数据科学入门

《数据科学入门》学习笔记

1. python

• sorted(notonly_list,key=lambda: xxx,reverse=True), a.sort()是就地修改。同理，max，min等函数也可以采用sorted中的方法，用key=lambda或函数；
• reduce(func,list)：传入的函数func必须接收两个参数，reduce()对list的每个元素反复调用函数func，并返回最终结果值；
• partial(func,arg)：返回一个函数，这个是func()函数中的部分参数由arg指定后的函数；
• map(func,list)：对list中的每个元素都调用func()，但在Python2.7版本中才返回结果列表，Python3.6版本返回map对象；
• filter(func,list)：func函数返回bool值，filter函数返回值为list中使得func()返回True的元素的列表；
• a=b if A else c；
• zip：for i,j in zip(x,y)，zip(*x)解压；
• enumerate：for num,xi in enumerate(x)；
• collections.Counter：传入一个列表来初始化，自动计数，有most_common()方法；
• collections.defaultdict：不用管键值是否存在，可以直接引用；
• __future__.division：在Python2.7中，5/2默认为整除，而import之后，就可以采用3.6中的除法，此时要用整除只能5//2；
• random.choice()：从列表中随机选择一个元素；random.random()：0~1之间均匀分布的随机数；random.randrange()：从对应range()函数随机选择一个元素；random.sample(list,n)：从列表中不放回取样n个；random.shuffle()：随机就地重排列表中的元素；
• math.erf：normal_cdf=(1+math.erf((x-mu)/math.sqrt(2)/sigma))/2；
• glob：glob.glob(path)会返回每一个与通配路径所匹配的文件名：

import glob
path=r'C:\spam\*\*'
for fn in glob.glob(path):
    dosomething()

• startswith：
• with open(”) as reader：在代码段结束后，自动close(”)；
• Python会省略方括号和圆括号中的空白，否则需要用\来表示在下一行续写；
• IPython函数%paste，可以正确复制剪切板上的内容，包括空白；
• 在函数定义内再定义函数
• Python风格互换变量：x,y=y,x；
• dicts.get(key,None),dicts.keys(),dicts.values(),dicts.items()，dicts.iteritems()；
• Python真假值
• __repr__
• Python图像加载：

path_to_png_file=r'C:...'
import matplotlib.image as mpimg
img=mpimg.imread(path_to_png_file)

• 创建一元组，需要在末尾加一个逗号，否则Python会把括号当成单纯的括号：([10,20],)

2. 概率统计

• 辛普森悖论：
  即在某个条件下的两组数据，分别讨论时都会满足某种性质，可是一旦合并考虑，却可能导致相反的结论。为了避免辛普森悖论的出现，就需要斟酌各分组的权重，并乘以一定的系数去消除以分组数据基数差异而造成的影响；
• 协方差：covariance=sum((x-mean(x))(y-mean(y)))/(n-1)；
• 相关性：correlation=covariance/stdev(x)/stdev(y)；
• 贝叶斯定理；
• 分布：正态分布，伯努利分布，二项分布，泊松分布；
• 假设推断：显著性、势、单边检验、p值、置信区间、p-hacking；

3. 梯度下降

• 梯度下降、随机梯度下降

4. 获取数据

• 管道字符：“|”运算符表示使用左边命令的输出作为右边命令的输入。如在Linux中：

cat SomeFile.txt | python egrep.py “[0-9]” | python line_count.py

• sys.stdin:

import sys
# sys.argv是命令行参数的列表
# sys.argv[0]是程序自己的名字
# sys.argv[1]参数
a=[]
for line in sys.stdin:
    # a=[[],...,[]]
    a.append(line.strip().split())

• open(”)
• csv.reader():

import csv
with open('','rb') as f:
    reader=csv.reader(f,delimiter='\t')
    #reader=csv.DictReader(f,delimiter=':')
    for row in reader:
        dosomething()

• pandas.read_csv(), pandas.read_table；
• requests、bs4.BeautifulSoap、html5lib网络爬取解析；

5. 数据工作

• 相关矩阵：矩阵中第i行第j列的元素表示第i维与第j维数据的相关性；
• dateutil.parser.parse：解析时间；
• 聚类中的距离，需要提前把各个维度的数据rescale，使均值为0，标准差为1的；
• 主成分分析（PCA），从数据中提取一个或多个维度，用于降维。找出一个单位向量，数据在该方向上投影的模方即。。。。。。可以通过清除噪声维度和整合高度相关的维度来清理数据；在提取数据的低维代表后，就可以运用一系列不太适用于高维数据的技术；
• 相关Python库：

