机器学习快速入门

来源于黑马机器学习快速入门 ，笔记方便复习使用

机器学习概述

机器学习、深度学习、人工智能

机器学习是人工智能的一个实现途径

深度学习是机器学习的一个方法发展而来

机器学习、深度学习可以用来做 传统预测、图像识别、自然语言处理

什么是机器学习？

定义

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

解释

数据集的构成

结构：特征值+目标值

注：

• 对每一行数据我们可以称之为样本
• 有些数据集可以没有目标值

机器学习的算法分类

目标值：类别（例：猫还是狗），分类问题

目标值：连续型的数据（例：房屋价格，面积越大价格越大），回归问题

目标值：无，无监督学习（没有目标监督着你）

总结：

• 监督学习(supervised learning)(预测)

  • 定义：输入数据是由输入特征值和目标值所组成。函数的输出可以是一个连续的值(称为回归)，或是输出是有限个离散值(称作分类)。
  • 分类 k-近邻算法、贝叶斯分类、决策树与随机森林、逻辑回归。
  • 回归 线性回归、岭回归

• 无监督学习(unsupervised learning)

  • 定义:输入数据是由输入特征值所组成。
  • 聚类 k-means

小练习：

1. 预测明天天气多少度？ 回归问题
2. 预测明天是晴天还是雨天？ 分类问题
3. 人脸年龄预测？回归（具体多少岁）/分类（老/少）
4. 人脸识别？ 分类问题

机器学习开发流程

1. 获取数据
2. 数据处理
3. 特征工程
4. 机器学习算法训练——模型
5. 模型评估
6. 应用

特征工程

数据集

可用数据集

学习阶段可用的数据集：

1. sklearn
2. kaggle
3. UCI

sklearn数据集

安装，在终端中：

pip install scipy
pip install numpy
pip install scikit-learn

sklearn.datasets

​ load_* 获取小规模数据集

​ fetch_* 获取大规模数据集

sklearn小数据集：

• sklearn.datasets.load_iris() 加载并返回鸢尾花数据集

  名称	数量
  类别	3
  特征	4
  样本数量	150
  每个类别数量	50

• sklearn.datasets.load_boston() 加载并返回波士顿房价数据集

sklearn大数据集：

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

数据集的返回值：datasets.base.Bunch（继承自字典）

dict["key"] = values
bunch.key = values

sklearn数据集返回值介绍

• load和fetch返回的数据类型datasets.base.Bunch(字典格式)
• data:特征数据数组，是[n_samples * n_features]的二维numpy.ndarray 数组
• target:标签数组，是n_samples 的一维numpy.ndarray数组。DESCR:数据描述
• feature_names:特征名,新闻数据，手写数字、回归数据集没有o target_names:标签名

不要把所有的数据集都拿来训练一个模型，需要留一部分用来验证，于是有了数据集的划分

数据集的划分

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

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

划分比例：

• 训练集：70 80
• 测试集：30 20

数据集划分api：

sklearn.model_selection.train_test_split(arrays, *options)

• x数据集的特征值
• y数据集的标签值
• test_size测试集的大小，一般为float
• random_state随机数种子,不同的种子会造成不同的随机采样结果。相同的种子采样结果相同。
• return训练集特征值，测试集特征值，训练集目标值, 测试集目标值

代码：

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split


def datasets_demo():
    """
    sklearn数据集的使用
    :return:
    """
    # 获取数据集
    iris = load_iris()
    # print("鸢尾花数据集：\n", iris)
    # print("查看数据集描述:\n", iris["DESCR"])  # 可以用 .属性  的方式
    # print("查看特征值的名字:\n", iris.feature_names)
    # print("查看特征值:\n", iris.data)
    # print("查看特征值形状:\n", iris.data.shape)
    # 数据集的划分
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=22)
    print("训练集的特征值:\n", x_train, x_train.shape)
    print("测试集的特征值:\n", x_test, x_test.shape)
    return None


if __name__ == '__main__':
    datasets_demo()

特征工程介绍

为什么需要特征工程？

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

什么是特征工程？

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

​ 意义：会直接影响机器学习的效果。

pandas:数据清洗、数据处理

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

特征工程包含的内容：

• 特征抽取
• 特征预处理
• 特征降维

特征提取

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

注：特征化是为了机器更好的理解数据。

• 字典特征提取（特征离散化）
• 文本特征提取
• 图像特征提取

特征提取api sklearn.feature_extraction

字典特征提取

对以下数据进行特征提取：

 [{'city':'北京','temperature':100},{'city':'上海','temperature':60},{'city':'深圳','temperature':30}]

代码：

from sklearn.feature_extraction import DictVectorizer
def dict_extraction_demo():
    data = [{'city': '北京', 'temperature': 100}, {'city': '上海', 'temperature': 60}, {'city': '深圳', 'temperature': 30}]
    # 实例一个转换器类
    transfer = DictVectorizer(sparse=True)
    # 调用fit_transform（）
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)
    print("特征名称:\n", transfer.get_feature_names_out())
    return None


if __name__ == '__main__':
    dict_extraction_demo()

data_new:
   (0, 1)	1.0
  (0, 3)	100.0
  (1, 0)	1.0
  (1, 3)	60.0
  (2, 2)	1.0
  (2, 3)	30.0
特征名称:
 ['city=上海' 'city=北京' 'city=深圳' 'temperature']

输出并不是二维数组，因为当我们实例化DictVectorizer时，默认参数sparse=True，想要得到二维数组形式，需要将sparse=False,两者是等价的，前者对应后者在数组中的位置

