sklearn进行机器学习 ( 一天掌握 )

最新推荐文章于 2023-04-03 10:11:41 发布
最新推荐文章于 2023-04-03 10:11:41 发布
阅读量469 收藏 9
点赞数 3
分类专栏： 机器学习 文章标签： sklearn 机器学习 python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_39616953/article/details/120002584
版权

目录

文章目录

机器学习

[机器学习开发流程]
    1. 获取数据
    2. 数据处理
    3. 特征工程
    4. 机器学习算法训练 - 模型
    	4.1 监督学习（有目标值）
        	4.1.1 分类算法
            4.1.2 回归算法
        4.2 无监督学些（无目标值）
        	4.2.1 聚类算法
    5. 模型评估
    6. 应用

特征工程

特征抽取

skearn数据集使用

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

def datasets_demo():
    """sklearn数据集使用"""
    iris=load_iris()
    print("鸢尾花数据集：\n",iris)
    print("查看数据集描述：\n",iris['DESCR'])
    print("查看特征值名字：\n",iris.target_names)
    print("查看特征值：\n",iris.data.shape)
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.2,random_state=25)#默认0.25
    print("训练集的特征值：\n",x_train.shape)
    return None

字典特征提取

from sklearn.feature_extraction import DictVectorizer

def dict_dome():
    """
    字典特征抽取
    :return:
    """
    data=[{'city':'北京','temperature':100},
          {'city':'上海','temperature':60},
          {'city':'深圳','temperature':30}]
    #1.实例化一个转换器类
    transfer=DictVectorizer(sparse=False)
    transfer = DictVectorizer(sparse=True)
    #2.调用fit_transform()
    data_new=transfer.fit_transform(data)
    print("data_new:\n ",data_new)
    print("特征名字:\n",transfer.get_feature_names())
    return None

文本特征抽取

from sklearn.feature_extraction.text import CountVectorizer

def count_demo():
    """文本特征抽取：CountVecotrizer"""
    data=["Life is short,i like like python","Life is long,i dislike python"]
    #1.实例化一个转换器类
    transfer=CountVectorizer(stop_words=["is","too "])
    #2.调用fir_transform
    data_new=transfer.fit_transform(data)
    print("data_new:\n",data_new)
    print("特征名字:\n",transfer.get_feature_names())
    return None

中文文本特征抽取

from sklearn.feature_extraction.text import CountVectorizer

def count_chinese_demo():
    """文本特征抽取：CountVecotrizer"""
    data=["我 爱 北京 天安门","天安门 上 太阳 升"]
    #1.实例化一个转换器类
    transfer=CountVectorizer()
    #2.调用fir_transform
    data_new=transfer.fit_transform(data)
    print("data_new:\n",data_new)
    print("特征名字:\n",transfer.get_feature_names())
    return None

中文分词

import jieba

def cut_word(text):
    """进行中文分词：“我爱北京天安门”-->"我 爱 北京 天安门"   """""
    text=" ".join(list(jieba.cut(text)))
    return text

中文文本特征抽取-自动分词

from sklearn.feature_extraction.text import CountVectorizer
import jieba

def cut_word(text):
    """进行中文分词：“我爱北京天安门”-->"我 爱 北京 天安门"   """""
    text=" ".join(list(jieba.cut(text)))
    return text
def count_chinese_demo2():
    """中文文本特征抽取，自动分词"""
    # 1.将中文文本分词
    data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
    data_new=[]
    for sent in data:
        data_new.append(cut_word(sent))
    # 2.实例化一个转换器类
    transfer = CountVectorizer(stop_words=["一种","所以"])
    # 3.调用fir_transform
    data_final = transfer.fit_transform(data_new)
    print("data_final:\n", data_final)
    print("特征名字:\n", transfer.get_feature_names())
    return None

TF-IDF

from sklearn.feature_extraction.text import TfidfVectorizer
import jieba

def cut_word(text):
    """进行中文分词：“我爱北京天安门”-->"我 爱 北京 天安门"   """""
    text=" ".join(list(jieba.cut(text)))
    return text
