机器学习算法课程定位、目标
定位
课程以算法、案例为驱动的学习，伴随浅显易懂的数学知识
作为人工智能领域(数据挖掘/机器学习方向)的提升课程，掌握更深更有效的解决问题技能
目标
应用Scikit-learn实现数据集的特征工程
掌握机器学习常见算法原理
应用Scikit-learn实现机器学习算法的应用，结合场景解决实际问题
机器学习概述
了解机器学习定义以及应用场景
什么是机器学习
1、 背景介绍
人工智能范围

2、定义
机器学习是从数据中自动分析获得规律（模型），并利用规律对未知数据进行预测

3、解释
alphago

广告推荐

机器学习定义
为什么需要机器学习
解放生产力：
智能客服：不知疲倦24小时小时作业
量化投资：避免更多的编写策略、交易人员
医疗：帮助医生辅助医疗
机器学习应用场景
机器学习的应用场景非常多，可以说渗透到了各个行业领域当中。医疗、航空、教育、物流、电商等等领域的各种场景。

用在挖掘、预测领域：

应用场景：店铺销量预测、量化投资、广告推荐、企业客户分类、SQL语句安全检测分类…
传统预测

量化投资

用在图像领域：

应用场景：街道交通标志检测、图片商品识别检测等等
用在自然语言处理领域：

应用场景：文本分类、情感分析、自动聊天、文本检测等等
当前重要的是掌握一些机器学习算法等技巧，从某个业务领域切入解决问题。
学习框架和资料介绍
1、学习框架
框架

2、书籍资料
学习书籍

3、提深内功（但不是必须）
深度学习
特征工程
了解特征工程在机器学习当中的重要性
应用sklearn实现特征预处理
应用sklearn实现特征抽取
应用sklearn实现特征选择
应用PCA实现特征的降维
说明机器学习算法监督学习与无监督学习的区别
说明监督学习中的分类、回归特点
说明机器学习算法目标值的两种数据类型
说明机器学习(数据挖掘)的开发流程
特征工程介绍
学习目标
目标
说出机器学习的训练数据集结构组成
了解特征工程在机器学习当中的重要性
知道特征工程的分类
应用
无
1、什么是特征工程
特征工程是使用专业背景知识和技巧处理数据，使得特征能在机器学习算法上发挥更好的作用的过程。

意义：会直接影响机器学习的效果
2、为什么需要特征工程(Feature Engineering)
机器学习领域的大神Andrew Ng(吴恩达)老师说“Coming up with features is difficult, time-consuming, requires expert knowledge. “Applied machine learning” is basically feature engineering. ”

注：业界广泛流传：数据和特征决定了机器学习的上限，而模型和算法只是逼近这个上限而已。

我们从一个简单的例子理解一下：

猫

猫2

问题：从历史数据当中获得规律？这些历史数据是怎么的格式？
3、数据集的构成
3.1 可用数据集
可用数据集

Kaggle:https://www.kaggle.com/datasets

UCI:http://archive.ics.uci.edu/ml/index.php

3.2 数据集构成
结构：特征值+目标值
数据集结构

注：有些数据集可以没有目标值，对于每一行数据我们可以称之为样本。

为什么需要这样的结构？后面结合机器学习算法去解释

特征工程的位置与Pandas比较？
特征工程过程

pandas:一个数据读取非常方便以及基本的处理格式的工具
sklearn:对于特征的处理提供了强大的接口
特征工程包含内容
特征抽取
特征预处理
特征降维
4、特征工程所需工具
4.1Scikit-learn工具介绍
scikitlearn

Python语言的机器学习工具
Scikit-learn包括许多知名的机器学习算法的实现
Scikit-learn文档完善，容易上手，丰富的API
目前稳定版本0.18
4.2 安装
pip3 install Scikit-learn==0.18
安装好之后可以通过以下命令查看是否安装成功

import sklearn
注：安装scikit-learn需要Numpy,Pandas等库

4.3 Scikit-learn包含的内容
scikitlearn接口

分类、聚类、回归
特征工程
模型选择、调优
特征提取
学习目标
目标
应用DictVectorizer实现对类别特征进行数值化、离散化
应用CountVectorizer实现对文本特征进行数值化
应用TfidfVectorizer实现对文本特征进行数值化
说出两种文本特征提取的方式区别
应用
无
什么是特征提取呢？

文本特征提取图

字典特征提取图

演示案例：特征提取例子演示

1、特征提取
1.1包括将任意数据（如文本或图像）转换为可用于机器学习的数字特征
注：特征值化是为了计算机更好的去理解数据

字典特征提取(特征离散化)
文本特征提取
图像特征提取（深度学习将介绍）
1.2 特征提取API
sklearn.feature_extraction
2、字典特征提取
作用：对字典数据进行特征值化

sklearn.feature_extraction.DictVectorizer(sparse=True,…)
DictVectorizer.fit_transform(X) X:字典或者包含字典的迭代器返回值：返回sparse矩阵
DictVectorizer.inverse_transform(X) X:array数组或者sparse矩阵 返回值:转换之前数据格式
DictVectorizer.get_feature_names() 返回类别名称
2.1应用
我们对以下数据进行特征提取

[{‘city’: ‘北京’,‘temperature’:100}
{‘city’: ‘上海’,‘temperature’:60}
{‘city’: ‘深圳’,‘temperature’:30}]
dictvec结果

2.2流程分析
实例化类DictVectorizer
调用fit_transform方法输入数据并转换（注意返回格式）
def dict_vec():

# 实例化dict
dict = DictVectorizer(sparse=False)
# diaoyong fit_transform

data = dict.fit_transform([{'city': '北京','temperature':100},{'city': '上海','temperature':60},{'city': '深圳','temperature':30}])

# 打印每一个列的名称
print(dict.get_feature_names())
print(data)

return None

注意观察没有加上sparse=False参数的结果

sparse矩阵

这个结果并不是我们想要看到的，所以加上参数,得到想要的结果

我们会议之前在做pandas的离散化时候，也实现了类似的效果，那在这里我们把这个处理数据的技巧用专业的称呼"one-hot"编码，之前我们也解释过为什么需要这种离散化的了，是分析数据的一种手段。比如下面例子：

onehot

onehot1

2.3 总结
对于特征当中存在类别信息的我们都会做one-hot编码处理

3、文本特征提取
作用：对文本数据进行特征值化

sklearn.feature_extraction.text.CountVectorizer(stop_words=[])

返回词频矩阵
CountVectorizer.fit_transform(X) X:文本或者包含文本字符串的可迭代对象 返回值：返回sparse矩阵
CountVectorizer.inverse_transform(X) X:array数组或者sparse矩阵 返回值:转换之前数据格
CountVectorizer.get_feature_names() 返回值:单词列表
sklearn.feature_extraction.text.TfidfVectorizer
3.1应用
我们对以下数据进行特征提取

[“life is short,i like python”,
“life is too long,i dislike python”]
countvec结果

3.2 流程分析
实例化类CountVectorizer
调用fit_transform方法输入数据并转换 （注意返回格式，利用toarray()进行sparse矩阵转换array数组）
def countvec():

# 实例化conunt
count = CountVectorizer()

data = count.fit_transform(["life is is short,i like python", "life is too long,i dislike python"])

# 内容
print(count.get_feature_names())
print(data.toarray())

return None

问题:如果我们将数据替换成中文？
“人生苦短，我喜欢Python” “生活太长久，我不喜欢Python”
那么最终得到的结果是

不支持单个中文字

为什么会得到这样的结果呢，仔细分析之后会发现英文默认是以空格分开的。其实就达到了一个分词的效果，所以我们要对中文进行分词处理

3.3jieba分词处理
jieba.cut()
返回词语组成的生成器
需要安装下jieba库

pip3 install jieba
3.4 案例分析
对以下三句话进行特征值化

今天很残酷，明天更残酷，后天很美好，
但绝对大部分是死在明天晚上，所以每个人不要放弃今天。

我们看到的从很远星系来的光是在几百万年之前发出的，
这样当我们看到宇宙时，我们是在看它的过去。

如果只用一种方式了解某样事物，你就不会真正了解它。
了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。
分析
准备句子，利用jieba.cut进行分词
实例化CountVectorizer
将分词结果变成字符串当作fit_transform的输入值
三段中文结果

def cutword():

# 将三个句子用jieba.cut处理
contetn1 = jieba.cut("今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。")
contetn2 = jieba.cut("我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。")
contetn3 = jieba.cut("如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。")

# 先将着三个转换成列表
c1 = ' '.join(list(contetn1))
c2 = ' '.join(list(contetn2))
c3 = ' '.join(list(contetn3))

return c1, c2, c3

def chvec():

# 实例化conunt
count = CountVectorizer(stop_words=['不要', '我们', '所以'])

# 定义一个分词的函数
c1, c2, c3 = cutword()

data = count.fit_transform([c1, c2, c3])

# 内容
print(count.get_feature_names())
print(data.toarray())

return None

请看问题：

词语占比

该如何处理某个词或短语在多篇文章中出现的次数高这种情况

3.5 Tf-idf文本特征提取
TF-IDF的主要思想是：如果某个词或短语在一篇文章中出现的概率高，并且在其他文章中很少出现，则认为此词或者短语具有很好的类别区分能力，适合用来分类。
TF-IDF作用：用以评估一字词对于一个文件集或一个语料库中的其中一份文件的重要程度。
3.5.1 公式
词频（term frequency，tf）指的是某一个给定的词语在该文件中出现的频率
逆向文档频率（inverse document frequency，idf）是一个词语普遍重要性的度量。某一特定词语的idf，可以由总文件数目除以包含该词语之文件的数目，再将得到的商取以10为底的对数得到
tfidf公式

