机器学习（bilibili学习）

一、数据集的使用

• 小的数据集一般使用load加载，大的数据集一般使用fenth

二、数据集的分割

from sklearn.model_selection import train_test_split

#数据集的分割，x为训练集，y为测试集  
x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.2,random_state=22)

三、特征工程

3.1 特征抽取：类型->数值

• 字典特征提取（转化为one - hot代码）
• 文本特征提取
• 图像特征提取（深度学习）

3.1.1 特征提取代码

sklearn.feature_extraction

3.1.2 字典特征提取

• 1） 字典特征提取代码

#引入转换器
from sklearn.feature_extraction import DictVectorizer

sklearn.feature_extraction.DictVectorizer(sparse=Ture)
#返回sparse矩阵，每个样本为一个向量

• 2）字典特征提取流程

data = [{'city':'北京','temperature':100},{'city':'上海','temperature':60},{'city':'深圳','temperature':30}]  
#实例化转换器，这个转换器存在一个sparse的参数，默认设置为True，返回为sparse矩阵，设置为False返回array类型  
transform = DictVectorizer()  
#调用fit_transform()，数据预处理，作用就是先拟合数据，然后转化它将其转化为标准形式，训练集都是用 fit_transform()，而测试集用transform()，这里得到的时拟合之后的标准化的测试集
data_new = transform.fit_transform(data)

• 3） 应用场景

  • 数据集中类别特征比较多
  • 本身拿到的数据就是字典类型

3.1.3 文本特征提取

• 1） 停用词（stopwords=[]）：即认为是不需要的词

• 2） CountVectorizer：统计每个特征词的个数

from sklearn.feature_extraction.text import CountVectorizer

#流程
data = ["life is short,i like like python","life is too long,i dislike python"]  
#实例化转换器类  
transfer = CountVectorizer()  
#调用fit_transform方法  
data_new = transfer.fit_transform(data)  
print("data_new\n",data_new.toarray())  
print("特征名:\n",transfer.get_feature_names_out())

• 3） 中文文本特征提取

import jieba

#中文分词
def cut_words(text):  
    #中文分词  
    text_new = " ".join(list(jieba.cut(text)))  
    return text_new

def count_chinese_demo():  
    data = ["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",  
            "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。",  
            "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。"]  
    data_new = []  
    #中文分词调用  
    for sent in data:  
        data_new.append(cut_words(sent))  
    print(data_new)  
    #实例化转换器类  
    transfer = CountVectorizer()  
    #调用fit_transform方法  
    data_final = transfer.fit_transform(data_new)  
    print("data_new\n",data_final.toarray())  
    print("特征名:\n",transfer.get_feature_names_out())  
    return None

• 4） TfidfVectorizer（tf->词频：出现次数/文章字数，idf->逆向文档频率：lg(总文件数/包含该词语文件的数目)，tf-idf=tf×idf）

  • 例子：

1000篇文章-语料库
其中100篇文章-“非常”
其中10篇文章-“经济”
在这其中又有两篇文章：其中A(100词)出现了十次“经济”，B(100词)出现了十次“非常”
A->TF=10/100=0.1  IDF=lg(1000/10)=2 TF-IDF=0.1*2=0.2
B->TF=10/100=0.1  IDF=lg(1000/100)=1 TF-IDF=0.1*1=0.1

• 流程：

 from sklearn.feature_extraction.text import TfidfVectorizer

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

3.2 特征预处理（API：sklearn.preprocessing）

• 数值型数据的无量纲化：
  1. 归一化
  2. 标准化
• 为什么需要归一化与标准化：使不同规格的数据转换为同一规格，缩小差距

3.2.1归一化

• 定义：将原始的数据进行变换并映射到（默认为[0,1]）之间

• 公式
  

• 例子：
  

• 代码实现

from sklearn.preprocessing import MinMaxScaler