def tfidf_demo():
    """用TF-IDF的方法进行文本特征抽取"""
    # 1.将中文文本分词
    data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]
    data_new = []
    for sent in data:
        data_new.append(cut_word(sent))
    # 2.实例化一个转换器类
    transfer = TfidfVectorizer(stop_words=["一种", "所以"])
    # 3.调用fir_transform
    data_final = transfer.fit_transform(data_new)
    print("data_final:\n", data_final)
    print("特征名字:\n", transfer.get_feature_names())
    return None

特征预处理

[特征预处理]
	1. 无量纲化
    	1.1 归一化
        1.2 标准化

归一化

小数据用，异常值影响较大

import pandas as pd
from sklearn.preprocessing import MinMaxScaler

def minmax_demo():
    """归一化"""
    #1.获取数据
    data=pd.read_csv("data/dating.txt")
    data=data.iloc[:,:3]
    print("data:\n", data)
    #2.实例化一个转化器类
    transfer=MinMaxScaler(feature_range=[0,1])
    #3.调用fit_transform
    data_new=transfer.fit_transform(data)
    print("data_new:\n",data_new)
    return None

标准化（大数据用）

大数据用，异常值影响较小

import pandas as pd
from sklearn.preprocessing import StandardScaler

def stand_demo():
    """标准化"""
    # 1.获取数据
    data = pd.read_csv("data/dating.txt")
    data = data.iloc[:, :3]
    print("data:\n", data)
    # 2.实例化一个转化器类
    transfer = StandardScaler()
    # 3.调用fit_transform
    data_new = transfer.fit_transform(data)
    print("data_new:\n", data_new)
    return None

特征降维

特征选择

[特征选择]
	1. 过滤式
    	1.1 删除低方差特征
        1.2 相关系数 - 取值范围（-1,1）
    2. 嵌入式

低方差特征过滤

import pandas as pd
from sklearn.feature_selection import VarianceThreshold
from scipy.stats import pearsonr

def variance_demo():
    """过滤低方差特征"""
    #1.获取数据
    data=pd.read_csv("data/factor_returns.csv")
    data=data.iloc[:,1:-2]
    print("data:",data,"\n",data.shape)
    #2.实例化一个转换器类调用fit_transform
    transfer=VarianceThreshold(threshold=10)
    #3.调用fit_transform
    data_new=transfer.fit_transform(data)
    print("data_new:\n",data_new,"\n",data_new.shape)

    #计算某俩个变量之间的相关系数
    r1=pearsonr(data["pe_ratio"],data["pb_ratio"])
    print("pe_ratio,pb_ratio,相关系数:\n",r1)
    r2=pearsonr(data['revenue'],data['total_expense'])
    print("revenue,total_expense,相关系数:\n",r2)
    return None

主成分分析-PCA降维

尽可能保留原始信息，信息损失较少

from sklearn.decomposition import PCA

def pca_demo():
    """PCA降维"""
    data=[[2,8,4,5],[6,3,0,8],[5,4,9,1]]
    #1.实例化转化器类
    transfer=PCA(n_components=0.95)#小数：保留百分之多少的信息，整数：减少到多少信息
    #2.调用fit_transform
    data_new=transfer.fit_transform(data)
    print("data_new:\n",data_new)
    return None

分类算法

K-近临算法（KNN算法）

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

优点：

  • 简单，易于理解，易于实现，无需训练

缺点：

  • 懒惰算法，对测试样本分类时的计算量大，内存开销大
  • 必须指定K值，K值选择不当则分类精度不能保证
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)
    return None

输出为：

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.9210526315789473

模型选择与调优

[模型选择与调优]
	1.交叉验证
    	把训练集分为训练集和验证集，在训练集中训练，然后通过验证集看预测模型的精度。
    2.网格搜索
    	超参数搜索-网格搜索（调参数）

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

    return None

facebook案例

[流程分析]
	1. 获取数据
    2. 数据处理
    	特征值 x
        特征值 y
        a. 缩小数据范围
        	2 < x < 2.5
            1.0 < y < 1.5
        b. time --> 年月日时分秒
        c. 过滤次数少的地点
        数据集划分
    3. 特征工程：标准化
    4. KNN算法预估流程
    5. 模型选择与调优
    6. 模型评估

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

输出为：

y_predict:
 [8074414179 5991509451 2337680907 ... 1533408099 1663763627 6215057357]
直接比对真实值和预测值：
 12366416     True
6290714      True
21453668    False
5621166     False
4562788     False
            ...  
