Erreur et perte

Error generally refers to the difference between the predicted output of the neural network and the actual target values for a single data point. It is a quantitative measure of the mistakes made by the network in its predictions. The loss function is a mathematical function that takes the predicted output and the actual target values as inputs and outputs a single value representing the error. Learning is essentially minimizing the loss function over all training data. Suppose that the neural network outputs ${\hat{y}=(\hat{y}}_1,{\hat{y}}_2,\dots ,{\hat{y}}_n)$ and the target output is $y=(y_1,y_2,\dots ,y_n)$. Common loss functions that would measure the error between $\hat{y}$ and $y$ include:

• Erreur quadratique moyenne (MSE) : $\frac{1}{n}\sum _{i=1}^n(y_i-{\hat{y}}_i{)}^2$. La formule de la MSE (introduite dans Entraîner et tester un modèle) est importante en raison de son lien avec le concept de variance en statistique. C'est une fonction de perte fréquemment utilisée dans les tâches de régression, où l'objectif consiste à prédire des valeurs continues.
• Perte d'entropie croisée binaire (binary cross entropy loss) : $-\frac{1}{n}\sum _{i=1}^n[y_i\text{ ln }{\hat{y}}_i+(1-y_i\left)\text{ ln }{(1-\hat{y}}_i)\right]$. Cette fonction de perte est couramment utilisée pour les tâches de classification binaire, c'est-à-dire lorsque la sortie vaut soit 0, soit 1. (Remarque : le signe moins devant la formule sert à rendre la valeur globale positive, car les valeurs des logarithmes sont généralement négatives. Le terme entropie est lié aux mesures de l'information définies dans Arbres de décision.)
• Perte charnière (hinge loss) : $\frac{1}{n}\sum _{i=1}^n\text{max}(0,1-y_i{\hat{y}}_i)$. Cette fonction est également couramment utile en classification binaire.
• Entropie croisée catégorielle creuse (sparse categorical cross entropy) : une généralisation de l'entropie croisée binaire, particulièrement utile lorsque les étiquettes cibles sont des entiers.

La perte moyenne est calculée comme la moyenne de la perte sur l'ensemble des points de données. Plus la perte moyenne est proche de zéro, plus l'erreur de prédiction est faible. Le choix de la fonction de perte dépend de la tâche spécifique, de la nature des entrées et des sorties ainsi que de nombreux autres facteurs, qui seront abordés plus en détail dans Introduction à l'apprentissage profond.

Descente de gradient et rétropropagation

L'objectif de l'entraînement d'un réseau de neurones étant de réduire la valeur de l'erreur ou de la perte, nous devons essentiellement résoudre un (très vaste) problème d'optimisation. Supposons que vous entraîniez un réseau de neurones. Considérez l'ensemble des poids et des biais — qui peuvent se compter par milliers, par millions, voire davantage ! — comme les paramètres actuels du réseau susceptibles d'être modifiés pour améliorer le modèle. Lors d'une passe avant avec un vecteur d'entrée arbitraire $x^{\left(0\right)}$, la sortie $\hat{y}$ est obtenue et comparée à la sortie réelle $y$ au moyen d'une fonction de perte, $C$. Comment exploiter cette information pour modifier les paramètres (poids et biais) afin que, lors de la passe suivante avec le même vecteur d'entrée $x^{\left(0\right)}$, la sortie $\hat{y}$ constitue une représentation plus exacte de la sortie réelle $y$, au sens où la valeur de $C$ diminue ? La clé consiste à appréhender l'ensemble du réseau de neurones et le calcul de la perte comme une fonction $F$ des poids $W$ et des biais $B$, puis à utiliser des techniques comme la descente de gradient (que nous aborderons brièvement dans la section suivante) pour en trouver la valeur minimale. Ici, $W$ et $B$ sont en majuscules car ils représentent la multiplicité des poids et des biais à travers tout le réseau, et non ceux d'un seul neurone ou d'une seule couche. La Figure 7.7 présente un schéma illustrant la fonction $F$ en tant que processus composite.

As a very simple example, suppose that a neural network has only one neuron with weight $w$ and bias $b$. Input $x$ is fed into the neuron, the weight and bias are applied to $x$, and then an activation function is applied to the result to produce an output $\hat{y}$. We’ll use the sigmoid, $\sigma \left(x\right)=\frac{1}{1+e^{-x}}$ as activation function for simplicity. Now, the result, $\hat{y}=\sigma (wx+b)$, is compared to the true value $y$, using a cost function, which for this example will be MSE. The composite function $F$ looks like this:

S'il y avait davantage de neurones, de poids et de biais, la formule serait beaucoup plus complexe, car il faudrait prendre en compte un nombre bien supérieur de variables et de paramètres, mais le concept fondamental reste identique. Nous voulons trouver les valeurs de $w$ et de $b$ qui minimisent la valeur de $F(w,b)$. Cela exige de nombreux cycles successifs d'ajustement des poids et des biais en se basant sur les valeurs de la fonction de perte. Chaque cycle d'entraînement complet est appelé une époque (epoch).

Figure 7.7 Réseau de neurones avec fonction de perte $C$, considéré comme une fonction des poids et des biais. Étant donné un ensemble de poids $W$ et de biais $B$, le réseau de neurones est exécuté sur un ensemble de données d'entrée $x^{\left(0\right)}$, la sortie $\hat{y}$ est obtenue et comparée à la sortie réelle $y$ au moyen d'une fonction de perte, $C$, fournissant un nombre unique : la perte, $z$. L'objectif de l'entraînement consiste à ajuster $W$ et $B$ de telle sorte que $z$ soit minimisé.

Now suppose that $w=0.5$ and $b=0.25$. Consider a single point from the set of training data—for example, $(x,y)=(1,0)$. The neural network computes a prediction, $\hat{y}$, as follows:

La perte par rapport à la sortie réelle donnée $(y=0)$ est :

Thus, we have the value $F(0.5,0.25)=0.46$, which indicates that there is some nonzero amount of loss on the prediction just made, and so the values of $w$ and $b$ should be adjusted. Instead of trying to adjust $w$ and $b$ individually, let’s find the direction from the point (0.5, 0.25) that would result in the fastest decrease of the error $z$. If we label the direction of steepest decrease $(dx,dy)$, then we could move from the point (0.5, 0.25) to a new point, $(0.5,0.25)+h·(dw,db)=$ $(0.5+h·dw,0.25+h·db)$, where $h$ is a small number that affects the learning rate of the neural network. This is the main idea behind gradient descent. In our example, we could find the direction of steepest descent by simply looking at how the surface $z=F(w,b)$ is slanted near the point (0.5, 0.25). Figure 7.8 indicates the best direction with an arrow. (However, in practice, there will be no way to visualize the graph of loss with respect to weights $\left(W\right)$ and biases ($B$) because the points $(W,B,z)$ exist in very high-dimensional spaces. The details of gradient descent and how it is used in neural networks falls outside the scope of this textbook. (See this IBM article for a great introduction to this topic.)

Figure 7.8 Application simple de la descente de gradient. Le point $(w,b)=(0.5,0.25)$ présente une perte de $z=0.46$. La flèche indique la direction de plus grande pente descendante depuis le point $(0.5,0.25,0.46)$ sur la surface.

Un dernier point à souligner est que la descente de gradient ne fonctionne que lorsque la fonction F est différentiable, ce qui signifie que la courbe de $z=F\left(W,B\right)$ ne comporte ni angles vifs, ni points de rebroussement, ni points de discontinuité. Dans la mesure où $F$ est une composition de nombreuses fonctions composantes, chaque composante doit être différentiable. Les fonctions d'activation telles que la fonction en escalier, ReLU et LReLU ne peuvent pas être employées directement avec la descente de gradient. D'autres méthodes sont toutefois disponibles pour rétropropager et entraîner ce type de réseaux. Une autre solution consiste à approximer les fonctions d'activation non lisses par des versions régulières — par exemple, sigmoïde ou tanh à la place de la fonction en escalier, ou softplus à la place de ReLU.

Entraîner un réseau de neurones par rétropropagation en Python avec TensorFlow

La bibliothèque Python TensorFlow, développée à l'origine par l'équipe Google Brain en 2015, permet de concevoir un réseau de neurones doté de la rétropropagation. (Un tenseur (tensor) est un tableau multidimensionnel, généralisant le concept de vecteur.)

Mettons en place un réseau de neurones et entraînons-le à reconnaître des chiffres manuscrits de la base de données MNIST. Ce jeu de données, nommé mnist_784, peut être chargé automatiquement au moyen de la commande fetch_openml. Les étiquettes cibles doivent être converties explicitement en nombres entiers. Les données sont ensuite scindées en ensembles d'entraînement (80 %) et de test (20 %). Les variables explicatives sont renormalisées à l'aide de StandardScaler. Le modèle de réseau de neurones est ensuite créé avec tf.keras.Sequential. L'architecture peut être très complexe, mais nous nous limiterons au cas le plus simple : une couche d'entrée comprenant exactement autant de neurones que de variables (784) et une couche de sortie de 10 neurones, un pour chaque chiffre. Ce modèle ne comprend aucune couche cachée. La commande tf.keras.layers.Dense crée la couche de sortie de 10 neurones entièrement connectée à la couche d'entrée de 784 neurones (la valeur de X_train_scaled.shape[1]). La fonction d'activation softmax est employée, mais d'autres fonctions telles que ReLU sont également envisageables. Le paramètre optimizer='adam' dans la fonction model.compile fait référence à l'algorithme Adaptive Moment Estimation, utilisé pour actualiser les poids et les biais du modèle durant l'apprentissage, dont les détails techniques dépassent le cadre de cet ouvrage.

Remarque : Ce code nécessite un certain temps d'exécution — jusqu'à 5 minutes ! Même sans couche cachée, la rétropropagation prend du temps. Lors de l'exécution, vous devriez observer des barres de progression pour chaque époque (non représentées dans la sortie Python de l'encadré ci-dessous).

    # import the libraries
    import tensorflow as tf
    from sklearn.datasets import fetch_openml
    from sklearn.model_selection import train_test_split
    from sklearn.preprocessing import StandardScaler
    
    # Load MNIST Digits dataset
    mnist = fetch_openml('mnist_784', version=1)
    
    # Split the dataset into training and testing sets 80/20
    X_train, X_test, y_train, y_test = train_test_split(mnist.data, mnist.target, test_size=0.2, random_state=42)
    
    # Standardize features by removing the mean and scaling to unit variance
    scaler = StandardScaler()
    X_train_scaled = scaler.fit_transform(X_train)
    X_test_scaled = scaler.transform(X_test)
    
    # Cast the target variable as an integer (int32)
    y_train = y_train.astype('int32')
    y_test = y_test.astype('int32')
    
    # Define the neural network architecture
    model = tf.keras.Sequential([
     tf.keras.layers.Dense(10, activation='softmax', input_shape=(X_train_scaled.shape[1],))
    ])
    
    # Compile the model
    model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])
    
    # Train the model
    history = model.fit(X_train_scaled, y_train, epochs=10, batch_size=32, validation_split=0.2)
    
    # Evaluate the model on test data
    test_loss, test_accuracy = model.evaluate(X_test_scaled, y_test)
    print("Test Loss:", test_loss)
    print("Test Accuracy:", test_accuracy)
    

