Exemple de réseau de neurones Code source (de préférence Python)

Je me demande si quelqu'un a un exemple de code d'un réseau de Neurones en python. Si quelqu'un connais une sorte de tutoriel avec une solution complète, ce serait génial, mais juste un exemple serait très bien aussi!

Grâce

source d'informationauteur Fifth-Edition

  2. 7

    Voici un exemple simple de Armin Rigo: http://codespeak.net/pypy/dist/demo/bpnn.py.
    Si vous souhaitez utiliser plus sophistiqué des trucs, il y a aussi http://pybrain.org.

    Edit: Lien est rompu. De toute façon, la façon actuelle d'aller avec les réseaux de neurones en python est probablement Théano.

  3. 4

    Trouve cela interressant discusion sur ubuntu forums
    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: il est aussi un cadre nommé programme de chaînage
    https://pypi.python.org/pypi/chainer/1.0.0

  4. 2

    Vous voudrez peut-être jeter un oeil à Monte:

    Monte (python) est un framework en Python
    pour la construction de gradient en fonction de l'apprentissage
    les machines, comme les réseaux de neurones,
    conditionnel champs aléatoires, logistique
    régression, etc. Monte contient
    les modules (qui détiennent des paramètres, une
    coût-fonction et un gradient de la fonction)
    et des formateurs (qui peut s'adapter à un
    module de paramètres en minimisant ses
    coût en fonction des données de formation).

    Modules sont généralement composées d'autres
    les modules, qui peuvent à leur tour contenir des
    d'autres modules, etc. Des Gradients de
    décomposable systèmes comme ceux-ci peuvent être
    calculé avec rétro-propagation.

  5. 2

    Ici est un réseau de neurones probabilistes tutoriel :http://www.youtube.com/watch?v=uAKu4g7lBxU

    Et mon Python de mise en Œuvre:

    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)

    Résultat:

    >>> res
('o', 0.6132686067117191)