[c/php]reti neurali e programmazione [Archivio]

View Full Version : [c/php]reti neurali e programmazione

$te

13-06-2008, 00:04

sono molto interessato all'intelligenza artificiale e quindi anche alle reti neurali.
Avete degli esempi o esperienza su questi da spiegarmi?
Che applicazioni ci possono essere in ambito php?(quindi ambito web)

grazie

arcer

13-06-2008, 01:28

mi iscrivo al topic..

$te

13-06-2008, 22:09

mi iscrivo al topic..

???

variabilepippo

13-06-2008, 22:45

Avete degli esempi o esperienza su questi da spiegarmi?

Ci sono tanti bei libroni sull'argomento, vista la sua complessità/vastità. :)

$te

13-06-2008, 22:49

Ci sono tanti bei libroni sull'argomento, vista la sua complessità/vastità. :)

e lo so, anche in rete ho trovato molto, ma vorrei un esempio pratico e "semplice" da poter provare (naturalmente se é possibile...:P).
Vorrei diciamo "provare", avere un attimo le chiavi in mano, prima di buttarmi giu a studiare la teoria..:muro: :muro: :muro:

variabilepippo

13-06-2008, 23:07

naturalmente se é possibile

Dovresti restringere un po' il campo di applicazione, altrimenti ti si può soltanto suggerire un esempio di utilizzo magari lontano dai tuoi interessi.

$te

14-06-2008, 08:04

Dovresti restringere un po' il campo di applicazione, altrimenti ti si può soltanto suggerire un esempio di utilizzo magari lontano dai tuoi interessi.

e non so..mi basta un esempio che non sia troppo complicato, qualcosa di semplice (non certo una rete che mi risolva le equazioni differenziali..:P)

$te

14-06-2008, 15:48

niente?

variabilepippo

14-06-2008, 16:08

niente?

La richiesta è ancora troppo generica, è un po' come se chiedessi "mi fate vedere un esempio di mezzo di trasporto"?

Biciclette, aerei supersonici, Shuttle, yacht, monopattini, automobili, trattori (etc) rientrano nella categoria "mezzi di trasporto", ma potrebbero essere molto lontani dai tuoi intenti, magari stai cercando semplicemente un paio di scarpe...

$te

14-06-2008, 17:07

il problema é che non so che dirti:P
nelle varie cose che ho letto, parlavano di un esempio in cui la rete neurale imparava a fare delle operazioni matematiche come la somma o la moltiplicazione.

Io piu che altro cerco un esempio qualsiasi da cui partire, ma non so a cosa voglio arrivare (magari creare una rete che mi filtra gli utenti in malafede nel mio sito web, o magari una rete che mi faccia il riassunto di un testo)

In pratica accolgo tutto..basta che non sia qlc di troppo complicato:P (paginate di codice forse mi scoraggerebbero:P)

grazie

variabilepippo

14-06-2008, 17:15

Dai un'occhiata a Neural Network Applications (http://www.ip-atlas.com/pub/nap/) o la lista delle applicazioni Wikipedia (http://en.wikipedia.org/wiki/Neural_network#Applications) per farti un'idea della vastità del campo applicativo.

Potresti partire dagli esempi di una delle tante librerie open-source per l'implementazione di paradigmi basati su reti neurali: FANN, OWL, ...

$te

14-06-2008, 17:38

ok, grazie:P
finisco gli esami (5 giorni...5 esami...) e poi mi documento...e riprendero a rompervi le scatole:D

sim89

15-06-2008, 10:35

Sbaglio o Flavio Bernardotti si occupava un po' di queste cose? prova a guardare nel suo sito magari ;)

$te

15-06-2008, 12:28

nn é molto chiario il suo sito.
Mi pare abbia progettato una rete per la videosorveglianza..un po troppo avanti per me:P

$te

27-06-2008, 17:19

sim89

28-06-2008, 20:19

Mi iscrivo perchè interessa anche a me :O
Aspetto anch'io un esempio.

$te

30-06-2008, 22:23

niente esempi? anche semplicissimi?

$te

01-07-2008, 08:18

ho trovato questa pagina, in cui si fa una rete che esegue la somma di due numeri (spero nn sia troppo semplice:P)

http://www.orebla.it/file/reti.pdf

stasera me la guardo anchio

variabilepippo

01-07-2008, 09:09

L'argomento è complesso e va studiato sui libri, non "by example". :rolleyes:

Comunque ho già suggerito qualche link:

Neural Network Applications (http://www.ip-atlas.com/pub/nap/)
Neural Network - Apps (http://en.wikipedia.org/wiki/Neural_network#Applications)
OWL Neural Network Lib (http://www.hyperlogic.com/owl.html)
Fast Artificial Neural Network Library (http://leenissen.dk/fann/)

Ma ripeto, se ti interessa l'argomento ed hai le necessarie basi per affrontarne lo studio, devi andare in libreria non "a caccia di esempi" o di "tutorial".

$te

01-07-2008, 09:53

L'argomento è complesso e va studiato sui libri, non "by example". :rolleyes:
si, capisco, ma é una sorta di "filtro" per avere un'idea, e dirmi: "si, val la pena passarci un po di tempo, o no, é troppo complicato, non ho abb tempo per fare qlc di concreto"

Comunque ho già suggerito qualche link:

Neural Network Applications (http://www.ip-atlas.com/pub/nap/)
Neural Network - Apps (http://en.wikipedia.org/wiki/Neural_network#Applications)
OWL Neural Network Lib (http://www.hyperlogic.com/owl.html)
Fast Artificial Neural Network Library (http://leenissen.dk/fann/)

Li ho guardati, ma mi sembrano già in partenza complicati

Ma ripeto, se ti interessa l'argomento ed hai le necessarie basi per affrontarne lo studio, devi andare in libreria non "a caccia di esempi" o di "tutorial".

Sicuramente se l'esempio che ho postato mi riesce a "prendere"...non esito a buttarmi in libreria (ci saranno libri in italiano a proposito?)

$te

02-07-2008, 07:12

qualcuno ha provato l'esempio che ho postato?

$te

09-07-2008, 10:51

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

09-07-2008, 11:01

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... :stordita:

$te

12-07-2008, 17:37

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... :stordita:

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

12-07-2008, 17:47

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 :D .

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

12-07-2008, 17:49

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

12-07-2008, 17:59

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/index.php/Introduzione_ai_sistemi_fuzzy_e_alle_reti_neurali#Esempio_di_rete_neurale_con_algoritmo_di_backtraking_in_python

songoge

12-07-2008, 20:58

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? :D
Anche in inglese. Preferisco libri che si rivolgono a programmatori e magari che vengono adottati come testi universitari.

stdecden

13-07-2008, 10:29

Prova a vedere qui (http://www.ai-junkie.com/ann/evolved/nnt1.html). É un introduzione alle reti neurali che utilizza un algoritmo genetico per evolvere le reti invece della backpropagandation. Vedi se ti puó interessare!! :blah:

$te

18-07-2008, 07:47

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

songoge

19-07-2008, 18:11

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

Lunghino? :D 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 ;) :p

$te

22-07-2008, 10:22

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

$te

22-10-2008, 09:47

http://it.geocities.com/antonio_di_stefano/Downloads/esempi.htm#Applicazione%20di%20esempio%20in%20C