def minmax_demo():  
    #获取数据  
    data = pd.read_csv("dating.txt")  
    #由于测试，设置一定的索引,这里第一个参数表示每一行都要，:3表示只要前三列  
    data = data.iloc[:,:3]  
    #实例化转换器类,在转换器中可以设置feature_range参数来控制归一化的范围  
    transfer = MinMaxScaler(feature_range=[2,3])  
    #调用fit_transform  
    data_new = transfer.fit_transform(data)  
    print("data_new:\n",data_new)  
    return None

• 缺陷：最大值与最小值容易受到异常点的影响，所以鲁棒性比较差，只适合传统精确小鼠数据场景（鲁棒性是指系统或者器件在不同的环境或者条件下，能够保持其功能或者性能的特性，即健壮性）

3.2.2 标准化（对于出现的异常点，由于具有一定的数据量，所以出现少量的异常点不会对均值产生很大的影响，从而是的方差改变的也较小）

• 定义：通过对原数据进行变换，将其变化到均值为0，标准差为1的范围内

• 公式
  
  

  

• 代码

from sklearn.preprocessing import StandardScaler

def stand_demo():  
    #获取数据  
    data = pd.read_csv("dating.txt")  
    #由于测试，设置一定的索引,这里第一个参数表示每一行都要，:3表示只要前三列  
    data = data.iloc[:,:3]  
    #实例化转换器类  
    transfer = StandardScaler()  
    #调用fit_transform  
    data_new = transfer.fit_transform(data)  
    print("data_new:\n",data_new)  
    return None

3.3 特征降维

3.3.1 降维

• 对象：二维数组
• 降低特征的个数，以得到一组“不相关”的主变量的过程

3.3.2 特征选择

• 旨在从原有特征中找出主要特征
• 方法
  1. Filter（过滤式）
  • 方差选择法：低方差特征过滤，方差小即数据较为集中，需要过滤
  • 相关系数：衡量特征与特征之间的相关程度
  1. Embedded（嵌入式）
     • 决策树
     • 正则化
     • 深度学习

• 1）过滤式

  1. API

sklearn.feature_selection.VarianceThreshold(threshold = 0.0)

2. 例子

from sklearn.feature_selection import VarianceThreshold

def variance_demo():  
    #获取数据  
    data = pd.read_csv("factor_returns.csv")  
    data = data.iloc[:,1:-2]  
    #实例化转换器类,有一定范围,在其中有threshold参数,这里设置为5，即过滤掉方差等于5的特征  
    transer = VarianceThreshold(threshold=5)  
    #调用fit_transform  
    data_new = transer.fit_transform(data)  
    print("data_new\n",data_new,data_new.shape)  
    return None

• 2）相关系数

  1. 公式
     

  2. 例子
     

  3. 相关系数的值介于-1到+1直接

  • r>0，则为正相关，反之则为负相关
  • |r|=1，表示完全相关
  • r=0，表示完全不相关
  • 一般划分为|r|<0.4为低相关度，0.4<=|r|<0.7为显著性相关，0.7<=|r|<1为高度线性相关
  4. API

from scipy.stats import pearsonr

5. 代码示例

#相关系数算法，这样可以得出两个特征之间的相关系数，存放在r之中
r = pearsonr(data["pe_ratio"],data["pb_ratio"])

6. 当特征之间相关性很高：
   • 选取其中一个
   • 加权求和
   • 主成分分析***

3.3.3 主成分分析（PCA）

• 定义：高维数据转化为低维数据的过程，在此过程中可能回舍弃原有数据、创造新的变量
• 作用：是数据维数压缩，尽可能降低原数据的维数（复杂度），损失少量信息

1）API

#n_components如果是小数，则表示保留到百分之多少，如果是证书，则表示减少到多少个特征
sklearn.decomposition.PCA(n_components=None)

2）代码示例

from sklearn.decomposition import PCA

def pca_demo():  
    data=[[2,8,4,5],[6,3,0,8],[5,4,9,1]]  
    #实例化转换器,参数n_components如果是整数，则表示减少到多少个特征，如果是小数，则表示保留百分之多少的特征  
    transfer = PCA(n_components=2)  
    #调用fit_transform  
    data_new = transfer.fit_transform(data)  
    print("data_new:\n",data_new)  
    return None

