Sklearn机器学习基础（day02基础入门篇）

基本算法使用（Sklearn)

到目前这一步涉及到了具体的算法使用，也就是调用 sklearn 的一些基本集成算法，那么关于 sklearn 的算法调用可以有一下调用规范(这些都是统一的，由于操作类似所有形成了规范)

（Ps：此时对于一些基本算法将不再进行数学推导，不太会，东西多 ，有些我很熟悉不想写，本博文为学习总结笔记结合 B站学习的浓缩精简笔记）

算子API调用分步曲

estimator 预估器

estimator = 某个算子 API（）

estimator.fit(x_train,y_train) 进行运算，训练对应的模型

estimator.predict(x_test) 进行预测（调用模型）

estimator.score(x_test,y_test) 进行模型预估评价

数据分析分步曲

1.加载数据

2.数据标准化，归一化

3.数据特征提取，降维 etc

4.数据切割划分，划分训练集，测试集

5.使用对于算子API

6.使用estimator 进行训练

7.对数据进行预测评估

8.根据测试结果进行优化

9.保存优化后的算法模型

那么接下来就是关于数据处理的一些算子。

分类算法

KNN 算法

描述：

​ 如果一个样本在特征空间中的k个最相似（k值）的大对数属于某一个类别，则该样本也属于这个类别。

​ 用于做分类预测！例如对地图地点分类，预测用户最喜欢聚集的地方（然后投放广告，参考 facebook 案例 ：预测facebook签到位置）

原理：

​ 对于一个样本，计算对应某个相似值与其他点的距离（例如通过欧式距离等）从而找到近似的点进行划分。

优点：

• 易于实现，无需训练

缺点：

• 懒惰算法，对测试样本分类时的计算量大，内存开销大
• 必须指定K值，K值选择不当则分类精度不能保证（此时需要通过一定的自我修正，在这里是sklearn 的网格修正）

对应 API：

from sklearn.neighbors import KNeighborsClassifier

代码示例：

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

#用KNN对鸢尾花进行分类
def knn_iris():
    """用KNN算法对鸢尾花进行分类"""
    #1.获取数据
    iris=load_iris()
    #2.划分数据集
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,random_state=6)
    #3.特征工程：标准化
    transfer=StandardScaler()
    x_train=transfer.fit_transform(x_train)
    x_test=transfer.transform(x_test)
    #4.KNN算法预估器
    estimator=KNeighborsClassifier(n_neighbors=3)
    estimator.fit(x_train,y_train)
    #5.模型评估
        #5.1 方法1：直接比对真实值和预测值
    y_predict=estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("直接比对真实值和预测值：\n",y_test==y_predict)
        #5.2 方法2：计算准确率
    score=estimator.score(x_test,y_test)
    print("准确率为：\n",score)

out:

y_predict:
[0 2 0 0 2 1 1 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 False 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.9210526315789

网格优化

from sklearn.model_selection import GridSearchCV

这个作用呢其实很简单，就是前面说的自动参数设置，也就是前面 estimator=KNeighborsClassifier(n_neighbors=3)

这个 n_neighbors 的数值其实那啥也是要不断的去试试的，那么这里sklearn 提供了一个方法来帮助我们去试一试这个参数的设置

from sklearn.datasets import load_iris
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 knn_iris_gsv():
    """用KNN算法对鸢尾花进行分类,添加网格搜索和交叉验证"""
    #1.获取数据
    iris=load_iris()
    #2.划分数据集
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,random_state=6)
    #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：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率

    estimator.fit(x_train,y_train)
    #5.模型评估
        #5.1 方法1：直接比对真实值和预测值
    y_predict=estimator.predict(x_test)
    print("y_predict:\n",y_predict)
    print("直接比对真实值和预测值：\n",y_test==y_predict)
        #5.2 方法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_)

重点在这：

