算法工程师8——机器学习概述（中篇-基本算法）

这里比较概括，主要看嘿马的人工智能课件
搞算法首先清楚它是有无监督，再清楚它是分类还是回归
算法理解+编程实现+应用
搞算法首先清楚它是有无监督，再清楚它是分类还是回归
算法理解+编程实现+应用
搞算法首先清楚它是有无监督，再清楚它是分类还是回归
算法理解+编程实现+应用

1 引言

1.1 基本概念

机器学习的准确率一般不可能达到100%，一个合理的准确率是非常必要的。

1.2 机器学习分类

机器学习的经典算法主要有五种类型,分别为:
(1)聚类算法,采用各种距离度量技术将一系列的数据点划分到K类中,划分后的聚类结构具有类内相似、类间差距最大的特点。
(2)分类算法,事先按照一定的标准给一组对象集合进行分类,并赋予类标签,训练出学习模型,利用该模型对未知对象进行分类。
(3)回归算法,综合考虑整个数据集中因变量和自变量之间的关系进行建模, 进而利用模型对给定的自变量进行计算得到预测值。
(4)关联规则算法,在整个事务型数据中分析同时出现次数较多的频繁项集,并将出现次数满足一定阈值的频繁项集作为关联项集。
(5)降维算法,在机器学习过程中由于对象属性较多,为了降低计算复杂度利用各种度量技术将高维空间中的数据转换成低维空间中的数据。（摘自：并行机器学习算法基础体系前沿进展综述）
（1）人工智能的常用十种算法_人工智能_fanyun的博客-CSDN博客
（2）人工智能常见算法简介_人工智能_nfzhlk的专栏-CSDN博客
（3）周志华老师的西瓜书很不错。
————————————————

1.3 机器学习常用的距离

1.4 数据集

训练集分为训练集和验证集

1.5 特征预处理

1.5.1 无量纲化

归一化的值在0-1之间
标准化的值在-1到1之间

1.6 损失函数

https://blog.csdn.net/xiaotiig/article/details/111257955

1.7 样本类别不平衡解决方法

（1）进行过采样，就是多次复制类别较少的样本
（2）欠采样，就是把类别对的样本丢弃一些

1.8 特征提取

1.9特征降维（去除一些无关或两两相关性较强的数据）

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

1.10 如何选择合适算法

关于在计算的过程中，如何选择合适的算法进行计算，可以参考scikit learn官方给的指导意见

1.11 构建模型的最优方法

最小化训练数据的损失函数
这是构建模型的根本

1.12 相关概念

（1）交叉验证

（2）超参数
凡是手动设置的都叫超参数

（3）网格搜索

（4）准确率勃论
假设现在你正在做一个关于垃圾邮件分类的工作，数据集98%都是垃圾邮件，仅2%为有效邮件，在这种情况下，即便是不建立任何模型，直接把所有的邮件都认为是垃圾邮件，你都可以获得98%的准确率。这种情况我们称作是“准确率悖论”(https://en.wikipedia.org/wiki/Accuracy_paradox)。
（5）自助法和留一法
留一法是数据集中只留下一个做测试

自助法是

（5）最小二乘法
通过求平方和使损失函数最小

1.13 大O计法

在 大O符号表示法中，时间复杂度的公式是： T(n) = O( f(n) )，其中f(n) 表示每行代码执行次数之和，而 O 表示正比例关系，这个公式的全称是：算法的渐进时间复杂度。
就是每行执行了多少次，常见几种
（1）常数阶O(1)
（2）对数阶O(logN)
（3）线性阶O(n)
（4）线性对数阶O(nlogN)
（5）平方阶O(n²)
（6）立方阶O(n³)
（7）K次方阶O(n^k)
（8）指数阶(2^n)
https://zhuanlan.zhihu.com/p/50479555

2 k 近邻（KNN）

监督分类

K Nearest Neighbor算法又叫KNN算法

2.1 定义

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

2.2 距离计算

2.3 计算步骤

1）计算已知类别数据集中的点与当前点之间的距离

2）按距离递增次序排序

3）选取与当前点距离最小的k个点

4）统计前k个点所在的类别出现的频率

5）返回前k个点出现频率最高的类别作为当前点的预测分类

2.4 案例

2.5 K值选择说明

2.6 kd树

2.7 KNN接口API

再识K-近邻算法API
sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm=‘auto’)
n_neighbors：
int,可选（默认= 5），k_neighbors查询默认使用的邻居数
algorithm：{‘auto’，‘ball_tree’，‘kd_tree’，‘brute’}
快速k近邻搜索算法，默认参数为auto，可以理解为算法自己决定合适的搜索算法。除此之外，用户也可以自己指定搜索算法ball_tree、kd_tree、brute方法进行搜索，
brute是蛮力搜索，也就是线性扫描，当训练集很大时，计算非常耗时。
kd_tree，构造kd树存储数据以便对其进行快速检索的树形数据结构，kd树也就是数据结构中的二叉树。以中值切分构造的树，每个结点是一个超矩形，在维数小于20时效率高。
ball tree是为了克服kd树高维失效而发明的，其构造过程是以质心C和半径r分割样本空间，每个节点是一个超球体。

