[c/php]reti neurali e programmazione

[$te]

qualcuno ha provato l'esempio che ho postato?

[$te]

ho provato a compilare l'esempio, ma ci sono molti errori..
posto il codice completo per chi vuole provare a compilarlo:

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

typedef struct TypeNeuron neuron;
typedef struct TypeSynapsis sinapsi;
typedef struct TypeLayer layer;
typedef struct TypeNN neuralnet;

#define _PRECISION float

struct TypeNeuron {
_PRECISION trans_value;
_PRECISION prop_value;
sinapsi* in_links[16];
int num_in_links;
sinapsi* out_links[16];
int num_out_links;
_PRECISION (*trans_func)(_PRECISION prop_value);
};

struct TypeSynapsis {
_PRECISION delta;
_PRECISION weight;
neuron *in,*out;
};

struct TypeLayer {
neuron** elements;
int num_elements;
void (*update_weights)(layer* lPtr);
};

struct TypeNN {
int max_epochs;
_PRECISION l_rate;
layer* input_layer;
layer* hidden_layer;
layer* output_layer;
};

void init_net(neuralnet *net) {
net = (neuralnet*) malloc(sizeof(neuralnet));
max_epochs=1024; // Valore arbitrario
l_rate=0.5; // Valore arbitrario
}
void new_layer(layer *l) {
l = (layer*) malloc(sizeof(layer));
num_elements=0;
}
void new_neuron(neuron *n) {
n = (neuron*) malloc(sizeof(neuron));
num_in_links=0;
num_out_links=0;
}

void link_layers(layer* layer_in,layer* layer_out){
int i,j;
sinapsi* aux_syn;
neuron *curr_in,*curr_out;
for(i=0;i < layer_in >num_elements;i++) {
curr_in = layer_in> elements[i];
for(j=0;j < layer_out> num_elements; j++) {
curr_out = layer_out> elements[j];
aux_syn = (sinapsi*)malloc(sizeof(sinapsi));
aux_syn>in = curr_in;
aux_syn>out = curr_out;
aux_syn>weight = norm(get_rand());
curr_in>out_links[curr_in>num_out_links++] = aux_syncurr_out>in_links[curr_out>num_in_links++] = aux_syn;
}
}
}

float get_rand() {
float x,y;
srand( (unsigned) time(NULL));
x = (float) rand();
y = (sin(x)*sin(x))0.5;
return y;
}

#define TRAINING_FILE “training.txt”
int open_training_file() {
int fd;
if ((fd=open(TRAINING_FILE, O_RDONLY)) < 0)
return 1;
else
return fd;
}

int get_data(float *data, int fd) {
int curr_char;
int status;
int is_dec;
char buf[1],ch;
// Attenzione: così come è dichiarata questa stringa può essere soggetta
// a buffer overflow. Imponete voi dei controlli ulteriori per evitarlo,
// controllando prima quanti caratteri ci sono nel file fino al prossimo
// ';' e dichiarando la stringa dinamicamente
char aux_str[256];
curr_char=0;
// Ciclo finché ci sono caratteri da leggere nel file
while( ( status = read(fd,buf,sizeof(buf)) ) != 0) {
// Se status < 0, c'è qualche errore
if(status<0)if(_DEBUG)perror(strerror(errno));
ch=buf[0];
// Se il carattere letto è proprio un ';', esco dal ciclo
if(ch == ';') break;
// Altrimenti continuo. Gli a capo sono ininfluenti
if(ch == '\n')continue;
// Gli unici caratteri validi al fine della lettura sono . e tutti
// i valori numerici. Se il carattere letto non è uno di quelli,
// ritorno errore
if(ch != '.' && ch != ''&& ( ch < 48 || ch > 57 )) {
if(_DEBUG)fprintf(stderr,"invalid ch %d\n",ch);
data = NULL;
return 1;
}
// Controllo quanti punti ci sono nel numero
if( ch == '.' ){
// Se è già stato trovato un . allora c'è un errore
if(is_dec){
aux_str[curr_char++]=ch;
aux_str[curr_char]='\0';
fprintf(stderr,"invalid format: two '.' found in%s\n",aux_str);
return 1;
}
// Altrimenti, il numero è decimale
else
is_dec=1;
}
// Salvo l'ulteriore carattere letto nella stringa aux_str
aux_str[curr_char++] = ch;
}
// Termino la stringa
aux_str[curr_char]='\0';
// Converto la stringa in float e salvo il valore in *data
*data = atof(aux_str);
return 0;
}

