Tutoriel de réseau de neurones artificiels avec des exemples TensorFlow ANN

Qu'est-ce qu'un réseau de neurones artificiels ?

An Réseau neuronal artificiel (ANN) est un système informatique inspiré des réseaux de neurones biologiques permettant de créer des cerveaux artificiels basés sur un ensemble d'unités connectées appelées neurones artificiels. Il est conçu pour analyser et traiter les informations comme des humains. Le réseau de neurones artificiels possède des capacités d'auto-apprentissage pour produire de meilleurs résultats à mesure que davantage de données sont disponibles.

Réseau neuronal artificiel
Réseau neuronal artificiel

Un réseau de neurones artificiels (ANN) est composé de quatre objets principaux :

  • Couches: tout l'apprentissage se fait dans les couches. Il y a 3 couches 1) Entrée 2) Cachée et 3) Sortie
  • Caractéristique et étiquette: Données d'entrée sur le réseau (caractéristiques) et sortie du réseau (étiquettes)
  • Fonction de perte: Métrique utilisée pour estimer la performance de la phase d'apprentissage
  • Optimizer: Améliorer l'apprentissage en mettant à jour les connaissances dans le réseau

Un réseau de neurones prendra les données d’entrée et les regroupera dans un ensemble de couches. Le réseau doit évaluer ses performances avec une fonction de perte. La fonction de perte donne au réseau une idée du chemin qu'il doit emprunter avant de maîtriser les connaissances. Le réseau doit améliorer ses connaissances à l'aide d'un optimiseur.

Si vous jetez un œil à la figure ci-dessus, vous comprendrez le mécanisme sous-jacent.

Le programme prend certaines valeurs d'entrée et les place dans deux couches entièrement connectées. Imaginez que vous ayez un problème de mathématiques, la première chose à faire est de lire le chapitre correspondant pour résoudre le problème. Vous appliquez vos nouvelles connaissances pour résoudre le problème. Il y a de fortes chances que vous n'obteniez pas un très bon score. C'est la même chose pour un réseau. La première fois qu’il voit les données et fait une prédiction, celle-ci ne correspondra pas parfaitement aux données réelles.

Pour améliorer ses connaissances, le réseau utilise un optimiseur. Dans notre analogie, un optimiseur peut être considéré comme une relecture du chapitre. Vous obtenez de nouvelles idées/leçons en relisant. De même, le réseau utilise l'optimiseur, met à jour ses connaissances et teste ses nouvelles connaissances pour vérifier ce qu'il lui reste à apprendre. Le programme répétera cette étape jusqu'à ce qu'il produise l'erreur la plus basse possible.

Dans notre analogie avec un problème mathématique, cela signifie que vous lisez le chapitre du manuel plusieurs fois jusqu'à ce que vous compreniez parfaitement le contenu du cours. Même après avoir lu plusieurs fois, si vous continuez à faire des erreurs, cela signifie que vous avez atteint la capacité de connaissances avec le matériel actuel. Vous devez utiliser un manuel différent ou tester une méthode différente pour améliorer votre score. Pour un réseau de neurones, c'est le même processus. Si l’erreur est loin de 100%, mais que la courbe est plate, c’est avec l’architecture actuelle ; il ne peut rien apprendre d'autre. Le réseau doit être mieux optimisé pour améliorer les connaissances.

Architecture de réseau de neurones

L'architecture du réseau de neurones artificiels se compose des éléments suivantswing Composants:

  • Couches
  • Fonction d'activation
  • Fonction de perte
  • Optimizer

Couches

Une couche est l’endroit où tout l’apprentissage a lieu. À l’intérieur d’une couche, il y a une quantité infinie de poids (neurones). Un réseau neuronal typique est souvent traité par des couches densément connectées (également appelées couches entièrement connectées). Cela signifie que toutes les entrées sont connectées à la sortie.

Un réseau neuronal typique prend un vecteur d'entrée et un scalaire qui contient les étiquettes. La configuration la plus confortable est une classification binaire avec seulement deux classes : 0 et 1.