最终得出结果可以理解为重要程度。

注：假如一篇文件的总词语数是100个，而词语"非常"出现了5次，那么"非常"一词在该文件中的词频就是5/100=0.05。而计算文件频率（IDF）的方法是以文件集的文件总数，除以出现"非常"一词的文件数。所以，如果"非常"一词在1,000份文件出现过，而文件总数是10,000,000份的话，其逆向文件频率就是lg（10,000,000 / 1,0000）=3。最后"非常"对于这篇文档的tf-idf的分数为0.05 * 3=0.15
3.5.2 案例
def tfidfvec():

# 实例化conunt
tfidf = TfidfVectorizer()

# 定义一个分词的函数
c1, c2, c3 = cutword()

data = tfidf.fit_transform([c1, c2, c3])

# 内容
print(tfidf.get_feature_names())
print(data.toarray())

return None

3.6 Tf-idf的重要性
分类机器学习算法进行文章分类中前期数据处理方式
特征预处理
学习目标
目标
了解数值型数据、类别型数据特点
应用MinMaxScaler实现对特征数据进行归一化
应用StandardScaler实现对特征数据进行标准化
应用
无
什么是特征预处理？

特征预处理图

1、什么是特征预处理

scikit-learn的解释

provides several common utility functions and transformer classes to change raw feature vectors into a representation that is more suitable for the downstream estimators.
翻译过来：通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程

可以通过上面那张图来理解

1.1 包含内容
数值型数据的无量纲化：
归一化
标准化
1.2 特征预处理API
sklearn.preprocessing
为什么我们要进行归一化/标准化？
特征的单位或者大小相差较大，或者某特征的方差相比其他的特征要大出几个数量级，容易影响（支配）目标结果，使得一些算法无法学习到其它的特征
约会对象数据
约会对象数据

我们需要用到一些方法进行无量纲化，使不同规格的数据转换到同一规格

2、归一化
2.1定义
通过对原始数据进行变换把数据映射到(默认为[0,1])之间

2.2公式
归一化公式

作用于每一列，max为一列的最大值，min为一列的最小值,那么X’’为最终结果，mx，mi分别为指定区间值默认mx为1,mi为0

那么怎么理解这个过程呢？我们通过一个例子

归一化计算过程

2.3 API
sklearn.preprocessing.MinMaxScaler (feature_range=(0,1)… )
MinMaxScalar.fit_transform(X)
X:numpy array格式的数据[n_samples,n_features]
返回值：转换后的形状相同的array
2.4 数据计算
我们对以下数据进行运算，在dating.txt中。保存的就是之前的约会对象数据

milage,Liters,Consumtime,target
40920,8.326976,0.953952,3
14488,7.153469,1.673904,2
26052,1.441871,0.805124,1
75136,13.147394,0.428964,1
38344,1.669788,0.134296,1
分析
1、实例化MinMaxScalar

2、通过fit_transform转换

def mm():
“”"
对二维数组进行归一化处理
:return:
“”"
data = pd.read_csv("./data/datingtest/dating.txt")

mm = MinMaxScaler(feature_range=(2, 3))

data = mm.fit_transform(data[['milage','Liters','Consumtime']])

print(data)

return None

问题：如果数据中异常点较多，会有什么影响？
异常点对归一化影响

2.5 归一化总结
注意最大值最小值是变化的，另外，最大值与最小值非常容易受异常点影响，所以这种方法鲁棒性较差，只适合传统精确小数据场景。

怎么办？

3、标准化
3.1定义
通过对原始数据进行变换把数据变换到均值为0,标准差为1范围内

3.2 公式
标准化公式

作用于每一列，mean为平均值，σ为标准差

所以回到刚才异常点的地方，我们再来看看标准化

标准化异常点影响

对于归一化来说：如果出现异常点，影响了最大值和最小值，那么结果显然会发生改变
对于标准化来说：如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大，从而方差改变较小。
3.3 API
sklearn.preprocessing.StandardScaler( )
处理之后每列来说所有数据都聚集在均值0附近标准差差为1
StandardScaler.fit_transform(X)
X:numpy array格式的数据[n_samples,n_features]
返回值：转换后的形状相同的array
3.4 数据计算
同样对上面的数据进行处理

[[90,2,10,40],
[60,4,15,45],
[75,3,13,46]]
分析
1、实例化StandardScaler

2、通过fit_transform转换

def std():
“”"
标准化处理
“”"
data = pd.read_csv("./data/datingtest/dating.txt")

std = StandardScaler()

data = std.fit_transform(data[['milage','Liters','Consumtime']])

print(data)
return None

3.5 标准化总结
在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。
特征选择
学习目标
目标
知道特征选择的嵌入式、过滤式以及包裹氏三种方式
应用VarianceThreshold实现删除低方差特征
了解相关系数的特点和计算
应用相关性系数实现特征选择
应用
无
在讲什么是特征选择之前，我们得先介绍一个降维的概念
1、降维
降维是指在某些限定条件下，降低随机变量(特征)个数，得到一组“不相关”主变量的过程

降低随机变量的个数
降维

相关特征(correlated feature)
的相对湿度与降雨量之间的相关
等等
正是因为在进行训练的时候，我们都是使用特征进行学习。如果特征本身存在问题或者特征之间相关性较强，对于算法学习预测会影响较大

2、降维的两种方式
特征选择
主成分分析（可以理解一种特征提取的方式）
3、什么是特征选择
3.1 定义
数据中包含冗余或无关变量（或称特征、属性、指标等），旨在从原有特征中找出主要特征。

鸟类特征选择

3.2 方法
Filter(过滤式)：主要探究特征本身特点、特征与特征和目标值之间关联
方差选择法：低方差特征过滤
相关系数
Embedded (嵌入式)：算法自动选择特征（特征与目标值之间的关联）
决策树:信息熵、信息增益
正则化：L1、L2
深度学习：卷积等
Wrapper (包裹式)
对于Embedded方式，只能在讲解算法的时候在进行介绍，更好的去理解

3.3 模块
sklearn.feature_selection
4、过滤式
4.1低方差特征过滤
删除低方差的一些特征，前面讲过方差的意义。再结合方差的大小来考虑这个方式的角度。

特征方差小：某个特征大多样本的值比较相近
特征方差大：某个特征很多样本的值都有差别
4.1.1 API
sklearn.feature_selection.VarianceThreshold(threshold = 0.0)
删除所有低方差特征
Variance.fit_transform(X)
X:numpy array格式的数据[n_samples,n_features]
返回值：训练集差异低于threshold的特征将被删除。默认值是保留所有非零方差特征，即删除所有样本中具有相同值的特征。
4.1.2 数据计算
我们对某些股票的指标特征之间进行一个筛选，数据在"factor_regression_data/factor_returns.csv"文件当中,除去’index,‘date’,'return’列不考虑（这些类型不匹配，也不是所需要指标）

一共这些特征

pe_ratio,pb_ratio,market_cap,return_on_asset_net_profit,du_return_on_equity,ev,earnings_per_share,revenue,total_expense
index,pe_ratio,pb_ratio,market_cap,return_on_asset_net_profit,du_return_on_equity,ev,earnings_per_share,revenue,total_expense,date,return
0,000001.XSHE,5.9572,1.1818,85252550922.0,0.8008,14.9403,1211444855670.0,2.01,20701401000.0,10882540000.0,2012-01-31,0.027657228229937388
1,000002.XSHE,7.0289,1.588,84113358168.0,1.6463,7.8656,300252061695.0,0.326,29308369223.2,23783476901.2,2012-01-31,0.08235182370820669
2,000008.XSHE,-262.7461,7.0003,517045520.0,-0.5678,-0.5943,770517752.56,-0.006,11679829.03,12030080.04,2012-01-31,0.09978900335112327
3,000060.XSHE,16.476,3.7146,19680455995.0,5.6036,14.617,28009159184.6,0.35,9189386877.65,7935542726.05,2012-01-31,0.12159482758620697
4,000069.XSHE,12.5878,2.5616,41727214853.0,2.8729,10.9097,81247380359.0,0.271,8951453490.28,7091397989.13,2012-01-31,-0.0026808154146886697
分析
1、初始化VarianceThreshold,指定阀值方差

2、调用fit_transform

def var():
“”"
删除所有低方差特征
:return:
“”"
data = pd.read_csv("./data/factor_regression_data/factor_returns.csv")

var = VarianceThreshold(threshold=1.0)

data = var.fit_transform(data.iloc[:, 1:10])
return None

4.2 相关系数
皮尔逊相关系数(Pearson Correlation Coefficient)
反映变量之间相关关系密切程度的统计指标
4.2.2 公式计算案例(了解，不用记忆)
公式
相关系数公式

比如说我们计算年广告费投入与月均销售额
广告费表

那么之间的相关系数怎么计算

广告费统计系数结果

最终计算：

相关系数计算数字结果

= 0.9942

所以我们最终得出结论是广告投入费与月平均销售额之间有高度的正相关关系。

4.2.2 特点
相关系数的值介于–1与+1之间，即–1≤ r ≤+1。其性质如下：

当r>0时，表示两变量正相关，r<0时，两变量为负相关
当|r|=1时，表示两变量为完全相关，当r=0时，表示两变量间无相关关系
当0<|r|<1时，表示两变量存在一定程度的相关。且|r|越接近1，两变量间线性关系越密切；|r|越接近于0，表示两变量的线性相关越弱
一般可按三级划分：|r|<0.4为低度相关；0.4≤|r|<0.7为显著性相关；0.7≤|r|<1为高度线性相关
这个符号：|r|为r的绝对值， |-5| = 5

