assignment1——KNN

news2024/11/13 23:22:38

KNN

整体思路

  1. 加载数据集CIFAR10并随机展示部分数据
  2. 构建KNearestNeighbor分类器，计算测试集每张图片的每个像素点与训练集每张图片的每个像素点的距离。
  3. 将图片转化为数组。在测试集使用compute_distances_one_loop，compute_distances_no_loops，compute_distances_two_loops三种方法计算距离矩阵和欧氏距离
  4. 交叉验证选择最优K值在验证集计算准确率

加载CIFAR10数据集

#下载并加载数据集
from cs231n.data_utils import load_CIFAR10
cifar10_dir = 'cs231n/datasets/cifar-10-batches-py'
#初始化
try:
   del X_train, y_train
   del X_test, y_test
   print('Clear previously loaded data.')
# 加载数据集
X_train, y_train, X_test, y_test = load_CIFAR10(cifar10_dir)
# 打印数据集大小和维度
print('Training data shape: ', X_train.shape)
print('Training labels shape: ', y_train.shape)
print('Test data shape: ', X_test.shape)
print('Test labels shape: ', y_test.shape)

展示图片

# 图片类别
classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck']
num_classes = len(classes)
# 每个类别展示七张照片
samples_per_class = 7
for y, cls in enumerate(classes):
    idxs = np.flatnonzero(y_train == y)
    idxs = np.random.choice(idxs, samples_per_class, replace=False)
    for i, idx in enumerate(idxs):
        plt_idx = i * num_classes + y + 1
        plt.subplot(samples_per_class, num_classes, plt_idx)
        plt.imshow(X_train[idx].astype('uint8'))
        plt.axis('off')
        if i == 0:
            plt.title(cls)
plt.show()

构建模型

欧式距离也称欧几里得距离，衡量的是多维空间中两个点之间的 绝对距离 。

在这里插入图片描述

compute_distances_two_loops

#距离计算如下：
import numpy as np
X= np.arange(20)
print(X)    #输出[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
X=np.reshape(X,(5,4))
print(X)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]]
'''
X_train = np.arange(16)
print(X_train)      #输出[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
X_train=np.reshape(X_train,(4,4))
print(X_train)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
'''

num_test = X.shape[0]
print(num_test)     #输出5
num_train = X_train.shape[0]
print(num_train)        #输出4
dists = np.zeros((num_test, num_train))
for i in range(num_test):
    for j in range(num_train):
        dists[i,j] = np.sqrt(np.sum((X[i]-X_train[j])*(X[i]-X_train[j])))
        '''
        [[ 0.  8. 16. 24.]
         [ 8.  0.  8. 16.]
         [16.  8.  0.  8.]
         [24. 16.  8.  0.]
         [32. 24. 16.  8.]]
        '''
print(dists)

所以在k_nearest_neighbor.py中完成compute_distances_two_loops函数如下：

    def compute_distances_two_loops(self, X):
        """
        Compute the distance between each test point in X and each training point
        in self.X_train using a nested loop over both the training data and the
        test data.

        Inputs:
        - X: A numpy array of shape (num_test, D) containing test data.

        Returns:
        - dists: A numpy array of shape (num_test, num_train) where dists[i, j]
          is the Euclidean distance between the ith test point and the jth training
          point.
        """
        #X.shape[0]读取数组行数
        num_test = X.shape[0]
        num_train = self.X_train.shape[0]
        dists = np.zeros((num_test, num_train))
        for i in range(num_test):
            for j in range(num_train):
                #####################################################################
                # TODO:                                                             #
                # Compute the l2 distance between the ith test point and the jth    #
                # training point, and store the result in dists[i, j]. You should   #
                # not use a loop over dimension, nor use np.linalg.norm().          #
                #####################################################################
                # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

                dists[i,j] = np.sqrt(np.sum((X[i]-self.X_train[j])*(X[i]-self.X_train[j])))

                # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        return dists

compute_distances_one_loops

计算如下

在这里插入图片描述