使用的是one-hot编码：特征提取方法: one-hot 和 TF-IDF - ML小菜鸟 - 博客园 (cnblogs.com)

文本特征提取

CountVectorizer

统计每个特征词出现的个数

代码：

from sklearn.feature_extraction.text import CountVectorizer
def count_demo():
    data = {"Life is short,i like like python", "Life is too long,i dislike python"}
    # 实例化一个转化器
    transfer = CountVectorizer()
    # 调用transform
    data_new = transfer.fit_transform(data)
    # print("data_new:\n", data_new)
    print("data_new:\n", data_new.toarray())  # 改变输出方式,显然统计的是词频
    print("特征名称：", transfer.get_feature_names_out())
    return None

中文文本分词：

首先要安装jieba分词：

pip install jieba

import jieba
def cut_word(text):
    return " ".join(list(jieba.cut(text)))
def count_chinese_demo():
    data = {"在北上广深，软考证书可以混个工作居住证，也是一项大的积分落户筹码。",
            "升职加d薪必备，很多企业人力资源会以此作为审核晋升的条件。",
            "简历上浓彩重抹一笔，毕竟是国家人力部、工信部承认的IT高级人才。"}
    data_new=[]
    for sent in data:
        data_new.append(cut_word(sent))
    #实例化一个转化器
    transfer = CountVectorizer()
    #调用transform
    data_final = transfer.fit_transform(data_new)
    print("data_new:\n",data_final.toarray())
    print("特征名字:\n",transfer.get_feature_names())
    return None
if __name__ == '__main__':
    count_chinese_demo()

在某一类别的文章当中，出现的次数很多，但是在其他类别的文章当中出现很少。

TfidfVectorizer

Tf-idf文本特征提取

公式：

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

api：

特征预处理

什么是特征预处理

特征预处理就是通过一些转化函数将特征数据转换成更加适合算法模型的特征数据过程（无量纲化处理）

数值型数据的无量纲化：

• 归一化
• 标准化

特征预处理API

sklearn.preprocessing

为什么要进行归一化/标准化

特征的单位或者大小相差较大，或者某特征的方差相比其他的特征要大出几个数量级，容易影响（支配)目标结果，使得一些算法无法学习到其它的特征。

我们需要用到一些方法进行无量纲化，使不同规格的数据转换到同一规格。（例如，里程数数值相较于公升，消耗时间比数值过大）

归一化

定义

通过对原始数据进行变换把数据映射到（默认为0-1）之间。

公式

