neural.c

indentation

#include stdlib.h
#include math.h
#include string.h

#include "var.h"
#include "neural.h"



int init_nn()
{
if ((W_h_1 = (double ) malloc(num_hidden_unit_1 num_input_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((W_h_2 = (double ) malloc(num_hidden_unit_2 num_input_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((W_o_1 = (double ) malloc(num_output_unit_1 num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((W_o_2 = (double ) malloc(num_output_unit_2 num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((b_h_1 = (double ) malloc(num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((b_h_2 = (double ) malloc(num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((b_o_1 = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((b_o_2 = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((W_h_1_d = (double ) malloc(num_hidden_unit_1 num_input_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((W_h_2_d = (double ) malloc(num_hidden_unit_2 num_input_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((W_o_1_d = (double ) malloc(num_output_unit_1 num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((W_o_2_d = (double ) malloc(num_output_unit_2 num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((b_h_1_d = (double ) malloc(num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((b_h_2_d = (double ) malloc(num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((b_o_1_d = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((b_o_2_d = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);

if ((out_h_1 = (double ) malloc(num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((in_p_1 = (double ) malloc(num_input_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((in_h_1 = (double ) malloc(num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((in_o_1 = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((out_o_1 = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((out_1 = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((out_h_2 = (double ) malloc(num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((in_p_2 = (double ) malloc(num_input_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((in_h_2 = (double ) malloc(num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((in_o_2 = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((out_o_2 = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((out_2 = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((out_h_1_d = (double ) malloc(num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((in_p_1_d = (double ) malloc(num_input_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((in_h_1_d = (double ) malloc(num_hidden_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((in_o_1_d = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((out_o_1_d = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);
if ((out_1_d = (double ) malloc(num_output_unit_1 sizeof(double))) == NULL)
return (ERROR);

if ((out_h_2_d = (double ) malloc(num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((in_p_2_d = (double ) malloc(num_input_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((in_h_2_d = (double ) malloc(num_hidden_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((in_o_2_d = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((out_o_2_d = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);
if ((out_2_d = (double ) malloc(num_output_unit_2 sizeof(double))) == NULL)
return (ERROR);

return (OK);

}

int parse_line(char str, int num_col, double matrix, int row)
{
int i = 0;
char parse_str[LEN_LINE] = "%lg";
char tmp_str[LEN_LINE] = "$\backslash$0";
for (i = 0; i num_col; i++) {
if (sscanf(str, parse_str, (matrix + row num_col + i)) $\neq$ 1)
return (ERROR);
strcpy(tmp_str, "%g ");
strcat(tmp_str, parse_str);
strcpy(parse_str, tmp_str);
}
return (OK);
}



int Read_Weight_1(char inweight)
{
int i;
FILE fp;
char str[LEN_LINE];
if ((fp = fopen(inweight, "r")) == NULL)
return (ERROR);
fgets(str, LEN_LINE, fp); / riga di commento: W_h /
for (i = 0; i num_hidden_unit_1; i++) {
fgets(str, LEN_LINE, fp); / riga di W_h /
if (parse_line(str, num_input_unit_1, W_h_1, i) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_input_unit_1, W_h_1_d, i) $\neq$ 0)
return (ERROR);
}
fgets(str, LEN_LINE, fp); / riga di commento: W_o /
for (i = 0; i num_output_unit_1; i++) {
fgets(str, LEN_LINE, fp); / riga di W_h /
if (parse_line(str, num_hidden_unit_1, W_o_1, i) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_hidden_unit_1, W_o_1_d, i) $\neq$ 0)
return (ERROR);
}
fgets(str, LEN_LINE, fp); / riga di commento: b_h /
fgets(str, LEN_LINE, fp);
if (parse_line(str, num_hidden_unit_1, b_h_1, 0) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_hidden_unit_1, b_h_1_d, 0) $\neq$ 0)
return (ERROR);

fgets(str, LEN_LINE, fp); / riga di commento: b_o /
fgets(str, LEN_LINE, fp);
if (parse_line(str, num_output_unit_1, b_o_1, 0) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_output_unit_1, b_o_1_d, 0) $\neq$ 0)
return (ERROR);
fclose(fp);

return (OK);
}

int Read_Weight_2(char inweight)
{
int i;
FILE fp;
char str[LEN_LINE];
if ((fp = fopen(inweight, "r")) == NULL)
return (ERROR);
fgets(str, LEN_LINE, fp); / riga di commento: W_h /
for (i = 0; i num_hidden_unit_2; i++) {
fgets(str, LEN_LINE, fp); / riga di W_h /
if (parse_line(str, num_input_unit_2, W_h_2, i) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_input_unit_2, W_h_2_d, i) $\neq$ 0)
return (ERROR);
}
fgets(str, LEN_LINE, fp); / riga di commento: W_o /
for (i = 0; i num_output_unit_2; i++) {
fgets(str, LEN_LINE, fp); / riga di W_h /
if (parse_line(str, num_hidden_unit_2, W_o_2, i) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_hidden_unit_2, W_o_2_d, i) $\neq$ 0)
return (ERROR);
}
fgets(str, LEN_LINE, fp); / riga di commento: b_h /
fgets(str, LEN_LINE, fp);
if (parse_line(str, num_hidden_unit_2, b_h_2, 0) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_hidden_unit_2, b_h_2_d, 0) $\neq$ 0)
return (ERROR);

fgets(str, LEN_LINE, fp); / riga di commento: b_o /
fgets(str, LEN_LINE, fp);
if (parse_line(str, num_output_unit_2, b_o_2, 0) $\neq$ 0)
return (ERROR);
if (parse_line(str, num_output_unit_2, b_o_2_d, 0) $\neq$ 0)
return (ERROR);
fclose(fp);

return (OK);
}



double eval_out_nn1(double input_pattern)
{
int i, j;
for (i = 0; i num_input_unit_1; i++) {
(in_p_1 + i) = (input_pattern + i);
/ printf("%g ",(input_patterni)); /
}

for (i = 0; i num_hidden_unit_1; i++) {
(out_h_1 + i) = 0.0;
in_h_1[i] = 0.0;
}

/ printf("$\backslash$nin_h:$\backslash$n"); /
for (i = 0; i num_hidden_unit_1; i++) {
for (j = 0; j num_input_unit_1; j++) {
in_h_1[i] += input_pattern[j] ((W_h_1 + i num_input_unit_1 + j));

}
in_h_1[i] += b_h_1[i];
/ printf("%g ",in_h[i]); /
}
/ printf("$\backslash$n$\backslash$n$\backslash$nout_h:$\backslash$n "); /
for (i = 0; i num_hidden_unit_1; i++) {
(out_h_1 + i) = sigmoid(in_h_1[i]);
/ printf("%g ",((out_h_1i))); /
}

for (i = 0; i num_output_unit_1; i++)
in_o_1[i] = out_o_1[i] = 0.0;

for (i = 0; i num_output_unit_1; i++) {
for (j = 0; j num_hidden_unit_1; j++)
in_o_1[i] += ((out_h_1 + j)) ((W_o_1 + i num_hidden_unit_1 + j));
in_o_1[i] += b_o_1[i];
}
/ printf("$\backslash$n$\backslash$n$\backslash$nout_o:$\backslash$n"); /
for (i = 0; i num_output_unit_1; i++) {
/ out_o_1[i] $=$ sigmoid(in_o_1[i]); /
out_o_1[i] = in_o_1[i];
/ printf("%g ",out_o[i]); /
}
/ printf("$\backslash$n$\backslash$n"); /
for (i = 0; i num_output_unit_1; i++)
(out_1 + i) = out_o_1[i];
return (out_1);
}

double eval_out_nn2(double input_pattern)
{
int i, j;
for (i = 0; i num_input_unit_2; i++) {
(in_p_2 + i) = (input_pattern + i);
/ printf("%g ",(input_patterni)); /
}

for (i = 0; i num_hidden_unit_2; i++)
in_h_2[i] = (out_h_2 + i) = 0.0;

/ printf("$\backslash$nin_h:$\backslash$n"); /
for (i = 0; i num_hidden_unit_2; i++) {
for (j = 0; j num_input_unit_2; j++) {
in_h_2[i] += input_pattern[j] ((W_h_2 + i num_input_unit_2 + j));

}
in_h_2[i] += b_h_2[i];
/ printf("%g ",in_h[i]); /
}
/ printf("$\backslash$n$\backslash$n$\backslash$nout_h:$\backslash$n "); /
for (i = 0; i num_hidden_unit_2; i++) {
(out_h_2 + i) = sigmoid(in_h_2[i]);
/ printf("%g ",((out_hi))); /
}

for (i = 0; i num_output_unit_2; i++)
in_o_2[i] = out_o_2[i] = 0.0;

for (i = 0; i num_output_unit_2; i++) {
for (j = 0; j num_hidden_unit_2; j++)
in_o_2[i] += ((out_h_2 + j)) ((W_o_2 + i num_hidden_unit_2 + j));
in_o_2[i] += b_o_2[i];
}
/ printf("$\backslash$n$\backslash$n$\backslash$nout_o:$\backslash$n"); /
for (i = 0; i num_output_unit_2; i++) {
/ out_o_2[i] $=$ sigmoid(in_o_2[i]); /
out_o_2[i] = in_o_2[i];
/ printf("%g ",out_o[i]); /
}
/ printf("$\backslash$n$\backslash$n"); /
for (i = 0; i num_output_unit_2; i++)
(out_2 + i) = out_o_2[i];
return (out_2);
}

double sigmoid(double val)
{
return (tanh(val g));
}