3 sklearn入门

4 线性回归

4.1 两种类型（线性回归和非线性回归）

4.1.1 线性回归

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

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

4.1.2 非线性回归

就是自变量具有高次幂

4.2 两个API

4.3 模型优化正则化等

4.3 岭回归

5 逻辑回归

逻辑回归（Logistic Regression）是机器学习中的一种分类模型，逻辑回归是一种分类算法，虽然名字中带有回归。
输入 就是线性回归的输出，经过sigmoid函数，把整体的值映射到【0，1】之间

6 决策树

6.1 决策树划分原理

6.1.1 信息增益

1948年香农提出了信息熵（Entropy）的概念。

信息理论：
1、从信息的完整性上进行的描述:

当系统的有序状态一致时，数据越集中的地方熵值越小，数据越分散的地方熵值越大。

2、从信息的有序性上进行的描述:

当数据量一致时，系统越有序，熵值越低；系统越混乱或者分散，熵值越高。

"信息熵" (information entropy)是度量样本集合纯度最常用的一种指标。

**信息增益：**以某特征划分数据集前后的熵的差值。熵可以表示样本集合的不确定性，熵越大，样本的不确定性就越大。因此可以使用划分前后集合熵的差值来衡量使用当前特征对于样本集合D划分效果的好坏。

信息增益 = entroy(前) - entroy(后)

6.1.2 信息增益率

