《机器学习实战》笔记1 - KNN手写数字

曾经终败给现在 2022-02-09 08:17 271阅读 0赞

### 文章目录 ###

*   *  简述KNN
     *   *  KNN原理
         *  优点
         *  缺点
     *  涉及到的python知识点
     *   *  1、np.tile()广播
         *  2、os.listdir() 获取目录文件
         *  3、open(filename, 'r') 打开文件
         *  4、argsort()
         *  5、python字典添加元素的方法
         *  6、python字典按value排序
         *  7、混淆矩阵
         *  8、recall、precision、F-Measure
     *  完整KNN示例代码

## 简述KNN ##

### KNN原理 ###

通过计算特征向量之间距离的方法，找出距离待测试的向量最小的k个训练样本，统计他们的标签，标签数量最多的一个就是我们预测的结果。距离的计算可以自己定义，如欧式距离，曼哈顿距离哪个效果好就用哪个。k的选取也会对结果产生较大的影响，调整k值（所谓调参）以获得最好的效果。

### 优点 ###

1、算法简单，易于实现  
2、可以作分类，也可以做回归  
3、对异常值不敏感，准确度高，对数据没有假定

### 缺点 ###

1、时间复杂度、空间复杂度高。取决于“训练”的样本数量  
2、不像是所谓机器学习，因为它没有训练模型的过程。

--------------------

## 涉及到的python知识点 ##

### 1、np.tile()广播 ###

功能：在KNN中计算距离时，将当前特征向量广播到整个数据大小，以便利用python特性直接计算。  
参考 [https://blog.csdn.net/qq\_18433441/article/details/54897250][https_blog.csdn.net_qq_18433441_article_details_54897250]

### 2、os.listdir() 获取目录文件 ###

功能：获取某一目录下所有文件名，可用来遍历文件夹，读取数据

### 3、open(filename, ‘r’) 打开文件 ###

功能：可以打开txt文件，获取到字符串信息，用split()或replace()等方法对文本进行处理。

### 4、argsort() ###

功能：获取排序好的索引下标，可用来做递增或递减的部分遍历

### 5、python字典添加元素的方法 ###

`classCount[one_label] = classCount.get(one_label, 0) + 1`  
如果没有one\_label这个key，就置0，否则读取原来的value，然后+1.

### 6、python字典按value排序 ###

`sortedClassCount = sorted(classCount.items(), key = lambda x:x[1], reverse=True)`  
三个参数默认是迭代的对象、排序按哪个值排序，是否反转（默认为升序）  
按键排序也可以这样实现  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70]

### 7、混淆矩阵 ###

混淆矩阵是什么可以百度，它对分析数据的预测结果很有帮助。如图是一个手写数字识别的混淆矩阵，它把十个数字预测成了什么和他们实际是什么直观地展示了出来。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70 1]  
代码：利用sklearn封装的函数得出混淆矩阵，并用seaborn作图

# 绘制混淆矩阵
    def sklearn_confusion_matrix(ytest, ymodel):
        from sklearn.metrics import confusion_matrix
        import seaborn as sns
        import matplotlib.pyplot as plt
        
        mat = confusion_matrix(ytest, ymodel)
        print(mat)
        sns.heatmap(mat, square=True, annot=True, cbar=False)
        plt.xlabel('predicted value')
        plt.ylabel('true value')
    
    sklearn_confusion_matrix(test_labels, result)

### 8、recall、precision、F-Measure ###

这篇博客讲的非常好非常详细  
[https://www.cnblogs.com/Zhi-Z/p/8728168.html][https_www.cnblogs.com_Zhi-Z_p_8728168.html]

这些概念似乎是相对于二分类问题的，所以我们这个问题（手写数字识别）是无法得出这些统计学概念的，但不妨碍我们学习。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70 2]  
图片来源：[https://www.cnblogs.com/Zhi-Z/p/8728168.html][https_www.cnblogs.com_Zhi-Z_p_8728168.html]

一个代码示例

def get_precision_recall_f1(trues, predicts):
        TP = TN = FP = FN = 0
        precisioin = recall = f1 = 0
        for i in range(len(trues)):
            if trues[i] == 1 and predicts[i] == 1:
                TP += 1
            elif trues[i] == 0 and predicts[i] == 0:
                TN += 1
            elif trues[i] == 1 and predicts[i] == 0:
                FP += 1
            elif trues[i] == 0 and predicts[i] == 1:
                FN += 1
        precision = TP / (TP + FP)
        recall = TP / (TP + FN)
        f1 = 2*precision*recall / (precision + recall)
        return precision, recall, f1
    
    trues = [1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1]
    predicts = [1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1]
    sklearn_confusion_matrix(trues, predicts)
        
    precision, recall, f1 = get_precision_recall_f1(trues, predicts)
    print("precision = {}, recall = {}, f1 = {}".format(precision, recall, f1))

输出结果  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70 3]

--------------------

