Perceptron en C échoue à s'entraîner

Question

Essayer d'implémenter un perceptron en C, ne peut pas l'entraîner. La sortie va toujours juste à zéro et je ne sais pas ce qui ne va pas. Bien que, je soupçonne que ce soit la fonction delta ou que je mette en œuvre incorrectement le perceptron.

Merci d'avance à tous ceux qui aident!

#include<stdio.h> 
#define arrayLength(x) (sizeof(x)/sizeof((x)[0])) 
typedef int bool; 
enum { false, true }; 

int main(){ 
    float trainInputs [2][2] = {{0.0f, 1.0f}, {0.0f, 0.0f}}; 
    float trainOutputs [2][1] = {{1.0f}, {0.0f}}; 
    int amontOfTrainData = 1; 

    float inputs [] = {0.0f, 1.1f}; 
    float outputs [] = {0.0f}; 
    float wights [(arrayLength(inputs) * arrayLength(outputs))] = {0.5f, 0.5f, 0.5f, 0.5f}; 
    float learningRate = 0.01f; 

    float delta(float actual, float want, float wight){ 
     float error = want - actual; 
     float out = error * learningRate * wight; 
     printf(":%.6f:\n", out); 
     return out; 
    } 

    // Run perceptron 

    void run(bool train){ 
     int outputInc = 0; 
     int wightInc = 0; 
     while(outputInc < arrayLength(outputs)){ 
      int inputInc = 0; 

      while(inputInc < arrayLength(inputs)){ 
       if(train){ 
        int x = 0; 
        while(x < amontOfTrainData){ 
         outputs[outputInc] = trainInputs[x][inputInc] * wights[wightInc]; 
         wights[wightInc] = delta(outputs[outputInc], trainOutputs[x][outputInc], wights[wightInc]); 
         x++; 
        } 
       }else{ 
        outputs[outputInc] = inputs[inputInc] * wights[wightInc]; 
       } 
       inputInc++; 
       wightInc++; 
      } 
      //printf("out[%i]: %.5f\n", outputInc, outputs[outputInc]); 
      outputInc++; 
     } 
    } 

    int b = 0; 
    while(b < 100){ 
     run(true); 
     b++; 
    } 
    printf("-----------[ 100 LOOPS DONE ]-----------\n"); 
    run(false); 

    return 0; 
} 

Answer 1

Comme error, learningRate et wight sont inférieurs à 0, l'expression error * learningRate * wight aura tendance à 0 aussi.

Le delta ne devrait pas être la nouvelle valeur pour le poids, il est la quantité de changement, donc au lieu de:

wights[wightInc] = delta(...); 

Essayez:

wights[wightInc] += delta(...); 

(Quelle source vous utilisez pour vous avez perceptron formules?)

Answer 2

J'ai appliqué tous les changements et ceci est le code de travail final. Merci à tous ceux qui m'ont aidé!

#include<stdio.h> 
#include<stdbool.h> 
#define arrayLength(x) (sizeof(x)/sizeof((x)[0])) 

float trainInputs [2][2] = {{0.0f, 1.0f}, {0.0f, 0.0f}}; 
float trainOutputs [2][1] = {{1.0f}, {0.0f}}; 
int amontOfTrainData = 1; 

float inputs [] = {1.0f, 1.0f}; 
float outputs [] = {0.0f}; 
float wights [(arrayLength(inputs) * arrayLength(outputs))] = {0.001f, 0.001f}; 
float learningRate = 0.1f; 


float delta(float actual, float want, float wight) 
{ 
    float error = want - actual; 
    float out = error * learningRate * wight; 
    return out; 
} 

void run(bool train) 
{ 
    int outputInc = 0; 
    int wightInc = 0; 
    while(outputInc < arrayLength(outputs)) 
    { 
     int inputInc = 0; 

     while(inputInc < arrayLength(inputs)) 
     { 
      if(train) 
      { 
       int x = 0; 
       while(x < amontOfTrainData) 
       { 
        outputs[outputInc] = trainInputs[x][inputInc] * wights[wightInc]; 
        wights[wightInc] += delta(outputs[outputInc], trainOutputs[x][outputInc], wights[wightInc]); 
        x++; 
       } 
      } 
      else 
      { 
       outputs[outputInc] = inputs[inputInc] * wights[wightInc]; 
      } 
      inputInc++; 
      wightInc++; 
     } 
     printf("out[%i]: %.5f\n", outputInc, outputs[outputInc]); 
     outputInc++; 
    } 
} 

int main() 
{ 
    // Run neural network 
    int b = 0; 
    int loops = 500; 
    while(b < loops) 
    { 
     run(true); 
     b++; 
    } 
    printf("-----------[ %i LOOPS DONE ]-----------\n", loops); 
    run(false); 

    return 0; 
}