Thread: My Perceptron finished! (code included)

Hi, after lots of programing(for me ) and thinking, my perceptron is finally done...
It has to programs - one for learning, and Second is the perceptron.
First one adjusts the weights, and then saves them to per.dat file.
Second just reads the file.
Really special thanks to: MK27, tabstop, MTK, King Mir and abachler. They have shown me much effort and free time...thanks...

Learning:

Code:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

float weight_x = 0.0f, weight_y = 0.0f, weight_z = 0.0f;
float threshold = 0.5f;
int successive_right = 0;
int total_go_round = 1;
const float learning_rate = 0.1f;
int input_x;
int input_y;
int input_z;
bool percept;
bool target(int x, int y, int z) { //što ucimo perceptron
    //x je bias, pa se ne ubraja
    return (!(y||z)); //funkcija koju ucimo perceptron

}

int educate() {
  
        input_x = 1; //bias, uvijek 1
        input_y = rand() % 2;
        input_z = rand() % 2;
        bool goal = target(input_x, input_y, input_z);
        percept = (weight_x*input_x+weight_y*input_y+weight_z*input_z > threshold);
        if (percept == goal) {
            successive_right++;
        } else {
            successive_right = 0;
            int sign = goal ? 1 : -1; //sign of (y-f(x))
            weight_x += learning_rate*sign*input_x;
            weight_y += learning_rate*sign*input_y;
            weight_z += learning_rate*sign*input_z;
        }
    printf("%d", percept);
    return;
}

int main(){
   printf("1\n");
   srand(time(NULL));
   total_go_round=1;
   while(total_go_round <= 575){
      educate();
      total_go_round++;FILE *g;
}
   printf("Perceptron: (%.2f, %.2f, %.2f, %.2f)\n", weight_x, weight_y, weight_z, threshold);
   input_x = 1;
   printf("input_y: ");
   scanf("%d", &input_y);
   printf("input_z: ");
   scanf("%d", &input_z);
   percept = (weight_x*input_x+weight_y*input_y+weight_z*input_z > threshold);
   printf("perceptron: ");
   printf("%d\n", percept);

FILE *g;
g = fopen("per.dat","wb"); 
fwrite(&weight_x,sizeof(weight_x),1,g);
fwrite(&weight_y,sizeof(weight_y),1,g);
fwrite(&weight_z,sizeof(weight_z),1,g);
fclose(g);

return 0;
}

The brain(perceptron):

Code:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int weight_xf = 0.0f, weight_yf = 0.0f, weight_zf = 0.0f;
float weight_x = 0.0f, weight_y = 0.0f, weight_z = 0.0f;
float threshold = 0.5f;
int input_x = 1;
int input_y;
int input_z;
bool percept;

int main(){
   FILE *g;
   g = fopen("per.dat","rb"); 
   fread(&weight_x,sizeof(weight_x),1,g);
   fread(&weight_y,sizeof(weight_y),1,g);
   fread(&weight_z,sizeof(weight_z),1,g);
   fclose(g);
   printf("input_y: ");
   scanf("%d", &input_y);
   printf("input_z: ");
   scanf("%d", &input_z);
   percept = (weight_x*input_x+weight_y*input_y+weight_z*input_z > threshold);
   printf("perceptron: ");
   printf("%d\n", percept);
}

Tell me what you think

Everybody thank you for you're time and effort (:

Hey thank you yann, you taught me what a perceptron is!

Neat. I am looking forward to playing with this.

I'm very impressed. How old did you say you were?

The learning function is a correct implementation of gradient descent on the error term. How did you figure that out? You may not realize it, but you're doing calculus there.

Congrats.

I got it but have no idea how to use it.

Originally Posted by brewbuck

I'm very impressed. How old did you say you were?

The learning function is a correct implementation of gradient descent on the error term. How did you figure that out? You may not realize it, but you're doing calculus there.

Congrats.