6. 机器学习

• 训练集、验证集、测试集
• 混淆矩阵（confusion matrix）：真阳性tp、假阳性fp、假阴性fn、真阴性tn
• 查准率（precision）：p=tp/(tp+fp)
• 查全率、召回率（recall）：r=tp/(tp+fn)
• F1得分：2*p*r/(p+r)
• 偏倚和方差：用来度量不同的训练数据集上多次重复训练模型的情况。高偏倚意味着任何可能的训练集都会造成大量的错误，但任何两个随机选择的训练集会给出相似的模型。高偏倚和低方差对应着欠拟合，低偏倚和高方差对应着过拟合。如果高偏倚，需要尝试加入更多的特征。如果高方差，需要移除特征或者获得更多的数据。

7. KNN算法

• K近邻法，需要某种距离的概念，以及一种彼此接近的点具有相似性质的假设；
• 并列情况：随机选择其中一个获胜者；根据距离加权投票并选择加权的获胜者；减少K值直到找到唯一的获胜者；
• 维数灾难：高维空间内的点根本不会表现得彼此近邻（当有许多维度时，看上去最邻近的两个点的距离并不比点和点的平均距离小），所以需要降维；

8. 朴素贝叶斯

• 避免概率相乘发生下溢，利用对数相加再取指数来代替；
• 伪计数k（平滑技术）：为避免概率分子为0（可能训练集不存在，而测试集存在），对分子加k，分母加2k；
• tokenize(message)：标记赋予器，提取单词集合；
• count_words(training_set)：计算单词出现在已做标记的邮件训练集中的次数；
• word_probabilities(counts,total_spams,total_non_spams,k=0.5)：利用平滑技术将单词技术转换为估计概率；
• spam_probability(word_probs,message)：利用训练集中单词的概率，计算message邮件是垃圾邮件的概率：

def spam_probability(word_probs, message):
    message_words = tokenize(message)
    log_prob_if_spam = log_prob_if_not_spam = 0.0
    for word, prob_if_spam, prob_if_not_spam in word_probs:
        # 如果word出现在了邮件中，则增加看见它的对数概率
        if word in message_words:
            log_prob_if_spam += math.log(prob_if_spam)
            log_prob_if_not_spam += math.log(prob_if_not_spam)
        # 如果word没有出现在邮件中，则增加看不到它的对数概率
        else:
            log_prob_if_spam += math.log(1.0 - prob_if_spam)
            log_prob_if_not_spam += math.log(1.0 - prob_if_not_spam)
    # p1*p2*...*pi*(1-pi+1)*...(1-pn)
    # 即单词组合为message中的情况时，是垃圾邮件的概率
    prob_if_spam = math.exp(log_prob_if_spam)
    prob_if_not_spam = math.exp(log_prob_if_not_spam)
    # 相当于归一化
    return prob_if_spam / (prob_if_spam + prob_if_not_spam)

• 改善模型： 考察邮件内容（现在只考虑了主题）；修改分类器（如果某单词出现次数小于min_count就不考虑）；在标记赋予器中使用词干分析器（stemmer）来找出单词对应的同义词，现成的Porter Stemmer；创建类似contain_number这样的伪标记，并修改标记赋予器；
• 相关Python库：scikit-learn库中的BernoulliNB模型；

9. 回归分析

9.1 简单线性回归

• 最小二乘法：y=beta*x+alpha:

beta=correlation(x,y)*standard_deviation(y)/standard_deviation(x)
alpha=mean(y)-beta*mean(x)

• 决定系数（R平方）：

1.0-(sum_of_squared_errors(alpha,beta,x,y)/total_sum_of_squares(y))

• 可以利用梯度下降来求参数
• 通常假设回归误差是呈正态分布的，其均值为0，已知标准偏差为sigma，可以通过最大似然估计来求解最小二乘法的参数表达式；

9.2 多重回归分析

• 最小二乘估计的假设：x的各个列线性无关；x的各列与误差无关；

• 利用梯度下降求解参数，而不是手动求解；

• Bootstrap：相继地，独立地自原始样本中放回抽样很多个Bootstrap样本，利用这些样本对总体进行统计推断，这种方法称为非参数Bootstrap方法，又称自助法。

9.3 逻辑回归

10. 决策树