#距离计算如下
import numpy as np
X= np.arange(20)
print(X)    #输出[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
X=np.reshape(X,(5,4))
print(X)
X_train = np.arange(16)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]]
'''
print(X[0])
print(X_train)      #输出[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
X_train=np.reshape(X_train,(4,4))
print(X_train)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
'''
print(X_train-X[0])
'''
[[ 0  0  0  0]
 [ 4  4  4  4]
 [ 8  8  8  8]
 [12 12 12 12]]
'''
for i in range(num_test):
    #axis为1是压缩列,即将每一行的元素相加,将矩阵压缩为一
    print(np.sum((X_train-X[i])*(X_train-X[i]),axis=1))
    
'''
[  0  64 256 576]
[ 64   0  64 256]
[256  64   0  64]
[576 256  64   0]
[1024  576  256   64]
'''

所以在k_nearest_neighbor.py中完成compute_distances_one_loops函数如下：

    def compute_distances_one_loop(self, X):
        """
        Compute the distance between each test point in X and each training point
        in self.X_train using a single loop over the test data.

        Input / Output: Same as compute_distances_two_loops
        """
        num_test = X.shape[0]
        num_train = self.X_train.shape[0]
        dists = np.zeros((num_test, num_train))
        for i in range(num_test):
            #######################################################################
            # TODO:                                                               #
            # Compute the l2 distance between the ith test point and all training #
            # points, and store the result in dists[i, :].                        #
            # Do not use np.linalg.norm().                                        #
            #######################################################################
            # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

            dists[i]=np.sqrt(np.sum((X_train-X[i])*(X_train-X[i]),axis=1)).reshape(1,num_train)

            # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        return dists

compute_distances_no_loops

在这里插入图片描述
在这里插入图片描述

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传
（推导过程来自知乎）

#距离计算如下
import numpy as np
X= np.arange(20)
print(X)    #输出[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19]
X=np.reshape(X,(5,4))
print(X)
X_train = np.arange(16)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]
 [16 17 18 19]]
'''
print(X[0])
print(X_train)      #输出[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]
X_train=np.reshape(X_train,(4,4))
print(X_train)
'''
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]
 [12 13 14 15]]
'''
num_test = X.shape[0]
num_train = X_train.shape[0]

dists=np.sqrt(np.matmul(X**2, np.ones((4, num_train))) + np.transpose(np.matmul(X_train**2, np.ones((4, 5)))) - 2*np.matmul(X, np.transpose(X_train)))
print(dists)
'''
[[ 0.  8. 16. 24.]
 [ 8.  0.  8. 16.]
 [16.  8.  0.  8.]
 [24. 16.  8.  0.]
 [32. 24. 16.  8.]]