Actually tabstop(he found some code on the net (not all)), i did some changes, im 13 years old, I think just understanding how that works was ok for me, i could never write it myself in C(i know some other programing languages(i started programing in the 4th grade(10-11 years old),but i wrote everything else and made changes to the learning program)

Thank you

if you cant compile/run/read the program; i made it on the linux 32bit platform and it may not work on windows :/

,yann

Originally Posted by MTK

I got it but have no idea how to use it.

you first run the 1. program, it teaches perceptron a function of you're choice, then you run the other one, enter an input and output and he( (: ) gives you the correct answer.

Originally Posted by MK27

Hey thank you yann, you taught me what a perceptron is!

Neat. I am looking forward to playing with this.

Thanks

Hi, i just made 2 more (now i have 3) perceptrons,

I made XOR all by myself!!! I have 2 inputs and 3 perceptrons, i will post the code later, its on my lap
I'm now on to making some bigger connections!
DD so happy i finally got the whole thing, i have a presentation in biology about this, and in informatics

Originally Posted by yann

Hi, i just made 2 more (now i have 3) perceptrons, and im going to make them do XOR! What is the actual combination for XOR, do i need to have 3 inputs?

Look in wikipedia under XOR. The idea is if ONE (not both) of the inputs is 1, then the answer is 1. Not sure how you would use 3 inputs...

I think I have read somewhere that in actual hardware, sometimes NAND and NOR gates are used to implement everything else (AND, OR, etc), because it is possible, and this streamlines production (you only need two kinds of transistor).

I don't know if that will be useful to you, unless it turns out that doing XOR that way is easier/better than just doing XOR. Probably not...silly me. Maybe tho. If you had those two kinds of perceptrons, couldn't you arrange them the same way you would arrange transistors? Eg, in the same sequence?

Code:

(a NAND b) && !(a NOR b) == a XOR b

Originally Posted by yann

Hi, i just made 2 more (now i have 3) perceptrons,

I made XOR all by myself!!! I have 2 inputs and 3 perceptrons, i will post the code later, its on my lap
I'm now on to making some bigger connections!
DD so happy i finally got the whole thing, i have a presentation in biology about this, and in informatics

No i don't have 3 inputs, i have only two, but i have 3 PERCEPTRONS;
1, for teaching percept. 1

Code:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
float weight_x3 = 0.0f, weight_y3 = 0.0f, weight_z3 = 0.0f;
float weight_x = 0.0f, weight_y = 0.0f, weight_z = 0.0f;
float weight_x2 = 0.0f, weight_y2 = 0.0f, weight_z2 = 0.0f;
float threshold = 0.5f;
int successive_right = 0;
int total_go_round = 1;
const float learning_rate = 0.1f;
int input_x;
int input_y;
int input_z;
bool percept;
bool target(int x, int y, int z) { //što ucimo perceptron
    //x je bias, pa se ne ubraja
    return (y||z); //funkcija koju ucimo perceptron

}

int educate() {
  
        input_x = 1; //bias, uvijek 1
        input_y = rand() % 2;
        input_z = rand() % 2;
        bool goal = target(input_x, input_y, input_z);
        percept = (weight_x*input_x+weight_y*input_y+weight_z*input_z > threshold);
        if (percept == goal) {
            successive_right++;
        } else {
            successive_right = 0;
            int sign = goal ? 1 : -1; //sign of (y-f(x))
            weight_x += learning_rate*sign*input_x;
            weight_y += learning_rate*sign*input_y;
            weight_z += learning_rate*sign*input_z;
        }
    printf("%d", percept);
    return;
}

int main(){
   
FILE *g;
g = fopen("per.dat","rb"); 
fread(&weight_x,sizeof(weight_x),1,g);
fread(&weight_y,sizeof(weight_y),1,g);
fread(&weight_z,sizeof(weight_z),1,g);
fread(&weight_x2,sizeof(weight_x2),1,g);
fread(&weight_y2,sizeof(weight_y2),1,g);
fread(&weight_z2,sizeof(weight_z2),1,g);
fread(&weight_x3,sizeof(weight_x3),1,g);
fread(&weight_y3,sizeof(weight_y3),1,g);
fread(&weight_z3,sizeof(weight_z3),1,g);
fclose(g);

printf("1\n");
   srand(time(NULL));
   total_go_round=1;
   while(total_go_round <= 575){
      educate();
      total_go_round++;FILE *g;
}
   printf("Perceptron: (%.2f, %.2f, %.2f, %.2f)\n", weight_x, weight_y, weight_z, threshold);
   input_x = 1;
   printf("input_y: ");
   scanf("%d", &input_y);
   printf("input_z: ");
   scanf("%d", &input_z);
   percept = (weight_x*input_x+weight_y*input_y+weight_z*input_z > threshold);
   printf("perceptron: ");
   printf("%d\n", percept);

FILE *f;
f = fopen("per.dat","wb"); 
fwrite(&weight_x,sizeof(weight_x),1,f);
fwrite(&weight_y,sizeof(weight_y),1,f);
fwrite(&weight_z,sizeof(weight_z),1,f);
fwrite(&weight_x2,sizeof(weight_x2),1,f);
fwrite(&weight_y2,sizeof(weight_y2),1,f);
fwrite(&weight_z2,sizeof(weight_z2),1,f);
fwrite(&weight_x3,sizeof(weight_x3),1,f);
fwrite(&weight_y3,sizeof(weight_y3),1,f);
fwrite(&weight_z3,sizeof(weight_z3),1,f);
fclose(g);

return 0;
}

2, for teaching percept. 1

Code:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

float weight_x3 = 0.0f, weight_y3 = 0.0f, weight_z3 = 0.0f;
float weight_x = 0.0f, weight_y = 0.0f, weight_z = 0.0f;
float weight_x2 = 0.0f, weight_y2 = 0.0f, weight_z2 = 0.0f;
float threshold = 0.5f;
int successive_right = 0;
int total_go_round = 1;
const float learning_rate = 0.1f;
int input_x;
int input_y;
int input_z;
bool percept;
bool target(int x, int y, int z) { //što ucimo perceptron
    //x je bias, pa se ne ubraja
    return (!(y&&z)); //funkcija koju ucimo perceptron

}

int educate() {
  
        input_x = 1; //bias, uvijek 1
        input_y = rand() % 2;
        input_z = rand() % 2;
        bool goal = target(input_x, input_y, input_z);
        percept = (weight_x2*input_x+weight_y2*input_y+weight_z2*input_z > threshold);
        if (percept == goal) {
            successive_right++;
        } else {
            successive_right = 0;
            int sign = goal ? 1 : -1; //sign of (y-f(x))
            weight_x2 += learning_rate*sign*input_x;
            weight_y2 += learning_rate*sign*input_y;
            weight_z2 += learning_rate*sign*input_z;
        }
    printf("%d", percept);
    return;
}

int main(){

FILE *g;
g = fopen("per.dat","rb"); 
fread(&weight_x,sizeof(weight_x),1,g);
fread(&weight_y,sizeof(weight_y),1,g);
fread(&weight_z,sizeof(weight_z),1,g);
fread(&weight_x2,sizeof(weight_x2),1,g);
fread(&weight_y2,sizeof(weight_y2),1,g);
fread(&weight_z2,sizeof(weight_z2),1,g);
fread(&weight_x3,sizeof(weight_x3),1,g);
fread(&weight_y3,sizeof(weight_y3),1,g);
fread(&weight_z3,sizeof(weight_z3),1,g);
fclose(g);   

printf("1\n");
   srand(time(NULL));
   total_go_round=1;
   while(total_go_round <= 575){
      educate();
      total_go_round++;
}
   printf("Perceptron: (%.2f, %.2f, %.2f, %.2f)\n", weight_x2, weight_y2, weight_z2, threshold);
   input_x = 1;
   printf("input_y: ");
   scanf("%d", &input_y);
   printf("input_z: ");
   scanf("%d", &input_z);
   percept = (weight_x2*input_x+weight_y2*input_y+weight_z2*input_z > threshold);
   printf("perceptron: ");
   printf("%d\n", percept);

FILE *f;
f = fopen("per.dat","wb"); 
fwrite(&weight_x2,sizeof(weight_x2),1,f);
fwrite(&weight_y2,sizeof(weight_y2),1,f);
fwrite(&weight_z2,sizeof(weight_z2),1,f);
fwrite(&weight_x,sizeof(weight_x),1,f);
fwrite(&weight_y,sizeof(weight_y),1,f);
fwrite(&weight_z,sizeof(weight_z),1,f);
fwrite(&weight_x3,sizeof(weight_x3),1,f);
fwrite(&weight_y3,sizeof(weight_y3),1,f);
fwrite(&weight_z3,sizeof(weight_z3),1,f);
fclose(g);

return 0;
}

3, for guess what, teaching perceptron 3

Code:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
float weight_x3 = 0.0f, weight_y3 = 0.0f, weight_z3 = 0.0f;
float weight_x = 0.0f, weight_y = 0.0f, weight_z = 0.0f;
float weight_x2 = 0.0f, weight_y2 = 0.0f, weight_z2 = 0.0f;
float threshold = 0.5f;
int successive_right = 0;
int total_go_round = 1;
const float learning_rate = 0.1f;
int input_x;
int input_y;
int input_z;
bool percept;
bool target(int x, int y, int z) { //što ucimo perceptron
    //x je bias, pa se ne ubraja
    return (y&&z); //funkcija koju ucimo perceptron

}

int educate() {
  
        input_x = 1; //bias, uvijek 1
        input_y = rand() % 2;
        input_z = rand() % 2;
        bool goal = target(input_x, input_y, input_z);
        percept = (weight_x3*input_x+weight_y3*input_y+weight_z3*input_z > threshold);
        if (percept == goal) {
            successive_right++;
        } else {
            successive_right = 0;
            int sign = goal ? 1 : -1; //sign of (y-f(x))
            weight_x3 += learning_rate*sign*input_x;
            weight_y3 += learning_rate*sign*input_y;
            weight_z3 += learning_rate*sign*input_z;
        }
    printf("%d", percept);
    return;
}

int main(){
   
FILE *g;
g = fopen("per.dat","rb"); 
fread(&weight_x,sizeof(weight_x),1,g);
fread(&weight_y,sizeof(weight_y),1,g);
fread(&weight_z,sizeof(weight_z),1,g);
fread(&weight_x2,sizeof(weight_x2),1,g);
fread(&weight_y2,sizeof(weight_y2),1,g);
fread(&weight_z2,sizeof(weight_z2),1,g);
fread(&weight_x3,sizeof(weight_x3),1,g);
fread(&weight_y3,sizeof(weight_y3),1,g);
fread(&weight_z3,sizeof(weight_z3),1,g);
fclose(g);

printf("1\n");
   srand(time(NULL));
   total_go_round=1;
   while(total_go_round <= 575){
      educate();
      total_go_round++;FILE *g;
}
   printf("Perceptron: (%.2f, %.2f, %.2f, %.2f)\n", weight_x, weight_y, weight_z, threshold);
   input_x = 1;
   printf("input_y: ");
   scanf("%d", &input_y);
   printf("input_z: ");
   scanf("%d", &input_z);
   percept = (weight_x3*input_x+weight_y3*input_y+weight_z3*input_z > threshold);
   printf("perceptron: ");
   printf("%d\n", percept);

FILE *f;
f = fopen("per.dat","wb"); 
fwrite(&weight_x,sizeof(weight_x),1,f);
fwrite(&weight_y,sizeof(weight_y),1,f);
fwrite(&weight_z,sizeof(weight_z),1,f);
fwrite(&weight_x2,sizeof(weight_x2),1,f);
fwrite(&weight_y2,sizeof(weight_y2),1,f);
fwrite(&weight_z2,sizeof(weight_z2),1,f);
fwrite(&weight_x3,sizeof(weight_x3),1,f);
fwrite(&weight_y3,sizeof(weight_y3),1,f);
fwrite(&weight_z3,sizeof(weight_z3),1,f);
fclose(g);

return 0;
}

and the brain

Code:

#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int input_x3 = 1; //bias
int input_x2 = 1; //bias
int input_x = 1;  //bias
int input_y;      //bias
int input_z;      //bias  


float weight_x = 0.0f, weight_y = 0.0f, weight_z = 0.0f; //tezine percept 1
float threshold = 0.5f;                                  //granica percept 1
bool percept;                                            //percept 1

float weight_x2 = 0.0f, weight_y2 = 0.0f, weight_z2 = 0.0f; //tezine percept 2
float threshold2 = 0.5f;                                    //granica percept 2
bool percept2;                                              //percept 2

float weight_x3 = 0.0f, weight_y3 = 0.0f, weight_z3 = 0.0f; //tezine percept 3
float threshold3 = 0.5f;                                  //granica percept 3
bool percept3;                                            //percept 3 

/*main*/
int main(){
   printf("\n");
   FILE *g;
   g = fopen("per.dat","rb"); 
   fread(&weight_x,sizeof(weight_x),1,g);
   fread(&weight_y,sizeof(weight_y),1,g);
   fread(&weight_z,sizeof(weight_z),1,g);
   fread(&weight_x2,sizeof(weight_x2),1,g);
   fread(&weight_y2,sizeof(weight_y2),1,g);
   fread(&weight_z2,sizeof(weight_z2),1,g);
   fread(&weight_x3,sizeof(weight_x3),1,g);
   fread(&weight_y3,sizeof(weight_y3),1,g);
   fread(&weight_z3,sizeof(weight_z3),1,g);
   printf("weights:\n");
   printf("%f\n", weight_x);
   printf("%f\n", weight_y);
   printf("%f\n", weight_z);
   printf("%f\n", weight_x2);
   printf("%f\n", weight_y2);
   printf("%f\n", weight_z2);
   printf("%f\n", weight_x3);
   printf("%f\n", weight_y3);
   printf("%f\n", weight_z3);
   printf("\n");
   fclose(g);
   printf("inputs:\n");
   printf("input_y: ");
   scanf("%d", &input_y);
   printf("input_z: ");
   scanf("%d", &input_z);
   percept = (weight_x*input_x+weight_y*input_y+weight_z*input_z > threshold);
   percept2 = (weight_x2*input_x2+weight_y2*input_y+weight_z2*input_z > threshold2);
   percept3 = (weight_x3*input_x3+weight_y3*percept+weight_z3*percept2 > threshold3);
   printf("\n");
   printf("outputs:\n");
   printf("perceptron: ");
   printf("%d\n", percept);
   printf("perceptron2: ");
   printf("%d\n", percept2);
   printf("perceptron3 (the network output): ");
   printf("%d\n", percept3);
   printf("\n");
}

first compile the first 3 programs, then run them, then compile the bran, rum it and thats all!

I'm now looking forward for making some bigger networks, and i will need more efficient ways of teaching percepts. I mean, to be able of teaching them inside the brain(i didn't do that because of the return function).

Tell me what do you think...



,yann

Originally Posted by Adak

I think my brain has already been "rummed", thanks.

hehe

Originally Posted by mike_g

Hi Yann,

I have not really had time to go over your code, but are you sure it works?

The XOR problem is a classic example of non-linearly separable data. This link should explain better: 2.4.1 Linear Separability and the XOR Problem

To solve it you would generally use a multi layer perception, with back propagation. This is where things start to get trickier, but once you have it cracked, you can make preceptrons that can do some very useful stuff.

But , i use multilayer , and yeah it does work ...check it your'e self ...