4.2.2 API
from scipy.stats import pearsonr
x : (N,) array_like
y : (N,) array_like Returns: (Pearson’s correlation coefficient, p-value)
4.3、 案例：股票的财务指标相关性计算
我们刚才的股票的这些指标进行相关性计算， 假设我们以

factor = [‘pe_ratio’,‘pb_ratio’,‘market_cap’,‘return_on_asset_net_profit’,‘du_return_on_equity’,‘ev’,‘earnings_per_share’,‘revenue’,‘total_expense’]
这些特征当中的两两进行计算，得出相关性高的一些特征

指标相关性结果

分析
两两特征之间进行相关性计算
data = pd.read_csv("./data/factor_regression_data/factor_returns.csv")

for i in range(len(factor)):
for j in range(i, len(factor)-1):
print(“指标%s与指标%s之间的相关性大小为%f” % (factor[i], factor[j+1], pearsonr(data[factor[i]], data[factor[j+1]])[0]))
从中我们得出

指标revenue与指标total_expense之间的相关性大小为0.995845
指标return_on_asset_net_profit与指标du_return_on_equity之间的相关性大小为0.818697
我们也可以通过画图来观察结果

import matplotlib.pyplot as plt
plt.scatter(data[‘revenue’], data[‘total_expense’])
plt.show()
这两对指标之间的相关性较大，可以做之后的处理，比如合成这两个指标。
主成分分析
学习目标
目标
应用PCA实现特征的降维
应用
用户与物品类别之间主成分分析
1、什么是主成分分析(PCA)
定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量

作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。

应用：回归分析或者聚类分析当中
对于信息一词，在决策树中会进行介绍

那么更好的理解这个过程呢？我们来看一张图

PCA解释图

1.1 计算案例理解(了解，无需记忆)
假设对于给定5个点，数据如下

(-1,-2)
(-1, 0)
( 0, 0)
( 2, 1)
( 0, 1)
PCA计算图

要求：将这个二维的数据简化成一维？ 并且损失少量的信息

PCA坐标轴结果

这个过程如何计算的呢？找到一个合适的直线，通过一个矩阵运算得出主成分分析的结果（不需要理解）

PCA运算过程

1.2 API
sklearn.decomposition.PCA(n_components=None)
将数据分解为较低维数空间
n_components:
小数：表示保留百分之多少的信息
整数：减少到多少特征
PCA.fit_transform(X) X:numpy array格式的数据[n_samples,n_features]
返回值：转换后指定维度的array
1.3 数据计算
先拿个简单的数据计算一下

[[2,8,4,5],
[6,3,0,8],
[5,4,9,1]]
def pca():
“”"
主成分分析进行降维
:return:
“”"
pca = PCA(n_components=0.7)

data = pca.fit_transform([[2,8,4,5],[6,3,0,8],[5,4,9,1]])

print(data)

return None

2、案例：探究用户对物品类别的喜好细分降维
instacart

数据如下：

order_products__prior.csv：订单与商品信息

字段：order_id, product_id, add_to_cart_order, reordered
products.csv：商品信息

字段：product_id, product_name, aisle_id, department_id
orders.csv：用户的订单信息
字段：order_id,user_id,eval_set,order_number,….
aisles.csv：商品所属具体物品类别
字段： aisle_id, aisle
2.1 需求
instacart效果

instacartPCA结果

2.2 分析
合并表，使得user_id与aisle在一张表当中
进行交叉表变换
进行降维
2.3 完整代码

去读四张表的数据

prior = pd.read_csv("./data/instacart/order_products__prior.csv")
products = pd.read_csv("./data/instacart/products.csv")
orders = pd.read_csv("./data/instacart/orders.csv")
aisles = pd.read_csv("./data/instacart/aisles.csv")

合并四张表

mt = pd.merge(prior, products, on=[‘product_id’, ‘product_id’])
mt1 = pd.merge(mt, orders, on=[‘order_id’, ‘order_id’])
mt2 = pd.merge(mt1, aisles, on=[‘aisle_id’, ‘aisle_id’])

pd.crosstab 统计用户与物品之间的次数关系（统计次数）

cross = pd.crosstab(mt2[‘user_id’], mt2[‘aisle’])

PCA进行主成分分析

pc = PCA(n_components=0.95)
data = pc.fit_transform(cross)
机器学习算法简介
学习目标
目标
说明机器学习算法监督学习与无监督学习的区别
说明机器学习算法目标值的两种数据类型
说明监督学习中的分类、回归特点
说明机器学习(数据挖掘)的开发流程
应用
无
1、机器学习算法类别
1.1 按照学习方式分类
监督学习(supervised learning)（预测）
定义：输入数据是由输入特征值和目标值所组成。函数的输出可以是一个连续的值(称为回归），或是输出是有限个离散值（称作分类）。
分类 k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归、神经网络
回归 线性回归、岭回归
标注 隐马尔可夫模型 (不做要求)
无监督学习(unsupervised learning)
定义：输入数据是由输入特征值所组成。
聚类 k-means
半监督和强化学习
1.2 区别
监督学习无监督学习区别

1.3 理解监督无监督
1.4 关于监督学习中的分类与回归区别
要理解这两个概念，我们从两个数据类别来看。

数据类别图

1.4.1 两种数据类型
离散型数据：由记录不同类别个体的数目所得到的数据，又称计数数据，所有这些数据全部都是整数，而且不能再细分，也不能进一步提高他们的精确度。
连续型数据：变量可以在某个范围内取任一数，即变量的取值可以是连续的，如，长度、时间、质量值等，这类整数通常是非整数，含有小数部分。
注：只要记住一点，离散型是区间内不可分，连续型是区间内可分

数据的类型将是机器学习中监督学习不同问题不同处理的依据？

猫狗

票房预测

结合刚才讲过的数据类型，针对这两个例子的输出结果，得出结论

分类：目标值数据类型为离散型
分类是监督学习的一个核心问题，在监督学习中，当输出变量取有限个离散值时，预测问题变成为分类问题，最基础的便是二分类问题，即判断是非，从两个类别中选择一个作为预测结果；
回归：目标值数据类型为连续型
回归是监督学习的另一个重要问题。回归用于预测输入变量和输出变量之间的关系，输出是连续型的值。
2、机器学习开发流程
开发流程

2.1 理解模型这个概念
指对于某个实际问题或客观事物，应用合适的算法得到的结果，称之为模型。

相当于对问题，抽象成数学问题。模型 = 算法 + 数据
分类算法
知道数据集的分为训练集和测试集
知道sklearn的转换器和估计器流程
了解sklearn的分类、回归数据集
说明K-近邻算法的距离公式
说明K-近邻算法的超参数K值以及取值问题
说明K-近邻算法的优缺点
应用KNeighborsClassifier实现分类
了解分类算法的评估标准准确率
说明朴素贝叶斯算法的原理
说明朴素贝叶斯算法的优缺点
应用MultinomialNB实现文本分类
应用模型选择与调优
说明决策树算法的原理
说明决策树算法的优缺点
应用DecisionTreeClassifier实现分类
说明随机森林算法的原理
说明随机森林算法的优缺点
应用RandomForestClassifier实现分类
数据集介绍与划分
学习目标
目标
知道数据集的分为训练集和测试集
知道sklearn的分类、回归数据集
应用
无
拿到的数据是否全部都用来训练一个模型？

1、 数据集的划分
机器学习一般的数据集会划分为两个部分：

训练数据：用于训练，构建模型
测试数据：在模型检验时使用，用于评估模型是否有效
划分比例：

训练集：70% 80% 75%
测试集：30% 20% 30%
API
sklearn.model_selection.train_test_split(arrays, *options)
x 数据集的特征值
y 数据集的标签值
test_size 测试集的大小，一般为float
random_state 随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
return ，测试集特征训练集特征值值，训练标签，测试标签(默认随机取)
结合后面的数据集作介绍

2、sklearn数据集介绍
2.1分类和回归数据集
分类数据集
分类数据集

sklearn.datasets.fetch_20newsgroups(data_home=None,subset=‘train’)
subset: ‘train’或者’test’,‘all’，可选，选择要加载的数据集.训练集的“训练”，测试集的“测试”，两者的“全部”
回归数据集
回归数据集

2.2 API
sklearn.datasets
加载获取流行数据集
datasets.load_()
获取小规模数据集，数据包含在datasets里
datasets.fetch_(data_home=None)
获取大规模数据集，需要从网络上下载，函数的第一个参数是data_home，表示数据集下载的目录,默认是 ~/scikit_learn_data/
2.3 返回类型
load和fetch返回的数据类型datasets.base.Bunch(字典格式)
data：特征数据数组，是 [n_samples * n_features] 的二维 numpy.ndarray 数组
target：标签数组，是 n_samples 的一维 numpy.ndarray 数组
DESCR：数据描述
feature_names：特征名,新闻数据，手写数字、回归数据集没有
target_names：标签名
sklearn转换器和估计器
学习目标
目标
知道sklearn的转换器和估计器流程
应用
无
1、转换器和估计器
1.1 转换器
想一下之前做的特征工程的步骤？

1、实例化 (实例化的是一个转换器类(Transformer))
2、调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)
我们把特征工程的接口称之为转换器，其中转换器调用有这么几种形式

fit_transform
fit
transform
这几个方法之间的区别是什么呢？我们看以下代码就清楚了

In [1]: from sklearn.preprocessing import StandardScaler

In [2]: std1 = StandardScaler()

In [3]: a = [[1,2,3], [4,5,6]]

In [4]: std1.fit_transform(a)
Out[4]:
array([[-1., -1., -1.],
[ 1., 1., 1.]])

In [5]: std2 = StandardScaler()

In [6]: std2.fit(a)
Out[6]: StandardScaler(copy=True, with_mean=True, with_std=True)

