[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]

Originariamente inviato da gugoXX

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]

Originariamente inviato da gugoXX

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
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]

Originariamente inviato da _Claudio

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

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

[_Claudio]

Originariamente inviato da marco.r

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]

Originariamente inviato da _Claudio

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]

Originariamente inviato da CozzaAmara

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]

Originariamente inviato da _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.

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

[gugoXX]

Originariamente inviato da misterx

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]

Originariamente inviato da gugoXX

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).

Originariamente inviato da misterx

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

Originariamente inviato da gugoXX

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]

Originariamente inviato da marco.r

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 ()

Bioinformatica

[$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]

Originariamente inviato da 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.

no..preferirei "farle" io.
Ma tu te ne intendi?
Ecco un es (l'unico che finora ho trovato che funzioni:

Codice PHP:

# Back-Propagation Neural Networks
# 
# Written in Python.  See http://www.python.org/
# Placed in the public domain.
# Neil Schemenauer <[email protected]>

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/.../00000603.html
http://xoomer.virgilio.it/webidee/simulazioni.html
http://www.quantnet.org/forum/showthread.php?p=25431

[Albitexm]

Originariamente inviato da 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.

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).