Le réseau prend une entrée, l'envoie à tous les nœuds connectés et calcule le signal avec un activation la fonction.

Architecture de réseau de neurones
Architecture de réseau de neurones

La figure ci-dessus illustre cette idée. La première couche contient les valeurs d'entrée de la deuxième couche, appelée couche cachée, reçoit l'entrée pondérée de la couche précédente

  1. Le premier nœud correspond aux valeurs d'entrée
  2. Le neurone est décomposé en partie d'entrée et en fonction d'activation. La partie gauche reçoit toutes les entrées de la couche précédente. La partie droite est la somme des entrées passées dans une fonction d'activation.
  3. Valeur de sortie calculée à partir des couches cachées et utilisée pour faire une prédiction. Pour le classement, il est égal au numéro de classe. Pour la régression, une seule valeur est prédite.

Fonction d'activation

La fonction d'activation d'un nœud définit la sortie à partir d'un ensemble d'entrées. Vous avez besoin d'une fonction d'activation pour permettre au réseau d'apprendre un modèle non linéaire. Une fonction d'activation courante est une Relu, Unité linéaire rectifiée. La fonction donne un zéro pour toutes les valeurs négatives.

Fonction d'activation

Les autres fonctions d'activation sont :

  • Linéaire par morceaux
  • Sigmoïde
  • Tanh
  • Relu qui fuit

La décision cruciale à prendre lors de la création d’un réseau de neurones est la suivante :

  • Combien de couches dans le réseau neuronal
  • Combien d'unités cachées pour chaque couche

Un réseau neuronal avec de nombreuses couches et unités cachées peut apprendre un complex représentation des données, mais cela rend le calcul du réseau très coûteux.

Fonction de perte

Après avoir défini les couches cachées et la fonction d'activation, vous devez spécifier la fonction de perte et l'optimiseur.

Pour la classification binaire, il est courant d'utiliser une fonction de perte d'entropie croisée binaire. Dans la régression linéaire, vous utilisez l’erreur quadratique moyenne.

La fonction de perte est une mesure importante pour estimer les performances de l'optimiseur. Pendant la formation, cette métrique sera minimisée. Vous devez sélectionner cette quantité avec soin en fonction du type de problème auquel vous êtes confronté.

Optimizer

La fonction de perte est une mesure des performances du modèle. L'optimiseur permettra d'améliorer les poids du réseau afin de diminuer les pertes. Il existe différents optimiseurs disponibles, mais le plus courant est la descente de gradient stochastique.

Les optimiseurs conventionnels sont :

  • Optimisation de la dynamique,
  • Dégradé accéléré Nesterov,
  • AdaGrad,
  • Optimisation Adam

Limites du réseau neuronal

Following sont les limites du réseau neuronal :

Surapprentissage