In [7]: std2.transform(a)
Out[7]:
array([[-1., -1., -1.],
[ 1., 1., 1.]])
从中可以看出，fit_transform的作用相当于transform加上fit。但是为什么还要提供单独的fit呢, 我们还是使用原来的std2来进行标准化看看

In [8]: b = [[7,8,9], [10, 11, 12]]

In [9]: std2.transform(b)
Out[9]:
array([[3., 3., 3.],
[5., 5., 5.]])

In [10]: std2.fit_transform(b)
Out[10]:
array([[-1., -1., -1.],
[ 1., 1., 1.]])
1.2 估计器(sklearn机器学习算法的实现)
在sklearn中，估计器(estimator)是一个重要的角色，是一类实现了算法的API

1、用于分类的估计器：
sklearn.neighbors k-近邻算法
sklearn.naive_bayes 贝叶斯
sklearn.linear_model.LogisticRegression 逻辑回归
sklearn.tree 决策树与随机森林
2、用于回归的估计器：
sklearn.linear_model.LinearRegression 线性回归
sklearn.linear_model.Ridge 岭回归
3、用于无监督学习的估计器
sklearn.cluster.KMeans 聚类
1.3 估计器工作流程
估计器工作流程
K-近邻算法
学习目标
目标
说明K-近邻算法的距离公式
说明K-近邻算法的超参数K值以及取值问题
说明K-近邻算法的优缺点
应用KNeighborsClassifier实现分类
了解分类算法的评估标准准确率
应用
Facebook签到位置预测
问题：回忆分类问题的判定方法
什么是K-近邻算法
地图K紧邻算法

你的“邻居”来推断出你的类别
1、K-近邻算法(KNN)
1.1 定义
如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

来源：KNN算法最早是由Cover和Hart提出的一种分类算法

1.2 距离公式
两个样本的距离可以通过如下公式计算，又叫欧式距离

距离公式

2、电影类型分析
假设我们有现在几部电影

电影类型分析

其中？ 号电影不知道类别，如何去预测？我们可以利用K近邻算法的思想

电影距离计算

2.1 问题
如果去的最近的电影数量不一致？
2.2 K-近邻算法数据的特征工程处理
结合前面的约会对象数据，分析K-近邻算法需要做什么样的处理
3、K-近邻算法API
sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)
n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数
algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)
4、案例：预测签到位置
FBlocation介绍

数据介绍：

train.csv，test.csv
row_id：登记事件的ID
xy：坐标
准确性：定位准确性
时间：时间戳
place_id：业务的ID，这是您预测的目标
4.1 分析
对于数据做一些基本处理（这里所做的一些处理不一定达到很好的效果，我们只是简单尝试，有些特征我们可以根据一些特征选择的方式去做处理）

1、缩小数据集范围 DataFrame.query()

2、处理日期数据 pd.to_datetime pd.DatetimeIndex

3、增加分割的日期数据

4、删除没用的日期数据 DataFrame.drop

5、将签到位置少于n个用户的删除

place_count = data.groupby(‘place_id’).count()

tf = place_count[place_count.row_id > 3].reset_index()

data = data[data[‘place_id’].isin(tf.place_id)]

分割数据集

标准化处理

k-近邻预测

4.2 代码
def knncls():
“”"
K近邻算法预测入住位置类别
:return:
“”"
# 一、处理数据以及特征工程
# 1、读取收，缩小数据的范围
data = pd.read_csv("./data/FBlocation/train.csv")

# 数据逻辑筛选操作 df.query()
data = data.query("x > 1.0 & x < 1.25 & y > 2.5 & y < 2.75")

# 2、处理时间戳日期
time_value = pd.to_datetime(data['time'], unit='s')

time_value = pd.DatetimeIndex(time_value)

# 加入时间的其它的特征
data['day'] = time_value.day

data['weekday'] = time_value.weekday

data['hour'] = time_value.hour

# 删除time这一列特征
data = data.drop(['time'], axis=1)

print(data)

# 删除入住次数少于三次位置
place_count = data.groupby('place_id').count()

tf = place_count[place_count.row_id > 3].reset_index()

data = data[data['place_id'].isin(tf.place_id)]

# 3、取出特征值和目标值
y = data['place_id']
# y = data[['place_id']]

x = data.drop(['place_id', 'row_id'], axis=1)

# 4、数据分割与特征工程?

# （1）、数据分割
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)

# (2)、标准化
std = StandardScaler()

# 队训练集进行标准化操作
x_train = std.fit_transform(x_train)
print(x_train)

# 进行测试集的标准化操作
x_test = std.fit_transform(x_test)

# 二、算法的输入训练预测
# K值：算法传入参数不定的值    理论上：k = 根号(样本数)
# K值：后面会使用参数调优方法，去轮流试出最好的参数[1,3,5,10,20,100,200]
knn = KNeighborsClassifier(n_neighbors=1)

# 调用fit()
knn.fit(x_train, y_train)

# 预测测试数据集，得出准确率
y_predict = knn.predict(x_test)

print("预测测试集类别：", y_predict)

print("准确率为：", knn.score(x_test, y_test))

return None

4.3 结果分析
准确率： 分类算法的评估之一
1、k值取多大？有什么影响？
k值取很小：容易受到异常点的影响

k值取很大：受到样本均衡的问题

2、性能问题？
距离计算上面，时间复杂度高

5、K-近邻总结
优点：
简单，易于理解，易于实现，无需训练
缺点：
懒惰算法，对测试样本分类时的计算量大，内存开销大
必须指定K值，K值选择不当则分类精度不能保证
使用场景：小数据场景，几千～几万样本，具体场景具体业务去测试
模型选择与调优
学习目标
目标
说明交叉验证过程
说明超参数搜索过程
应用GridSearchCV实现算法参数的调优
应用
Facebook签到位置预测调优
1、为什么需要交叉验证
交叉验证目的：为了让被评估的模型更加准确可信

2、什么是交叉验证(cross validation)
交叉验证：将拿到的训练数据，分为训练和验证集。以下图为例：将数据分成5份，其中一份作为验证集。然后经过5次(组)的测试，每次都更换不同的验证集。即得到5组模型的结果，取平均值作为最终结果。又称5折交叉验证。

2.1 分析
我们之前知道数据分为训练集和测试集，但是为了让从训练得到模型结果更加准确。做以下处理

训练集：训练集+验证集
测试集：测试集
交叉验证过程

问题：那么这个只是对于参数得出更好的结果，那么怎么选择或者调优参数呢？
3、超参数搜索-网格搜索(Grid Search)
通常情况下，有很多参数是需要手动指定的（如k-近邻算法中的K值），这种叫超参数。但是手动过程繁杂，所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型。

超参数

3.1 模型选择与调优
sklearn.model_selection.GridSearchCV(estimator, param_grid=None,cv=None)
对估计器的指定参数值进行详尽搜索
estimator：估计器对象
param_grid：估计器参数(dict){“n_neighbors”:[1,3,5]}
cv：指定几折交叉验证
fit：输入训练数据
score：准确率
结果分析：
bestscore:在交叉验证中验证的最好结果_
bestestimator：最好的参数模型
cvresults:每次交叉验证后的验证集准确率结果和训练集准确率结果
4、Facebook签到位置预测K值调优
使用网格搜索估计器

使用网格搜索和交叉验证找到合适的参数

knn = KNeighborsClassifier()

param = {“n_neighbors”: [3, 5, 10]}

gc = GridSearchCV(knn, param_grid=param, cv=2)

gc.fit(x_train, y_train)

print(“选择了某个模型测试集当中预测的准确率为：”, gc.score(x_test, y_test))

训练验证集的结果

print(“在交叉验证当中验证的最好结果：”, gc.best_score_)
print(“gc选择了的模型K值是：”, gc.best_estimator_)
print(“每次交叉验证的结果为：”, gc.cv_results_)
朴素贝叶斯算法
学习目标
目标
说明条件概率与联合概率
说明贝叶斯公式、以及特征独立的关系
记忆贝叶斯公式
知道拉普拉斯平滑系数
应用贝叶斯公式实现概率的计算
应用
20类新闻文章分类预测
1、 什么是朴素贝叶斯分类方法
垃圾邮件分类

文章分类

2、 概率基础
2.1 概率(Probability)定义
概率定义为一件事情发生的可能性
扔出一个硬币，结果头像朝上
某天是晴天
P(X) : 取值在[0, 1]
2.2 女神是否喜欢计算案例
在讲这两个概率之前我们通过一个例子，来计算一些结果：

计算概率

问题如下：
概率问题

那么其中有些问题我们计算的结果不正确，或者不知道计算，我们有固定的公式去计算

2.3 条件概率与联合概率
联合概率：包含多个条件，且所有条件同时成立的概率
记作：P(A,B)
特性：P(A, B) = P(A)P(B)
条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率
记作：P(A|B)
特性：P(A1,A2|B) = P(A1|B)P(A2|B)
注意：此条件概率的成立，是由于A1,A2相互独立的结果(记忆)

这样我们计算结果为：

p(程序员, 匀称) = P(程序员)P(匀称) =3/7*(4/7) = 12/49
P(产品, 超重|喜欢) = P(产品|喜欢)P(超重|喜欢)=1/2 * 1/4 = 1/8
那么，我们知道了这些知识之后，继续回到我们的主题中。朴素贝叶斯如何分类，这个算法经常会用在文本分类，那就来看文章分类是一个什么样的问题？

文章分类引入

这个了类似一个条件概率，那么仔细一想，给定文章其实相当于给定什么？结合前面我们将文本特征抽取的时候讲的？所以我们可以理解为

文章分类引入2

但是这个公式怎么求？前面并没有参考例子，其实是相似的，我们可以使用贝叶斯公式去计算