四、分类算法

4.1 sklearn转换器与估计器

4.1.1 转换器

• 特征工程的结构就是转换器，具有以下几种形式
  • fit_transform：以下两个的集合
  • fit：求出每一列的平均值与标准差
  • transform：使用（（x - mean）/ 标准差）进行标准化

4.1.2 估计器

• 用于分类的估计器：
  • sklearn.neighbors k-近邻算法
  • sklearn.naive_bayes 贝叶斯
  • sklearn.linear_model.LogisticRegression 逻辑回归
  • sklearn.tree 决策树与随机森林
• 用于回归的估计器：
  • sklearn.linear_model.LinearRegression 线性回归
  • sklearn.linear_model.Ridge 岭回归
• 用于无监督学习的估计器
  • sklearn.cluster.KMeans 聚类
• 工作流程
  1. 实例化一个estimator
  2. estimator.fit(x_train, y_train) 计算，传入训练集和测试集
     • 调用完毕，生成模型
  3. 模型评估：
     • 直接比对真实值和预测值
       y_predict = estimator.predict(x_test)
       y_test == y_predict
     • 计算准确率
       estimator.score(x_test,y_test)
       

4.2 K-近邻算法（KNN）

• 核心思想：通过“邻居”来推断数据类别
• 定义： 如果一个样本在特征空间中的k个最相似（即特征空间中最近邻）的样本中大多数属于某一个类别，则该样本也属于这个类别

4.2.1 算法原理

• 距离公式：
  • 欧氏距离：即最普通的距离公式
  • 曼哈顿距离：绝对值距离
  • 明可夫斯基距离：
• k的取值：代表着取多少个离得近的样本，k取得过大时，会由于样本不均衡的影响
• 一般需要使用标准化的方式对数据进行无量纲化
• API

#n_neighbors指查询的邻居数量，algorithm的参数有'auto'、'ball_tree'、'brute'，其中auto是更具数据传递给fit方法的值来决定最合适的算法
sklearn.neighbors.KNeghborsClassifier(n_neighbors=5,algorithm='auto')

• 代码示例

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

def knn_iris():  
    #获取数据  
    iris=load_iris()  
    #数据集划分  
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.2,random_state=22)  
    #特征工程：标准化  
    transfer = StandardScaler()  
    x_train = transfer.fit_transform(x_train)  
    x_test = transfer.transform(x_test)  
    #KNN预估器流程  
    estimator = KNeighborsClassifier()  
    estimator.fit(x_train,y_train)  
    #模型评估  
    #第一种方式：直接比对真实值与预测值  
    y_predict = estimator.predict(x_test)  
    print(y_test == y_predict)  
    #第二种方式：计算准确率  
    score = estimator.score(x_test,y_test)  
    print("准确率：\n",score)  
    return None

4.3 模型选择与调优

4.3.1 交叉验证

• 将数据分为k份，每次选择其中一份作为验证集，然后经过k次测试，得到不同的验证集，每次都需要更换不同的验证集
• 目的：让被评估的模型更加准确

4.3.2 超参数搜索-网格搜索

• 自动找出最适合的参数

4.3.3 API

#cv指定几折交叉验证，即分为多少个块
#fit()输入训练数据
#score()准确率
#结果分析：1.最佳参数:best_params_，2.最佳结果:best_score_，3.最佳估计器:best_estimator_，4.交叉验证结果:cv_results_
sklearn.model_selection.GridSearchCV(estimator,param_grid=None,cv=None)