• 决策树分为分类决策树和回归决策树，包含决策节点和叶节点；
• 熵：H(S)=-p1log2p1-…-pnlog2pn，pi表示ci类别中的数据所占的比例；H=q1H(S1)+…+qmH(Sm),分割之熵；
• 信息熵，信息增益，ID3；
• 算法思路（“贪婪算法”）：如果所有数据都有相同的标签，那么创建一个预测最终结果即为该标签所示的叶节点，然后停止；如果属性列表是空的（即已经没有更多的问题可以问了），就创建一个预测结果为最常见的标签的叶节点，然后停止；否则，尝试用每个属性对数据进行划分；选择具有最低划分熵的那次划分的结果；根据选定的属性添加一个决策节点；针对划分得到的每个子集，利用剩余属性重复上述过程；
• 要对某个属性有缺失值，就把预测结果设为最常见的标签；
• 决策树的表示：

('level',
    {'Junior':('phd',
                    {'no':True,'yes':False}),
     'Mid':True,
     'Senior':('tweets',
                    {'no':False,'yes':True})})

• 随机森林：
• 相关Python库：scikit-learn库提供了许多决策树模型以及ensemble模块，其包含了RandomForestClassifier以及其他集成方法；

11. 神经网络

• 感知器perception：具有n个二进制输入的单个神经元组成的神经网络，首先会对输入值加权求和（dot(weights,x)+bias），如果加权和大于等于0，它就会被激活；
• 前馈神经网络：包括一个输入层，一个或多个隐藏层，一个输出层；输入：(x1,…xn,1)，权重(w1,…wn,bias)，对输入与权重之积做平滑处理（如sigmoid）；
• sigmoid(t)=1/(1+math.exp(-t))；
• 神经网络的表示：[层列表[神经元列表[权重列表]]]
• 反向传播（BP）神经网络：随机值初始化权重向量；在输入向量上运行feed_forward，从而得到网络所有神经元的输出；每个输出神经元都会得到一个误差（目标值与输出值之差）；计算作为神经元权重的误差的梯度，然后根据误差降低最快的方向调整权重；将这些输出误差反向传播给隐藏层以便计算相应误差；计算这些误差的梯度，并利用同样的方式调整隐藏层的权重：

def backpropagate(network, input_vector, target):

    hidden_outputs, outputs = feed_forward(network, input_vector)

    # the output * (1 - output) is from the derivative of sigmoid
    output_deltas = [output * (1 - output) * (output - target[i])
                     for i, output in enumerate(outputs)]

    # adjust weights for output layer (network[-1])
    for i, output_neuron in enumerate(network[-1]):
        for j, hidden_output in enumerate(hidden_outputs + [1]):
            output_neuron[j] -= output_deltas[i] * hidden_output

    # back-propagate errors to hidden layer
    hidden_deltas = [hidden_output * (1 - hidden_output) *
                      dot(output_deltas, [n[i] for n in network[-1]])
                     for i, hidden_output in enumerate(hidden_outputs)]

    # adjust weights for hidden layer (network[0])
    for i, hidden_neuron in enumerate(network[0]):
        for j, input in enumerate(input_vector + [1]):
            hidden_neuron[j] -= hidden_deltas[i] * input

• 相关Python库：PyBrain，Pylearn2

12. 聚类分析

• 聚类分析是无监督学习方法，通常没有“正确”的聚类，很难说哪种方案肯定比其他方案要好，但是，对于每一种方案而言，都可以按照自己的“优良聚类”标准不断进行优化；
• K-均值算法（k-means）：首先选出聚类K的数目，然后把输入划分为集合S1,…,Sk，并使得每个数据到其所在聚类的均值（中心对象）的距离的平方之和最小化；
• k-means迭代算法：首先从d维空间中随机选择k个数据作为初始聚类的均值；计算每个数据点到这些聚类的均值的距离，然后把各个数据点分配给离它最近的那个聚类；如果所有数据点都不再被重新分配，则停止并保持现有聚类；如果仍有数据点被重新分配，则重新计算均值，并返回第二步；
• k值选择：以误差（即每个数据点到所在聚类的中心的距离）的平方和作为k的函数，画出该函数的图像，并在其“弯曲”的地方寻找合适的取值；
• 自下而上的分层聚类：利用每个输入构成一个聚类；只要还剩余多个聚类，就找出最近的两个，并将它们合二为一；
• 聚类间的距离可以是两个聚类元素间的最小、平均、最大距离，不同的距离得到的聚类不太一样；
• 借助合并次序踪迹来跟踪合并的顺序，数字越小，表示合并的次序越靠后，merged=(1,[leaf1,leaf2])；
• 相关Python库：scikit-learn库中的sklearn.cluster模块，包括k-means和ward分级聚类算法；scipy模块有scipy.cluster.vq（k-means）和scipy.cluster.hierarchy（多种层次聚类算法）

