机器学习各种算法以及开发具体流程+API具体实例+案例的实现

<机器学习算法分类以及开发流程>

本可儿不才，最近学习机器学习和深度学习的算法之余总结了一点小经验，供大家参考。排版还有待提高厚~~

离散型（不可分）--连续型（预测类别，票房等等）

一、

（1）
    
    【1、监督学习： 特征值 + 目标值。   2、 非监督学习： 特征值 1000个样本】

机器学习算法的分类：

1监督学习（预测）重点
    //

    分类：k-近邻算法，贝叶斯分类，决策树与随机森林，逻辑回归，神经网络（目标是离散型）（样本属于哪一个类别）

    //大多数算法应用非常广泛，一定要学好

    回归：线性回归，岭回归 （目标值连续型，具体的值）  连续型
    //

    标注：隐马尔可夫模型（不做要求）

2、无监督学习
    聚类。k-means （只有特征值。什么都没有的）

应用： 银行，图像，文本，贷款吗，票房，      预测价格，股票
        预测具体的气温，年龄扽等 （回归）   预测天气是晴天还是阴天：（分类问题）

（2）
    机器学习开发流程。         《数据》
                    1、公司本身就有的数据
                    2、合作过来的数据（和银行的合作数据，情感分析）
                    3、购买的数据（很少）
                爬虫爬数据需要提前定好。但是不能随便想爬什么就爬什么

    原始数据：   
            1、明确问题是做什么的，建立模型：根据数据类型划分应用种类
               分类问题还是回归问题

            2、 表的合并pd取处理数据，前读取pd.red_csv
                                        pd.merge合并

                数据的基本处理 ：合并表，缺失值

            3、（主要）特征工程
                对每个特征进行处理

                对特征进行处理，标准化，归一化。文本转化数字，fit_transform

            4、找到合适的算法去进行预测分析（使用算法）

         什么是模型？   算法 + 数据 （抽象）

             5、 

             模型的评估过程。，不能讲拿来就用。（不断提高模型的准确性 95%以上）

             如果模型评估没有合格，则需要换其他比较好的算法（调整参数）
                 if （==false）
                     特征工程继续改变，影响因素，增加特征，删除
《前提。明确问题。分裂回归还是聚类》

             模型评估 ➡️ 上线使用 （以API形式提供）

知识点回顾：

             CountVectorizer       Tf idf。//////用这个

             特征预处理：对于数值型的数据需要归一化标准化，主成分分析

            归一化（目的）：避免某一个特征对最终结果造成影响

            特征的降维：把特征值减少。1、特征选择 （删除低方差特征）
                                  2、主成分分析（PCA：特征数量>=100）

            有监督（有特征有目标值），无监督 （无目标，只有特征）

            分类：离散
            回归：连续

            聚类：

课程第二天：  （内容重要并且多）
            1、sklearn数据集与估计器
            2、分类算法-k-近邻算法
            3、k-近邻算法实例
            4、分类模型评估
            5、分类算法-朴素贝叶斯算法  （分类算法：重点）
            6、朴素贝叶斯算法实例
            7、模型选择和调优   （重点）
            8、决策树余随机森林

            （一）
                1、数据的获取pd
                2、数据集的划分
                3、数据及的接口介绍
                4、分类和回归数据集（重点）

        问题：1、如果拿到数据全部都用于训练一个模型？

            数据  （拿一部分数据取训练） （拿一些未知的数据评估）

            （训练集（多）  -  测试集（少））     比例： 70% ：30% / 80% :20% / 75%: 25%（使用最多）

            2、划分训练集合测试集是什么意思？

            把样本给划分一部分给测试集  

            训练集（建立模型）      测试集（评估模型，建议模型效果是否好不好）

            3、划分的API ：sklearn。model_seletion.train_test_split       训练测试分来

    （二）
        sklearn 数据集api介绍
                            sklearn。datasets                     。。加载获取流行数据集
                            datasets,load_*（）                  ..规模小的数据集
                            datasets,fetch_*(data_home=None)    。。 规模大的数据集
                            默认下载目录是 ~/scikit_learn_data/

                获取数据格式：
                            load* fecth* 都是字典数据
                            [n_sample * n_features]

                            提前实例化好

                            print(xxx.data)    特征值        二维的numpy.ndarray     
                            print(xxx.target)  目标值            标签数组  二维的numpy.ndarray

                            print(xxx.DESCR) //特征的属性含义

                            也可以单独获取
                            feature_names:特征名
                            target_names:标签名

                sklearn分类数据集（目标值是离散型的，具体的数值）
                                sklearn，datasets.load_iris() 加载鸢尾花数据集
                                sklearn.datasets.load_digits() 加载并返回数字数据集

                数据集的分割：
                            sklearn.model_seletion.train_test_split()
                            参数：x数据集的特征值,     y训练集的特征值 
                            test_size 测试集的大小  0.2 float
                            random_state
                            return 

                            特征值x的训练集和测试集，目标值y的训练集和测试集
     x_train, x_test, y_train, y_test = train_test_split(li.data , li.target, test_size=0.25)

                用于分类的大数据集：新闻数据集
                            (已经下载好了，世直接实例就好了fetch_20newsgroups)
                            slklearn,daatsets.fetch_20newsgroups(data_home=None,subset='train')
                            datasets.clear_data_home(data_home=None)

                sllearn回归数据集

                        sklearn.datasets.load_boston() 
                        加载并获取波士顿房价数据集

                        sklearn.datasets_load_diabetes()  获取并返回糖尿病数据集 

                进行数据的转换：transform

                            fit_transform 输入数据直接转化为数值  
                            fit（）：输入数据  transform（）转化数据
from sklearn.preprocessing import StandScaler
s = StandScaler()
s,fit_transform([[],[],[]])
直接进行数据转化
先用standardScaler（）实例化再用fit_transform([])进行标准化和转化

        (三)估计器：算法的实现，实线算法的api                          

  

   

    

     

    
    

     

        
      1、用于分类的估计器：
     
    
   

    

     

    
    

     

                                                  sklearn.neighbors  k-近邻算法
     
    
   

    

     

    
    

     

                                                  sklearn.naive_bayes  贝叶斯
     
    
   

    

     

    
    

     

                                                  sklearn.linear_model.LogosticRegression 逻辑回归
     
    
   

    

     

    
    

     

                                                  sklearn.tree   决策树余随机森林
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

        
      2、用于回归的估计器：
     
    
   

    

     

    
    

     

                                                  sklearn.linear_model.LinearRegression 线性回归
     
    
   

    

     

    
    

     

                                                  sklearn.linear_model.Ridge  岭回归
     
    
   

    

     

    
    

     
 
     
    
  

门槛：每隔算法api中的参数，传入算法的参数以及属性。了解哪些参数需要传

                
                估计器的流程：

                训练集     测试集    

          extamitor 估计器 ：流程与transform类似 （x_train， y_train）

                        1、调用fit(x_train, y_train)  //可以用

                        2、输入预测数据(测试集) x_test， y_test
                                                    y_predict = predict(x_test) //预测目标值
                        
                        3、预测准确率：score(x_text, y_test)

