AI avec Python - Réseaux de neurones

Les réseaux neuronaux sont des dispositifs informatiques parallèles qui tentent de créer un modèle informatique du cerveau. L'objectif principal derrière est de développer un système pour effectuer diverses tâches de calcul plus rapidement que les systèmes traditionnels. Ces tâches incluent la reconnaissance et la classification de modèles, l'approximation, l'optimisation et le clustering de données.

Qu'est-ce que les réseaux de neurones artificiels (ANN)

Le réseau de neurones artificiels (ANN) est un système informatique efficace dont le thème central est emprunté à l'analogie des réseaux de neurones biologiques. Les ANN sont également appelés systèmes neuronaux artificiels, systèmes de traitement distribués parallèles et systèmes connexionnistes. ANN acquiert une grande collection d'unités qui sont interconnectées selon un certain modèle pour permettre les communications entre elles. Ces unités, également appeléesnodes ou neurons, sont des processeurs simples qui fonctionnent en parallèle.

Chaque neurone est connecté à un autre neurone via un connection link. Chaque lien de connexion est associé à un poids contenant les informations sur le signal d'entrée. Il s'agit de l'information la plus utile pour les neurones pour résoudre un problème particulier car leweightexcite ou inhibe généralement le signal qui est communiqué. Chaque neurone a son état interne qui s'appelleactivation signal. Les signaux de sortie, qui sont produits après la combinaison des signaux d'entrée et de la règle d'activation, peuvent être envoyés à d'autres unités.

Si vous souhaitez étudier en détail les réseaux de neurones, vous pouvez suivre le lien - Réseau de neurones artificiels .

Installer des packages utiles

Pour créer des réseaux de neurones en Python, nous pouvons utiliser un package puissant pour les réseaux de neurones appelé NeuroLab. Il s'agit d'une bibliothèque d'algorithmes de réseaux de neurones de base avec des configurations de réseau flexibles et des algorithmes d'apprentissage pour Python. Vous pouvez installer ce package à l'aide de la commande suivante sur l'invite de commande -

pip install NeuroLab

Si vous utilisez l'environnement Anaconda, utilisez la commande suivante pour installer NeuroLab -

conda install -c labfabulous neurolab

Création de réseaux de neurones

Dans cette section, construisons des réseaux de neurones en Python en utilisant le package NeuroLab.

Classificateur basé sur Perceptron

Les perceptrons sont les éléments constitutifs de l'ANN. Si vous voulez en savoir plus sur Perceptron, vous pouvez suivre le lien - artificial_neural_network

Voici une exécution pas à pas du code Python pour créer un classificateur basé sur un simple réseau neuronal perceptron -

Importez les packages nécessaires comme indiqué -

import matplotlib.pyplot as plt
import neurolab as nl

Entrez les valeurs d'entrée. Notez qu'il s'agit d'un exemple d'apprentissage supervisé, vous devrez donc également fournir des valeurs cibles.

input = [[0, 0], [0, 1], [1, 0], [1, 1]]
target = [[0], [0], [0], [1]]

Créez le réseau avec 2 entrées et 1 neurone -

net = nl.net.newp([[0, 1],[0, 1]], 1)

Maintenant, formez le réseau. Ici, nous utilisons la règle Delta pour l'entraînement.

error_progress = net.train(input, target, epochs=100, show=10, lr=0.1)

Maintenant, visualisez la sortie et tracez le graphique -

plt.figure()
plt.plot(error_progress)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.grid()
plt.show()

Vous pouvez voir le graphique suivant montrant la progression de l'entraînement à l'aide de la métrique d'erreur -

Réseaux de neurones monocouche

Dans cet exemple, nous créons un réseau de neurones à couche unique composé de neurones indépendants agissant sur les données d'entrée pour produire la sortie. Notez que nous utilisons le fichier texte nomméneural_simple.txt comme notre entrée.

Importez les packages utiles comme indiqué -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Chargez l'ensemble de données comme suit -