3、 贝叶斯公式
3.1 公式
贝叶斯公式

那么这个公式如果应用在文章分类的场景当中，我们可以这样看：

贝叶斯公式理解

公式分为三个部分：

P：每个文档类别的概率(某文档类别数／总文档数量)
P(W│C)：给定类别下特征（被预测文档中出现的词）的概率
计算方法：P(F1│C)=Ni/N （训练文档中去计算）
Ni为该F1词在C类别所有文档中出现的次数
N为所属类别C下的文档所有词出现的次数和
P(F1,F2,…) 预测文档中每个词的概率
如果计算两个类别概率比较：

概率前面比较大小

所以我们只要比较前面的大小就可以，得出谁的概率大

3.2 文章分类计算
假设我们从训练数据集得到如下信息
分类计算例子

计算结果
科技：P(科技|影院,支付宝,云计算) = ?(影院,支付宝,云计算|科技)∗P(科技)=(8/100)∗(20/100)∗(63/100)∗(30/90) = 0.00456109

娱乐：P(娱乐|影院,支付宝,云计算) = ?(影院,支付宝,云计算|娱乐)∗P(娱乐)=(56/121)∗(15/121)∗(0/121)∗(60/90) = 0
思考:我们计算出来某个概率为0，合适吗？
3.3 拉普拉斯平滑系数
目的：防止计算出的分类概率为0

平滑系数公式

P(娱乐|影院,支付宝,云计算) =P(影院,支付宝,云计算|娱乐)P(娱乐) =P(影院|娱乐)*P(支付宝|娱乐)P(云计算|娱乐)P(娱乐)=(56+1/121+4)(15+1/121+4)(0+1/121+14)(60/90) = 0.00002
3.4 API
sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
朴素贝叶斯分类
alpha：拉普拉斯平滑系数
4、案例：20类新闻分类
新闻分类介绍

4.1 分析
分割数据集

tfidf进行的特征抽取

朴素贝叶斯预测
4.2 代码
def nbcls():
“”"
朴素贝叶斯对新闻数据集进行预测
:return:
“”"
# 获取新闻的数据，20个类别
news = fetch_20newsgroups(subset=‘all’)

# 进行数据集分割
x_train, x_test, y_train, y_test = train_test_split(news.data, news.target, test_size=0.3)

# 对于文本数据，进行特征抽取
tf = TfidfVectorizer()

x_train = tf.fit_transform(x_train)
# 这里打印出来的列表是：训练集当中的所有不同词的组成的一个列表
print(tf.get_feature_names())
# print(x_train.toarray())

# 不能调用fit_transform
x_test = tf.transform(x_test)

# estimator估计器流程
mlb = MultinomialNB(alpha=1.0)

mlb.fit(x_train, y_train)

# 进行预测
y_predict = mlb.predict(x_test)

print("预测每篇文章的类别：", y_predict[:100])
print("真实类别为：", y_test[:100])

print("预测准确率为：", mlb.score(x_test, y_test))

return None

5、总结
优点：
朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
对缺失数据不太敏感，算法也比较简单，常用于文本分类。
分类准确度高，速度快
缺点：
由于使用了样本属性独立性的假设，所以如果特征属性有关联时其效果不好
决策树
学习目标
目标
说明信息熵的公式以及作用
说明信息增益的公式作用
应用信息增益实现计算特征的不确定性减少程度
了解决策树的三种算法实现
应用
泰坦尼克号乘客生存预测
1、认识决策树
决策树思想的来源非常朴素，程序设计中的条件分支结构就是if-then结构，最早的决策树就是利用这类结构分割数据的一种分类学习方法

怎么理解这句话？通过一个对话例子

相亲对话

想一想这个女生为什么把年龄放在最上面判断！！！！！！！！！

2、决策树分类原理详解
为了更好理解决策树具体怎么分类的，我们通过一个问题例子？

银行贷款数

问题：如何对这些客户进行分类预测？你是如何去划分？
有可能你的划分是这样的

贷款划分1

那么我们怎么知道这些特征哪个更好放在最上面，那么决策树的真是划分是这样的

贷款划分2

2.1 原理
信息熵、信息增益等
需要用到信息论的知识！！！问题：通过例子引入信息熵

2.2 信息熵
那来玩个猜测游戏，猜猜这32支球队那个是冠军。并且猜测错误付出代价。每猜错一次给一块钱，告诉我是否猜对了，那么我需要掏多少钱才能知道谁是冠军？ （前提是：不知道任意球队的信息、历史比赛记录、实力等）

足球队

为了使代价最小，可以使用二分法猜测：

我可以把球编上号，从1到32，然后提问：冠 军在1-16号吗？依次询问，只需要五次，就可以知道结果。

二分法猜测

我们来看这个式子：

32支球队，log32=5比特
64支球队，log64=6比特
香农

香农指出，它的准确信息量应该是，p为每个球队获胜的概率（假设概率相等，都为1/32），我们不用钱去衡量这个代价了，香浓指出用比特：

H = -(p1logp1 + p2logp2 + … + p32log32) = - log32
2.2.1 信息熵的定义
H的专业术语称之为信息熵，单位为比特。
信息熵公式

“谁是世界杯冠军”的信息量应该比5比特少，特点（重要）：

当这32支球队夺冠的几率相同时，对应的信息熵等于5比特
只要概率发生任意变化，信息熵都比5比特大
2.2.2 总结（重要）
信息和消除不确定性是相联系的
当我们得到的额外信息（球队历史比赛情况等等）越多的话，那么我们猜测的代价越小（猜测的不确定性减小）

问题： 回到我们前面的贷款案例，怎么去划分？可以利用当得知某个特征（比如是否有房子）之后，我们能够减少的不确定性大小。越大我们可以认为这个特征很重要。那怎么去衡量减少的不确定性大小呢？
2.3 决策树的划分依据之一------信息增益
2.3.1 定义与公式
特征A对训练数据集D的信息增益g(D,A),定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)之差，即公式为：

信息增益公式

公式的详细解释：

信息增益公式详解

注：信息增益表示得知特征X的信息而息的不确定性减少的程度使得类Y的信息熵减少的程度

2.3.2 贷款特征重要计算
银行贷款数

我们以年龄特征来计算：
1、g(D, 年龄) = H(D) -H(D|年龄) = 0.971-[5/15H(青年)+5/15H(中年)+5/15H(老年]

2、H(D) = -(6/15log(6/15)+9/15log(9/15))=0.971

3、H(青年) = -(3/5log(3/5) +2/5log(2/5))
H(中年)=-(3/5log(3/5) +2/5log(2/5))
H(老年)=-(4/5og(4/5)+1/5log(1/5))
我们以A1、A2、A3、A4代表年龄、有工作、有自己的房子和贷款情况。最终计算的结果g(D, A1) = 0.313, g(D, A2) = 0.324, g(D, A3) = 0.420,g(D, A4) = 0.363。所以我们选择A3 作为划分的第一个特征。这样我们就可以一棵树慢慢建立

2.4 决策树的三种算法实现
当然决策树的原理不止信息增益这一种，还有其他方法。但是原理都类似，我们就不去举例计算。

ID3
信息增益 最大的准则
C4.5
信息增益比 最大的准则
CART
分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的默认原则
优势：划分更加细致（从后面例子的树显示来理解）
2.5 决策树API
class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None,random_state=None)
决策树分类器
criterion:默认是’gini’系数，也可以选择信息增益的熵’entropy’
max_depth:树的深度大小
random_state:随机数种子
其中会有些超参数：max_depth:树的深度大小
其它超参数我们会结合随机森林讲解
3、案例：泰坦尼克号乘客生存预测
泰坦尼克号数据
在泰坦尼克号和titanic2数据帧描述泰坦尼克号上的个别乘客的生存状态。这里使用的数据集是由各种研究人员开始的。其中包括许多研究人员创建的旅客名单，由Michael A. Findlay编辑。我们提取的数据集中的特征是票的类别，存活，乘坐班，年龄，登陆，home.dest，房间，票，船和性别。

1、乘坐班是指乘客班（1，2，3），是社会经济阶层的代表。

2、其中age数据存在缺失。

数据：http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt

泰坦尼克号数据

3.1 分析
选择我们认为重要的几个特征 [‘pclass’, ‘age’, ‘sex’]
填充缺失值
特征中出现类别符号，需要进行one-hot编码处理(DictVectorizer)
x.to_dict(orient=“records”) 需要将数组特征转换成字典数据
数据集划分
决策树分类预测
3.2 代码
def decisioncls():
“”"
决策树进行乘客生存预测
:return:
“”"
# 1、获取数据
titan = pd.read_csv(“http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt”)

# 2、数据的处理
x = titan[['pclass', 'age', 'sex']]

y = titan['survived']

# print(x , y)
# 缺失值需要处理，将特征当中有类别的这些特征进行字典特征抽取
x['age'].fillna(x['age'].mean(), inplace=True)

# 对于x转换成字典数据x.to_dict(orient="records")
# [{"pclass": "1st", "age": 29.00, "sex": "female"}, {}]

dict = DictVectorizer(sparse=False)

x = dict.fit_transform(x.to_dict(orient="records"))

print(dict.get_feature_names())
print(x)

# 分割训练集合测试集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)

# 进行决策树的建立和预测
dc = DecisionTreeClassifier(max_depth=5)

dc.fit(x_train, y_train)

print("预测的准确率为：", dc.score(x_test, y_test))

return None

由于决策树类似一个树的结构，我们可以保存到本地显示