Un problème courant avec le complex Le réseau neuronal est la difficulté de généraliser des données invisibles. Un réseau neuronal avec de nombreux poids peut identifier des problèmes spécifiques.tails dans la rame mais conduit souvent à un surapprentissage. Si les données sont déséquilibrées au sein des groupes (c'est-à-dire pas assez de données disponibles dans certains groupes), le réseau apprendra très bien pendant la formation mais n'aura pas la capacité de généraliser un tel modèle à des données inédites.

Il existe un compromis en apprentissage automatique entre optimisation et généralisation.

Optimiser un modèle nécessite de trouver les meilleurs paramètres qui minimisent la perte de l'ensemble d'entraînement.

Cependant, la généralisation indique comment le modèle se comporte pour les données invisibles.

Pour empêcher le modèle de capturer des détails spécifiquestails ou des modèles indésirables des données d'entraînement, vous pouvez utiliser différentes techniques. La meilleure méthode consiste à disposer d’un ensemble de données équilibré avec une quantité suffisante de données. L'art de réduire le surapprentissage s'appelle régularisation. Passons en revue quelques techniques conventionnelles.

Taille du réseau

Un réseau neuronal comportant trop de couches et d’unités cachées est connu pour être très sophistiqué. Un moyen simple de réduire les complexLa particularité du modèle est de réduire sa taille. Il n’existe pas de bonne pratique pour définir le nombre de couches. Vous devez commencer avec une petite quantité de couche et augmenter sa taille jusqu'à ce que vous trouviez le modèle surajusté.

Régularisation du poids

Une technique standard pour éviter le surajustement consiste à ajouter des contraintes aux poids du réseau. La contrainte force la taille du réseau à ne prendre que de petites valeurs. La contrainte est ajoutée à la fonction de perte de l'erreur. Il existe deux types de régularisation :

L1 : Lasso : Le coût est proportionnel à la valeur absolue des coefficients de poids

L2 : Faîtage : Le coût est proportionnel au carré de la valeur des coefficients de poids

marginal

L'abandon est une technique étrange mais utile. Un réseau avec décrochage signifie que certains poids seront mis à zéro de manière aléatoire. Imaginez que vous disposez d'un tableau de poids [0.1, 1.7, 0.7, -0.9]. Si le réseau neuronal présente un décrochage, il deviendra [0.1, 0, 0, -0.9] avec un 0 distribué aléatoirement. Le paramètre qui contrôle le décrochage est le taux de décrochage. Le taux définit le nombre de poids à mettre à zéro. Avoir un taux compris entre 0.2 et 0.5 est courant.

Exemple de réseau neuronal dans TensorFlow

Voyons un exemple de réseau de neurones artificiels en action sur le fonctionnement d'un réseau de neurones pour un problème de classification typique. Il y a deux entrées, x1 et x2 avec une valeur aléatoire. La sortie est une classe binaire. L'objectif est de classer l'étiquette en fonction de ces deux caractéristiques. Pour mener à bien cette tâche, l'architecture du réseau neuronal est définie comme suitwing:

  • Deux couches cachées
    • La première couche comporte quatre neurones entièrement connectés
    • La deuxième couche possède deux neurones entièrement connectés
  • La fonction d'activation est un Relu
  • Ajoutez une régularisation L2 avec un taux d'apprentissage de 0.003

Réseau neuronal dans TensorFlow

Le réseau optimisera le poids pendant 180 époques avec une taille de lot de 10. Dans l'exemple de vidéo ANN ci-dessous, vous pouvez voir comment les poids évoluent et comment le réseau améliore la cartographie de classification.

Tout d’abord, le réseau attribue des valeurs aléatoires à tous les poids.

  • Avec les poids aléatoires, c'est-à-dire sans optimisation, la perte de sortie est de 0.453. L'image ci-dessous représente le réseau avec différentes couleurs.
  • En général, la couleur orange représente les valeurs négatives tandis que les couleurs bleues représentent les valeurs positives.
  • Les points de données ont la même représentation ; les bleus sont les étiquettes positives et les oranges les étiquettes négatives.

Réseau neuronal dans TensorFlow

A l'intérieur du deuxième calque caché, les lignes sont colorées comme suitwing le signe des poids. Les lignes orange attribuent des poids négatifs et la bleue des poids positifs.

Comme vous pouvez le constater, dans le mappage de sortie, le réseau commet de nombreuses erreurs. Voyons comment le réseau se comporte après optimisation.

L'image de l'exemple ANN ci-dessous décrit les résultats du réseau optimisé. Tout d’abord, vous remarquez que le réseau a appris avec succès à classer le point de données. Vous pouvez le voir sur la photo précédente ; le poids initial était de -0.43 alors qu'après optimisation, il en résulte un poids de -0.95.

Réseau neuronal dans TensorFlow

L’idée peut être généralisée aux réseaux comportant davantage de couches et de neurones cachés. Vous pouvez jouer dans le lien.

Comment former un réseau neuronal avec TensorFlow

Voici le processus étape par étape pour former un réseau neuronal avec TensorFlow ANN à l'aide de l'estimateur DNNClassifier de l'API.

Nous utiliserons l'ensemble de données MNIST pour former votre premier réseau neuronal. Entraîner un réseau de neurones avec TensorFlow ce n'est pas très compliqué. L'étape de prétraitement est exactement la même que dans les didacticiels précédents. Vous procéderez comme suit :

  • Étape 1 : Importer les données
  • Étape 2 : Transformer les données
  • Étape 3 : Construire le tenseur
  • Étape 4 : Construire le modèle
  • Étape 5 : Former et évaluer le modèle
  • Étape 6 : Améliorer le modèle

Étape 1) Importez les données