4.4.4 代码示例(鸢尾花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  
from sklearn.model_selection import GridSearchCV

def knn_iris_cv():  
    #获取数据  
    iris=load_iris()  
    #数据集划分  
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.2,random_state=22)  
    #特征工程：标准化  
    transfer = StandardScaler()  
    x_train = transfer.fit_transform(x_train)  
    x_test = transfer.transform(x_test)  
    #KNN预估器流程  
    estimator = KNeighborsClassifier()  
    #加入网格搜索与网格验证  
    #参数准备  
    param_dict={"n_neighbors": [1,3,5,7,9,11]}  
    #对预估器参数进行调整  
    estimator=GridSearchCV(estimator,param_grid=param_dict,cv=10)  
    estimator.fit(x_train,y_train)  
    #模型评估  
    #第一种方式：直接比对真实值与预测值  
    y_predict = estimator.predict(x_test)  
    print(y_test == y_predict)  
    #第二种方式：计算准确率  
    score = estimator.score(x_test,y_test)  
    print("准确率：\n",score)  
    print("最佳参数：\n",estimator.best_params_)  
    print("最佳结果：\n",estimator.best_score_)  
    print("最佳预估器：\n",estimator.best_estimator_)  
    print("交叉验证结果：\n",estimator.cv_results_)  
    return None

4.4 朴素贝叶斯算法（认为目标为最大可能性的）（认为两个特征之间是相互独立的）

• 文本分类

4.4.1 贝叶斯公式

4.4.2 拉普拉斯平滑系数

4.4.3 API

#alpha是拉普拉斯平滑系数
sklearn.naive_bayes.MUltinomialNB(alpha = 1.0)

4.4.4 代码示例

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

def nb_news():  
    #获取数据  
    news = fetch_20newsgroups()  
    #划分数据集  
    x_train,x_test,y_train,y_test=train_test_split(news.data,news.target,test_size=0.2,random_state=22)  
    #特征工程：文本特征抽取-tfidf  
    transfer = TfidfVectorizer()  
    x_train = transfer.fit_transform(x_train)  
    x_test = transfer.transform(x_test)  
    #朴素贝叶斯算法预估器流程  
    estimator = MultinomialNB()  
    estimator.fit(x_train,y_train)  
    #算法评估  
    #第一种方式：直接比对真实值与预测值  
    y_predict = estimator.predict(x_test)  
    print(y_test == y_predict)  
    #第二种方式：计算准确率  
    score = estimator.score(x_test,y_test)  
    print("准确率：\n",score)  
    print("最佳参数：\n",estimator.best_params_)  
    print("最佳结果：\n",estimator.best_score_)  
    print("最佳预估器：\n",estimator.best_estimator_)  
    print("交叉验证结果：\n",estimator.cv_results_)  
    return None

4.5 决策树

• 如何高效的决策：特征具有先后顺序

• 信息熵：

• 信息增益：

4.5.1 API

#criterion默认为'gini'，也可以选择信息增益的'entropy'
#maxdepth：树的最大深度
#random_state：随机数种子
class sklearn.tree.DecisionTreeClassifier(criterion='gini',max_depth=None,random_state=None)

4.5.2 代码示例

from sklearn.tree import DecisionTreeClassifier

def decision_iris():  
    #数据获取  
    iris = load_iris()  
    #划分数据集  
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.2,random_state=22)  
    #使用决策树预估器  
    estimator = DecisionTreeClassifier()  
    estimator.fit(x_train,y_train)  
    #模型评估  
    #第一种方式：直接比对真实值与预测值  
    y_predict = estimator.predict(x_test)  
    print(y_test == y_predict)  
    #第二种方式：计算准确率  
    score = estimator.score(x_test,y_test)  
    print("准确率：\n",score)  
    return None

4.5.3 决策树可视化

• API

sklearn.tree.export_graphviz(estimator,out_file='tree.dot',feature_names=['',''])

• 导出的文件复制其中内容放到http://webgraphviz.com/

4.6 随即森林

• 集成学习方法：生成多个分类器/模型，得出不同的预测结果在进行组合预测
• 随机：训练集随机（bootstrap：随机又放回抽样，抽到和原集合一样的个数）、特征随机（从M个特征中抽取m个特征，且M >> m）

4.6.1 API

