तंत्रिका नेटवर्क: सतत उत्पादन चर

Question

ठीक है के लिए अवग्रह सक्रियण समारोह, तो मैं Andrew Ng's machine learning course on coursera के बीच में हूँ और तंत्रिका नेटवर्क जो काम 4.

विशेष रूप से, तंत्रिका नेटवर्क के हिस्से के रूप में पूरा किया गया अनुकूल करने के लिए चाहते हैं

• अवग्रह सक्रियण समारोह: इस प्रकार है जो मैं सही ढंग से पूरा किया था काम के हिस्से के रूप था g(z) = 1/(1+e^(-z))
• 10 उत्पादन इकाइयों, जिनमें से प्रत्येक ले सकता है 0 या 1
• 1 हाय dden परत
• बैक प्रचार विधि लागत समारोह को कम से कम करने के लिए इस्तेमाल
• लागत समारोह:

जहां L=number of layers, s_l = number of units in layer l, m = number of training examples, K = number of output units

अब मैं व्यायाम समायोजित करना चाहते हैं ताकि एक निरंतर आउटपुट इकाई हो जो [0,1] के बीच कोई मूल्य लेती है और मैं काम करने की कोशिश कर रहा हूं कि क्या बदलने की जरूरत है, इसलिए f ar मैं

• मेरे अपने, यानी, ऐसी है कि उत्पादन निरंतर चर 0 और
• के बीच 1 उत्पादन इकाइयों की संख्या के लिए संदर्भ अपडेट किया गया
• पीठ में अपडेट किया गया लागत समारोह है साथ डेटा जगह ले ली है -प्रोपैगेशन एल्गोरिदम: जहां a_3 आगे प्रसार से निर्धारित आउटपुट इकाई का मान है।

मुझे यकीन है कि कुछ और बदलना चाहिए क्योंकि ढाल जांच विधि बैक-प्रोपेगेशन द्वारा निर्धारित ढाल को दिखाती है और संख्यात्मक अनुमान से अब मेल नहीं खाता है। मैंने सिग्मोइड ढाल नहीं बदला; यह f(z)*(1-f(z)) पर छोड़ा गया है जहां f(z) सिग्मोइड फ़ंक्शन 1/(1+e^(-z))) है और न ही मैंने व्युत्पन्न सूत्र के संख्यात्मक अनुमान को अद्यतन किया है; बस (J(theta+e) - J(theta-e))/(2e)।

क्या कोई अन्य सलाह दे सकता है कि अन्य कदमों की आवश्यकता होगी?

मैटलैब में कोडित इस प्रकार है:

% FORWARD PROPAGATION 
% input layer 
a1 = [ones(m,1),X]; 
% hidden layer 
z2 = a1*Theta1'; 
a2 = sigmoid(z2); 
a2 = [ones(m,1),a2]; 
% output layer 
z3 = a2*Theta2'; 
a3 = sigmoid(z3); 

% BACKWARD PROPAGATION 
delta3 = a3 - y; 
delta2 = delta3*Theta2(:,2:end).*sigmoidGradient(z2); 
Theta1_grad = (delta2'*a1)/m; 
Theta2_grad = (delta3'*a2)/m; 

% COST FUNCTION 
J = 1/(2 * m) * sum((a3-y).^2); 

% Implement regularization with the cost function and gradients. 
Theta1_grad(:,2:end) = Theta1_grad(:,2:end) + Theta1(:,2:end)*lambda/m; 
Theta2_grad(:,2:end) = Theta2_grad(:,2:end) + Theta2(:,2:end)*lambda/m; 
J = J + lambda/(2*m)*(sum(sum(Theta1(:,2:end).^2)) + sum(sum(Theta2(:,2:end).^2))); 

मैं के बाद से महसूस किया कि इस सवाल @Mikhail Erofeev on StackOverflow द्वारा पूछे जाने पर कि के समान है, लेकिन इस मामले में मैं 0 और और इसलिए बीच 1 का उपयोग निरंतर चर होना चाहते है एक सिग्मोइड समारोह।

Answer 1

पहले, अपने लागत समारोह होना चाहिए:

J = 1/m * sum((a3-y).^2); 

मुझे लगता है कि अपने Theta2_grad = (delta3'*a2)/m;delta3 = 1/2 * (a3 - y); करने के लिए बदल के बाद संख्यात्मक सन्निकटन मैच के लिए) की उम्मीद है।

अधिक जानकारी के लिए यह slide देखें।

संपादित करें: यदि हमारे कोड के बीच कुछ मामूली विसंगति है, तो मैंने आपके संदर्भ के लिए नीचे अपना कोड चिपकाया। कोड पहले से ही संख्यात्मक सन्निकटन समारोह checkNNGradients(lambda); के साथ तुलना में किया गया है, सापेक्ष अंतर कम से कम 1e-4

function [J grad] = nnCostFunctionRegression(nn_params, ... 
            input_layer_size, ... 
            hidden_layer_size, ... 
            num_labels, ... 
            X, y, lambda) 

Theta1 = reshape(nn_params(1:hidden_layer_size * (input_layer_size + 1)), ... 
       hidden_layer_size, (input_layer_size + 1)); 

Theta2 = reshape(nn_params((1 + (hidden_layer_size * (input_layer_size + 1))):end), ... 
       num_labels, (hidden_layer_size + 1)); 

m = size(X, 1); 
J = 0; 
Theta1_grad = zeros(size(Theta1)); 
Theta2_grad = zeros(size(Theta2)); 


X = [ones(m, 1) X]; 
z1 = sigmoid(X * Theta1'); 
zs = z1; 
z1 = [ones(m, 1) z1]; 
z2 = z1 * Theta2'; 
ht = sigmoid(z2); 


y_recode = zeros(length(y),num_labels); 
for i=1:length(y) 
    y_recode(i,y(i))=1; 
end  
y = y_recode; 


regularization=lambda/2/m*(sum(sum(Theta1(:,2:end).^2))+sum(sum(Theta2(:,2:end).^2))); 
J=1/(m)*sum(sum((ht - y).^2))+regularization; 
delta_3 = 1/2*(ht - y); 
delta_2 = delta_3 * Theta2(:,2:end) .* sigmoidGradient(X * Theta1'); 

delta_cap2 = delta_3' * z1; 
delta_cap1 = delta_2' * X; 

Theta1_grad = ((1/m) * delta_cap1)+ ((lambda/m) * (Theta1)); 
Theta2_grad = ((1/m) * delta_cap2)+ ((lambda/m) * (Theta2)); 

Theta1_grad(:,1) = Theta1_grad(:,1)-((lambda/m) * (Theta1(:,1))); 
Theta2_grad(:,1) = Theta2_grad(:,1)-((lambda/m) * (Theta2(:,1))); 


grad = [Theta1_grad(:) ; Theta2_grad(:)]; 

end 

Answer 2

(Dr.Andrew एनजी हालांकि द्वारा 1e-11 आवश्यकता नहीं मिलती है) आप का उपयोग नहीं करने की कोशिश सतत उत्पादन करना चाहते हैं है लक्षित मूल्य की गणना करते समय सिग्मोइड सक्रियण।

a1 = [ones(m, 1) X]; 
a2 = sigmoid(X * Theta1'); 
a2 = [ones(m, 1) z1]; 
a3 = z1 * Theta2'; 
ht = a3; 

nnCostFunction में इसका उपयोग करने से पहले इनपुट को सामान्यीकृत करें। बाकी सब कुछ वही रहता है।