$$X^{\prime }=\frac{x-min}{max-min}{X}^{"}=X^{\prime }\ast (mx-mi)+mi$$

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

如何理解这一过程？我们通过一个例子：

第一列：

x’ = (90-60)/(90-60) = 1

x" = 1*1+0 = 1

api

数据计算

代码：

import pandas as pd
from sklearn.preprocessing import MinMaxScaler
def minmax_demo():
    data = pd.read_csv("dating.txt")
    data = data.iloc[:,:3]  #只取数据前三列,每行都要
    print("data=\n",data)
    transfer = MinMaxScaler() #默认0-1
    data_new = transfer.fit_transform(data)
    print("data_new=\n",data_new)


if __name__ == '__main__':
    minmax_demo()

归一化总结

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

标准化

定义

通过对原始数据进行变换把数据变换到均值为0，标准差为1范围内。

公式

$$X^{\prime }=\frac{x-mean}{\sigma }$$

作用于每一列，mean为平均值，$ \sigma $ 为标准差（集中程度）

回到刚才异常点的地方，再来看看标准化。

• 对于归一化来说:如果出现异常点，影响了最大值和最小值，那么结果显然会发生改变
• 对于标准化来说:如果出现异常点，由于具有一定数据量，少量的异常点对于平均值的影响并不大，从而方差改变较小。

api

代码

from sklearn.preprocessing import MinMaxScaler, StandardScaler
def stand_demo():
    """
    标准化
    :return:
    """
    # 1、获取数据
    data = pd.read_csv("dating.txt")
    data = data.iloc[:, :3]
    print("data:\n", data)

    # 2、实例化一个转换器类
    transfer = StandardScaler()

    # 3、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)
    return None

特征降维

降维

降维是指在某些限定条件下，降低随机变量（特征，行是样本数量，列是特征个数）的个数，得到一组“不想关“主变量的过程。

• 降低随机变量的个数：

• 相关特征
  • 相对湿度与降雨量之间的相关

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

降维的两种方式

• 特征选择
• 主成分分析（可以理解一种特征提取的方式）

什么是特征选择

定义

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

例如鸟都有爪子

方法

• Filter(过滤式)︰主要探究特征本身特点、特征与特征和目标值之间关联。

  • 方差选择法:低方差特征过滤。
  • 相关系数

• Embedded(嵌入式):算法自动选择特征(特征与目标值之间的关联)。

  • 决策树:信息嫡、信息增益

  • 正则化:L1、L2

  • 深度学习:卷积等

过滤式

低方差特征过滤

删除低方差的一些特征，前面讲过方差的意义。再结合方差的大小来考虑这个方式的角度。

• 特征方差小:某个特征大多样本的值比较相近
• 特征方差大:某个特征很多样本的值都有差别

api：

数据计算：

对某些股票的指标特征之间进行一个筛选：

from scipy.stats import pearsonr
from sklearn.feature_selection import VarianceThreshold
def variance_demo():
    """
    过滤低方差特征
    :return:
    """
    # 1、获取数据
    data = pd.read_csv("factor_returns.csv")
    data = data.iloc[:, 1:-2] # 去掉第一列和最后一列  左闭右开
    print("data:\n", data)

    # 2、实例化一个转换器类
    transfer = VarianceThreshold(threshold=10)

    # 3、调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new, data_new.shape)

    # 计算某两个变量之间的相关系数
    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

相关系数

皮尔逊相关系数（Pearson Correlation Coefficient）反映变量之间相关关系密切程度的统计指标

公式：
$$r=\frac{n{\sum }_{}^{}xy-{\sum }_{}^{}x{\sum }_{}^{}y}{\sqrt{n{\sum }_{}^{}{x}^2-({\sum }_{}^{}x{)}^2}\sqrt{n{\sum }_{}^{}{y}^2-({\sum }_{}^{}y{)}^2}}$$

举例：

相关系数的特点：

api:

代码在上节，也可画图观察结果

import matplotlib.pyplot as plt
import matplotlib.pyplot as pltplt.figure(figsize=(20,8),dpi=100)
plt.scatter(data['revenue'], data['total_expense'])
plt.show()

特征和特征之间的相关性很高：

1. 选取其中一个
2. 加权求和
3. 主成分分析

主成分分析

什么是主成分分析

• 定义：高维数据转化为低维数据的过程，在此过程中可能会舍弃原有数据、创造新的变量
• 作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息。
• 应用：回归分析或者聚类分析当中

案例

把二维的数据降成一维（一条直线）

虽然降成一维，但是由原来的五个点变成三个点，有数据损失:

上图我们就可以完成降维的任务了，我们还应该考虑让所有点到直线的距离之和最小。

api

数据计算

# 主成分分析: PCA(高维数据变低维,舍弃原由数据,创造新数据,
# 如: 压缩数据维数,降低原数据复杂度,损失少了信息)
def decomposition_PCA():  # PCA 降维
    data = [[2, 8, 4, 5], [3, 8, 5, 5], [10, 5, 1, 0]]  # 3*4矩阵 包含四个特征
    N = 3  # N为整数就是转为多少个特征  保留的至少都比原特征值少一个
    # N = 0.95  # N为小数就是保留百分之多少的信息
    transfer = PCA(n_components=N)
    data_new = transfer.fit_transform(data)
    print("PCA降维:", data_new)
    return None

总结

分类算法

目标值为类别

sklearn的转换器和估计器

转换器

特征工程的父类

之前做的特征工程的步骤：

1. 实例化 (实例化的是一个转换器类(Transformer))
2. 实例化 (实例化的是一个转换器类(Transformer))

我们把特征工程的接口称之为转换器

fit(): 求得训练集X的均值，方差，最大值，最小值,这些训练集X固有的属性。

transform(): 在fit的基础上，进行标准化，降维，归一化等操作。

fit_transform(): fit和transform的组合，既包括了训练又包含了转换。

估计器(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 聚类

估计器工作流程：

estimator.score() 要想api自己去计算准确率，需要比对真实值和预测值，所以要将测试集的特征值和目标值传入，这样它才可以跟它的预测值比较。

K-近邻算法

哪个小朋友距离自己最近，判断出自己在哪个区。

KNN（K-NearesNeighbor） 即K邻近法，是一个理论上比较成熟的、也是最简单的机器学习算法之一。用老话就说：“人以群分，物以类聚”。

定义

如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

距离公式:

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

K-近邻算法API

• sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)
  • n_neighbors：int,可选（默认= 5），k_neighbors查询默认使用的邻居数(k值)
  • algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}，可选用于计算最近邻居的算法：‘ball_tree’将会使用 BallTree，‘kd_tree’将使用 KDTree。‘auto’将尝试根据传递给fit方法的值来决定最合适的算法。 (不同实现方式影响效率)

案例：鸢尾花种类预测

1. 获取数据
2. 数据集划分
3. 特征工程
4. 标准化
5. KN预估器流程
6. 模型评估

# -*- coding:utf-8 -*-

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier


def knn_iris():
    """
    knn算法对鸢尾花分类
    :return:
    """
    # 获取数据
    iris = load_iris()
    # 划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
    # 特征工程:标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)  # 测试集不要用fit, 因为要保持和训练集处理方式一致
    # KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train, y_train)  # 训练 【训练集的特征值与目标值】 有了模型 
    # 模型评估
    # 方法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


if __name__ == '__main__':
    knn_iris()

结果分析：

k值取多大,有何影响？

• k值取得过小：容易受到异常点的影响
• k值取得过大：受到样本均衡的问题

性能问题：

• 距离计算上，时间复杂度高

总结

• 优点：
  • 简单，易于理解，易于实现，无需训练
• 缺点：
  • 懒惰算法，对测试样本分类时的计算量大，内存开销大
  • 必须指定K值，K值选择不当则分类精度不能保证
• 使用场景：小数据场景，几千～几万样本，具体场景具体业务去测试

模型选择与调优

为什么需要交叉验证

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

什么是交叉验证

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

分析

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

• 训练集：训练集+验证集
• 测试集：测试集

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

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

模型选择与调优

• 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:每次交叉验证后的验证集准确率结果和训练集准确率结果
    • best_params 最佳参数

代码：