增益率：增益率是用前面的信息增益Gain(D, a)和属性a对应的"固有值"(intrinsic value) [Quinlan , 1993J的比值来共同定义的。

7 集成学习

看黑马的课件资料比较好

7.1 Bagging(负担来进行抑制)

就是多次采样一部分数据集，每次利用这部分数据集构建分类器，那采样几次就构建几个分类器 ，最后进行平均投票。
Bagging就是一种思想：

Bagging + 决策树/线性回归/逻辑回归/深度学习… = bagging集成学习方法

7.2 随机森林（随机森林 = Bagging + 决策树）

7.3 boosting

7.4 AdaBoost介绍（boosting的一种）

训练数据集的时候，每次给误分类的权重高于正确分类的权重

7.5 GBDT（ Gradient Boosting Decision Tree）

GBDT 的全称是 Gradient Boosting Decision Tree，梯度提升树，在传统机器学习算法中，GBDT算的上TOP3的算法。

8 聚类算法

非监督算法

8.1 Canopy算法

8.2 Kmeans++

8.3 二分Kmeans

8.4 k_medoids

必会代码

1 KNN实现鸢尾花分类

# 实现鸢尾花的分类
# python3.7.10，scikit-learn = 0.19.1
# 参考黑马人工智能课程
from sklearn import model_selection
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt


# 1 数据获取与处理

iris = load_iris()
print(iris)

print("鸢尾花的特征值:\n", iris["data"])
print("鸢尾花的目标值：\n", iris.target)
print("鸢尾花目标值的名字：\n", iris.target_names)
print("鸢尾花的描述：\n", iris.DESCR)
print("鸢尾花特征的名字：\n", iris.feature_names)


# 数据集的划分
x_train, x_test, y_train, y_test = model_selection.train_test_split(iris.data, iris.target,
                                                                    test_size=0.2, random_state=22)

# 2 特征预处理
transfer = StandardScaler()
# 训练和处理
x_train = transfer.fit_transform(x_train)
# 因为前面训练好了，直接转换
x_test = transfer.transform(x_test)

# 3 机器学习模型KNN
# 实例化一个估计器
estimator = KNeighborsClassifier(n_neighbors=5)
# 模型训练
estimator.fit(x_train, y_train)

# 4 测试
# 4.1 预测值结果输出
y_pre = estimator.predict(x_test)
print("预测值是：\n", y_pre)
print("预测值和真实值的对比：\n", y_pre==y_test)

# 4.2 准确值计算
score = estimator.score(x_test, y_test)
print("准确率为：\n", score)

2 KNN鸢尾花分类中加入网格搜索

# 实现鸢尾花的分类
# python3.7.10，scikit-learn = 0.19.1
# 参考黑马人工智能课程
from sklearn import model_selection
from sklearn.datasets import load_iris
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt


# 1 数据获取与处理

iris = load_iris()
print(iris)

print("鸢尾花的特征值:\n", iris["data"])
print("鸢尾花的目标值：\n", iris.target)
print("鸢尾花目标值的名字：\n", iris.target_names)
print("鸢尾花的描述：\n", iris.DESCR)
print("鸢尾花特征的名字：\n", iris.feature_names)


# 数据集的划分
x_train, x_test, y_train, y_test = model_selection.train_test_split(iris.data, iris.target,
                                                                    test_size=0.2, random_state=22)

# 2 特征预处理
transfer = StandardScaler()
# 训练和处理
x_train = transfer.fit_transform(x_train)
# 因为前面训练好了，直接转换
x_test = transfer.transform(x_test)

# 3 机器学习模型KNN
# 实例化一个估计器
estimator = KNeighborsClassifier()

# 模型选择与调优
# 准备超参数
param_dict = {"n_neighbors":[1,3,5]}
estimator = model_selection.GridSearchCV(estimator,param_grid=param_dict,cv=3)

# 模型训练
estimator.fit(x_train, y_train)

# 4 测试
# 4.1 预测值结果输出
y_pre = estimator.predict(x_test)
print("预测值是：\n", y_pre)
print("预测值和真实值的对比：\n", y_pre==y_test)

# 4.2 准确值计算
score = estimator.score(x_test, y_test)
print("准确率为：\n", score)

print("在交叉验证中验证的最好结果：\n", estimator.best_score_)
print("最好的参数模型：\n", estimator.best_estimator_)
print("每次交叉验证后的准确率结果：\n", estimator.cv_results_)

3简单的回归方程实现（一元一次）

# 线性回归

from sklearn.linear_model import LinearRegression

x = [[80, 86],
[82, 80],
[85, 78],
[90, 90],
[86, 82],
[82, 90],
[78, 80],
[92, 94]]
y = [84.2, 80.6, 80.1, 90, 83.2, 87.6, 79.4, 93.4]

estimator = LinearRegression()
# 使用fit方法训练

estimator.fit(x,y)

print("线性回归的系数：")
print(estimator.coef_)

print("输出预测的结果：\n", estimator.predict([[100,80]]))

4 线性回归预测波士顿放假（一元一次）

# 使用线性回归的正规方法、梯度下降法、和岭回归实现波士顿房价的预测

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
from sklearn.externals import joblib

def linear_model1():
    """
    线性回归:正规方程
    :return:None
    """
    # 1.获取数据
    data = load_boston()
    print(data)

    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(data.data, data.target, random_state=22)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-线性回归(正规方程)
    estimator = LinearRegression()
    estimator.fit(x_train, y_train)

    # 4.1模型保存
    joblib.dump(estimator,"test.pkl")

    # 4.2 模型加载
    estimator1 = joblib.load("test.pkl")

    # 5.模型评估
    # 5.1 获取系数等值
    y_predict = estimator1.predict(x_test)
    print("预测值为:\n", y_predict)
    print("模型中的系数为:\n", estimator1.coef_)
    print("模型中的偏置为:\n", estimator1.intercept_)

    # 5.2 评价
    # 均方误差
    error = mean_squared_error(y_test, y_predict)
    print("误差为:\n", error)

    # 5.3 评介2
    # 准确率，因为这是回归，不是分类，一般不用准确率，用均方误差来评估
    score = estimator1.score(x_test, y_test)
    print("准确率为：\n", score)

    return None


def linear_model2():
    """
    线性回归:梯度下降法
    :return:None
    """
    # 1.获取数据
    data = load_boston()

    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(data.data, data.target, random_state=22)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-线性回归
    # estimator = SGDRegressor(max_iter=1000, learning_rate="constant", eta0=0.1)
    estimator = SGDRegressor(max_iter=1000)
    estimator.fit(x_train, y_train)

    # 5.模型评估
    # 5.1 获取系数等值
    y_predict = estimator.predict(x_test)
    print("预测值为:\n", y_predict)
    print("模型中的系数为:\n", estimator.coef_)
    print("模型中的偏置为:\n", estimator.intercept_)

    # 5.2 评价
    # 均方误差
    error = mean_squared_error(y_test, y_predict)
    print("误差为:\n", error)

    return None

def linear_model3():
    """
    线性回归:岭回归
    :return:None
    """
    # 1.获取数据
    data = load_boston()

    # 2.数据集划分
    x_train, x_test, y_train, y_test = train_test_split(data.data, data.target, random_state=22)

    # 3.特征工程-标准化
    transfer = StandardScaler()
    x_train = transfer.fit_transform(x_train)
    x_test = transfer.fit_transform(x_test)

    # 4.机器学习-线性回归(岭回归)
    estimator = Ridge(alpha=1.0)
    estimator.fit(x_train, y_train)

    # 5.模型评估
    # 5.1 获取系数等值
    y_predict = estimator.predict(x_test)
    print("预测值为:\n", y_predict)
    print("模型中的系数为:\n", estimator.coef_)
    print("模型中的偏置为:\n", estimator.intercept_)

    # 5.2 评价
    # 均方误差
    error = mean_squared_error(y_test, y_predict)
    print("误差为:\n", error)

    return None

if __name__ == "__main__":
    linear_model1()
    print("第二种")
    linear_model2()
    print("第三种")
    linear_model3()

5 逻辑回归判断肿瘤

# 逻辑回归实现肿瘤预测
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
from sklearn.metrics import classification_report, roc_auc_score


# 1 获取数据和数据预处理
# 1.1 读取数据
names = ['Sample code number', 'Clump Thickness', 'Uniformity of Cell Size', 'Uniformity of Cell Shape',
                   'Marginal Adhesion', 'Single Epithelial Cell Size', 'Bare Nuclei', 'Bland Chromatin',
                   'Normal Nucleoli', 'Mitoses', 'Class']

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

# 1.2 缺失值处理
# 替换
data = data.replace(to_replace="?", value=np.NaN)
# 去掉空值
data = data.dropna()

# 1.3 确定特征值和目标值
x = data.iloc[:, 1:10]
print("特征值：")
print(x.head())
y = data["Class"]
print(y.head())

# 1.4 分割数据
x_train, x_test, y_train, y_test = train_test_split(x, y, random_state=22)
print("看看默认训练数据和测试数据是安多少比例分开的：")
print(x_train)
print(x_test)


# 2 特征提取
transfer = StandardScaler()
x_train = transfer.fit_transform(x_train)
x_test = transfer.transform(x_test)

# 3 模型构建
estimator = LogisticRegression()
estimator.fit(x_train, y_train)


# 4 模型预测
y_predict = estimator.predict(x_test)
print("预测值：")
# 这里不能用y_predict。head()，因为只有是pandas的对象才可以
print(y_predict)
print("真实值")
print(y_test.head())
# 准确率
score = estimator.score(x_test,y_test)
print("准确率：")
print(score)


# 评价指标
ret = classification_report(y_test,y_predict, labels=(2,4), target_names=("良性","恶性"))
print(ret)

# AUC
y_test = np.where(y_test>3,1,0)
auc_score = roc_auc_score(y_test, y_predict)
print("AUC指标：")
print(auc_score)

6 实现字典和文本的特征提取，即文本数字化

# 实现字典和文本的特征提取，即文本数字化
# 进行字典特征提取
from sklearn.feature_extraction import DictVectorizer
from sklearn.feature_extraction.text import CountVectorizer
import jieba

def dict_demo():
    """
    对字典类型的数据进行特征抽取
    :return: None
    """
    data = [{'city': '北京','temperature':100}, {'city': '上海','temperature':60}, {'city': '深圳','temperature':30}]
    # 1、实例化一个转换器类
    transfer = DictVectorizer(sparse=False)
    # 2、调用fit_transform
    data = transfer.fit_transform(data)
    print("返回的结果:\n", data)
    # 打印特征名字
    print("特征名字：\n", transfer.get_feature_names())

    return None

def text_count_demo():
    """
    对文本类型的数据进行特征抽取
    :return: None
    """
    data = ["life is short,i like like python", "life is too long,i dislike python"]
    # 1、实例化一个转换器类
    # transfer = CountVectorizer(sparse=False)
    transfer = CountVectorizer()
    # 2、调用fit_transform
    data = transfer.fit_transform(data)
    print("文本提取的结果:\n", data.toarray())
    # 打印特征名字
    print("特征名字：\n", transfer.get_feature_names())
    return None

def cut_word(text):
    """
        对中文进行分词
        "我爱北京天安门"————>"我 爱 北京 天安门"
        :param text:
        :return: text
        """
    # 用结巴对中文字符串进行分词,注意这里有个空格
    jie_ba = jieba.cut(text)
    print("分词后到底是什么：")
    print(jie_ba)
    text = " ".join(list(jieba.cut(text)))

    return text


def text_chinese_count_demo():
    """
    对中文文本类型的数据进行特征抽取
    :return: None
    """
    data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]

    text_list = []
    for sent in data:
        text_list.append(cut_word(sent))
    print("结巴分词后得到的列表：")
    print(text_list)
    # 1、实例化一个转换器类
    # transfer = CountVectorizer(sparse=False)
    transfer = CountVectorizer()
    # 2、调用fit_transform

    # 不使用结巴分词
    print("不使用结巴分词：")
    data = transfer.fit_transform(data)
    print("文本提取的结果:\n", data.toarray())
    # 打印特征名字
    print("特征名字：\n", transfer.get_feature_names())

    # 使用结巴分词后
    print("使用结巴分词：")
    data = transfer.fit_transform(text_list)
    print("文本提取的结果:\n", data.toarray())
    # 打印特征名字
    print("特征名字：\n", transfer.get_feature_names())


    return None