3297444     False
23761357     True
6049010     False
3467747      True
4858505      True
Name: place_id, Length: 20228, dtype: bool
准确率为：
 0.36311053984575836
最佳参数：
 {'n_neighbors': 7}
最佳结果：
 0.3351241016466924
最佳估计器:
 KNeighborsClassifier(n_neighbors=7)
交叉验证结果:
 {'mean_fit_time': array([0.18021361, 0.17641131, 0.16131012, 0.15977105]), 'std_fit_time': array([0.01700113, 0.01322228, 0.02683005, 0.01216048]), 'mean_score_time': array([2.06328313, 2.43823083, 1.95054746, 2.05517125]), 'std_score_time': array([0.23691522, 0.47519429, 0.03647261, 0.06388052]), 'param_n_neighbors': masked_array(data=[3, 5, 7, 9],
             mask=[False, False, False, False],
       fill_value='?',
            dtype=object), 'params': [{'n_neighbors': 3}, {'n_neighbors': 5}, {'n_neighbors': 7}, {'n_neighbors': 9}], 'split0_test_score': array([0.32623097, 0.33226221, 0.33438798, 0.32979039]), 'split1_test_score': array([0.32347852, 0.33588767, 0.33371236, 0.33035052]), 'split2_test_score': array([0.32560439, 0.33534385, 0.33727196, 0.33331685]), 'mean_test_score': array([0.32510463, 0.33449791, 0.3351241 , 0.33115259]), 'std_test_score': array([0.00117794, 0.00159639, 0.00154361, 0.00154736]), 'rank_test_score': array([4, 2, 1, 3])}

朴素贝叶斯算法

[定义]
	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:训练文档出现的特征总个数

20类新闻分类

[流程分析]
	1. 获取数据
    2. 划分数据集
    3. 特征工程
    	3.1 文本特征抽取
    4. 朴素贝叶斯预估器流程
    5. 模型评估

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)

    return None

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

决策树

如何高效的进行决策（特征的先后顺序）

优点：

  • 可视化 - 可解释能力强

缺点：

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

改进：

  • 减枝cart算法
  • 随机森林
[信息论基础]
	1. 信息
		香农：消除随机不确定的东西
	2. 信息的衡量 - 信息量 - 信息熵
		2.1 单位：bit
		2.2 信息增益
        	g(D|A) = H(D)-H(D|A)
        2.3 决策树的划分依据之一 ------- 信息增益

决策树对鸢尾花数据分类

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)

    return None

y_predict:
 [0 2 1 2 1 1 1 1 1 0 2 1 2 2 0 2 1 1 1 1 0 2 0 1 2 0 1 2 2 1 0 0 1 1 1 0 0
 0]
直接比对真实值和预测值:
 [ True  True  True  True  True  True  True False  True  True  True  True
  True  True  True  True  True  True False  True  True  True  True  True
  True  True False  True  True False  True  True  True  True  True  True
  True  True]
准确率为：
 0.8947368421052632

泰坦尼克号乘客生存预测

[流程分析]
	1. 获取数据
	2. 数据处理
		缺失值处理
		特征值 --> 字典类型
	3. 准备好特征值目标值
	4. 划分数据集
	5. 特征工程：字典特征抽取
	6. 决策树预估器流程
	7. 模型评估

结果为：

y_predict:
 [0 1 0 0 1 1 1 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1 1 0 1 0 1 0 0 0
 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0
 1 1 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 0 1
 0 1 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0 1 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1 1
 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1 0 0 0 0 0 1 1 1 1 0 0 0 0 0
 0 0 0 1 1 1 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 0 0 0 1 0
 0 0 1 0 0 0 0 0 0 1 0 0 0 0 1 0 1 0 0 1 1 0 0 1 0 0 0 0 1 0 1 0 0 0 0 1 0
 0 1 1 1 0 0 1 1 1 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1
 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 1 0 1 0 0 0 0 1]
直接比对真实值和预测值:
 831      True
261     False
1210     True
1155     True
255      True
        ...  
1146     True
1125    False
386      True
1025    False
337      True
Name: survived, Length: 329, dtype: bool
准确率为：
 0.7811550151975684

随机森林

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

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

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

回归与聚类算法

线性回归

[线性回归]
	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）评价机制

波士顿房价预测

