जावा में एक्सओआर न्यूरल नेटवर्क

Question

मैं जावा में एक्सओआर फ़ंक्शन के लिए बैक प्रोपेगेशन के साथ पांच न्यूरॉन तंत्रिका नेटवर्क को कार्यान्वित करने और प्रशिक्षित करने की कोशिश कर रहा हूं। मेरे कोड (यह उग्रता के लिए क्षमा करें):

public class XORBackProp { 

private static final int MAX_EPOCHS = 500; 

//weights 
private static double w13, w23, w14, w24, w35, w45; 
private static double theta3, theta4, theta5; 
//neuron outputs 
private static double gamma3, gamma4, gamma5; 
//neuron error gradients 
private static double delta3, delta4, delta5; 
//weight corrections 
private static double dw13, dw14, dw23, dw24, dw35, dw45, dt3, dt4, dt5; 
//learning rate 
private static double alpha = 0.1; 
private static double error; 
private static double sumSqrError; 
private static int epochs = 0; 
private static boolean loop = true; 

private static double sigmoid(double exponent) 
{ 
    return (1.0/(1 + Math.pow(Math.E, (-1) * exponent))); 
} 

private static void activateNeuron(int x1, int x2, int gd5) 
{ 
    gamma3 = sigmoid(x1*w13 + x2*w23 - theta3); 
    gamma4 = sigmoid(x1*w14 + x2*w24 - theta4); 
    gamma5 = sigmoid(gamma3*w35 + gamma4*w45 - theta5); 

    error = gd5 - gamma5; 

    weightTraining(x1, x2); 
} 

private static void weightTraining(int x1, int x2) 
{ 
    delta5 = gamma5 * (1 - gamma5) * error; 
    dw35 = alpha * gamma3 * delta5; 
    dw45 = alpha * gamma4 * delta5; 
    dt5 = alpha * (-1) * delta5; 

    delta3 = gamma3 * (1 - gamma3) * delta5 * w35; 
    delta4 = gamma4 * (1 - gamma4) * delta5 * w45; 

    dw13 = alpha * x1 * delta3; 
    dw23 = alpha * x2 * delta3; 
    dt3 = alpha * (-1) * delta3; 
    dw14 = alpha * x1 * delta4; 
    dw24 = alpha * x2 * delta4; 
    dt4 = alpha * (-1) * delta4; 

    w13 = w13 + dw13; 
    w14 = w14 + dw14; 
    w23 = w23 + dw23; 
    w24 = w24 + dw24; 
    w35 = w35 + dw35; 
    w45 = w45 + dw45; 
    theta3 = theta3 + dt3; 
    theta4 = theta4 + dt4; 
    theta5 = theta5 + dt5; 
} 

public static void main(String[] args) 
{ 

    w13 = 0.5; 
    w14 = 0.9; 
    w23 = 0.4; 
    w24 = 1.0; 
    w35 = -1.2; 
    w45 = 1.1; 
    theta3 = 0.8; 
    theta4 = -0.1; 
    theta5 = 0.3; 

    System.out.println("XOR Neural Network"); 

    while(loop) 
    { 
     activateNeuron(1,1,0); 
     sumSqrError = error * error; 
     activateNeuron(0,1,1); 
     sumSqrError += error * error; 
     activateNeuron(1,0,1); 
     sumSqrError += error * error; 
     activateNeuron(0,0,0); 
     sumSqrError += error * error; 

     epochs++; 

     if(epochs >= MAX_EPOCHS) 
     { 
      System.out.println("Learning will take more than " + MAX_EPOCHS + " epochs, so program has terminated."); 
      System.exit(0); 
     } 

     System.out.println(epochs + " " + sumSqrError); 

     if (sumSqrError < 0.001) 
     { 
      loop = false; 
     } 
    } 
} 
} 

यह किसी भी मदद करता है, यहाँ एक diagram of the network अगर।

सभी वजन और सीखने की दर के शुरुआती मूल्य सीधे मेरी पाठ्यपुस्तक में एक उदाहरण से लिया जाता है। लक्ष्य नेटवर्क को प्रशिक्षित करना है जब तक कि स्क्वायर त्रुटियों का योग .001 से कम न हो। पाठ्यपुस्तक पहले पुनरावृत्ति (1,1,0) के बाद सभी वजनों के मूल्य भी देता है और मैंने अपने कोड का परीक्षण किया है और इसके परिणाम पाठ्यपुस्तक के परिणामों से पूरी तरह मेल खाते हैं। लेकिन पुस्तक के मुताबिक, इसे केवल 224 युगों को अभिसरण करने के लिए लेना चाहिए। लेकिन जब मैं इसे चलाता हूं, तो यह हमेशा MAX_EPOCHS तक पहुंच जाता है जब तक कि यह कई हज़ार तक सेट न हो जाए। मैं क्या गलत कर रहा हूं?

Answer 1

instace के लिए सक्रियण चरण में gamma3, gamma4, gamma5 के पूर्णांकन जबकि का प्रयास करें:

if (gamma3 > 0.7) gamma3 = 1; 
if (gamma3 < 0.3) gamma3 = 0; 

और वृद्धि छोटा सा learnig चर (अल्फा)

alpha = 0.2; 

सीखने 466 अवधियों में समाप्त होता है।

बेशक

यू बड़ा पूर्णांकन और उच्च अल्फा यू सेट यू से 224.

Answer 2

//Add this in the constants declaration section. 
    private static double alpha = 3.8, g34 = 0.13, g5 = 0.21; 

    // Add this in activate neuron 
    gamma3 = sigmoid(x1 * w13 + x2 * w23 - theta3); 
    gamma4 = sigmoid(x1 * w14 + x2 * w24 - theta4);   
    if (gamma3 > 1 - g34) {gamma3 = 1;} 
    if (gamma3 < g34) {gamma3 = 0;} 
    if (gamma4 > 1- g34) {gamma4 = 1;} 
    if (gamma4 < g34) {gamma4 = 0;} 
    gamma5 = sigmoid(gamma3 * w35 + gamma4 * w45 - theta5); 
    if (gamma5 > 1 - g5) {gamma5 = 1;} 
    if (gamma5 < g5) {gamma5 = 0;} 

और भी बेहतर परिणाम प्राप्त कर सकते हैं एएनएन 66 पुनरावृत्तियों में सीखना चाहिए, लेकिन विचलन के कगार पर है अगर।

Answer 3

इस नेटवर्क का पूरा बिंदु यह दिखाने के लिए है कि ग्रुपिंग "top = yes, bottom = no" पर आधारित नहीं है, बल्कि एक केंद्रीय रेखा है (अंक के माध्यम से जा रहा है (0,1) और (1,0) इस मामले में) और यदि मान लाइन के नजदीक है, तो उत्तर "हां" है, जबकि यदि यह दूर है, तो उत्तर "नहीं" है। आप इस प्रणाली को केवल एक परत से क्लस्टर नहीं कर सकते हैं। हालांकि दो परतें पर्याप्त हैं।