CNN for Visual Recognition (assignment1_Q1)

参考：http://cs231n.github.io/assignment1/

Q1: k-Nearest Neighbor classifier (30 points)

 import numpy as np
 from matplotlib.cbook import todate

 class KNearestNeighbor:
   """ 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.

     Input:
     X - A num_train x dimension array where each row is a training point.
     y - A vector of length num_train, 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.

     Input:
     X - A num_test x dimension array where each row is a test point.
     k - The number of nearest neighbors that vote for predicted label
     num_loops - Determines which method to use to compute distances
                 between training points and test points.

     Output:
     y - A vector of length num_test, 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.

     Input:
     X - An num_test x dimension array where each row is a test point.

     Output:
     dists - A num_test x num_train array where dists[i, j] is the 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]               #
         #####################################################################
         dists[i,j] = np.sqrt(np.sum(np.square(X[i,:] - self.X_train[j,:])))
         #####################################################################
         #                       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(np.square(self.X_train - X[i,:]), 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.                                                                #
     # HINT: Try to formulate the l2 distance using matrix multiplication    #
     #       and two broadcast sums.                                         #
     #########################################################################
     tDot = np.multiply(np.dot(X, self.X_train.T), -2)
     t1 = np.sum(np.square(X), axis=1, keepdims=True)
     t2 = np.sum(np.square(self.X_train), axis=1)
     tDot = np.add(t1, tDot)
     tDot = np.add(tDot, t2)
     dists = np.sqrt(tDot)
     #########################################################################
     #                         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.

     Input:
     dists - A num_test x num_train array where dists[i, j] gives the distance
             between the ith test point and the jth training point.

     Output:
     y - A vector of length num_test where y[i] is the predicted label for the
         ith test point.
     """
     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    #
       # training 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.                             #
       #########################################################################
       # pass
       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

输出：

Two loop version took 55.817642 seconds
One loop version took 49.692089 seconds
No loop version took 1.267753 seconds