## 完整KNN示例代码 ##

**由于我是在jupyter notebook上写的代码，所以直接把它下载成py文件，看上去格式不怎么好。代码也无法直接运行，仅供参考。**

#!/usr/bin/env python
    # coding: utf-8
    # In[52]:
    
    
    import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    import os
    get_ipython().run_line_magic('matplotlib', 'inline')
    
    
    # In[53]:
    
    
    def getFileArray(filename):
        file_array = []
        labels = []
        train_files = os.listdir(filename)
        for each in train_files:
            labels.append(each[0])
            tmp_file = open(filename + '/' + each, 'r')
            contents = tmp_file.read().replace('\n', '')
            tmp = []
            for i in range(1024):
                tmp.append(int(contents[i]))
            file_array.append(tmp)
        return np.array(file_array), np.array(labels)
    
    
    # In[54]:
    
    
    digits_matrix, digit_labels = getFileArray('./digits/trainingDigits')
    test_x, test_labels = getFileArray('./digits/testDigits')
    
    
    # In[55]:
    
    
    def knn(xtest, data, label, k): # xtest为测试的特征向量，data、label为“训练”数据集，k为设定的阈值
    # print(xtest.shape)
    # print(label.shape)
        exp_xtest = np.tile(xtest, (len(label), 1)) - data
        sq_diff = exp_xtest**2
        sum_diff = sq_diff.sum(axis=1)
        distance = sum_diff**0.5
    # print(distance)
        sort_index = distance.argsort()
        classCount = { }
        for i in range(k):
            one_label = label[sort_index[i]]
            classCount[one_label] = classCount.get(one_label, 0) + 1
        sortedClassCount = sorted(classCount.items(), key = lambda x:x[1], reverse=True)
    # print(sortedClassCount)
        return sortedClassCount[0][0]
    
    
    # In[56]:
    
    
    result = []
    for i in range(len(test_x)):
        result.append(knn(test_x[i], digits_matrix, digit_labels, 3))
    
    
    # In[57]:
    
    
    print(test_labels)
    print(len(test_labels))
    print(len(result))
    
    
    # In[51]:
    
    
    # print(result)
    wrong = 0
    right = 0
    for i in range(len(result)):
        if result[i] != test_labels[i]:
            wrong += 1
        else:
            right += 1
    print("wrong = {} right = {}".format(wrong, right))
    print("accurate: {}".format(right / (wrong + right)))
    print("wrong rate: {}".format(wrong / (wrong + right)))
    
    
    # In[70]:
    
    
    # 绘制混淆矩阵
    def sklearn_confusion_matrix(ytest, ymodel):
        from sklearn.metrics import confusion_matrix
        import seaborn as sns
        import matplotlib.pyplot as plt
        
        mat = confusion_matrix(ytest, ymodel)
        print(mat)
        sns.heatmap(mat, square=True, annot=True, cbar=False)
        plt.xlabel('predicted value')
        plt.ylabel('true value')
    
    sklearn_confusion_matrix(test_labels, result)
    
    
    # In[68]:
    
    
    dic1 = { '1': 2, '3': 5, '0': -1}
    print(dic1.items())
    x = [0, 3, 1]
    y = lambda x:x[2]
    print(y(x))
    
    
    # In[76]:
    
    
    
    
    
    # In[92]:
    
    
    def get_precision_recall_f1(trues, predicts):
        TP = TN = FP = FN = 0
        precisioin = recall = f1 = 0
        for i in range(len(trues)):
            if trues[i] == 1 and predicts[i] == 1:
                TP += 1
            elif trues[i] == 0 and predicts[i] == 0:
                TN += 1
            elif trues[i] == 1 and predicts[i] == 0:
                FP += 1
            elif trues[i] == 0 and predicts[i] == 1:
                FN += 1
        precision = TP / (TP + FP)
        recall = TP / (TP + FN)
        f1 = 2*precision*recall / (precision + recall)
        return precision, recall, f1
    
    trues = [1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1]
    predicts = [1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1]
    sklearn_confusion_matrix(trues, predicts)
        
    precision, recall, f1 = get_precision_recall_f1(trues, predicts)
    print("precision = {}, recall = {}, f1 = {}".format(precision, recall, f1))

[https_blog.csdn.net_qq_18433441_article_details_54897250]: https://blog.csdn.net/qq_18433441/article/details/54897250
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70]: /images/20220209/ab6058602f9544e09f587ecf172b027f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20220209/59eb7a06fa794d68945d77406c3b5885.png
[https_www.cnblogs.com_Zhi-Z_p_8728168.html]: https://www.cnblogs.com/Zhi-Z/p/8728168.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70 2]: /images/20220209/6ad1874d40e34087b340209a0c4a41af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dqaDI2MjIwNzUxMjc_size_16_color_FFFFFF_t_70 3]: /images/20220209/55b9a49cd74d4bb382fb23236cc9b652.png