[C/C++/Phyton/PHP] Appassionati di reti neurali?

[$te]

C'é qualcuno appassionato delle reti? Vorrei iniziare..ho letto un po' la teoria..ora vorrei passare alla pratica con una rete semplice..per poi passare alle piu complicate.
Avete già creato reti? Che applicazioni riuscite a trovare?

[gugoXX]

Lo sono stato, qualche anno fa.
Applicazioni riuscite il classico riconoscitore di grafia (solo stampatello)
Un paio di SOM

Applicazione non riuscita un predittore di andamento titoli finanziari
In pratica se chiedevo a mio cuginetto cosa fare alla fine rischiavo di guadagnare di piu'.
Da questo ho concluso che "secondo me" i dati di borsa non sono sufficienti per predire l'andamento della borsa. I giochi veri si fanno altrove.

[$te]

E ma per la borsa non é cosi semplice:P
Mi puoi aiutare ad iniziare con un esempio pf?
grazie

[CozzaAmara]

Applicazione non riuscita un predittore di andamento titoli finanziari
In pratica se chiedevo a mio cuginetto cosa fare alla fine rischiavo di guadagnare di piu'.
Da questo ho concluso che "secondo me" i dati di borsa non sono sufficienti per predire l'andamento della borsa. I giochi veri si fanno altrove.

Beh, in questo caso credo che il numero di variabili da considerare sia veramente troppo alto.

[Tommo]

Applicazione non riuscita un predittore di andamento titoli finanziari
In pratica se chiedevo a mio cuginetto cosa fare alla fine rischiavo di guadagnare di piu'.
Da questo ho concluso che "secondo me" i dati di borsa non sono sufficienti per predire l'andamento della borsa. I giochi veri si fanno altrove.

Non che gli analisti finanziari abbiano tante più probabilità di riuscita di tuo cugino :D
A giugno 2008 bisognava comprare per moltissimi...

Cmq le reti neurali sono molto interessanti, ma dopo averci giocato un pò ho concluso che hanno ben poco a che fare con l'"intelligenza"...

[_Claudio]

Visto l'overhead che presentano tali reti... per problemi complessi (predizione dell'andamento dei titoli in borsa) non convengono assolutamente.

Tenendo conto che poi tale ovh intacca anche il calcolo utile dopo una certa soglia.

Come teoria è un po' passata, a meno di ristrutturazioni pesanti cadrà in disuso a favore degli algoritmi genetici...

Però rimane un bel giochetto e comunque molto performante per problemi semplici e/o che non richiedono la convergenza ad un ottimo globale o "sub-globale" (fissata una soglia) come dico io.

[marco.r]

Come teoria è un po' passata, a meno di ristrutturazioni pesanti cadrà in disuso a favore degli algoritmi genetici...

:mbe:
i campi di applicazione di NN e GA non sono proprio gli stessi

[_Claudio]

:mbe:
i campi di applicazione di NN e GA non sono proprio gli stessi

No, ma dove si possono usare gli algoritmi genetici sono preferiti...

Solitamente dove si cerca una soluzione ottima, cioè l'output è la soluzione trovata e non i dati ottenibili dalla soluzione.

[shinya]

Come teoria è un po' passata
Non sono un esperto, ma mi sembra che la ricerca sia ancora parecchio attiva.
http://www.youtube.com/watch?v=AyzOUbkUf3M

[gugoXX]

Beh, in questo caso credo che il numero di variabili da considerare sia veramente troppo alto.

La mia considerazione finale e' stata che qualunque sia la quantita' di dati relativi ai movimenti di borsa che introduci nel sistema, questo non sara' sufficiente per predire i futuri movimenti di borsa.
Ovvero, le influenze piu' grandi sono da cercarsi al di fuori dell'insieme dei valori di borsa.
Ma questa appunto e' una mia considerazione smentibile.

[misterx]

Visto l'overhead che presentano tali reti... per problemi complessi (predizione dell'andamento dei titoli in borsa) non convengono assolutamente.

Tenendo conto che poi tale ovh intacca anche il calcolo utile dopo una certa soglia.

Come teoria è un po' passata, a meno di ristrutturazioni pesanti cadrà in disuso a favore degli algoritmi genetici...

Però rimane un bel giochetto e comunque molto performante per problemi semplici e/o che non richiedono la convergenza ad un ottimo globale o "sub-globale" (fissata una soglia) come dico io.

