5

Tôi đang cố gắng giải quyết sự cố http://postimg.org/image/4bmfha8m7/Triển khai Mạng Lưới Thần kinh trong Matlab/Octave

Tôi gặp sự cố khi triển khai ma trận trọng lượng cho 36 đầu vào.

  1. Tôi có 3 lớp ẩn thần kinh.

  2. Tôi sử dụng thuật toán backpropagation để tìm hiểu.

Những gì tôi đã cố gắng cho đến nay là:

% Sigmoid Function Definition 
function [result] = sigmoid(x) 
    result = 1.0 ./ (1.0 + exp(-x)); 
end 

% Inputs 
input = [1 1 0 1 1 1 0 1 0 1 0 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0; 
     0 0 0 0 1 0 1 1 1 0 0 1 1 1 0 0 0 0 0 1 0 1 1 1 0 0 1 1 1 0 0 0 0 0 1; 
     0 0 0 0 0 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1 0 0 0 0 0; 
     0 0 0 0 1 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0 0 0 0 0 1]; 

% Desired outputs 
output = [1;1;1;1]; 

% Initializing the bias (Bias or threshold are the same thing, essential for learning, to translate the curve) 
% Also, the first column of the weight matrix is the weight of the bias values 
bias = [-1 -1 -1 -1]; 

% Learning coefficient 
coeff = 1.0; 

% Number of learning iterations 
iterations = 100; 
disp('No. Of Learning Iterations = '); 
disp(iterations); 

% Initial weights 
weights = ones(36,36); 

