分类算法学习

一、分类算法-k近邻算法(KNN)

定义：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。

二、推测入住位置案例

分析：特征值：x，y坐标，定位准确性，年 ，日，时，周， 目标值：入住位置的id 是一个分类问题。
处理：
1、0 <x <10 0 <y <10
2、时间戳进行（年，月，日，周，时分秒），当做新的特征
3、几千 ~几万个 少于指定签到人数的位置删除

三、没有进行标准化

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
import pandas as pd
def knncls():
    """
    k-近邻预测用户签到位置
    :return: None
    """
    #读取数据
    data = pd.read_csv("./data/train.csv")
    # print(data.head(10))
    #处理数据
    #1 缩小数据 查询数据筛选
    data = data.query("x > 1.0 & x <1.25 & y >2.5 & y<2.75")
    #处理时间的数据
    time_value = pd.to_datetime(data['time'],unit='s')
    #把日期格式转换成字典格式
    time_value = pd.DatetimeIndex(time_value)
    #构造一些特征
    data['day'] = time_value.day
    data['hour'] = time_value.hour
    data['weekday'] = time_value.weekday
    #把时间戳特征删除
    data = data.drop(['time'],axis=1)

    #把签到数量少于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)]
    # print(data)
    #取出数据当中的特证值和目标值
    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)
    #特征工程(标准化)

    #进行算法流程
    knn = KNeighborsClassifier(n_neighbors=5)
    knn.fit(x_train,y_train)
    #得出预测结果
    y_predict = knn.predict(x_test)
    print("预测的目标签到位置为：",y_predict)
    #得出准确率
    print("预测的准确率",knn.score(x_test,y_test))


if __name__ == "__main__":
    knncls()

四、进行标准化

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
import pandas as pd
def knncls():
    """
    k-近邻预测用户签到位置
    :return: None
    """
    #读取数据
    data = pd.read_csv("./data/train.csv")
    # print(data.head(10))
    #处理数据
    #1 缩小数据 查询数据筛选
    data = data.query("x > 1.0 & x <1.25 & y >2.5 & y<2.75")
    #处理时间的数据
    time_value = pd.to_datetime(data['time'],unit='s')
    #把日期格式转换成字典格式
    time_value = pd.DatetimeIndex(time_value)
    #构造一些特征
    data['day'] = time_value.day
    data['hour'] = time_value.hour
    data['weekday'] = time_value.weekday
    #把时间戳特征删除
    data = data.drop(['time'],axis=1)

    #把签到数量少于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)]
    # print(data)
    #取出数据当中的特证值和目标值
    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)
    #特征工程(标准化)
    std = StandardScaler()
    #对测试集和训练集的特证值进行标准化
    x_train = std.fit_transform(x_train)
    x_test = std.fit_transform(x_test)
    #进行算法流程
    knn = KNeighborsClassifier(n_neighbors=5)
    knn.fit(x_train,y_train)
    #得出预测结果
    y_predict = knn.predict(x_test)
    print("预测的目标签到位置为：",y_predict)
    #得出准确率
    print("预测的准确率",knn.score(x_test,y_test))


if __name__ == "__main__":
    knncls()

五、k近邻算法总结

1、k值取多大？有什么影响？

k值取很小：容易受异常点影响
k值取很大：容易受最近数据太多导致比例变化

优点：
简单，易于理解，易于实现，无需估计参数，无需训练

缺点：
懒惰算法，对测试样本分类时的计算量大，内存开销大
必须指定K值，K值选择不当则分类精度不能保证
使用场景：小数据场景，几千～几万样本，具体场景具体业务
去测试

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

朴素贝叶斯算法的条件是 特征独立。

1、联合概率和条件概率：

联合概率：包含多个条件，且所有条件同时成立的概率

记作：P(A,B)

条件概率：就是事件A在另外一个事件B已经发生条件下的发生概率

记作：P(A|B)

特性：P(A1,A2|B) = P(A1|B)P(A2|B)
注意：此条件概率的成立，是由于A1,A2相互独立的结果

2、朴素贝叶斯-贝叶斯公式

3、拉普拉斯平滑系数

问题：从上面的例子我们得到娱乐概率为0，这是不合理的，如果词频列表里面
有很多出现次数都为0，很可能计算结果都为零

解决方法：拉普拉斯平滑系数

α为指定的系数一般为1，m为训练文档中统计出的特征词个数

3、朴素贝叶斯API

sklearn.naive_bayes.MultinomialNB(alpha = 1.0)
朴素贝叶斯分类