if __name__ == "__main__":
    dict_demo()
    text_count_demo()
    text_chinese_count_demo()

7 决策树预测泰坦尼克号乘客生存预测

# 使用决策树实现泰坦尼克号存活预测
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.tree import DecisionTreeClassifier, export_graphviz

# 1 获取数据并处理
# 下面这个网址好像不能用了，需要自己另外找一个
titan = pd.read_csv(r"http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt")
print("数据查看")
print(titan)

# 1.1 确定特征值，目标值
x =  titan[["pclass", "age", "sex"]]
y = titan["survived"]

# 1.2 缺失值处理
x["age"].fillna(x['age'].mean(), inplace=True)

# 1.3 数据集的划分
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2, random_state=22)
print(x_train.head())

# 2 特征提取处理
# 特征中出现类别符号，需要进行one-hot编码处理(DictVectorizer)
# 需要将数组特征转换成字典数据
transfer = DictVectorizer(sparse=False)

x_train = transfer.fit_transform(x_train.to_dict(orient="records"))
x_test = transfer.fit_transform(x_test.to_dict(orient="records"))

# 3 机器学习
estimator = DecisionTreeClassifier(criterion="entropy", max_depth=5)
estimator.fit(x_train, y_train)


# 4 预测
estimator.score(x_test, y_test)

