目录
1 将任意数据(如文本或图像)转换为可用于机器学习的数字特征---特征值化
3.1.4Tf-idf文本特征提取(选取更重要的词进行文本特征提取)
5.3.7 ROC曲线与AUC指标------精确率和召回率评估更进一步在样本不均衡时使用
5.5.5 案例:k-means对Instacart Market用户聚类
1.人工智能概述
1.1什么是机器学习
![](https://i-blog.csdnimg.cn/blog_migrate/5f94820245a4d882fd1ee5c415aae5d9.png)
![](https://i-blog.csdnimg.cn/blog_migrate/139dc66a4f15b58f941a42089add1a51.png)
从历史数据当中获得规律?这些历史数据是怎么的格式?
1.2 数据集构成
结构:特征值+目标值
例子:房屋价格的预测
![](https://i-blog.csdnimg.cn/blog_migrate/6f9825e50275b526ee24331b1a2592ab.png)
注:
1.对于每一行数据我们可以称之为样本。
![](https://i-blog.csdnimg.cn/blog_migrate/05bcb3b3336eb0355d7091d7aaa36373.png)
1.3机器学习算法分类
目标值:类别(离散型数据) - 分类问题
目标值:连续型数据 - 回归问题
目标值: 无 - 无监督学习
总结:
1.4机器学习的开发流程
1.5 学习框架和资料介绍
1.5.1 机器学习库、框架参考书籍
2.数据集
2.1学习阶段可用的数据集
1 Scikit-learn工具介绍
2.安装sklearn
pip install Scikit-learn
import sklearn
2.2 sklearn数据集
1.scikit-learn数据集API介绍
2.sklearn小数据集
3 sklearn大数据集
4 sklearn数据集的使用
字典两种获取属性的方式:
dict[key]=value
dict.key=value
2.3数据集的划分
数据集划分api
3.特征工程
3.1什么是特征工程
3.2特征工程与数据处理比较
![](https://i-blog.csdnimg.cn/blog_migrate/143bd500e007fe190e017f2aab7d871d.png)
![](https://i-blog.csdnimg.cn/blog_migrate/ae24d788482f474b1f1da8fa7fe159d1.png)
3.3特征抽取
1 将任意数据(如文本或图像)转换为可用于机器学习的数字特征---特征值化
特征值化是为了计算机更好的去理解数据
2.特征提取API特征提取API
sklearn . feature_extraction
3.3.1字典特征提取
![](https://i-blog.csdnimg.cn/blog_migrate/fc3d0c3ad47f837735d15c1ad7c8c4dc.png)
sparse=True返回的数值为稀疏矩阵形式:
这种形式便于显示特征值种类非常多时(矩阵显示0非常多)
sparse=false 返回矩阵形式:
1 应用
[{ 'city' : ' 北京 ' , 'temperature' : 100 }{ 'city' : ' 上海 ' , 'temperature' : 60 }{ 'city' : ' 深圳 ' , 'temperature' : 30 }]
![](https://i-blog.csdnimg.cn/blog_migrate/a95591a67dc9c9449f3d8cad6a58a92b.png)
3.1.2文本特征提取
统计每个词出现的次数。
stop_words将列表中的词不出现在特征名称中
1 应用
我们对以下数据进行特征提取
[ "life is short,i like python" ,"life is too long,i dislike python" ]
![](https://i-blog.csdnimg.cn/blog_migrate/75bd2ce0d2c4734d5f97ca2ac36e1398.png)
返回每句话中特征名称出现的次数:
3.1.3中文文本特征提取
1.jieba分词处理
#分词函数
def cut_word(text):
""" 对中文进行分词 "我爱北京天安门"————>"我 爱 北京 天安门"
:param text: :return: text """
textlist=list(jieba.cut(text))
# print(" ".join(textlist))
new_text=" ".join(textlist)
#text = " ".join(list(jieba.cut(text)))
return new_text
2.特征提取
def count_chinese_demo():
#中文文本特征抽取函数,自动分词
data=["今天很残酷,明天更残酷,后天很美好, 但绝对大部分是死在明天晚上,所以每个人不要放弃今天。",
" 我们看到的从很远星系来的光是在几百万年之前发出的, 这样当我们看到宇宙时,我们是在看它的过去。",
" 如果只用一种方式了解某样事物,你就不会真正了解它。 了解事物真正含义的秘密取决于如何将其与"
"我们所了解的事物相联系。"]
#存储分词后的data
text_list=[]
#对列表的每个单元进行分词
for i in data:
# print(i)
text_list.append(cut_word(i))
print(text_list)
# 1.实例一个转换器类
transfer=CountVectorizer(stop_words=[])
# 2.调用转换方法fit_transform
data_new=transfer.fit_transform(text_list)
print("new_data:\n", data_new.toarray())
print("特征名称:\n", transfer.get_feature_names())
return None
运行结果:
3.1.4Tf-idf文本特征提取(选取更重要的词进行文本特征提取)
1.公式
例子:
2.TF-IDF的特征提取API
3.特征提取函数
def tfidf_demo():
"""
用TF-IDF进行文本特征提取(选取更为关键的特征词进行提取)
:return:
"""
data = ["今天很残酷,明天更残酷,后天很美好, 但绝对大部分是死在明天晚上,所以每个人不要放弃今天。",
" 我们看到的从很远星系来的光是在几百万年之前发出的, 这样当我们看到宇宙时,我们是在看它的过去。",
" 如果只用一种方式了解某样事物,你就不会真正了解它。 了解事物真正含义的秘密取决于如何将其与"
"我们所了解的事物相联系。"]
# 特征名称列表
text_list = []
# 对列表的每个单元进行分词
for i in data:
# print(i)
text_list.append(cut_word(i))
print(text_list)
transfer=TfidfVectorizer()
new_data=transfer.fit_transform(text_list)
print("new_data;\n",new_data.toarray())
print("特征名称:\n",transfer.get_feature_names())
return None
4.输出内容
3.4特征预处理
3.4.1什么是特征预处理
示例:
# scikit-learn 的解释provides several common utility functions and transformer classes to change rawfeature vectors into a representation that is more suitable for the downstreamestimators .
![](https://i-blog.csdnimg.cn/blog_migrate/61741bb38befba1889d530e50c9d6c79.png)
2 特征预处理API
sklearn.preprocessing
3.4.2归一化
1 定义
通过对原始数据进行变换把数据映射到(默认为[0,1])之间。
2 公式
示例:计算特征1第一个数据90的X''
3 API
我们对以下数据进行运算:
milage , Liters , Consumtime , target40920 , 8.326976 , 0.953952 , 314488 , 7.153469 , 1.673904 , 226052 , 1.441871 , 0.805124 , 175136 , 13.147394 , 0.428964 , 138344 , 1.669788 , 0.134296 , 1
![](https://i-blog.csdnimg.cn/blog_migrate/1775d767eb0f9af6452234415abeb84b.png)
运行结果:
![](https://i-blog.csdnimg.cn/blog_migrate/8ec921be6c30af98585d7e0f412ec627.png)
3.4.3标准化(相较于归一化受异常点的影响较小)
![](https://i-blog.csdnimg.cn/blog_migrate/0eba173f77537d2114e7203054b96008.png)
🔺视频解释
3 API
4 数据计算
def stand_demo():
"""
标准化
:return:
"""
# 1.使用pandas库获取数据
data = pd.read_csv("dating.txt")
# pandas的iloc函数选取指定的行和列(此为选取全部行和前三列)
data = data.iloc[:, :3]
print("data\n", data)
# 2.实例化一个转换器类
transfer = StandardScaler()
# 3.调用fit_transform对数据进行归一化
new_data = transfer.fit_transform(data)
print("new_data:\n", new_data)
return None
5.输出(数据处在均值为零,标准差为一)
6 标准化总结
在已有样本足够多的情况下比较稳定,适合现代嘈杂大数据场景。
3.5 特征降维
3.5.1降维
![](https://i-blog.csdnimg.cn/blog_migrate/af4aa4c287a03cd2e5903693b035cfec.png)
![](https://i-blog.csdnimg.cn/blog_migrate/2606888c6aceec72216cf5a3a09fc8ef.png)
3.5.2 降维的两种方式
3.5.3 特征选择
![](https://i-blog.csdnimg.cn/blog_migrate/d80d81c45c94533068cb9c5047b851c6.png)
3 模块
sklearn . feature_selection
![](https://i-blog.csdnimg.cn/blog_migrate/224f7ad8689b7187a6114d88faa0cbbe.png)
4.1.1 API
删除方差小于2的数据:
def variance_demo():
"""
过滤低方差特征
:return:
"""
data=pd.read_csv("factor_returns.csv")
data=data.iloc[:,1:-2]
print("data:\n",data)
# 2.实例化一个转换器类
transfer=VarianceThreshold(threshold=2)
# 3.调用fit_transform对数据进行归一化
data_new=transfer.fit_transform(data)
print("data_new:\n",data_new,data_new.shape)
return None
![](https://i-blog.csdnimg.cn/blog_migrate/c174f5597184b0d5aa4cdb603cacbe4d.png)
4.2 相关系数
4.2.1 公式计算案例
= 0.9942
![](https://i-blog.csdnimg.cn/blog_migrate/6760be604bb137d783e9246c6a4cfac7.png)
4.2.3 API
安装 :
4.2.4 案例:股票的财务指标相关性计算
factor =[ 'pe_ratio' , 'pb_ratio' , 'market_cap' , 'return_on_asset_net_profit' , 'du_return_on_equity' , 'ev' , 'earnings_per_share' , 'revenue' , 'total_expense' ]
两两特征之间进行相关性计算:
运行结果:
from scipy.stats import pearsonr
def variance_demo():
"""
过滤低方差特征&&&计算两两特征之间进行相关性
:return:
"""
data=pd.read_csv("factor_returns.csv")
data=data.iloc[:,1:-2]
print("data:\n",data)
#1.删除方差小于2的列
transfer=VarianceThreshold(threshold=2)
data_new=transfer.fit_transform(data)
print("data_new:\n",data_new,data_new.shape)
#2.计算两两特征之间进行相关性
r1=pearsonr(data['pe_ratio'],data['pb_ratio'])
print("相关系数:\n",r1)
r2=pearsonr(data['revenue'],data['total_expense'])
print("revenue和total_expense的相系数:\n",r2)
return None
输出:
指标revenue与指标total_expense之间的相关性大小为0.995845,很高我们也可以通过画图来观察结果,使用python绘画库matplotlib来展示。
这两对指标之间的相关性较大,可以做之后的处理,比如合成这两个指标。
3.5.4主成分分析(PCA)
1 计算案例理解
假设对于给定5个点,数据如下
(-1,-2)(-1, 0)( 0, 0)( 2, 1)( 0, 1)
![](https://i-blog.csdnimg.cn/blog_migrate/e1a52e0ef239fba6a2c69c5a7f1ee7b1.png)
要求:将这个二维的数据简化成一维? 并且损失少量的信息。
2.API
3 数据计算
先拿个简单的数据计算一下
输出结果:
3.6.5 案例:探究用户对物品类别的喜好细分降维
![](https://i-blog.csdnimg.cn/blog_migrate/0b9abbeef3a67d3c00ae656d6698d6ac.png)
4.分类问题、分类算法
区别分类问题:目标值为类别。
内容:
4.1 sklearn转换器和估计器
4.1.1转换器---特征工程的父类
之前做特征工程的步骤:
这三个方法的联系,例子:
4.1.2估计器(sklearn机器学习算法的实现)
1. sklearn估计器工作流程
4.2 K-近邻算法(KNN算法)
4.2.1什么是k近邻算法
1 定义
想要知道自己所在哪个区,只需知道离自己最近的人的位置,那个人所在的区就极大可能是我所在的区。你的“邻居”来推断出你的类别。
2、电影类型分析
3、K-近邻算法API
4.案例一:鸢尾花种类预测
操作步骤:
代码实现:
输出结果:
优缺点:
4.3模型选择与调优
内容
4.3.1交叉验证(cross validation)
什么是交叉验证:
![](https://i-blog.csdnimg.cn/blog_migrate/c7b4aa274301ccaef3308ebfdaf4a386.png)
问题:那么这个只是对于参数得出更好的结果,那么怎么选择或者调优参数呢?
4.3.2 超参数搜索-网格搜索(Grid Search)
4.3.3模型选择与调优API
4.3.4鸢尾花案例增加交叉验证和网格搜索(k值调优)
修改后:
def knn_iris_gscv():
"""
用knn算法对鸢尾花进行分类
改进:
1)使用交叉验证(cross validation)得出更准确结果
2)K值选择使用超参数搜索-网格搜索(Grid Search),优化k值选择
:return:
# """
# 1)获取数据
iris = load_iris()
# 2)数据集划分
x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.25,random_state=6)
# 3)特征工程# 标准化
transfer=StandardScaler()
x_train=transfer.fit_transform(x_train)
#测试集也而要标准化
#在训练集中已经求得了平均值和标准差(fit()方法),要使得训练集和测试集对数据的处理一致,
# 因此使用训练集的平均值和标准差。
x_test=transfer.transform(x_test)
# 4)KNN预估器流程 n_neighbors=3表示k值取3
#参数准备(k值列表)
estimator=KNeighborsClassifier()
# 加入网格搜索和交叉验证
parm_dict = {'n_neighbors': [1, 3, 5, 7, 9, 11]}
estimator=GridSearchCV(estimator,param_grid=parm_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_predict==y_test)
# 方法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
运行结果:
y_predict:
[0 2 0 0 2 1 2 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 True 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.9473684210526315
最佳参数:
{'n_neighbors': 11}
最佳结果:
0.9734848484848484
最佳预估器:
KNeighborsClassifier(n_neighbors=11)
交叉验证结果:
{'mean_fit_time': array([0.00059831, 0.00059786, 0.00059869, 0.00029881, 0.00060213,
0.00049853]), 'std_fit_time': array([0.00048852, 0.00048815, 0.00048883, 0.00045644, 0.00049194,
0.00049853]), 'mean_score_time': array([0.00109718, 0.00119801, 0.00109665, 0.00110698, 0.00099375,
0.00119359]), 'std_score_time': array([0.00029994, 0.00059937, 0.00029797, 0.00031232, 0.00043974,
0.00040174]), 'param_n_neighbors': masked_array(data=[1, 3, 5, 7, 9, 11],
mask=[False, False, False, False, False, False],
fill_value='?',
dtype=object), 'params': [{'n_neighbors': 1}, {'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}, {'n_neighbors': 11}], 'split0_test_score': array([1., 1., 1., 1., 1., 1.]), 'split1_test_score': array([0.91666667, 0.91666667, 1. , 0.91666667, 0.91666667,
0.91666667]), 'split2_test_score': array([1., 1., 1., 1., 1., 1.]), 'split3_test_score': array([1. , 1. , 1. , 1. , 0.90909091,
1. ]), 'split4_test_score': array([1., 1., 1., 1., 1., 1.]), 'split5_test_score': array([0.90909091, 0.90909091, 1. , 1. , 1. ,
1. ]), 'split6_test_score': array([1., 1., 1., 1., 1., 1.]), 'split7_test_score': array([0.90909091, 0.90909091, 0.90909091, 0.90909091, 1. ,
1. ]), 'split8_test_score': array([1., 1., 1., 1., 1., 1.]), 'split9_test_score': array([0.90909091, 0.81818182, 0.81818182, 0.81818182, 0.81818182,
0.81818182]), 'mean_test_score': array([0.96439394, 0.95530303, 0.97272727, 0.96439394, 0.96439394,
0.97348485]), 'std_test_score': array([0.04365767, 0.0604591 , 0.05821022, 0.05965639, 0.05965639,
0.05742104]), 'rank_test_score': array([5, 6, 2, 3, 3, 1])}
PS:KNN算法计算距离:
欧氏距离
曼哈顿距离(绝对值距离)
明可夫斯基距离(此是欧氏距离和曼哈顿距离的推广)
查看使用的距离公式;
4.4案例:Facebook签到位置预测K值调优
为防止每次运行调试都需要重新加载数据,使用jupyter进行调试。
流程分析: 1)获取数据 2)数据处理 目的: 特征值 x 目标值 y a.缩小数据范围 2 < x < 2.5 1.0 < y < 1.5(此处x、y为坐标) b.time -> 年月日时分秒 c.过滤签到次数少的地点 数据集划分 3)特征工程:标准化 4)KNN算法预估流程 5)模型选择与调优 6)模型评估
jupyter代码展示:
4.5朴素贝叶斯算法
4.5.1 什么是朴素贝叶斯分类方法
根据概率预测类别。
4.5.2 概率基础
2.条件概率与联合概率
🔺相互独立: P(A, B) = P(A)P(B) <=> 事件A与事件B相互独立。
4.5.3贝叶斯公式&朴素贝叶斯公式
贝叶斯公式解释:
当输入x时,想根据贝叶斯公式求出x的所属类别,就需要知道,在各个类别的情况下出现x的概率,取出现X=x的最大概率对应的类别作为输出。
贝叶斯公司是逆概率公式,即求在第k个类别情况下出现X=x的概率,取最大值。
朴素?
假设:特征与特征之间是相互独立
朴素贝叶斯算法:
朴素 + 贝叶斯
例子:
朴素贝叶斯算法应用场景: 文本分类
单词作为特征
拉普拉斯平滑系数
4.5.4拉普拉斯平滑系数
例子:文章分类计算
4.5.5 朴素贝叶斯算法API
4.5.6案例:20类新闻分类
步骤:
1)获取数据 2)划分数据集 3)特征工程 文本特征抽取 4)朴素贝叶斯预估器流程 5)模型评估
代码展示:
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)特征工程
# 文本特征抽取
transfer=TfidfVectorizer()
x_train=transfer.fit_transform(x_train)
x_test=transfer.transform(x_test)
# 4)朴素贝叶斯预估器流程(默认拉普拉斯平滑系数alpha=1)
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
结果:
y_predict:
[ 6 14 7 ... 3 12 15]
直接比对真实值和与测试:
[ True True True ... True True False]
准确率成为:
0.8612054329371817
4.5.7朴素贝叶斯算法评价
4.6决策树
内容:
4.6.1认识决策树
如何高效的进行决策?
特征的先后顺序
例子:决策树分类原理详解
已知 四个特征值 预测 是否贷款给某个人?
先看房子 -> 再工作 -> 决定是否贷款 只看了两个特征 年龄 -> 信贷情况 -> 工作 -> 决定是否贷款 看了三个特征
4.6.2信息论基础
1)信息 香农说信息是:消除随机不定性的东西 小明 年龄 “我今年18岁” - 信息 小华 ”小明明年19岁” - 不是信息
2)信息的衡量 - 信息量 - 信息熵 bit g(D,A) = H(D) - 条件熵H(D|A)
2.决策树的划分依据之一------信息增益
![](https://i-blog.csdnimg.cn/blog_migrate/4f585380c7f9d138412b0219e983a012.png)
4.6.3决策树的三种算法实现![](https://i-blog.csdnimg.cn/blog_migrate/c910f04d195da9755f800b324721704a.png)
4.6.4 决策树API
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)决策树预估器
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)
return None
4.6.6 决策树可视化
1. API
保存树的结构到dot文件
2.代码
3.对生成的.dot文件进行展示
4.6.7案例:泰坦尼克号乘客生存预测
流程分析: 特征值 目标值 1)获取数据 2)数据处理 缺失值处理 特征值 -> 字典类型 3)准备好特征值 目标值 4)划分数据集 5)特征工程:字典特征抽取 6)决策树预估器流程 7)模型评估
#划分数据集
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier,export_graphviz
import pandas as pd
from sklearn.feature_extraction import DictVectorizer
def decision_titanic():
"""
决策树预测泰坦尼克获救的人
:return:
"""
# 1)获取数据
path = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt"
titanic = pd.read_csv(path)
#筛选目标值和特征值
x = titanic[["pclass", "age", "sex"]]
y = titanic[["survived"]]
# 2)数据处理
# 缺失值处理
x["age"].fillna(x["age"].mean(),inplace=True)
# 特征值 -> 字典类型
x=x.to_dict(orient="recorda")
# 3)划分数据集
x_train,x_text,y_train,y_test=train_test_split(x,y,random_state=22)
# 4)特征工程:字典特征抽取
transfer=DictVectorizer()
x_train=transfer.fit_transform(x_train)
x_text=transfer.transform(x_text)
# 5)决策树预估器流程
estimator=DecisionTreeClassifier(criterion="entropy",max_depth=8)
estimator.fit(x_train,x_text)
# 6)模型评估
#方法1:直接对比真实值和预测值
y_predict=estimator.predict(x_text)
print("y_predict:\n", y_predict)
print("直接比对真实值和与测试:\n", y_test == y_predict)
#方法2:计算准确率
score=estimator.score(x_text,y_test)
print("准确率成为:\n", score)
# 可视化决策树
export_graphviz(estimator, out_file="titanic_tree.dot", feature_names=transfer.get_feature_names())
return None
4.6.8优缺点
4.7随机森林---决策树的改进
1.、什么是集成学习方法
![](https://i-blog.csdnimg.cn/blog_migrate/622b828a9fe0f819c95f67e4cbdb100c.png)
4、 为什么采用BootStrap抽样
![](https://i-blog.csdnimg.cn/blog_migrate/b1bcfd2a3c21ad82403d0e39ee0608ff.png)
3-4总结: 训练集: N个样本 特征值 目标值 M个特征 随机 两个随机 训练集随机 - N个样本中随机有放回的抽样N个 bootstrap 随机有放回抽样 [1, 2, 3, 4, 5] 新的树的训练集 [2, 2, 3, 1, 5] 特征随机 - 从M个特征中随机抽取m个特征 M >> m 降维
5、API
![](https://i-blog.csdnimg.cn/blog_migrate/c22f30ab1a282e87accb6167b8f4b9ea.png)
6.示例
#随机森林
from sklearn.ensemble import RandomForestClassifier
#网格搜索、交叉验证
from sklearn.model_selection import GridSearchCV
def randomForest_demo():
"""
随机森林
:return:
"""
# 1)获取数据
path = "http://biostat.mc.vanderbilt.edu/wiki/pub/Main/DataSets/titanic.txt"
titanic = pd.read_csv(path)
# 筛选目标值和特征值
x = titanic[["pclass", "age", "sex"]]
y = titanic[["survived"]]
# 2)数据处理
# 缺失值处理
x["age"].fillna(x["age"].mean(), inplace=True)
# 特征值 -> 字典类型
x = x.to_dict(orient="recorda")
# 3)划分数据集
x_train, x_text, y_train, y_test = train_test_split(x, y, random_state=22)
# 4)特征工程:字典特征抽取
transfer = DictVectorizer()
x_train = transfer.fit_transform(x_train)
x_text = transfer.transform(x_text)
# 5)决策树预估器流程
estimator=RandomForestClassifier()
# 加入网格搜索和交叉验证
parm_dict = {'n_estimators': [120,200,300,500,800,1200],
"max_depth": [5, 8, 15, 25, 30]}
estimator = GridSearchCV(estimator, param_grid=parm_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_predict == y_test)
# 方法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
7.总结
能够有效地运行在大数据集上, 处理具有高维特征的输入样本,而且不需要降维
5. 回归与聚类算法
5.1线性回归
回归问题:
目标值 - 连续型的数据
5.1.1线性回归的原理
1.线性回归应用场景
2. 什么是线性回归
![](https://i-blog.csdnimg.cn/blog_migrate/5196f88edba18b97a6b868abeb1aec2c.png)
那么怎么理解呢?我们来看几个例子
![](https://i-blog.csdnimg.cn/blog_migrate/53b6b81fb5b92781ebd90341c34f77a1.png)
2.两个特征 y=w1x1+w2x2+b
![](https://i-blog.csdnimg.cn/blog_migrate/38e5b51c966db7cc7ec1967af561a23a.png)
广义线性模型 非线性关系? 线性模型 自变量一次 y = w1x1 + w2x2 + w3x3 + …… + wnxn + b 或参数一次 y = w1x1 + w2x1^2 + w3x1^3 + w4x2^3 + …… + b线性关系&线性模型 线性关系一定是线性模型 线性模型不一定是线性关系(参数一次高次方程也可是线性模型)
5.1.2 线性回归的损失和优化原理(理解记忆)
假设刚才的房子例子,真实的数据之间存在这样的关系
真实关系:真实房子价格 = 0.02×中心区域的距离 + 0.04×城市一氧化氮浓度 + (-0.12×自住房平均房价) + 0.254×城镇犯罪率
那么现在呢,我们随意指定一个关系(猜测)
随机指定关系:预测房子价格 = 0.25×中心区域的距离 + 0.14×城市一氧化氮浓度 + 0.42×自住房平均房价 + 0.34×城镇犯罪率
请问这样的话,会发生什么?真实结果与我们预测的结果之间是不是存在一定的误差呢?类似这样样子
那么存在这个误差,我们将这个误差给衡量出来----损失函数
5.1.3损失函数
使用损失函数的目的是为了求得一组权重和偏置使得得出的损失函数结果最小,则确定这组权重和偏执确定的线性回归模型是最优的,用此线性模型预测输入数据。所以需要一种好的优化方法来快速得出最好的权重和偏执,所以引出下面的优化损失。
优化损失:
1)正规方程---天才 - 直接求解W
拓展:
1)一般方程求最小值 求导-》找极值
y = ax^2 + bx + c
y' = 2ax + b = 0
x = - b / 2a
2)多个自变量使用矩阵求导 求导结果=零 找最小值
根据此公式直接求多个特征值的损失函数的最小值(只求一个最小值就认为这个是最小值了)。
线性代数逆矩阵:
a * b = 1
b = 1 / a = a ^ -1
A * B = E
[[1, 0, 0],
[0, 1, 0],
[0, 0, 1]]
B = A ^ -1
2)梯度下降---勤奋努力的普通人(试错、改进)
w为权重,每次迭代由上一步中的权重 - 右面的式子 得到新的权重。
优化动态图演示:
5.1.5线性回归API
5.1.6案例:波士顿房价预测(构建回归模型)
流程:
1)获取数据集
2)划分数据集
3)特征工程:
无量纲化 - 标准化
4)预估器流程
fit() --> 模型
coef_ intercept_
5)模型评估
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
def linear1_demo():
"""
:return:
"""
# 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)预估器流程
# fit() --> 模型
# coef_intercept_
estimator=LinearRegression()
estimator.fit(x_train,y_train)
# 5)得出模型
print("正规方程回归系数:\n",estimator.coef_)
print("正规方程偏置:\n",estimator.intercept_)
# 6) 模型评估
return None
def linear2_demo():
"""
:return:
"""
# 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)预估器流程
# fit() --> 模型
# coef_intercept_
estimator = SGDRegressor()
estimator.fit(x_train, y_train)
# 5)得出模型
print("梯度下降回归系数:\n", estimator.coef_)
print("梯度下降偏置:\n", estimator.intercept_)
# 6) 模型评估
return None
输出:
特征数量:
(506, 13)
正规方程回归系数:
[-0.64817766 1.14673408 -0.05949444 0.74216553 -1.95515269 2.70902585
-0.07737374 -3.29889391 2.50267196 -1.85679269 -1.75044624 0.87341624
-3.91336869]
正规方程偏置:
22.62137203166228
梯度下降回归系数:
[-0.49685791 0.82945265 -0.44904987 0.77017342 -1.5905398 2.84740953
-0.14191001 -3.04706359 1.49911167 -0.77102381 -1.68090541 0.90278836
-3.87831614]
梯度下降偏置:
[22.61379951]
5.1.7回归性能评估--均方误差&&均方误差API
梯度下降示例:
def linear2_demo():
"""
:return:
"""
# 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)预估器流程
# fit() --> 模型
# coef_intercept_
estimator = SGDRegressor()
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)
#==============================================================
return None
输出:
梯度下降偏置:
[22.62725463]
预测房价:
[28.33648346 31.64925471 21.45323971 32.73584022 20.23269316 19.06439937
21.37468545 19.44983911 19.68487021 32.83818668 21.3746111 27.35382152
15.61457037 19.96877171 37.02305785 18.68896562 9.52463014 18.63973978
30.80512492 24.33326585 19.04586688 34.05742222 29.55234607 17.43110409
34.85563544 26.53293355 34.38006123 27.3851111 19.10374887 15.70777825
30.7920448 14.54128578 37.49094738 8.56553308 16.39938929 16.89607725
7.63108939 19.83317127 40.55341756 29.19467967 25.29074762 17.81436972
39.3018985 6.67786656 21.61211625 25.07435036 20.78287331 20.66842851
17.06646181 26.29296984 9.63305316 27.20212435 30.67456302 16.65888048
9.5380822 35.46054702 31.58345186 22.90472434 17.59026841 21.86963363
23.67527921 23.98648824 20.36168555 38.2309461 25.68958611 19.68174375
14.10640059 6.65001684 42.46830478 21.88643167 16.78651968 22.58417476
40.88565056 21.74918887 36.88133169 27.18393984 21.79862869 20.80208214
25.34151666 23.69078482 31.51947987 20.22878362 24.02004822 31.47077052
27.24813849 20.88419774 29.1136252 21.98292327 26.75724321 18.85982568
25.22917134 24.01079813 19.92125414 17.4902074 15.45073178 18.30723881
24.60844512 16.72053076 20.7047491 26.80799486 20.7125933 17.94692741
24.14462134 23.28156607 20.37128754 36.62051001 16.01721086 22.44081692
32.69996248 33.7693516 20.57483253 26.06077218 23.18527011 17.71411771
21.50225286 21.74546817 27.49591692 25.22522658 23.68445355 14.45388553
15.58661742 3.64089337 29.26363916 20.65912385 22.3362939 28.09095789
28.4010181 ]
梯度下降均方误差:
21.141190509193216
预估器调参:以获得不同的均方误差
5.1.8正规方程和梯度下降对比
sklearn指导如何选择分类方法
5.1.9梯度下降优化方法---GD、SGD、SAG
1. GD
梯度下降(Gradient Descent),原始的梯度下降法需要计算所有样本的值才能够得出梯度,计算量大,所以后面才有会一系列的改进。
2. SGD
3. SAG
5.2欠拟合与过拟合
5.2.1什么是过拟合与欠拟合
欠拟合:一个假设在训练数据上不能获得更好的拟合,并且在测试数据集上也不能很好地拟合数
解决: 增加数据的特征数量
过拟合:个假设在训练数据上能够获得比其他假设更好的拟合, 但是在测试数据集上却不能很好
解决: 正则化 L1 损失函数 + λ惩罚项 LASSO L2 更常用 损失函数 + λ惩罚项 Ridge - 岭回归
5.2.2过拟合解决
解决: 正则化 L1 损失函数 + λ惩罚项 LASSO L2 更常用 损失函数 + λ惩罚项 Ridge - 岭回归
正则化类别
可以看作新的损失函数,旧损失函数+惩罚项,在降低新损失函数的同时,必不可少的也把权重减少了,高次函数系数减少,回归模型就减少了过拟合。
🔺?
5.2.3 带有L2正则化的线性回归-岭回归
![](https://i-blog.csdnimg.cn/blog_migrate/b020d536412304576b1ad11f6e059466.png)
5.2.4观察正则化程度的变化,对结果的影响?
![](https://i-blog.csdnimg.cn/blog_migrate/a106291011371f982b773c27abcdda63.png)
5.2.5岭回归-波士顿房价预测
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
def linear3_demo():
"""
岭回归--波士顿房价预测
:return:
"""
# 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)预估器流程
# fit() --> 模型
# coef_intercept_
estimator = Ridge(alpha=0.1,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)
#==============================================================
return None
5.3分类算法-逻辑回归与二分类
![](https://i-blog.csdnimg.cn/blog_migrate/0c6808b3d9b67c92e5bc37f958801c00.png)
5.3.1逻辑回归的应用场景
正例 / 反例
5.3.2逻辑回归的原理
线型回归的输出 就是 逻辑回归 的 输入
1 输入
2 激活函数
1/(1 + e^(-x)) 此处使用矩阵形式表示方程
5.3.3 损失以及优化
线性回归预测求误差使用最小二乘法或者均方误差,但在此处逻辑回归中预测值属于某个类别,显然不能用最小二乘法或者均方误差(预测结果都不是具体数值,而是所属的类别)
ps: 均方误差方程 = (y_predict - y_true)平方和/总数
那么如何去衡量逻辑回归的预测结果与真实结果的差异呢?
1.损失
横坐标预测值,纵坐标误差。
当需要预测数据真实值属于这个类别(y=1),预测值越接近1(横坐标),表明预测的误差越小(纵坐标越接近零)。
2 优化
同样使用梯度下降优化算法,去减少损失函数的值。这样去更新逻辑回归前面对应算法的权重参数,提升原本属于1类别的概率,降低原本是0类别的概率。
5.3.4逻辑回归API
5.3.5 案例:癌症分类预测-良/恶性乳腺癌肿瘤预测
- 数据介绍
原始数据的下载地址:https://archive.ics.uci.edu/ml/machine-learning-databases/
数据描述
(1)699条样本,共11列数据,第一列用语检索的id,后9列分别是与肿瘤
相关的医学特征,最后一列表示肿瘤类型的数值。
(2)包含16个缺失值,用”?”标出。
流程分析: 1)获取数据 读取的时候加上names 2)数据处理 处理缺失值 3)数据集划分 4)特征工程: 无量纲化处理-标准化 5)逻辑回归预估器 6)模型评估
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
def cancer_demo():
# 1)获取数据
# 读取的时候加上names
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)数据处理
# 处理缺失值 1.替换-》np.nan 2.删除缺失样本(将替换了nan的项删除)
data=data.replace(to_replace="?",value=np.nan)
data.dropna(inplace=True)
# 3)数据集划分
#1.筛选特征值和目标值
x=data.iloc[:,1:-1]
y=data["Class"]
#2.划分训练集和测试集
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)
# 6)模型评估
#1.得出模型
print("模型回归系数(权重):/n",estimator.coef_)
print("模型偏执:/n",estimator.intercept_)
#2.模型评估
y_predict=estimator.predict(x_test)
#对比
print("Y_predict:/n",y_predict)
print("预测值和真实值对比/n",y_predict==y_test)
score=estimator.score(x_test,y_test)
print("准确率为/n",score)
return None
5.3.6分类的评估方法
在很多分类场景当中我们不一定只关注预测的准确率!!!!!比如以这个癌症举例子!!!我们并不关注预测的准确率,而是关注在所有的样本当中,癌症患者有没有被全部预测(检测)出来。
1 精确率与召回率
1)混淆矩阵
TP = True Possitive FN = False Negative
2 精确率(Precision)与召回率(Recall)
精确率 真实所患癌症占预测结果的比例。 召回率 真是患癌症,能够被查得出来的概率(查得全不全)。
3 分类评估报告API
使用ROC曲线和AUC指标进行模型评估(上面这个小例子):
准确率:99%
召回率:99/99 = 100%
精确率:99%
F1-score: 2*99%/ 199% = 99.497%
AUC:0.5 -----》 得出这是很差的模型
TPR = 100%
FPR = 1 / 1 = 100%
加入精确率和召回率分类评估后代码:
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
#逻辑回归分类评估API精确率和召回率
from sklearn.metrics import classification_report
def cancer_demo():
# 1)获取数据
# 读取的时候加上names
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)数据处理
# 处理缺失值 1.替换-》np.nan 2.删除缺失样本(将替换了nan的项删除)
data=data.replace(to_replace="?",value=np.nan)
data.dropna(inplace=True)
# 3)数据集划分
#1.筛选特征值和目标值
x=data.iloc[:,1:-1]
y=data["Class"]
#2.划分训练集和测试集
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)
# 6)模型评估
#1.得出模型
print("模型回归系数(权重):/n",estimator.coef_)
print("模型偏执:/n",estimator.intercept_)
#2.模型评估
y_predict=estimator.predict(x_test)
#对比
print("Y_predict:/n",y_predict)
print("预测值和真实值对比/n",y_predict==y_test)
score=estimator.score(x_test,y_test)
print("准确率为",score)
report=classification_report(y_test,y_predict,labels=[2,4],target_names=["良性","恶行"])
print("评估报告",report)
return None
输出:
模型回归系数(权重):/n [[1.17598079 0.16853151 0.83067016 0.97467652 0.24550186 1.14443806
0.95259023 0.45232191 0.78382144]]
模型偏执:/n [-0.90875732]
Y_predict:/n [2 2 2 4 2 4 2 4 4 2 2 2 2 4 2 4 2 4 2 2 4 4 4 2 4 2 2 2 2 2 2 4 4 2 2 4 2
2 2 2 4 2 4 2 2 2 2 4 4 2 4 2 2 2 4 2 2 2 4 2 2 2 2 2 2 2 2 2 2 4 2 2 4 4
4 4 2 2 2 4 2 2 2 2 4 2 2 2 2 2 2 4 4 2 2 2 4 2 2 2 2 2 2 4 2 2 2 4 2 4 4
2 4 4 2 4 4 2 2 2 2 4 2 2 2 2 2 2 4 2 4 4 2 2 4 4 2 2 2 2 2 2 2 2 2 4 4 4
2 2 2 2 2 2 2 2 2 4 4 2 2 2 2 2 4 2 2 2 4 4 2]
预测值和真实值对比/n 0 True
527 True
687 True
603 True
78 True
...
625 True
458 True
183 True
391 True
470 True
Name: Class, Length: 171, dtype: bool
准确率为 0.9766081871345029
评估报告 precision recall f1-score support
良性 0.97 0.99 0.98 116
恶行 0.98 0.95 0.96 55
accuracy 0.98 171
macro avg 0.98 0.97 0.97 171
weighted avg 0.98 0.98 0.98 171
Process finished with exit code 0
不管怎样我全都预测正例(默认癌症为正例) - 不负责任的模型
5.3.7 ROC曲线与AUC指标------精确率和召回率评估更进一步在样本不均衡时使用
1 知道TPR与FPR
TPR=召回率
2 ROC曲线
蓝色为ROC曲线,蓝色曲线以下的面积为AUC当计算出的AUC指标小于0.5,适合反向预测。
3 AUC计算API
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
#逻辑回归分类评估API精确率和召回率
from sklearn.metrics import classification_report
#ROC曲线和AUC指标进行预测
from sklearn.metrics import roc_auc_score
def cancer_demo():
# 1)获取数据
# 读取的时候加上names
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)数据处理
# 处理缺失值 1.替换-》np.nan 2.删除缺失样本(将替换了nan的项删除)
data=data.replace(to_replace="?",value=np.nan)
data.dropna(inplace=True)
# 3)数据集划分
#1.筛选特征值和目标值
x=data.iloc[:,1:-1]
y=data["Class"]
#2.划分训练集和测试集
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)
# 6)模型评估
#1.得出模型
print("模型回归系数(权重):/n",estimator.coef_)
print("模型偏执:/n",estimator.intercept_)
#2.模型评估
y_predict=estimator.predict(x_test)
#对比
print("Y_predict:/n",y_predict)
print("预测值和真实值对比/n",y_predict==y_test)
score=estimator.score(x_test,y_test)
print("准确率为",score)
report=classification_report(y_test,y_predict,labels=[2,4],target_names=["良性","恶行"])
print("评估报告",report)
#使用ROC曲线和AUC指标衡量准确率(每个样本的真是类别,必须0-返例 1-正例)
#将y_test转换成 0 1
y_true=np.where(y_test>3,1,0)#y_test>3置为1,y_test<3置为0
rocAuc_score=roc_auc_score(y_true,y_predict)
print("ROC_AUC预测值:",rocAuc_score)
return None
模型回归系数(权重):/n [[1.15860225 0.31220656 0.55309848 0.75549063 0.20025917 1.27656328
1.19340775 0.5485425 0.6603317 ]]
模型偏执:/n [-1.22017436]
Y_predict:/n [2 2 2 2 2 2 4 2 4 4 2 4 4 2 2 4 4 2 4 2 4 4 2 2 4 4 2 2 4 4 2 2 2 2 2 2 4
4 4 2 2 2 2 2 4 4 4 2 2 2 2 2 2 2 2 2 2 2 4 4 2 2 2 2 4 2 4 2 2 2 4 2 4 4
4 4 2 4 2 4 2 2 4 2 2 2 2 2 2 4 4 2 2 4 2 4 2 2 2 2 2 2 4 4 4 2 4 2 4 2 2
2 2 2 4 2 4 2 2 2 2 4 2 2 2 2 4 4 4 2 4 2 4 2 4 2 2 2 2 4 4 2 2 2 2 2 2 2
4 2 4 4 2 4 4 2 2 2 2 4 4 2 4 2 2 4 2 2 2 2 2]
预测值和真实值对比/n 362 True
554 True
525 True
687 True
101 False
...
652 True
495 True
683 True
384 True
455 False
Name: Class, Length: 171, dtype: bool
准确率为 0.9590643274853801
评估报告 precision recall f1-score support
良性 0.95 0.98 0.97 107
恶行 0.97 0.92 0.94 64
accuracy 0.96 171
macro avg 0.96 0.95 0.96 171
weighted avg 0.96 0.96 0.96 171
ROC_AUC预测值: 0.9515917056074766
4、总结
- AUC只能用来评价二分类
- AUC非常适合评价样本不平衡中的分类器性能
5.4 模型保存和加载
当训练或者计算好一个模型之后,那么如果别人需要我们提供结果预测,就需要保存模型(主要是保存算法的参数)
1、sklearn模型的保存和加载API
import joblib
joblib已从sklearn中删除了
dump函数第二个参数是模型保存的路径,后缀为.pkl。
2、线性回归的模型保存加载案例
# 5)逻辑回归预估器
estimator=LogisticRegression()
estimator.fit(x_train,y_train)
#模型保存
joblib.dump(estimator,"test.pkl")
# # 5)逻辑回归预估器
# estimator=LogisticRegression()
# estimator.fit(x_train,y_train)
# #模型保存
# joblib.dump(estimator,"test.pkl")
#模型加载(已经训练好了)
estimator=joblib.load("test.pkl")
5.5.无监督学习-K-means算法
5.5.1、 什么是无监督学习
5.5.2、 无监督学习包含算法
5.5.3 K-means原理
1 K-means聚类步骤
5.5.4K-meansAPI
5.5.5 案例:k-means对Instacart Market用户聚类
#1. 获取数据
#2.合并表
#3.找到user_id和aisle之间的关系
#4.PCA降维
import pandas as pd
#1.获取数据
order_products=pd.read_csv("./instacart/order_products__prior.csv")
products=pd.read_csv("./instacart/products.csv")
orders=pd.read_csv("./instacart/orders.csv")
aisles=pd.read_csv("./instacart/aisles.csv")
#2.合并表
# order_products__prior.csv:订单与商品信息
# 字段:order_id, product_id, add_to_cart_order, reordered
# products.csv:商品信息
# 字段:product_id, product_name, aisle_id, department_id
# orders.csv:用户的订单信息
# 字段:order_id,user_id,eval_set,order_number,….
# aisles.csv:商品所属具体物品类别
# 字段: aisle_id, aisle
#合并aisles和products aisle和product_id 放一起
tab1=pd.merge(aisles,products,on=["aisle_id","aisle_id"])
tab2=pd.merge(tab1,order_products,on=["product_id","product_id"])
tab3=pd.merge(tab2,orders,on=["order_id","order_id"])
#3.找到user_id和aisle之间的关系
#交叉表和透视表 此处使用交叉表
table=pd.crosstab(tab3["user_id"],tab3["aisle"])
#减少数据 快速运行
data=table[:10000]
#4.PCA降维
from sklearn.decomposition import PCA
#1)实例化转换器类
transfer=PCA(n_components=0.95)
data_new=transfer.fit_transform(data)
#引入K-means预估器类
from sklearn.cluster import KMeans
estimator=KMeans(n_clusters=3)
#生成模型
estimator.fit(data_new)
#预测
y_predict=estimator.predict(data_new)
y_predict[0:200]
5.5.6Kmeans性能评估指标
1 轮廓系数--用来量化聚合成都的好坏
高内聚,低耦合。被认为是好的聚合效果。
2 轮廓系数值分析
如果b_i>>a_i:趋近于1效果越好, b_i<<a_i:趋近于-1,效果不好。 轮廓系数的值是介于 [-1,1] , 越趋近于1代表内聚度和分离度都相对较优。
3 结论
如果b_i>>a_i:趋近于1效果越好, b_i<<a_i:趋近于-1,效果不好。轮廓系数的值是介于 [-1,1] ,越趋近于1代表内聚度和分离度都相对较优。
4 轮廓系数API
labels聚类标记的结果
5 用户聚类结果评估
在上一步训练模型并进行预测后加入模型评估:
#模型评估---轮廓系数
from sklearn.metrics import silhouette_score
silhouette_score(data_new,y_predict)
6、K-means总结
K-means应用场景:
没有目标值
分类