% Main Algorithm Begins 
for i = 1:iterations 
    out = zeros(4,1); 
    numIn = length (input(:,1)); 
    for j = 1:numIn 
     % 1st neuron in the hidden layer 
     H1 = bias(1,1)*weights(1,1) + input(j,1)*weights(1,2) + input(j,2)*weights(1,3) + input(j,3)*weights(1,4)+ input(j,4)*weights(1,5) + input(j,5)*weights(1,6) + input(j,6)*weights(1,7) 
      + input(j,7)*weights(1,8) + input(j,8)*weights(1,9) + input(j,9)*weights(1,10)+ input(j,10)*weights(1,11) + input(j,11)*weights(1,12) + input(j,12)*weights(1,13) 
      + input(j,13)*weights(1,14) + input(j,14)*weights(1,15) + input(j,15)*weights(1,16)+ input(j,16)*weights(1,17) + input(j,17)*weights(1,18) + input(j,18)*weights(1,19) 
      + input(j,19)*weights(1,20) + input(j,20)*weights(1,21) + input(j,21)*weights(1,22)+ input(j,22)*weights(1,23) + input(j,23)*weights(1,24) + input(j,24)*weights(1,25) 
      + input(j,25)*weights(1,26) + input(j,26)*weights(1,27) + input(j,27)*weights(1,28)+ input(j,28)*weights(1,29) + input(j,29)*weights(1,30) + input(j,30)*weights(1,31) 
      + input(j,31)*weights(1,32) + input(j,32)*weights(1,33) + input(j,33)*weights(1,34)+ input(j,34)*weights(1,35) + input(j,35)*weights(1,36) 

     x2(1) = sigmoid(H1); 

     % 2nd neuron in the hidden layer 
     H2 = bias(1,2)*weights(2,1) + input(j,1)*weights(2,2) + input(j,2)*weights(2,3) + input(j,3)*weights(2,4)+ input(j,4)*weights(2,5) + input(j,5)*weights(2,6) + input(j,6)*weights(2,7) 
      + input(j,7)*weights(2,8) + input(j,8)*weights(2,9) + input(j,9)*weights(2,10)+ input(j,10)*weights(2,11) + input(j,11)*weights(2,12) + input(j,12)*weights(2,13) 
      + input(j,13)*weights(2,14) + input(j,14)*weights(2,15) + input(j,15)*weights(2,16)+ input(j,16)*weights(2,17) + input(j,17)*weights(2,18) + input(j,18)*weights(2,19) 
      + input(j,19)*weights(2,20) + input(j,20)*weights(2,21) + input(j,21)*weights(2,22)+ input(j,22)*weights(2,23) + input(j,23)*weights(2,24) + input(j,24)*weights(2,25) 
      + input(j,25)*weights(2,26) + input(j,26)*weights(2,27) + input(j,27)*weights(2,28)+ input(j,28)*weights(2,29) + input(j,29)*weights(2,30) + input(j,30)*weights(2,31) 
      + input(j,31)*weights(2,32) + input(j,32)*weights(2,33) + input(j,33)*weights(2,34)+ input(j,34)*weights(2,35) + input(j,35)*weights(2,36) 

     x2(2) = sigmoid(H2); 

     % 3rd neuron in the hidden layer 
     H3 = bias(1,3)*weights(3,1) + input(j,1)*weights(3,2) + input(j,2)*weights(3,3) + input(j,3)*weights(3,4)+ input(j,4)*weights(3,5) + input(j,5)*weights(3,6) + input(j,6)*weights(3,7) 
      + input(j,7)*weights(3,8) + input(j,8)*weights(3,9) + input(j,9)*weights(3,10)+ input(j,10)*weights(3,11) + input(j,11)*weights(3,12) + input(j,12)*weights(3,13) 
      + input(j,13)*weights(3,14) + input(j,14)*weights(3,15) + input(j,15)*weights(3,16)+ input(j,16)*weights(3,17) + input(j,17)*weights(3,18) + input(j,18)*weights(3,19) 
      + input(j,19)*weights(3,20) + input(j,20)*weights(3,21) + input(j,21)*weights(3,22)+ input(j,22)*weights(3,23) + input(j,23)*weights(3,24) + input(j,24)*weights(3,25) 
      + input(j,25)*weights(3,26) + input(j,26)*weights(3,27) + input(j,27)*weights(3,28)+ input(j,28)*weights(3,29) + input(j,29)*weights(3,30) + input(j,30)*weights(3,31) 
      + input(j,31)*weights(3,32) + input(j,32)*weights(3,33) + input(j,33)*weights(3,34)+ input(j,34)*weights(3,35) + input(j,35)*weights(3,36) 

     x2(3) = sigmoid(H3); 

     % Output layer 
     x3_1 = bias(1,4)*weights(4,1) + x2(1)*weights(4,2) + x2(2)*weights(4,3) + x2(3)*weights(4,4); 
     out(j) = sigmoid(x3_1); 

     % Adjust delta values of weights 
     % For output layer: delta(wi) = xi*delta, 
     % delta = (1-actual output)*(desired output - actual output) 
     delta3_1 = out(j)*(1-out(j))*(output(j)-out(j)); 

     % Propagate the delta backwards into hidden layers 
     delta2_1 = x2(1)*(1-x2(1))*weights(3,2)*delta3_1; 
     delta2_2 = x2(2)*(1-x2(2))*weights(3,3)*delta3_1; 
     delta2_3 = x2(3)*(1-x2(3))*weights(3,4)*delta3_1; 

     % Add weight changes to original weights and then use the new weights. 
     % delta weight = coeff*x*delta 

     for k = 1:4 
     if k == 1 % Bias cases 
      weights(1,k) = weights(1,k) + coeff*bias(1,1)*delta2_1; 
      weights(2,k) = weights(2,k) + coeff*bias(1,2)*delta2_2; 
      weights(3,k) = weights(3,k) + coeff*bias(1,3)*delta2_3; 
      weights(4,k) = weights(4,k) + coeff*bias(1,4)*delta3_1; 
     else  % When k=2 or 3 input cases to neurons 
      weights(1,k) = weights(1,k) + coeff*input(j,1)*delta2_1; 
      weights(2,k) = weights(2,k) + coeff*input(j,2)*delta2_2; 
      weights(3,k) = weights(3,k) + coeff*input(j,3)*delta2_3; 
      weights(4,k) = weights(4,k) + coeff*x2(k-1)*delta3_1; 
     end 
     end 
    end 
end 

disp('For the Input'); 
disp(input); 
disp('Output Is'); 
disp(out); 
disp('Test Case: For the Input'); 
input = [1 1 0 1 1 1 0 1 0 1 0 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0 1 1 1 0 0 1 1 1 0]; 
+0

Sự cố với mã của bạn là gì? – Daniel

+0

@Daniel Nó không chính xác, tôi không thể có được backprop một cách chính xác. –

Trả lời

3

Đối với tôi vấn đề là việc ghi nhãn, tôi không thể nhìn thấy nơi nào bạn có đầu ra

Output (1,1 , 1,1)? Ý anh là gì. Có lẽ tôi nhớ cái gì đó nhưng đối với tôi có hai cách ghi nhãn một bản phân lớp nhiều lớp là gắn nhãn trực tiếp (0 cho A, 1 cho B, 3 cho C ...) và mở rộng nó sau hoặc trực tiếp mở rộng như A = 1, 0,0,0 = [1,0,0,0; 0,1,0,0; 0,0,1,0; 0,0,0,1]

Cách bạn thực hiện thao tác là rất dễ mắc lỗi, hãy xem các hoạt động ma trận matlab/octave, nó rất mạnh và có thể đơn giản hóa mọi thứ rất nhiều.

Các vấn đề liên quan