zoukankan      html  css  js  c++  java
  • linear_classifier.py

      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)
  • 相关阅读:
    C#中泛型类,泛型方法,泛型约束实际应用
    Sql语法高级应用之七:如何在存储过程中使用事务
    再探motan
    终于好像懂motan了!!!
    java 反射详解
    设计模式之一工厂方法模式(Factory Method)
    记一次CPU占用率和load高的排查
    浅谈反射性能
    短网址服务(TinyURL)生成算法
    记一次阿里云中间件面试
  • 原文地址:https://www.cnblogs.com/wangxiu/p/5673717.html
Copyright © 2011-2022 走看看