stai dicendo che seguire un corso di reti neurali non conviene più ?

[gugoXX]

stai dicendo che seguire un corso di reti neurali non conviene più ?

Secondo me hanno ancora molto da dire.
Applicazioni di nicchia per ora, ma dove ci sono tanti, tanti dati, le reti neurali hanno una buona applicazione.
P.es. Un amico ex collega di universita' mi ha detto come recentemente parecchie aziende nel campo energetico del calibro di EDF, per le quali lui e' consulente, hanno investito milionate per sistemi di intelligenza artificiale, principalmente reti neurali, per la previsione di tempo e temperature atmosferiche.
Poi non concordo con la critica sull'overhead. Dove vengono applicate le reti neurali vengono preferite proprio per la loro alta efficienza a confronto con i modelli completi.
Dove magari i dati non sono completi o completamente corretti, oppure dove addirittura non esiste un modello deterministico non se ne puo' fare quasi a meno.

[_Claudio]

La mia considerazione finale e' stata che qualunque sia la quantita' di dati relativi ai movimenti di borsa che introduci nel sistema, questo non sara' sufficiente per predire i futuri movimenti di borsa.
Ovvero, le influenze piu' grandi sono da cercarsi al di fuori dell'insieme dei valori di borsa.
Ma questa appunto e' una mia considerazione smentibile.

È vero, semplicemente perchè l'andamento della borsa dipende anche dagli avvenimenti nel mondo, dalla legislazione dei singoli paesi ecc... quindi i modelli di predizione o in qualche modo incorporano anche queste cose (!!!) oppure sono destinati a fallire nella loro applicazione a lungo termine (e si sa che in borsa a breve termine ci si perde, a meno di avere capitali abbastanza grossi).

stai dicendo che seguire un corso di reti neurali non conviene più ?

Secondo me hanno ancora molto da dire.
Applicazioni di nicchia per ora, ma dove ci sono tanti, tanti dati, le reti neurali hanno una buona applicazione.
P.es. Un amico ex collega di universita' mi ha detto come recentemente parecchie aziende nel campo energetico del calibro di EDF, per le quali lui e' consulente, hanno investito milionate per sistemi di intelligenza artificiale, principalmente reti neurali, per la previsione di tempo e temperature atmosferiche.
Poi non concordo con la critica sull'overhead. Dove vengono applicate le reti neurali vengono preferite proprio per la loro alta efficienza a confronto con i modelli completi.
Dove magari i dati non sono completi o completamente corretti, oppure dove addirittura non esiste un modello deterministico non se ne puo' fare quasi a meno.

Anche secondo me hanno molto e molto da dire, ma le limitazioni intrinseche ne fanno semplicemente prevedere molto facilmente gli orizzonti, tutto qui.

[B|4KWH|T3]

:mbe:
i campi di applicazione di NN e GA non sono proprio gli stessi

Vero, per non parlare del fatto che -anche se potrei sbagliarmi- di solito convergono alla soluzione più lentamente e sono molto rognosi.

Cmq, per applicazioni che di solito non vengono mai citate su questo forum (:p)

