Udacity AI学习笔记

机器学习
- logistics regression（LR）
- support vector machine（SVM）
- 神经网络（neural network）
- 核方法
- k均值聚类（k-means clustering）
- 分层聚类
- 实战项目
- - str.format() #格式化字符串
- 统计学知识
- 贝塞尔修正
- - 读取数据集（csv文件）
  - 转化为数组
- sklearn中训练模型
- - 逻辑回归
  - 神经网络
  - 决策树
  - SVM
  - - 核函数
- 训练模型
- 评估指标
- - 混淆矩阵
  - 准确率
  - 精度
  - 召回率
  - F1分数（harmonic mean）
  - ROC曲线
  - 评估回归模型的指标
- 模型选择
- - 错误类型
  - 交叉验证集
  - 学习曲线
  - 网格搜索（grid search）

机器学习

logistics regression（LR）

回归问题：返回连续的值
分类问题：返回状态
基于最大似然估计的方法，最小化模型分布和经验分部之间的交叉熵。损失函数为

远离分界线的点，权值越低。

support vector machine（SVM）

SVM基于最大化分类间隔的原理，只考虑分界线附近的支持向量，在支持向量外添加任何样本点，其权值为0，对分类结果无任何影响。损失函数为

神经网络（neural network）

将数据基于标签划分区域

核方法

将低维空间的非线性可分问题转化成高维空间的线性可分问题

k均值聚类（k-means clustering）

适用于已知数据集有k个集群的情况。

随机选择k个点作为聚类中心；
对数据集中的每个点，计算其到每个聚类中心的距离，并将其划分到对应聚类中心所属的集合；
对新得到的集合进行重新计算聚类中心（均值）；
若得到的聚类中心与之前的差值小于一定阈值或已收敛，则算法结束，否则重复2-3步骤。

分层聚类

已知数据集有N个点（即初始有N个集合），设定集合之间的相似度阈值为r。

计算每个点和其他点之间的距离，将距离最近的点划分为一个集合；
计算得到的新集合和其他集合之间的最近距离，将距离最近的两个集合划分为一个集合；
若两个集合之间的距离大于设定的阈值r，则算法结束，否则重复步骤2。

实战项目

Titanic生存率分析
pandas：Python data analysis library，数据结构有series，与numpy中的array相似，只允许存储相同的数据类型；time-series，以时间为索引的series；dataframe，二维的表格型数据结构，可以看成是series组成的字典，
将df按性别分组求身高的平均值
df.groupby(‘性别’)[‘身高’].mean()