Tout d'abord, vous devez importer la bibliothèque nécessaire. Vous pouvez importer l'ensemble de données MNIST à l'aide de scikit learn, comme indiqué dans l'exemple de réseau neuronal TensorFlow ci-dessous.

L'ensemble de données MNIST est l'ensemble de données couramment utilisé pour tester de nouvelles techniques ou algorithmes. Cet ensemble de données est une collection d'images de 28 × 28 pixels avec un chiffre manuscrit de 0 à 9. Actuellement, l'erreur la plus faible du test est de 0.27 % avec un comité de 7 réseaux de neurones convolutifs.

import numpy as np
import tensorflow as tf
np.random.seed(1337)

Vous pouvez télécharger scikit learn temporairement à cette adresse. Copiez et collez l'ensemble de données dans un dossier pratique. Pour importer les données vers python, vous pouvez utiliser fetch_mldata de scikit learn. Collez le chemin du fichier dans fetch_mldata pour récupérer les données.

from sklearn.datasets import fetch_mldata
mnist = fetch_mldata(' /Users/Thomas/Dropbox/Learning/Upwork/tuto_TF/data/mldata/MNIST original')
print(mnist.data.shape)
print(mnist.target.shape)

Après cela, vous importez les données et obtenez la forme des deux ensembles de données.

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
y_train  = y_train.astype(int)
y_test  = y_test.astype(int)
batch_size =len(X_train)

print(X_train.shape, y_train.shape,y_test.shape )

Étape 2) Transformer les données

Dans le didacticiel précédent, vous avez appris que vous devez transformer les données pour limiter l'effet des valeurs aberrantes. Dans ce didacticiel sur les réseaux de neurones, vous transformerez les données à l'aide du scaler min-max. La formule est :

(X-min_x)/(max_x - min_x)

Scikit apprend qu'il existe déjà une fonction pour cela : MinMaxScaler()

## resclae
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
# Train
X_train_scaled = scaler.fit_transform(X_train.astype(np.float64))
# test
X_test_scaled = scaler.fit_transform(X_test.astype(np.float64))

Étape 3) Construire le tenseur

Vous connaissez maintenant la manière de créer un tenseur dans Tensorflow. Vous pouvez convertir la rame en colonne numérique.

feature_columns = [tf.feature_column.numeric_column('x', shape=X_train_scaled.shape[1:])]

Étape 4) Construire le modèle

L'architecture du réseau de neurones contient 2 couches cachées avec 300 unités pour la première couche et 100 unités pour la seconde. Nous utilisons ces valeurs en fonction de notre propre expérience. Vous pouvez ajuster ces valeurs et voir comment cela affecte la précision du réseau.

Pour construire le modèle, vous utilisez l'estimateur DNNClassifier. Vous pouvez ajouter le nombre de couches aux arguments feature_columns. Vous devez définir le nombre de classes sur 10 car il y a dix classes dans l'ensemble de formation. Vous connaissez déjà la syntaxe de l’objet estimateur. Les arguments caractéristiques colonnes, nombre de classes et model_dir sont exactement les mêmes que dans le tutoriel précédent. Le nouvel argument Hidden_unit contrôle le nombre de couches et le nombre de nœuds à connecter au réseau neuronal. Dans le code ci-dessous, il y a deux couches cachées avec une première connectant 300 nœuds et la seconde avec 100 nœuds.

