机器学习常用算法

k近邻算法

  求出未知点 与周围最近的 k个点的距离

  查看这k个点中大多数是哪一类

  根号((x已知-x未知)^2+(y已知-y未知)^2)  即平面间2点距离公式

  收异常点影响较大,因此需要做标准化处理

  API:sklearn.neighbors.KNeighborsClassifier(n_neighbors=5,algorithm="auto")

      algorithm:{"auto","ball_tree","kd_tree","brute"}

          效率不同

          ball_tree:会使用BallTree

          kd_tree:会使用KdTree

          auto:尝试根据传递的fit方法的值决定最适合的算法

      n_neighbors: 邻居数,默认为5

处理:

  时间特征:需要转为年,月,日,时,分,秒 ,当做几个新的特征处理,并不是全部要加入,要根据结果选择加入

  目标值:可以去掉某些目标值

from sklearn.neighbors import KNeighborsClassifier

def knnCls():

    """

    预测鸢尾花的种类

    :return:

    """

    # 读取数据

    from sklearn.datasets import load_iris

    iris = load_iris()

    print(iris.feature_names)

    print(iris.data[0:5,:])

    print(iris.data)

    # 处理数据

    # 1,缩小数据  对于csv中的数据可使用 data.query("id>8 & money <2000") 等过滤掉一些数据

    # 2,时间处理

    #   time_value = pd.to_datetime(data中的时间列,unit="s") unit 表示时间最小的单位

    #        time_value格式为 1970-01-01 00:00:00 注意不能单独获取年月日

    #   time_value=pd.DatatimeIndex(time_value) 此时转换为字典格式的时间

    #   增加特征,例如年相同,就不能当做特征

    #       data['day'] = time_value.day,weekday,hour等不建议使用 此方式

    #           建议使用data.loc["day"] = xxx

    #       pandas使用data.drop(["time"],axis=1) 删除原来的时间戳,

    #       数组使用np.delete(data,[1,2,3等列],axis=1) 删除原来的时间戳

    # 3,目标值处理

    #     目标值过多,单有的目标值数量太少,可以忽略

    #     分组求和,本例中 可表示为 把数量少于n个的种类删除(虽然本类中目标值只有3个,其实不用删除,只为演示效果)

    #     group = data.groupby("目标值列名").count()

    #     此时返回结果 列数不变,目标值列名列为所有的目标值,其他列不再是值,而是分组后该组的个数

    #     tf = group[group['非目标值列列名']>n].reset_index()

    #     data = data[data[目标列列名].isin(tf.目标列列名)]

    #     取出目标值 y =data["目标列"]

    #     取出目标值 x =data.drop(["目标列"],axis=1)

    #     x_train,y_train,x_test,y_test数据分割 train_test_spilt

    # 特征工程(标准化)

    #   x_train 进行fit_transform

    #   注意 也需要对 x_test进行标准化,注意使用 transform即可, 即 使用 训练集的参数进行标准化

    #   标准化对数据最后结果影响很大

    # 算法处理

    knn = KNeighborsClassifier(n_neighbors=5)

    # fit ,predict,score

    knn.fit(x_train,y_train)

    # 得出结果

    y_predict = knn.predict(x_test) # 得出预测目标值

    # 得出准确率

    knn.score(x_test,y_test) # 也可以使用y_predict与y_test 得出

    return None

问题1:k的取值问题,很大,很小?

    很大:易受异常点影响

    很小:容易受k值(数量)波动

性能问题:每一个未知数来都需要与全部数据进行计算

    很费时间

调参:n_neighbors 的合适值

优点:易于理解,易实现,无需参数(算法里边的参数)估计,无需训练\

缺点:计算慢,耗内存,必须有k

朴素(条件独立)贝叶斯算法 (需要学习概率相关内容)

概率:

  条件概率:P(A1,A2|B) = P(A1|B)*P(A2|B)  A1,A2 不能相互影响  应该是条件独立

  联合概率 P(A,B) = P(A)*P(B)

例:常用与对于文章的分类

  每个文章会计算属于每个分类的概率,比较数据那个的概率较大,就是该分类

P(科技|文章1)  文档

P(科技|词1,词2.....)  文档:词1,词2....  (多个条件下 x的概率)

朴素贝叶斯-贝叶斯公式

P(A|B)=P(B|A)P(A)/P(B)

=====================================

个人体会:例 有两个箱子 A:两黑,两白球 B两黑球,1白球

  随机从两个盒子中拿出一个球,是白球, 求是从A中拿出的概率

  P(A|白) = (P(白|A)P(A))/P(白) = 0.5*0.5/(1/2*1/2+1/2*1/3)=7/12

  P(B|白) = (P(白|B)P(B))/P(白) = 1/3*0.5/(1/2*1/2+1/2*2/3)=5/12
贝叶斯推导:https://www.cnblogs.com/lliuye/p/9178090.html

