DL-C/and.c at main · aadityansha06/DL-C · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91


/*
                         And Gate neural netwrok
               compile it with gcc and_gate.c -o and-gate -lm

                        trained weight-1 15.663549
                                weight-2 15.663549
                                bais -23.658016

                                hypothesis
                        y=sigmoid((w-1*i-1+w-2*i-2)+bais)

*/

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

#include <math.h>
#define epoch 300000
#define data_set 4
int data[][3] = {{1, 1, 1}, {1, 0, 0}, {0, 0, 0}, {0, 1, 0}};

typedef struct para {
  float input;
  float weight_1;
  float weight_2;
  float bias;
  float learn_rate;
} para;
float bias_sum = 0, weight1_sum = 0, weight2_sum = 0;
float rand_float() { return (float)rand() / (float)RAND_MAX; }

float sigmoid(float x) { return 1.0 / (1.0 + exp(-x)); }

int main() {
  para para1;
  para *parameter = &para1;

  srand(69);
  parameter->bias = 1.0;
  parameter->weight_1 = rand_float() * 10.0f;
  parameter->weight_2 = rand_float() * 10.0f;
  parameter->learn_rate = 1e-1;

  printf("\n sno.\texpected\tpredicted\t weight\t weight_gradient\t");
  float weight_gradient_1 = 0;
  float weight_gradient_2 = 0;
  for (int j = 0; j < epoch; j++) {

    bias_sum = 0;
    weight1_sum = 0;
    weight2_sum = 0;
    float y_cap = 0;
    for (int i = 0; i < data_set; i++) {
      y_cap = sigmoid((data[i][0] * parameter->weight_1) +
                      (data[i][1] * parameter->weight_2) + parameter->bias);
      bias_sum += data[i][2] - y_cap;
      weight1_sum += (data[i][2] - y_cap) * data[i][0];
      weight2_sum += (data[i][2] - y_cap) * data[i][1];
      printf("%d\t%d\t%d\t%f\t%f\t%f\n", j, data[i][0], data[i][1], y_cap,
             weight_gradient_1, weight_gradient_2);
    }
    // bias cost
    float bias_gradient = (bias_sum * -2) / data_set;
    // bias update
    parameter->bias -= parameter->learn_rate * bias_gradient;

    // weight cost
    weight_gradient_1 = (weight1_sum * -2) / data_set;
    weight_gradient_2 = (weight2_sum * -2) / data_set;
    parameter->weight_1 -= parameter->learn_rate * weight_gradient_1;
    parameter->weight_2 -= parameter->learn_rate * weight_gradient_2;
  }
  printf("\nFinal output\n W-1\t%f\nW-2\t%f\nBias\t%f", parameter->weight_1,
         parameter->weight_2, parameter->bias);
  float x1 = 0, x2 = 0;
  int ch = 1;
  while (ch != 0) {

    printf("\n Enter two  number");
    scanf("%f %f", &x1, &x2);
    printf("\n %f is answer\n",
           sigmoid((x1 * parameter->weight_1) + (x2 * parameter->weight_2) +
                   parameter->bias));

    printf("\n\nDo u want to exit? 0 for yes and 1 for no\t\n");
    scanf("%d", &ch);
  }
  return 0;
}