dates=pd.date_range('20180310',periods=6)
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=['A','B','C','D'])#生成6行4列位置
print(df)#输出6行4列的表格
'''A         B         C         D
2018-03-10 -0.092889 -0.503172  0.692763 -1.261313
2018-03-11 -0.895628 -2.300249 -1.098069  0.468986
2018-03-12  0.084732 -1.275078  1.638007 -0.291145
2018-03-13 -0.561528  0.431088  0.430414  1.065939
2018-03-14  1.485434 -0.341404  0.267613 -1.493366
2018-03-15 -1.671474  0.110933  1.688264 -0.910599'''
print(df['B'])
'''
2018-03-10   -0.927291
2018-03-11   -0.406842
2018-03-12   -0.088316
2018-03-13   -1.631055
2018-03-14   -0.929926
2018-03-15   -0.010904
Freq: D, Name: B, dtype: float64'''#创建特定数据的DataFrame
df_1=pd.DataFrame({'A' : 1.,'B' : pd.Timestamp('20180310'),'C' : pd.Series(1,index=list(range(4)),dtype='float32'),'D' : np.array([3] * 4,dtype='int32'),'E' : pd.Categorical(["test","train","test","train"]),'F' : 'foo'})
print(df_1)
'''A          B    C  D      E    F
0  1.0 2018-03-10  1.0  3   test  foo
1  1.0 2018-03-10  1.0  3  train  foo
2  1.0 2018-03-10  1.0  3   test  foo
3  1.0 2018-03-10  1.0  3  train  foo
'''
print(df_1.dtypes)
'''
A           float64
B    datetime64[ns]
C           float32
D             int32
E          category
F            object
dtype: object
'''
print(df_1.index)#行的序号
#Int64Index([0, 1, 2, 3], dtype='int64')
print(df_1.columns)#列的序号名字
#Index(['A', 'B', 'C', 'D', 'E', 'F'], dtype='object')
print(df_1.values)#把每个值进行打印出来
'''
[[1.0 Timestamp('2018-03-10 00:00:00') 1.0 3 'test' 'foo'][1.0 Timestamp('2018-03-10 00:00:00') 1.0 3 'train' 'foo'][1.0 Timestamp('2018-03-10 00:00:00') 1.0 3 'test' 'foo'][1.0 Timestamp('2018-03-10 00:00:00') 1.0 3 'train' 'foo']]'''
print(df_1.describe())#数字总结
'''A    C    D
count  4.0  4.0  4.0
mean   1.0  1.0  3.0
std    0.0  0.0  0.0
min    1.0  1.0  3.0
25%    1.0  1.0  3.0
50%    1.0  1.0  3.0
75%    1.0  1.0  3.0
max    1.0  1.0  3.0
'''
print(df_1.T)#翻转数据
'''0                    1                    2  \
A                    1                    1                    1
B  2018-03-10 00:00:00  2018-03-10 00:00:00  2018-03-10 00:00:00
C                    1                    1                    1
D                    3                    3                    3
E                 test                train                 test
F                  foo                  foo                  foo   3
A                    1
B  2018-03-10 00:00:00
C                    1
D                    3
E                train
F                  foo
'''
print(df_1.sort_index(axis=1, ascending=False))#axis等于1按列进行排序 如ABCDEFG 然后ascending倒叙进行显示
'''F      E  D    C          B    A
0  foo   test  3  1.0 2018-03-10  1.0
1  foo  train  3  1.0 2018-03-10  1.0
2  foo   test  3  1.0 2018-03-10  1.0
3  foo  train  3  1.0 2018-03-10  1.0
'''
print(df_1.sort_values(by='E'))#按值进行排序
'''A          B    C  D      E    F
0  1.0 2018-03-10  1.0  3   test  foo
2  1.0 2018-03-10  1.0  3   test  foo
1  1.0 2018-03-10  1.0  3  train  foo
3  1.0 2018-03-10  1.0  3  train  foo
'''

display(data.head()) #默认展示数据的前五行
data.drop(‘Survived’，axis=1) #axis=1删除Survived这一列，axis=0，删除index即行
data.loc() #按照索引进行行列选择，包含索引的开头结尾，如[1:5],包含第五行

str.format() #格式化字符串

通过位置

In [1]: '{0},{1}'.format('kzc',18)
Out[1]: 'kzc,18'
In [2]: '{},{}'.format('kzc',18)
Out[2]: 'kzc,18'
In [3]: '{1},{0},{1}'.format('kzc',18)
Out[3]: '18,kzc,18'

通过参数

In [5]: '{name},{age}'.format(age=18,name='kzc')
Out[5]: 'kzc,18'

通过对象属性

class Person: def __init__(self,name,age): self.name,self.age = name,age def __str__(self): return 'This guy is {self.name},is {self.age} old'.format(self=self)

填充与对齐
填充常跟对齐一起使用
^、<、>分别是居中、左对齐、右对齐，后面带宽度
:号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

In [15]: '{:>8}'.format('189')
Out[15]: ' 189'
In [16]: '{:0>8}'.format('189')
Out[16]: '00000189'
In [17]: '{:a>8}'.format('189')
Out[17]: 'aaaaa189'

指定精度和类型，其中.2表示长度为2的精度，f表示float类型

In [44]: '{:.2f}'.format(321.33345)
Out[44]: '321.33'

统计学知识

四分位距法：
四分位数是将数列等分成四个部分的数，一个数列有三个四分位数，设下四分位数、中位数和上四分位数分别为Q1、Q2、Q3，则：Q1、Q2、Q3的位置可由下述公式确定：
Q1的位置 1(n+1)/4
Q2的位置 2 (n+1) /4
Q3的位置 3(n+1)/4
例如：某车间某月份的工人生产某产品的数量分别为13、13.5、13.8、13.9、14、14.6、14.8、15、15.2、15.4公斤，则三个四分位数的位置分别为：
Q1的位置 (n+1)/4 =(10+1)/4=2.75
Q2的位置(n+1) /2=(10+1)/2=5.5
Q3的位置3(n+1)/4=3(10+1)/4=8.25
即变量数列中的第2.75项、第5.5项、第8.25项工人的某种产品产量分别为下四分位数、中位数和上四分位数。即：
Q1=0.25×第二项+0.75×第三项=0.25×13.5+0.75×13.8=13.73(公斤)
Q2=0.5×第五项+0.5×第六项=0.5×14+0.5×14.6=14.3(公斤)
Q3=0.75×第八项+0.25×第九项=0.75×15+0.25×15.2=15.05(公斤)