estimator.predict(x_test)

# 保存树结构
export_graphviz(estimator,out_file='./data/tree.dot',feature_names=['age', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', '女性', '男性'])

8 随机森林实现otto数据集分类（很综合）

# 使用随机森林实现otto数据集
# otto数据集竞赛，链接：https://www.kaggle.com/c/otto-group-product-classification-challenge/overview
# 这个案例比较综合，好好看看相应的步骤

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.preprocessing import LabelEncoder, OneHotEncoder
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import log_loss


## 1 获取数据和处理
# 1.0 数据获取
# 1.1 查看数据特征
# 1.2 数据缺失值处理
# 1.3 数据标准化或归一化
# 1.4 确定特征x和目标y
# 1.5 标签字符转数字
# 1.6 拆分训练集和验证集


## 2 特征提取
## 3 机器学习模型
## 4 模型测试

## 1 获取数据和处理
# 1.0 数据获取
#data = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day08\02_机器学习算法day08\02-代码\data\otto\submission.csv")
#data = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day08\02_机器学习算法day08\02-代码\data\otto\test.csv")
data = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day08\02_机器学习算法day08\02-代码\data\otto\train.csv")

# 1.1 查看数据特征
print("数据形状：\n", data.shape)
print("数据：\n",data.head())
print("数据统计：\n",data.describe())

# 查看数据分布，每个类别的分布，是否平衡，本例中数据严重不平衡
sns.countplot(data.target)
plt.show()

# 本例中数据经过了脱敏处理，不需要进行特俗处理，我们也不知道每一列代表的涵义

# 1.2 数据缺失值处理
# 1.3 数据标准化或归一化



## 数据较多，我们截取一部分数据
new1_data = data[:10000]
print("截取后数据的形状：\n", new1_data.shape)
sns.countplot(new1_data.target)
plt.show()   #通过数据截取发现前10000条数据的分布只包括两个类别，这样的方式不可行

# 1.4 确定特征x和目标y
# 上面方式不行，需要进行随机欠取样，欠采样需要用到imblearn库，下载麻烦，这里就没进行欠采样
y = data["target"]
x = data.drop(["id","target"], axis=1) # 安列丢弃
print("看看y:\n",y.head())
print("看看x:\n",x.head())

# 1.5 标签字符转数字
le = LabelEncoder()
y = le.fit_transform(y)
print("看看字符转换为数字后的y:\n", y)

# 1.6 拆分训练集和验证集
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.2)
print("看看分割后的情况：\n", x_train.shape,x_test.shape)

# 2 特征提取

# 3 机器学习模型,oob_score是包外估计
rf = RandomForestClassifier(oob_score=True)
rf.fit(x_train, y_train)

 # 4 模型测试
y_pre = rf.predict(x_test)
print("看看预测值：\n", y_pre)

# 看看准确率
score = rf.score(x_test, y_test)
print("看看准确率:",score)
# 看看包外估计的准确率
oob_score = rf.oob_score_
print("看看包外估计的准确率:", oob_score)

# logloss模型评估
# laoloss估计需要用one_hot编码，首先需要将预测值转换为one-hot

one_hot = OneHotEncoder(sparse=False)
# 必须使用列的形式，y_test现在是行
y_test1 = one_hot.fit_transform(y_test.reshape(-1,1))
y_pre1 = one_hot.fit_transform(y_pre.reshape(-1,1))

logloss1 = log_loss(y_test1, y_pre1,eps=1e-15, normalize=True)
print("损失值1：", logloss1)


# 改变输出值的输出模式，让它由分类变成每个的概率,提高损失值
y_pre_proba = rf.predict_proba(x_test)
print("看看是不是输出为百分占比：\n",y_pre_proba)

logloss2 = log_loss(y_test1, y_pre_proba,eps=1e-15, normalize=True)
print("损失值2：", logloss2)


## 到此已经结束
##
##  下面实现一个超参数的调优
##

## 调优n_eatimators,学习器的个数
tuned_parameters = parameters = range(10,200,10)
# 创建一个添加accuracy的numpy
accuracy_t = np.zeros(len(tuned_parameters))

# 创建添加error的numpy
error_t = np.zeros(len(tuned_parameters))

for j, one_parameter in enumerate(tuned_parameters):
    rf2 = RandomForestClassifier(n_estimators=one_parameter,
                                 max_depth=10,max_features=10,
                                 min_samples_leaf=10,oob_score=True,
                                 random_state=0,n_jobs=1)

    rf2.fit(x_train,y_train)

    # 输出accuracy
    accuracy_t[j] = rf2.oob_score_
    # 输出error
    y_pre_max = rf2.predict_proba(x_test)
    error_t[j] = log_loss(y_test, y_pre_max, eps=1e-15, normalize=True)

    print(error_t[j])

# 优化结果展示
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20,4), dpi = 100)
axes[0].plot(tuned_parameters,error_t)
axes[1].plot(tuned_parameters,accuracy_t)

