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

Posted 2021-12-11 HUTEROX

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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_)

朴素贝叶斯算法

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

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

联合概率
包含多个条件，且所有条件同时成立的概率
条件概率
就是时间A在另外一个时间B已经发生的条件下发生的概率
相互独立
如果P(A,B)=P(A)P(B)，则称事件A与事件B相互独立
贝叶斯公式
P(C|W)=( P(W|C)PC ) / P(W)
朴素
特征与特征之间相互独立
朴素贝叶斯算法
朴素 + 贝叶斯
应用分类
文本分类（单词作为特征）
拉普拉斯平滑系数
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

[信息论基础]

信息
香农：消除随机不确定的东西
信息的衡量 - 信息量 - 信息熵
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

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

[线性回归]

回归问题
目标值 - 连续型的数据
定义
函数关系(线性模型)：特征值和目标值建立关系
y = w1x1 + w2x2 + w3x3 + … + wnxn + b = wTx + b
广义线性模型
a. 自变量一次(线性关系)
y = w1x1 + w2x2 + w3x3 + … + wnxn + b = wTx + b
b. 参数一次(非线性关系)
y = w1x1 + w2x1^2 + w3x1^3 + w4x2^3 + … + b
线性回归的损失和优化原理
目标：求模型参数
损失函数/cost/成本函数/目标函数 – 最小 – 最小二乘法
优化损失（优化方法）
a. 正规方程（天才）
直接求解w
b. 梯度下降（勤奋努力的普通人）
试错、改进
分类
GD梯度下降：计算所有的样本的值才能得出梯度
SGD随机梯度下降：在一次迭代只考虑一个样本
SAG随机平均梯度法
回归性能评估
均方误差（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
以上是关于Sklearn机器学习基础（day02基础入门篇）的主要内容，如果未能解决你的问题，请参考以下文章 
 机器学习 ｜ 小编结语
 A.深度学习基础入门篇[二]：机器学习常用评估指标:AUCmAPISFIDPerplexityBLEUROUGE等详解
 web安全之机器学习入门——3.1 KNN/k近邻算法
 Pandas高级数据分析快速入门之二——基础篇
 python学习之路（基础篇）——python入门
 机器学习实战教程：决策树实战篇