黑马程序员机器学习Day2学习笔记

• 一.转换器和预估器
• 二. KNN算法
  • 网格搜索和交叉验证
• KNN案例：Facebook预测签到位置
• 朴素贝叶斯
  • 联合概率、条件概率与相互独立
• 决策树
  • 信息熵

回顾传统机器学习算法流程：

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

总结本章内容： 1.KNN算法用于小型数据集的分类 2.朴素贝叶斯用于特征于特征之间关系不强的算法，比如文本的分类 3.决策树算法用于大型的数据集中

一.转换器和预估器

Day1的时候我们学习了获取数据，特征工程。（Day1中我们并没有没有使用到数据处理，因为我们的数据都是来自sklearn官方的数据库，这个数据库基本都是完整的，直接调用就行了）

转换器作用： 进行特征工程的父类 (Transformer) 调用：fit_transform来完成数据的处理

需要注意的点：fit_transform = fit + transform

Fit(): Method calculates the parameters μ and σ and saves them as internal objects.

解释：简单来说，就是求得训练集X的均值啊，方差啊，最大值啊，最小值啊这些训练集X固有的属性。计算mean, std数值，可以理解为一个训练过程

Transform(): Method using these calculated parameters apply the transformation to a particular dataset.

解释：计算公式：(x-mean)/std ，在Fit的基础上，将mean和std的数值带入，进行标准化，所以transform前需要fit这一步；降维，归一化等操作（看具体用的是哪个工具，如PCA，StandardScaler等）。

实例化过程中需要注意的点，训练集x_train使用fit_transform，而测试集只需要使用transform，不用fit(因为它需要统一方差，均值这些标准)

    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test) #这里不是用fit_transform,因为要统一标准

预估器作用： 对数据进行训练的父类(estimator)

预估器，顾名思义，就说进行预测这步的函数。（我们的目的就是说输入一个东西（比如猫狗的图片），他能够进行预测这个东西是什么）

注意的点：前面转换器我们有使用fit_transform和transform，而在预估器这里，我们只使用fit，而不用transform。

模型评估： 方法1：直接比对真实值和预测值 y_predict = estimator.predict(x_test) 方法2：计算准确率，计算分数 accuracy = estimator.score(x_test, y_test)

分类问题

二. KNN算法

讲完预估器后，我们来学习一下KNN分类算法。

简单来讲，就是我越靠近谁，我就和他归为一类。

比如我们已知A,B,C,D分别为4个象限的点，我们要判断点E为哪个象限，我们就计算E到点A,B,C,D四个点的距离来判断，因为它最靠近点A，所以我们将E归为第一象限。（这是K=1的情况）

K=1就容易受到异常点的影响，如下图所示，E离第四象限的D比较近，因此我们判定E为第四象限的点。

所以K=1就容易受到异常点的影响。

因此我们一般K会适当的调整，但是如果K太大，会受到样本不均衡的影响。

我们以鸢尾花种类预测作为KNN算法的案例： 1)获取数据 2）数据集划分 3）特征工程——标准化 4）KNN预估器流程 5）模型评估

def knn_iris():
    """
    用KNN算法对鸢尾花进行分类
    :return:
    流程：
    1.获取数据
    2.数据集划分
    3.特征工程， 标准化
    4.KNN预估器流程
    5.模型评估
    """

    # 1）获取数据
    iris = load_iris()

    # 2）划分数据集
    x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, random_state=22)#random_state 随机数种子

    # 3）特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test) #这里不是用fit_transform,因为要统一标准
    #x_train和x_test需要使用同一个标准差和方差进行计算。fit是用于计算标准差和方差，因为要和train一致
    #因此test这里不用fit

    # 4）KNN算法预估器
    estimator = KNeighborsClassifier(n_neighbors=3) #n_neighbors 就是K的数值
    #注意：这里只使用到了fit，就是相当于训练，输入训练集的输入x和训练集的目标值y
    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

网格搜索和交叉验证

交叉验证：即将原来的训练集再拆分成训练集和验证集

数据集本应分成三份，1.训练集，2，验证集， 3.测试集， 只不过我们一般都去掉了中间的验证集。

交叉验证多一个验证集后，我们可以通过截取不同片段作为验证集，然后通过求平均准确率作为模型的准确率。

网格搜索： 比如KNN算法，K的取值对最后评判是有影响的，我们如何选取一个最佳的结果呢？ 可以使用暴力检索的方式，也就是一个一个K值去测试。我们设置一个K值表，然后一个个的去测试哪一个K值好。