plt.show()



##  生成提交数据
test_data = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day08\02_机器学习算法day08\02-代码\data\otto\test.csv")

print("看看测试数据:\n",test_data)
test_data_drop_id = test_data.drop(["id"], axis=1)
y_pre_test = rf.predict_proba(test_data_drop_id)
result = pd.DataFrame(y_pre_test,columns=["Class_"+str(i) for i in range(1,10)])

# 添加一行
result.insert(loc=0, column="id", value=test_data.id)
print("查看结果：")
print(result)

# 保存数据
result.to_csv("submission.csv",index=False)

9 特征降维

# coding:utf-8

import pandas as pd
from sklearn.feature_selection import VarianceThreshold
from scipy.stats import pearsonr, spearmanr
from sklearn.decomposition import PCA


def var_thr():
    """
    特征选择:低方差特征过滤
    :return:
    """
    data = pd.read_csv("./data/factor_returns.csv")
    # print(data)
    print(data.shape)

    # 实例化一个对象
    transfer = VarianceThreshold(threshold=10)
    # 转换
    transfer_data = transfer.fit_transform(data.iloc[:, 1:10])
    print(transfer_data)
    print(data.iloc[:, 1:10].shape)
    print(transfer_data.shape)


def pea_demo():
    """
    皮尔逊相关系数
    :return:
    """
    # 准备数据
    x1 = [12.5, 15.3, 23.2, 26.4, 33.5, 34.4, 39.4, 45.2, 55.4, 60.9]
    x2 = [21.2, 23.9, 32.9, 34.1, 42.5, 43.2, 49.0, 52.8, 59.4, 63.5]

    # 判断
    ret = pearsonr(x1, x2)
    print("皮尔逊相关系数的结果是:\n", ret)


