CS231N作业1KNN

对于每一张测试图像，kNN把它与训练集中的每一张图像计算距离，找出距离最近 的ｋ张图像．这ｋ张图像里，占多数的标签类别，就是测试图像的类别。

1.补充k_nearest_neighbor.py中compute_distances_two_loops 方法
使用L2距离。

#两层循环
dists[i,j]=np.sqrt(np.sum(np.square(X[i]-self.X_train[j])))

2.实现k_nearest_neighbor.py中 predict_labels方法

  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 range(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.                             #
      #########################################################################
      #取前k个最近邻
      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.                                                                #
      #########################################################################
      #k个近邻中次数最多的标签
      y_pred[i]=np.argmax(np.bincount(closest_y))
      #########################################################################
      #                           END OF YOUR CODE                            # 
      #########################################################################

    return y_pred

3.补充k_nearest_neighbor.py中compute_distances_one_loop 方法

dists[i]=np.sqrt(np.sum(np.square(self.X_train-X[i]),axis=1))

4.补充k_nearest_neighbor.py中compute_distances_no_loops 方法

  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

5.Cross-validation

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 i in range(num_folds):
        X_train_temp=np.vstack(X_train_folds[: i]+X_train_folds[i+1:])
        y_train_temp=np.hstack(y_train_folds[:i]+y_train_folds[i+1:])
        X_test_temp=X_train_folds[i]
        y_test_temp=y_train_folds[i]
        classifier=KNearestNeighbor()
        classifier.train(X_train_temp,y_train_temp)
        dists=classifier.compute_distances_no_loops(X_test_temp)
        y_pred=classifier.predict_labels(dists,k)
        num_correct=np.sum(y_pred==y_test_temp)
        accuracy=float(num_correct)/X_test_temp.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))

运行结果