Comment implémenter un réseau neuronal à deux couches et un modèle perceptron en Python

Cet article partagera avec vous comment utiliser Python pour implémenter un réseau neuronal à deux couches et un modèle perceptron Le contenu spécifique et les exemples sont les suivants pour votre référence

python 3.4 Parce que numpy est utilisé

Ici, nous implémentons d'abord un modèle perceptron pour obtenir la correspondance suivante

[[0,0,1], ——- 0 
 [0,1,1], ——- 1 
 [1,0,1], ——- 0 
 [1,1,1]] ——- 1

Comme le montrent les données ci-dessus : le L'entrée est à trois canaux, la sortie est à canal unique.

La fonction d'activation

ici nous utilisons la fonction sigmoïde f(x)=1/(1+exp(-x))

La dérivation dérivée est la suivante :

L0=W*X;
 z=f(L0);
 error=y-z;
 delta =error * f'(L0) * X;
 W=W+delta;

Le code python est le suivant :

import numpy as np
 
#sigmoid function
 
def nonlin(x, deriv = False):
  if(deriv==True):
    return x*(1-x)
  return 1/(1+np.exp(-x))
 
 
# input dataset
 
X=np.array([[0,0,1],
      [0,1,1],
      [1,0,1],
      [1,1,1]])
 
# output dataset
 
y=np.array([[0,1,0,1]]).T
 
#seed( ) 用于指定随机数生成时所用算法开始的整数值，
#如果使用相同的seed( )值，则每次生成的随即数都相同，
#如果不设置这个值，则系统根据时间来自己选择这个值，
#此时每次生成的随机数因时间差异而不同。
np.random.seed(1) 
 
# init weight value with mean 0
 
syn0 = 2*np.random.random((3,1))-1  
 
for iter in range(1000):
  # forward propagation
  L0=X
  L1=nonlin(np.dot(L0,syn0))
 
  # error
  L1_error=y-L1
 
  L1_delta = L1_error*nonlin(L1,True)
 
  # updata weight
  syn0+=np.dot(L0.T,L1_delta)
 
print("Output After Training:")
print(L1)

Il ressort des résultats que la relation correspondante est fondamentalement atteinte.

Ensuite, un réseau à deux couches est utilisé pour réaliser la tâche ci-dessus. Une couche cachée est ajoutée ici, et la couche cachée contient 4 neurones.

   
import numpy as np
 
def nonlin(x, deriv = False):
  if(deriv == True):
    return x*(1-x)
  else:
    return 1/(1+np.exp(-x))
 
#input dataset
X = np.array([[0,0,1],
       [0,1,1],
       [1,0,1],
       [1,1,1]])
 
#output dataset
y = np.array([[0,1,1,0]]).T
 
#the first-hidden layer weight value
syn0 = 2*np.random.random((3,4)) - 1
 
#the hidden-output layer weight value
syn1 = 2*np.random.random((4,1)) - 1
 
for j in range(60000):
  l0 = X     
  #the first layer,and the input layer
  l1 = nonlin(np.dot(l0,syn0))
  #the second layer,and the hidden layer
  l2 = nonlin(np.dot(l1,syn1))
  #the third layer,and the output layer
 
 
  l2_error = y-l2   
  #the hidden-output layer error
 
  if(j%10000) == 0:
    print "Error:"+str(np.mean(l2_error))
 
  l2_delta = l2_error*nonlin(l2,deriv = True)
 
  l1_error = l2_delta.dot(syn1.T)  
  #the first-hidden layer error
 
  l1_delta = l1_error*nonlin(l1,deriv = True)
 
  syn1 += l1.T.dot(l2_delta)
  syn0 += l0.T.dot(l1_delta)
 
print "outout after Training:"
print l2

Je crois que vous maîtrisez la méthode après avoir lu ces cas. Pour des informations plus intéressantes, veuillez prêter attention aux autres cas connexes. articles sur le site PHP chinois !

Lecture connexe :

Exemple de code détaillé de la façon dont PHP implémente la structure de données de pile et l'algorithme de correspondance entre crochets

Le plus populaire code en PHP Algorithme de correspondance de chaînes simple, algorithme de correspondance php_Tutoriel PHP

Le tutoriel d'algorithme de correspondance de chaînes le plus simple en php

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!