def KNN_optimal():  # 模型选择和调优
    # 网格搜索和交叉验证
    iris = load_iris()
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)
    estimator = KNeighborsClassifier()  # 默认都是欧式距离, 采用的是minkowski推广算法,p=1是曼哈顿, p=2是欧式, 而默认值为2
    # 开始调优
    # 第一个参数是estimator
    # 第二个是估计器参数，参数名称（字符串）作为key，要测试的参数列表作为value的字典，或这样的字典构成的列表
    # 第三个是指定cv=K,  K折交叉验证
    # https://www.cnblogs.com/dblsha/p/10161798.html
    param_dict = {"n_neighbors": [1, 3, 5, 7, 9, 11]}
    estimator = GridSearchCV(estimator, param_grid=param_dict, cv=10)
    # 结束调优
    estimator.fit(x_train, y_train)

    # 传入测试值通过前面的预估器获得预测值
    y_predict = estimator.predict(x_test)
    print("预测值为:", y_predict, "\n真实值为:", y_test, "\n比较结果为:", y_test == y_predict)
    score = estimator.score(x_test, y_test)
    print("准确率为: ", score)
    # ------------------
    print("最佳参数:\n", estimator.best_params_)
    print("最佳结果:\n", estimator.best_score_)
    print("最佳估计器:\n", estimator.best_estimator_)
    print("交叉验证结果:\n", estimator.cv_results_)
    # -----------------以上是自动筛选出的最佳参数, 调优结果

    return None

例子：预测facebook签到位置

流程分析：

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

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV

def facebook_demo():
    data = pd.read_csv("F:/python_work/train.csv")

    #缩小数据范围
    data = data.query("x<2.5 & x>2 & y<1.5 & y>1")

    #处理时间特征
    #转换为年月日时分秒
    time_value = pd.to_datetime(data["time"],unit="s")
    date = pd.DatetimeIndex(time_value)
    #人工排除年和月两个信息
    data["day"] = date.day
    data["weekday"] = date.weekday
    data["hour"] = date.hour
    print(data)
    #过滤掉签到次数少的地方
    #先统计每个地点被签到的次数
    place_count = data.groupby("place_id").count()[ "row_id"]
    place_count[place_count>3]
    data_final=data[data["place_id"].isin(place_count[place_count>3].index.values)]
    # 筛选特征值和目标值
    x = data_final[["x", "y", "accuracy", "day", "weekday", "hour"]]
    y = data_final["place_id"]
    # 数据集划分
    x_train, x_test, y_train, y_test = train_test_split(x, y)
    # 3）特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）KNN算法预估器
    estimator = KNeighborsClassifier()

    # 加入网格搜索与交叉验证
    # 参数准备
    param_dict = {"n_neighbors": [3, 5, 7, 9]}
    estimator = GridSearchCV(estimator, param_grid=param_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_test == y_predict)

    # 方法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_)
if __name__ == '__main__':
    facebook_demo()

朴素贝叶斯算法

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

朴素 即假设各样本之间相互独立

贝叶斯 就是概率中的贝叶斯公式

朴素贝叶斯分类 是对相对独立的样本间，根据特征以及类别计算相应的后验概率，所有可能的分类中概率最高的即为预测的结果。

例子：

通过观察可以发现产品类所占比例最大，即将其预测为产品类垃圾广告

概率基础

定义

概率定义为一件事情发生的可能性

如：扔出一个硬币，结果头像朝上的几率，某天是晴天的可能性，P(X) : 取值在[0, 1]

条件概率与联合概率

• 联合概率：包含多个条件，且所有条件同时成立的概率
  • 记作：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

这个算法经常会用在文本分类

贝叶斯公式

$$P(C|W)=\frac{P(W|C)P(C)}{P(W)}$$

注：w为给定文档的特征值（频数统计，预测文档提供），c为文档类别

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

公式可以理解为：
$$P(C|F1,F2,\dots )=\frac{P(F1,F2,\dots |C)P(C)}{P(F1,F2,\dots )}$$
其中c可以是不同类别：

公式分为三个部分：

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

如果计算两个类别概率比较：

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

文章分类

结果：

P(ChineselC)=5/8
P(TokyolC)=0
P(JapanIC)=0

出现了结果为0的情况

拉普拉斯平滑系数

目的：防止计算出的分类概率为0

m就是有多少个特征词

P(ChineseIC)=(5+1)/(8+1*6)=6/14=3/7
P(TokyolC)=(0+1)/(8+1*6)=1/14
P(JapanIC)=(0+1)/(8+1*6)=1/14

api

• sklearn.naive_bayes.MultinomialNB(alpha = 1.0) alpha:阿尔法
  • 朴素贝叶斯分类
  • alpha：拉普拉斯平滑系数

案例：20类新闻分类

