机器学习基础笔记（自用）

目录

1.人工智能概述

1.1什么是机器学习

 1.2 数据集构成

1.3机器学习算法分类

目标值：类别（离散型数据） - 分类问题

 目标值：连续型数据 - 回归问题

 目标值： 无 - 无监督学习

 总结：

1.4机器学习的开发流程

1.5 学习框架和资料介绍

 1.5.1 机器学习库、框架参考书籍

 2.数据集      

​  

2.1学习阶段可用的数据集

 1 Scikit-learn工具介绍

2.安装sklearn

2.2 sklearn数据集

1.scikit-learn数据集API介绍

 2.sklearn小数据集

3 sklearn大数据集 

4 sklearn数据集的使用 

 2.3数据集的划分

数据集划分api

3.特征工程

3.1什么是特征工程

3.2特征工程与数据处理比较

3.3特征抽取

1 将任意数据（如文本或图像）转换为可用于机器学习的数字特征---特征值化

 2.特征提取API特征提取API

3.3.1字典特征提取

3.1.2文本特征提取

3.1.3中文文本特征提取

1.jieba分词处理

3.1.4Tf-idf文本特征提取（选取更重要的词进行文本特征提取）

3.4特征预处理

 3.4.1什么是特征预处理

3.4.2归一化

 3.4.3标准化（相较于归一化受异常点的影响较小）

视频解释

3.5 特征降维

 3.5.1降维

3.5.2 降维的两种方式

 3.5.3 特征选择

 3.5.4主成分分析(PCA)

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

4.分类问题、分类算法

 4.1 sklearn转换器和估计器

4.1.1转换器---特征工程的父类

 4.1.2估计器（sklearn机器学习算法的实现）

 4.2 K-近邻算法（KNN算法）

4.2.1什么是k近邻算法

4.3模型选择与调优

 4.3.1交叉验证(cross validation)

4.3.2 超参数搜索-网格搜索(Grid Search)

4.3.3模型选择与调优API

 4.3.4鸢尾花案例增加交叉验证和网格搜索（k值调优）

4.4案例：Facebook签到位置预测K值调优

4.5朴素贝叶斯算法

 

 4.5.1 什么是朴素贝叶斯分类方法

​4.5.2 概率基础

 4.5.3贝叶斯公式&朴素贝叶斯公式

4.5.4拉普拉斯平滑系数 

例子：文章分类计算

 4.5.5 朴素贝叶斯算法API

 4.5.6案例：20类新闻分类

4.5.7朴素贝叶斯算法评价

4.6决策树

 4.6.1认识决策树

4.6.2信息论基础

 4.6.3决策树的三种算法实现​

 4.6.4 决策树API

4.6.7案例：泰坦尼克号乘客生存预测

4.6.8优缺点

4.7随机森林---决策树的改进

5. 回归与聚类算法

5.1线性回归

5.1.1线性回归的原理

 5.1.2 线性回归的损失和优化原理（理解记忆）

 5.1.3损失函数

 5.1.5线性回归API

5.1.6案例：波士顿房价预测（构建回归模型）

 5.1.7回归性能评估--均方误差&&均方误差API

 预估器调参：以获得不同的均方误差

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

5.1.9梯度下降优化方法---GD、SGD、SAG

5.2欠拟合与过拟合

5.2.1什么是过拟合与欠拟合

 5.2.2过拟合解决

5.2.3 带有L2正则化的线性回归-岭回归

 5.2.4观察正则化程度的变化，对结果的影响？

 5.2.5岭回归-波士顿房价预测

5.3分类算法-逻辑回归与二分类

 5.3.1逻辑回归的应用场景

 5.3.2逻辑回归的原理

5.3.3 损失以及优化

 ​

5.3.4逻辑回归API

5.3.5 案例：癌症分类预测-良／恶性乳腺癌肿瘤预测 

5.3.6分类的评估方法

1 精确率与召回率

5.3.7 ROC曲线与AUC指标------精确率和召回率评估更进一步在样本不均衡时使用

5.4 模型保存和加载

5.5.无监督学习-K-means算法

5.5.1、 什么是无监督学习

5.5.2、 无监督学习包含算法

 5.5.3 K-means原理

 5.5.4K-meansAPI

 5.5.5 案例：k-means对Instacart Market用户聚类

5.5.6Kmeans性能评估指标

---

1.人工智能概述

1.1什么是机器学习

机器学习是从 数据 中 自动分析获得 模型 ，并利用 模型 对未知数据进行 预测 。

从历史数据当中获得规律？这些历史数据是怎么的格式？ 

 1.2 数据集构成

结构：特征值+目标值

例子：房屋价格的预测

 注：

1.对于每一行数据我们可以称之为样本。

2.有些数据集可以没有目标值

1.3机器学习算法分类

目标值：类别（离散型数据） - 分类问题

 目标值：连续型数据 - 回归问题

 目标值： 无 - 无监督学习

 总结：

 

1.4机器学习的开发流程

 

1.5 学习框架和资料介绍

 1.5.1 机器学习库、框架参考书籍

 

 

 2.数据集      

  

2.1学习阶段可用的数据集

Kaggle网址：https://www.kaggle.com/datasets

UCI数据集网址： http://archive.ics.uci.edu/ml/

scikit-learn网址：http://scikit-learn.org/stable/datasets/index.html#datasets

 1 Scikit-learn工具介绍

Python语言的机器学习工具

Scikit-learn包括许多知名的机器学习算法的实现

Scikit-learn文档完善，容易上手，丰富的API

2.安装sklearn

pip install Scikit-learn

安装好之后可以通过以下命令查看是否安装成功

import sklearn

分类、聚类、回归

特征工程

模型选择、调优

2.2 sklearn数据集

1.scikit-learn数据集API介绍

 2.sklearn小数据集

3 sklearn大数据集 

4 sklearn数据集的使用 

 

字典两种获取属性的方式：

dict[key]=value

dict.key=value

 2.3数据集的划分

数据集划分api

 

 

3.特征工程

3.1什么是特征工程

特征工程是使用 专业背景知识和技巧处理数据 ， 使得特征能在机器学习算法上发挥更好的作用的过程 。

3.2特征工程与数据处理比较

pandas: 一个数据读取非常方便以及基本的处理格式的工具（数据清洗，数据处理）

sklearn: 对于特征的处理提供了强大的接口（特征工程）

特征工程包含内容：

3.3特征抽取

1 将任意数据（如文本或图像）转换为可用于机器学习的数字特征---特征值化

特征值化是为了计算机更好的去理解数据

 2.特征提取API特征提取API

sklearn . feature_extraction

3.3.1字典特征提取

 sparse=True返回的数值为稀疏矩阵形式：

这种形式便于显示特征值种类非常多时（矩阵显示0非常多）

 sparse=false 返回矩阵形式：

 1 应用

我们对以下数据进行特征提取

