1 import numpy as np 2 from cs231n.classifiers.linear_svm import * 3 from cs231n.classifiers.softmax import * 4 5 class LinearClassifier(object): 6 7 def __init__(self): 8 self.W = None 9 10 def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100, 11 batch_size=200, verbose=False): 12 """ 13 Train this linear classifier using stochastic gradient descent. 14 15 Inputs: 16 - X: A numpy array of shape (N, D) containing training data; there are N 17 training samples each of dimension D. 18 - y: A numpy array of shape (N,) containing training labels; y[i] = c 19 means that X[i] has label 0 <= c < C for C classes. 20 - learning_rate: (float) learning rate for optimization. 21 - reg: (float) regularization strength. 22 - num_iters: (integer) number of steps to take when optimizing 23 - batch_size: (integer) number of training examples to use at each step. 24 - verbose: (boolean) If true, print progress during optimization. 25 26 Outputs: 27 A list containing the value of the loss function at each training iteration. 28 """ 29 num_train, dim = X.shape 30 num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes 31 if self.W is None: 32 # lazily initialize W 33 self.W = 0.001 * np.random.randn(dim, num_classes) 34 35 # Run stochastic gradient descent to optimize W 36 loss_history = [] 37 for it in xrange(num_iters): 38 X_batch = None 39 y_batch = None 40 41 ######################################################################### 42 # TODO: # 43 # Sample batch_size elements from the training data and their # 44 # corresponding labels to use in this round of gradient descent. # 45 # Store the data in X_batch and their corresponding labels in # 46 # y_batch; after sampling X_batch should have shape (dim, batch_size) # 47 # and y_batch should have shape (batch_size,) # 48 # # 49 # Hint: Use np.random.choice to generate indices. Sampling with # 50 # replacement is faster than sampling without replacement. # 51 ######################################################################### 52 # num_train = 49000 batch_size = 200 53 mask = np.random.choice(num_train, batch_size, replace=False) 54 X_batch = X[mask] 55 y_batch = y[mask] 56 ######################################################################### 57 # END OF YOUR CODE # 58 ######################################################################### 59 60 # evaluate loss and gradient 61 loss, grad = self.loss(X_batch, y_batch, reg) 62 loss_history.append(loss) 63 64 # perform parameter update 65 ######################################################################### 66 # TODO: # 67 # Update the weights using the gradient and the learning rate. # 68 ######################################################################### 69 self.W = self.W - learning_rate * grad 70 ######################################################################### 71 # END OF YOUR CODE # 72 ######################################################################### 73 74 if verbose and it % 100 == 0: 75 print 'iteration %d / %d: loss %f' % (it, num_iters, loss) 76 77 return loss_history 78 79 def predict(self, X): 80 """ 81 Use the trained weights of this linear classifier to predict labels for 82 data points. 83 84 Inputs: 85 - X: D x N array of training data. Each column is a D-dimensional point. 86 87 Returns: 88 - y_pred: Predicted labels for the data in X. y_pred is a 1-dimensional 89 array of length N, and each element is an integer giving the predicted 90 class. 91 """ 92 y_pred = np.zeros(X.shape[1]) 93 ########################################################################### 94 # TODO: # 95 # Implement this method. Store the predicted labels in y_pred. # 96 ########################################################################### 97 #49000*3073 * 3073 * 10 98 y_pred = np.argmax(np.dot(X,self.W), axis=1) 99 ########################################################################### 100 # END OF YOUR CODE # 101 ########################################################################### 102 return y_pred 103 104 def loss(self, X_batch, y_batch, reg): 105 """ 106 Compute the loss function and its derivative. 107 Subclasses will override this. 108 109 Inputs: 110 - X_batch: A numpy array of shape (N, D) containing a minibatch of N 111 data points; each point has dimension D. 112 - y_batch: A numpy array of shape (N,) containing labels for the minibatch. 113 - reg: (float) regularization strength. 114 115 Returns: A tuple containing: 116 - loss as a single float 117 - gradient with respect to self.W; an array of the same shape as W 118 """ 119 pass 120 121 122 class LinearSVM(LinearClassifier): 123 """ A subclass that uses the Multiclass SVM loss function """ 124 125 def loss(self, X_batch, y_batch, reg): 126 return svm_loss_vectorized(self.W, X_batch, y_batch, reg) 127 128 129 class Softmax(LinearClassifier): 130 """ A subclass that uses the Softmax + Cross-entropy loss function """ 131 132 def loss(self, X_batch, y_batch, reg): 133 return softmax_loss_vectorized(self.W, X_batch, y_batch, reg)