KNN算法的实现

import pandas as pddef maxminNormalization(data):
　　"""标准化
　　data = (data - data.mean) / data.std
　　:return data
　　"""
    mean_vals = data.mean(axis=0)
    std_val = data.std(axis=0)
    data = (data - mean_vals) / std_val
    return data


class KNN():
    def __init__(self,k=1):
        self.k = k

    def fit(self,x_train,y_train):
        self.x_train = x_train
        self.y_train = y_train

    def predict(self,x_test):
        dis_squar = (x_train - x_test)**2
        dis_squar_sum = dis_squar.sum(axis=1)
        distances = dis_squar_sum**0.5
        sortedIndics = distances.argsort()
        indices = sortedIndics[:self.k]
        labelCount = {}  # 存储每个label的出现次数
        for i in indices:
            label = self.y_train[i]
            labelCount[label] = labelCount.get(label, 0) + 1  # 次数加一
        # 排序方式一
        # sortedCount = list(zip(labelCount.values(),labelCount.keys()))
        # 对label出现的次数从大到小进行排序
        # sortedCount.sort()
        # return sortedCount[0][1]  # 返回出现次数最大的label
        # 排序方式二
        sortedCount = sorted(labelCount.items(), key=lambda k:k[1], reverse=True)
        return sortedCount[0][0]  # 返回出现次数最大的label


if __name__ == ‘__main__‘:
    # data = np.arange(24).reshape(4,6)
    train = pd.DataFrame({‘age‘:[23,33,45],‘income‘:[5000,12000,13000],‘work‘:[1,2,3]})
    test = pd.DataFrame({‘age‘:[22,30,40],‘income‘:[9000,13000,14000],‘work‘:[2,1,2]})
    x_train = maxminNormalization(train[[‘age‘,‘work‘]])
    y_train = train[‘income‘]
    x_test = maxminNormalization(test[[‘age‘,‘work‘]])
    y_test = test[‘income‘]
    knn = KNN()
    knn.fit(x_train,y_train)
    y_predict = knn.predict(x_test)
    print(y_predict)

from sklearn.datasets import load_iris,fetch_20newsgroups,load_boston
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
import pandas as pd
from sklearn.metrics import classification_report

def knncls():
    """
    k-近邻预测用户签到位置
    :return None
    """
    #读取数据
    data = pd.read_csv(‘./data/FBlocation/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‘)
    print(time_value)

    #把日期格式转化为字典参数
    time_value = pd.DatetimeIndex(time_value)

    #构造一些特征
    data.loc[:,‘day‘] = time_value.day
    data.loc[:,‘hour‘] = time_value.hour
    data.loc[:,‘weekday‘] = time_value.weekday

    #时间戳特征删除
    data.drop([‘time‘],axis=1)
    print(data)

    #把签到数量少于n个目标位置删除
    place_count = data.groupby(‘place_id‘).aggregate(np.count_nonzero)
    tf = place_count[place_count.row_id > 3].reset_index()
    data = data[data[‘place_id‘].isin(tf.place_id)]

    # 2.4 清理无效特征
    data = data.drop([‘row_id‘], axis=1)
    data = data.drop([‘accuracy‘], axis=1)

    #取出数据当中的特征值和目标值
    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()
    # # fit,perdict,score
    # 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=2)
    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


def knncls_iris():
    li = load_iris()

    x_train,x_test,y_train,y_test = train_test_split(li.data,li.target,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))
    print(‘每个分类的精确率和召回率是：‘,classification_report(y_test,y_predict,target_names=li.target_names))
    """
    #模型选择与调优
    knn = KNeighborsClassifier()
    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()
    knncls_iris()