Test Loss: 0.4051963686943054
Test Accuracy: 0.9189285635948181

Dérouler un RNN

The effect of feedback loops may be visualized by “unrolling” the RNN. Consider the simplest case of a single feedback loop from one neuron to itself. The effect of the connecting weight is equivalent to connecting to a copy of the same RNN (with identical weights and biases). Of course, since the second copy of the RNN has the same feedback loop, it can be unrolled to a third, fourth, fifth copy, etc. An “unrolled” RNN with $n$ copies of the neural net has $n$ inputs. The effect of feeding the entire vector $x^{\left(0\right)}$ into the unrolled model is equivalent to feeding the data points $(x_1,x_2,x_3,\dots ,x_n)$ sequentially into the RNN. Figure 7.10 shows how this works.

Figure 7.10 Dérouler un RNN

Problème de disparition ou d'explosion du gradient

Entraîner un RNN est plus complexe en raison de la grande sensibilité du modèle aux variations des poids de connexion. Au cours de la phase d'apprentissage, la descente de gradient et une variante de la rétropropagation (BPTT, comme indiqué précédemment) sont mises en œuvre pour ajuster l'ensemble des poids et des biais. Cependant, en raison des boucles de rétroaction propres aux RNN, les poids de connexion peuvent se multiplier de manière répétée jusqu'à atteindre des valeurs gigantesques. Dès lors, des algorithmes comme la descente de gradient perdent toute leur efficacité, car des poids élevés induisent des modifications proportionnellement excessives des paramètres, à l'opposé des ajustements infinitésimaux requis pour localiser des minima. C'est ce que l'on appelle le problème d'explosion du gradient (exploding gradient problem). À l'inverse, si les poids de connexion sont initialement trop faibles, l'entraînement peut les faire tendre très vite vers zéro, ce qui constitue le problème de disparition du gradient (vanishing gradient problem). Il est essentiel de prendre en compte ces deux écueils lors de l'utilisation de RNN, faute de quoi l'exactitude de votre modèle risque d'être sérieusement compromise.