#n_estimators:森林里的树个数
#criterion：可选分割特征测量方法
#max_features：'auto'，'sqrt'，'log2'，'None'
#bootstrap:是否在构建树时使用放回抽样
#min_samples_split：节点划分最少样本数
#min_samples_leaf：叶子接待你的最小样本数
sklearn.ensemble.RandomForestClassifier(n_estimators=10,criterion='gini',max_depth=None,bootstrap=True,random_state=None,min_samples_split=2)

4.6.2 代码示例

from sklearn.ensemble import RandomForestClassifier

def decision_random_iris():  
    #数据获取  
    iris = load_iris()  
    #划分数据集  
    x_train,x_test,y_train,y_test=train_test_split(iris.data,iris.target,test_size=0.2,random_state=22)  
    #使用随机树预估器  
    estimator = RandomForestClassifier()  
    #加入网格搜索与网格验证  
    #参数准备  
    param_dict={"n_estimators": [1,3,5,7,9,11],"max_depth": [5,8,15,25,30]}  
    #对预估器参数进行调整  
    estimator=GridSearchCV(estimator,param_grid=param_dict,cv=10)  
    estimator.fit(x_train,y_train)  
    #模型评估  
    #第一种方式：直接比对真实值与预测值  
    y_predict = estimator.predict(x_test)  
    print(y_test == y_predict)  
    #第二种方式：计算准确率  
    score = estimator.score(x_test,y_test)  
    print("准确率：\n",score)  
    print("最佳参数：\n",estimator.best_params_)  
    print("最佳结果：\n",estimator.best_score_)  
    print("最佳预估器：\n",estimator.best_estimator_)  
    print("交叉验证结果：\n",estimator.cv_results_)  
    return None

4.6.3 总结

1. 适合大数据集
2. 能够评估各个特征在每个问题上的重要性

五、回归与聚类算法

• 回归问题：目标值是一种连续的数据

5.1 线性回归

• 找到特征值与目标值之间的关系

• 通用公式：
  

• 自变量一次或者参数一次都是线性关系
  

5.1.1 线性回归的损失和优化原理

1. 先假设特征值和目标值存在线性关系

2. 随意假定

3. 使用损失函数/cost/成本函数/目标函数
   #损失函数
   

4. 优化损失

5. 优化方法

   • 正规方程（矩阵运算）
     

   • 梯度下降（α为步长）
     

5.1.2 API

• 正规方程

#fit_intercept:是否计算偏差
#LinearRegression.coef_:回归系数
#LinearRegression.intercept_:偏置
sklearn.linear_model.LinearRegression(fit_intercept=True)

#SGDRegressor类实现了随机梯度下降学习，它支持不同的loss函数和正则化惩罚项来你和线性回归模型
#loss:损失类型->loss='squared_loss':普通最小二乘法
#fit_intercept:是否计算偏差
#learning_rate:学习率填充、'constant':eta0、'optimal':eta=1.0/(alpha*(t+t0))[defult]、'invscaling':eta=eta0/pow(t,power_t)->power_t=0.25存在于父类之中、对于一个常数值的学习率来说。可以使用learning_rate='constant'，并使用eta0来指定学习率
#SGDRegression.coef_:回归系数
#SGDRegression.intercept_:偏置
sklearn.linear_model.SGDRegressor(loss='squared_loss',fit_intercept=True,learning_rate='invscaling',eta0=0.01)

5.1.3 代码示例

from sklearn.datasets import load_diabetes  
from sklearn.model_selection import train_test_split  
from sklearn.preprocessing import StandardScaler  
from sklearn.linear_model import LinearRegression

def linear1():  
    #获取数据  
    boston=load_diabetes()  
    #划分数据集  
    x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target,test_size=0.2,random_state=22)  
    #标准化  
    transfer=StandardScaler()  
    x_train=transfer.fit_transform(x_train)  
    x_test=transfer.transform(x_test)  
    #初始化预估器  
    estimator = LinearRegression()  
    estimator.fit(x_train,y_train)  
    #得出模型  
    print("权重系数为：\n",estimator.coef_)  
    print("偏置为：\n",estimator.intercept_)