input_data = np.loadtxt(“/Users/admin/neural_simple.txt')

Voici les données que nous allons utiliser. Notez que dans ces données, les deux premières colonnes sont les caractéristiques et les deux dernières colonnes sont les étiquettes.

array([[2. , 4. , 0. , 0. ],
      [1.5, 3.9, 0. , 0. ],
      [2.2, 4.1, 0. , 0. ],
      [1.9, 4.7, 0. , 0. ],
      [5.4, 2.2, 0. , 1. ],
      [4.3, 7.1, 0. , 1. ],
      [5.8, 4.9, 0. , 1. ],
      [6.5, 3.2, 0. , 1. ],
      [3. , 2. , 1. , 0. ],
      [2.5, 0.5, 1. , 0. ],
      [3.5, 2.1, 1. , 0. ],
      [2.9, 0.3, 1. , 0. ],
      [6.5, 8.3, 1. , 1. ],
      [3.2, 6.2, 1. , 1. ],
      [4.9, 7.8, 1. , 1. ],
      [2.1, 4.8, 1. , 1. ]])

Maintenant, séparez ces quatre colonnes en 2 colonnes de données et 2 étiquettes -

data = input_data[:, 0:2]
labels = input_data[:, 2:]

Tracez les données d'entrée à l'aide des commandes suivantes -

plt.figure()
plt.scatter(data[:,0], data[:,1])
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Input data')

Maintenant, définissez les valeurs minimale et maximale pour chaque dimension comme indiqué ici -

dim1_min, dim1_max = data[:,0].min(), data[:,0].max()
dim2_min, dim2_max = data[:,1].min(), data[:,1].max()

Ensuite, définissez le nombre de neurones dans la couche de sortie comme suit -

nn_output_layer = labels.shape[1]

Maintenant, définissez un réseau de neurones monocouche -

dim1 = [dim1_min, dim1_max]
dim2 = [dim2_min, dim2_max]
neural_net = nl.net.newp([dim1, dim2], nn_output_layer)

Entraînez le réseau neuronal avec le nombre d'époques et le taux d'apprentissage comme indiqué -

error = neural_net.train(data, labels, epochs = 200, show = 20, lr = 0.01)

Maintenant, visualisez et tracez la progression de l'entraînement à l'aide des commandes suivantes -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Training error')
plt.title('Training error progress')
plt.grid()
plt.show()

Maintenant, utilisez les points de données de test dans le classificateur ci-dessus -

print('\nTest Results:')
data_test = [[1.5, 3.2], [3.6, 1.7], [3.6, 5.7],[1.6, 3.9]] for item in data_test:
   print(item, '-->', neural_net.sim([item])[0])

Vous pouvez trouver les résultats du test comme indiqué ici -

[1.5, 3.2] --> [1. 0.]
[3.6, 1.7] --> [1. 0.]
[3.6, 5.7] --> [1. 1.]
[1.6, 3.9] --> [1. 0.]

Vous pouvez voir les graphiques suivants comme la sortie du code discuté jusqu'à présent -

Réseaux de neurones multicouches

Dans cet exemple, nous créons un réseau neuronal multicouche composé de plusieurs couches pour extraire les modèles sous-jacents dans les données d'entraînement. Ce réseau neuronal multicouche fonctionnera comme un régresseur. Nous allons générer des points de données basés sur l'équation: y = 2x ² +8.

Importez les packages nécessaires comme indiqué -

import numpy as np
import matplotlib.pyplot as plt
import neurolab as nl

Générez un point de données basé sur l'équation mentionnée ci-dessus -

min_val = -30
max_val = 30
num_points = 160
x = np.linspace(min_val, max_val, num_points)
y = 2 * np.square(x) + 8
y /= np.linalg.norm(y)

Maintenant, remodelez cet ensemble de données comme suit -

data = x.reshape(num_points, 1)
labels = y.reshape(num_points, 1)

Visualisez et tracez l'ensemble de données d'entrée à l'aide des commandes suivantes -

plt.figure()
plt.scatter(data, labels)
plt.xlabel('Dimension 1')
plt.ylabel('Dimension 2')
plt.title('Data-points')

Maintenant, construisez le réseau neuronal ayant deux couches cachées avec neurolab avec ten neurones dans la première couche cachée, six dans la deuxième couche cachée et one dans la couche de sortie.

neural_net = nl.net.newff([[min_val, max_val]], [10, 6, 1])

Maintenant, utilisez l'algorithme d'apprentissage du gradient -

neural_net.trainf = nl.train.train_gd

Maintenant, formez le réseau dans le but d'apprendre sur les données générées ci-dessus -

error = neural_net.train(data, labels, epochs = 1000, show = 100, goal = 0.01)

Maintenant, exécutez les réseaux de neurones sur les points de données d'entraînement -

output = neural_net.sim(data)
y_pred = output.reshape(num_points)

Maintenant tâche de tracé et de visualisation -

plt.figure()
plt.plot(error)
plt.xlabel('Number of epochs')
plt.ylabel('Error')
plt.title('Training error progress')

Nous allons maintenant tracer la sortie réelle par rapport à la sortie prévue -

x_dense = np.linspace(min_val, max_val, num_points * 2)
y_dense_pred = neural_net.sim(x_dense.reshape(x_dense.size,1)).reshape(x_dense.size)
plt.figure()
plt.plot(x_dense, y_dense_pred, '-', x, y, '.', x, y_pred, 'p')
plt.title('Actual vs predicted')
plt.show()

À la suite des commandes ci-dessus, vous pouvez observer les graphiques comme indiqué ci-dessous -