2017-01-15 7 views
10

मैं स्टैनफोर्ड सीएस 231 के लिए कुछ वीडियो देख रहा हूं: दृश्य पहचान के लिए कनवॉल्यूशनल न्यूरल नेटवर्क, लेकिन यह समझ में नहीं आता कि numpy का उपयोग करके सॉफ्टमैक्स हानि फ़ंक्शन के लिए विश्लेषणात्मक ढाल की गणना कैसे करें।CS231n: सॉफ़्टमैक्स हानि फ़ंक्शन के लिए ढाल की गणना कैसे करें?

enter image description here

अजगर कार्यान्वयन के लिए ऊपर है::

this stackexchange जवाब से, softmax ढाल के रूप में गणना की जाती है

num_classes = W.shape[0] 
num_train = X.shape[1] 
for i in range(num_train): 
    for j in range(num_classes): 
    p = np.exp(f_i[j])/sum_i 
    dW[j, :] += (p-(j == y[i])) * X[:, i] 

किसी को कैसे ऊपर टुकड़ा काम समझा सकते हैं? सॉफ्टमैक्स के लिए विस्तृत कार्यान्वयन भी नीचे शामिल है।

def softmax_loss_naive(W, X, y, reg): 
    """ 
    Softmax loss function, naive implementation (with loops) 
    Inputs: 
    - W: C x D array of weights 
    - X: D x N array of data. Data are D-dimensional columns 
    - y: 1-dimensional array of length N with labels 0...K-1, for K classes 
    - reg: (float) regularization strength 
    Returns: 
    a tuple of: 
    - loss as single float 
    - gradient with respect to weights W, an array of same size as W 
    """ 
    # Initialize the loss and gradient to zero. 
    loss = 0.0 
    dW = np.zeros_like(W) 

    ############################################################################# 
    # Compute the softmax loss and its gradient using explicit loops.   # 
    # Store the loss in loss and the gradient in dW. If you are not careful  # 
    # here, it is easy to run into numeric instability. Don't forget the  # 
    # regularization!               # 
    ############################################################################# 

    # Get shapes 
    num_classes = W.shape[0] 
    num_train = X.shape[1] 

    for i in range(num_train): 
    # Compute vector of scores 
    f_i = W.dot(X[:, i]) # in R^{num_classes} 

    # Normalization trick to avoid numerical instability, per http://cs231n.github.io/linear-classify/#softmax 
    log_c = np.max(f_i) 
    f_i -= log_c 

    # Compute loss (and add to it, divided later) 
    # L_i = - f(x_i)_{y_i} + log \sum_j e^{f(x_i)_j} 
    sum_i = 0.0 
    for f_i_j in f_i: 
     sum_i += np.exp(f_i_j) 
    loss += -f_i[y[i]] + np.log(sum_i) 

    # Compute gradient 
    # dw_j = 1/num_train * \sum_i[x_i * (p(y_i = j)-Ind{y_i = j})] 
    # Here we are computing the contribution to the inner sum for a given i. 
    for j in range(num_classes): 
     p = np.exp(f_i[j])/sum_i 
     dW[j, :] += (p-(j == y[i])) * X[:, i] 

    # Compute average 
    loss /= num_train 
    dW /= num_train 

    # Regularization 
    loss += 0.5 * reg * np.sum(W * W) 
    dW += reg*W 

    return loss, dW 

उत्तर

8

सुनिश्चित नहीं हैं कि इस मदद करता है, तो है, लेकिन:

y_i वास्तव में सूचक समारोह y_i, के रूप में वर्णित here है। यह कोड में अभिव्यक्ति (j == y[i]) बनाता है।

इसके अलावा, वजन के संबंध में नुकसान की ढाल है:

y_i

जहां

y_i

जो कोड में X[:,i] का मूल है।

+0

इसे इंगित करने के लिए धन्यवाद। मैंने इसे पहले स्थान पर नहीं देखा। स्टैकएक्सचेंज पर सवाल में, वे संकेतक फ़ंक्शन के लिए yj को स्पष्ट रूप से इंगित करते हैं –

संबंधित मुद्दे