def knn_iris_gscv():
    """
    用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    :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）特征工程：标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

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

    # 加入网格搜索与交叉验证
    # 参数准备
    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)

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

    return None

和前面KNN算法相比，就是多了GridSearchCV函数。

    # 参数准备
    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)

KNN案例：Facebook预测签到位置

算法步骤： 1.获取数据 2.数据处理（之前使用sklearn库的时候，都没有这步筛选数据这步） 3.特征工程 4.训练 5.模型评估

主要和鸢尾花KNN不同的在于，这里的数据需要自己处理

自己提的需求：选择 23次，将时间戳转成年月日的形式

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
#因为是导入csv数据文件，所以使用Pandas库来进行处理。
# 1、获取数据
data = pd.read_csv("./FBlocation/train.csv") #看你自己train.csv在哪一个文件夹中

#数据处理（筛选数据）


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

# 2）处理时间特征  to_datetime
time_value = pd.to_datetime(data["time"], unit="s") #将其转换成年月日

date = pd.DatetimeIndex(time_value) #要把数据插入到列表中
#将时间数据插入data中
data["day"] = date.day
data["weekday"] = date.weekday
data["hour"] = date.hour

# 3）过滤签到次数少的地点
#这里groupuby 计算的是place_id相同的， 其他row_id那些全部都是一样的数
place_count = data.groupby("place_id").count()["row_id"]
#place_count > 3 这里输出的是满足条件的布尔值，True和False
place_count[place_count > 3].head() 
data_final = data[data["place_id"].isin([place_count > 3].index.values)] #去取出place_count>3的索引，然后data[index]，将那些数值取出


# 筛选特征值和目标值，将原本数据转成特征和目标值
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_)

朴素贝叶斯

KNN输出的是为一个答案，而朴素贝叶斯算法输出的是各个可能条件的概率。 应用：文本分类 说到底，贝叶斯就是KNN外的另一种分类算法，对于sklearn来讲，也还是一行代码解决问题

朴素贝叶斯 = 朴素 + 贝叶斯

朴素：指的是事件相互独立 贝叶斯即指贝叶斯公式：

联合概率、条件概率与相互独立

• 联合概率：包含多个条件，且所有条件同时成立的概率 P(A, B)=P(A)P(B) P(程序员, 匀称) P(程序员, 超重|喜欢)

• 条件概率：

  P(A|B) B发生的条件下，A发生的概率 欢)

• 相互独立:

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

如果样本量太小的话，计算的概率可能为0。所以加上一个拉普拉斯平滑算子。其公式如下所示

新闻分类栗子

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）特征工程：文本特征抽取-tfidf
    transfer = TfidfVectorizer()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.transform(x_test)

    # 4）朴素贝叶斯算法预估器流程
    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

决策树

因为一个物体，他的特征不止一个。比如猫，他的耳朵，体态，颜色，尾巴这些都是他的特征。面对这么多特征，我们要如何更快速的进行判断？我们就需要对这些特征的重要性进行一个排序，先判断重要明显的特征，比如如果没有尾巴，那么这一定不是一只猫。根据特征的有用程度，进行物体的分类。这个就是决策树。

信息定义：消除随机不定性的东西。比如， 狗咬人，这个不算什么信息。人咬狗，这个信息量比较大。

信息熵

为了判断哪个参数影响更大，使用信息熵这个概念。解决了对信息的量化度量问题香农用信息熵的概念来描述信源的不确定度。

信息熵公式：

变量的不确定性越大，熵也就越大，把它搞清楚所需要的信息量也就越大. 一件事情越是确定，则他的信息熵越小。

信息增益： 当你得到这个特征后，总的信息熵的减小程度。 所以信息增益越大，所以这个特征信息越有用。 特征A对训练数据集D的信息增益g(D，A),定义为集合D的信息熵H(D)与特征A给定条件下D的信息条件熵H(D|A)差，即公式为 g(D,A)=H(D)-H(D|A)

H(D|A)的计算公式如下：

总的信息熵 - 只给特征A条件下的概率。

H(D|A)计算举个栗子： 数据集：

现在要求H(D|年龄),查看年龄对于贷款的影响。 H(D|年龄)=1/3H(青年)+1/3H(中年)+1/3H(老年)

H(青年)=-(2/5log2/5 +3/5log3/5)

H(中年)=-(2/5log2/5 +3/5log3/5)

H(老年)=-(1/5log1/5 + 4/5log4/5)

带入信息增益的公式， g(D,年龄)=H(D)-H(D|年龄)带入即可计算出各个特征的信息增益。增益越大，说明知道这个特征后，可以消除越多的不确定性。 这个特征就应当越先作为条件划分。

决策树划分依据：信息增益

决策树的优点： 可视化——可解释能力强 缺点： 决策树不能很好的推广数据的泛化能力，容易产生过拟合。

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)

  #决策树这里不用去标准化x_train这些
  # 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

这里生成了决策树文件，可以拷贝文件内容到决策树可视化网址中生成决策树文件。