Bioinformatica (http://www.biocomp.unibo.it/fields.html)

[$te]

nessuno riesce a postarmi un esempio semplice di rete?

[$te]

niente?

[Johnn]

Ma intendi il codice o un'architettura?

Hai provato a vedere tool come Joone o Fann? Permettono di creare reti senza scrivere codice per mezzo di GUI. Per iniziare e non solo, potrebbero essere utili.

[$te]

Ma intendi il codice o un'architettura?

Hai provato a vedere tool come Joone o Fann? Permettono di creare reti senza scrivere codice per mezzo di GUI. Per iniziare e non solo, potrebbero essere utili.
no..preferirei "farle" io.
Ma tu te ne intendi?
Ecco un es (l'unico che finora ho trovato che funzioni:

# Back-Propagation Neural Networks
#
# Written in Python. See http://www.python.org/
# Placed in the public domain.
# Neil Schemenauer <nas@arctrix.com>

import math
import random
import string

random.seed(0)

# calculate a random number where: a <= rand < b
def rand(a, b):
return (b-a)*random.random() + a

# Make a matrix (we could use NumPy to speed this up)
def makeMatrix(I, J, fill=0.0):
m = []
for i in range(I):
m.append([fill]*J)
return m

# our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)
def sigmoid(x):
return math.tanh(x)

# derivative of our sigmoid function, in terms of the output (i.e. y)
def dsigmoid(y):
return 1.0 - y**2

class NN:
def __init__(self, ni, nh, no):
# number of input, hidden, and output nodes
self.ni = ni + 1 # +1 for bias node
self.nh = nh
self.no = no

# activations for nodes
self.ai = [1.0]*self.ni
self.ah = [1.0]*self.nh
self.ao = [1.0]*self.no

# create weights
self.wi = makeMatrix(self.ni, self.nh)
self.wo = makeMatrix(self.nh, self.no)
# set them to random vaules
for i in range(self.ni):
for j in range(self.nh):
self.wi[i][j] = rand(-0.2, 0.2)
for j in range(self.nh):
for k in range(self.no):
self.wo[j][k] = rand(-2.0, 2.0)

# last change in weights for momentum
self.ci = makeMatrix(self.ni, self.nh)
self.co = makeMatrix(self.nh, self.no)

def update(self, inputs):
if len(inputs) != self.ni-1:
raise ValueError, 'wrong number of inputs'

# input activations
for i in range(self.ni-1):
#self.ai[i] = sigmoid(inputs[i])
self.ai[i] = inputs[i]

# hidden activations
for j in range(self.nh):
sum = 0.0
for i in range(self.ni):
sum = sum + self.ai[i] * self.wi[i][j]
self.ah[j] = sigmoid(sum)

# output activations
for k in range(self.no):
sum = 0.0
for j in range(self.nh):
sum = sum + self.ah[j] * self.wo[j][k]
self.ao[k] = sigmoid(sum)

return self.ao[:]


def backPropagate(self, targets, N, M):
if len(targets) != self.no:
raise ValueError, 'wrong number of target values'

# calculate error terms for output
output_deltas = [0.0] * self.no
for k in range(self.no):
error = targets[k]-self.ao[k]
output_deltas[k] = dsigmoid(self.ao[k]) * error

# calculate error terms for hidden
hidden_deltas = [0.0] * self.nh
for j in range(self.nh):
error = 0.0
for k in range(self.no):
error = error + output_deltas[k]*self.wo[j][k]
hidden_deltas[j] = dsigmoid(self.ah[j]) * error

# update output weights
for j in range(self.nh):
for k in range(self.no):
change = output_deltas[k]*self.ah[j]
self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k]
self.co[j][k] = change
#print N*change, M*self.co[j][k]

# update input weights
for i in range(self.ni):
for j in range(self.nh):
change = hidden_deltas[j]*self.ai[i]
self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j]
self.ci[i][j] = change

# calculate error
error = 0.0
for k in range(len(targets)):
error = error + 0.5*(targets[k]-self.ao[k])**2
return error


def test(self, patterns):
for p in patterns:
print p[0], '->', self.update(p[0])

def weights(self):
print 'Input weights:'
for i in range(self.ni):
print self.wi[i]
print
print 'Output weights:'
for j in range(self.nh):
print self.wo[j]

def train(self, patterns, iterations=1000, N=0.5, M=0.1):
# N: learning rate
# M: momentum factor
for i in xrange(iterations):
error = 0.0
for p in patterns:
inputs = p[0]
targets = p[1]
self.update(inputs)
error = error + self.backPropagate(targets, N, M)
if i % 100 == 0:
print 'error %-14f' % error


def demo():
# Teach network XOR function