'''

所以在k_nearest_neighbor.py中完成compute_distances_no_1oops函数如下：

def compute_distances_no_loops(self, X):
        """
        Compute the distance between each test point in X and each training point
        in self.X_train using no explicit loops.

        Input / Output: Same as compute_distances_two_loops
        """
        num_test = X.shape[0]
        num_train = self.X_train.shape[0]
        dists = np.zeros((num_test, num_train))
        #########################################################################
        # TODO:                                                                 #
        # Compute the l2 distance between all test points and all training      #
        # points without using any explicit loops, and store the result in      #
        # dists.                                                                #
        #                                                                       #
        # You should implement this function using only basic array operations; #
        # in particular you should not use functions from scipy,                #
        # nor use np.linalg.norm().                                             #
        #                                                                       #
        # HINT: Try to formulate the l2 distance using matrix multiplication    #
        #       and two broadcast sums.                                         #
        #########################################################################
        # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

        dists= np.sqrt(np.matmul(X**2, np.ones((self.X_train.shape[1], num_train))) + np.transpose(np.matmul(self.X_train**2, np.ones((self.X_train.shape[1], num_test)))) - 2*np.matmul(X, np.transpose(self.X_train)))

        # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
        return dists

对比三种方法对欧氏距离的求解速度

def time_function(f, *args):
    """
    Call a function f with args and return the time (in seconds) that it took to execute.
    """
    import time
    tic = time.time()
    f(*args)
    toc = time.time()
    return toc - tic

two_loop_time = time_function(classifier.compute_distances_two_loops, X_test)
print('Two loop version took %f seconds' % two_loop_time)

one_loop_time = time_function(classifier.compute_distances_one_loop, X_test)
print('One loop version took %f seconds' % one_loop_time)

no_loop_time = time_function(classifier.compute_distances_no_loops, X_test)
print('No loop version took %f seconds' % no_loop_time)

k折交叉验证

num_folds = 5
k_choices = [1, 3, 5, 8, 10, 12, 15, 20, 50, 100]

X_train_folds = []
y_train_folds = []

################################################################################
# TODO:                                                                        #
# Split up the training data into folds. After splitting, X_train_folds and    #
# y_train_folds should each be lists of length num_folds, where                #
# y_train_folds[i] is the label vector for the points in X_train_folds[i].     #
# Hint: Look up the numpy array_split function.                                #
################################################################################
# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****
X_train_folds = np.array_split(X_train, num_folds)
y_train_folds = np.array_split(y_train, num_folds)
# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

# A dictionary holding the accuracies for different values of k that we find
# when running cross-validation. After running cross-validation,
# k_to_accuracies[k] should be a list of length num_folds giving the different
# accuracy values that we found when using that value of k.
k_to_accuracies = {}


################################################################################
# TODO:                                                                        #
# Perform k-fold cross validation to find the best value of k. For each        #
# possible value of k, run the k-nearest-neighbor algorithm num_folds times,   #
# where in each case you use all but one of the folds as training data and the #
# last fold as a validation set. Store the accuracies for all fold and all     #
# values of k in the k_to_accuracies dictionary.                               #
################################################################################
# *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

from sklearn import datasets
from sklearn.model_selection import KFold


kf = KFold(n_splits=5,shuffle=True)
for k in k_choices:
  acc = []
  #k_to_accuracies初始化
  k_to_accuracies[k]=np.zeros(num_folds)
  for train_index,test_index in kf.split(X_train):     # 将数据划分为k折
    train_data=X_train[train_index]   # 选取的训练集数据下标
    train_data_y=y_train[train_index]
    test=X_train[test_index]          # 选取的测试集数据下标
    test_y=y_train[test_index] 
    classifier=KNearestNeighbor()
    classifier.train(train_data,train_data_y)
    # 计算距离矩阵
    dists=classifier.compute_distances_no_loops(test)
    #预测
    ypred=classifier.predict_labels(dists,k=k)
    #计算准确率
    num_correct=np.mean(ypred==test_y)
    acc.append(num_correct)
  k_to_accuracies[k] = acc
# *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****

# Print out the computed accuracies
for k in sorted(k_to_accuracies):
    for accuracy in k_to_accuracies[k]:
        print('k = %d, accuracy = %f' % (k, accuracy))

然后选取最优k=8在测试集进行验证求准确率

best_k = 8

classifier = KNearestNeighbor()
classifier.train(X_train, y_train)
y_test_pred = classifier.predict(X_test, k=best_k)

# Compute and display the accuracy
num_correct = np.sum(y_test_pred == y_test)
accuracy = float(num_correct) / num_test
print('Got %d / %d correct => accuracy: %f' % (num_correct, num_test, accuracy))

主要解决问题

  • 三种方法计算欧氏距离（公式推导如上）

  • k折交叉验证数据不随机问题：

    shuffle：分割之前是否对数据进行洗牌（默认True）
    random_state：随机种子 当种子固定时，可以实现实验复现，方便调节参数
    只有当shuffle=True时，random_state才起作用。

    1. shuffle和random_state均不设置，即默认为shuffle=True，重新分配前会重新洗牌，则两次运行结果不同
    2. 设置random_state，那么默认shuffle=True，根据新的种子点，每次的运行结果是相同的
    3. 如果仅设置shuffle=True 那么每次划分之前都要洗牌 多次运行结果不同

num_test, accuracy))


# 主要解决问题

 - [ ] 三种方法计算欧氏距离（公式推导如上）

 

 - [ ] k折交叉验证数据不随机问题：

  shuffle：分割之前是否对数据进行洗牌（默认True）
  random_state：随机种子 当种子固定时，可以实现实验复现，方便调节参数
  只有当shuffle=True时，random_state才起作用。

  1. shuffle和random_state均不设置，即默认为shuffle=True，重新分配前会重新洗牌，则两次运行结果不同
  2. 设置random_state，那么默认shuffle=True，根据新的种子点，每次的运行结果是相同的
  3. 如果仅设置shuffle=True 那么每次划分之前都要洗牌 多次运行结果不同
（解决方案来自CSDN）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1398214.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

挑战杯参赛总结-时间序列预测

挑战杯参赛总结-时间序列预测

参赛任务： 目标：针对中国各个市区的不同年份二氧化碳排放量，预测未来年份的二氧化碳排放量。 不同与之前我学习过的波士顿房价预测机器学习-波士顿房价预测-CSDN博客 房价预测是通过学习与房价有关的很多特征，训练出一个模型来预…
阅读更多...
UV胶水粘接尼龙聚酰胺类聚合物PA有哪些优势呢？

UV胶水粘接尼龙聚酰胺类聚合物PA有哪些优势呢？

使用UV胶水（紫外线固化胶水）粘接尼龙聚酰胺类聚合物（PA）具有一些优势，这些优势包括： 1.快速固化： UV胶水是一种紫外线固化的胶水，它可以在短时间内迅速固化。这使得粘接过程非常快速…
阅读更多...
02-编程猜谜游戏

02-编程猜谜游戏

本章通过演示如何在实际程序中使用 Rust，你将了解 let 、 match 、方法、关联函数、外部crate等基础知识。 本章将实现一个经典的初学者编程问题：猜谜游戏。 工作原理如下：程序将随机生成一个介于 1 和 100 之间的整数。然后，程序…
阅读更多...
Pycharm详细安装 配置教程

Pycharm详细安装 配置教程

继上次安装完Anaconda之后，现在更新最新版本的pycharm的安装和使用教程~~~ Anaconda：是一个开源的Python发行版本，其中包含了conda、Python等180多个科学包及其依赖项。【Anaconda和Pycharm详细安装 配置教程_anconda安装时clear the packag…
阅读更多...
音频筑基：时延、帧长选取的考量

音频筑基：时延、帧长选取的考量

音频筑基：时延、帧长选取的考量 帧长与时延的关系帧长变化的影响参考资料 音频算法中，时延和音频帧长的选择通常是个需要平衡的参数，这里分析下背后的考量因素。 帧长与时延的关系 一般来说，帧长是音频算法端到端时延的子集&…
阅读更多...
【Linux】Linux 系统编程——touch 命令

【Linux】Linux 系统编程——touch 命令

文章目录 1.命令概述2.命令格式3.常用选项4.相关描述5.参考示例 1.命令概述 在**Linux 中，每个文件都与时间戳相关联，每个文件都存储了上次访问时间、**上次修改时间和上次更改时间的信息。因此，每当我们创建新文件并访问或修改现有文件时&a…
阅读更多...
设计模式篇章（4）——十一种行为型模式

设计模式篇章（4）——十一种行为型模式

这个设计模式主要思考的是如何分配对象的职责和将对象之间相互协作完成单个对象无法完成的任务，这个与结构型模式有点像，结构型可以理解为静态的组合，例如将不同的组件拼起来成为一个更大的组件；而行为型更是一种动态或者具有某个…
阅读更多...
【Python爬虫】项目案例讲解，一步步教你爬取淘宝商品数据！

【Python爬虫】项目案例讲解，一步步教你爬取淘宝商品数据！

前言 随着互联网时代的到来，人们更加倾向于互联网购物，某宝又是电商行业的巨头，在某宝平台中有很多商家数据，今天带大家使用pythonselenium工具获取这些公开的商家数据 环境介绍： python 3.6pycharmseleniumcsvtime…
阅读更多...
快来体验，免费一步步教你，零代码，无需服务器，一键部署你的大模型！

快来体验，免费一步步教你，零代码，无需服务器，一键部署你的大模型！

今天给大家分享一个项目，零代码、无需服务器，直接 一键部署 你的大模型项目。 废话不多说，项目就是它： 我们看到目前已支持： ChatGPT-Next-Web：一键免费部署你的私人 ChatGPT、谷歌Gemini 网页应用AutoGPT-…
阅读更多...
安防监控系统EasyCVR平台用户调用设备参数，信息不返回是什么原因？

安防监控系统EasyCVR平台用户调用设备参数，信息不返回是什么原因？

安防视频监控系统EasyCVR视频综合管理平台，采用了开放式的网络结构，平台能在复杂的网络环境中（专网、局域网、广域网、VPN、公网等）将前端海量的设备进行统一集中接入与视频汇聚管理，平台支持设备通过4G、5G、WIFI、有…
阅读更多...
Leetcoder Day9｜栈与队列part01

Leetcoder Day9｜栈与队列part01

语言：Java/C 目录 理论基础 C 栈 队列 Java 栈 队列 ​编辑 232.用栈实现队列 225. 用队列实现栈 Queue Deque 今日心得 理论基础 又是考研时数据结构里接触到的老朋友，栈是先进后出，队列是先进先出。 C 现在刷题除了思路还…
阅读更多...
【算法与数据结构】494、LeetCode目标和

【算法与数据结构】494、LeetCode目标和

文章目录 一、题目二、解法三、完整代码 所有的LeetCode题解索引，可以看这篇文章——【算法和数据结构】LeetCode题解。 一、题目 二、解法 思路分析：本题和这道题【算法与数据结构】1049、LeetCode 最后一块石头的重量 II类似，同样可以转换成…
阅读更多...
Windows系统使用手册

Windows系统使用手册

点击前往查看🔗我的博客文章目录 Windows系统使用手册 文章目录 Windows系统使用手册Windows10解决大小核调度问题Windows系统安装软件Windows系统Typora快捷键Windows系统压缩包方式安装redisWindows安装dockerWindows系统的docker设置阿里源Windows系统下使用doc…
阅读更多...
JAVA正则表达式第二个作用：爬取

JAVA正则表达式第二个作用：爬取

目录 本地数据爬取： 本地爬取练习： 网络爬取： ----- 以下为均本地数据爬取： 带条件爬取 贪婪爬取和非贪婪爬取： 例题 1：使获取 1 为不贪婪 *例题 2：使获取 0、1 都为不贪婪 之前介绍了正…
阅读更多...
mp4文件可以转成mp3音频吗

mp4文件可以转成mp3音频吗

现在是个非常流行刷短视频一个年代，刷短视似乎成了人们休闲娱乐的一种方式，在日常刷短视频过程中，肯定会有很多同学被短视频 bgm 神曲洗脑，比如很多被网红翻唱带火的歌曲，例如其中"不负人间”，就是其中…
阅读更多...
从零开始，自己搭建一个autonomous mobile robot做gazebo仿真（1）：mobile robot建模与添加差速控制器

从零开始，自己搭建一个autonomous mobile robot做gazebo仿真（1）：mobile robot建模与添加差速控制器

这样一个简单的mobile robot模型 首先写xacro文件&#xff0c;创建 link joint transmission <?xml version"1.0"?> <robot xmlns:xacro"http://www.ros.org/wiki/xacro" name"whill_modelc" ><xacro:property name"PI&q…
阅读更多...
Unity导出Android项目踩坑记录

Unity导出Android项目踩坑记录

导出的时候需要注意以下地方的配置&#xff1a; 1、buildSetting-> 设置ExportProject 2、buildsetting ->playerSetting ->设置IL2CPP 3、设置ndk edit->preferences->external tools->ndk 如果unity的ndk版本和android项目里的ndk版本不一致会报错&…
阅读更多...
尝试着在Stable Diffusion里边使用SadTalker进行数字人制作

尝试着在Stable Diffusion里边使用SadTalker进行数字人制作

首先需要标明的是&#xff0c;我这里是图片说话类型&#xff0c;而且是看了知识星球AI破局俱乐部大航海数字人手册进行操作的。写下这篇文章是防止我以后遗忘。 我使用的基础软件是Stable Diffusion&#xff0c;SadTalker是作为插件放进来的&#xff0c;需要注意的是这对自己的…
阅读更多...
Swagger + Knife4j 接口文档的整合

Swagger + Knife4j 接口文档的整合

Swagger 接口文档的整合&#xff1a; 引入依赖&#xff08;Swagger 或 Knife4j&#xff09;。自定义 Swagger 配置类。定义需要生成接口文档的代码位置&#xff08;Controller&#xff09;。注意&#xff1a;线上环境不要把接口暴露出去&#xff01;&#xff01;&#xff01;可…
阅读更多...
统计学-R语言-6.1

统计学-R语言-6.1

文章目录 前言参数估计的原理总体、样本和统计量点估计区间估计评价估计量的标准有效性 总体均值的区间估计一个总体均值的估计&#xff08;大样本&#xff09;一个总体均值的估计&#xff08;小样本估计&#xff09; 练习 前言 本篇文章将开始介绍参数估计的相关知识。 参数估…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023