param_dict={
    
    "n_neighbors":[1,3,5,7,9,11],}#估计器参数
    estimator=GridSearchCV(estimator,param_grid=param_dict,cv=10)#estimator：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率

KNN 案例 （预测facebook签到位置）

此案例为facebook 的定位 案例。

这个案例比较复杂的其实是数据清洗 也就是pandas 的数据清洗。这里详细说一下毕竟我觉得难点就是数据处理这一块。

数据集：

链接：https://pan.baidu.com/s/1nojpx6ovymtLJEr9CoBadw
提取码：6666

数据清洗

首先数据长这个样子：

   row_id       x       y  accuracy    time    place_id
0       0  0.7941  9.0809        54  470702  8523065625
1       1  5.9567  4.7968        13  186555  1757726713
2       2  8.3078  7.0407        74  322648  1137537235
3       3  7.3665  2.5165        65  704587  6567393236
4       4  4.0961  1.1307        31  472130  7440663949
(29118021, 6)

#1.获取数据 data = pd.read_csv("…/input/train.csv")

然后我们需要对数据进行基本处理，也就是说首先 要 把 time 进行格式转换，然后我们需要提取出训练集X 和 预测集Y

也就是提取之后长这个样子

Y 长这个样子

place_id
1014605271    28
1015645743     4
1017236154    31
1024951487     5
1028119817     4
Name: row_id, dtype: int64

那么具体代码是这样的：

	# 1)缩小数据范围
data=data.query(" x<2.5 & x>2 & y<1.5 & y>1.0")
	# 2)处理时间特征
time_value=pd.to_datetime(data["time"],unit="s")
data["day"]=date.day
data["weekdaty"]=date.weekday
data["hour"]=date.hour
	# 3)过滤掉次数少的地点
place_count=data.groupby("place_id").count()["row_id"]
data_final = data[data["place_id"].isin(place_count[place_count>3].index.values)]
	# 4)筛选特征值和目标值
x=data_final[["x","y","accuracy","day","weekdaty","hour"]]
y=data_final["place_id"]

KNN处理预测

这一步就是套口诀了：

	# 5)数据集划分
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：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率
estimator.fit(x_train,y_train)

#5.模型评估
    #5.1 方法1：直接比对真实值和预测值
y_predict=estimator.predict(x_test)
print("y_predict:\n",y_predict)
print("直接比对真实值和预测值：\n",y_test==y_predict)
    #5.2 方法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
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import GridSearchCV
# 1.获取数据
data=pd.read_csv("./FBlocation/train.csv")

# 2.基本数据处理
	# 1)缩小数据范围
data=data.query(" x<2.5 & x>2 & y<1.5 & y>1.0")
	# 2)处理时间特征
time_value=pd.to_datetime(data["time"],unit="s")
data["day"]=date.day
data["weekdaty"]=date.weekday
data["hour"]=date.hour
	# 3)过滤掉次数少的地点
place_count=data.groupby("place_id").count()["row_id"]
data_final = data[data["place_id"].isin(place_count[place_count>3].index.values)]
	# 4)筛选特征值和目标值
x=data_final[["x","y","accuracy","day","weekdaty","hour"]]
y=data_final["place_id"]
	# 5)数据集划分
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：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率
estimator.fit(x_train,y_train)

#5.模型评估
    #5.1 方法1：直接比对真实值和预测值
y_predict=estimator.predict(x_test)
print("y_predict:\n",y_predict)
print("直接比对真实值和预测值：\n",y_test==y_predict)
    #5.2 方法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_)

朴素贝叶斯算法

这个其实是类似于用概率预测的方式进行运算预测分类，其实就是问某一个玩意属于某一个类别（或者范围）的概率

朴素：这个是指假设忽略数据集的影响（数据集可能不完整）也就是假设在数据集里面的每一个元素都是独立的！

1. 联合概率
   包含多个条件，且所有条件同时成立的概率