1. 获取数据（获取的是sklearn的数据 不需要进行数据处理）
2. 划分数据集
3. 特征工程 文本特征抽取tfidf
4. 朴素贝叶斯预估器流程
5. 模型评估

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """

    # 获取数据（获取的是sklearn的数据
    news = fetch_20newsgroups(subset="all")
    # 划分数据集
    x_train, x_test, y_train, y_test = train_test_split(news.data, news.target)
    # 特征工程 文本特征抽取tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 朴素贝叶斯预估器流程
    estimator = MultinomialNB()
    estimator.fit(x_train, y_train)
    # 模型评估
    # 方法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

总结

• 优点：

  • 朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
  • 对缺失数据不太敏感，算法也比较简单，常用于文本分类。
  • 分类准确度高，速度快

• 缺点：

  • 由于使用了样本属性独立性的假设，所以如果特征属性有关联时其效果不好

  我爱北京天安门 北京和天安门有关联

决策树

认识决策树

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

决策树分类原理详解

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

如何对这些客户进行分类预测？

可能先划分年龄或者先划分工作

但是哪些特征是考虑的第一位，决策树可能将有没有房子放在第一位，再看是否有无工作

信息熵

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

定义与公式

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

公式的详细解释：

信息增益表示知道了某个条件后，事件的不确定性下降的程度

贷款特征重要计算

• 我们以年龄特征来计算：

  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 作为划分的第一个特征。这样我们就可以一棵树慢慢建立

决策树的三种算法实现

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

• ID3
  • 信息增益 最大的准则
• C4.5
  • 信息增益比 最大的准则
• CART
  • 分类树: 基尼系数 最小的准则 在sklearn中可以选择划分的默认原则
  • 优势：划分更加细致（从后面例子的树显示来理解）

决策树API

• class sklearn.tree.DecisionTreeClassifier(criterion=’gini’, max_depth=None,random_state=None)
  • 决策树分类器
  • criterion:默认是’gini’系数，也可以选择信息增益的熵’entropy’
  • max_depth:树的深度大小
  • random_state:随机数种子
• 其中会有些超参数：max_depth:树的深度大小
  • 其它超参数我们会结合随机森林讲解

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, export_graphviz
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)

    # 可视化决策树
    export_graphviz(estimator, out_file="iris_tree.dot", feature_names=iris.feature_names)

    return None
if __name__ == '__main__':
    decision_iris()

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

• 泰坦尼克号数据

在泰坦尼克号和titanic2数据帧描述泰坦尼克号上的个别乘客的生存状态。这里使用的数据集是由各种研究人员开始的。其中包括许多研究人员创建的旅客名单，由Michael A. Findlay编辑。我们提取的数据集中的特征是票的类别，存活，乘坐班，年龄，登陆，home.dest，房间，票，船和性别。

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

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

分析

• 选择我们认为重要的几个特征 [‘pclass’, ‘age’, ‘sex’]
• 填充缺失值
• 特征中出现类别符号，需要进行one-hot编码处理(DictVectorizer)
  • x.to_dict(orient=“records”) 需要将数组特征转换成字典数据
• 数据集划分
• 决策树分类预测

流程分析：
特征值目标值

1. 获取数据

2. 数据处理

   • 缺失值处理

   • 特征值->字典类型

3. 准备好特征值目标值

4. 划分数据集

5. 特征工程：字典特征抽取

6. 决策树预估器流程

7. 模型评估

pclass sex 这些都是类别 当特征当中有许多类别的话，要转换成onehot编码，但是一个一个转比较麻烦，有多个特征是类别先转换成字典，再用字典特征抽取较为方便。

def titanic():
    # 1、获取数据
    path = "titanic.csv"
    titanic = pd.read_csv(path)
    # 筛选特征值和目标值
    x = titanic[["pclass", "age", "sex"]]
    y = titanic["survived"]
    # 2、数据处理
    # 1）缺失值处理
    x["age"].fillna(x["age"].mean(), inplace=True)  # 填充平均值
    # 2) 转换成字典
    x = x.to_dict(orient="records")
    # 3、数据集划分
    x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)
    # 4、字典特征抽取
    transfer = DictVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 3）决策树预估器
    estimator = DecisionTreeClassifier(criterion="entropy", max_depth=8)
    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)

    # 可视化决策树
    dot_data = "titanic_tree.dot"
    tree.export_graphviz(estimator, out_file=dot_data, feature_names=transfer.get_feature_names())
    with open(dot_data) as f:
        dot_graph = f.read()  # 将文件数据作为字符串返回
    graph = pydotplus.graph_from_dot_data(dot_graph)

    graph.write_pdf('example.pdf')  # 保存图像为pdf格式
    Image(graph.create_png())  # 绘制图像为png格式

总结

• 优点：
  • 简单的理解和解释，树木可视化。
• 缺点：
  • 决策树学习者可以创建不能很好地推广数据的过于复杂的树，这被称为过拟合。
• 改进：
  • 减枝cart算法(决策树API当中已经实现，随机森林参数调优有相关介绍)
  • 随机森林

集成学习方法之随机森林

什么是集成学习方法

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

什么是随机森林

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

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

随机森林原理过程

学习算法根据下列算法而建造每棵树：

• 用N来表示训练用例（样本）的个数，M表示特征数目。
  • 1、一次随机选出一个样本，重复N次， （有可能出现重复的样本） 训练集随机
  • 2、随机去选出m个特征, m <<M，建立决策树 特征随机
• 采取bootstrap抽样

为什么采用BootStrap抽样?

• 为什么要随机抽样训练集？
  • 如果不进行随机抽样，每棵树的训练集都一样，那么最终训练出的树分类结果也是完全一样的
• 为什么要有放回地抽样？
  • 如果不是有放回的抽样，那么每棵树的训练样本都是不同的，都是没有交集的，这样每棵树都是“有偏的”，都是绝对“片面的”（当然这样说可能不对），也就是说每棵树训练出来都是有很大的差异的；而随机森林最后分类取决于多棵树（弱分类器）的投票表决。

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

def suijisanli_demo():
    # 1、获取数据
    path = "titanic.csv"
    titanic = pd.read_csv(path)
    # 筛选特征值和目标值
    x = titanic[["pclass", "age", "sex"]]
    y = titanic["survived"]
    # 2、数据处理
    # 1）缺失值处理
    x["age"].fillna(x["age"].mean(), inplace=True)
    # 2) 转换成字典
    x = x.to_dict(orient="records")
    # 3、数据集划分
    x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)
    # 4、字典特征抽取
    transfer = DictVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)
    # 随机森林预估器
    estimator = RandomForestClassifier()
    # 加入网格搜索与交叉验证
    # 参数准备
    param_dict = {"n_estimators": [120, 200, 300, 500, 800, 1200], "max_depth": [5, 8, 15, 25, 30]}
    estimator = GridSearchCV(estimator, param_grid=param_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_test == y_predict)

    # 方法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_)

总结

• 在当前所有算法中，具有极好的准确率
• 能够有效地运行在大数据集上，处理具有高维特征的输入样本，而且不需要降维
• 能够评估各个特征在分类问题上的重要性

回归与聚类算法

线性回归

定义与公式

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

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

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

• 期末成绩：0.7×考试成绩+0.3×平时成绩
• 房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率

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

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

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

• 线性关系

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

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

• 非线性关系

  

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

线性模型
自变量一次
y = w1x1 + w2x2 + w3x3 + …… + wnxn + b
参数一次
y = w1x1 + w2x1^2 + w3x1^3 + w4x2^3 + …… + b

线性关系一定是线性模型 线性模型不一定是线性关系

线性回归的损失和优化原理

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

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

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

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

真实结果与我们预测的结果之间是不是存在一定的误差呢？类似这样

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

损失函数

总损失定义为：

• y_i为第i个训练样本的真实值
• h(x_i)为第i个训练样本特征值组合预测函数
• 又称最小二乘法

如何去减少这个损失，使我们预测的更加准确些？既然存在了这个损失，我们一直说机器学习有自动学习的功能，在线性回归这里更是能够体现。这里可以通过一些优化方法去优化（其实是数学当中的求导功能）回归的总损失！！！

优化算法

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

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

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

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

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

梯度下降(Gradient Descent) 勤奋努力的普通人 试错、改进

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

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

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

线性回归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)

  • SGDRegressor类实现了随机梯度下降学习，它支持不同的loss函数和正则化惩罚项来拟合线性回归模型。
  • loss:损失类型
    • loss=”squared_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:存在父类当中
    • 对于一个常数值的学习率来说，可以使用learning_rate=’constant’ ，并使用eta0来指定学习率。
  • SGDRegressor.coef_：回归系数
  • SGDRegressor.intercept_：偏置

sklearn提供给我们两种实现的API， 可以根据选择使用

回归性能评估

均方误差(Mean Squared Error)MSE)评价机制：

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

• sklearn.metrics.mean_squared_error(y_true, y_pred)
  • 均方误差回归损失
  • y_true:真实值
  • y_pred:预测值
  • return:浮点数结果

波士顿房价预测

流程：

1. 获取数据集
2. 划分数据集
3. 特征工程：
   无量纲化 - 标准化
4. 预估器流程
   fit() --> 模型
   coef_ intercept_
5. 模型评估
   回归的性能评估：
   均方误差
6. 正规方程和梯度下降对比

• 数据介绍

  

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

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

• 数据分割与标准化处理
• 回归预测
• 线性回归的算法效果评估

代码：

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
from sklearn.metrics import mean_squared_error
def linear1():
    """
    正规方程的优化方法对波士顿房价进行预测
    :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）预估器
    estimator = LinearRegression()
    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