（1）分类算法-k近邻算法（knn） 1960年提出（简单）

                    需要标准化

                    1、    定义：一个样本中k个最相似（特征宽假中最邻近）的样本的大多数属于某一个类别，则该样本也属于这个类别

                    2、欧式距离：比如说a(a1,a2,a3)b(b1,b2,b3)
                    (a1-b1)^2+(a2-b2)^2+(a3-b3)^2 开根号

            结合之前的例子，计算两个样本距离的特征有什么影响？需要对数据做些什么？

                        标准化： preprocession StandardScaler

            API： sklearn.neighbors.KNeighborsClassifier(n_neighboes=5,algorithm='auto')

                    n_neighbors:查询默认使用的邻居数
                    algorithm：可选用余计算最近邻居的算法 BallTree    kd_tree=KDTree传递参数
 

举例：k-近邻实例预测住房数据 （分类问题）

 

 

  

   

    

     

    
    

     

      import numpy 
      as np
     
    
   

    

     

    
    

     

      import pandas 
      as pd
     
    
   

    

     

    
    

     

      from sklearn.model_selection 
      import train_test_split
     
    
   

    

     

    
    

     

      from sklearn.neighbors 
      import  KNeighborsClassifier
     
    
   

    

     

    
    

     

      from sklearn.preprocessing 
      import StandardScaler
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def knncls():
     
    
   

    

     

    
    

     
    
      """
     
    
   

    

     

    
    

     

       k-近邻预测用户签到位置
     
    
   

    

     

    
    

     

       :return: None
     
    
   

    

     

    
    

     

       """
     
    
   

    

     

    
    

     
    
      # 读取数据
     
    
   

    

     

    
    

     

          data = pd.read_csv(
      "/Users/wusibin/Downloads/热身赛数据/01-12/chongzhi_beier-east-01-12.csv")
     
    
   

    

     

    
    

     
    
      # print(data.head(10))
     
    
   

    

     

    
    

     
    
      # print(data.head(20))
     
    
   

    

     

    
    

     
    
      #处理数据
     
    
   

    

     

    
    

     
    
      #缩小数据，查询数据筛选
     
    
   

    

     

    
    

     

          data = data.query(
      "x> 1.0 & x < 1.25, y>1.0 & y<1.25")
     
    
   

    

     

    
    

     
    
      #处理时间的的数据
     
    
   

    

     

    
    

     

          time_value = pd.to_datetime(data[
      'time'], unit=
      's')
     
    
   

    

     

    
    

     

          print(time_value)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #把日期格式转换成字典格式
     
    
   

    

     

    
    

     

          time_value = pd.DatetimeIndex(time_value)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 构造一些特征
     
    
   

    

     

    
    

     

          data[
      'date'] = time_value.day
     
    
   

    

     

    
    

     

          data[
      'hour'] = time_value.hour
     
    
   

    

     

    
    

     

          data[
      'weekday']  = time_value.weekday
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #把时间戳特征删除
     
    
   

    

     

    
    

     

          data.drop([
      'time'], axis=
      1)
     
    
   

    

     

    
    

     

          print(data)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #把签到数量少于n的目标位置删除
     
    
   

    

     

    
    

     

          place_count= data.groupby(
      'place_id').count()
     
    
   

    

     

    
    

     

          tf = place_count[place_count.row_id > 
      3].reset_index()
     
    
   

    

     

    
    

     

          data = data[data[
      'place_id'].isin(tf.place_id)]
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #去除数据当中的特征值和目标值
     
    
   

    

     

    
    

     

          y = data[
      'place_id']
     
    
   

    

     

    
    

     

          x = data.drop([
      'place_id'], axis=
      1)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #把数据分成训练集和测试集
     
    
   

    

     

    
    

     

          x_train,x_test,y_train,y_test = train_test_split(x, y, test_size=
      0.25)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #特征工程（标准化）
     
    
   

    

     

    
    

     
    
      # data['day'] =
     
    
   

    

     

    
    

     

          std = StandardScaler()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #对测试集合训练集进行标准化
     
    
   

    

     

    
    

     

          x_train = std.fit_transform(x_train)
     
    
   

    

     

    
    

     

          x_test = std.transform(x_test)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #进行算法流程
     
    
   

    

     

    
    

     

          knn = KNeighborsClassifier(n_neighbors=
      5)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #fit ,predict,acore
     
    
   

    

     

    
    

     

          knn.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #得出预测结果
     
    
   

    

     

    
    

     

          y_predict= knn.predict(x_test)
     
    
   

    

     

    
    

     

          print(
      "预测目标签到位置为：",y_predict)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 得出一个准确率
     
    
   

    

     

    
    

     

          print(
      "预测的准确率：",knn.score(x_test,y_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      None
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      "__main__":
     
    
   

    

     

    
    

     

          knncls()
     
    
  

            强调：以下的方法不一定对，需要看训练后的结果怎么样。

            特征值：x,y 坐标，定位准确性，时间戳，日，时，周       目标值：入住位置的id

                        处理：   0<x<10   0<y<10
                            1、由于数据量大，节省时间x，y缩小

                            2、时间戳进行处理，看最后的效果。
                            效果不好就不处理。（年、月、日、周、时、分秒），当做新特征放入数据里

                            3、入住位置特别多（几千，几万个），导致预测准确率低。少于指定的亲到人数的位置删除

data.query(""),里面翻条件，大于多少小于多少，，索引去查询数据

pd.to_datetime()  把时间戳转换成时间年月日

数据的处理：
        1、缩小数据集的范围
        Dataframe.query()

        2、处理日期数据
        pd.to_datetime
        pd.Datetimeindex

        3、删除没用的日期数据
        DataFrame.drop

        5、将签到位置少于n个用户的删除
        data.groupby('place_id').count[] tf = place_count[place_count.row_id >3].reset_index()
        data = data[data['place_id'].isin(tf.place_id)]

.reset_index()、把索引变成某一列

        总结：
                问题：
                    1、k值去多大？有什么影响？

                        k值去很小：容易受异常点的影响

                        k值取很大：容易受样本，k值 数量里面的类别的影响的波动

                    2、性能问题？

                        时间复杂度，样本越大，时间复杂度越高。所以需要手动调参。特别麻烦

                        参数需要调优，参数对结果造成影响。所以需要调优

        总结：
                1、优点：简单易于实现理解，无需参数，无需训练。估计（超参数）
                    算法实例化

                2、缺点：k值取值，以及计算量。

                基本上在实际案例中不用。准确率不高，容易影响计算性能。

分类算法------朴素贝叶斯

    1、概率基础     2、朴素贝叶斯介绍

    应用：垃圾邮件的分类（金融，软件，产品，互联网）找出类别那个可能性概率最高，
         就将这个类别分为所占比例最高的一类的名称

         1、概率基础：根据历史数据预测未来发生的可能性，扔硬币和预测天气

         2、联合概率：包含多个条件，且所有条件同事成立    p(AB)
         2、条件概率：事件A在事件B以及发生的条件下的概率  p(A|B)p(A|B）

         自然语言处理不独立的情况

         朴素贝叶斯----条件（特征）相互独立，否则效果不好
         面试：朴素，条件独立的意思

                    文档分类： 
                            反应主题中心的词：

                            P(科技|词1，词2，词3.。。)  文档：词1，词2，词3.。。。。

                            P(娱乐|词a，词b，词c。。。)  文档：词1 ，词2，词3  。。。

重点：

            （面试）贝叶斯公式：  p(C|W) = P(W|C)P(C) /P(W) 

                                w为给定文档的特征值（），c为文档的类别（给定文档的词）

                                P(C)：每个文档类别的概率：（某文档数、总文档数）
                                P(W|C)：给定类别下特征（被预测文档中出现的词）的概率

                    但是也会出现概率为0
                            如何解决？

                            拉普拉斯平滑系数  P(F1|C) = Ni+a / N+am 
                            a指定的系数1，m为训练集中统计文档的次数

  朴素贝叶斯分类实现API
                    sklearn.naive_bayes.MultinomalNB（alpha = 1.0）  默认

                    alpha：拉普拉斯平滑系数，防止分类的时候类别的概率为0

    朴素贝叶斯算法案例：
                    sklearn20类新闻分类
                    20个新闻数据集包含20个主题的18000个新闻组帖子

 

  

   

    

     

    
    

     

      from sklearn.datasets 
      import fetch_20newsgroups
     
    
   

    

     

    
    

     

      from sklearn.model_selection 
      import train_test_split
     
    
   

    

     

    
    

     

      from sklearn.neighbors 
      import KNeighborsClassifier
     
    
   

    

     

    
    

     

      from sklearn.preprocessing 
      import StandardScaler
     
    
   

    

     

    
    

     

      from sklearn.feature_extraction.text 
      import TfidfVectorizer
     
    
   

    

     

    
    

     

      from sklearn.naive_bayes 
      import MultinomialNB
     
    
   

    

     

    
    

     

      from sklearn.metrics 
      import classification_report
     
    
   

    

     

    
    

     

      from sklearn.model_selection 
      import GridSearchCV
     
    
   

    

     

    
    

     

      from sklearn.tree 
      import DecisionTreeClassifier
     
    
   

    

     

    
    

     

      import pandas 
      as pd
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def naviebays():
     
    
   

    

     

    
    

     
    
      """
     
    
   

    

     

    
    

     

       朴素贝叶斯分类文本
     
    
   

    

     

    
    

     

       :return: None
     
    
   

    

     

    
    

     

       """
     
    
   

    

     

    
    

     

          news = fetch_20newsgroups(subset=
      'all')
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 对数据进行分割
     
    
   

    

     

    
    

     

          x_train,x_test,y_train,y_test = train_test_split(news.data,news.target,test_size=
      0.25)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 对数据集进行特征抽取
     
    
   

    

     

    
    

     

          tf = TfidfVectorizer()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 训练集中对此的列表进行每篇文章的重要性统计['a','b','c','d']
     
    
   

    

     

    
    

     

          x_train = tf.fit_transform(x_train)
     
    
   

    

     

    
    

     

          print(tf.get_feature_names())
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          x_test = tf.transform(x_test)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #进行朴素贝叶斯算法的预测
     
    
   

    

     

    
    

     

          mlt = MultinomialNB(alpha=
      1.0)
     
    
   

    

     

    
    

     

          print(x_train.toarray())
     
    
   

    

     

    
    

     
    
      #sparse的矩阵
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          mlt.fit(x_train, y_train)
     
    
   

    

     

    
    

     
    
      # 以及在api实现了 关于predict的算法
     
    
   

    

     

    
    

     

          y_predict = mlt.predict(x_test)
     
    
   

    

     

    
    

     

          print(
      "预测文章的类别为：", y_predict)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 得出准确率
     
    
   

    

     

    
    

     

          print(
      "准确率为：",mlt.score(x_test,y_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "每个类别的精确率和召回率：",classification_report(y_test,y_predict,news.target_names))
     
    
   

    

     

    
    

     
    
      # classification_report(y_true=,y_pred=,target_names=)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #构造一些参数值进行搜索
     
    
   

    

     

    
    

     

          param = {
      "n_neighbors":[
      3,
      5,
      10]}
     
    
   

    

     

    
    

     
    
      # 进行网格搜索 knn无实例，数据需要在官网获取下载
     
    
   

    

     

    
    

     

          gc = GridSearchCV(knn,param_grid=param,cv=
      10)
     
    
   

    

     

    
    

     

          gc.fit(x_train,y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测准确率
     
    
   

    

     

    
    

     

          print(
      "在测试集上的准确率：",gc.score(x_test,y_test))
     
    
   

    

     

    
    

     

          print(
      "在交叉验证中最好的结果：", gc.best_score_)
     
    
   

    

     

    
    

     

          print(
      "选择最好的模型是：",gc.best_estimator_)
     
    
   

    

     

    
    

     

          print(
      "每隔超参数每次交叉验证的结果：",gc.cv_results_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      None
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ ==  
      "__main__":
     
    
   

    

     

    
    

     

          naviebays()
     
    
   

    

     

    
    

     
 
     
    
  

            流程：
                1、先把数据加载下来fetch——20newsgroups（subsets=0.5）
                    
                    并进行分割陈训练集测试集x_train，y_train，x_test,y_test

                    文本特征抽取

                2、生成文章特征词
                    文本特征抽取

                3、朴素贝叶斯estimator流程进行预估    不需要调参。

                朴素贝叶斯算法受训练集的影响非常大，训练集误差大，结果看到不好

                重要的词如果不具有代表性的话。

                不需要调参。

        总结：
                优点：

                1、分类效率高，准确。只要数据集是准确的
                2、对于缺失数据集不太敏感，少了一个词一个概率影响不大
                3、分类准确率高，无法调参
                4、易于文本分类

                缺点：
                1、假设了文章中的词是具有独立性的，对文章讲不太靠谱
                2、在训练集中进行统计词的工作，会对结果造成较大的干扰。
                只要训练集准备的准确，里面的词具有代表性就效果好

            
            朴素贝叶斯：文本分类
            神经网络：效果更好

    （一）
         分类模型的评估：精确率（准确率）和召回率 
         其他分类标准：F1-score 反应了数据的稳定性

         分类模型评估API：        度量，评估  分类，精确率，召回率
                         sklearn.metrics.classification_report（y_true,y_pred,target_names=Nome）
                         
                         y_true:真实目标值
                         y_pred：估计器预测目标值
                         target——names：目标类别名称
                         return：每个类别进去率余召回率

             实例：
                 print("每个类别的精确率和召回率：",classification_report(y_test,y_predict,news.target_names))

    （二）
        模型的选择余调优 k值，特征值
        
        交叉验证  网格搜索    

        交叉验证，网格搜索搭配使用

        1、交叉验证，为了让评估的模型更加准确可以信

                    所有数据分成n等分（与x_test，y_test，无关系）

                    训练集   训练集    训练集    | 验证集  得出一个模型准确率  模型1

                    训练集   训练集   验证集   | 训练集   得出一个模型准确率  模型2

                    训练集   验证集   训练集   | 训练集   得出一个模型准确率  模型3
                    。。。最后求出模型的品均值的结果为80%

        2、网格搜索---调参数 （调到某一个位置达到的效果最好 ）
                            k-近邻：超参数K

                            若超参数不止一个，a[2,3,5,8,10] b[20,70,80] 两两进行组合

            超参数搜索--网格搜索API      交叉验证

             param = {"n_neighbors":[3,5,10]}  这里的参数可调，提前构造出来的参数值

            sklearn.model_selection.GridSearchCV(estimator,param_gird=None,cv=None)
            estimator:估计器对象
            param_grid:估计器参数（dict）{"n_neighbors":[1,3,5]}
            fit：输入训练数据
            cv：指定几折交叉验证
            score：准确率

            结果分析：
            best_score:在交叉验证中验证的最好结果
            best——estimator：最好的参数模型
            cv_results_:每次交叉验证后的验证集准确率地结果和训练集的准确率的结果

（三） 分类算法----决策树（随机森林）

        比朴素贝叶斯 和 k近邻准确率高很多，高纬度高特征，数据月复杂优势越明显

                                1、认识决策树
                                2、信息基础-银行贷款分析
                                3、决策树的生成
                                4、泰坦尼克号乘客生存分类

    信息熵----信息和消除不确定性是相联系的（决策树的时间划分）
            哪个减少的信息熵更多就选哪个（以此玩下进行二分，是则继续，否则不分）
                                    例如：决策树的实际划分：有自己的房子（是/否）
                                                    是公务员吗？（否/是）

        
        决策树的划分依据：
                信息和消除不确定性是相互联系的

                    （1）信息增益 
                                当得知一个特征的条件之后，减少的信息熵的大小
                                g(D,A)=H(D)-H(D|A) 
                                g为信息增益
                                H(D) 初始信息熵的大小

                        信息熵的计算
                        条件熵的计算
                        g(D|年龄)=H(D|年龄）= 

                常见的决策树的使用方法
                                       ID3信息增益最大的准则
                                       C4.5 信息增益比 对大的准则
                                       CART
                                       回归树：平方误差最小
                                       分类树：基尼系数 最小准则在sklearn中可以选择划分的默认原则

        sklearn决策树API
                        class sklearn.tree.DecisionTreeClassifier(criterion='gini',max_depth=None,random_state=None)

                        决策树分类器：
                        criterion：默认是'gini'系数，也可以选择信息增益的熵'entropy'
                        max_depth:书店深度大小
                        random_state:随机数种子

                        method：
                        decision_path:返回洁厕书的路径

        案例：泰坦尼克号的分类，预测是生是死。看看预测是否准确

        集成学习方法--随机森林

            泰坦尼克号乘客生死分类模型

  

   

    

     

    
    

     

      import pandas 
      as pd
     
    
   

    

     

    
    

     

      from sklearn.feature_extraction 
      import DictVectorizer
     
    
   

    

     

    
    

     

      from sklearn.model_selection 
      import train_test_split, GridSearchCV
     
    
   

    

     

    
    

     

      from sklearn.tree 
      import DecisionTreeClassifier, export_graphviz
     
    
   

    

     

    
    

     

      from sklearn.ensemble 
      import RandomForestClassifier
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def decisionTree():
     
    
   

    

     

    
    

     
    
      """
     
    
   

    

     

    
    

     

       决策树预测泰坦尼克号的生死
     
    
   

    

     

    
    

     

       :return: None
     
    
   

    

     

    
    

     

       """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 获取数据
     
    
   

    

     

    
    

     

          titan = pd.read_csv(
      "http://biostat.mc.vanderbilt.edu/wiki/pub//Main/DataSets/titanic.txt")
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 处理数据，找出特征值和目标值
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          x = titan[[
      'pclass',
      'age',
      'sex']]
     
    
   

    

     

    
    

     

          y = titan[
      'survived']
     
    
   

    

     

    
    

     

          print(x)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #缺失值的处理,把空值进行填充，求平均值
     
    
   

    

     

    
    

     

          x[
      'age'].fillna(x[
      'age'].mean(), inplace=
      True)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 分割数据到训练集到测试集
     
    
   

    

     

    
    

     

          x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=
      0.25)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 进行处理 特征工程 特征？》类别的处理---one_hot编码
     
    
   

    

     

    
    

     

          dict = DictVectorizer(sparse=
      False)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          x_train = dict.fit_transform(x_train.to_dict(orient=
      "records"))
     
    
   

    

     

    
    

     

          print(dict.get_feature_names())
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          x_test = dict.transform(x_test.to_dict(orient=
      "records"))
     
    
   

    

     

    
    

     
    
      # print(x_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 重点，，，用决策树进行预测，并且修改深度5层，超参数，会影响结果
     
    
   

    

     

    
    

     
    
      # max_depth深度可调，值越大决策树越少
     
    
   

    

     

    
    

     

          dec =  DecisionTreeClassifier(max_depth=
      8)
     
    
   

    

     

    
    

     
    
      # 固定步骤，把训练集的目标值和特征值翻入进行
     
    
   

    

     

    
    

     

          dec.fit(x_train,y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测准确率
     
    
   

    

     

    
    

     
    
      # 训练后的成为测试集用dec.score方法预测准确率
     
    
   

    

     

    
    

     

          print(
      "预测的准确率：", dec.score(x_test, y_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #
     
    
   

    

     

    
    

     
    
      # # 导出决策树的结构
     
    
   

    

     

    
    

     
    
      # export_graphviz(dec, out_file="./tree.dot", feature_names=['年龄', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', '女性', '男性'])
     
    
   

    

     

    
    

     
    
      #
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 随机森林进行预测，超参数调优
     
    
   

    

     

    
    

     

          rf = RandomForestClassifier()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          param = {
      "n_estimators": [
      120, 
      200, 
      300, 
      500, 
      800, 
      1200], 
      "max_depth":[
      5,
      8,
      15,
      25,
      30]}
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 网格搜索余交叉验证
     
    
   

    

     

    
    

     

          gc = GridSearchCV(rf, param_grid=param, cv=
      2)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          gc.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "预测准确率:", gc.score(x_test, y_test))
     
    
   

    

     

    
    

     

          print(
      "查看选择的参数模型：", gc.best_params_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      None
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      '__main__':
     
    
   

    

     

    
    

     

          decisionTree()
     
    
  

        流程：
            1、pd读取数据
            2、寻找有影响的特征，处理缺失值（填补，按照那一列的品均值进行填补）
            3、进行特种工程，pd转化字典，特征抽取x_train.to_tict(orient="records")
            4、决策树估计器流程

 

        决策树的结构、本地保存

            1、sklearn.tree.export_graphviz()该函数能够导出DOT格式
            tree.export_graphviz(estimator,out_file='tree.dot',feature_names=[","])

            2、工具：（能够将dot文件替换为pdf、png）
                按照graphviz
                mac： brew install graphviz

                运行命令
                $ dot -Tpng tree.dot -o tree.png

    # 导出决策树的结构
    export_graphviz(dec, out_file="/User/wusibin/Downloads/tree.dot", feature_names=['age年龄', 'pclass=1st', 'pclass=2nd', 'pclass=3rd', 'sex=female女性', 'sex=male男性'])

    总结：
         优点：
             1、简单的理解和解释，树木的可视化
             需要很少的数据准备，其他技术通常需要数据归一化

         缺点：
             1、决策树学习者穿件不能很好的推广数据过于复杂的数
             这被称为过拟合

         DecisionTree

         改进：
             1、减枝cart算法（决策树api中以及实现，随机森林参数调优有关的介绍）
                 把最后分的结果砍掉一点，通过api中实现

             2、随机森林  也可以解决过拟合的问题（决策树的原理）

             ps：企业的重要决策，由于决策树很傻的分析能力，在决策过程应用较多（通过信息增益的大小来判断）
                 前三个因素占主要，就用决策树
                 没有进行归一化，数据参数需要修改

  集成学习方法：
                  建立多个模型组合来解决单一的一个问题

              随机森林：
                      包含多个决策树进行分类（随机森林建立多个决策树的过程）

              
              单个树建立过程：
                          1、随机在N个样本中选择一个样本，重复N次，样本有可能重复
                          2、随机在N个样本在选出m个特征。m取值  

                      随机又返回的抽样：bootstrap

     重点：随机森林API（参数有很多）

             ensemble 集成学习方法  n_estimators： int potional（default = 10）
             random随机数

             class sklearn.ensemble.RandomForestClassifier(n_estimators=10,criterion='gini', max_depth=None,bootstrap=True,random_state=None)

             nestimators: 森林里的树木量

             max_depth：(默认=无) 数的最大深度 5，8，15，25，30

             max_features='auto' 每隔决策树的最大特征数量
             //特征数量太多会过拟合
             if "auto ,then 'max_feature=sqrt(n_features)'"

             bootstrap： 博哦了按，optional（default = True）是否在构建树时使用返回抽样，随机有放回

             随机森林的超参数： 
                             n_estimator 决策树的数量
                             max_depth 每颗树的深度限制

总结：
     优点：
         1、没有缺点
         2、具有极高的准确率
         2、有效运行在大数据上
         3、不需要降维
         4、评估各个特征在分类问题上的重要性
         5、使用最多最广泛

复习：
    （三个分类算法）
                    1、数据集的划分   

                    训练集x_train ，y_train  
                    测试集  x_test ，y_test
                    目的，调试好，使得预测结果准确

                    2、sk-learn的api：
                                    estimator 估计器里面

                                    # 随机森林进行预测，超参数调优
                                    rf = RandomForestClassifier()

                                     param = {"n_estimators": [120, 200, 300, 500, 800, 1200], "max_depth":[5,8,15,25,30]}

                    3、算法
                            k-近邻   //重要程度低
                            朴素贝叶斯
                            决策树-随机森林，网格搜索和交叉验证

                            信息熵，信息增益，

                            多了就过拟合

、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、、

（第三天）

回归
    1、线性回归     之前是准确率，精确率，召回率

    2、分类算法

    3、非监督学习
                岭回归

                k-means ：数据集里面没有目标值怎么去处理 （聚类算法）

回忆回归问题的判定？

    1、【之前的是分类问题：离散，属于哪个类别。每一个数值代表着一个类型】

    2、目标值为连续性，无线划分，某个区间内取得任意数。
        100.35   223.43  

        只要目标值为连续性都可以预测

应用：
        房价()，销售额(影响因素：公司收入，研发的好坏，对特征进行预测)，等等
        贷款额度的预测(得到贷款的一个数值，而不是是否能得到贷款)

    举例： 期末成绩= ：0.7 X 考试成绩 + 0.3 X 平时成绩（上课出勤率）

    线性回归，寻找一种预测的趋势：二维的直线关系
                                三维：特征，目标值，平面中

                            
                        线性关系的定义：
                                    y = kx + b
                                    加b：伪类是对于单个特征的勤快更加通用

                        多个特征：k1 房子的面积 + k2 房子的位置 + b

    线性关系模型：
                1、一个通过属性（特征）的线性组合来进行预测的函数

                f(x) = w1x3 +w2x3 + w3x3

                w为权重    b为偏置项

        线性回归：
                （简单的线性组合）

                1、特征值余目标值之间进行建模的回归分析 
                2、一元线性回归（一个特征，一个目标值）
                   多元：    

        （一）、属性和权重的一种组合来预测结果

                矩阵：
                    大多数算法的计算基础

         数组：                                                矩阵：

0维          5                                               
1维    【5，2，3，3，322】                        
2维     【2，34，56，345，【】】行和列的格式                        必须是二维结构[[行]列]，满足特定运算需求

3维     【【】【】【】】 列表套列表                                矩阵的乘法（神经网络）

                                                            (m行,l列）*（l行，n列）=（m行，n列）
                                                            特征值

                                                  [[1，2，3，4]    [[2],[2],[2],[2]]
                                                  [5,6,7,8]]

                                                    一个特征         一个权重      目标值

                                                   （1行，4列）       （ ）      一个样本一个值
                                                                                 (1,1)
                                                                                (100,1)

数组的运算：加法  乘法

numpy： ndarray

从今往后的所有算法都是迭代的算法：

                            回归： 迭代的算法（一步一步取调参，一步一步取更新的算法）

                            神经网络

                            我们只需要用什么方法，和api就行。拿过来能用就可以了。不需要深入了解

专有名词：损失函数： （预测结果与真实结果的 - 第二个预测结果和真实结果的）的平方 从1开始依次递加
                    不断迭代，寻找最优化的w的值

                    方法

                            《统计学习方法》  
                                           算法     策略         优化   ----迭代过程

                                         线性回归  损失函数        

            方法：
                1、正规方程：（不做要求）
                求解： w = (x的转置x)的-1次方 x的转置y
                   缺点：当特征过于复杂，求解速度太慢

                2、最下二乘法之梯度下降
                                    学习率 * 方向

                 正规方程与梯度下降对比？
             sklearn 线性回归方程，梯度下降API

                         sklearn.linear_model.LinearRegression
                         正规方程
                         普通最小二乘法线性回归

                         coef_；回归系数

                         sklearn.linear_model.SGDRegressor
                         通过SGD最小化线性模型

                         梯度下降

        scikit-learn 优点：

                            1、建立模型简单，预测简单

                     缺点：

                             1、算法过程，有些参数都在API内部优化执行好了，不用自己去指定

        TensorFlow框架：

                        封装有高有低，可以自己实现线性回归，学习率，这些参数可以自己手动指定

        

    案例：
        线性回归实例：
                    1、sklearn线性回归正规方程，梯度下降API
                    2、波士顿房价数据集分析流程

  

   

    

     

    
    

     

      from sklearn.datasets 
      import load_boston
     
    
   

    

     

    
    

     

      from sklearn.linear_model 
      import LinearRegression, SGDRegressor, Ridge, LogisticRegression
     
    
   

    

     

    
    

     

      from sklearn.model_selection 
      import train_test_split
     
    
   

    

     

    
    

     

      from sklearn.preprocessing 
      import StandardScaler
     
    
   

    

     

    
    

     

      from sklearn.metrics 
      import mean_squared_error
     
    
   

    

     

    
    

     

      from sklearn.externals 
      import joblib
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def mylinear():
     
    
   

    

     

    
    

     
    
      """
     
    
   

    

     

    
    

     

       线性回归两种预测房子价格
     
    
   

    

     

    
    

     

       :return: None
     
    
   

    

     

    
    

     

       """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 获取数据
     
    
   

    

     

    
    

     

          lb = load_boston()
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      # 分割数据到训练集和测试集 data训练值 target 测试纸
     
    
   

    

     

    
    

     

          x_train, x_test, y_train, y_test = train_test_split(lb.data, lb.target, test_size=
      0.25)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 输出的是目标值的训练集和测试集，不是测试值的训练集和测试集
     
    
   

    

     

    
    

     

          print(y_train,y_test)
     
    
   

    

     

    
    

     
    
      # 进行标准化处理(?)目标值是否需要标准化处理？要，标准化处理的结果是所有数据都变得非常非常小权重也小。所以更原来的比起来就小监理损失求解
     
    
   

    

     

    
    

     
    
      # inverse_transform 转化成之前的值
     
    
   

    

     

    
    

     
    
      # 特征值和目标值都必须进行标准化处理，要处理两个，所以要实例化两个标准化的API
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 标准化测试值
     
    
   

    

     

    
    

     

          std_x = StandardScaler()
     
    
   

    

     

    
    

     

          x_train = std_x.fit_transform(x_train)
     
    
   

    

     

    
    

     

          x_test = std_x.transform(x_test)
     
    
   

    

     

    
    

     
    
      # 标准化目标值
     
    
   

    

     

    
    

     

          std_y = StandardScaler()
     
    
   

    

     

    
    

     
    
      # 19版本需要用reshape转化成数组或矩阵的形式 .reshape(-1),,,-1是默认值
     
    
   

    

     

    
    

     

          y_train = std_y.fit_transform(y_train.reshape(
      -1, 
      1))
     
    
   

    

     

    
    

     

          y_test = std_y.transform(y_test.reshape(
      1, 
      -1))
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # estimator预测
     
    
   

    

     

    
    

     
    
      # 正规方程求解方式预测结果 训练数据
     
    
   

    

     

    
    

     

          lr = LinearRegression()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          lr.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 打印权重参数
     
    
   

    

     

    
    

     

          print(lr.coef_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
     
    
   

    

     

    
    

     

          y_lr_predict = std_y.inverse_transform(lr.predict(x_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "测试集里面每个房子样本的预测价格：", y_lr_predict)
     
    
   

    

     

    
    

     

          print(
      "正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_lr_predict))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 梯度下降进行房价预测 实例化
     
    
   

    

     

    
    

     

          sgd = SGDRegressor()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          sgd.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 打印权重参数
     
    
   

    

     

    
    

     

          print(sgd.coef_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 保存训练好的模型
     
    
   

    

     

    
    

     

          joblib.dump(lr, 
      "./temp/test.pkl")
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测房价的价格
     
    
   

    

     

    
    

     

          model = joblib.load(
      "./temp/test.pkl")
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          y_predict = std_y.inverse_transform(model.predict_test)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "保存的模型预测结果：", y_predict)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
     
    
   

    

     

    
    

     

          y_sgd_predict = std_y.inverse_transform(sgd.predict(x_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "梯度下降测试集里面每个房子样本的预测价格：", y_sgd_predict)
     
    
   

    

     

    
    

     

          print(
      "梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_sgd_predict))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 岭回归进行实例".
     
    
   

    

     

    
    

     

          rd = Ridge(alpha=
      1)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 梯度下降进行房价预测 实例化
     
    
   

    

     

    
    

     

          rd = SGDRegressor()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          rd.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 打印权重参数
     
    
   

    

     

    
    

     

          print(rd.coef_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
     
    
   

    

     

    
    

     

          y_rd_predict = std_y.inverse_transform(rd.predict(x_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "梯度下降测试集里面每个房子样本的预测价格：", y_rd_predict)
     
    
   

    

     

    
    

     

          print(
      "梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_rd_predict))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      None
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      "__main__":
     
    
   

    

     

    
    

     

          mylinear()
     
    
  

 

                分析：影响房子的价格因素：小区犯罪率，空气好坏等等，得出13个权重
                目的：求出这13个权重

需要做标准化处理的算法：
                    k-近邻
                    线性回归

            流程：
                1、获取数据
                2、数据分割
                3、训练与测试集，数据标准化处理（重点）
                    为什么要标准化？
                    因为建立过程，权重和特征都会有影响。数据特征越大影响越大，所以需要做标准化处理

                    # 进行标准化处理(?)目标值是否需要标准化处理？要，标准化处理的结果是所有数据都变得非常非常小
                    特征值和目标值都必须进行标准化处理，要处理两个，所以要实例化两个标准化的API

                4、使用最简单的线性回归模型LinearReggression 和梯度下降估计SGDRegressor对房价进行预测

                19版本要求标准化API转换器，estimator必须是二维的
                # 19版本需要用reshape转化成数组或矩阵的形式 .reshape(-1),,,-1是默认值
                   y_train = std_y.fit_transform(y_train.reshape(-1, 1))
                y_test = std_y.transform(y_test.reshape(1, -1))

        (二)
            回归性能评估：均方误差，与差值余真实值之间差值的平安和求一个平均值

            API：mean_squared_error(y_true,y_pred)
            y_true：真实值
            y_pred：预测值
            return：浮点数结果

------------------------------- ---------------对比--------------------------------------------------------

  梯度下降                                            |                正规方程                                       
需要选择学习率a                                 |                不需要
需要多次迭代                                       |                一次运算出
当特征数量n大是也能很好的使用        |            需要计算很多东西东西东西
适用于各种类型的模型                        |            只适用于线性模型，不适用逻辑回归模型等其他模型

小规模数据LinearRegression                           大规模数据：SGDRegressor

(三)
    过拟合（模型过于复杂）  与  欠拟合（模型过于简单）

    解决办法：
            根据结果现象来判断：
                            比较：交叉验证训练集的结果，网格搜索

欠拟合：测试集，交叉验证，训练集的结果表现不写
过拟合：交叉验证99%，但在测试集就是89%，表现越来越差

            欠拟合：增加数据

            过拟合：在训练的时候学不到什么东西，但是在测试集的时候还是。
                    1、特征选择（消除一些没用的删掉）
                    2、交叉训练（让所有数据都有结果训练）：实际无效果
                    3、正则化

            特征选择：
                    1、嵌入式   重点
                    2、包裹时
                    3、过滤式   低方差特征
                    4、正则化
                    5、神经网络
                    6、决策树

线性回归：LinearRegression 容易出现过拟合 因为在训练的过程中伪类把训练集的数据表现更好。

    对线性和非线性都可以去拟合
    对于非线性去拟合最容易出现复杂模型 

    问题？训练数据训练的很好啊，误差也不大，为什么测试集上面有问题呢？    对线性模型模型训练会变成复杂模型

（岭回归）

通过回归解决过拟合：
                线性回归LinearRegression  容易出现过拟合，为了把训练集数据表现根号

                L2正则化： 岭回归  带有正则化的西安新回归  解决过拟合

                API： sklearn.linear_model.Ridge(alpha=1.0)

                具有L2 正则化的闲心最小二乘法把二次项的系数趋近于0

                Ridge：

                alpha：正则化力度
                coef_：回归系数

        岭回归：正则化，把高次项系数不断趋近于0 

        总结：

            岭回归LinearRession 与Ridge对比

            岭回归与闲心回归的比较一定要在数据中才能体现出来

            具有L2 正则化的闲心最小二乘法把二次项的系数趋近于0

            岭回归得到的回归系数更符合实际。林外，能让估计参数的波动更稳定，变化小，又有实用价值

第二天总结：  思维导图存于桌面机器学习文件夹里面

        （一）
            模型的保存与加载
            API： from sklearn.externals.import  joblib
            joblib 模块

            保存： joblib.dump(rf, 'test.pkl')

            加载：estimator = joblib.load('test.okl') 

            ps:sklearn里面固定保存的文件格式

        （二）逻辑回归

                    1、线性回归的输入------>分类问题   （逻辑回归）

                    2、sigmoid函数 （要求计入其样子）
                                                    值为 0-1 之间（具体的概率值） 

                    3、
                        逻辑回归的损失：    信息熵越小预测越准确，100%确定，信息熵为0
                        

                        梯度下降求解：损失函数的最低点

                        损失函数：均方误差（不存在局部最低点）只有一个最小值

                        对数似然损失：
                                    方法：使用梯度下降关系 

                        梯度下降求解：
                                    1、多次随机初始化，多次比较最小值结果
                                    2、求解过程当中，调整学习率
                                    （尽量改善，但不能解决最终问题）
                                    尽管没有全局最低点，但效果哦还是不错的

                正规方程与梯度下降的对比？

        逻辑回归API：
                    sklearn.linear_model.LogisticRegression(penalty='12',c=1.0) 
                    Logistic 回归分类器
                    coef_:回归系数

        逻辑回归案例：

                    良性、恶性乳腺癌肿瘤
                    数据描述：699个氧泵，一共11列数组，第一列用语言检索id，后9列分别是与肿瘤相关的医学特征

  

   

    

     

    
    

     

      from sklearn.datasets 
      import load_boston
     
    
   

    

     

    
    

     

      from sklearn.linear_model 
      import LinearRegression, SGDRegressor, Ridge, LogisticRegression
     
    
   

    

     

    
    

     

      from sklearn.model_selection 
      import train_test_split
     
    
   

    

     

    
    

     

      from sklearn.preprocessing 
      import StandardScaler
     
    
   

    

     

    
    

     

      from sklearn.metrics 
      import mean_squared_error, classification_report
     
    
   

    

     

    
    

     

      from sklearn.externals 
      import joblib
     
    
   

    

     

    
    

     

      import pandas 
      as pd
     
    
   

    

     

    
    

     

      import numpy 
      as np
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def mylinear():
     
    
   

    

     

    
    

     
    
      """
     
    
   

    

     

    
    

     

       线性回归两种预测房子价格
     
    
   

    

     

    
    

     

       :return: None
     
    
   

    

     

    
    

     

       """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 获取数据
     
    
   

    

     

    
    

     

          lb = load_boston()
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
    
      # 分割数据到训练集和测试集 data训练值 target 测试纸
     
    
   

    

     

    
    

     

          x_train, x_test, y_train, y_test = train_test_split(lb.data, lb.target, test_size=
      0.25)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 输出的是目标值的训练集和测试集，不是测试值的训练集和测试集
     
    
   

    

     

    
    

     

          print(y_train,y_test)
     
    
   

    

     

    
    

     
    
      # 进行标准化处理(?)目标值是否需要标准化处理？要，标准化处理的结果是所有数据都变得非常非常小权重也小。所以更原来的比起来就小监理损失求解
     
    
   

    

     

    
    

     
    
      # inverse_transform 转化成之前的值
     
    
   

    

     

    
    

     
    
      # 特征值和目标值都必须进行标准化处理，要处理两个，所以要实例化两个标准化的API
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 标准化测试值
     
    
   

    

     

    
    

     

          std_x = StandardScaler()
     
    
   

    

     

    
    

     

          x_train = std_x.fit_transform(x_train)
     
    
   

    

     

    
    

     

          x_test = std_x.transform(x_test)
     
    
   

    

     

    
    

     
    
      # 标准化目标值
     
    
   

    

     

    
    

     

          std_y = StandardScaler()
     
    
   

    

     

    
    

     
    
      # 19版本需要用reshape转化成数组或矩阵的形式 .reshape(-1),,,-1是默认值
     
    
   

    

     

    
    

     

          y_train = std_y.fit_transform(y_train.reshape(
      -1, 
      1))
     
    
   

    

     

    
    

     

          y_test = std_y.transform(y_test.reshape(
      1, 
      -1))
     
    
   

    

     

    
    

     
    
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # estimator预测
     
    
   

    

     

    
    

     
    
      # 正规方程求解方式预测结果 训练数据
     
    
   

    

     

    
    

     

          lr = LinearRegression()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          lr.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 打印权重参数
     
    
   

    

     

    
    

     

          print(lr.coef_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
     
    
   

    

     

    
    

     

          y_lr_predict = std_y.inverse_transform(lr.predict(x_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "测试集里面每个房子样本的预测价格：", y_lr_predict)
     
    
   

    

     

    
    

     

          print(
      "正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_lr_predict))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 梯度下降进行房价预测 实例化
     
    
   

    

     

    
    

     

          sgd = SGDRegressor()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          sgd.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 打印权重参数
     
    
   

    

     

    
    

     

          print(sgd.coef_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 保存训练好的模型
     
    
   

    

     

    
    

     

          joblib.dump(lr, 
      "./temp/test.pkl")
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测房价的价格
     
    
   

    

     

    
    

     

          model = joblib.load(
      "./temp/test.pkl")
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          y_predict = std_y.inverse_transform(model.predict_test)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "保存的模型预测结果：", y_predict)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
     
    
   

    

     

    
    

     

          y_sgd_predict = std_y.inverse_transform(sgd.predict(x_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "梯度下降测试集里面每个房子样本的预测价格：", y_sgd_predict)
     
    
   

    

     

    
    

     

          print(
      "梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_sgd_predict))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 岭回归进行实例".
     
    
   

    

     

    
    

     

          rd = Ridge(alpha=
      1)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 梯度下降进行房价预测 实例化
     
    
   

    

     

    
    

     

          rd = SGDRegressor()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          rd.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 打印权重参数
     
    
   

    

     

    
    

     

          print(rd.coef_)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 预测测试集的发展价格,,这个不能缩小，所以用inverse在std_y下的api，换回原来的值
     
    
   

    

     

    
    

     

          y_rd_predict = std_y.inverse_transform(rd.predict(x_test))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(
      "梯度下降测试集里面每个房子样本的预测价格：", y_rd_predict)
     
    
   

    

     

    
    

     

          print(
      "梯度下降正规方程的均方误差回归性能的评估：", mean_squared_error(std_y.inverse_transform(y_test), y_rd_predict))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      None
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      def logistic():
     
    
   

    

     

    
    

     
    
      """
     
    
   

    

     

    
    

     

       逻辑回归左细胞分类的预测
     
    
   

    

     

    
    

     

       :return:
     
    
   

    

     

    
    

     

       """
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # pd.merge( )
     
    
   

    

     

    
    

     
    
      # 构造列明标签名字，
     
    
   

    

     

    
    

     

          column = [
      'time_date',
      'street',
      'direction',
      'car1',
      'car2']
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      #以下的数据可能有误差
     
    
   

    

     

    
    

     

          data = pd.read_csv(
      "/Users/wusibin/Downloads/热身赛数据/01-12/chongzhi_beier-east-01-12.csv",names=column)
     
    
   

    

     

    
    

     
    
      # data = pd.read_csv("https://archive.ics.uic.edu/ml/machine-learning-databases/breast-cancer-wisconsin/breast-cancer-wisconsin.data",names=column)
     
    
   

    

     

    
    

     

          print(data)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 缺失值进行处理 缺失值是？号，替换？号 替换成np.nan
     
    
   

    

     

    
    

     

          data.replace(to_replace=
      '?', value=np.nan)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 删除空缺值
     
    
   

    

     

    
    

     

          data = data.dropna()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 进行数据的分割 评判 找特征值
     
    
   

    

     

    
    

     

          x_train,x_test,y_train,y_test = train_test_split(data[column[
      1:
      10]],data[column[
      10]],test_size=
      0.25)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 进行标准化处理
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          std = StandardScaler()
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          x_train = std.fit_transform(x_train)
     
    
   

    

     

    
    

     

          x_test = std.transform(x_test)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      # 逻辑回归预测
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          lg = LogisticRegression(C=
      1.0)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          lg.fit(x_train, y_train)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          y_preditc = lg.predict(x_test)
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

          print(lg.coef_)
     
    
   

    

     

    
    

     

          print(
      "准确率：", lg.score(x_test,y_test))
     
    
   

    

     

    
    

     

          print(
      "召回率:", classification_report(y_test,y_preditc,labels =[
      2,
      4],target_names=[
      "良性", 
      "恶性"]))
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
    
      return 
      None
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     
 
     
    
   

    

     

    
    

     

      if __name__ == 
      "__main__":
     
    
   

    

     

    
    

     
    
      # mylinear()
     
    
   

    

     

    
    

     

          logistic()
     
    
  

            流程：
                1、网上获取数据（工具pandas）
                2、数据缺失值的处理、标准化
                3、LogisticRegression 估计器流程

    pandas的使用：
                pd.read_csv(",names=column_names")
                类别的名字
                column_names=['Sample code number','clump thichks','....','.......']
                replace(to_place",value=):返回数据

                cv是代表交叉验证

    总结逻辑回归：
                只能解决二分类问题：
                                应用： 广告点击率预测，是否患病，金融诈骗，是否为虚假账号

                                1、优点：适合需要得到一个分类概率的场景，建档，速度快

                                2、缺点：不好处理多分类问题

    多分类问题：神经网络

                    1、softmax方法-逻辑回归咋更多分类问题上的推广

                    生成模型和判别模型

                    逻辑回归                                 朴素贝叶斯  

    解决问题               二分类                                文本分类
    应用场景         癌症，二分类需要的概率                    文本分类问题
    参数              正则化力度                            没有
                    得出的结果都有概率解释

判别模型：

        判别模型的依据：
        是否有先验概率：是否从历史依据中总结出来的概率信息

        如果不需要总结就称之为判别模型

        1、决策树，随机森林，神经网络，k-近邻  （先验概率）

        2、隐马尔可夫模型

基本的分类和回归算法都已经完毕了

softmax方法逻辑回归在多分类问题上的推广---将在后面的神经网络算法中介绍

非监督学习算法：（聚类  k-means ）
            1、没有目标值，只有特征值（不适用来预测）
            2、把相近特征的数据归为一个类别（物以类聚，人以群分）

    聚类：k把数据划分成多少个类别，
                            1、知道类别个数
                            2、不知道类别个数      超参数

                k-means步骤：

                举例：
                    1、k=3 在1000多个样本中取出三个样本，当做三个类别的中心点（    k1,k2,k3）
                    2、计算其余的点，分别到这三个中心点的举例（a,b,c）,每一个样本有三个距离，从中选出距离最近的一个点，作为自己的一个标记（形成了三个族群）//简单的聚类过程
                    3、分别计算这三个族群的平均值，把三个品均值与之前的三个旧中心点进行比较
                                            绿1(x1,x2) 绿2(x2,x2) 平均值（x1平,x2平）

                        如果相同： 结束聚类
                        如果不相同：把这三个平均值单做新的中心点，重复第二步骤

                    k-means API          聚类 
                                sklearn.cluster.KMeans(n_cluster=8,init='k-means++')

                                k-means'聚类'
                                n_cluster:开始的聚类中心数量
                                init:初始化方法，默认为'k-means++'

                                labels_:默认标记的类型，可以和真实值比较（不是值比较）

                                k-means对instacart Market用户聚类
                                1、降维之后的数据
                                2、k-means聚类
                                3、聚类结果显示

 

                

    

转载：https://blog.csdn.net/evanwusibin/article/details/106255177