[{ 'city' : ' 北京 ' , 'temperature' : 100 }

{ 'city' : ' 上海 ' , 'temperature' : 60 }

{ 'city' : ' 深圳 ' , 'temperature' : 30 }]

 

 

3.1.2文本特征提取

stop_words将列表中的词不出现在特征名称中

 1 应用

 我们对以下数据进行特征提取

[ "life is short,i like python" ,

"life is too long,i dislike python" ]

 返回每句话中特征名称出现的次数：

3.1.3中文文本特征提取

英文默认是以空格分开的。其实就达到了一个分词的 效果 ，所以我们要对中文进行分词处理。

1.jieba分词处理

#分词函数
def cut_word(text):
    """ 对中文进行分词 "我爱北京天安门"————>"我 爱 北京 天安门"
    :param text: :return: text """
    textlist=list(jieba.cut(text))
    # print(" ".join(textlist))
    new_text=" ".join(textlist)
    #text = " ".join(list(jieba.cut(text)))
    return new_text

 2.特征提取

def count_chinese_demo():
    #中文文本特征抽取函数，自动分词
    data=["今天很残酷，明天更残酷，后天很美好， 但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
          " 我们看到的从很远星系来的光是在几百万年之前发出的， 这样当我们看到宇宙时，我们是在看它的过去。",
          " 如果只用一种方式了解某样事物，你就不会真正了解它。 了解事物真正含义的秘密取决于如何将其与"
          "我们所了解的事物相联系。"]
    #存储分词后的data
    text_list=[]
    #对列表的每个单元进行分词
    for i in data:
       # print(i)
        text_list.append(cut_word(i))
    print(text_list)
    # 1.实例一个转换器类
    transfer=CountVectorizer(stop_words=[])
    # 2.调用转换方法fit_transform
    data_new=transfer.fit_transform(text_list)
    print("new_data:\n", data_new.toarray())
    print("特征名称：\n", transfer.get_feature_names())
    return None

运行结果：

3.1.4Tf-idf文本特征提取（选取更重要的词进行文本特征提取）

1.公式

 例子：

 2.TF-IDF的特征提取API

3.特征提取函数

def tfidf_demo():
    """
    用TF-IDF进行文本特征提取（选取更为关键的特征词进行提取）
    :return:
    """
    data = ["今天很残酷，明天更残酷，后天很美好， 但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
            " 我们看到的从很远星系来的光是在几百万年之前发出的， 这样当我们看到宇宙时，我们是在看它的过去。",
            " 如果只用一种方式了解某样事物，你就不会真正了解它。 了解事物真正含义的秘密取决于如何将其与"
            "我们所了解的事物相联系。"]
    # 特征名称列表
    text_list = []
    # 对列表的每个单元进行分词
    for i in data:
        # print(i)
        text_list.append(cut_word(i))
    print(text_list)
    transfer=TfidfVectorizer()
    new_data=transfer.fit_transform(text_list)
    print("new_data；\n",new_data.toarray())
    print("特征名称：\n",transfer.get_feature_names())
    return None

 4.输出内容

3.4特征预处理

 3.4.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 包含内容

2 特征预处理API 

sklearn.preprocessing

3.4.2归一化

 1 定义

通过对原始数据进行变换把数据映射到(默认为[0,1])之间。

2 公式

 

 示例：计算特征1第一个数据90的X''

 3 API

4 数据计算

 我们对以下数据进行运算:

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

 运行结果：

5 归一化总结

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

怎么办？

 3.4.3标准化（相较于归一化受异常点的影响较小）

1 定义

通过对原始数据进行变换把数据变换到均值为 0, 标准差为 1 范围内。( 使得数据变得更为平均一些 )

2 公式

标准差：衡量集中程度或离散程度。

视频解释

 3 API

4 数据计算

def stand_demo():
    """
    标准化
    :return:
    """
    # 1.使用pandas库获取数据
    data = pd.read_csv("dating.txt")
    # pandas的iloc函数选取指定的行和列（此为选取全部行和前三列）
    data = data.iloc[:, :3]
    print("data\n", data)
    # 2.实例化一个转换器类
    transfer = StandardScaler()
    # 3.调用fit_transform对数据进行归一化
    new_data = transfer.fit_transform(data)
    print("new_data:\n", new_data)
    return None

 5.输出（数据处在均值为零，标准差为一）

 6 标准化总结

在已有样本足够多的情况下比较稳定，适合现代嘈杂大数据场景。

3.5 特征降维

 3.5.1降维

降维 是指在某些限定条件下， 降低随机变量 ( 特征 ) 个数 ，得到 一组 “ 不相关 ” 主变量 的过程。

3.5.2 降维的两种方式

 3.5.3 特征选择

1 定义

数据中包含 冗余或无关变量（或称特征、属性、指标等） ，旨在从 原有特征中找出主要特征 。

2 方法

 3 模块

sklearn . feature_selection

4 过滤式

4.1 低方差特征过滤

 4.1.1 API

删除方差小于2的数据：

def variance_demo():
    """
    过滤低方差特征
    :return:
    """
    data=pd.read_csv("factor_returns.csv")
    data=data.iloc[:,1:-2]
    print("data:\n",data)
    # 2.实例化一个转换器类
    transfer=VarianceThreshold(threshold=2)
    # 3.调用fit_transform对数据进行归一化
    data_new=transfer.fit_transform(data)
    print("data_new:\n",data_new,data_new.shape)
    return None

输出示例：删除了一行。

4.2 相关系数 

 4.2.1 公式计算案例

 

                                                                   = 0.9942

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

4.2.2  特点

 4.2.3 API

        安装 ：

 4.2.4 案例：股票的财务指标相关性计算

我们刚才的股票的这些指标进行相关性计算， 假设我们以

factor =