def linear2():
    """
    梯度下降的优化方法对波士顿房价进行预测
    :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）预估器
    estimator = SGDRegressor(learning_rate="constant", eta0=0.01, max_iter=10000, penalty="l1")
    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

if __name__ == '__main__':
    linear1()
    linear2()

正规方程和梯度下降对比

• 文字对比

梯度下降	正规方程
需要选择学习率	不需要
需要迭代求解	一次运算得出
特征数量较大可以使用	需要计算方程，时间复杂度高$O(n^3)$

• 选择：
  • 小规模数据：
    • LinearRegression(不能解决拟合问题)
    • 岭回归
  • 大规模数据：SGDRegressor

总结

• 线性回归的损失函数-均方误差
• 线性回归的优化方法
  • 正规方程
  • 梯度下降
• 线性回归的性能衡量方法-均方误差
• sklearn的SGDRegressor API 参数

欠拟合与过拟合

训练数据训练的很好，误差也不大，为什么在测试集上面有问题呢？
当算法在某个数据集当中出现这种情况，可能就出现了过拟合现象。

简易介绍

• 欠拟合

• 过拟合

​

• 分析
  • 第一种情况：因为机器学习到的天鹅特征太少了，导致区分标准太粗糙，不能准确识别出天鹅。
  • 第二种情况：机器已经基本能区别天鹅和其他动物了。然后，很不巧已有的天鹅图片全是白天鹅的，于是机器经过学习后，会认为天鹅的羽毛都是白的，以后看到羽毛是黑的天鹅就会认为那不是天鹅。

定义

• 过拟合：一个假设在训练数据上能够获得比其他假设更好的拟合， 但是在测试数据集上却不能很好地拟合数据，此时认为这个假设出现了过拟合的现象。(模型过于复杂)
• 欠拟合：一个假设在训练数据上不能获得更好的拟合，并且在测试数据集上也不能很好地拟合数据，此时认为这个假设出现了欠拟合的现象。(模型过于简单)

那么是什么原因导致模型复杂？线性回归进行训练学习的时候变成模型会变得复杂，这里就对应前面再说的线性回归的两种关系，非线性关系的数据，也就是存在很多无用的特征或者现实中的事物特征跟目标值的关系并不是简单的线性关系。

原因以及解决办法

• 欠拟合原因以及解决办法

  • 原因：学习到数据的特征过少
  • 解决办法：增加数据的特征数量

• 过拟合原因以及解决办法

  • 原因：原始特征过多，存在一些嘈杂特征， 模型过于复杂是因为模型尝试去兼顾各个测试数据点

  • 解决办法：

    • 正则化

      L1
      损失函数 + λ惩罚项
      LASSO
      L2 更常用
      损失函数 + λ惩罚项
      Ridge - 岭回归

在这里针对回归，我们选择了正则化。但是对于其他机器学习算法如分类算法来说也会出现这样的问题，除了一些算法本身作用之外（决策树、神经网络），我们更多的也是去自己做特征选择，包括之前说的删除、合并一些特征

解决方式：

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

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

正则化类别

• L2正则化
  • 作用：可以使得其中一些W的都很小，都接近于0，削弱某个特征的影响
  • 优点：越小的参数说明模型越简单，越简单的模型则越不容易产生过拟合现象
  • Ridge回归
• L1正则化
  • 作用：可以使得其中一些W的值直接为0，删除这个特征的影响
  • LASSO回归

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

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

API

• sklearn.linear_model.Ridge(alpha=1.0, fit_intercept=True,solver=“auto”, normalize=False)
  • 具有l2正则化的线性回归
  • alpha:正则化力度，也叫 λ
    • λ取值：0~1 1~10
  • solver:会根据数据自动选择优化方法
    • sag:如果数据集、特征都比较大，选择该随机梯度下降优化
  • normalize:数据是否进行标准化
    • normalize=False:可以在fit之前调用preprocessing.StandardScaler标准化数据
  • Ridge.coef_:回归权重
  • Ridge.intercept_:回归偏置

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

• sklearn.linear_model.RidgeCV(_BaseRidgeCV, RegressorMixin)
  • 具有l2正则化的线性回归，可以进行交叉验证
  • coef_:回归系数

正则化程度的变化，对结果的影响

• 正则化力度越大，权重系数会越小
• 正则化力度越小，权重系数会越大

波士顿房价预测

def linear3():
    """
    岭回归对波士顿房价进行预测
    :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）预估器
    estimator = Ridge(alpha=0.5, 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

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

逻辑回归的应用场景

• 广告点击率
• 是否为垃圾邮件
• 是否患病
• 金融诈骗
• 虚假账号

看到上面的例子，我们可以发现其中的特点，那就是都属于两个类别之间的判断。逻辑回归就是解决二分类问题的利器

逻辑回归的原理

输入

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

激活函数

• sigmoid函数

  

  • 分析
    • 回归的结果输入到sigmoid函数当中
    • 输出结果：[0, 1]区间中的一个概率值，默认为0.5为阈值

  逻辑回归最终的分类是通过属于某个类别的概率值来判断是否属于某个类别，并且这个类别默认标记为1(正例),另外的一个类别会标记为0(反例)。（方便损失计算）

  输出结果解释(重要)：假设有两个类别A，B，并且假设我们的概率值为属于A(1)这个类别的概率值。现在有一个样本的输入到逻辑回归输出结果0.6，那么这个概率值超过0.5，意味着我们训练或者预测的结果就是A(1)类别。那么反之，如果得出结果为0.3那么，训练或者预测结果就为B(0)类别。

  所以接下来我们回忆之前的线性回归预测结果我们用均方误差衡量，那如果对于逻辑回归，我们预测的结果不对该怎么去衡量这个损失呢？我们来看这样一张图:

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

损失以及优化

损失

逻辑回归的损失，称之为对数似然损失，公式如下：

• 分开类别：

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

• 综合完整损失函数

  

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

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

优化

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

逻辑回归API

• sklearn.linear_model.LogisticRegression(solver=‘liblinear’, penalty=‘l2’, C = 1.0)

  • solver:优化求解方式（默认开源的liblinear库实现，内部使用了坐标轴下降法来迭代优化损失函数）
    • sag：根据数据集自动选择，随机平均梯度下降
  • penalty：正则化的种类
  • C：正则化力度

  默认将类别数量少的当做正例

LogisticRegression方法相当于 SGDClassifier(loss=“log”, penalty=" "),SGDClassifier实现了一个普通的随机梯度下降学习，也支持平均随机梯度下降法（ASGD），可以通过设置average=True。而使用LogisticRegression(实现了SAG)

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

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

数据描述

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

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

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

from sklearn.linear_model import LogisticRegression
import pandas as pd
import numpy as np

def cancer():
    """
    先获取数据
    处理数据
        有缺失值
    数据集划分 测试 训练
    特征工程
        无量纲化-标准化(不要用归一化 之前有笔记)
    逻辑回归预估器
    模型评估
    :return: 
    """
    
    # 1、读取数据
    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
    data = data.replace(to_replace="?", value=np.nan)
    # 2）删除缺失样本
    data.dropna(inplace=True)
    data.isnull().any()  # 检验,不存在缺失值
    # 3、划分数据集
    # 筛选特征值和目标值
    x = data.iloc[:, 1:-1]
    y = data["Class"]
    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)
    # 5）得出模型
    print("逻辑回归-权重系数为：\n", estimator.coef_)
    print("逻辑回归-偏置为：\n", estimator.intercept_)
    # 6、模型评估
    # 方法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)

