Esempio di rete neurale Codice sorgente (preferibilmente Python)

Question

Mi chiedo se qualcuno abbia qualche codice di esempio di una rete neurale in python. Se qualcuno è a conoscenza di una sorta di tutorial con una soluzione completa, sarebbe fantastico, ma solo la sorgente di esempio sarebbe grandiosa!

Grazie

Answer 1

Dai uno sguardo allo Learning from Clicks dal libro Programming Collective Intelligence.

Answer 2

Ecco un semplice esempio di Armin Rigo: http://codespeak.net/pypy/dist/demo/bpnn.py. Se si desidera utilizzare materiale più sofisticato, esiste anche http://pybrain.org.

Modifica: Il collegamento è interrotto. Ad ogni modo, il modo attuale di andare con le reti neurali in Python è probabilmente Theano.

Answer 3

Si potrebbe voler dare un'occhiata a Monte:

Monte (python) is a Python framework for building gradient based learning machines, like neural networks, conditional random fields, logistic regression, etc. Monte contains modules (that hold parameters, a cost-function and a gradient-function) and trainers (that can adapt a module's parameters by minimizing its cost-function on training data).

Modules are usually composed of other modules, which can in turn contain other modules, etc. Gradients of decomposable systems like these can be computed with back-propagation.

Answer 4

Abbiamo trovato questo discussione interresting sul forum di Ubuntu http://ubuntuforums.org/showthread.php?t=320257

import time 
import random 

# Learning rate: 
# Lower = slower 
# Higher = less precise 
rate=.2 

# Create random weights 
inWeight=[random.uniform(0, 1), random.uniform(0, 1)] 

# Start neuron with no stimuli 
inNeuron=[0.0, 0.0] 

# Learning table (or gate) 
test =[[0.0, 0.0, 0.0]] 
test+=[[0.0, 1.0, 1.0]] 
test+=[[1.0, 0.0, 1.0]] 
test+=[[1.0, 1.0, 1.0]] 

# Calculate response from neural input 
def outNeuron(midThresh): 
    global inNeuron, inWeight 
    s=inNeuron[0]*inWeight[0] + inNeuron[1]*inWeight[1] 
    if s>midThresh: 
     return 1.0 
    else: 
     return 0.0 

# Display results of test 
def display(out, real): 
     if out == real: 
      print str(out)+" should be "+str(real)+" ***" 
     else: 
      print str(out)+" should be "+str(real) 

while 1: 
    # Loop through each lesson in the learning table 
    for i in range(len(test)): 
     # Stimulate neurons with test input 
     inNeuron[0]=test[i][0] 
     inNeuron[1]=test[i][1] 
     # Adjust weight of neuron #1 
     # based on feedback, then display 
     out = outNeuron(2) 
     inWeight[0]+=rate*(test[i][2]-out) 
     display(out, test[i][2]) 
     # Adjust weight of neuron #2 
     # based on feedback, then display 
     out = outNeuron(2) 
     inWeight[1]+=rate*(test[i][2]-out) 
     display(out, test[i][2]) 
     # Delay 
     time.sleep(1) 

EDIT: c'è anche un quadro di nome chainer https://pypi.python.org/pypi/chainer/1.0.0

Answer 5

Ecco un tutor rete neurale probabilistica al: http://www.youtube.com/watch?v=uAKu4g7lBxU

E la mia implementazione di Python:

import math 

data = {'o' : [(0.2, 0.5), (0.5, 0.7)], 
     'x' : [(0.8, 0.8), (0.4, 0.5)], 
     'i' : [(0.8, 0.5), (0.6, 0.3), (0.3, 0.2)]} 

class Prob_Neural_Network(object): 
    def __init__(self, data): 
     self.data = data 

    def predict(self, new_point, sigma): 
     res_dict = {} 
     np = new_point 
     for k, v in self.data.iteritems(): 
      res_dict[k] = sum(self.gaussian_func(np[0], np[1], p[0], p[1], sigma) for p in v) 
     return max(res_dict.iteritems(), key=lambda k : k[1]) 

    def gaussian_func(self, x, y, x_0, y_0, sigma): 
     return math.e ** (-1 *((x - x_0) ** 2 + (y - y_0) ** 2)/((2 * (sigma ** 2)))) 

prob_nn = Prob_Neural_Network(data) 
res = prob_nn.predict((0.2, 0.6), 0.1) 

Risultato:

>>> res 
('o', 0.6132686067117191)