3.3 保存树的结构到dot文件
1、sklearn.tree.export_graphviz() 该函数能够导出DOT格式
tree.export_graphviz(estimator,out_file='tree.dot’,feature_names=[‘’,’’])
2、工具:(能够将dot文件转换为pdf、png)
安装graphviz
ubuntu:sudo apt-get install graphviz Mac:brew install graphviz
3、运行命令
然后我们运行这个命令
dot -Tpng tree.dot -o tree.png
export_graphviz(dc, out_file="./tree.dot", feature_names=[‘age’, ‘pclass=1st’, ‘pclass=2nd’, ‘pclass=3rd’, ‘女性’, ‘男性’])
4、 决策树总结
优点：
简单的理解和解释，树木可视化。
缺点：
决策树学习者可以创建不能很好地推广数据的过于复杂的树，这被称为过拟合。
改进：
减枝cart算法(决策树API当中已经实现，随机森林参数调优有相关介绍)
随机森林
注：企业重要决策，由于决策树很好的分析能力，在决策过程应用较多， 可以选择特征
集成学习方法之随机森林
学习目标
目标
说名随机森林每棵决策树的建立过程
知道为什么需要随机有放回(Bootstrap)的抽样
说明随机森林的超参数
应用
泰坦尼克号乘客生存预测
1、 什么是集成学习方法
集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。

2、 什么是随机森林
在机器学习中，随机森林是一个包含多个决策树的分类器，并且其输出的类别是由个别树输出的类别的众数而定。

随机森林

例如, 如果你训练了5个树, 其中有4个树的结果是True, 1个数的结果是False, 那么最终投票结果就是True

投票

3、 随机森林原理过程
学习算法根据下列算法而建造每棵树：

用N来表示训练用例（样本）的个数，M表示特征数目。
1、一次随机选出一个样本，重复N次， （有可能出现重复的样本）
2、随机去选出m个特征, m <<M，建立决策树
采取bootstrap抽样
3.1 为什么采用BootStrap抽样
为什么要随机抽样训练集？　　
如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的
为什么要有放回地抽样？
如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决。
3.2 API
class sklearn.ensemble.RandomForestClassifier(n_estimators=10, criterion=’gini’, max_depth=None, bootstrap=True, random_state=None, min_samples_split=2)

随机森林分类器
n_estimators：integer，optional（default = 10）森林里的树木数量120,200,300,500,800,1200
criteria：string，可选（default =“gini”）分割特征的测量方法
max_depth：integer或None，可选（默认=无）树的最大深度 5,8,15,25,30
max_features="auto”,每个决策树的最大特征数量
If “auto”, then max_features=sqrt(n_features).
If “sqrt”, then max_features=sqrt(n_features) (same as “auto”).
If “log2”, then max_features=log2(n_features).
If None, then max_features=n_features.
bootstrap：boolean，optional（default = True）是否在构建树时使用放回抽样
min_samples_split:节点划分最少样本数
min_samples_leaf:叶子节点的最小样本数
超参数：n_estimator, max_depth, min_samples_split,min_samples_leaf
3.3 代码

随机森林去进行预测

rf = RandomForestClassifier()

param = {“n_estimators”: [120,200,300,500,800,1200], “max_depth”: [5, 8, 15, 25, 30]}

超参数调优

gc = GridSearchCV(rf, param_grid=param, cv=2)

gc.fit(x_train, y_train)

print(“随机森林预测的准确率为：”, gc.score(x_test, y_test))
4、总结
在当前所有算法中，具有极好的准确率
能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维
能够评估各个特征在分类问题上的重要性
回归与聚类算法
说明线性回归的原理
应用LinearRegression或SGDRegressor实现回归预测
记忆回归算法的评估标准及其公式
说明线性回归的缺点
说明过拟合与欠拟合的原因以及解决方法
说明岭回归的原理即与线性回归的不同之处
说明正则化对于权重参数的影响
说明L1和L2正则化的区别
说明逻辑回归的原理
知道逻辑回归的应用场景
说明分类(主要针对二分类)问题的评估标准
应用classification_report实现精确率、召回率计算
应用roc_auc_score实现指标计算
应用joblib实现模型的保存与加载
说明K-means算法原理
说明K-means的性能评估标准轮廓系数
说明K-means的优缺点
线性回归
学习目标
目标
记忆线性回归的原理过程
应用LinearRegression或SGDRegressor实现回归预测
记忆回归算法的评估标准及其公式
应用
波士顿房价预测
回忆一下回归问题的判定是什么？
1、 线性回归的原理
1.1 线性回归应用场景
房价预测
销售额度预测
金融：贷款额度预测、利用线性回归以及系数分析因子和选股
销售额度

1.2 什么是线性回归
1.2.1定义与公式
线性回归(Linear regression)是利用回归方程(函数)对一个或多个自变量(特征值)和因变量(目标值)之间关系进行建模的一种分析方式。

特点：只有一个自变量的情况称为单变量回归，大于一个自变量情况的叫做多元回归
线性回归公式

那么怎么理解呢？我们来看几个例子

期末成绩：0.7×考试成绩+0.3×平时成绩
房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率
上面两个例子，我们看到特征值与目标值之间建立的一个关系，这个可以理解为回归方程。

1.2.2 线性回归的特征与目标的关系分析
线性回归当中的关系有两种，一种是线性关系，另一种是非线性关系。在这里我们只能画一个平面更好去理解，所以都用单个特征举例子。

线性关系
线性关系图

多变量线性关系

注释：如果在单特征与目标值的关系呈直线关系，或者两个特征与目标值呈现平面的关系

更高维度的我们不用自己去想，记住这种关系即可

非线性关系
非线性关系

注释：为什么会这样的关系呢？原因是什么？我们后面 讲解过拟合欠拟合重点介绍

如果是非线性关系，那么回归方程可以理解为：w1x1+w2x2^2+w3x32

2、线性回归的损失和优化原理（理解记忆）
假设刚才的房子例子，真实的数据之间存在这样的关系

真实关系：真实房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率
那么现在呢，我们随意指定一个关系（猜测）

随机指定关系：预测房子价格 = 0.25×中心区域的距离 + 0.14×城市一氧化氮浓度 + 0.42×自住房平均房价 + 0.34×城镇犯罪率
请问这样的话，会发生什么？真实结果与我们预测的结果之间是不是存在一定的误差呢？类似这样样子

误差

那么存在这个误差，我们将这个误差给衡量出来

2.1 损失函数
总损失定义为：

线性回归损失函数

y_i为第i个训练样本的真实值
h(x_i)为第i个训练样本特征值组合预测函数
又称最小二乘法
如何去减少这个损失，使我们预测的更加准确些？既然存在了这个损失，我们一直说机器学习有自动学习的功能，在线性回归这里更是能够体现。这里可以通过一些优化方法去优化（其实是数学当中的求导功能）回归的总损失！！！

2.2 优化算法
如何去求模型当中的W，使得损失最小？（目的是找到最小损失对应的W值）

线性回归经常使用的两种优化算法

正规方程
正规方程

理解：X为特征值矩阵，y为目标值矩阵。直接求到最好的结果

缺点：当特征过多过复杂时，求解速度太慢并且得不到结果

损失行数求解1

梯度下降(Gradient Descent)
梯度下降公式

理解：α为学习速率，需要手动指定（超参数），α旁边的整体表示方向

沿着这个函数下降的方向找，最后就能找到山谷的最低点，然后更新W值

使用：面对训练数据规模十分庞大的任务 ，能够找到较好的结果

我们通过两个图更好理解梯度下降的过程

单变量的梯度下降

多变量的梯度下降

所以有了梯度下降这样一个优化算法，回归就有了"自动学习"的能力

3、 线性回归API
sklearn.linear_model.LinearRegression(fit_intercept=True)
通过正规方程优化
fit_intercept：是否计算偏置
LinearRegression.coef_：回归系数
LinearRegression.intercept_：偏置
sklearn.linear_model.SGDRegressor(loss=“squared_loss”, fit_intercept=True, learning_rate =‘invscaling’, eta0=0.01)
通过使用SGD优化
loss:损失类型 *
fit_intercept：是否计算偏置
learning_rate : string, optional
学习率填充
‘constant’: eta = eta0
‘optimal’: eta = 1.0 / (alpha * (t + t0)) [default]
‘invscaling’: eta = eta0 / pow(t, power_t)
power_t=0.25:存在父类当中
SGDRegressor.coef_：回归系数
SGDRegressor.intercept_：偏置
sklearn提供给我们两种实现的API， 可以根据选择使用

4、波士顿房价预测
数据介绍
房价数据集介绍

属性

给定的这些特征，是专家们得出的影响房价的结果属性。我们此阶段不需要自己去探究特征是否有用，只需要使用这些特征。到后面量化很多特征需要我们自己去寻找

4.1 分析
回归当中的数据大小不一致，是否会导致结果影响较大。所以需要做标准化处理。同时我们对目标值也需要做标准化处理。

数据分割与标准化处理
回归预测
线性回归的算法效果评估
4.2 回归性能评估
均方误差(Mean Squared Error)MSE)评价机制：

线性回归评估

注：y^i为预测值，¯y为真实值

sklearn.metrics.mean_squared_error(y_true, y_pred)
均方误差回归损失
y_true:真实值
y_pred:预测值
return:浮点数结果
4.2 代码
def mylinearregression():
“”"
线性回归预测房子价格
:return:
“”"
lb = load_boston()
#
# print(lb.data)
#
# print(lb.target)

# 对数据集进行划分
x_train, x_test, y_train, y_test = train_test_split(lb.data, lb.target, test_size=0.3, random_state=24)

# 需要做标准化处理对于特征值处理
std_x = StandardScaler()

x_train = std_x.fit_transform(x_train)
x_test = std_x.fit_transform(x_test)
# print(x_train)

# 对于目标值进行标准化
std_y = StandardScaler()