int fd;
int status;
float temp;
// Apro il file con gli input
fd=open_training_file();
// Ciclo su tutti gli elementi del layer di input
for(i=0; i < net>input_layer>num_elements; i++) {
// Se la funzione get_data ritorna un valore negativo, allora c'è qualcosa
// che non va negli input
if((status = get_data(&temp,fd)) < 0){
fprintf(stderr,"Invalid input data\n");
free(net);
return 1;
}
// Il valore del potenziale postsinattico del neurone è quello appena
// letto da input, e il valore di trasferimento sarà uguale in virtù della
// scelta di funzione di trasferimento che abbiamo fatto
net>input_layer>elements[i]>prop_value=(_PRECISION)temp;
net>input_layer>elements[i]>trans_value=(_PRECISION)temp;
}
//Per quanto riguarda invece il layer nascosto
void propagate_into_layer(layer* lPtr){
int i;
neuron* nPtr;
// Ciclo for su tutti gli elementi del layer
for(i=0;i < lPtr>num_elements;i++) {
nPtr = lPtr>elements[i];
// Per ogni neurone calcolo il potenziale postsinattico...
nPtr>prop_value = potential(nPtr);
// ...e la funzione di trasferimento
nPtr>trans_value = nPtr>trans_func(nPtr>prop_value);
}
}
//La funzione potential() ha questo codice:
_PRECISION potential(neuron* nPtr){
_PRECISION aux_value=0;
int i=0;
// Per ogni sinapsi in ingresso al neurone...
for(i=0; i<nPtr>num_in_links; i++) {
// ...il valore del potenziale è la sommatoria del peso sinattico della
// sinapsi in questione moltiplicato per il suo valore di trasferimento
aux_value += (nPtr>in_links[i]>weight * nPtr>in_links[i]>in>trans_value);
}
return aux_value;
}

_PRECISION compute_output_delta(
_PRECISION output_prop_value, _PRECISION des_out) {
_PRECISION delta;
delta =(output_prop_value des_out) * linear_derivate (output_prop_value);
return delta;
}

void update_output_weights(layer* lPtr,_PRECISION delta,_PRECISION l_rate){
int i,j;
sinapsi* sPtr;
neuron* nPtr;
for(i=0; i<lPtr>num_elements; i++) {
         nPtr = lPtr>elements[i];
for(j=0;j < nPtr>num_in_links;j++){
sPtr = nPtr>in_links[j];
// Äwij = – ç Dj xi
sPtr>delta = (sPtr>in>trans_value*delta*l_rate);
}
}
}

void commit_weight_changes(layer* lPtr){
int i,j;
neuron* nPtr;
sinapsi* sPtr;
// Ciclo su tutti gli elementi del layer
for(i=0; i < lPtr>num_elements; i++) {
nPtr = lPtr>elements[i];
// Ciclo su tutte le sinapsi collegate ad un certo neurone
for(j=0; j < nPtr>num_in_links; j++) {
// La sinapsi sarà associata al jesimo collegamento del neurone
sPtr = nPtr>in_links[j];
// Il peso della sinapsi viene aggiornato con il delta
// appena calcolato
sPtr>weight += sPtr>delta;
// Resetto il valore di delta, in modo da potergli applicare
// nuove modifiche
sPtr>delta = 0;
}
}
}

// Ciclo per max_epochs volte
for(j=0; j<net>max_epochs; j++) {
// Leggo i valori in input dal file, con il procedimento già visto
// in precedenza
for(i=0; i<net>input_layer>num_elements; i++) {
if((status = get_data(&temp,fd)) < 0){
fprintf(stderr,"errore irreversibile, closing...\n");
free(net);
return 1;
}
net>input_layer>elements[i]>prop_value=(_PRECISION)temp;
net>input_layer>elements[i]>trans_value=(_PRECISION)temp;
}
// Passo i valori prima al layer nascosto, quindi al layer di output
propagate_into_layer(net>hidden_layer);
propagate_into_layer(net>output_layer);
// Calcolo la delta di output
if((status = get_data(&des_out,fd)) < 0){
fprintf(stderr,"errore irreversibile, closing...\n");
return 1;
} else {
out_delta = compute_output_delta(net>output_layer>elements[0]>prop_value,des_out);
update_output_weights(net>output_layer,out_delta,net>l_rate);
}
// Calcolo la variazione dei pesi sinattici per il layer nascosto
// e aggiorno tutti i pesi sinattici
update_hidden_weights(net>hidden_layer,out_delta,net>l_rate);
commit_weight_changes(net>output_layer);
commit_weight_changes(net>hidden_layer);
net_output = net>output_layer>elements[0]>prop_value;
printf("DES=%f\tERROR=%f\tOUT=%f\tDELTA=%f\n",des_out,(des_outnet_output),net_output,out_delta);
}

