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))
运行结果