pat = [
[[0,1,1,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,1,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[0,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,0,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,1,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,0,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,0,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
0,0,0,0,1], [1]],

[[1,1,1,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,1,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,0,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,1,1,0,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[0,1,1,1,0,
1,1,0,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[0,1,1,1,0,
1,1,0,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,1,1,1,
1,0,0,0,1,
1,0,0,0,1], [1]],

[[0,1,1,1,0,
1,1,0,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [0]],

[[0,1,1,1,0,
1,1,0,1,1,
1,1,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [0]],

[[0,1,1,1,0,
1,1,0,1,1,
1,1,0,0,1,
1,0,0,1,1,
1,0,0,0,0,
1,0,0,0,1,
1,0,0,0,1], [0]],

[[0,1,0,0,0,
0,1,0,1,1,
0,1,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
0,0,0,0,1,
0,0,0,0,1], [0]],

[[1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1], [0]],

[[1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,1,
1,0,0,0,1,
1,0,0,0,1], [0]]
]

pat2 = [
[[1,1,1,1,1,
1,0,0,0,1,
0,0,0,0,1,
1,0,0,0,1,
1,1,1,1,1,
1,0,0,0,0,
1,0,0,0,1]],
]


# create a network with two input, two hidden, and one output nodes
n = NN(35, 3, 1)
# train it with some patterns
n.train(pat)
# test it
n.test(pat2)



if __name__ == '__main__':
demo()


Non ho ben capito il compito dei hidden..

[Albitexm]

Ti consiglierei di andare a vederti "il metodo montecarlo" :
http://it.wikipedia.org/wiki/Metodo_Monte_Carlo
http://www.economia.unimi.it/projects/finance/mc.pdf
http://www.sissa.it/~baroni/MC.html
http://livedocs.adobe.com/flashlite/2_it/main/00000603.html
http://xoomer.virgilio.it/webidee/simulazioni.html
http://www.quantnet.org/forum/showthread.php?p=25431

[Albitexm]

Lo sono stato, qualche anno fa.
Applicazioni riuscite il classico riconoscitore di grafia (solo stampatello)
Un paio di SOM

Applicazione non riuscita un predittore di andamento titoli finanziari
In pratica se chiedevo a mio cuginetto cosa fare alla fine rischiavo di guadagnare di piu'.
Da questo ho concluso che "secondo me" i dati di borsa non sono sufficienti per predire l'andamento della borsa. I giochi veri si fanno altrove.

Vorrei solo fare notare, che l'ultimo crollo di borsa era stato da più analisti previsto. Avevo io, come credo molti, assistito a interviste di economisti che predicevano il crollo finanziario del sistema dovuto ai mutui supr.. come cavolo si chiamavano. E non cera bisogno di analisi computerizzate per prevederlo. C'è stata una speculazione e come al solito molti che hanno giocato sporco (e si sono arrichiti facilmente). Con l'analisi statistica, in borsa come in alcuni giochi, si può pianificare un piccolo rendimento sul lungo termine. E' non c'è bisogno del Pc, questi può solo aiutarti nel lavoro di calcolo.
Ma se uno vuol "giocare" in borsa, come "giocare" al casinò, com'è insito nel termine stesso "giocare",può avere grandi guadagni, come enormi perdite, senza nessuna sicurezza.
Con la statistica, avrai un piccolo rendimento, risultato di costanza, dedizione, calcolo, impegno (noia).. insomma lavoro. Ma non diventerai certo ricco.
In ogni caso, i crolli di borsa o le crisi finanziarie, non sono sicuramente addebitabili a errori di calcolo dei computer o sbagliate pevisioni degli analisti (seri).

[$te]

Ti consiglierei di andare a vederti "il metodo montecarlo" :
http://it.wikipedia.org/wiki/Metodo_Monte_Carlo
http://www.economia.unimi.it/projects/finance/mc.pdf
http://www.sissa.it/~baroni/MC.html
http://livedocs.adobe.com/flashlite/2_it/main/00000603.html
http://xoomer.virgilio.it/webidee/simulazioni.html
http://www.quantnet.org/forum/showthread.php?p=25431

perché il metodo di montecarlo mi consigli?

[Johnn]

no..preferirei "farle" io.
Ma tu te ne intendi?

Se vuoi implementarti una rete neurale da zero, ovviamente lo puoi fare, ma lo vedo più un esercizio di programmazione che non un utilizzo reale della rete neurale, perché prima di arrivare ad un insieme di funzionalità sufficiente passarebbe abbastanza tempo. Quindi perché non usare qualcosa di già pronto?
Tipo:
http://www.jooneworld.com/docs/sampleEngine.html

Poi la rete la fai tu come vuoi, ma hai già parecchi strumenti a disposizione.
Se non ti piace Java ci sono altri tool simili in altri linguggi.


Non ho ben capito il compito dei hidden..

I neuroni hidden sono quelli compresi tra l'insieme dei neuroni di input e di output. Ovviamente prendono parte al calcolo che svolge la rete e anzi sono la parte principale: per capirci, più ce ne sono più la rete è in grado di svolgere compiti difficili.