Réseaux à mémoire court et long terme

Un réseau à mémoire court et long terme (LSTM) (long short-term memory (LSTM) network) est un type particulier de RNN conçu pour surmonter les problèmes d'explosion ou de disparition du gradient en intégrant des cellules de mémoire (memory cells) capables de capturer les dépendances à long terme bien mieux que de simples boucles de rétroaction. Introduits en 1997, les LSTM sont devenus incontournables dans de nombreuses applications, notamment le traitement du langage naturel, la reconnaissance vocale et la prévision de séries temporelles.

Les réseaux LSTM sont généralement plus stables et plus faciles à entraîner que les RNN classiques. Ils s'avèrent ainsi particulièrement indiqués pour la prévision de séries temporelles comportant des tendances à long terme et des comportements cycliques, ainsi que pour le traitement de données séquentielles d'apparence beaucoup plus imprévisible comme la modélisation du langage naturel, la traduction automatique et l'analyse de sentiments. Les RNN et les LSTM constituent un tremplin vers des modèles d'IA très sophistiqués, que nous examinerons dans la section suivante.

Les RNN en Python

Considérons le jeu de données MonthlyCoalConsumption.csv, que nous avons analysé au moyen des méthodes de séries temporelles de base dans Séries temporelles et prévisions. Ce jeu de données contient des observations s'étendant jusqu'à la fin de l'année 2022. Supposons que vous souhaitiez prévoir la consommation mensuelle de charbon pour chaque mois de l'année suivante à l'aide d'un réseau de neurones récurrent. Nous allons d'abord configurer un RNN simple en Python. La bibliothèque TensorFlow peut être utilisée pour concevoir un RNN. Nous emploierons pandas pour charger les données et numpy pour les structurer sous une forme plus exploitable (np.array) par le modèle. Le modèle RNN est défini à l'aide de la commande tf.keras.layers.SimpleRNN, où units précise le nombre de neurones dans la couche et activation='tanh' définit la fonction d'activation.

    import numpy as np
    import pandas as pd
    import tensorflow as tf
    from sklearn.preprocessing import MinMaxScaler
    
    # Load and preprocess the data
    data = pd.read_csv('MonthlyCoalConsumption.csv')
    values = np.array(data['Value'])
    scaler = MinMaxScaler(feature_range=(0, 1))
    scaled_values = scaler.fit_transform(values.reshape(-1, 1))
    
    # Prepare input sequences and target values
    window_size = 12 # Number of months in each input sequence
    X = []
    y = []
    for i in range(len(scaled_values) - window_size):
      X.append(scaled_values[i:i+window_size])
      y.append(scaled_values[i+window_size])
    X = np.array(X)
    y = np.array(y)
    
    # Split data into training and testing sets
    split = int(0.8 * len(X))
    X_train, X_test = X[:split], X[split:]
    y_train, y_test = y[:split], y[split:]
    
    # Define the RNN architecture
    model = tf.keras.Sequential([
      tf.keras.layers.SimpleRNN(units=32, activation='tanh',
                    input_shape=(window_size, 1)),
      tf.keras.layers.Dense(1)
    ])
    
    # Compile the model
    model.compile(optimizer='adam', loss='mean_squared_error')
    
    # Train the model
    model.fit(X_train, y_train, epochs=50, batch_size=16)
    
    # Evaluate the model
    loss = model.evaluate(X_test, y_test)
    print("Test Loss:", loss)
    