分类的评估方法

精确率与召回率

在分类任务下，预测结果(Predicted Condition)与正确标记(True Condition)之间存在四种不同的组合，构成混淆矩阵(适用于多分类)

• 精确率：预测结果为正例样本中真实为正例的比例（了解）

  

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

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

分类评估报告API

• sklearn.metrics.classification_report(y_true, y_pred, labels=[], target_names=None )
• • y_true：真实目标值
  • y_pred：估计器预测目标值
  • labels:指定类别对应的数字
  • target_names：目标类别名称
  • return：每个类别精确率与召回率

假设这样一个情况，如果99个样本癌症，1个样本非癌症( 样本不均衡)，不管怎样我全都预测正例(默认癌症为正例),准确率就为99%但是这样效果并不好，这就是样本不均衡下的评估问题

准确率：99%
召回率：99/99 = 100%
精确率：99%
F1-score: 2*99%/ 199% = 99.497%
AUC:0.5
TPR = 100%
FPR = 1 / 1 = 100%

如何衡量样本不均衡下的评估？

ROC曲线与AUC指标

• TPR = TP / (TP + FN)
  • 所有真实类别为1的样本中，预测类别为1的比例
• FPR = FP / (FP + FN)
  • 所有真实类别为0的样本中，预测类别为1的比例