[ 'pe_ratio' , 'pb_ratio' , 'market_cap' , 'return_on_asset_net_profit' , 'du_return_on_e

quity' , 'ev' , 'earnings_per_share' , 'revenue' , 'total_expense' ]

 两两特征之间进行相关性计算：

运行结果：

from scipy.stats import pearsonr



def variance_demo():
    """
    过滤低方差特征&&&计算两两特征之间进行相关性
    :return:
    """
    data=pd.read_csv("factor_returns.csv")
    data=data.iloc[:,1:-2]
    print("data:\n",data)
    #1.删除方差小于2的列
    transfer=VarianceThreshold(threshold=2)
    data_new=transfer.fit_transform(data)
    print("data_new:\n",data_new,data_new.shape)
    #2.计算两两特征之间进行相关性
    r1=pearsonr(data['pe_ratio'],data['pb_ratio'])
    print("相关系数：\n",r1)
    r2=pearsonr(data['revenue'],data['total_expense'])
    print("revenue和total_expense的相系数：\n",r2)
    return None

 输出：

 指标revenue与指标total_expense之间的相关性大小为0.995845，很高我们也可以通过画图来观察结果，使用python绘画库matplotlib来展示。

这两对指标之间的相关性较大，可以做之后的处理，比如合成这两个指标。

 3.5.4主成分分析(PCA)

 1 计算案例理解

假设对于给定5个点，数据如下

(-1,-2)

(-1, 0)

( 0, 0)

( 2, 1)

( 0, 1)

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

 

 2.API

 3 数据计算

先拿个简单的数据计算一下

输出结果：

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

 

4.分类问题、分类算法

区别分类问题：目标值为类别。

内容：

 4.1 sklearn转换器和估计器

4.1.1转换器---特征工程的父类

之前做特征工程的步骤：

 

 这三个方法的联系，例子：

 4.1.2估计器（sklearn机器学习算法的实现）

在sklearn中，估计器(estimator)是一个重要的角色，分类算法、回归算法、无监督学习的一系列算法都继承自估计器（estimator）类。

 1. sklearn估计器工作流程

 4.2 K-近邻算法（KNN算法）

4.2.1什么是k近邻算法

 1 定义

 

 想要知道自己所在哪个区，只需知道离自己最近的人的位置，那个人所在的区就极大可能是我所在的区。你的“邻居”来推断出你的类别。

2、电影类型分析

 

 3、K-近邻算法API

 

 4.案例一：鸢尾花种类预测

操作步骤： 

 代码实现：

输出结果：

 优缺点：

4.3模型选择与调优

内容

 4.3.1交叉验证(cross validation)

交叉验证目的： 为了让被评估的模型更加准确可信

 什么是交叉验证：

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

例子：4折交叉验证

 问题：那么这个只是对于参数得出更好的结果，那么怎么选择或者调优参数呢？

4.3.2 超参数搜索-网格搜索(Grid Search)

通常情况下， 有很多参数是需要手动指定的（如 k- 近邻算法中的 K 值），这种叫超参数 。但是手动过程繁杂，所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数 组合建立模型。

4.3.3模型选择与调优API

 4.3.4鸢尾花案例增加交叉验证和网格搜索（k值调优）

修改后：

def knn_iris_gscv():
    """
    用knn算法对鸢尾花进行分类
    改进：
    1）使用交叉验证(cross validation)得出更准确结果
    2）K值选择使用超参数搜索-网格搜索(Grid Search)，优化k值选择
    :return:
    # """
    # 1）获取数据
    iris = load_iris()
    # 2）数据集划分
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.25,random_state=6)
    # 3）特征工程# 标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    #测试集也而要标准化
    #在训练集中已经求得了平均值和标准差（fit()方法），要使得训练集和测试集对数据的处理一致，
    # 因此使用训练集的平均值和标准差。
    x_test=transfer.transform(x_test)
    # 4）KNN预估器流程   n_neighbors=3表示k值取3
    #参数准备（k值列表）
    estimator=KNeighborsClassifier()
    # 加入网格搜索和交叉验证
    parm_dict = {'n_neighbors': [1, 3, 5, 7, 9, 11]}
    estimator=GridSearchCV(estimator,param_grid=parm_dict,cv=10)
    estimator.fit(x_train,y_train)
    # 5）模型评估
    # 方法1：直接比对真实值和预测值
    y_predict=estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("比对真实值和预测值：\n",y_predict==y_test)
    # 方法2:计算准确率
    score=estimator.score(x_test,y_test)
    print("准确率为：\n",score)
    # 最佳参数：best_params_
    print("最佳参数：\n",estimator.best_params_)
    # 最佳结果：best_score_
    print("最佳结果：\n",estimator.best_score_)
    # 最佳预估器：best_estimator_
    print("最佳预估器：\n",estimator.best_estimator_)
    # 交叉验证结果：cv_results_
    print("交叉验证结果：\n",estimator.cv_results_)
    return None

    运行结果：

y_predict:
 [0 2 0 0 2 1 2 0 2 1 2 1 2 2 1 1 2 1 1 0 0 2 0 0 1 1 1 2 0 1 0 1 0 0 1 2 1
 2]
比对真实值和预测值：
 [ True  True  True  True  True  True  True  True  True  True  True  True
  True  True  True False  True  True  True  True  True  True  True  True
  True  True  True  True  True  True  True  True  True  True False  True
  True  True]
准确率为：
 0.9473684210526315
最佳参数：
 {'n_neighbors': 11}
最佳结果：
 0.9734848484848484
最佳预估器：
 KNeighborsClassifier(n_neighbors=11)