[variabilepippo]

qualcuno ha provato l'esempio che ho postato?

No, perché non capisco a cosa serva compilare UN sorgente per capire un argomento complesso come le reti neurali, argomento che richiede delle SOLIDE basi teoriche, non un compilatore...

[$te]

Originariamente inviato da variabilepippo

No, perché non capisco a cosa serva compilare UN sorgente per capire un argomento complesso come le reti neurali, argomento che richiede delle SOLIDE basi teoriche, non un compilatore...

xké mi sono letto piu e piu volte la teoria sui sistemi fuzzy ecc, e sono arrivato ad un punto in cui ho bisogno di un esempio per capire piu a fondo (sarà ke sono ignorante...).

Quindi se qualcuno ha un es semplice sulle reti neurali in c, mi fa molto piacere se me lo linka

grazie

[Johnn]

Prova a scaricarti programmi per la realizzazione di reti neurali come Joone o Fann che hanno anche una interfaccia grafica e non vedi per niente codice. In entrambi c'è una rete d'esempio (tipo rete che impara la somma o l'OR logico) e vedrai una rete subito all'opera.

Nel forum di Bernardotti c'è molto materiale a riguardo, forse troppo .

In estrema sintesi, le reti neurali sono molto potenti in alcuni ambiti da lasciarti a bocca aperta (riconoscimento di un viso) e sembra che fanno tutto loro (non devi "programmare" l'interno della rete o implementare algoritmi), ma devi settare diversi parametri e progettare la rete (dire quanti strati, quanti nodi in input/output, quali funzioni di apprendimento usare) cose tutt'altro che semplici man mano che il problema si fa complesso.

[Johnn]

Se vuoi vedere il codice sorgente, entrambi i programmi che ho segnalato sono open source, quindi buon divertimento (anche se pure io ti sconsiglio di partire dai sorgenti).

[$te]

appena ho tempo allora provo i due progammi, grazie!!

ho comunque visto un esempio in python, trovato su wiky, che funziona, il problema é che non cé spiegato cosa fa la rete:P
ecco il link: http://blacklight.gotdns.org/wiki/in...king_in_python

[songoge]

Ti consiglio di dare un'occhiata anche alla libreria Aforge. E' open source (c#), orientata agli oggetti, e comprende diverse cose oltre alle pure reti neurali. Buon Divertimento.

Inoltre ti consiglio due libri.

1)Fausett-Fundamentals of Neural Networks-architectures Algorithms applications
In inglese, ma veramente ideale per chi inizia. Spiega l'argomento dal lato del programmatore (con pseudo-codice e molti esempi). Inoltre a fine di ogni capitolo ci sono utili riferimenti ad altri libri per approfondimenti.

2)Reti neuronali. Dal perceptron alle reti caotiche e neuro-fuzzy (di Silvio Cammarata)
In Italiano, ma meno interessante per un programmatore. Troppe parole buttate al vento e formule matematiche malamente spiegate. Lo consiglio solo perchè tratta reti neurali insolite che molti libri trascurano di descrivere.

Voi invece, oltre a quei link, che libri mi consigliate?
Anche in inglese. Preferisco libri che si rivolgono a programmatori e magari che vengono adottati come testi universitari.

[stdecden]

Prova a vedere qui. É un introduzione alle reti neurali che utilizza un algoritmo genetico per evolvere le reti invece della backpropagandation. Vedi se ti puó interessare!!

[$te]

ho iniziato a leggere "Fondamentals of neural networks"...un po' lunghino pero:P

[songoge]

Originariamente inviato da $te

ho iniziato a leggere "Fondamentals of neural networks"...un po' lunghino pero:P

Lunghino? Sono solo 400 pagine. L'ho finito in 20gg.

Adesso sto per iniziare questo:
Neural Networks, A Comprehensive Foundation [Haykin] [2ed] [Prentice Hall] [1999]

Sono solo 900 pagine

[$te]

ah ok:P
saresti disposto a delucidarmi su alcune cose? (t posso fare delle domande sul libro via mess privati?`)
grazie...

[$te]

http://it.geocities.com/antonio_di_s...empio%20in%20C