2. 条件概率
   就是时间A在另外一个时间B已经发生的条件下发生的概率
3. 相互独立
   如果P(A,B)=P(A)P(B)，则称事件A与事件B相互独立
4. 贝叶斯公式
   P(C|W)=( P(W|C)PC ) / P(W)
5. 朴素
   特征与特征之间相互独立
6. 朴素贝叶斯算法
   朴素 + 贝叶斯
7. 应用分类
   文本分类（单词作为特征）
8. 拉普拉斯平滑系数
   P(F1|C) = (分子+α) / (分母+αm)
   α:指定的系数
   m:训练文档出现的特征总个数

调用 API：

from sklearn.naive_bayes import MultinomialNB

这个咱们直接上例子：

from sklearn.datasets import fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB

def nb_news():
    """
    用朴素贝叶斯算法对新闻进行分类
    :return:
    """
    #1.获取数据
    news = fetch_20newsgroups(subset="all")#subset="all"获取所有数据，train获取训练数据
    #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)

y_predict:
 [15  2 16 ... 11 10 18]
直接比对真实值和预测值:
 [False  True False ...  True  True  True]
准确率为：
 0.8503820033955858

(PS :这些玩意都是可以用网格优化的！)

决策树

这玩意懂的都懂！

参考 up:https://www.bilibili.com/video/BV1Xp4y1U7vW

[信息论基础]

1. 信息
   香农：消除随机不确定的东西
2. 信息的衡量 - 信息量 - 信息熵
   2.1 单位：bit
   2.2 信息增益
   g(D|A) = H(D)-H(D|A)
   2.3 决策树的划分依据之一 ------- 信息增益(越大越好)

优点：

• 可视化 - 可解释能力强

缺点：

• 决策树不能很好的用于过于复杂的树（过拟合）

改进：

• 减枝cart算法
• 随机森林

调用 ＡＰＩ

from sklearn.tree import DecisionTreeClassifier

案例

决策树对鸢尾花数据分类

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier,export_graphviz

def decision_iris():
    """用决策树对决策树对鸢尾花进行分类"""
    #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)

可视化决策树

export_graphviz(estimator,out_file=“iris_tree.dot”,feature_names=iris.feature_names)

这个会生成一个文件然后你放到网站去解析就好了。

随机森林

参考 up:https://www.bilibili.com/video/BV1H5411e73F?spm_id_from=333.999.0.0

一句话总结： 让多个森林去跑，然后统一一下。

[集成学习方法]
集成学习通过建立几个模型组合的来解决单一预测问题。它的工作原理是生成多个分类器/模型，各自独立地学习和作出预测。这些预测最后结合成组合预测，因此优于任何一个单分类的做出预测。
[随机森林]
随机：训练集随机，特征随机
森林：包含多个决策树的分类器

API

from sklearn.ensemble import RandomForestClassifier

数据集：

链接：https://pan.baidu.com/s/1cocizyxtizZMCGoyZvgQOg
提取码：6666

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

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV
#获取数据
path="./titanic.csv"
titanic=pd.read_csv(path)
#筛选特征值和目标值
x=titanic[["pclass","age","sex"]]
y=titanic["survived"]
#2.数据处理
	#2.1缺失值处理
x["age"].fillna(x["age"].mean(),inplace=True)
	#2.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：估计器对象，cv：几折交叉验证，fit():输入训练数据，score():准确率
estimator.fit(x_train,y_train)
#5.模型评估
    #5.1 方法1：直接比对真实值和预测值
y_predict=estimator.predict(x_test)
print("y_predict:\n",y_predict)
print("直接比对真实值和预测值：\n",y_test==y_predict)
    #5.2 方法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_)

回归与聚类算法

线性回归

参考up : https://www.bilibili.com/video/BV17T4y1J7SB?spm_id_from=333.999.0.0

这个老朋友了，来看老师给的定义：

[线性回归]

1. 回归问题
   目标值 - 连续型的数据
