cs231n作业1--KNN

最新推荐文章于 2023-01-28 03:08:20 发布
最新推荐文章于 2023-01-28 03:08:20 发布
阅读量915 收藏
点赞数 1
分类专栏： 机器学习 文章标签： 机器学习 KNN分类 cs231n作业1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swj110119/article/details/70788348
版权

KNN算法：
1、算法思想：kNN算法则是从训练集中找到和新数据最接近的k条记录，然后根据他们的主要分类来决定新数据的类别。该算法涉及3个主要因素：训练集、距离或相似的衡量、k的大小。
2、优缺点：需要存储训练集，把测试样本分别与训练集中每一个数据进行比较，存储与计算读很耗费资源。由于要存储大量训练样本集，所以就SVM、softmax分类器就利用权重来记录样本信息（此处用记录样本信息，是因为在可视化权重能够发现，可视化图像和样本很相像），然后进行分类。
3、代码实现：
k_nearest_neighbor.py

import numpy as np
#from past.builtins import xrange

class KNearestNeighbor(object):
  """ a kNN classifier with L2 distance """

  def __init__(self):
    pass

  def train(self, X, y):
    """
    Train the classifier. For k-nearest neighbors this is just 
    memorizing the training data.

    Inputs:
    - X: A numpy array of shape (num_train, D) containing the training data
      consisting of num_train samples each of dimension D.
    - y: A numpy array of shape (N,) containing the training labels, where
         y[i] is the label for X[i].
    """
    self.X_train = X
    self.y_train = y

  def predict(self, X, k=1, num_loops=0):
    """
    Predict labels for test data using this classifier.

    Inputs:
    - X: A numpy array of shape (num_test, D) containing test data consisting
         of num_test samples each of dimension D.
    - k: The number of nearest neighbors that vote for the predicted labels.
    - num_loops: Determines which implementation to use to compute distances
      between training points and testing points.

    Returns:
    - y: A numpy array of shape (num_test,) containing predicted labels for the
      test data, where y[i] is the predicted label for the test point X[i].  
    """
    if num_loops == 0:
      dists = self.compute_distances_no_loops(X)
    elif num_loops == 1:
      dists = self.compute_distances_one_loop(X)
    elif num_loops == 2:
      dists = self.compute_distances_two_loops(X)
    else:
      raise ValueError('Invalid value %d for num_loops' % num_loops)

    return self.predict_labels(dists, k=k)

  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.
    """
    num_test = X.shape[0]
    num_train = self.X_train.shape[0]
    dists = np.zeros((num_test, num_train))
    for i in xrange(num_test):
      for j in xrange(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.                                    #
        #####################################################################
        dists[i][j] = np.sqrt(np.sum((X[i,:]-self.X_train[j,:])**2))
        #####################################################################
        #                       END OF YOUR CODE                            #
        #####################################################################
    return dists

  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 xrange(num_test):
      #######################################################################
      # TODO:                                                               #
      # Compute the l2 distance between the ith test point and all training #
      # points, and store the result in dists[i, :].                        #
      #######################################################################
      dists[i,:] = np.sqrt(np.sum((X[i,:]-self.X_train)**2,axis=1))
      #######################################################################
      #                         END OF YOUR CODE                            #
      #######################################################################
    return dists

  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.                #
    #                                                                       #
    # HINT: Try to formulate the l2 distance using matrix multiplication    #
    #       and two broadcast sums.                                         #
    #########################################################################
    ##利用完全平方公式求得距离矩阵
    dists = np.multiply(np.dot(X,self.X_train.T),-2)
    sq1 = np.sum(np.square(X),axis=1,keepdims = True)
    sq2 = np.sum(np.square(self.X_train),axis=1)
    dists = np.add(dists,sq1)
    dists = np.add(dists,sq2)
    dists = np.sqrt(dists)
    #########################################################################
    #                         END OF YOUR CODE                              #
    #########################################################################
    return dists

  def predict_labels(self, dists, k=1):
    """
    Given a matrix of distances between test points and training points,
    predict a label for each test point.

    Inputs:
    - dists: A numpy array of shape (num_test, num_train) where dists[i, j]
      gives the distance betwen the ith test point and the jth training point.

    Returns:
    - y: A numpy array of shape (num_test,) containing predicted labels for the
      test data, where y[i] is the predicted label for the test point X[i].  
    """
    num_test = dists.shape[0]
    y_pred = np.zeros(num_test)
    for i in xrange(num_test):
      # A list of length k storing the labels of the k nearest neighbors to
      # the ith test point.
      closest_y = []
      #########################################################################
      # TODO:                                                                 #
      # Use the distance matrix to find the k nearest neighbors of the ith    #
      # testing point, and use self.y_train to find the labels of these       #
      # neighbors. Store these labels in closest_y.                           #
      # Hint: Look up the function numpy.argsort.                             #
      #########################################################################
      closest_y = self.y_train[np.argsort(dists[i,:])[:k]]
      #########################################################################
      # TODO:                                                                 #
      # Now that you have found the labels of the k nearest neighbors, you    #
      # need to find the most common label in the list closest_y of labels.   #
      # Store this label in y_pred[i]. Break ties by choosing the smaller     #
      # label.                                                                #
      #########################################################################
      y_pred[i] = np.argmax(np.bincount(closest_y))
      #########################################################################
      #                           END OF YOUR CODE                            # 
      #########################################################################

    return y_pred

knn.ipynb

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.                                #
################################################################################
X_train_folds = np.array_split(X_train,num_folds)
y_train_folds = np.array_split(y_train,num_folds)
################################################################################
#                                 END OF YOUR CODE                             #
################################################################################

# 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.                               #
################################################################################
for k in k_choices:
    k_to_accuracies[k] = []

for k in k_choices:
    print ('evaluating k=%d' %k)
    for j in range(num_folds):
        X_train_cv = np.vstack(X_train_folds[0:j]+X_train_folds[j+1:])
        X_test_cv = X_train_folds[j]

        #print len(y_train_folds), y_train_folds[0].shape

        y_train_cv = np.hstack(y_train_folds[0:j]+y_train_folds[j+1:])  #size:4000
        y_test_cv = y_train_folds[j]

        #print 'Training data shape: ', X_train_cv.shape
        #print 'Training labels shape: ', y_train_cv.shape
        #print 'Test data shape: ', X_test_cv.shape
        #print 'Test labels shape: ', y_test_cv.shape

        classifier.train(X_train_cv, y_train_cv)
        dists_cv = classifier.compute_distances_no_loops(X_test_cv)
        #print 'predicting now'
        y_test_pred = classifier.predict_labels(dists_cv, k)
        num_correct = np.sum(y_test_pred == y_test_cv)
        accuracy = float(num_correct) / y_test_cv.shape[0]

        k_to_accuracies[k].append(accuracy)
################################################################################
#                                 END OF YOUR CODE                             #
################################################################################

# 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))
Sun-Flower
关注
专栏目录
CS231n knn.ipynb作业
qq_38816993的博客
03-01 593
CS231n assignment1 KNN分类器 第一个作业的第一个问题，写KNN分类器，KNN的原理本身描述起来还是比较简单 这里再啰嗦两句，对KNN分类器的一些描述 KNN算法，只找最相近的那1个图片的标签，我们找最相似的k个图片的标签，然后让他们针对测试图片进行投票，最后把票数最高的标签作为对测试图片的预测。所以当k=1的时候，k-Nearest Neighbor分类器就是Near...
cs231n 作业一 knn
zhanliangliang33的博客
09-05 751
其只找最相近的那1个图片的标签，我们找最相似的k个图片的标签，然后让他们针对测试图片进行投票，最后把票数最高的标签作为对测试图片的预测。一：计算第 i 个测试点到第 j 个训练点的 l2 距离，并将结果存储在 dists[i, j] 中。X[a:b, :]---->从第0列开始到最后一列结束，取矩阵X的第 a 行到第 b 行的元素。X[i, :]---->从第0列开始到最后一列结束，取矩阵X的第 i 行的元素。：计算向量间的距离有很多种方法，另一个常用的方法是。函数，它的作用是预测输入的新数据的分类标签。
cs231n作业一 knn
qq_42186444的博客
08-28 3579
cs231——knn作业 cs231——knn作业cs231——knn作业1.基础概念1.1 self.X_train1.2 y_train1.3 X2.作业一——两层循环实现3作业二——实现knn投票机制4作业三——使用一层循环实现5作业四——不用循环6作业五--交叉验证 1.基础概念 1.1 self.X_train 这是训练集，是由n*d的二位向量组成，表示由n个样本，每一个样本有d个特征值，就是把图片拉直了 1.2 y_train 这是训练集的标识，由数值组成，是n*1组成的，范围在0-9之间
CS231N作业1KNN
最新发布
weixin_40473318的博客
01-28 197
CS231N作业1KNN
CS231n的第一次作业之KNN
无
05-08 378
作业一 作业内容：实现k-NN，SVM分类器，Softmax分类器和两层神经网络，实践一个简单的图像分类流程。 1. KNN分类器 KNN介绍： KNN分类器其只找最相近的那1个图片的标签，我们找最相似的k个图片的标签，然后让他们针对测试图片进行投票，最后把票数最高的标签作为对测试图片的预测。所以当k=1的时候，k-Nearest Neighbor分类器就是Nearest Neighbor分类器。...
CS231n课程作业(一) kNN classifier
LeeWanzhi的博客
01-04 1120
之前就写过一个简单的kNN分类器：机器学习之kNN算法，kNN的理论非常通俗易懂，有兴趣的可以参考。 cs231n是针对图像的，本次作业内容是对图像进行分类。 分类的标准就是待分类图像与训练集图像的L2距离。 (PS：样本集是32x32x3的图像，所以分类前需要对待分类图像进行resize。但其实没有人用kNN进行图像识别，所以不用care，hahaha) 源代码见GitHub：CS231
cs231n-Assignment-1 python.
12-06
【标题】"cs231n-Assignment-1 python." 是斯坦福大学计算机视觉课程CS231n的作业一，使用Python3.6语言编写。这个作业涉及到的基础知识点主要涵盖了机器学习，特别是监督学习中的分类算法，如K近邻（KNN）、支持...
cs231n-assignment1-knn
coder
03-18 379
之前准备把所有的问题都写在一个博客里面，我发现实在太长了，所以就把作业一的问题都分开了！ part0：环境的安装和配置 part1：KNN， part2：SVM part3：softmax part4：two_layer_net part5:feature KNN 现在就part1进行解释与说明： 一、建议写之前先阅读下面的材料：http://cs231n.git
cs231n作业记录(答案)-ASS1(KNN)
一个脱离了高级趣味的人
09-24 1228
cs231n A1
CS231N-2017课程作业（assignment 1）之KNN
Snowy_susu的博客
08-16 1933
Cs231n-2017课程作业（assignment 1）之KNN KNN算法理解：（百度百科）   KNN也即k-Nearest Neighbor,K（最）近邻分类算法，即是给定一个训练数据集，对新的输入实例，在训练数据集中找到与该实例最邻近的K个实例（也即是K个邻居，可根据一定的距离计算公式寻找邻居，如曼哈顿距离，欧式距离等）， 这K个实例的多数属于某个类，就把该输入实例分类到这个类中。 ...
CS231N第一课KNN部分作业实现
12-31
这个是斯坦福cs231n课程的课程作业，在做这个课程作业的过程中， 遇到了各种问题，通过查阅资料加以解决，加深了对课程内容的理解， 以及熟悉了相应的python 代码实现
cs231n李飞飞课程作业一题目和答案
04-15
斯坦福大学李飞飞计算机视觉教程，cs231n课程2017年的作业一的代码题目和答案，答案为自己实现，自己实际验证过，都能够通过，所用环境为windows Pycharm和Pycharm中的Jumpyter Notebook。
CS231n深度学习课程作业1实现
11-20
CS231n深度学习课程作业1实现，实现完整的KNN、SVM、softmax、二层神经网络的作业。
cs231n作业1——knn
qq_46132949的博客
08-15 561
导入数据 import random import numpy as np from cs231n.data_utils import load_CIFAR10 import matplotlib.pyplot as plt # This is a bit of magic to make matplotlib figures appear inline in the notebook # rather than in a new window. %matplotlib inline plt.rcPar
cs231n knn
panxiaoxie的博客
11-01 373
k近邻（KNN）KNN分类器分为两个阶段： 在训练阶段，分类器获取训练数据，并记住它; 在测试阶段，knn分类器计算每一张测试集的图片与训练集中所有图片的距离，并导出k个最近的训练样本的类标签; 对k进行交叉验证 # 获取数据 from six.moves import cPickle as pickle import os import numpy as npdef load_CIFAR_batc
CS231N作业1 详细实录（1）：环境准备+Knn
diaolvshe1971的博客
08-01 477
一、准备工作 安装Ipython Notebook[4] 设置远程访问服务器上Ipython[2,5],我直接用的[5]中的方法，可以直接在本地浏览器上使用服务器上的notebook。 在工作目录下输入命令jupyter notebook --ip 0.0.0.0 会输出一个同token,在浏览器上输入服务器ip和token组成的URL，例如：http://192.1...
CS231n作业（一）KNN分类
wjp_ctt的博客
09-24 357
作业说明 学习ML和DL很关键的两点在于对最基本的算法的理解，以及通过编程将算法复现的能力。做好这两点，才有实现更加复杂算法与工作的可能。否则，只会调包，跑跑开源代码，永远是重复别人的工作，没有自己的理解，也就无法将算法应用到实际任务中来。 还好有cs231n这门课程，以DL在计算机视觉中的应用为切入点，讲解了如KNN分类、线性判别函数、神经网络等基本的方法。而且配套的作业的要求是不可以调包，...
cs231n作业1_KNN
jiruijing123的博客
12-07 664
0.使用之前请确保浏览器联网，且可用内存较大，可以避免不必要的麻烦 1.载入数据集 cifar10 数据集位置：http://www.cs.toronto.edu/~kriz/cifar.html 载入代码： 输出相应的训练集和测试集数据 Xtr, Ytr, Xte, Ytedef load_CIFAR_batch(filename): """ load single batch of
CS231n: KNN
shuuu的博客
07-30 161
最近邻算法 import numpy as np class NearestNeighbor(object): def __init__(self): pass def train(self, X, y): """ X is N x D where each row is an example. Y is 1-dimension of size N """ # the nearest neighbor classifier simply remembers all the.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值