def linear2():  
    #获取数据  
    boston=load_diabetes()  
    #划分数据集  
    x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target,test_size=0.2,random_state=22)  
    #标准化  
    transfer=StandardScaler()  
    x_train=transfer.fit_transform(x_train)  
    x_test=transfer.transform(x_test)  
    #初始化预估器  
    estimator = SGDRegressor()  
    estimator.fit(x_train,y_train)  
    #得出模型  
    print("权重系数为：\n",estimator.coef_)  
    print("偏置为：\n",estimator.intercept_)

5.2 回归模型评估方法

5.2.1 均方差评价机制

5.2.2 API

#y_true：真实值
#y_pred：预测值
#return：浮点数结果
sklearn.metrics.mean_squard_error(y_true,y_pred)

5.2.3 代码示例

from sklearn.metrics import mean_squared_error

def linear1():  
    #获取数据  
    boston=load_diabetes()  
    #划分数据集  
    x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target,test_size=0.2,random_state=22)  
    #标准化  
    transfer=StandardScaler()  
    x_train=transfer.fit_transform(x_train)  
    x_test=transfer.transform(x_test)  
    #初始化预估器  
    estimator = LinearRegression()  
    estimator.fit(x_train,y_train)  
    #得出模型  
    print("权重系数为：\n",estimator.coef_)  
    print("偏置为：\n",estimator.intercept_)  
    #模型评估  
    y_predict = estimator.predict(x_test)  
    error = mean_squared_error(y_test,y_predict)  
    print("预测值为：",y_predict)  
    print("正规方程均方差为：",error)

5.2.4 正规方程与梯度下降对比

5.2.5 优化方法

5.3 过拟合与欠拟合

• 过拟合：在训练集上面表现很好，在测试集上不好–>训练集学习之后学得的特征过多
• 欠拟合：在训练集和测试集上都不能很好的拟合数据

5.3.1 欠拟合的解决

• 原因：学习到的数据特征过少
• 解决方式：增加数据的特征数量

5.3.2 过拟合的解决

• 原因：原始特征过多，存在一些嘈杂特征，模型过于复杂是因为模型尝试去兼顾各个测试数据点
• 解决方式：正则化

5.3.3 正则化类别

• 损失函数+λ惩罚项
  

5.4 线性回归的改进-岭回归

5.4.1 API

#alpha：正则化力度，取值为0~1，1~10
#solver：会根据数据自动选择优化方法，当数据集和特征都比较大时，选用"sag"随机梯度下降优化
#normalize：是否进行标准化
#Ridge.coef_：回归权重
#Ridge.intercept_：回归偏置
sklearn.linear_model.Ridge(alpha=1.0,fit_intercept=True,solver="auto",normalize=False)

5.4.2 代码示例

from sklearn.linear_model import Ridge

def linear3():  
    #获取数据  
    boston=load_diabetes()  
    #划分数据集  
    x_train,x_test,y_train,y_test=train_test_split(boston.data,boston.target,test_size=0.2,random_state=22)  
    #标准化  
    transfer=StandardScaler()  
    x_train=transfer.fit_transform(x_train)  
    x_test=transfer.transform(x_test)  
    #初始化预估器  
    estimator = Ridge()  
    estimator.fit(x_train,y_train)  
    #得出模型  
    print("权重系数为：\n",estimator.coef_)  
    print("偏置为：\n",estimator.intercept_)  
    #模型评估  
    y_predict = estimator.predict(x_test)  
    error = mean_squared_error(y_test,y_predict)  
    print("预测值为：",y_predict)  
    print("正规方程均方差为：",error)

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

5.5.1 逻辑回归的原理

• 输入（就是线性回归的输出）
  

• 激活函数

  1. sigmoid函数
     

5.5.2 损失以及优化

• 分开原则：（y->真实值，y=1属于这个类别，y=0不属于这个类别）
  

• 综合完整损失函数
  

• 例子
  

5.6 一次例子