alpha：拉普拉斯平滑系数

在这里插入代码片

七、朴素贝叶斯案例

sklearn20类新闻分类
20个新闻组数据集包含20个主题的18000个新闻组帖子

# coding=utf-8
from sklearn.datasets import load_iris,fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
import pandas as pd
def naviebayes():
    """
    朴素贝叶斯进行文本分类
    :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()
    x_train = tf.fit_transform(x_train)
    print(tf.get_feature_names_out())
    x_test = tf.transform(x_test)
    #进行朴素贝叶斯算法
    mlt = MultinomialNB(alpha=1.0)
    print(x_train.toarray())
    mlt.fit(x_train,y_train)
    y_predict = mlt.predict(x_test)
    print("预测的文章的类别为：",y_predict)
    #得出准确率
    print("准确率为：",mlt.score(x_test,y_test))
    return None
if __name__ == "__main__":
    naviebayes()

朴素贝叶斯总结：

优点：
朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。

对缺失数据不太敏感，算法也比较简单，常用于文本分类。

分类准确度高，速度快
缺点：
需要知道先验概率P(F1,F2,…|C)，因此在某些时候会由于假设的先验
模型的原因导致预测效果不佳。

八、分类模型的评估

精确率：预测结果为正例样本中真实为正例的比例（查得准）

召回率：真实为正例的样本中预测结果为正例的比例（查的全，对正样本的区分能力）

# coding=utf-8
from sklearn.datasets import load_iris,fetch_20newsgroups
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.metrics import classification_report
import pandas as pd
def naviebayes():
    """
    朴素贝叶斯进行文本分类
    :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()
    x_train = tf.fit_transform(x_train)
    print(tf.get_feature_names_out())
    x_test = tf.transform(x_test)
    #进行朴素贝叶斯算法
    mlt = MultinomialNB(alpha=1.0)
    print(x_train.toarray())
    mlt.fit(x_train,y_train)
    y_predict = mlt.predict(x_test)
    print("预测的文章的类别为：",y_predict)
    #得出准确率
    print("准确率为：",mlt.score(x_test,y_test))
    print("每个类别的精确率和召回率",classification_report(y_test,y_predict,target_names=news.target_names))
    return None
if __name__ == "__main__":
    naviebayes()

九、交叉验证

交叉验证：为了让被评估的模型更加准确可信
交叉验证：将拿到的数据，分为训练和验证集。以下图为例：将数据分成5份，其中一份作为验证集。然后经过5次(组)的测试，每次都更换不同的验证集。即得到5组模型的结果，取平均值作为最终结果。又称5折交叉验证。

超参数搜索-网格搜索
通常情况下，有很多参数是需要手动指定的（如k-近邻算法中的K值），这种叫超参数。但是手动过程繁杂，所以需要对模型预设几种超参数组合。每组超参数都采用交叉验证来进行评估。最后选出最优参数组合建立模型。

from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.preprocessing import StandardScaler
import pandas as pd
def knncls():
    """
    k-近邻预测用户签到位置
    :return: None
    """
    #读取数据
    data = pd.read_csv("./data/train.csv")
    # print(data.head(10))
    #处理数据
    #1 缩小数据 查询数据筛选
    data = data.query("x > 1.0 & x <1.25 & y >2.5 & y<2.75")
    #处理时间的数据
    time_value = pd.to_datetime(data['time'],unit='s')
    #把日期格式转换成字典格式
    time_value = pd.DatetimeIndex(time_value)
    #构造一些特征
    data['day'] = time_value.day
    data['hour'] = time_value.hour
    data['weekday'] = time_value.weekday
    #把时间戳特征删除
    data = data.drop(['time'],axis=1)

    #把签到数量少于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)]
    # print(data)
    #取出数据当中的特证值和目标值
    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)
    #特征工程(标准化)
    std = StandardScaler()
    #对测试集和训练集的特证值进行标准化
    x_train = std.fit_transform(x_train)
    x_test = std.fit_transform(x_test)
    #进行算法流程
    knn = KNeighborsClassifier()
    # knn.fit(x_train,y_train)
    # #得出预测结果
    # y_predict = knn.predict(x_test)
    # print("预测的目标签到位置为：",y_predict)
    # #得出准确率
    # print("预测的准确率",knn.score(x_test,y_test))
    #构造一些参数的值进行搜索
    param = {"n_neighbors":[3,5,10]}
    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_)
if __name__ == "__main__":
    knncls()

总结