Pour construire l'estimateur, utilisez tf.estimator.DNNClassifier avec le suivantwing paramètres:

  • feature_columns : Définissez les colonnes à utiliser dans le réseau
  • Hidden_units : définit le nombre de neurones cachés
  • n_classes : définissez le nombre de classes à prédire
  • model_dir : Définir le chemin de TensorBoard
estimator = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100], 
    n_classes=10, 
    model_dir = '/train/DNN')

Étape 5) Former et évaluer le modèle

Vous pouvez utiliser la méthode numpy pour entraîner le modèle et l'évaluer

# Train the estimator
train_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_train_scaled},
    y=y_train,
    batch_size=50,
    shuffle=False,
    num_epochs=None)
estimator.train(input_fn = train_input,steps=1000) 
eval_input = tf.estimator.inputs.numpy_input_fn(
    x={"x": X_test_scaled},
    y=y_test, 
    shuffle=False,
    batch_size=X_test_scaled.shape[0],
    num_epochs=1)
estimator.evaluate(eval_input,steps=None) 

Sortie :

{'accuracy': 0.9637143,
 'average_loss': 0.12014342,
 'loss': 1682.0079,
 'global_step': 1000}

L'architecture actuelle conduit à une précision sur l'ensemble d'évaluation de 96 pour cent.

Étape 6) Améliorer le modèle

Vous pouvez essayer d'améliorer le modèle en ajoutant des paramètres de régularisation.

Nous utiliserons un optimiseur Adam avec un taux d'abandon de 0.3, L1 de X et L2 de y. Dans TensorFlow Neural Network, vous pouvez contrôler l'optimiseur à l'aide du train d'objets suivantwing par le nom de l'optimiseur. TensorFlow est une API intégrée pour l'optimiseur Proximal AdaGrad.

Pour ajouter une régularisation au réseau neuronal profond, vous pouvez utiliser tf.train.ProximalAdagradOptimizer avec le suivantwing paramètre

  • Taux d'apprentissage : learning_rate
  • Régularisation L1 : l1_regularization_strength
  • Régularisation L2 : l2_regularization_strength
estimator_imp = tf.estimator.DNNClassifier(
    feature_columns=feature_columns,
    hidden_units=[300, 100],
    dropout=0.3, 
    n_classes = 10,
    optimizer=tf.train.ProximalAdagradOptimizer(
      learning_rate=0.01,
      l1_regularization_strength=0.01, 
      l2_regularization_strength=0.01
    ),
    model_dir = '/train/DNN1')
estimator_imp.train(input_fn = train_input,steps=1000) 
estimator_imp.evaluate(eval_input,steps=None) 

Sortie :

{'accuracy': 0.95057142,
 'average_loss': 0.17318928,
 'loss': 2424.6499,
 'global_step': 2000}

Les valeurs choisies pour réduire le surajustement n’ont pas amélioré la précision du modèle. Votre premier modèle avait une précision de 96 % tandis que le modèle avec régularisateur L2 a une précision de 95 %. Vous pouvez essayer avec différentes valeurs et voir comment cela affecte la précision.

Résumé

Dans ce didacticiel, vous apprendrez à créer un réseau de neurones. Un réseau de neurones nécessite :

  • Nombre de calques cachés
  • Nombre de nœuds entièrement connectés
  • Fonction d'activation
  • Optimizer
  • Nombre de cours

Dans TensorFlow ANN, vous pouvez entraîner un réseau neuronal pour résoudre un problème de classification avec :

  • tf.estimator.DNNClassifier

L'estimateur nécessite de préciser :

  • feature_columns=feature_columns,
  • unités_cachées=[300, 100]
  • n_classes=10
  • rép_modèle

Vous pouvez améliorer le modèle en utilisant différents optimiseurs. Dans ce didacticiel, vous avez appris à utiliser l'optimiseur Adam Grad avec un taux d'apprentissage et à ajouter un contrôle pour éviter le surajustement.