Test Loss: 0.018054470419883728

La perte sur les données de test étant extrêmement faible, nous pouvons nous attendre à ce que le modèle soit très précis. Ensuite, le modèle peut être utilisé pour prédire les valeurs inconnues des 12 prochains mois. Remarque : les données d'origine ayant été mises à l'échelle, les prédictions fournies par le RNN doivent être reconverties en données non normalisées grâce à la commande scaler.inverse_transform.

    # Predict future values
    future_months = 12
    last_window = scaled_values[-window_size:].reshape(1, window_size, 1)
    predicted_values = []
    for _ in range(future_months):
     prediction = model.predict(last_window)
     predicted_values.append(prediction[0, 0])
     last_window = np.append(last_window[:, 1:, :], prediction.reshape(1, 1, 1), axis=1)
    
    # Inverse transform the predicted births to get actual values
    predicted_values = scaler.inverse_transform(np.array(predicted_values).reshape(-1, 1))
    print("Predicted Values for the Next 12 Months:\n", predicted_values.flatten())
    

Predicted Values for the Next 12 Months:
[49227.05 49190.258 41204.16 30520.389 29591.129 34516.586 42183.016
38737.39 32026.324 23482.027 23381.914 30206.467]

Enfin, voici le tracé superposant les données d'origine et les valeurs prédites. Remarque : de nombreuses lignes de code sont consacrées à la mise en forme des données et aux étiquettes des axes avant de tracer le graphique. C'est malheureusement le propre de ce type de visualisation. Le détail précis de chaque instruction ne fera pas l'objet d'une explication approfondie dans cet ouvrage.