y_train = std_y.fit_transform(y_train)
y_test = std_y.transform(y_test)
# print(y_train)
# y_test = std_y.inverse_transform(y_train)
# print(y)

y_test = std_y.inverse_transform(y_test)

# 使用线性模型进行预测
# 使用正规方程求解
lr = LinearRegression()
# # 此时在干什么？
lr.fit(x_train, y_train)

y_lr_predict = std_y.inverse_transform(lr.predict(x_test))

print(lr.coef_)

print("正规方程预测的结果为：", y_lr_predict)

print("正规方程的均方误差为：", mean_squared_error(y_test, y_lr_predict))

# 梯度下降进行预测
sgd = SGDRegressor()
#
sgd.fit(x_train, y_train)
print("SGD的权重参数为：", sgd.coef_)
#
y_sgd_predict = std_y.inverse_transform(sgd.predict(x_test))
#
print("SGD的预测的结果为：", y_sgd_predict)
#
# # 怎么评判这两个哪个好？
print("SGD的均方误差为：", mean_squared_error(y_test, y_sgd_predict))

return None

当我们尝试去修改学习率的时候

sgd = SGDRegressor(learning_rate=‘constant’, eta0=0.5)
可以看到效果会更好，此时我们可以通过调参数，找到学习率效果更好的值。

这里的案例数据比较简单，所以效果非常不错。可以在数据量、特征复杂的数据中进行测试

4.3 正规方程和梯度下降对比
正规方程和梯度下降对比

文字对比
梯度下降 正规方程
需要选择学习率 不需要
需要迭代求解 一次运算得出
特征数量较大可以使用 需要计算方程，时间复杂度高O(n3)
选择：
小规模数据：
LinearRegression(不能解决拟合问题)
岭回归
大规模数据：SGDRegressor
5、总结
线性回归的损失函数-均方误差
线性回归的优化方法
正规方程
梯度下降
线性回归的性能衡量方法-均方误差
sklearn的SGDRegressor API 参数
欠拟合与过拟合
学习目标
目标
说明线性回归（不带正则化）的缺点
说明过拟合与欠拟合的原因以及解决方法
应用
无
问题：训练数据训练的很好啊，误差也不大，为什么在测试集上面有问题呢？
当算法在某个数据集当中出现这种情况，可能就出现了过拟合现象。

1、 什么是过拟合与欠拟合
欠拟合
欠拟合

过拟合
过拟合

分析
第一种情况：因为机器学习到的天鹅特征太少了，导致区分标准太粗糙，不能准确识别出天鹅。
第二种情况：机器已经基本能区别天鹅和其他动物了。然后，很不巧已有的天鹅图片全是白天鹅的，于是机器经过学习后，会认为天鹅的羽毛都是白的，以后看到羽毛是黑的天鹅就会认为那不是天鹅。
1.1 定义
过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)
欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)
欠拟合过拟合图示

那么是什么原因导致模型复杂？线性回归进行训练学习的时候变成模型会变得复杂，这里就对应前面再说的线性回归的两种关系，非线性关系的数据，也就是存在很多无用的特征或者现实中的事物特征跟目标值的关系并不是简单的线性关系。
2、 原因以及解决办法
欠拟合原因以及解决办法
原因：学习到数据的特征过少
解决办法：增加数据的特征数量
过拟合原因以及解决办法
原因：原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点
解决办法：
正则化
在这里针对回归，我们选择了正则化。但是对于其他机器学习算法如分类算法来说也会出现这样的问题，除了一些算法本身作用之外（决策树、神经网络），我们更多的也是去自己做特征选择，包括之前说的删除、合并一些特征

模型复杂

如何解决？
正则化

在学习的时候，数据提供的特征有些影响模型复杂度或者这个特征的数据点异常较多，所以算法在学习的时候尽量减少这个特征的影响（甚至删除某个特征的影响），这就是正则化

注：调整时候，算法并不知道某个特征影响，而是去调整参数得出优化的结果

2.1 正则化类别
L2正则化
作用：可以使得其中一些W的都很小，都接近于0，削弱某个特征的影响
优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
Ridge回归
L1正则化
作用：可以使得其中一些W的值直接为0，删除这个特征的影响
LASSO回归
2.2 拓展-原理(了解)
线性回归的损失函数用最小二乘法，等价于当预测值与真实值的误差满足正态分布时的极大似然估计；岭回归的损失函数，是最小二乘法+L2范数，等价于当预测值与真实值的误差满足正态分布，且权重值也满足正态分布（先验分布）时的最大后验估计；LASSO的损失函数，是最小二乘法+L1范数，等价于等价于当预测值与真实值的误差满足正态分布，且且权重值满足拉普拉斯分布（先验分布）时的最大后验估计
线性回归的改进-岭回归
学习目标
目标
说明岭回归的原理即与线性回归的不同之处
说明正则化对于权重参数的影响
说明L1和L2正则化的区别
应用
波士顿房价预测
1、 带有L2正则化的线性回归-岭回归
岭回归，其实也是一种线性回归。只不过在算法建立回归方程时候，加上正则化的限制，从而达到解决过拟合的效果

1.1 API
sklearn.linear_model.Ridge(alpha=1.0)
具有l2正则化的线性回归
alpha:正则化力度，也叫 λ
λ取值：0~1 1~10
coef_:回归系数
sklearn.linear_model.RidgeCV(BaseRidgeCV, RegressorMixin)
具有l2正则化的线性回归，可以进行交叉验证
coef:回归系数
class _BaseRidgeCV(LinearModel):
def init(self, alphas=(0.1, 1.0, 10.0),
fit_intercept=True, normalize=False, scoring=None,
cv=None, gcv_mode=None,
store_cv_values=False):
1.2 观察正则化程度的变化，对结果的影响？
正则化力度

正则化力度越大，权重系数会越小
正则化力度越小，权重系数会越大
1.3 波士顿房价预测
rd = Ridge(alpha=1.0)

rd.fit(x_train, y_train)
print(“岭回归的权重参数为：”, rd.coef_)

y_rd_predict = std_y.inverse_transform(rd.predict(x_test))

print(“岭回归的预测的结果为：”, y_rd_predict)

print(“岭回归的均方误差为：”, mean_squared_error(y_test, y_rd_predict))
分类算法-逻辑回归与二分类
学习目标
目标
说明逻辑回归的损失函数
说明逻辑回归的优化方法
说明sigmoid函数
知道逻辑回归的应用场景
知道精确率、召回率指标的区别
知道F1-score指标说明召回率的实际意义
说明如何解决样本不均衡情况下的评估
了解ROC曲线的意义说明AUC指标大小
应用classification_report实现精确率、召回率计算
应用roc_auc_score实现指标计算
应用
癌症患者预测
逻辑回归（Logistic Regression）是机器学习中的一种分类模型，逻辑回归是一种分类算法，虽然名字中带有回归，但是它与回归之间有一定的联系。由于算法的简单和高效，在实际中应用非常广泛。

1、逻辑回归的应用场景
广告点击率
是否为垃圾邮件
是否患病
金融诈骗
虚假账号
看到上面的例子，我们可以发现其中的特点，那就是都属于两个类别之间的判断。逻辑回归就是解决二分类问题的利器

2、 逻辑回归的原理
2.1 输入
逻辑回归输入

逻辑回归的输入就是一个线性回归的结果。

2.2 激活函数
sigmoid函数
sigmoid公式

分析
回归的结果输入到sigmoid函数当中
输出结果：[0, 1]区间中的一个概率值，默认为0.5为阈值
逻辑回归最终的分类是通过属于某个类别的概率值来判断是否属于某个类别，并且这个类别默认标记为1(正例),另外的一个类别会标记为0(反例)。（方便损失计算）

输出结果解释(重要)：假设有两个类别A，B，并且假设我们的概率值为属于A(1)这个类别的概率值。现在有一个样本的输入到逻辑回归输出结果0.6，那么这个概率值超过0.5，意味着我们训练或者预测的结果就是A(1)类别。那么反之，如果得出结果为0.3那么，训练或者预测结果就为B(0)类别。
所以接下来我们回忆之前的线性回归预测结果我们用均方误差衡量，那如果对于逻辑回归，我们预测的结果不对该怎么去衡量这个损失呢？我们来看这样一张图
逻辑回归运算过程

那么如何去衡量逻辑回归的预测结果与真实结果的差异呢？

2.3 损失以及优化
2.3.1 损失
逻辑回归的损失，称之为对数似然损失，公式如下：

分开类别：
单个对数似然损失

怎么理解单个的式子呢？这个要根据log的函数图像来理解

单个损失解释

综合完整损失函数
完整对数似然损失

看到这个式子，其实跟我们讲的信息熵类似。

接下来我们呢就带入上面那个例子来计算一遍，就能理解意义了。

损失计算过程

我们已经知道，log§, P值越大，结果越小，所以我们可以对着这个损失的式子去分析

2.3.2 优化
同样使用梯度下降优化算法，去减少损失函数的值。这样去更新逻辑回归前面对应算法的权重参数，提升原本属于1类别的概率，降低原本是0类别的概率。

拓展-关于逻辑回归的损失和线性回归的损失优化问题
均方误差这种损失函数，是一定能够通过梯度下降找到最优解。

3、逻辑回归API
sklearn.linear_model.LogisticRegression(solver=‘liblinear’, penalty=‘l2’, C = 1.0)
solver:优化求解方式（默认开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数）
sag：随机平均梯度下降
penalty：正则化的种类
C：正则化力度
默认将类别数量少的当做正例

4、 案例：癌症分类预测-良／恶性乳腺癌肿瘤预测
数据介绍
癌症数据

原始数据的下载地址：https://archive.ics.uci.edu/ml/machine-learning-databases/