[流程分析]
	1. 获取数据集
    2. 划分数据集
    3. 特征工程
    	无量纲化 - 标准化
    4. 预估器流程
    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
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)

    return None

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)

    return None

欠拟合与过拟合

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

线性回归的改进-岭回归

带有L2正则化的线性回归-岭回归

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)

    return None

分类算法-逻辑回归与二分类

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

癌症分类预测-良/恶性乳腺癌肿瘤预测

[流程分析]
	1. 获取数据
	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

#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非常适合评价样本不平衡中的分类器性能

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)

模型保存与加载

[模型保存与加载]
	import joblib
	1.保存
		joblib.dump(estimator,'test.pkl')
	2.加载
		estimator = joblib.load('test.pkl')

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
import joblib

def save_model():
    """岭回归对波士顿房价进行预测"""
    #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)
    #保存模型
    joblib.dump(estimator,"my_ridge.pkl")

    return x_train,x_test,y_train,y_test

def load_model(x_train,x_test,y_train,y_test):
    #5.得出模型
    estimator=joblib.load('my_ridge.pkl')
    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
if __name__ == '__main__':
    x_train,x_test,y_train,y_test=save_model()
    load_model(x_train,x_test,y_train,y_test)

无监督学习 K-means算法

[无监督学习]
	1. 定义
    	没有目标值 - 无监督学习
    2. 包含的算法
    	聚类：K-means(K均值聚类)
        降维：PCA
[K-means算法步骤]
	1. 随机设置K个特征空间内的点作为初始的聚类中心
    2. 对于其他每个点计算到K个中心的距离，未知的点选择最近的一个聚类中心点作为标记类别
    3. 接着对着标记的聚类中心之后，重新计算出每个聚类的新中心点（平均值）
    4. 如果计算得出的新中心点与原中心点一样，那么结束，否则重新进行第二步过程

K-means对InstacartMarket用户聚类

[K-means算法]
    1. 优缺点
        优点：采用迭代式算法，直观易懂且非常实用
        缺点：容易收敛到局部最优解（解决：多次聚类）
    2. 注意
    	聚类一般做在分类之前
[流程分析]
	1. 降维之后的数据
    2. 预估器流程
    3. 看结果
    4. 模型评估
    	4.1 目标
        	高内聚，低耦合（内部距离最小化，外部距离最大化）
    	4.2 轮廓系数
			聚类效果好坏的一种评价方式

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)

相关资料下载：链接：https://pan.baidu.com/s/17DeVm48VRG0tlEzQM0KfSA 提取码：gx4a
参考文献：
[1],http://yun.itheima.com/course/500.html?bili