2. 定义
   函数关系(线性模型)：特征值和目标值建立关系
   y = w1x1 + w2x2 + w3x3 + … + wnxn + b = wTx + b
3. 广义线性模型
   a. 自变量一次(线性关系)
   y = w1x1 + w2x2 + w3x3 + … + wnxn + b = wTx + b
   b. 参数一次(非线性关系)
   y = w1x1 + w2x1^2 + w3x1^3 + w4x2^3 + … + b
4. 线性回归的损失和优化原理
   目标：求模型参数
   损失函数/cost/成本函数/目标函数 – 最小 – 最小二乘法
   优化损失（优化方法）
   a. 正规方程（天才）
   直接求解w
   b. 梯度下降（勤奋努力的普通人）
   试错、改进
   分类
   GD梯度下降：计算所有的样本的值才能得出梯度
   SGD随机梯度下降：在一次迭代只考虑一个样本
   SAG随机平均梯度法
5. 回归性能评估
   均方误差（MSE）评价机制

正规方程

API

from sklearn.linear_model import LinearRegression

特点：运算快，适合小样本数据

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():
    """正规方程的优化方法对波士顿房价进行预测"""
    #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=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)

梯度下降

这个上代码

from sklearn.linear_model import SGDRegressor

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

岭回归

在这里主要是前面的两个方法会有问题,如下：

[欠拟合与过拟合]

1. 训练集表现很好，测试集不好 - 过拟合
   2. 训练集表现不好，测试集不好 - 欠拟合
2. 原因及解决办法
   3.1 欠拟合
   原因：学习到数据的特征过少
   解决办法：增加数据的特征数量
   3.2 过拟合
   原因：原始特征过多，存在一些嘈杂特征，模型过于复杂是因为模型尝试去兼顾各个测试数据点
   解决办法：正则化
   L1-LASSO:损失函数 + λ惩罚项（|w|）
   L2-Ridge岭回归:更常用（损失函数 + λ惩罚项（w²））

所以为了解决这个问题引入了这个玩意

from sklearn.linear_model import Ridge

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

def linear3():
    """岭回归对波士顿房价进行预测"""
    #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=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)

逻辑回归与二分类

[逻辑回归的原理]

1. 输入：线性回归的输出就是逻辑回归的输入
2. 激活函数：代入sigmoid函数：1/(1+e^(-x))
3. 损失函数 对数似然损失
4. 优化损失：梯度下降

[二分类]

这个其实是那啥类似于森林的玩意，告诉最终结果是还是不是，具备两个值 真假，最典型的就是疾病预测之类的看看你有木有病

from sklearn.linear_model import LogisticRegression

这个和正规方程的不要搞混了

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

#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.缺失值处理
	#2.1替换-->np.nan
data=data.replace(to_replace="?",value=np.nan)
	#2.2删除缺失样本
data.dropna(inplace=True)
#筛选特征值和目标值
x=data.iloc[:,1:-1]
y=data["Class"]
#3.划分数据集
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)
#逻辑回归的模型参数：回归系数和偏置
print("特征参数：",estimator.coef_)
#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)

分类的评估

由于在这里我们发现这个这里的话比较特殊，这里的分类不是单单的类别分类，而是带有真假值的分类。并且对于数据来源也有点问题，由于在来源当中对于有病的（参照上例）元素在数据集里面占比可能不明显，这就导致在预测分类有病人群里面的结果可能不准确，所以我们需要对这玩意进行评估。

分类的评估方法]

1. 混淆矩阵
   TP真正例 = True Possitive
   FP伪正例 = False Possitive
   FN伪反例 = False Negative
   TN真反例 = True Negative
2. 精确率（Precision）与召回率（Recall）
   精确率：预测结果为正例样本中真实为正例的比例
   召回率：真实为正例的样本中预测结果为正例的比例（对正样本的区分能力）
   F1-score：模型的稳健型
