机器学习(二).png

分类算法

目标值：类别

1、sklearn转换器和预估器
2、KNN算法`
3、模型选择与调优
4、朴素贝叶斯算法
5、决策树
6、随机森林

3.1 sklearn转换器和估计器

转换器
估计器(estimator)
3.1.1 转换器 - 特征工程的父类
    1 实例化 (实例化的是一个转换器类(Transformer))
    2 调用fit_transform(对于文档建立分类词频矩阵，不能同时调用)
    标准化：
        (x - mean) / std
        fit_transform()
            fit()           计算 每一列的平均值、标准差
            transform()     (x - mean) / std进行最终的转换
3.1.2 估计器(sklearn机器学习算法的实现)
    估计器(estimator)
        1 实例化一个estimator
        2 estimator.fit(x_train, y_train) 计算
            —— 调用完毕，模型生成
        3 模型评估：
            1）直接比对真实值和预测值
                y_predict = estimator.predict(x_test)
                y_test == y_predict
            2）计算准确率
                accuracy = estimator.score(x_test, y_test)

3.2 K-近邻算法

3.2.1 什么是K-近邻算法
    KNN核心思想：
        你的“邻居”来推断出你的类别
    1 K-近邻算法(KNN)原理
        k = 1
            容易受到异常点的影响
        如何确定谁是邻居？
        计算距离：
            距离公式
                欧氏距离 metric='metric' p=2
                曼哈顿距离 绝对值距离 metric='metric' p=1
                明可夫斯基距离  metric='minkowski'
    2 电影类型分析
        k = 1 爱情片
        k = 2 爱情片
        ……
        k = 6 无法确定
        k = 7 动作片

        如果取的最近的电影数量不一样？会是什么结果？
            k 值取得过小，容易受到异常点的影响
            k 值取得过大，样本不均衡的影响
        结合前面的约会对象数据，分析K-近邻算法需要做什么样的处理
            无量纲化的处理
                标准化
        sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm='auto')
        n_neighbors：k值
    3.2.3 案例1：鸢尾花种类预测
        1）获取数据
        2）数据集划分
        3）特征工程
            标准化
        4）KNN预估器流程
        5）模型评估
    3.2.4 K-近邻总结
        优点：简单，易于理解，易于实现，无需训练
        缺点：
            1）必须指定K值，K值选择不当则分类精度不能保证
            2）懒惰算法，对测试样本分类时的计算量大，内存开销大
        使用场景：小数据场景，几千～几万样本，具体场景具体业务去测试
3.3 模型选择与调优
    3.3.1 什么是交叉验证(cross validation)
    3.3.2 超参数搜索-网格搜索(Grid Search)
        k的取值
            [1, 3, 5, 7, 9, 11]
            暴力破解
    3.3.3 鸢尾花案例增加K值调优
    3.2.4 案例：预测facebook签到位置
        流程分析：
            1）获取数据
            2）数据处理
            目的：
                特征值 x
                目标值 y
                a.缩小数据范围
                  2 < x < 2.5
                  1.0 < y < 1.5
                b.time -> 年月日时分秒
                c.过滤签到次数少的地点
                数据集划分
             3）特征工程：标准化
             4）KNN算法预估流程
             5）模型选择与调优
             6）模型评估

3.4 朴素贝叶斯算法

3.4.1 什么是朴素贝叶斯分类方法
3.4.2 概率基础
    1 概率(Probability)定义
    3.4.3 联合概率、条件概率与相互独立
        联合概率：包含多个条件，且所有条件同时成立的概率
        P(程序员, 匀称) P(程序员, 超重|喜欢)
        P(A, B)
        条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率
        P(程序员|喜欢) P(程序员, 超重|喜欢)
        P(A|B)
        相互独立:
            P(A, B) = P(A)P(B) <=> 事件A与事件B相互独立
    朴素？
        假设：特征与特征之间是相互独立
    朴素贝叶斯算法：
        朴素 + 贝叶斯
    应用场景：
        文本分类
        单词作为特征
    拉普拉斯平滑系数
3.4.6 案例：20类新闻分类
    1）获取数据
    2）划分数据集
    3）特征工程
        文本特征抽取
    4）朴素贝叶斯预估器流程
    5）模型评估
3.4.7 朴素贝叶斯算法总结
    优点：
        对缺失数据不太敏感，算法也比较简单，常用于文本分类。
        分类准确度高，速度快
    缺点：
        由于使用了样本属性独立性的假设，所以如果特征属性有关联时其效果不好

        我爱北京天安门

3.5 决策树

3.5.1 认识决策树
    如何高效的进行决策？
        特征的先后顺序
3.5.2 决策树分类原理详解
    已知 四个特征值 预测 是否贷款给某个人
    先看房子，再工作 -> 是否贷款 只看了两个特征
    年龄，信贷情况，工作 看了三个特征
信息论基础
    1）信息
        香农：消除随机不定性的东西
        小明 年龄 “我今年18岁” - 信息
        小华 ”小明明年19岁” - 不是信息
    2）信息的衡量 - 信息量 - 信息熵
        bit
        g(D,A) = H(D) - 条件熵H(D|A)
    4 决策树的划分依据之一------信息增益
    没有免费的午餐(没办法有一个通用的算法解决)
3.5.5 决策树可视化
3.5.6 决策树总结
    优点：
        可视化 - 可解释能力强
    缺点：
        容易产生过拟合
3.5.4 案例：泰坦尼克号乘客生存预测
    流程分析：
        特征值 目标值
        1）获取数据
        2）数据处理
            缺失值处理
            特征值 -> 字典类型
        3）准备好特征值 目标值
        4）划分数据集
        5）特征工程：字典特征抽取
        6）决策树预估器流程
        7）模型评估

3.6 集成学习方法之随机森林

3.6.1 什么是集成学习方法
3.6.2 什么是随机森林
    随机
    森林：包含多个决策树的分类器
3.6.3 随机森林原理过程
    训练集：
    N个样本
    特征值 目标值
    M个特征
    随机
        两个随机
            训练集随机 - N个样本中随机有放回的抽样n个
                bootstrap 随机有放回抽样
                [1, 2, 3, 4, 5]
                新的树的训练集
                [2, 2, 3, 1, 5]
            特征随机 - 从M个特征中随机抽取m个特征
                M >> m
                降维
3.6.6 总结
      能够有效地运行在大数据集上，
      处理具有高维特征的输入样本，而且不需要降维          

初步代码

# 获取数据级
from sklearn.datasets import load_iris
# 划分数据集
from sklearn.model_selection import train_test_split
# 无量钢化,预处理
from sklearn.preprocessing import StandardScaler
# Knn算法
from sklearn.neighbors import KNeighborsClassifier
# 模型选择与调优 超参数网格搜索,交叉验证
from sklearn.model_selection import GridSearchCV
# 下载大数据集
from sklearn.datasets import fetch_20newsgroups
# 文本特征抽取 Tfidf
from sklearn.feature_extraction.text import TfidfVectorizer
# 朴素贝叶斯
from sklearn.naive_bayes import MultinomialNB
# 决策树 可视化
from sklearn.tree import DecisionTreeClassifier, export_graphviz


def knn_iris():
    """
    用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()
    # 训练集标准化 fit计算,transform转化
    x_train = transfer.fit_transform(x_train)
    # 保证准确性 测试集也要做标准化
    x_test = transfer.transform(x_test)

    # 4）KNN算法预估器  metric 距离类型 默认"minkowski" 参数 p=1 欧式距离,p=2 曼哈顿距离
    estimator = KNeighborsClassifier(n_neighbors=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)

    return None


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]}
    # cv 指定几折交叉验证 param_grid估计器参数
    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


def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """
    # 1）获取数据 默认下载训练集 subset='train' 
    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）朴素贝叶斯算法预估器流程 alpha 拉普拉斯平滑系数 处理分母概率可能为0
    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


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）决策树预估器 criterion 信息熵增益
    # 预剪枝 min_samples_split 内部节点再分所需最小样本数 / min_samples_leaf 叶子节点最少样本数 max_depth
    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__":
    # 代码1： 用KNN算法对鸢尾花进行分类
    # knn_iris()
    # 代码2：用KNN算法对鸢尾花进行分类，添加网格搜索和交叉验证
    # knn_iris_gscv()
    # 代码3：用朴素贝叶斯算法对新闻进行分类
    # nb_news()
    # 代码4：用决策树对鸢尾花进行分类
    decision_iris()

可视化决策树

可视化决策树

facebbook签到案例

#只做简单的实现
import pandas as pd
import os 

# 1、获取数据
 data =("./FBlocation/train.csv")
#电脑问题,先抽取10w
data = data.get_chunk(100000)

data.head()

# 2、基本的数据处理
# 1）缩小数据范围 现实根据实际情况划分
data = data.query("x < 2.5 & x > 2 & y < 1.5 & y > 1.0")

data.head()

# 2）处理时间特征
time_value = pd.to_datetime(data["time"], unit="s")

time_value.values

#便于快捷的获取各种时间格式,用时间序列处理
date = pd.DatetimeIndex(time_value)
date

#data.year,month,day,weekday,time
data["day"] = date.day

data["weekday"] = date.weekday

data["hour"] = date.hour

data.head()

# 3）过滤签到次数少的地点 暂时不考虑<3的签到 ["row_id"]选择哪列无关
place_count = data.groupby("place_id").count()["row_id"]

data.groupby("place_id").count().head()

#使用布尔索引
place_count[place_count > 3].head()

#通过布尔取索引取得地点 
# place_count[place_count > 3].index.values
data_final = data[data["place_id"].isin(place_count[place_count > 3].index.values)]

data_final.head()

# 筛选特征值和目标值,实际应该考虑更多的进行特征工程的处理
x = data_final[["x", "y", "accuracy", "day", "weekday", "hour"]]
y = data_final["place_id"]

x.head()

y.head()

# 数据集划分
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x, y)

# 标准预处理
from sklearn.preprocessing import StandardScaler
# Knn算法
from sklearn.neighbors import KNeighborsClassifier
# 网格搜索 交叉验证择优
from sklearn.model_selection import GridSearchCV

# 3）特征工程：标准化
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
# 记得对x_test数据标准化,不要用fit_transform,来源于同一样本
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_)

泰坦尼克生存预测案例

import pandas as pd

# 1、获取数据
path = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt"
titanic = pd.read_csv(path)

titanic.head()

# 筛选特征值和目标值
x = titanic[["pclass", "age", "sex"]]
y = titanic["survived"]

x.head()

y.head()

# 2、数据处理
# 1）缺失值处理
x["age"].fillna(x["age"].mean(), inplace=True)

# 2) 转换成字典
x = x.to_dict(orient="records")

x

from sklearn.model_selection import train_test_split
# 3、数据集划分
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)

# 4、字典特征抽取
from sklearn.feature_extraction import DictVectorizer
from sklearn.tree import DecisionTreeClassifier, export_graphviz
from sklearn.model_selection import GridSearchCV

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)

# 可视化决策树
export_graphviz(estimator, out_file="titanic_tree.dot", feature_names=transfer.get_feature_names())


### 随机森林对泰坦尼克号乘客的生存进行预测

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

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