鼠小米
关注
  • 3
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
如何用3个月零基础入门机器学习？
CSDN 人工智能
05-14 1万+
来源 | 微调的知乎专栏▌0. 背景写这篇文章的初衷是大部分私信我的朋友都想了解如何入门/转行机器学习，搭上人工智能这列二十一世纪的快车。再加上这个问题每隔一阵子就会在知...
机器学习---sklearn
weixin_44838881的博客
05-21 4万+
1.Sklearn简介 sklearn (全称 Scikit-Learn) 是基于 Python 语言的机器学习工具,Sklea是处理机器学习 (有监督学习和无监督学习) 的包。它建立在 NumPy, SciPy, Pandas 和 Matplotlib 之上，其主要集成了数据预处理、数据特征选择，sklearn有六个任务模块和一个数据引入模块： 有监督学习的分类任务 有监督学习的回归任务 无监督学习的聚类任务 无监督学习的降维任务 数据预处理任务 模型选择任务 数据引入 具体流程如下： 下载 skl.
机器学习之sklearn基础教程！
小白学视觉
04-07 5924
点击上方“小白学视觉”，选择加"星标"或“置顶”重磅干货，第一时间送达本次分享是基于scikit-learn工具包的基本分类方法，包括常见的Logisitic Regression、支持向量机、决策树、随机森林以及K近邻方法KNN。本文在基于读者已经基本了解这些基本算法的原理以及推导的基础上，使用sklearn工具包进行算法实践，如果大家没有掌握基本算法原理，文中也会给出...
scikit-learn(sklearn)学习笔记十 支持向量机
weixin_52703681的博客
03-31 1385
书接上次笔记，我们通过把二维的数据映射到三维，再用超平面进行划分。但是这也是有很大的问题的，维数越高越难以计算。于是在上次笔记的最后，采用了更换核函数来满足支持向量机的分类要求。 klearn在skearn中可选择以下几种选项 linear 线性核，解决问题为线性。 poly 多项式核，解决问题为偏线性。 sigmoid 双曲正切核，解决问题为非线性。 rbf 高斯径向基，解决偏为非线性。 所以要研究kernel应该如何选取 from sklearn.datasets import load_brea
浅谈机器学习--聚类
小马哥的博客
04-03 844
机器学习
Sklearn机器学习中的主要算法原理
03-02
Scikit-learn（简称Sklearn）是一个流行的Python机器学习库，提供了许多常用的机器学习算法。以下是Sklearn中一些常用机器学习算法的原理概念： 线性回归（Linear Regression）： 通过拟合一个线性模型来预测连续...
基于python sklearn 的机器学习教程
09-25
基于python sklearn 的机器学习教程
基于python sklearn的机器学习教程
09-25
本教程是在学习机器学习的过程中的记录并进行整理之后的教程
【机器学习】菜菜的机器学习sklearn课堂配套教材和代码
06-29
B站课程《菜菜的机器学习sklearn》的配套教材和代码，老师讲解的很详细的课程，十分推荐。 课程链接：...
机器学习-sklearn中文文档
最新发布
03-27
sklearn，全称scikit-learn，是Python中一个非常强大的机器学习库，它提供了简单高效的工具，用于数据挖掘和数据分析。sklearn库包含了大量的算法，如分类、回归、聚类、降维、模型选择等，并且这些算法都经过了良好...
sklearn中文文档+Python英文文档
12-28
sklearn0.19中文文档+Python3.7.2英文文档，epub格式，可以下载一个Neat reader，看起来很方便
sklearn的官方文档（0.16）
04-06
sklearn的官方文档（0.16），是全的，包括监督学习，非监督学习等方法
机器学习实验报告.docx
03-22
学校机器学习的实验报告(仅部分完成)
sklearn库的学习
热门推荐
yeal
12-24 17万+
sklearn入门，sklearn库结构
使用sklearn对比各种机器学习方法：SVM，XGBoost...
yimenren的博客
10-11 2270
sklearn常用机器学习算法总结（附python代码） - 简书 (jianshu.com)https://www.jianshu.com/p/641707e4e72c 注意：在使用XGBoost算法的时候，需要将X_train,y_train等Tensor类型变量数据类型置为nd array类型，而其他算法可以直接使用Tensor数据类型，即： features = features.numpy() labels = labels.numpy() idx_train = idx_train.nu.
机器学习实战 --- sklearn
不加糖咖啡q的博客
04-04 2748
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 一、sklearn中数据......
Scikit-learn中的机器学习算法
林学森的技术专栏
04-26 2594
以下文章摘录自： 《机器学习观止——核心原理与实践》 京东：https://item.jd.com/13166960.html 当当：http://product.dangdang.com/29218274.html (由于博客系统问题，部分公式、图片和格式有可能存在显示问题，请参阅原书了解详情) ———————————————— 版权声明：本文为CSDN博主「林学森」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.cs.
非常详细的sklearn介绍
机器学习算法那些事
11-12 16万+
0引言Sklearn (全称 Scikit-Learn) 是基于 Python 语言的机器学习工具。它建立在 NumPy, SciPy, Pandas 和 Matplot...
【机器学习】 sklearn 模块详解
haoweixl的博客
03-27 5107
【机器学习】 sklearn 模块详解前言小白问题解决机器学习一般问题的步骤sklearn 概述sklearn dataset模块预处理 sklearn.preprcessing特征抽取 sklearn.feature_extraction特征选择 sklearn.feature_selection降维 sklearn.decomposition模型评估 sklearn.metrics分类结果度量回归结果度量多标签度量聚类的度量交叉验证 sklearn.model_selection网格搜索 sklearn
sklearn通用机器学习
03-25
scikit-learn（简称为sklearn）是Python中最受欢迎的机器学习库之一，提供了各种各样的机器学习算法和工具，包括分类、回归、聚类、降维等。sklearn支持各种数据格式，包括Numpy数组、Pandas Dataframe和SciPy稀疏...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值