交叉验证结果：
 {'mean_fit_time': array([0.00059831, 0.00059786, 0.00059869, 0.00029881, 0.00060213,
       0.00049853]), 'std_fit_time': array([0.00048852, 0.00048815, 0.00048883, 0.00045644, 0.00049194,
       0.00049853]), 'mean_score_time': array([0.00109718, 0.00119801, 0.00109665, 0.00110698, 0.00099375,
       0.00119359]), 'std_score_time': array([0.00029994, 0.00059937, 0.00029797, 0.00031232, 0.00043974,
       0.00040174]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9, 11],
             mask=[False, False, False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([1., 1., 1., 1., 1., 1.]), 'split1_test_score': array([0.91666667, 0.91666667, 1.        , 0.91666667, 0.91666667,
       0.91666667]), 'split2_test_score': array([1., 1., 1., 1., 1., 1.]), 'split3_test_score': array([1.        , 1.        , 1.        , 1.        , 0.90909091,
       1.        ]), 'split4_test_score': array([1., 1., 1., 1., 1., 1.]), 'split5_test_score': array([0.90909091, 0.90909091, 1.        , 1.        , 1.        ,
       1.        ]), 'split6_test_score': array([1., 1., 1., 1., 1., 1.]), 'split7_test_score': array([0.90909091, 0.90909091, 0.90909091, 0.90909091, 1.        ,
       1.        ]), 'split8_test_score': array([1., 1., 1., 1., 1., 1.]), 'split9_test_score': array([0.90909091, 0.81818182, 0.81818182, 0.81818182, 0.81818182,
       0.81818182]), 'mean_test_score': array([0.96439394, 0.95530303, 0.97272727, 0.96439394, 0.96439394,
       0.97348485]), 'std_test_score': array([0.04365767, 0.0604591 , 0.05821022, 0.05965639, 0.05965639,
       0.05742104]), 'rank_test_score': array([5, 6, 2, 3, 3, 1])}

PS:KNN算法计算距离：

欧氏距离

曼哈顿距离（绝对值距离）

明可夫斯基距离(此是欧氏距离和曼哈顿距离的推广)

查看使用的距离公式;

 

4.4案例：Facebook签到位置预测K值调优

 

 为防止每次运行调试都需要重新加载数据，使用jupyter进行调试。

流程分析：
    1）获取数据
    2）数据处理
    目的：
        特征值 x
        目标值 y
        a.缩小数据范围
          2 < x < 2.5
          1.0 < y < 1.5（此处x、y为坐标）
        b.time -> 年月日时分秒
        c.过滤签到次数少的地点
        数据集划分
     3）特征工程：标准化
     4）KNN算法预估流程
     5）模型选择与调优
     6）模型评估

jupyter代码展示：

 

 

 

4.5朴素贝叶斯算法

 4.5.1 什么是朴素贝叶斯分类方法

根据概率预测类别。

4.5.2 概率基础

1. 概率 (Probability) 定义

 

2.条件概率与联合概率

   相互独立:
          P(A, B) = P(A)P(B) <=> 事件A与事件B相互独立。

 4.5.3贝叶斯公式&朴素贝叶斯公式

贝叶斯公式解释：

当输入x时，想根据贝叶斯公式求出x的所属类别，就需要知道，在各个类别的情况下出现x的概率，取出现X=x的最大概率对应的类别作为输出。

贝叶斯公司是逆概率公式，即求在第k个类别情况下出现X=x的概率，取最大值。

 

朴素？

        假设：特征与特征之间是相互独立

朴素贝叶斯算法：

        朴素 + 贝叶斯

 例子：

 

 

  朴素贝叶斯算法应用场景： 文本分类

                                              单词作为特征

                                             拉普拉斯平滑系数

4.5.4拉普拉斯平滑系数 

例子：文章分类计算

 4.5.5 朴素贝叶斯算法API

 4.5.6案例：20类新闻分类

 步骤：

 1）获取数据
 2）划分数据集
 3）特征工程
     文本特征抽取
 4）朴素贝叶斯预估器流程
 5）模型评估

代码展示：

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """
    # 1）获取数据
    news=fetch_20newsgroups(subset="all")
    # 2）划分数据集
    x_train,x_test,y_train,y_test=train_test_split(news.data,news.target)
    # 3）特征工程
    #     文本特征抽取
    transfer=TfidfVectorizer()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    # 4）朴素贝叶斯预估器流程(默认拉普拉斯平滑系数alpha=1)
    estimator=MultinomialNB()
    estimator.fit(x_train,y_train)
    # 5）模型评估
    #方法1：直接比对真实值和预测值
    y_predict=estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("直接比对真实值和与测试：\n",y_test==y_predict)
    #方法2：计算准确率
    score=estimator.score(x_test,y_test)
    print("准确率成为：\n",score)
    return None

结果：

y_predict:
 [ 6 14  7 ...  3 12 15]
直接比对真实值和与测试：
 [ True  True  True ...  True  True False]
准确率成为：
 0.8612054329371817

4.5.7朴素贝叶斯算法评价

4.6决策树

内容：

 4.6.1认识决策树

决策树思想的来源非常朴素，程序设计中的条件分支结构就是 if-then 结构，最早的决策树就是利用这类 结构分割数据的一种分类学习方法。

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

 如何高效的进行决策？

特征的先后顺序

例子：决策树分类原理详解

已知 四个特征值 预测 是否贷款给某个人？

先看房子 -> 再工作 -> 决定是否贷款               只看了两个特征
年龄 -> 信贷情况 -> 工作 -> 决定是否贷款         看了三个特征

4.6.2信息论基础

1）信息
香农说信息是：消除随机不定性的东西
小明 年龄 “我今年18岁” - 信息
小华 ”小明明年19岁” - 不是信息

2）信息的衡量 - 信息量 - 信息熵
    bit
    g(D,A) = H(D) - 条件熵H(D|A)

1. 信息熵的定义

信息和消除不确定性是相联系的

当我们得到的额外信息（球队历史比赛情况等等）越多的话，那么我们猜测的代价越小（猜测的不确定性减小）

问题： 回到我们前面的贷款案例，怎么去划分？可以利用当得知某个特征（比如是

否有房子）之后，我们能够减少的不确定性大小。越大我们可以认为这个特征很重

要。那怎么去衡量减少的不确定性大小呢？

2.决策树的划分依据之一------信息增益

特征A 对训练数据集 D 的 信息增益g(D,A) , 定义为集合 D 的信息熵 H(D) 与特征 A 给定条件下 D 的信息条件熵 H(D|A)之差，即公式为：

 

 

 4.6.3决策树的三种算法实现

 4.6.4 决策树API

 ​

4.6.5 案例：使用决策树对鸢尾花进行分类

def decision_iris():
    """
    使用决策树对鸢尾花进行分类
    :return:
    """
    # 1)获取数据
    iris=load_iris()
    # 2)划分数据集
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,random_state=22)
    # 3)决策树预估器
    estimator=DecisionTreeClassifier(criterion="entropy")
    estimator.fit(x_train,y_train)
    # 4)模型评估
    #方法1：直接比对真实值和预测值
    y_predict=estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("直接比对真实值和与测试：\n",y_test==y_predict)
    #方法2：计算准确率
    score=estimator.score(x_test,y_test)
    print("准确率成为：\n",score)
    return None

4.6.6 决策树可视化

1. API

保存树的结构到dot文件

 2.代码

3.对生成的.dot文件进行展示

据测试展示工具网址

4.6.7案例：泰坦尼克号乘客生存预测

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

 

流程分析：
    特征值 目标值
    1）获取数据
    2）数据处理
        缺失值处理
        特征值 -> 字典类型
    3）准备好特征值 目标值
    4）划分数据集
    5）特征工程：字典特征抽取
    6）决策树预估器流程
    7）模型评估

#划分数据集
from sklearn.model_selection import train_test_split
from  sklearn.tree import DecisionTreeClassifier,export_graphviz
import pandas as pd
from sklearn.feature_extraction import DictVectorizer


def decision_titanic():
    """
    决策树预测泰坦尼克获救的人
    :return:
    """
    # 1）获取数据
    path = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt"
    titanic = pd.read_csv(path)
    #筛选目标值和特征值
    x = titanic[["pclass", "age", "sex"]]
    y = titanic[["survived"]]
    # 2）数据处理
    # 缺失值处理
    x["age"].fillna(x["age"].mean(),inplace=True)
    # 特征值 -> 字典类型
    x=x.to_dict(orient="recorda")
    # 3）划分数据集
    x_train,x_text,y_train,y_test=train_test_split(x,y,random_state=22)
    # 4）特征工程：字典特征抽取
    transfer=DictVectorizer()
    x_train=transfer.fit_transform(x_train)
    x_text=transfer.transform(x_text)
    # 5）决策树预估器流程
    estimator=DecisionTreeClassifier(criterion="entropy",max_depth=8)
    estimator.fit(x_train,x_text)
    # 6）模型评估
    #方法1：直接对比真实值和预测值
    y_predict=estimator.predict(x_text)
    print("y_predict:\n", y_predict)
    print("直接比对真实值和与测试：\n", y_test == y_predict)
    #方法2：计算准确率
    score=estimator.score(x_text,y_test)
    print("准确率成为：\n", score)
    # 可视化决策树
    export_graphviz(estimator, out_file="titanic_tree.dot", feature_names=transfer.get_feature_names())
    return None

4.6.8优缺点

优点：

        简单的理解和解释，树木可视化。

缺点：

        决策树学习者可以创建不能很好地推广数据的过于复杂的树，这被称为过拟合。

改进：

        1)减枝cart 算法 ( 决策树 API 当中已经实现，随机森林参数调优有相关介绍 )

        2)随机森林

注：企业重要决策，由于决策树很好的分析能力，在决策过程应用较多， 可以选择特征

4.7随机森林---决策树的改进

1.、什么是集成学习方法

集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是 生成多个分类器 / 模型， 各自独立地学习和作出预测。这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。

2.、什么是随机森林

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

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

3 、 随机森林原理过程

4、 为什么采用BootStrap抽样

3-4总结：
训练集：
N个样本
特征值 目标值
M个特征
随机
    两个随机
        训练集随机 - N个样本中随机有放回的抽样N个
            bootstrap 随机有放回抽样
            [1, 2, 3, 4, 5]
            新的树的训练集
            [2, 2, 3, 1, 5]
        特征随机 - 从M个特征中随机抽取m个特征
            M >> m
            降维

 5、API

 6.示例

#随机森林
from sklearn.ensemble import RandomForestClassifier
#网格搜索、交叉验证
from sklearn.model_selection import GridSearchCV
def randomForest_demo():
    """
        随机森林
       :return:
       """
    # 1）获取数据
    path = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt"
    titanic = pd.read_csv(path)
    # 筛选目标值和特征值
    x = titanic[["pclass", "age", "sex"]]
    y = titanic[["survived"]]
    # 2）数据处理
    # 缺失值处理
    x["age"].fillna(x["age"].mean(), inplace=True)
    # 特征值 -> 字典类型
    x = x.to_dict(orient="recorda")
    # 3）划分数据集
    x_train, x_text, y_train, y_test = train_test_split(x, y, random_state=22)
    # 4）特征工程：字典特征抽取
    transfer = DictVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_text = transfer.transform(x_text)
    # 5）决策树预估器流程
    estimator=RandomForestClassifier()
    # 加入网格搜索和交叉验证
    parm_dict = {'n_estimators': [120,200,300,500,800,1200],
                 "max_depth": [5, 8, 15, 25, 30]}
    estimator = GridSearchCV(estimator, param_grid=parm_dict, cv=3)
    estimator.fit(x_train, y_train)
    # 5）模型评估
    # 方法1：直接比对真实值和预测值
    y_predict = estimator.predict(x_test)
    print("y_predict:\n", y_predict)
    print("比对真实值和预测值：\n", y_predict == y_test)
    # 方法2:计算准确率
    score = estimator.score(x_test, y_test)
    print("准确率为：\n", score)
    # 最佳参数：best_params_
    print("最佳参数：\n", estimator.best_params_)
    # 最佳结果：best_score_
    print("最佳结果：\n", estimator.best_score_)
    # 最佳预估器：best_estimator_
    print("最佳预估器：\n", estimator.best_estimator_)
    # 交叉验证结果：cv_results_
    print("交叉验证结果：\n", estimator.cv_results_)
    return None

7.总结

能够有效地运行在大数据集上，
处理具有高维特征的输入样本，而且不需要降维 

5. 回归与聚类算法

5.1线性回归

 回归问题：

         目标值 - 连续型的数据

5.1.1线性回归的原理

1.线性回归应用场景

2. 什么是线性回归 

1) 定义与公式

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

期末成绩 =  0.7× 考试成绩 +0.3× 平时成绩

房子价格 = 0.02× 中心区域的距离 + 0.04× 城市一氧化氮浓度 + (-0.12× 自住房平均房价 ) + 0.254× 城 镇犯罪率

上面两个例子， 我们看到特征值与目标值之间建立的一个关系，这个可以理解为 线性模型 。

2) 线性回归的特征与目标的关系分析

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

线性关系:

1.单个特征   y=kx+b

2.两个特征  y=w1x1+w2x2+b

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

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

非线性关系:

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

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

广义线性模型
    非线性关系？
    线性模型
        自变量一次
         y = w1x1 + w2x2 + w3x3 + …… + wnxn + b
        或参数一次
         y = w1x1 + w2x1^2 + w3x1^3 + w4x2^3 + …… + b

线性关系&线性模型
线性关系一定是线性模型
线性模型不一定是线性关系（参数一次高次方程也可是线性模型）

 5.1.2 线性回归的损失和优化原理（理解记忆）

假设刚才的房子例子，真实的数据之间存在这样的关系

真实关系：真实房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率

 那么现在呢，我们随意指定一个关系（猜测） 

随机指定关系：预测房子价格 = 0.25×中心区域的距离 + 0.14×城市一氧化氮浓度 + 0.42×自住房平均房价 + 0.34×城镇犯罪率

 请问这样的话，会发生什么？真实结果与我们预测的结果之间是不是存在一定的误差呢？类似这样样子

 

 那么存在这个误差，我们将这个误差给衡量出来----损失函数

 5.1.3损失函数

使用损失函数的目的是为了求得一组权重和偏置使得得出的损失函数结果最小，则确定这组权重和偏执确定的线性回归模型是最优的，用此线性模型预测输入数据。所以需要一种好的优化方法来快速得出最好的权重和偏执，所以引出下面的优化损失。

 优化损失：

1）正规方程---天才 - 直接求解W

 拓展：
                    1)一般方程求最小值  求导-》找极值
                        y = ax^2 + bx + c
                        y' = 2ax + b = 0
                        x = - b / 2a
                    2)多个自变量使用矩阵求导   求导结果=零 找最小值

根据此公式直接求多个特征值的损失函数的最小值（只求一个最小值就认为这个是最小值了）。

 

 线性代数逆矩阵：

                          a * b = 1
                          b = 1 / a = a ^ -1
                        A * B = E
                        [[1, 0, 0],
                        [0, 1, 0],
                        [0, 0, 1]]
                        B = A ^ -1

2）梯度下降---勤奋努力的普通人（试错、改进）

w为权重，每次迭代由上一步中的权重 - 右面的式子  得到新的权重。

 

 

 优化动态图演示：

 5.1.5线性回归API

5.1.6案例：波士顿房价预测（构建回归模型）

 

流程：
                    1）获取数据集
                    2）划分数据集
                    3）特征工程：
                        无量纲化 - 标准化
                    4）预估器流程
                        fit() --> 模型
                        coef_ intercept_
                    5）模型评估

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression,SGDRegressor

def linear1_demo():
    """

    :return:
    """
    # 1）获取数据集
    boston=load_boston()
    print("特征数量：\n",boston.data.shape)
    # 2）划分数据集
    x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target,random_state= 22)
    # 3）特征工程：
    #     无量纲化 - 标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    # 4）预估器流程
    # fit() --> 模型
    # coef_intercept_
    estimator=LinearRegression()
    estimator.fit(x_train,y_train)
    # 5）得出模型
    print("正规方程回归系数：\n",estimator.coef_)
    print("正规方程偏置：\n",estimator.intercept_)
    # 6) 模型评估

    return None


def linear2_demo():
    """

    :return:
    """
    # 1）获取数据集
    boston = load_boston()
    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)
    # 3）特征工程：
    #     无量纲化 - 标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4）预估器流程
    # fit() --> 模型
    # coef_intercept_
    estimator = SGDRegressor()
    estimator.fit(x_train, y_train)
    # 5）得出模型
    print("梯度下降回归系数：\n", estimator.coef_)
    print("梯度下降偏置：\n", estimator.intercept_)
    # 6) 模型评估

    return None

输出： 

特征数量：
 (506, 13)
正规方程回归系数：
 [-0.64817766  1.14673408 -0.05949444  0.74216553 -1.95515269  2.70902585
 -0.07737374 -3.29889391  2.50267196 -1.85679269 -1.75044624  0.87341624
 -3.91336869]
正规方程偏置：
 22.62137203166228
梯度下降回归系数：
 [-0.49685791  0.82945265 -0.44904987  0.77017342 -1.5905398   2.84740953
 -0.14191001 -3.04706359  1.49911167 -0.77102381 -1.68090541  0.90278836
 -3.87831614]
梯度下降偏置：
 [22.61379951]

 5.1.7回归性能评估--均方误差&&均方误差API

 梯度下降示例：

def linear2_demo():
    """

    :return:
    """
    # 1）获取数据集
    boston = load_boston()
    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)
    # 3）特征工程：
    #     无量纲化 - 标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4）预估器流程
    # fit() --> 模型
    # coef_intercept_
    estimator = SGDRegressor()
    estimator.fit(x_train, y_train)
    # 5）得出模型
    print("梯度下降回归系数：\n", estimator.coef_)
    print("梯度下降偏置：\n", estimator.intercept_)
    # 6) 模型评估===================================================
    y_predict = estimator.predict(x_test)
    print("预测房价：\n", y_predict)
    error = mean_squared_error(y_test, y_predict)
    print("梯度下降均方误差：\n", error)
    #==============================================================
    return None

输出： 

梯度下降偏置：
 [22.62725463]
预测房价：
 [28.33648346 31.64925471 21.45323971 32.73584022 20.23269316 19.06439937
 21.37468545 19.44983911 19.68487021 32.83818668 21.3746111  27.35382152
 15.61457037 19.96877171 37.02305785 18.68896562  9.52463014 18.63973978
 30.80512492 24.33326585 19.04586688 34.05742222 29.55234607 17.43110409
 34.85563544 26.53293355 34.38006123 27.3851111  19.10374887 15.70777825
 30.7920448  14.54128578 37.49094738  8.56553308 16.39938929 16.89607725
  7.63108939 19.83317127 40.55341756 29.19467967 25.29074762 17.81436972
 39.3018985   6.67786656 21.61211625 25.07435036 20.78287331 20.66842851
 17.06646181 26.29296984  9.63305316 27.20212435 30.67456302 16.65888048
  9.5380822  35.46054702 31.58345186 22.90472434 17.59026841 21.86963363
 23.67527921 23.98648824 20.36168555 38.2309461  25.68958611 19.68174375
 14.10640059  6.65001684 42.46830478 21.88643167 16.78651968 22.58417476
 40.88565056 21.74918887 36.88133169 27.18393984 21.79862869 20.80208214
 25.34151666 23.69078482 31.51947987 20.22878362 24.02004822 31.47077052
 27.24813849 20.88419774 29.1136252  21.98292327 26.75724321 18.85982568
 25.22917134 24.01079813 19.92125414 17.4902074  15.45073178 18.30723881
 24.60844512 16.72053076 20.7047491  26.80799486 20.7125933  17.94692741
 24.14462134 23.28156607 20.37128754 36.62051001 16.01721086 22.44081692
 32.69996248 33.7693516  20.57483253 26.06077218 23.18527011 17.71411771
 21.50225286 21.74546817 27.49591692 25.22522658 23.68445355 14.45388553
 15.58661742  3.64089337 29.26363916 20.65912385 22.3362939  28.09095789
 28.4010181 ]
梯度下降均方误差：
 21.141190509193216

 预估器调参：以获得不同的均方误差

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

sklearn指导如何选择分类方法 

5.1.9梯度下降优化方法---GD、SGD、SAG

1. GD

梯度下降(Gradient Descent)，原始的梯度下降法需要计算所有样本的值才能够得出梯度，计算量大，所以后面才有会一系列的改进。

2. SGD

3. SAG

5.2欠拟合与过拟合

5.2.1什么是过拟合与欠拟合

欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数

据，此时认为这个假设出现了欠拟合的现象。(学习到数据的特征过少， 模型过于简单)

解决：
    增加数据的特征数量

过拟合：个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好

地拟合数据，此时认为这个假设出现了过拟合的现象。 (模型过于复杂，训练集上表现得好，测试集上不好 - 过拟合 )原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点

解决：
    正则化
        L1
        损失函数 + λ惩罚项
        LASSO
        L2 更常用
        损失函数 + λ惩罚项
        Ridge - 岭回归

 

 5.2.2过拟合解决

正则化

在这里针对回归，我们选择了正则化。但是对于其他机器学习算法如分类算法来说也会出现这样的

问题，除了一些算法本身作用之外（决策树、神经网络），我们更多的也是去自己做特征选择，包

括之前说的删除、合并一些特征

 

解决：
    正则化
        L1
        损失函数 + λ惩罚项
        LASSO
        L2 更常用
        损失函数 + λ惩罚项
        Ridge - 岭回归

 正则化类别

可以看作新的损失函数，旧损失函数+惩罚项，在降低新损失函数的同时，必不可少的也把权重减少了，高次函数系数减少，回归模型就减少了过拟合。

？

 

5.2.3 带有L2正则化的线性回归-岭回归

岭回归，其实也是一种线性回归。只不过在算法建立回归方程时候，加上正则化的限制，从而达到解决过拟合的效果。

1.API

Ridge 方法相当于 SGDRegressor(penalty='l2', loss="squared_loss"), 只不过 SGDRegressor 实现了一个普通的随机梯度下降学习，推荐使用 Ridge( 实现了 SAG)

 5.2.4观察正则化程度的变化，对结果的影响？

 5.2.5岭回归-波士顿房价预测

from sklearn.datasets import load_boston
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LinearRegression,SGDRegressor,Ridge
from sklearn.metrics import mean_squared_error

def linear3_demo():
    """
    岭回归--波士顿房价预测
    :return:
    """
    # 1）获取数据集
    boston = load_boston()
    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(boston.data, boston.target, random_state=22)
    # 3）特征工程：
    #     无量纲化 - 标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 4）预估器流程
    # fit() --> 模型
    # coef_intercept_
    estimator = Ridge(alpha=0.1,max_iter=10000)
    estimator.fit(x_train, y_train)
    # 5）得出模型
    print("岭回归回归系数：\n", estimator.coef_)
    print("岭回归偏置：\n", estimator.intercept_)
    # 6) 模型评估===================================================
    y_predict = estimator.predict(x_test)
    print("预测房价：\n", y_predict)
    error = mean_squared_error(y_test, y_predict)
    print("岭回归均方误差：\n", error)
    #==============================================================
    return None

5.3分类算法-逻辑回归与二分类

逻辑回归（ Logistic Regression ）是机器学习中的一种分类模型，逻辑回归是一种分类算法，虽然名字中带有回归，但是它与回归之间有一定的联系。由于算法的简单和高效，在实际中应用非常广泛。

内容：

 5.3.1逻辑回归的应用场景

正例 / 反例

 5.3.2逻辑回归的原理

线型回归的输出 就是 逻辑回归 的 输入

1 输入

2 激活函数

1/(1 + e^(-x))  此处使用矩阵形式表示方程

5.3.3 损失以及优化

线性回归预测求误差使用最小二乘法或者均方误差，但在此处逻辑回归中预测值属于某个类别，显然不能用最小二乘法或者均方误差（预测结果都不是具体数值，而是所属的类别）

ps:   均方误差方程   =  (y_predict - y_true)平方和/总数

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

1.损失

 

横坐标预测值，纵坐标误差。

当需要预测数据真实值属于这个类别（y=1），预测值越接近1（横坐标），表明预测的误差越小（纵坐标越接近零）。

 

 

 2 优化

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

5.3.4逻辑回归API

5.3.5 案例：癌症分类预测-良／恶性乳腺癌肿瘤预测 

• 数据介绍

 

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

数据描述

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

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

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

流程分析：
    1）获取数据
        读取的时候加上names
    2）数据处理
        处理缺失值
    3）数据集划分
    4）特征工程：
        无量纲化处理-标准化
    5）逻辑回归预估器
    6）模型评估

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression

def cancer_demo():
    # 1）获取数据
    # 读取的时候加上names
    path="https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data"
    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(path,names=column_name)
    # 2）数据处理
    # 处理缺失值 1.替换-》np.nan  2.删除缺失样本(将替换了nan的项删除)
    data=data.replace(to_replace="?",value=np.nan)
    data.dropna(inplace=True)
    # 3）数据集划分
        #1.筛选特征值和目标值
    x=data.iloc[:,1:-1]
    y=data["Class"]
        #2.划分训练集和测试集
    x_train,x_test,y_train,y_test=train_test_split(x,y)
    # 4）特征工程：
    # 无量纲化处理 - 标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    # 5）逻辑回归预估器
    estimator=LogisticRegression()
    estimator.fit(x_train,y_train)
    # 6）模型评估
    #1.得出模型
    print("模型回归系数（权重）：/n",estimator.coef_)
    print("模型偏执：/n",estimator.intercept_)
    #2.模型评估
    y_predict=estimator.predict(x_test)
    #对比
    print("Y_predict：/n",y_predict)
    print("预测值和真实值对比/n",y_predict==y_test)
    score=estimator.score(x_test,y_test)
    print("准确率为/n",score)
    return None

5.3.6分类的评估方法

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

1 精确率与召回率

1)混淆矩阵

TP = True Possitive
FN = False Negative

2 精确率(Precision)与召回率(Recall)

精确率 真实所患癌症占预测结果的比例。
召回率 真是患癌症，能够被查得出来的概率（查得全不全）。

3 分类评估报告API

使用ROC曲线和AUC指标进行模型评估（上面这个小例子）：
准确率：99%
召回率：99/99 = 100%
精确率：99%
F1-score: 2*99%/ 199% = 99.497%
AUC:0.5   -----》 得出这是很差的模型
 TPR = 100%
  FPR = 1 / 1 = 100%

加入精确率和召回率分类评估后代码：

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
#逻辑回归分类评估API精确率和召回率
from sklearn.metrics import classification_report

def cancer_demo():
    # 1）获取数据
    # 读取的时候加上names
    path="https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data"
    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(path,names=column_name)
    # 2）数据处理
    # 处理缺失值 1.替换-》np.nan  2.删除缺失样本(将替换了nan的项删除)
    data=data.replace(to_replace="?",value=np.nan)
    data.dropna(inplace=True)
    # 3）数据集划分
        #1.筛选特征值和目标值
    x=data.iloc[:,1:-1]
    y=data["Class"]
        #2.划分训练集和测试集
    x_train,x_test,y_train,y_test=train_test_split(x,y)
    # 4）特征工程：
    # 无量纲化处理 - 标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    # 5）逻辑回归预估器
    estimator=LogisticRegression()
    estimator.fit(x_train,y_train)
    # 6）模型评估
    #1.得出模型
    print("模型回归系数（权重）：/n",estimator.coef_)
    print("模型偏执：/n",estimator.intercept_)
    #2.模型评估
    y_predict=estimator.predict(x_test)
    #对比
    print("Y_predict：/n",y_predict)
    print("预测值和真实值对比/n",y_predict==y_test)
    score=estimator.score(x_test,y_test)
    print("准确率为",score)
    report=classification_report(y_test,y_predict,labels=[2,4],target_names=["良性","恶行"])
    print("评估报告",report)
    return None

输出：

模型回归系数（权重）：/n [[1.17598079 0.16853151 0.83067016 0.97467652 0.24550186 1.14443806
  0.95259023 0.45232191 0.78382144]]
模型偏执：/n [-0.90875732]
Y_predict：/n [2 2 2 4 2 4 2 4 4 2 2 2 2 4 2 4 2 4 2 2 4 4 4 2 4 2 2 2 2 2 2 4 4 2 2 4 2
 2 2 2 4 2 4 2 2 2 2 4 4 2 4 2 2 2 4 2 2 2 4 2 2 2 2 2 2 2 2 2 2 4 2 2 4 4
 4 4 2 2 2 4 2 2 2 2 4 2 2 2 2 2 2 4 4 2 2 2 4 2 2 2 2 2 2 4 2 2 2 4 2 4 4
 2 4 4 2 4 4 2 2 2 2 4 2 2 2 2 2 2 4 2 4 4 2 2 4 4 2 2 2 2 2 2 2 2 2 4 4 4
 2 2 2 2 2 2 2 2 2 4 4 2 2 2 2 2 4 2 2 2 4 4 2]
预测值和真实值对比/n 0      True
527    True
687    True
603    True
78     True
       ... 
625    True
458    True
183    True
391    True
470    True
Name: Class, Length: 171, dtype: bool
准确率为 0.9766081871345029
评估报告               precision    recall  f1-score   support

          良性       0.97      0.99      0.98       116
          恶行       0.98      0.95      0.96        55

    accuracy                           0.98       171
   macro avg       0.98      0.97      0.97       171
weighted avg       0.98      0.98      0.98       171


Process finished with exit code 0

不管怎样我全都预测正例(默认癌症为正例) - 不负责任的模型

5.3.7 ROC曲线与AUC指标------精确率和召回率评估更进一步在样本不均衡时使用

1 知道TPR与FPR

TPR=召回率

2 ROC曲线 

 蓝色为ROC曲线，蓝色曲线以下的面积为AUC当计算出的AUC指标小于0.5，适合反向预测。

3 AUC计算API

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
#逻辑回归分类评估API精确率和召回率
from sklearn.metrics import classification_report
#ROC曲线和AUC指标进行预测
from sklearn.metrics import roc_auc_score

def cancer_demo():
    # 1）获取数据
    # 读取的时候加上names
    path="https://archive.ics.uci.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data"
    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(path,names=column_name)
    # 2）数据处理
    # 处理缺失值 1.替换-》np.nan  2.删除缺失样本(将替换了nan的项删除)
    data=data.replace(to_replace="?",value=np.nan)
    data.dropna(inplace=True)
    # 3）数据集划分
        #1.筛选特征值和目标值
    x=data.iloc[:,1:-1]
    y=data["Class"]
        #2.划分训练集和测试集
    x_train,x_test,y_train,y_test=train_test_split(x,y)
    # 4）特征工程：
    # 无量纲化处理 - 标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    # 5）逻辑回归预估器
    estimator=LogisticRegression()
    estimator.fit(x_train,y_train)
    # 6）模型评估
    #1.得出模型
    print("模型回归系数（权重）：/n",estimator.coef_)
    print("模型偏执：/n",estimator.intercept_)
    #2.模型评估
    y_predict=estimator.predict(x_test)
    #对比
    print("Y_predict：/n",y_predict)
    print("预测值和真实值对比/n",y_predict==y_test)
    score=estimator.score(x_test,y_test)
    print("准确率为",score)
    report=classification_report(y_test,y_predict,labels=[2,4],target_names=["良性","恶行"])
    print("评估报告",report)
    #使用ROC曲线和AUC指标衡量准确率（每个样本的真是类别，必须0-返例 1-正例）
    #将y_test转换成 0 1
    y_true=np.where(y_test>3,1,0)#y_test>3置为1，y_test<3置为0
    rocAuc_score=roc_auc_score(y_true,y_predict)
    print("ROC_AUC预测值：",rocAuc_score)

    return None

模型回归系数（权重）：/n [[1.15860225 0.31220656 0.55309848 0.75549063 0.20025917 1.27656328
  1.19340775 0.5485425  0.6603317 ]]
模型偏执：/n [-1.22017436]
Y_predict：/n [2 2 2 2 2 2 4 2 4 4 2 4 4 2 2 4 4 2 4 2 4 4 2 2 4 4 2 2 4 4 2 2 2 2 2 2 4
 4 4 2 2 2 2 2 4 4 4 2 2 2 2 2 2 2 2 2 2 2 4 4 2 2 2 2 4 2 4 2 2 2 4 2 4 4
 4 4 2 4 2 4 2 2 4 2 2 2 2 2 2 4 4 2 2 4 2 4 2 2 2 2 2 2 4 4 4 2 4 2 4 2 2
 2 2 2 4 2 4 2 2 2 2 4 2 2 2 2 4 4 4 2 4 2 4 2 4 2 2 2 2 4 4 2 2 2 2 2 2 2
 4 2 4 4 2 4 4 2 2 2 2 4 4 2 4 2 2 4 2 2 2 2 2]
预测值和真实值对比/n 362     True
554     True
525     True
687     True
101    False
       ...  
652     True
495     True
683     True
384     True
455    False
Name: Class, Length: 171, dtype: bool
准确率为 0.9590643274853801
评估报告               precision    recall  f1-score   support

          良性       0.95      0.98      0.97       107
          恶行       0.97      0.92      0.94        64

    accuracy                           0.96       171
   macro avg       0.96      0.95      0.96       171
weighted avg       0.96      0.96      0.96       171

ROC_AUC预测值： 0.9515917056074766

4、总结

• AUC只能用来评价二分类
• AUC非常适合评价样本不平衡中的分类器性能

5.4 模型保存和加载

当训练或者计算好一个模型之后，那么如果别人需要我们提供结果预测，就需要保存模型（主要是保存算法的参数）

1、sklearn模型的保存和加载API

    import joblib

joblib已从sklearn中删除了

dump函数第二个参数是模型保存的路径，后缀为.pkl。

 2、线性回归的模型保存加载案例

 # 5）逻辑回归预估器
    estimator=LogisticRegression()
    estimator.fit(x_train,y_train)
    #模型保存
    joblib.dump(estimator,"test.pkl")

   # # 5）逻辑回归预估器
    # estimator=LogisticRegression()
    # estimator.fit(x_train,y_train)
    # #模型保存
    # joblib.dump(estimator,"test.pkl")
    #模型加载（已经训练好了）
    estimator=joblib.load("test.pkl")

5.5.无监督学习-K-means算法

5.5.1、 什么是无监督学习

 

5.5.2、 无监督学习包含算法

 5.5.3 K-means原理

 1 K-means聚类步骤

 5.5.4K-meansAPI

 5.5.5 案例：k-means对Instacart Market用户聚类

#1. 获取数据
#2.合并表
#3.找到user_id和aisle之间的关系
#4.PCA降维
import pandas as pd

#1.获取数据
order_products=pd.read_csv("./instacart/order_products__prior.csv")
products=pd.read_csv("./instacart/products.csv")
orders=pd.read_csv("./instacart/orders.csv")
aisles=pd.read_csv("./instacart/aisles.csv")
#2.合并表
# 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

#合并aisles和products  aisle和product_id 放一起
tab1=pd.merge(aisles,products,on=["aisle_id","aisle_id"])
tab2=pd.merge(tab1,order_products,on=["product_id","product_id"])
tab3=pd.merge(tab2,orders,on=["order_id","order_id"])
#3.找到user_id和aisle之间的关系
#交叉表和透视表    此处使用交叉表
table=pd.crosstab(tab3["user_id"],tab3["aisle"])
#减少数据  快速运行
data=table[:10000]
#4.PCA降维
from  sklearn.decomposition import PCA
#1)实例化转换器类
transfer=PCA(n_components=0.95)
data_new=transfer.fit_transform(data)

#引入K-means预估器类
from sklearn.cluster import KMeans
estimator=KMeans(n_clusters=3)
#生成模型
estimator.fit(data_new)
#预测
y_predict=estimator.predict(data_new)
y_predict[0:200]

5.5.6Kmeans性能评估指标

1 轮廓系数--用来量化聚合成都的好坏

高内聚，低耦合。被认为是好的聚合效果。

2 轮廓系数值分析

如果b_i>>a_i:趋近于1效果越好，
b_i< 
  

3 结论 

 如果b_i>>a_i:趋近于1效果越好， b_i<

4 轮廓系数API

labels聚类标记的结果

5 用户聚类结果评估

在上一步训练模型并进行预测后加入模型评估：

#模型评估---轮廓系数
from sklearn.metrics import silhouette_score
silhouette_score(data_new,y_predict)

6、K-means总结

 

K-means应用场景：

没有目标值

分类