3. ROC曲线与AUC指标（可以衡量样本不均衡下的评估）
   3.1 TPR: TP/(TP+FN)
   所有真实类别为1的样本中，预测类别为1的比例（召回率）
   3.2 FPR: FP/(FP+TN)
   所有真实类别为0的样本中，预测类别为1的比例
   3.3 AUC只能用来评价二分类(例如上例)
   AUC非常适合评价样本不平衡中的分类器性能

from sklearn.metrics import classification_report

from sklearn.metrics import roc_auc_score

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
from sklearn.metrics import roc_auc_score

#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.缺失值处理
	#2.1替换-->np.nan
data=data.replace(to_replace="?",value=np.nan)
	#2.2删除缺失样本
data.dropna(inplace=True)
#筛选特征值和目标值
x=data.iloc[:,1:-1]
y=data["Class"]
#3.划分数据集
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)
#逻辑回归的模型参数：回归系数和偏置
print("特征参数：",estimator.coef_)
#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=["良性","恶性"])
#AUC指标
#y_true:每个样本的真实类别，必须为0（反例），1（正例）标记
#y_test转换成 0 1
y_true=np.where(y_test>3,1,0)
auc=roc_auc_score(y_true,y_predict)
print("auc:\n",auc)

K-means 无监督聚类算法

[无监督学习]

1. 定义
   没有目标值 - 无监督学习

2. 包含的算法
   聚类：K-means(K均值聚类)
   降维：PCA
   [K-means算法步骤]

3. 随机设置K个特征空间内的点作为初始的聚类中心
   2. 对于其他每个点计算到K个中心的距离，未知的点选择最近的一个聚类中心点作为标记类别

   3. 接着对着标记的聚类中心之后，重新计算出每个聚类的新中心点（平均值）

   4. 如果计算得出的新中心点与原中心点一样，那么结束，否则重新进行第二步过程

   5. 优缺点

      优点：

      ​ 采用迭代式算法，直观易懂且非常实用

      缺点：

      ​ 容易收敛到局部最优解（解决：多次聚类）

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

API：

from sklearn.cluster import KMeans

评估：

from sklearn.metrics import silhouette_score

这个例子是一个：

探究用户对物品类别的喜好细分的，在这里的话就是通过聚类分析得到用户喜欢的物品的分类

这个早就有人做出来了

数据集：

链接：https://pan.baidu.com/s/1P9xwvyYAy16rckSKxYZEkA
提取码：6666

import pandas as pd
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.metrics import silhouette_score
#1.获取数据
order_products=pd.read_csv("./data/order_products__prior.csv")
products=pd.read_csv("./data/products.csv")
orders=pd.read_csv("./data/orders.csv")
aisles=pd.read_csv("./data/aisles.csv")
# 2、合并表
#合并aisles和products   aisle和product_id
tab1=pd.merge(aisles,products,on=["aisle_id","aisle_id"])[:100]
tab2=pd.merge(tab1,order_products,on=["product_id","product_id"])[:100]
tab3=pd.merge(tab2,orders,on=["order_id","order_id"])[:100]
#3.找到user_id和aisle之间的关系
table=pd.crosstab(tab3["user_id"],tab3["aisle"])
data=table[:10000]#取一部分节省时间
#4.PCA降维
#4.1实例化转换器类
transfer=PCA(n_components=0.95)
#4.2调用fit_transform
data_new=transfer.fit_transform(data)

#5.预估器流程
estimator=KMeans(n_clusters=3)
estimator.fit(data_new)
y_predict=estimator.predict(data_new)
#模型评估-轮廓系数
silhouette_num=silhouette_score(data_new,y_predict)
print("轮廓系数：\n",silhouette_num)

模型加载与保存

import joblib
1.保存
joblib.dump(estimator,'test.pkl')
2.加载
estimator = joblib.load('test.pkl')

总结导图（大致）