Aperçu de la mise en œuvre des réseaux de neurones
Les réseaux de neurones artificiels sont inspirés des réseaux de neurones biologiques. Les réseaux de neurones aident à résoudre les problèmes sans être programmés avec les règles et conditions spécifiques au problème. Ce sont des modèles génériques avec la plupart des calculs mathématiques complexes comme BlackBox. Les différents types de réseaux neuronaux sont comme le réseau neuronal à convolution, le réseau neuronal récurrent, le réseau neuronal Feedforward, le perceptron multicouche et bien d'autres. Dans ce sujet, nous sommes prêts à en apprendre davantage sur la mise en œuvre des réseaux de neurones.
L'architecture des réseaux de neurones
Il y a 3 couches principalement dans les réseaux de neurones.
- Couche d'entrée
- Couches masquées
- Couche de sortie
1. Couche d'entrée: La couche d'entrée contient les neurones pour l'entrée des entités. Il existe également un biais ajouté à la couche d'entrée en plus des fonctionnalités. Donc, s'il y a n entités, la couche d'entrée contient n + 1 neurones.
2. Couche cachée: les couches cachées sont les couches intermédiaires entre les couches d'entrée et de sortie. Il peut y avoir n'importe quel nombre de couches cachées. Le réseau avec plus d'une couche cachée est appelé réseaux de neurones profonds. Les neurones de la couche cachée reçoivent une entrée de la couche d'entrée et ils fournissent une sortie à la couche de sortie.
3. Couche de sortie: La couche de sortie contient le nombre de neurones basé sur le nombre de classes de sortie. S'il s'agit d'un problème de classification multi-classes, il contient alors un nombre de neurones égal au nombre de classes. Pour la classification binaire, il contient un neurone.
Les entrées sont multipliées par des poids puis introduites dans la couche cachée suivante. Le biais est également donné en entrée avec les entrées pondérées. La somme pondérée passe par une fonction non linéaire appelée fonction d'activation.
Exemple d'implémentation
Voici l'exemple de mise en œuvre mentionné ci-dessous
Installation des bibliothèques
Il existe de nombreuses bibliothèques intégrées pour la mise en œuvre de réseaux de neurones artificiels dans différents langages de programmation. Ici, nous parlerons de deux des célèbres bibliothèques tensorflow et Keras utilisant python comme langage de programmation pour la mise en œuvre de réseaux de neurones. Keras est une API de niveau supérieur basée sur tensorflow ou theano en tant que backend. Il est beaucoup plus facile à mettre en œuvre. Vous pouvez choisir n'importe quelle bibliothèque pour votre modèle. Il y en a d'autres également disponibles comme PyTorch, theano, Caffe et bien d'autres.
Pour installer le tensorflow / Keras à l'aide de pip, exécutez la commande suivante:
pip install tensorflow
pip install Keras
Alternativement, il peut être installé à l'aide de la commande conda,
conda install -c conda-forge tensorflow
conda install -c conda-forge keras
la mise en oeuvre
Ici, nous parlerons de Keras pour la génération des modèles d'apprentissage profond. Il s'agit d'une bibliothèque d'apprentissage en profondeur Python open source.
- Importez l'ensemble de données MNIST disponible. MNIST est l'ensemble de données de chiffres manuscrits de chiffres anglais.
from tensorflow.examples.tutorials.mnist import input_data
train_images = mnist.train.images.reshape(mnist.train.images.shape(0), image_rows, image_cols, 1)
test_images = mnist.test.images.reshape(mnist.test.images.shape(0), image_rows, image_cols, 1)
- Initialisez les paramètres et hyperparamètres nécessaires au modèle.
- Ensuite, initialisez le modèle d'apprentissage en profondeur.
model = Sequential()
- Ajoutez une couche de convolution, une couche d'activation et une couche de regroupement maximal pour chacune des couches de convolution que nous ajoutons entre les couches d'entrée et de sortie (couches masquées). Ici, nous ajoutons deux couches de convolution.
model.add(Convolution2D(num_filters, conv_kernel_size(0), conv_kernel_size(1), border_mode='valid', input_shape=imag_shape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=max_pool_size))
- Différentes fonctions d'activation peuvent être utilisées selon le problème. Certaines fonctions d'activation courantes sont l'activation relu, l'activation tanh relu qui fuit et bien d'autres.
- Vient ensuite une couche entièrement connectée avant la couche dense. Ils compilent les données extraites par les couches précédentes pour former la sortie finale.
- La dimension de la couche en sortie dépend du nombre de classes. Les fonctions d'activation utilisées pour la couche de sortie sont généralement l'activation sigmoïde pour la classification binaire et l'activation softmax pour la classification multi-classes.
model.add(Dense(num_classes))
model.add(Activation('softmax'))
Le code complet pour le réseau neuronal convolutionnel profond pour la classification des données MNIST est comme ci-dessous.
from tensorflow.examples.tutorials.mnist import input_data
from keras.models import Sequential from keras.layers import Dense, Dropout, Activation, Flatten from keras.layers import Convolution2D, MaxPooling2D
# we use TF helper function to pull down the data from the MNIST site mnist_data = input_data.read_data_sets("MNIST_data/", one_hot=True)
img_rows = 28
img_cols = 28
# Reshape training and test images to 28x28x1
train_images = mnist_data.train.images.reshape(mnist_data.train.images.shape(0), img_rows, img_cols, 1)
test_images = mnist_data.test.images.reshape(mnist_data.test.images.shape(0), img_rows, img_cols, 1)
num_of_filters = 32 # No. of conv filters maxPoolSize = (2, 2) # shape of max_pool convKrnSize = (3, 3) # conv kernel shape imgShape = (28, 28, 1) num_of_classes = 10
dropProb = 0.5
model = Sequential()
# define layers in NN
# Define 1st convolution layer.
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1), border_mode='valid', input_shape=imgShape))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
# 2nd Convolution Layer
model.add(Convolution2D(num_of_filters, convKrnSize(0), convKrnSize(1))) model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=maxPoolSize))
#Fully Connected Layer model.add(Flatten())
model.add(Dense(128)) #Fully connected layer in Keras model.add(Activation('relu'))
# Dropout some neurons to reduce overfitting model.add(Dropout(dropProb))
#Readout Layer model.add(Dense(num_of_classes))
model.add(Activation('softmax'))
# Compile the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=('accuracy'))
# Training settings batch_size = 128
num_of_epoch = 2
# fit the training data to the model.
model.fit(train_images, mnist_data.train.labels, batch_size=batch_size,
nb_epoch=num_of_epoch, verbose=1, validation_data=(test_images, mnist_data.test.labels))
# predict the test_data using the model
test_labels_predicted = model.predict_classes(test_images)
# To get the predicted labels of all test images for i in range(len(test_images)):
print ("Image () -> Label ()".format(i+1, test_labels_predicted(0)))
Formation
La formation du modèle ressemble,
Conclusion - Mise en place de réseaux de neurones
Les réseaux de neurones offrent un moyen facile de résoudre les problèmes de classification ou de régression dans l'apprentissage automatique lorsque l'espace des caractéristiques des échantillons est très grand, principalement pour les images de grande taille ou d'autres multimédias ou signaux.
Articles recommandés
Ceci est un guide pour la mise en œuvre des réseaux de neurones. Nous discutons ici de l'architecture et de la mise en œuvre des réseaux de neurones avec un modèle de formation et un exemple de code. Vous pouvez également consulter l'article suivant pour en savoir plus -
- Classification du réseau neuronal
- Qu'est-ce que les réseaux de neurones?
- Réseaux de neurones convolutifs
- Algorithmes de réseau neuronal
- Graphiques 2D en Java