=====================================

  求在包含这些词的情况下是科技类的概率=在科技分类下这些词(这个文档)出现的概率*科技类的概率/在所有文档中,这些词的概率

  P(C|W)=(P(W|C)P(C))/P(W)

      W为给定文档的特征值(频数统计,预测文档提供),C为文档类别

      可理解为:P(C|F1,F2.....)=(P(F1,F2..|C)P(C))/P(F1,F2,....)

  P(C):每个文档类别的概率(某类文档数/文档总数)

  P(W|C):给定列别下 特征(词)的概率

      P(F1|C) = Ni/N (表示该次出现在科技文章中的概率)   F1,F2.....的概率乘积  表示 科技类文章中这些词都出现的概率

          Ni为F1词在c类所有文档中出现的次数,(科技类文章中改词的次数)

          N为c类文档下所有词的总和 .(科技类文章中 所有的词 和)

  有些情况下得到文章属于某类的概率为0,不合理

      解决办法:拉普拉斯平滑系数  P(F1|C) = (Ni+a)/N+am

          a:指定系数一般为1,m为训练文档中出现的特征词的个数

算法API sklearn.native_bayes.MultinomiaNB

  sklearn.native_bayes.MultinomiaNB(alpha=1.0) 拉普拉斯平滑系数,不属于超参数

例:新闻分类

from sklearn.datasets import fetch_20newsgroups

from sklearn.model_selection import train_test_split

def naviebayes():

    """

    朴素贝叶斯进行文章分类

    :return:

    """

    # 加载数据,进行分割

    news = fetch_20newsgroups(subset="all")

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

    # 生成文章特征词

    from sklearn.feature_extraction.text import TfidfVectorizer

    from sklearn.metrics.classification import classification_report

    tf = TfidfVectorizer()

    #以训练集中词的列表进行 每篇文章重要性统计

    x_train = tf.fit_transform(x_train)

    # print(tf.get_feature_names()) # 全部文章中所有的词

    x_test = tf.transform(x_test)

    # 朴素贝叶斯进行评估

    from sklearn.naive_bayes import MultinomialNB

    mlt = MultinomialNB(alpha=1.0)

    #print(x_train) # .toarray 可转化为二维数组

    """

    (0, 122986)    0.1189432263044612 # 第一篇文章中 feature_names下标122986的这个词 出现的频率

    (0, 139798)    0.25782353561208343

    (0, 117722)    0.12774899257629055

    """

    mlt.fit(x_train,y_train)

    y_predict = mlt.predict(x_test)

    print(classification_report(y_test,y_predict,target_names=news.target_names))

    # 算出准确率,由于文章词的数量确定,数据的正确性,因此 准确率不易提高

    # print(mlt.score(x_test,y_test))

优点:

  发源于古典数学,有稳定的分类效率

  速度快,效率高

  对数据缺失不敏感,常用于文本分类

缺点:

  前提是一个词的出现与另一个无关,当词之间出现关联时,效果不好

if __name__ == "__main__":

    # knnCls()

    naviebayes()

    pass

模型评估(不仅靠准确率,还有召回率)

  准确率:estimator.score() 最常见是预测结果的准确率,即百分比

  混淆矩阵

准确率 35%,但召回率 75%

"""                         预测结果

                         正例(猫)   假例(不是猫)

真实结果    20正例(猫)       真正例(15)     伪反例(5)

真实结果    80假例(不是猫)    伪正例(60)     真反例(20)

"""

  精确率:预测为正例的样本中,真正例的比例

  召回率:真实值正例中,预测为正例的比例 15/20 越高越好

其他分类标准F1-SCORE 反映了模型的稳健性

  F1 = 2*精确率*召回率/(精确率+召回率)

API sklearn.metrics.classification_reportly(y_true,y_pred,target_names=None)

  y_true:真实目标值

  y_pred:估计器预测目标值

  terget_names:目标类别名称

  return:每个类(目标值)的精确率与召回率

模型选择与调优

  交叉验证:让别评估模型更加准确

      训练集分为n份:训练集(n-1)份+验证集1份 得出一个准确率 模型一

      再次训练集分为n份:训练集(n-1)份+验证集1份(就是修改验证集,可能此时第一份为验证集) 得出一个准确率 模型二

      ..... 依次进行 得出n个准确率   求平均 即可以作为可信一点的模型结果

      分为n份就称为n折交叉验证

  网格搜索(超参数搜索):调参数(k近邻)

      与交叉验证组合k = 3,5,7 10折交叉验证

          k=3 时的平均,k=5的平均...  比较即可得出比较可信的k值

      当有两个找参数时:两两组合

  API sklearn.model_selection.GridSearchCV(estimator,param_grid=none,cv=None)

      estimator:估计器(knn) 此时估计器中不用再写超参数

      param_grid:估计参数 {"n_neighbors":[1,2,3,4,5]}

      cv:几折交叉验证

          不用 knn.fit predict

      此时返回的实例

          fit(x_train,y_train):输入训练数据

          score(x_test,y_test):准确率

          best_score_:在交叉验证中最好的结果

          best_estimator_:在交叉验证中最好的参数模型

          cv_results_:每次交叉验证后验证集集准确率和训练集准确率(验证集平均值)

from sklearn.model_selection import GridSearchCV

gc = GridSearchCV(KNeighborsClassifier(),param_grid={"n_neighbors":[1,2,3,4,5]})

gc.fit(x_train,y_train)