Code Python

    import matplotlib.pyplot as plt
    from matplotlib.ticker import MaxNLocator ## for graph formatting
    from matplotlib.ticker import FuncFormatter ## for formatting y-axis
    
    # Function to format the Y-axis values
    def y_format(value, tick_number):
     return f'{value:,.0f}'
    
    # Plot original time series data and predicted values
    plt.figure(figsize=(10, 6))
    plt.plot(data['Month'], data['Value'], label='Original Data', color='blue')
    plt.plot(range(len(data['Value']), len(data['Value']) + future_months), predicted_values,
        label='Predicted Values', color='red')
    
    # Create a list for the months
    pd_months = pd.date_range(start='2016-01-01', end='2023-07-01', freq='MS')
    
    xticks_positions = range(0, len(pd_months), 6) # Positions to display ticks (e.g., every 12 months)
    xticks_labels = [pd_months[pos].strftime('%Y-%m') for pos in xticks_positions] # Labels corresponding to positions
    
    plt.xlabel('Month')
    plt.ylabel('Value')
    plt.title('Monthly Consumption of Coal from 2016 to 2022 and Predicted Values for 2023')
    plt.legend()
    plt.xticks(ticks=xticks_positions, labels=xticks_labels, rotation=45)
    # Apply the formatter to the Y-axis
    plt.gca().yaxis.set_major_formatter(FuncFormatter(y_format))
    
    plt.show()
    

La sortie obtenue se présentera ainsi :