异常值（outlier）：
常规判定法：异常值是指一组测定值中与平均值的偏差超过两倍标准差的测定值，与平均值的偏差超过三倍标准差的测定值，称为高度异常的异常值。
箱型判定法：上四分位和下四分位（Q1、Q3）的差值为IQR，上界U=Q1+1.5IQR，下界D=Q3-1.5IQR，超过上下界的为异常值。

贝塞尔修正

标准差，方差：分别是样本标准差，总体标准差，样本方差，总体方差

读取数据集（csv文件）

data = pandas.read_csv(‘file_name.csv’) #读取的格式为dataframe

转化为数组

x = np.array(data[[‘x1’,‘x2’]]) #存储为特征x，若希望获得多列，则需要输入列表
y = np.array(data[‘y’]) #存储为标签y

sklearn中训练模型

定义分类器，然后使分类器和数据拟合。classifier.fit(X,y)
以下是常用的分类器，以及必须导入的文件包

逻辑回归

from sklearn.linear_model import LogisticRegression
classifier = LogisticRegression()

神经网络

from sklearn.neural_network import MLPClassifier
classifier = MLPClassifier(）

决策树

from sklearn.tree import DecisionTreeClassifier
classifier = DecisionTreeClassifier()

SVM

from sklearn.svm import SVC
classifier = SVC()

核函数

K(x, y)：表示样本 x 和 y，添加多项式特征得到新的样本 x’、y’，K(x, y) 就是返回新的样本经过计算得到的值；在 SVM 类型的算法 SVC() 中，K(x, y) 返回点乘：x’ . y’ 得到的值；

多项式特征的基本原理：依靠升维使得原本线性不可分的数据线性可分；
升维的意义：使得原本线性不可分的数据线性可分

高斯核：唯一超参数γ，手动调参的关键

目的是对样本数量少，特征多的数据集进行降维，找到更利于线性分类的空间

高斯核函数，也称为 RBF 核（Radial Basis Function Kernel），也称为径向基函数；
高斯核函数的本质：将每一个样本点映射到一个无穷维的特征空间；
无穷维：将 mn 的数据集，映射为 mm 的数据集，m 表示样本个数，n 表示原始样本特征种类，样本个数是无穷的，因此，得到的新的数据集的样本也是无穷维的；
高斯核升维的本质，使得线性不可分的数据线性可分；

训练模型

训练集测试集的划分
scikit-learn
from sklearn.model_selection import train_test_split
X_train,X_test,y_train,y_test = train_test_split(X ,y, test_size = 0.25,stratify=y)
stratify:使训练集和测试集中y的比例与原数据集相同如y取0,1=2:8

# Import statements
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score
import pandas as pd
import numpy as np
from sklearn.cross_validation import train_test_split
#Import the train test split
# http://scikit-learn.org/0.16/modules/generated/sklearn.cross_validation.train_test_split.html# Read in the data.
data = np.asarray(pd.read_csv('data.csv', header=None))
# Assign the features to the variable X, and the labels to the variable y.
X = data[:,0:2]
y = data[:,2]# Use train test split to split your data
# Use a test size of 25% and a random state of 42
X_train, X_test, y_train, y_test = train_test_split(X,y,test_size = 0.25,random_state =42)# Instantiate your decision tree model
model = DecisionTreeClassifier()# TODO: Fit the model to the training data.
model.fit(X_train,y_train)
# TODO: Make predictions on the test data
y_pred = model.predict(X_test)# TODO: Calculate the accuracy and assign it to the variable acc on the test data.
acc = accuracy_score(y_test,y_pred)

读取csv文件
添加到特征和标签变量。转化为数组
划分训练集和测试集
选择训练模型 #model
用训练模型拟合训练集 #model.fit(X_train,y_train)
预测测试集的输出 #model.predict(X_test)
验证预测输出的准确性 accuracy_score(y_test,y_pred)

评估指标

混淆矩阵

真阳性：true positive
真阴性：true negative
假阳性：false positive
假阴性：false negative

准确率

accuracy = true / all

精度

即预测为正确的样本中实际正确的样本所占比例。

召回率

recall = true positives / true positives + false negatives
即实际正确的样本中你预测为正确的样本所占比例。

F1分数（harmonic mean）

ROC曲线

横坐标为FPR，纵坐标为TPR，与x轴围成的面积AUC为判定标准

评估回归模型的指标

平均绝对误差（mean absolute error）：各点到拟合曲线的绝对距离（y的差值）的平均值
均方误差（mean squared error）：各点到拟合曲线的距离平方的平均值
R2 score：（0,1），越接近1，model越好，即模型与直接预测每个值为平均值的模型的差距越大，说明模型效果越好。

模型选择

错误类型

underfitting：we get errors due to high bias,过度简化问题，
overfitting:we get errors due to high variance,过度复杂化问题

交叉验证集

cross validation set: 用来决定模型，例如多项式的次数

k-fold cross validation：将交叉验证集数据划分成k份，训练模型k次，每次轮流取不同的几份数据作为测试集，剩余数据作为训练集，然后对得到的结果取平均，得到最终模型

from sklearn.model_selection import KFold
kf = KFold(data_size,teseting data_size,shuffle = true)

学习曲线

high bias：欠拟合，训练误差和验证误差收敛在误差较大的地方；
high variance：过拟合，训练误差和验证误差相差较大

网格搜索（grid search）

目的：给网络选择最佳参数，例如SVM中 kernal和C，以sklearn为例

导入GridSearchCV

from sklearn.model_selection import GridSearchCV

选择参数,形成一个列表

parameters = {'kernals':['poly',rbf'], 'c':[0.1, 1, 10]}

选择一个评分机制（scorer）为候选模型打分

from sklearn.metrics import make_scorer
from sklearn.metrics import f1_score
scorer =  make_scorer(f1_score)

使用参数和评分机制创建一个GridSearch对象。使用此对象fit the data。

grid_obj = GridSearchCV(clf, parameters, scoring = scorer)
grid_fit = grid_obj.fit(X,y)

获得最佳估算器

best_clf = grid_fit.best_estimator_

Udacity 机器学习笔记1相关推荐

一份520页的机器学习笔记！附下载链接
点击上方"视学算法",选择"星标"公众号第一时间获取价值内容近日,来自SAP(全球第一大商业软件公司)的梁劲(Jim Liang)公开了自己所写的一份 52 ...
700 页的机器学习笔记火了！完整版开放下载
点上方蓝字计算机视觉联盟获取更多干货在右上方 ··· 设为星标 ★,与你不见不散作者梁劲(Jim Liang),来自SAP(全球第一大商业软件公司). 书籍特点条理清晰 ...
机器学习笔记十四：随机森林
在上一篇机器学习笔记十三:Ensemble思想(上)中,简要的提了一下集成学习的原理和两种主要的集成学习形式. 而在这部分要讲的随机森林,就算是其中属于bagging思路的一种学习方法.为了篇幅,b ...
机器学习笔记七：损失函数与风险函数
一.损失函数回顾之前讲过的线性回归模型,我们为了要学习参数使得得到的直线更好的拟合数据,我们使用了一个函数这个函数就是比较模型得到的结果和"真实值"之间的"差距&qu ...
吴恩达机器学习笔记55-异常检测算法的特征选择（Choosing What Features to Use of Anomaly Detection）
吴恩达机器学习笔记55-异常检测算法的特征选择(Choosing What Features to Use of Anomaly Detection) 对于异常检测算法,使用特征是至关重要的,下面谈谈 ...
Python机器学习笔记：sklearn库的学习
自2007年发布以来,scikit-learn已经成为Python重要的机器学习库了,scikit-learn简称sklearn,支持包括分类,回归,降维和聚类四大机器学习算法.还包括了特征提取,数据 ...
神经网络与机器学习笔记—LMS（最小均方算法）和学习率退火
神经网络与机器学习笔记-LMS(最小均方算法)和学习率退火 LMS算法和Rosenblatt感知器算法非常想,唯独就是去掉了神经元的压制函数,Rosenblatt用的Sgn压制函数,LMS不需要压制 ...
神经网络与机器学习笔记—基本知识点（下）
神经网络与机器学习笔记-基本知识点(下) 0.1 网络结构: 神经网络中神经元的构造方式与用于训练网络的学习算法有着密切的联系,有三种基本的网络结构: 0.7 知识表示 ...
神经网络与机器学习笔记—基本知识点（上）
神经网络与机器学习笔记-基本知识点(上) 0.1 什么是神经网络: 神经网络是由简单处理单元构成的大规模并行分布处理器,天然具有存储经验知识和使之可用的特性.神经网络在两个方面与大脑类似. 神经网络 ...

Udacity 机器学习笔记1