ROC曲线的横轴就是FPRate，纵轴就是TPRate，当二者相等时，表示的意义则是：对于不论真实类别是1还是0的样本，分类器预测为1的概率是相等的，此时AUC为0.5

AUC指标

• AUC的概率意义是随机取一对正负样本，正样本得分大于负样本的概率
• AUC的最小值为0.5，最大值为1，取值越高越好
• AUC=1，完美分类器，采用这个预测模型时，不管设定什么阈值都能得出完美预测。绝大多数预测的场合，不存在完美分类器。
• 0.5<AUC<1，优于随机猜测。这个分类器（模型）妥善设定阈值的话，能有预测价值。

最终AUC的范围在[0.5, 1]之间，并且越接近1越好

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:每个样本预测的概率值

总结：

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

from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
import pandas as pd
import numpy as np
from sklearn.metrics import classification_report
from sklearn.metrics import roc_auc_score
def cancer():
    # 1、读取数据
    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
    data = data.replace(to_replace="?", value=np.nan)
    # 2）删除缺失样本
    data.dropna(inplace=True)
    data.isnull().any()  # 检验,不存在缺失值
    # 3、划分数据集
    # 筛选特征值和目标值
    x = data.iloc[:, 1:-1]
    y = data["Class"]
    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)
    # 5）得出模型
    print("逻辑回归-权重系数为：\n", estimator.coef_)
    print("逻辑回归-偏置为：\n", estimator.intercept_)
    # 6、模型评估
    # 方法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)
    # 查看精确率、召回率、F1-score
    report = classification_report(y_test, y_predict, labels=[2, 4], target_names=["良性", "恶性"])
    print(report)
    # y_true：每个样本的真实类别，必须为0(反例),1(正例)标记
    # 将y_test 转换成 0 1
    y_true = np.where(y_test > 3, 1, 0)
    score = roc_auc_score(y_true, y_predict)
    print(score)
if __name__ == '__main__':
    cancer()

模型保存与加载

api

• from sklearn.externals import joblib

  • 保存：joblib.dump(rf, ‘test.pkl’)
  • 加载：estimator = joblib.load(‘test.pkl’)

• 保存

# 使用线性模型进行预测
# 使用正规方程求解
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算法

什么是无监督学习

• 一家广告平台需要根据相似的人口学特征和购买习惯将美国人口分成不同的小组，以便广告客户可以通过有关联的广告接触到他们的目标客户。
• Airbnb 需要将自己的房屋清单分组成不同的社区，以便用户能更轻松地查阅这些清单。
• 一个数据科学团队需要降低一个大型数据集的维度的数量，以便简化建模和降低文件大小。

我们可以怎样最有用地对其进行归纳和分组？我们可以怎样以一种压缩格式有效地表征数据？这都是无监督学习的目标，之所以称之为无监督，是因为这是从无标签的数据开始学习的。

无监督学习包含算法

• 聚类
  • K-means(K均值聚类)
• 降维
  • PCA

K-means原理

K-means的聚类效果图

K-means聚类步骤

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

我们以一张图来解释效果：

K-meansAPI

• sklearn.cluster.KMeans(n_clusters=8,init=‘k-means++’)
  • k-means聚类
  • n_clusters:开始的聚类中心数量
  • init:初始化方法，默认为’k-means ++’
  • labels_:默认标记的类型，可以和真实值比较（不是值比较）

Kmeans性能评估指标

轮廓系数

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

轮廓系数值分析

• 分析过程（我们以一个蓝1点为例）
  • 1、计算出蓝1离本身族群所有点的距离的平均值a_i
  • 2、蓝1到其它两个族群的距离计算出平均值红平均，绿平均，取最小的那个距离作为b_i
  • 根据公式：极端值考虑：如果b_i >>a_i: 那么公式结果趋近于1；如果a_i>>>b_i: 那么公式结果趋近于-1

结论

如果b_i>>a_i:趋近于1效果越好， b_i<<a_i:趋近于-1，效果不好。轮廓系数的值是介于 [-1,1] ，越趋近于1代表内聚度和分离度都相对较优。

轮廓系数API

• sklearn.metrics.silhouette_score(X, labels)
  • 计算所有样本的平均轮廓系数
  • X：特征值
  • labels：被聚类标记的目标值

K-means总结

• 特点分析：采用迭代式算法，直观易懂并且非常实用
• 缺点：容易收敛到局部最优解(多次聚类)

注意：聚类一般做在分类之前

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

import pandas as pd
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score

def silhouette_coefficient():
    # 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降维
    # 1）实例化一个转换器类
    transfer = PCA(n_components=0.95)

    # 2）调用fit_transform
    data_new = transfer.fit_transform(data)
    data_new.shape
    # 预估器流程
    estimator = KMeans(n_clusters=3)
    estimator.fit(data_new)
    y_predict = estimator.predict(data_new)
    y_predict[:300]
    # 模型评估-轮廓系数
    silhouette_score(data_new, y_predict)

if __name__ == '__main__':
    silhouette_coefficient()