机器学习基础-KNN和朴素贝叶斯

KNN算法

定义：如果一个样本在特征空间中的k个最相似(即特征空间中最邻近)的样本中的大多数属于某一个类别，则该样本也属于这个类别。KNN算法中计算的是欧式距离。
KNN算法API：sklearn.neighbors.KNeighborsClassifier(n_neighbors =5,algorithm = ‘auto’)

def knn():
    knn = KNeighborsClassifier(n_neighbors=6)
    data = pd.read_csv('./train.csv')
    #print(data.head())
    #缩小x，y数据量
    data = data.query('x>1&x<2.5&y>5&y<8')
    #print(data.head())
    #时间戳进行（年，月，日，周时分秒），当作新的特征
    #unit参数表示最小的单位s,ns
    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

    #将时间戳删掉 dataframe中axis =1 代表列
    data = data.drop(['time'],axis = 1)
    #print(data.head(10))

    #少于指定特征的人数进行删除
    place_count = data.groupby('place_id').count()
    #print(place_count.head(5))
    #reset_index()函数将原本的行索引place_id变成单独一列
    tf = place_count[place_count.x>3].reset_index()
    data = data[data['place_id'].isin(tf.place_id)]

    #将特征和目标值提取
    y = data['place_id']
    x = data.drop('place_id',axis = 1)
    x = x.drop('row_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)

    #准确率
    #score = knn.score(x_test,y_test)

    #print('预测签到位置：',y_predict)
    #print('准确率:',score)

    #网格搜索和交叉验证
    #构造网格搜索的参数值
    param = {"n_neighbors":[3,5,10]}

    #进行网格搜素
    gc = GridSearchCV(knn,param_grid= param,cv = 5)

    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

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

优点：简单，易于理解，易于实现，无需估计参数，无需训练。
缺点：懒惰算法，对测试样本分类时的计算量大，内存开销大，必须指定K值，K值选择不当则分类精度不能保证。

混淆矩阵：在分类任务下，预测结果(Predicted Condition)与正确标记(True Condition)之间存在四种不同的组合，构成混淆矩阵(适用于多分类)。
精确率Precision: 预测结果为正例样本中真实为正例的比例（查得准）
召回率Recall: 真实为正例的样本中预测结果为正例的比例（查的全，对正样本的区分能力）
F1-score: 反应了模型的稳健性。 F1 = 2precisionrecall/precision+recall
分类模型评估API：sklearn.metrics.classification_report(y_true,y_pred,target_names=None)
y_true:真实目标值，y_pred:估计器预测目标值
target_names:目标类别名称。
返回值：每个类别的精确率和召回率

交叉验证：为了让被评估的模型更加准确可信
超参数搜素——网格验证API：sklearn.model_selection.GridSearchCV(estimator,param_grid=None,cv=None)
estimator:估计器对象，param_grid估计器参数（dict),cv指定几折交叉验证，fit输入训练数据，score准确率。
结果分析：
best_score_:在交叉验证中测试的最好结果
best_estimator_:最好的参数模型
cv_results_:每次交叉验证后的测试集准确率结果和训练集准确率结果。

朴素贝叶斯

贝叶斯公式：P(C│W)=P(W│C)P©/P(W)
为防止某一个概率值为0，增加一个拉普拉斯系数：P(F1│C)=Ni+α/N+αm α为指定的系数一般为1，m为训练文档中统计出的特征词个数。
API：sklearn.naive_bayes.MultinomialNB
优点：朴素贝叶斯模型发源于古典数学理论，有稳定的分类效率。
对缺失数据不太敏感，算法也比较简单，常用于文本分类。
分类准确度高，速度快，不需要调参

缺点：当特征之间相互有联系时效果不佳

def NB():
    news = fetch_20newsgroups(subset='all')

    #进行数据分割
    x_train,x_test,y_train,y_test = train_test_split(news.data,news.target,test_size=0.25)

    #进行tfidf特征取样
    tf = TfidfVectorizer()

    #对每篇文章进行重要型统计
    x_train = tf.fit_transform(x_train)
    x_test = tf.transform(x_test)

    #进行朴素贝叶斯算法预测
    mlt = MultinomialNB(alpha=1)

    mlt.fit(x_train,y_train)

    #预测值
    y_predict = mlt.predict(x_test)

    #预测结果
    print("预测结果为：",y_predict)
    #预测准确lv
    print("预测准确率为：",mlt.score(x_test,y_test))
    #每个类别的准确率和召回率
    print("准确率和召回率：",classification_report(y_test,y_predict,target_names=news.target_names))