这是一个MIT课程“Introductionto Computational Thinking and Data Science”的学习笔记。
学习该课程的前提条件是:能够使用 Python 进行面向对象编程(最好是 Python3.5)
熟悉计算复杂性理论的概念
熟悉一些简单的算法
前几次课的主题是计算模型(computational models):我们如何通过计算来理解现实世界?
什么是模型?它就像是一个设备帮助我们理解过去发生的事情(可以这么说:建一个模型来解释我们看见的现象)或者预测未来;例如气候模型,我们可以建一个气候模型来解释气候规律并预测未来的气候。
我们将学习三种模型:优化模型(optimization models)
统计模型(statisticalmodels)
仿真模型(simulationmodels)
Optimization Models 的概念:
优化模型其实就是一个求最大值或者最小值的目标函数;
举个例子:我想找出一个从纽约到波士顿的旅程时间最短的交通方式(汽车、飞机或者火车),这时我的目标函数就是花在交通上时间。
然后我们通常会给目标函数一些限制(限制也可以为空);
接上上一个例子,时间最短的交通方式毫无疑问是飞机,但是我只有一百美元,所以飞机这个选项只能被移除。
具体的优化问题——背包问题(knapsack problem)
背包问题经常用在窃贼偷东西的情境,窃贼的背包只能装下有限的东西,如何取舍才能装走最有价值的东西就是一个目标函数。
他有两种情况: 0/1 背包问题(举个例子就是,我拿走一整个金条或者不拿)
部分背包问题 (这种情况就是把金条磨成粉,我可以拿一部分的金条)
部分背包问题有点无聊,你可以全部装最有价值的那个东西直到背包装满,如果最值钱的装完了背包还有空间,那就可以装第二值钱的;0/1背包问题会复杂得多,因为你每一次选择都会影响你未来的选择。
接下来看一个具体的例子(0/1背包问题)
假设允许你吃1500卡路里的食物,有一些选择:沙拉、冰淇淋、意面、三明治等,选择其中一些食物并且加起来不能超过1500ka,如果你已经吃了1480ka,那你不能再吃其他的了。所以你每做一个选择都会影响可能的结果,这就是贪心算法(greedy algorithm),他不会给你最好的答案。
来看一下它的数据结构:每一项都有两个值<value, weight>
背包能容纳的项的总量(weight)不能超过w
一个长度为n的矢量L,其中每个元素都代表一项
一个长度为n的矢量V,每个元素代表是否选取这一项,V[i] = 1,选取i项,V[i] = 0,则不选取。
我们的目的是要找到一个V能够使得 value 最大:
同时要满足最大限制:
最暴力的方法是列举出所有的组合并一一计算其value值,然后找出最大的,这时候的算法复杂度是指数阶的,耗时巨大;我们选用贪心算法,只要背包没有满,每次都选择最好的那一项,最好这个指标根据算法设计者而定,可以是 value 值最大的,也可以是最便宜的等等。
现在我们有一个菜单
Food | wine | beer | pizza | burger | fries | coke | apple | donut |
Value | 89 | 90 | 30 | 50 | 90 | 79 | 90 | 10 |
calories | 123 | 154 | 258 | 354 | 365 | 150 | 95 | 195 |
现在我们用之前提到的数据结构来编写一个 Food 类(包括 getValue、getCost、density 方法):
给每一个 food 一个 name、value 和 calories 初始化每个对象
class Food(object):
def __init__(self, n, v, w):
self.name = n
self.value = v
self.calories = w
def getValue(self):
return self.value
def getCost(self):
return self.calories
def density(self):
return self.getValue()/self.getCost()
def __str__(self):
return self.name + ': <' + str(self.value)\
+ ', ' + str(self.calories) + '>'
编写一个 Menu List:
def buildMenu(names, values, calories):
"""names, values, calories lists of same length.
name a list of strings
values and calories lists of numbers
returns list of Foods"""
menu = []
for i in range(len(values)):
menu.append(Food(names[i], values[i],
calories[i]))
return menu
接下来是贪心算法函数,其中的传入的一个参数 keyfunction 使得该算法具有一定的灵活度,这个函数的作用是对应你所传入的一串对象的某个数值,然后你可以通过 sorted 函数根据这个数值进行排序,你可以选择任何一个你想要排序的指标,本文在 testGreedy 函数中使用了 value 属性、calories 的倒数(lambda构造的就是calories的倒数)以及 density 属性三个指标进行测试:
def greedy(items, maxCost, keyFunction):
"""Assumes items a list, maxCost >= 0,
keyFunction maps elements of items to numbers"""
itemsCopy = sorted(items, key = keyFunction,
reverse = True)
result = []
totalValue, totalCost = 0.0, 0.0
for i in range(len(itemsCopy)):
if (totalCost+itemsCopy[i].getCost()) <= maxCost:
result.append(itemsCopy[i])
totalCost += itemsCopy[i].getCost()
totalValue += itemsCopy[i].getValue()
return (result, totalValue)
def testGreedys(foods, maxUnits):
print('Use greedy by value to allocate', maxUnits,
'calories')
testGreedy(foods, maxUnits, Food.getValue)
print('\nUse greedy by cost to allocate', maxUnits,
'calories')
testGreedy(foods, maxUnits,
lambda x: 1/Food.getCost(x))
print('\nUse greedy by density to allocate', maxUnits,
'calories')
testGreedy(foods, maxUnits, Food.density)
现在我们来看一下这个算法的效率:
首先是 sorted 函数,Python 使用了 timsort 排序算法,它的复杂度和合并算法一样都是 nlogn ;
接下来是一个循环,循环次数是食物列表的长度,复杂度为 n ;
所以该算法的复杂度为 nlogn + n ,也就是 nlogn ,还是挺高效的。
最后我们来运行一下:
names = ['wine', 'beer', 'pizza', 'burger', 'fries',
'cola', 'apple', 'donut', 'cake']
values = [89,90,95,100,90,79,50,10]
calories = [123,154,258,354,365,150,95,195]
foods = buildMenu(names, values, calories)
testGreedys(foods, 1000)
会发现三个不同的测试指标最后得到的结果都不同,可以看到贪心算法不会给出唯一的答案,而是每一步都根据当前情况选出最合适的项