import pandas as pd  
import numpy as np  
from sklearn.metrics import mean_squared_error  
from sklearn.model_selection import train_test_split  
from sklearn.preprocessing import StandardScaler  
from sklearn.linear_model import LogisticRegression  
  
def test():  
    #获取数据  
    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)  
    #数据处理：处理缺失值  
    #替换->np.nan  
    data.replace(to_replace="?",value=np.nan)  
    #删除缺失值  
    data.dropna(inplace=True)  
    #筛选特征值和目标值  
    x = data.iloc[:,1:-1]  
    y = data["Class"]  
    #数据集划分  
    x_train,x_test,y_train,y_test = train_test_split(x,y)  
    #特征工程：无量纲化->标准化  
    transfer = StandardScaler()  
    x_train = transfer.fit_transform(x_train)  
    x_test = transfer.transform(x_test)  
    #逻辑回归预估器  
    estimator = LogisticRegression()  
    estimator.fit(x_train,y_train)  
    #逻辑回归的模型参数：回归系数和偏置  
    print("逻辑回归的模型参数的回归系数:\n",estimator.coef_)  
    print("逻辑回归的模型参数的偏置:\n",estimator.intercept_)  
    #模型评估  
    y_predict = estimator.predict(x_test)  
    error = mean_squared_error(y_test,y_predict)  
    print("预测值为：",y_predict)  
    print("正规方程均方差为：",error)
    #第一种方式：直接比对真实值与预测值  
	y_predict = estimator.predict(x_test)  
	print(y_test == y_predict)  
	#第二种方式：计算准确率  
	score = estimator.score(x_test,y_test)  
	print("准确率：\n",score)  
    return None  
  
if __name__ == '__main__':  
    test()

5.7 分类的评估方法

5.7.1 精确率与召回率

1）混淆矩阵

2）精确率和召回率

• 精确率：预测结果为正例，真实结果也为正例的比例
  

• 召回率：真实结果为正例，预测结果为正例的比例
  

• F1-score：反应模型的稳健性
  

5.7.2 API

#y_true：真实目标值
#y_pred：估计器预测值
#labels：指定类别对应的数字
#target_name：目标类别名称
#return：每个类别精确率和召回率
sklearn.metrics.classification_report(y_true,y_pred,labels=[],target_name=None)

#例
print("精确率和召回率：",classfication_report(y_test,lr.predect(x_test,y_test),labels=[2,4],target_name=["良性","恶性"]))

5.8 ROC曲线和AUC指标

• 衡量样本不均衡下的评估

5.8.1 TPR和FPR

• TPR->召回率
  

5.8.2 AUC指标（二分类：是或者不是）

• AUC=1完美预估器
• 0.5<AUC<1 优于随机猜测，设定合适的阈值，有预测价值
• API如下

#计算ROC曲线面积，即AUC值
#y_true：每个样本的真实类别，必须为0（反例），1（正例）标记
#y_score：预测得分，可以是正类的估计概率、置信值或者分类器方法的返回值
sklearn.metrics.roc_auc_score(y_true,y_score)

• 可以使用三元运算符来转换

y_test = np.where(y_test > 3,1,0)

5.9 模型的保存与加载

from sklearn.externals import joblib
#保存,rf->预估器
joblib.dump(rf,"test.pkl")
#加载
estimator = joblib.load("test.pkl")

5.10 无监督学习：K-means算法

• 没有目标值就是无监督学习
• 包含算法：聚类算法（K-means：K均值聚类），降维（PCA）

5.10.1 K-means算法

• 聚类步骤
  

  

• K-means的API

#n_clusters：开始的聚类中心位置
#init：初始化方法
#labels_：默认标记的类型，可以和真实值比较（不是值比较）
sklearn.cluster.KMeans(n_clusters=8,init='k-means++')

5.11 聚类评估：轮廓系数

• 轮廓系数公式（取值范围为-1~1，为-1时最差，为1时最好）
  

  

• API

#计算平均轮廓系数
#X：特征值
#labels：被聚类标记的目标值
sklearn.metrics.silhouette_score(X,labels)