13. 自然语言处理

14. 网络分析

• 连通图：每2个点之间都至少有一条路径相连；
• 度中心性（degree centrality）；
• 中介中心度（betweenness centrality），它可以用来找出经常位于其他节点对之间的最短路径中的人，可以通过累加节点j和节点k之间经过节点i的最短路径所占比例，以及节点j和节点k之外所有的节点对中相应的比例来求出；可以通过广度优先搜索BFS得以实现；
• 疏远度（farness），该用户到所有其他用户的最短路径的长度总和；
• 接近中心度（closeness centrality），疏远度的倒数；
• 特征向量中心度，每个用户对应一个数值，而每个用户的值就是他的相邻值之和的固定倍数；特征向量中心度较高的用户，不仅会拥有较多的连接，而且还倾向于连接到具有较高中心度的那些人；
• PageRank，网络中的PageRank的总分数为1；最初，网络中各个节点值为1/n；在每一步中，每个节点的PageRank很大一部分将被均匀分布到其外部链接中；在每个步骤中，每个节点的PageRank的其余部分被均匀分布到所有节点上：

def page_rank(users, damping = 0.85, num_iters = 100):

    # initially distribute PageRank evenly
    num_users = len(users)
    pr = { user["id"] : 1 / num_users for user in users }

    # this is the small fraction of PageRank
    # that each node gets each iteration
    base_pr = (1 - damping) / num_users

    for __ in range(num_iters):
        next_pr = { user["id"] : base_pr for user in users }
        for user in users:
            # distribute PageRank to outgoing links
            links_pr = pr[user["id"]] * damping
            for endorsee in user["endorses"]:
                next_pr[endorsee["id"]] += links_pr / len(user["endorses"])

        pr = next_pr

    return pr

• 相关Python库：NetworkX

15. 推荐系统

• 余弦相似度：dot(v,w)/math.sqrt(dot(v,v)*dot(w,w))；
• 基于用户的协同过滤方法：向量v是某一用户对于所有兴趣的表示，感兴趣则v[i]=1，否则v[i]=0；将该用户的v与所有其他用户做余弦相似度，得到相似用户列表；对某一用户的所有相似用户的兴趣，以相似度为权加和，排除自身兴趣后按值大小进行推荐；（需要注意维数灾难）
• 基于物品的协同过滤方法：向量v是某一兴趣对所有感兴趣用户的表示，用户i对其感兴趣则v[i]=1，否则v[i]=0；将该兴趣的v与所有其他兴趣做余弦相似度，得到相似兴趣列表；对某一用户的所有兴趣的相似兴趣列表，按照相似度为权加和，排除自身兴趣后按值大小进行推荐；
• 相关Python库：Crab是一个打造推荐系统的Python框架；

16. 数据库与SQL ##

• CREATE TABLE：

CREATE TABLE users(
    user_id INT NOT NULL,
    name VARCHAR(200),
    num_friends INT);

• INSERT：

INSERT INTO users (user_id, name, num_friends) VALUES (0, 'Hero', 0);
INSERT INTO users VALUES (0, 'Hero', 0);

• UPDATE：

UPDATE users
SET num_friends=3
WHERE user_id=1;

• DELETE

DELETE FROM users WHERE user_id=1;

• SELECT

SELECT user_id FROM users WHERE name='Hero';

• GROUP BY

SELECT LENGTH(name) AS name_length,
MIN(user_id) AS min_user_id,
COUNT(*) AS num_users
FROM users
GROUP BY LENGTH(name);

• ORDER BY

SELECT * FROM users
ORDER BY name DESC
LIMIT 2;

• JOIN

SELECT users.name
FROM users
JOIN user_interests
ON users.user_id=user_interests.user_id
WHERE user_interests.interest='SQL';

• 索引：数据库中的每个表都有一个或多个索引，可以通过关键词列快速查找行，可以有效并表，以及可以对行或者行集合施加唯一约束；
• 原子性、事务等

17. MapReduce