def spea_demo():
    """
    斯皮尔曼相关系数
    :return:
    """
    # 准备数据
    x1 = [12.5, 15.3, 23.2, 26.4, 33.5, 34.4, 39.4, 45.2, 55.4, 60.9]
    x2 = [21.2, 23.9, 32.9, 34.1, 42.5, 43.2, 49.0, 52.8, 59.4, 63.5]

    # 判断
    ret = spearmanr(x1, x2)
    print("斯皮尔曼相关系数的结果是:\n", ret)


def pca_demo():
    """
    pca降维
    :return:
    """
    data = [[2, 8, 4, 5], [6, 3, 0, 8], [5, 4, 9, 1]]

    # pca小数保留百分比
    transfer = PCA(n_components=0.9)
    trans_data = transfer.fit_transform(data)
    print("保留0.9的数据最后维度为:\n", trans_data)

    # pca小数保留百分比
    transfer = PCA(n_components=3)
    trans_data = transfer.fit_transform(data)
    print("保留三列数据:\n", trans_data)


if __name__ == '__main__':
    # var_thr()
    # pea_demo()
    # spea_demo()
    pca_demo()

10 Kmeans实现商品推荐（多数据表操作）

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


# 1.获取数据和预处理
order_product = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day09\02_机器学习算法day09\02-代码\data\instacart\order_products__prior.csv")
products = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day09\02_机器学习算法day09\02-代码\data\instacart\products.csv")
orders = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day09\02_机器学习算法day09\02-代码\data\instacart\orders.csv")
aisles = pd.read_csv(r"H:\05学习资料\14，软件开发\黑马人工智能\2课件\阶段3-人工智能机器学习\阶段3-人工智能机器学习\02_机器学习算法day09\02_机器学习算法day09\02-代码\data\instacart\aisles.csv")

# 合并表格
table1 = pd.merge(order_product, products, on=["product_id", "product_id"])
table2 = pd.merge(table1, orders, on=["order_id", "order_id"])
table = pd.merge(table2, aisles, on=["aisle_id", "aisle_id"])
# 交叉表合并
table = pd.crosstab(table["user_id"], table["aisle"])

# 数据截取
table = table[:1000]

# 2 特征处理PCA
transfer = PCA(n_components=0.9)
data = transfer.fit_transform(table)


# 3机器学习（k-means）

estimator = KMeans(n_clusters=8, random_state=22)
y_predict = estimator.fit_predict(data)
# 4 模型评估

score = silhouette_score(data, y_predict)

print(score)