数据描述

（1）699条样本，共11列数据，第一列用语检索的id，后9列分别是与肿瘤

相关的医学特征，最后一列表示肿瘤类型的数值。

（2）包含16个缺失值，用”?”标出。

4.1 分析
缺失值处理
标准化处理
逻辑回归预测
4.2 代码
def logisticregression():
“”"
逻辑回归进行癌症预测
:return: None
“”"
# 1、读取数据，处理缺失值以及标准化
column_name = [‘Sample code number’, ‘Clump Thickness’, ‘Uniformity of Cell Size’, ‘Uniformity of Cell Shape’,
‘Marginal Adhesion’, ‘Single Epithelial Cell Size’, ‘Bare Nuclei’, ‘Bland Chromatin’,
‘Normal Nucleoli’, ‘Mitoses’, ‘Class’]

data = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data",
                   names=column_name)

# 删除缺失值
data = data.replace(to_replace='?', value=np.nan)

data = data.dropna()

# 取出特征值
x = data[column_name[1:10]]

y = data[column_name[10]]

# 分割数据集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3)

# 进行标准化
std = StandardScaler()

x_train = std.fit_transform(x_train)

x_test = std.transform(x_test)

# 使用逻辑回归
lr = LogisticRegression()

lr.fit(x_train, y_train)

print("得出来的权重：", lr.coef_)

# 预测类别
print("预测的类别：", lr.predict(x_test))

# 得出准确率
print("预测的准确率:", lr.score(x_test, y_test))
return None

在很多分类场景当中我们不一定只关注预测的准确率！！！！！

手机评判好坏

比如以这个癌症举例子！！！我们并不关注预测的准确率，而是关注在所有的样本当中，癌症患者有没有被全部预测（检测）出来。

5、分类的评估方法
5.1 精确率与召回率
5.1.1混淆矩阵
在分类任务下，预测结果(Predicted Condition)与正确标记(True Condition)之间存在四种不同的组合，构成混淆矩阵(适用于多分类)

混淆矩阵

5.1.2 精确率(Precision)与召回率(Recall)
精确率：预测结果为正例样本中真实为正例的比例（了解）
精确率

召回率：真实为正例的样本中预测结果为正例的比例（查的全，对正样本的区分能力）
召回率

那么怎么更好理解这个两个概念

精确率与召回率理解

还有其他的评估标准，F1-score，反映了模型的稳健型

F1

5.1.3 分类评估报告API
sklearn.metrics.classification_report(y_true, y_pred, labels=[], target_names=None )
y_true：真实目标值
y_pred：估计器预测目标值
labels:指定类别对应的数字
target_names：目标类别名称
return：每个类别精确率与召回率
print(“精确率和召回率为：”, classification_report(y_test, lr.predict(x_test), labels=[2, 4], target_names=[‘良性’, ‘恶性’]))
假设这样一个情况，如果99个样本癌症，1个样本非癌症，不管怎样我全都预测正例(默认癌症为正例),准确率就为99%但是这样效果并不好，这就是样本不均衡下的评估问题

问题：如何衡量样本不均衡下的评估？
5.2 ROC曲线与AUC指标
5.2.1 知道TPR与FPR
TPR = TP / (TP + FN)
所有真实类别为1的样本中，预测类别为1的比例
FPR = FP / (FP + FN)
所有真实类别为0的样本中，预测类别为1的比例
5.2.2 ROC曲线
ROC曲线的横轴就是FPRate，纵轴就是TPRate，当二者相等时，表示的意义则是：对于不论真实类别是1还是0的样本，分类器预测为1的概率是相等的，此时AUC为0.5
ROC

5.2.3AUC指标
AUC的概率意义是随机取一对正负样本，正样本得分大于负样本的概率
AUC的最小值为0.5，最大值为1，取值越高越好
AUC=1，完美分类器，采用这个预测模型时，不管设定什么阈值都能得出完美预测。绝大多数预测的场合，不存在完美分类器。
0.5<AUC<1，优于随机猜测。这个分类器（模型）妥善设定阈值的话，能有预测价值。
AUC=0.5，跟随机猜测一样（例：丢铜板），模型没有预测价值。
AUC<0.5，比随机猜测还差；但只要总是反预测而行，就优于随机猜测，因此不存在 AUC<0.5 的情况。
最终AUC的范围在[0.5, 1]之间，并且越接近1越好

5.2.4 AUC计算API
from sklearn.metrics import roc_auc_score
sklearn.metrics.roc_auc_score(y_true, y_score)
计算ROC曲线面积，即AUC值
y_true:每个样本的真实类别，必须为0(反例),1(正例)标记
y_score:每个样本预测的概率值

0.5~1之间，越接近于1约好

y_test = np.where(y_test > 2.5, 1, 0)

print(“AUC指标：”, roc_auc_score(y_test, lr.predict(x_test)))
5.2.5、总结
AUC只能用来评价二分类
AUC非常适合评价样本不平衡中的分类器性能
AUC会比较预测出来的概率，而不仅仅是标签类
6、Scikit-learn的算法实现总结
scikit-learn把梯度下降求解的单独分开，叫SGDclassifier和SGDRegressor，他们的损失都是分类和回归对应的损失，比如分类：有log loss, 和 hingle loss(SVM)的，回归如：比如 均方误差, 其它的API是一样的损失，求解并不是用梯度下降的，所以一般大规模的数据都是用scikit-learn其中SGD的方式求解
模型保存和加载
学习目标
目标
应用joblib实现模型的保存与加载
应用
无
当训练或者计算好一个模型之后，那么如果别人需要我们提供结果预测，就需要保存模型（主要是保存算法的参数）

1、sklearn模型的保存和加载API
from sklearn.externals import joblib
保存：joblib.dump(rf, ‘test.pkl’)
加载：estimator = joblib.load(‘test.pkl’)
2、线性回归的模型保存加载案例
保存

使用线性模型进行预测

使用正规方程求解

lr = LinearRegression()

此时在干什么？

lr.fit(x_train, y_train)

保存训练完结束的模型

joblib.dump(lr, “test.pkl”)
加载

通过已有的模型去预测房价

model = joblib.load(“test.pkl”)
print(“从文件加载进来的模型预测房价的结果：”, std_y.inverse_transform(model.predict(x_test)))
无监督学习-K-means算法
学习目标
目标
说明K-means算法原理
说明K-means的性能评估标准轮廓系数
说明K-means的优缺点
应用
instacart用户聚类
回忆非监督学习的特点？
1、 什么是无监督学习
人员聚类

一家广告平台需要根据相似的人口学特征和购买习惯将美国人口分成不同的小组，以便广告客户可以通过有关联的广告接触到他们的目标客户。
Airbnb 需要将自己的房屋清单分组成不同的社区，以便用户能更轻松地查阅这些清单。
一个数据科学团队需要降低一个大型数据集的维度的数量，以便简化建模和降低文件大小。
我们可以怎样最有用地对其进行归纳和分组？我们可以怎样以一种压缩格式有效地表征数据？这都是无监督学习的目标，之所以称之为无监督，是因为这是从无标签的数据开始学习的。

2、 无监督学习包含算法
聚类
K-means(K均值聚类)
降维
PCA
3、 K-means原理
我们先来看一下一个K-means的聚类效果图

K-means如何聚类效果

3.1 K-means聚类步骤
1、随机设置K个特征空间内的点作为初始的聚类中心
2、对于其他每个点计算到K个中心的距离，未知的点选择最近的一个聚类中心点作为标记类别
3、接着对着标记的聚类中心之后，重新计算出每个聚类的新中心点（平均值）
4、如果计算得出的新中心点与原中心点一样，那么结束，否则重新进行第二步过程
我们以一张图来解释效果

K-means过程分析

4、K-meansAPI
sklearn.cluster.KMeans(n_clusters=8,init=‘k-means++’)
k-means聚类
n_clusters:开始的聚类中心数量
init:初始化方法，默认为’k-means ++’
labels_:默认标记的类型，可以和真实值比较（不是值比较）
5、 案例：k-means对Instacart Market用户聚类
5.1 分析
1、降维之后的数据
2、k-means聚类
3、聚类结果显示
5.2 代码

取500个用户进行测试

cust = data[:500]
km = KMeans(n_clusters=4)
km.fit(cust)
pre = km.predict(cust)
问题：如何去评估聚类的效果呢？
6、Kmeans性能评估指标
6.1 轮廓系数
轮廓系数公式

注：对于每个点i 为已聚类数据中的样本 ，b_i 为i 到其它族群的所有样本的距离最小值，a_i 为i 到本身簇的距离平均值。最终计算出所有的样本点的轮廓系数平均值

6.2 轮廓系数值分析

分析过程（我们以一个蓝1点为例）

1、计算出蓝1离本身族群所有点的距离的平均值a_i

2、蓝1到其它两个族群的距离计算出平均值红平均，绿平均，取最小的那个距离作为b_i

根据公式：极端值考虑：如果b_i >>a_i: 那么公式结果趋近于1；如果a_i>>>b_i: 那么公式结果趋近于-1
6.3 结论
如果b_i>>a_i:趋近于1效果越好， b_i<<a_i:趋近于-1，效果不好。轮廓系数的值是介于 [-1,1] ，越趋近于1代表内聚度和分离度都相对较优。

6.4 轮廓系数API
sklearn.metrics.silhouette_score(X, labels)
计算所有样本的平均轮廓系数
X：特征值
labels：被聚类标记的目标值
6.5 用户聚类结果评估
silhouette_score(cust, pre)
7、K-means总结
特点分析：采用迭代式算法，直观易懂并且非常实用
缺点：容易收敛到局部最优解(多次聚类)
注意：聚类一般做在分类之前