La traduction de cette page n'est pas à jour. Cliquez ici pour voir la dernière version en anglais.

trainingOptions

Options d’un réseau de neurones d’apprentissage pour le Deep Learning

Syntaxe

options = trainingOptions(solverName)

options = trainingOptions(solverName,Name=Value)

Description

options = trainingOptions(solverName) renvoie les options d’apprentissage de l’optimisation spécifiée par solverName. Pour entraîner un réseau de neurones, utilisez les options d’apprentissage comme argument d’entrée de la fonction trainnet.

options = trainingOptions(solverName,Name=Value) renvoie des options d’apprentissage avec des options complémentaires spécifiées par un ou plusieurs arguments nom-valeur.

Exemples

Spécifier les options d’apprentissage

Créez un jeu d’options pour l’apprentissage d’un réseau avec une descente de gradient stochastique avec momentum. Réduisez le taux d’apprentissage d’un facteur de 0,2 tous les 5 epochs. Définissez un nombre maximal d’epochs pour l’apprentissage de 20 et utilisez un mini-batch avec 64 observations à chaque itération. Activez le tracé de la progression de l’apprentissage.

options = trainingOptions("sgdm", ...
    LearnRateSchedule="piecewise", ...
    LearnRateDropFactor=0.2, ...
    LearnRateDropPeriod=5, ...
    MaxEpochs=20, ...
    MiniBatchSize=64, ...
    Plots="training-progress")

options = 
  TrainingOptionsSGDM with properties:

                        Momentum: 0.9000
                InitialLearnRate: 0.0100
                       MaxEpochs: 20
               LearnRateSchedule: 'piecewise'
             LearnRateDropFactor: 0.2000
             LearnRateDropPeriod: 5
                   MiniBatchSize: 64
                         Shuffle: 'once'
             CheckpointFrequency: 1
         CheckpointFrequencyUnit: 'epoch'
                  SequenceLength: 'longest'
        PreprocessingEnvironment: 'serial'
                L2Regularization: 1.0000e-04
         GradientThresholdMethod: 'l2norm'
               GradientThreshold: Inf
                         Verbose: 1
                VerboseFrequency: 50
                  ValidationData: []
             ValidationFrequency: 50
              ValidationPatience: Inf
             ObjectiveMetricName: 'loss'
                  CheckpointPath: ''
            ExecutionEnvironment: 'auto'
                       OutputFcn: []
                         Metrics: []
                           Plots: 'training-progress'
            SequencePaddingValue: 0
        SequencePaddingDirection: 'right'
                InputDataFormats: "auto"
               TargetDataFormats: "auto"
         ResetInputNormalization: 1
    BatchNormalizationStatistics: 'auto'
                   OutputNetwork: 'auto'
                    Acceleration: "auto"

Surveiller la progression de l'apprentissage du Deep Learning

Cet exemple montre comment surveiller la progression de l’apprentissage des réseaux de Deep Learning.

Lorsque vous entraînez des réseaux pour le Deep Learning, le tracé de diverses métriques pendant l’apprentissage vous permet de suivre la progression de celui-ci. Par exemple, vous pouvez déterminer si la précision du réseau s’améliore et dans quelle mesure, et si le réseau commence à provoquer un surajustement des données d’apprentissage.

Cet exemple montre comment surveiller la progression de l’apprentissage pour des réseaux entraînés avec la fonction trainnet. Si vous entraînez un réseau avec une boucle d’apprentissage personnalisée, utilisez plutôt un objet trainingProgressMonitor pour tracer les métriques pendant l’apprentissage. Pour plus d’informations, veuillez consulter Monitor Custom Training Loop Progress.

Lorsque vous définissez l’option d’apprentissage Plots à "training-progress" dans trainingOptions et commencez l’apprentissage d’un réseau, la fonction trainnet crée une figure et affiche les métriques à chaque itération. Chaque itération est une estimation du gradient et une mise à jour des paramètres du réseau. Si vous spécifiez des données de validation dans trainingOptions, la figure montre les métriques de validation chaque fois que trainnet valide le réseau. La figure trace la perte et toutes les métriques spécifiées par l’option de type nom-valeur Metrics. Par défaut, le software utilise une échelle linéaire pour les tracés. Pour spécifier une échelle logarithmique pour l’axe des ordonnées, sélectionnez le bouton correspondant dans la barre d’outils des axes.

Pendant l’apprentissage, vous pouvez arrêter l’apprentissage et revenir à l’état actuel du réseau en cliquant sur le bouton dans le coin supérieur droit. Une fois que vous avez cliqué sur le bouton d’arrêt, l’apprentissage peut prendre un certain temps pour s’achever. Une fois l’apprentissage terminé, trainnet renvoie le réseau entraîné.

Définissez l’option d’apprentissage OutputNetwork à "best-validation" pour obtenir des valeurs finalisées correspondant à l’itération avec la meilleure valeur de métrique de validation, où la métrique optimisée est spécifiée par les options d’apprentissage ObjectiveMetricName. Définissez l’option d’apprentissage OutputNetwork à "last-iteration" pour obtenir des métriques finalisées correspondant à la dernière itération de l’apprentissage.

Des informations sur le temps et les paramètres d’apprentissage s’affichent à droite du volet. Pour en savoir plus sur les options d’apprentissage, veuillez consulter Set Up Parameters and Train Convolutional Neural Network.

Pour enregistrer le tracé de la progression de l’apprentissage, cliquez sur Export as Image dans la fenêtre d’apprentissage. Vous pouvez enregistrer le tracé en tant que fichier PNG, JPEG, TIFF ou PDF. Vous pouvez également enregistrer les tracés individuels avec la barre d’outils des axes.

Tracer la progression de l’apprentissage pendant l’apprentissage

Entraînez un réseau et tracez la progression de l’apprentissage pendant l’apprentissage.

Chargez respectivement les données d’apprentissage et de test à partir des fichiers MAT DigitsDataTrain.mat et DigitsDataTest.mat. Les jeux de données d’apprentissage et de test contiennent 5 000 images chacun.

load DigitsDataTrain.mat
load DigitsDataTest.mat

Créez un objet dlnetwork.

net = dlnetwork;

Spécifiez les couches de la branche de classification et ajoutez-les au réseau.

layers = [
    imageInputLayer([28 28 1])
    convolution2dLayer(3,8,Padding="same")
    batchNormalizationLayer
    reluLayer   
    maxPooling2dLayer(2,Stride=2)
    convolution2dLayer(3,16,Padding="same")
    batchNormalizationLayer
    reluLayer
    maxPooling2dLayer(2,Stride=2)
    convolution2dLayer(3,32,Padding="same")
    batchNormalizationLayer
    reluLayer
    fullyConnectedLayer(10)
    softmaxLayer];

net = addLayers(net,layers);

Spécifiez les options pour l’apprentissage du réseau. Pour valider le réseau à intervalles réguliers pendant l’apprentissage, spécifiez les données de validation. Enregistrez les métriques de précision et de F-score. Pour tracer la progression de l’apprentissage pendant l’apprentissage, définissez l’option d’apprentissage Plots à "training-progress".

options = trainingOptions("sgdm", ...
    MaxEpochs=8, ...
    Metrics = ["accuracy","fscore"], ...
    ValidationData={XTest,labelsTest}, ...
    ValidationFrequency=30, ...
    Verbose=false, ...
    Plots="training-progress");

Entraînez le réseau.

net = trainnet(XTrain,labelsTrain,net,"crossentropy",options);

Arrêter l’apprentissage de manière précoce en utilisant des métriques

Utilisez des métriques pour l’arrêt précoce et le renvoi du meilleur réseau.

Chargez les données d’apprentissage qui contiennent 5 000 images de chiffres. Réservez 1 000 images pour la validation du réseau.

[XTrain,YTrain] = digitTrain4DArrayData;

idx = randperm(size(XTrain,4),1000);
XValidation = XTrain(:,:,:,idx);
XTrain(:,:,:,idx) = [];
YValidation = YTrain(idx);
YTrain(idx) = [];

Construisez un réseau pour classer les images de chiffres.

net = dlnetwork;

layers = [
    imageInputLayer([28 28 1])
    convolution2dLayer(3,8,Padding="same")
    batchNormalizationLayer
    reluLayer      
    fullyConnectedLayer(10)
    softmaxLayer];

net = addLayers(net,layers);

Spécifiez les options d’apprentissage :

• Utilisez un solveur SGDM pour l’apprentissage.

• Surveillez les performances de l’apprentissage en spécifiant des données de validation et une fréquence de validation.

• Suivez la précision et le rappel pendant l’apprentissage. Pour renvoyer le réseau avec la meilleure valeur de rappel, spécifiez "recall" comme métrique d'évaluation et définissez le réseau de sortie à "best-validation".

• Spécifiez la patience de la validation à 5 pour que l’apprentissage s’arrête si le rappel n’a pas diminué depuis cinq itérations.

• Visualisez le tracé de la progression de l’apprentissage du réseau.

• Désactivez la sortie en clair.

options = trainingOptions("sgdm", ...
    ValidationData={XValidation,YValidation}, ...
    ValidationFrequency=35, ...
    ValidationPatience=5, ...
    Metrics=["accuracy","recall"], ...
    ObjectiveMetricName="recall", ...
    OutputNetwork="best-validation", ...
    Plots="training-progress", ...
    Verbose=false);

Entraînez le réseau.

net = trainnet(XTrain,YTrain,net,"crossentropy",options);

Arguments d'entrée

solverName — Solveur pour l'apprentissage du réseau de neurones

"sgdm" | "rmsprop" | "adam" | "lbfgs" (depuis R2023b) | "lm" (depuis R2024b)

Solveur pour l'apprentissage du réseau de neurones, spécifié comme l’une des valeurs suivantes :

• "sgdm" — Descente de gradient stochastique avec momentum (SGDM, Stochastic Gradient Descent with Momentum). SGDM est un solveur stochastique. Pour des options d’apprentissage supplémentaires, veuillez consulter Options des solveurs stochastiques. Pour plus d’informations, veuillez consulter Descente de gradient stochastique avec momentum.

• "rmsprop" — Propagation de la moyenne quadratique (RMSProp, Root Mean Square Propagation). RMSProp est un solveur stochastique. Pour des options d’apprentissage supplémentaires, veuillez consulter Options des solveurs stochastiques. Pour plus d’informations, veuillez consulter Propagation de la moyenne quadratique.

• "adam" — Estimation adaptative des moments (Adam, Adaptive moment estimation). Adam est un solveur stochastique. Pour des options d’apprentissage supplémentaires, veuillez consulter Options des solveurs stochastiques. Pour plus d’informations, veuillez consulter Estimation adaptative des moments.

• "lbfgs" (depuis R2023b) — Méthode Broyden-Fletcher-Goldfarb-Shanno à mémoire limitée (L-BFGS, Limited-memory Broyden–Fletcher–Goldfarb–Shanno). L-BFGS est un solveur en batch. Utilisez l’algorithme L-BFGS pour les réseaux et jeux de données de petite taille que vous pouvez traiter en un seul batch. Pour des options d’apprentissage supplémentaires, veuillez consulter Options du solveur en batch. Pour plus d’informations, veuillez consulter BFGS à mémoire limitée.

• "lm" (depuis R2024b) — Levenberg–Marquardt (LM). LM est un solveur en batch. Utilisez l’algorithme LM pour les réseaux de régression comptant de petits nombres de paramètres entraînables pour lesquels vous pouvez traiter le jeu de données en un seul batch. Si solverName est "lm", alors l’argument lossFcn de la fonction trainnet doit être "mse" ou "l2loss". Pour des options d’apprentissage supplémentaires, veuillez consulter Options du solveur en batch. Pour plus d’informations, veuillez consulter Levenberg–Marquardt.

La fonction trainBERTDocumentClassifier (Text Analytics Toolbox) supporte uniquement les solveurs "sgdm", "rmsprop" et "adam".

Arguments nom-valeur

Spécifiez des paires d’arguments en option selon le modèle Name1=Value1,...,NameN=ValueN, où Name est le nom de l’argument et Value est la valeur correspondante. Les arguments nom-valeur doivent apparaître après les autres arguments, mais l’ordre des paires n’a aucune importance.

Avant R2021a, utilisez des virgules pour séparer les noms et les valeurs, et mettez Name entre guillemets.

Exemple : Plots="training-progress",Metrics="accuracy",Verbose=false spécifie de désactiver la sortie en clair et d’afficher la progression de l’apprentissage dans un graphique comprenant également la métrique de précision.

Contrôle

Plots — Tracés à afficher pendant l’apprentissage d’un réseau de neurones

"none" (par défaut) | "training-progress"

Tracés à afficher pendant l’apprentissage d’un réseau de neurones, spécifiés comme l’une des valeurs suivantes :

• "none" — Ne pas afficher de tracés pendant l’apprentissage.

• "training-progress" — Tracer la progression de l'apprentissage.

Le contenu du tracé dépend du solveur utilisé.

• Lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop", le tracé affiche la perte des mini-batchs, la perte de la validation, les métriques d’apprentissage des mini-batchs et de validation spécifiées par l’option Metrics ainsi que des informations complémentaires sur la progression de l’apprentissage.

• Lorsque l’argument solverName est "lbfgs" ou "lm", le tracé affiche la perte de l’apprentissage et de la validation, les métriques d’apprentissage et de validation spécifiées par l’option Metrics, ainsi que des informations complémentaires sur la progression de l’apprentissage.

Pour ouvrir et fermer le tracé de la progression de l’apprentissage de manière programmatique après l’apprentissage, utilisez les fonctions show et close avec la deuxième sortie de la fonction trainnet. Vous pouvez utiliser la fonction show pour afficher la progression de l’apprentissage même si l’option d’apprentissage Plots est définie à "none".

Pour que l’axe des ordonnées passe à une échelle logarithmique, utilisez la barre d’outils des axes.

Pour plus d’informations sur le tracé, veuillez consulter Surveiller la progression de l'apprentissage du Deep Learning.

Metrics — Métriques à surveiller

[] (par défaut) | vecteur de caractères | tableau de chaînes de caractères | handle de fonction | objet deep.DifferentiableFunction (depuis R2024a) | cell array | objet métrique

Depuis R2023b

Métriques à surveiller, définies par l’une des valeurs suivantes :

• Nom de métrique prédéfinie ou de fonction de perte — Spécifiez les métriques sous la forme d'un string scalar, un vecteur de caractères ou un cell array, ou bien tableau de chaînes de caractères (string array) contenant un ou plusieurs des noms suivants :

  • Métriques :

    • "accuracy" — Précision (également appelée précision top-1)

    • "auc" — Aire sous la courbe ROC (AUC)

    • "fscore" — F-score (également appelé F₁-score)

    • "precision" — Justesse

    • "recall" — Rappel

    • "rmse" — Racine de l’erreur quadratique moyenne

    • "mape" — Erreur absolue moyenne en pourcentage (MAPE) (depuis R2024b)

  • Fonctions de perte :

    • "crossentropy" — Perte d’entropie croisée pour les tâches de classification. (depuis R2024b)

    • "indexcrossentropy" — Perte d’entropie croisée d’indice pour les tâches de classification. (depuis R2024b)

    • "binary-crossentropy" — Perte d’entropie croisée binaire pour les tâches de classification binaire et multi-étiquette. (depuis R2024b)

    • "mae" / "mean-absolute-error" / "l1loss" — Erreur absolue moyenne pour les tâches de régression. (depuis R2024b)

    • "mse" / "mean-squared-error" / "l2loss" — Erreur quadratique moyenne pour les tâches de régression. (depuis R2024b)

    • "huber" — Perte de Huber pour les tâches de régression (depuis R2024b)

  Remarque : il est impossible de définir la fonction de perte comme "crossentropy" tout en utilisant "index-crossentropy" comme métrique, ou inversement, de définir "index-crossentropy" comme fonction de perte comme tout en utilisant "crossentropy" comme métrique.

• Objet métrique prédéfini — Si vous avez besoin de plus de flexibilité, vous pouvez utiliser des objets métriques prédéfinis. Le software supporte les objets métriques prédéfinis suivants :

  • AccuracyMetric

  • AUCMetric

  • FScoreMetric

  • PrecisionMetric

  • RecallMetric

  • RMSEMetric

  • MAPEMetric (depuis R2024b)

  Lorsque vous créez un objet métrique prédéfini, vous pouvez spécifier des options supplémentaires, par exemple le type de moyenne et s’il s’agit d’une tâche à une seule ou plusieurs étiquettes.

• Handle de fonction de métrique personnalisée — Si aucune métrique prédéfinie ne correspond à vos besoins, vous pouvez spécifier des métriques personnalisées avec un handle de fonction. La fonction doit avoir la syntaxe metric = metricFunction(Y,T), où Y correspond aux prédictions du réseau et T correspond aux réponses cibles. Pour les réseaux possédant plusieurs sorties, la syntaxe doit être metric = metricFunction(Y1,…,YN,T1,…TM), où N est le nombre de sorties et M est le nombre de cibles. Pour plus d’informations, veuillez consulter Define Custom Metric Function.

  Remarque

  Lorsque les données sont dans des mini-batchs, le logiciel calcule la métrique de chaque mini-batch, puis renvoie la moyenne de ces valeurs. Pour certaines métriques, ce comportement peut produire une métrique différente de celle obtenue en calculant la métrique sur le jeu de données entier en une fois. Dans la plupart des cas, les valeurs sont similaires. Pour utiliser une métrique personnalisée qui n’est pas moyennée par batch pour les données, vous devez créer un objet métrique personnalisé. Pour plus d’informations, veuillez consulter Define Custom Deep Learning Metric Object.

• Objet deep.DifferentiableFunction (depuis R2024a) — Objet fonction avec une fonction de rétropropagation personnalisée. Pour les cibles catégorielles, le logiciel convertit automatiquement les valeurs catégorielles en vecteurs à encodage one-hot et les transmet à la fonction métrique. Pour plus d’informations, veuillez consulter Define Custom Deep Learning Operations.

• Objet métrique personnalisé — Si vous avez besoin d’une personnalisation plus poussée, vous pouvez définir votre propre objet métrique personnalisé. Pour un exemple illustrant comment créer une métrique personnalisée, veuillez consulter Define Custom Metric Object. Pour des informations générales sur la création de métriques personnalisées, veuillez consulter Define Custom Deep Learning Metric Object.

Si vous spécifiez une métrique comme un handle de fonction, un objet deep.DifferentiableFunction ou un objet métrique personnalisé et que vous entraînez le réseau de neurones à l'aide de la fonction trainnet, la disposition des cibles que le logiciel transmet à la métrique dépend du type de données des cibles, de la fonction de perte que vous spécifiez dans la fonction trainnet et des autres métriques que vous spécifiez :

• Si les cibles sont des tableaux numériques, le logiciel les transmet directement à la métrique.

• Si la fonction de perte est "index-crossentropy" et que les cibles sont des tableaux catégoriels, le logiciel convertit automatiquement les cibles en indices de classe numériques et les transmet à la métrique.

• Pour les autres fonctions de perte, si les cibles sont des tableaux catégoriels, le logiciel convertit automatiquement les cibles en vecteurs à encodage one-hot et les transmet à la métrique.

Cette option supporte uniquement les fonctions trainnet et trainBERTDocumentClassifier (Text Analytics Toolbox).

Exemple : Metrics=["accuracy","fscore"]

Exemple : Metrics={"accuracy",@myFunction,precisionObj}

ObjectiveMetricName — Nom de la métrique d'évaluation

"loss" (par défaut) | string scalar | vecteur de caractères

Depuis R2024a

Nom de la métrique d'évaluation à utiliser pour l’arrêt précoce et le renvoi du meilleur réseau, spécifié comme un string scalar ou un vecteur de caractères.

Le nom de la métrique doit être "loss" ou correspondre au nom d’une métrique spécifiée par l’argument Metrics. Les métriques spécifiées avec des handles de fonction ne sont pas supportées. Pour que vous puissiez spécifier le nom d’une métrique personnalisée comme valeur de ObjectiveMetricName, il est nécessaire que la valeur de la propriété Maximize de l’objet métrique personnalisé ne soit pas vide. Pour plus d’informations, veuillez consulter Define Custom Deep Learning Metric Object.

Pour plus d’informations sur la spécification de la métrique d'évaluation pour l’arrêt précoce, veuillez consulter ValidationPatience. Pour plus d’informations sur le renvoi du meilleur réseau avec la métrique d'évaluation, veuillez consulter OutputNetwork.

Types de données : char | string

Verbose — Indicateur pour l’affichage des informations de la progression de l’apprentissage

1 (true) (par défaut) | 0 (false)

Indicateur pour l’affichage des informations de la progression de l’apprentissage dans la fenêtre de commande, spécifié comme 1 (true) ou 0 (false).

Le contenu de la sortie en clair dépend du type de solveur.

Pour les solveurs stochastiques (SGDM, Adam et RMSProp), la table contient les variables suivantes :

Variable	Description
Iteration	Numéro d’itération.
Epoch	Numéro d’epoch.
TimeElapsed	Temps écoulé en heures, minutes et secondes.
LearnRate	Taux d’apprentissage.
TrainingLoss	Perte lors de l'apprentissage.
ValidationLoss	Perte lors de la validation. Si vous ne spécifiez pas de données de validation, le software n’affiche pas cette information.

Pour les solveurs en batch (L-BFGS et LM), la table contient les variables suivantes :

Variable	Description
Iteration	Numéro d’itération.
TimeElapsed	Temps écoulé en heures, minutes et secondes.
TrainingLoss	Perte lors de l'apprentissage.
ValidationLoss	Perte lors de la validation. Si vous ne spécifiez pas de données de validation, le software n’affiche pas cette information.
GradientNorm	Norme des gradients.
StepNorm	Norme des pas.

Si vous spécifiez des métriques supplémentaires dans les options d’apprentissage, elles apparaissent également dans la sortie en clair. Par exemple, si vous définissez l’option d’apprentissage Metrics à "accuracy", les informations incluent les variables TrainingAccuracy et ValidationAccuracy.

Si l’apprentissage s’arrête, la sortie en clair (verbose) affiche la raison de l’arrêt.

Pour spécifier les données de validation, utilisez l’option d’apprentissage ValidationData.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

VerboseFrequency — Fréquence de l’impression en clair (verbose)

50 (par défaut) | entier positif

Fréquence de l’impression en clair, qui est le nombre d’itérations entre les impressions dans la fenêtre de commande, spécifiée comme un entier positif.

Si vous effectuez une validation du réseau de neurones pendant son apprentissage, le software affichera également les résultats dans la fenêtre de commande à chaque validation effectuée.

Pour activer cette propriété, définissez l’option d’apprentissage Verbose à 1 (true).

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

OutputFcn — Fonctions de sortie

handle de fonction | cell array de handles de fonction

Fonctions de sortie à appeler pendant l’apprentissage, spécifiées comme un handle de fonction ou un cell array de handles de fonction. Le software appelle les fonctions une fois avant le début de l’apprentissage, après chaque itération et une fois quand l’apprentissage est terminé.

Les fonctions doivent avoir la syntaxe stopFlag = f(info), où info est une structure contenant des informations sur la progression de l’apprentissage et stopFlag est un scalaire indiquant d’arrêter l’apprentissage de manière précoce. Si stopFlag est à 1 (true), le software arrête l’apprentissage. Sinon, il le poursuit.

La fonction trainnet passe la structure info à la fonction de sortie.

Pour les solveurs stochastiques (SGDM, Adam et RMSProp), info contient les champs suivants :

Champ	Description
Epoch	Numéro d’epoch
Iteration	Numéro d’itération
TimeElapsed	Temps écoulé depuis le début de l’apprentissage
LearnRate	Taux d’apprentissage de l’itération
TrainingLoss	Perte de l’apprentissage de l’itération
ValidationLoss	Perte de la validation si spécifiée et évaluée à cette itération.
State	État de l’apprentissage lors de l’itération, spécifié comme "start", "iteration" ou "done".

Pour les solveurs en batch (L-BFGS et LM), info contient les champs suivants :

Champ	Description
Iteration	Numéro d’itération
TimeElapsed	Temps écoulé en heures, minutes et secondes
TrainingLoss	Perte lors de l'apprentissage
ValidationLoss	Perte lors de la validation. Si vous ne spécifiez pas de données de validation, le software n’affiche pas cette information.
GradientNorm	Norme des gradients
StepNorm	Norme des pas
State	État de l’apprentissage lors de l’itération, spécifié comme "start", "iteration" ou "done".

Si vous spécifiez des métriques supplémentaires dans les options d’apprentissage, elles apparaissent également dans les informations sur l’apprentissage. Par exemple, si vous définissez l’option d’apprentissage Metrics à "accuracy", les informations incluent les champs TrainingAccuracy et ValidationAccuracy.

Si un champ n’est pas calculé ou pertinent pour un certain appel des fonctions de sortie, ce champ contient un tableau vide.

Vous trouverez un exemple illustrant comment utiliser des fonctions de sortie dans Custom Stopping Criteria for Deep Learning Training.

Types de données : function_handle | cell

Formats de données

InputDataFormats — Description des dimensions des données en entrée

"auto" (par défaut) | tableau de chaînes de caractères | cell array de vecteurs de caractères | vecteur de caractères

Depuis R2023b

Description des dimensions des données en entrée, spécifiée comme un tableau de string, un vecteur de caractères ou un cell array de vecteurs de caractères.

Si InputDataFormats est "auto", le software utilise les formats attendus par l’entrée du réseau. Sinon, il utilise les formats spécifiés pour l’entrée du réseau correspondante.

Un format de données est une chaîne de caractères où chaque caractère décrit le type de la dimension correspondante des données.

Les caractères sont les suivants :

• "S" — Spatial

• "C" — Canal

• "B" — Batch

• "T" — Temps

• "U" — Non spécifié

Prenons l’exemple d’un tableau contenant un batch de séquences dont les première, deuxième et troisième dimensions correspondent respectivement aux canaux, aux observations et aux pas de temps. Vous pouvez spécifier que ce tableau a le format "CBT" (canal, batch, temps).

Vous pouvez spécifier plusieurs dimensions ayant l’étiquette "S" ou "U". Vous pouvez utiliser les étiquettes "C", "B" et "T" au maximum une fois chacune. Le software ignore les dimensions unitaires "U" après la deuxième dimension.

Pour un réseau de neurones net possédant plusieurs entrées, spécifiez un tableau de formats de données en entrée où InputDataFormats(i) correspond à l’entrée net.InputNames(i).

Pour plus d’informations, veuillez consulter Deep Learning Data Formats.

Types de données : char | string | cell

TargetDataFormats — Description des dimensions des données cibles

"auto" (par défaut) | tableau de chaînes de caractères | cell array de vecteurs de caractères | vecteur de caractères

Depuis R2023b

Description des dimensions des données cibles, spécifiée comme l’une des valeurs suivantes :

• "auto" — Si les données cibles ont le même nombre de dimensions que les données en entrée, la fonction trainnet utilise le format spécifié par InputDataFormats. Si les données cibles n’ont pas le même nombre de dimensions que les données en entrée, la fonction trainnet utilise le format attendu par la fonction de perte.

• Tableau de string, vecteur de caractères ou cell array de vecteurs de caractères — La fonction trainnet utilise les formats de données que vous spécifiez.

Un format de données est une chaîne de caractères où chaque caractère décrit le type de la dimension correspondante des données.

Les caractères sont les suivants :

• "S" — Spatial

• "C" — Canal

• "B" — Batch

• "T" — Temps

• "U" — Non spécifié

Prenons l’exemple d’un tableau contenant un batch de séquences dont les première, deuxième et troisième dimensions correspondent respectivement aux canaux, aux observations et aux pas de temps. Vous pouvez spécifier que ce tableau a le format "CBT" (canal, batch, temps).

Vous pouvez spécifier plusieurs dimensions ayant l’étiquette "S" ou "U". Vous pouvez utiliser les étiquettes "C", "B" et "T" au maximum une fois chacune. Le software ignore les dimensions unitaires "U" après la deuxième dimension.

Pour plus d’informations, veuillez consulter Deep Learning Data Formats.

Types de données : char | string | cell

Options des solveurs stochastiques

MaxEpochs — Nombre maximal d’epochs

30 (par défaut) | entier positif

Nombre maximal d’epochs (passes complètes sur les données) à utiliser pour l’apprentissage, spécifié comme un entier positif.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

MiniBatchSize — Taille du mini-batch

128 (par défaut) | entier positif

Taille du mini-batch à utiliser pour chaque itération d’apprentissage, spécifiée comme un entier positif. Un mini-batch est un sous-ensemble du jeu d’apprentissage qui est utilisé pour évaluer le gradient de la fonction de perte et mettre à jour les poids.

Si la taille du mini-batch ne divise pas uniformément le nombre d’échantillons d’apprentissage, le software ignore les données d’apprentissage qui ne rentrent pas dans le mini-batch complet final de chaque epoch. Si la taille du mini-batch est inférieure au nombre d’échantillons d’apprentissage, le software n’ignore aucune donnée.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Shuffle — Option de mélange des données

"once" (par défaut) | "never" | "every-epoch"

Option de mélange des données, spécifiée comme l’une des valeurs suivantes :

• "once" — Mélanger les données d’apprentissage et de validation une fois avant l’apprentissage.

• "never" — Ne pas mélanger les données.

• "every-epoch" — Mélanger les données d’apprentissage avant chaque epoch d’apprentissage et mélanger les données de validation avant chaque validation du réseau de neurones. Si la taille du mini-batch ne divise pas uniformément le nombre d’échantillons d’apprentissage, le software ignore les données d’apprentissage qui ne rentrent pas dans le mini-batch complet final de chaque epoch. Pour éviter d’ignorer les mêmes données à chaque epoch, définissez l’option d’apprentissage Shuffle à "every-epoch".

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

InitialLearnRate — Taux d’apprentissage initial

scalaire positif

Le taux d’apprentissage initial utilisé pour l’apprentissage est spécifié comme un scalaire positif.

Si le taux d’apprentissage est trop faible, l’apprentissage peut prendre beaucoup de temps. Si le taux d’apprentissage est trop élevé, l’apprentissage peut atteindre un résultat sous-optimal ou diverger.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Lorsque solverName est "sgdm", la valeur par défaut est 0.01. Lorsque solverName est "rmsprop" ou "adam", la valeur par défaut est 0.001.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LearnRateSchedule — Programmation du taux d’apprentissage

"none" (par défaut) | vecteur de caractères | tableau de chaînes de caractères | objet programmation du taux d’apprentissage prédéfinie ou personnalisée | handle de fonction | cell array

Programmation du taux d’apprentissage, définie sous la forme d'un vecteur de caractères ou un string scalar contenant le nom d’une programmation du taux d’apprentissage prédéfinie, un tableau de chaînes de caractères de noms, un objet programmation du taux d’apprentissage prédéfinie ou personnalisée, un handle de fonction ou un cell array de noms, d’objets métriques et de handles de fonction.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Noms des programmations de taux d’apprentissage prédéfinies

Spécifiez les programmations de taux d’apprentissage sous la forme d'un string scalar, un vecteur de caractères, ou bien un tableau de chaîne de caractères ou un cell array contenant un ou plusieurs des noms suivants :

Nom	Description	Tracé
"none"	Aucune programmation du taux d’apprentissage. Cette programmation maintient le taux d'apprentissage constant.
"piecewise"	Programmation du taux d’apprentissage par morceaux Tous les 10 epochs, cette programmation réduit le taux d'apprentissage d'un facteur de 10.
"warmup" (depuis R2024b)	Programmation du taux d’apprentissage d’échauffement. Pendant 5 itérations, cette programmation augmente le taux d'apprentissage jusqu'à atteindre le taux d'apprentissage de base.
"polynomial" (depuis R2024b)	Programmation du taux d’apprentissage polynomiale. À chaque epoch, cette programmation réduit le taux d'apprentissage en utilisant une loi de puissance avec un exposant unitaire.
"exponential" (depuis R2024b)	Programmation du taux d’apprentissage exponentielle. À chaque epoch, cette programmation réduit le taux d’apprentissage d’un facteur de 10.
"cosine" (depuis R2024b)	Programmation du taux d’apprentissage en cosinus. À chaque epoch, cette programmation réduit le taux d'apprentissage en utilisant une formule de cosinus.
"cyclical" (depuis R2024b)	Programmation du taux d’apprentissage cyclique. Pour les périodes de 10 epochs, cette programmation augmente le taux d'apprentissage à partir du taux d'apprentissage de base pendant 5 epochs, puis réduit le taux d'apprentissage pendant 5 epochs.

Objet programmation du taux d’apprentissage prédéfinie (depuis R2024b)

Si vous avez besoin de plus de flexibilité que ce que les options décrites sous forme d'une chaîne de caractères vous proposent, vous pouvez utiliser des objets programmation du taux d’apprentissage prédéfinis :

• piecewiseLearnRate — Un objet programmation du taux d'apprentissage par morceaux réduit le taux d'apprentissage à intervalles réguliers en le multipliant par un facteur spécifié. Cet objet permet de personnaliser le facteur de réduction (drop factor) et la période de la programmation par morceaux.

  Avant R2024b : Personnalisez le facteur de réduction par morceaux et la période en utilisant respectivement les options d’apprentissage LearnRateDropFactor et LearnRateDropPeriod.

• warmupLearnRate — Un objet programmation du taux d'apprentissage d'échauffement accélère l'apprentissage pendant un nombre spécifié d'itérations. Cet objet permet de personnaliser les facteurs de taux d'apprentissage initial et final, ainsi que le nombre d'étapes du plan d'échauffement.

• polynomialLearnRate — Une programmation du taux d’apprentissage polynomiale réduit le taux d'apprentissage en utilisant une loi de puissance. Cet objet permet de personnaliser les facteurs de taux d'apprentissage initial et final, l’exposant, ainsi que le nombre d'étapes de la programmation polynomiale.

• exponentialLearnRate — Une programmation du taux d’apprentissage exponentielle réduit le taux d’apprentissage d’un facteur défini. Cet objet permet de personnaliser le facteur de réduction et la période de la programmation exponentielle.

• cosineLearnRate — Une programmation du taux d’apprentissage en cosinus réduit le taux d'apprentissage en utilisant une courbe de cosinus et intègre des redémarrages à chaud. Cet objet permet de personnaliser les facteurs de taux d'apprentissage initial et final, la période et le facteur de croissance périodique de la programmation en cosinus.

• cyclicalLearnRate — Un programmation du taux d’apprentissage cyclique augmente et réduit à intervalles réguliers le taux d'apprentissage. Cette option permet de personnaliser le facteur maximal, la période et le rapport de pas de la programmation cyclique.

Programmation du taux d’apprentissage personnalisée (depuis R2024b)

Pour plus de flexibilité, vous pouvez définir une programmation du taux d'apprentissage personnalisée sous la forme d'un handle de fonction ou d'une classe personnalisée qui hérite de deep.LearnRateSchedule.

• Handle de fonction pour une programmation du taux d'apprentissage personnalisée — Si aucune programmation du taux d'apprentissage prédéfinie ne correspond à vos besoins, vous pouvez spécifier des programmations personnalisées avec un handle de fonction. Pour spécifier une programmation personnalisée, utilisez un handle de fonction avec la syntaxe learningRate = f(baseLearningRate,epoch),où baseLearningRate désigne le taux d'apprentissage de base et epoch, le nombre d’epochs.

• Objet programmation du taux d’apprentissage personnalisée — Si vous avez besoin de davantage de flexibilité que ce que les handles de fonction peuvent vous proposer, vous pouvez définir une programmation du taux d'apprentissage personnalisée sous la forme d'une classe qui hérite de deep.LearnRateSchedule.

Programmations de taux d’apprentissage multiples (depuis R2024b)

Vous pouvez combiner plusieurs programmations de taux d'apprentissage en spécifiant plusieurs programmations sous la forme d'un string ou d’un cell array. Le logiciel applique alors les programmations dans l'ordre, en commençant par le premier élément. Au maximum l'une des programmations peut être infinie (programmations qui se poursuivent indéfiniment, tels que "cyclical" et les objets dont la propriété NumSteps est définie sur Inf) et la programmation infinie doit être le dernier élément du tableau.

Momentum — Contribution de l’étape précédente

0.9 (par défaut) | scalaire entre 0 et 1

La contribution de l’étape de mise à jour des paramètres, de l’itération précédente à l’itération actuelle, dans la descente de gradient stochastique avec momentum, est définie par un scalaire compris entre 0 et 1.

Une valeur de 0 signifie une absence de contribution de l’étape précédente, tandis qu’une valeur de 1 signifie une contribution maximale de l’étape précédente. La valeur par défaut fonctionne bien pour la plupart des tâches.

Cette option supporte uniquement le solveur SGDM (lorsque l’argument solverName est "sgdm").

Pour plus d’informations, veuillez consulter Descente de gradient stochastique avec momentum.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

GradientDecayFactor — Taux de décroissance de la moyenne mobile du gradient

0.9 (par défaut) | scalaire non négatif inférieur à 1

Le taux de décroissance de la moyenne mobile du gradient pour le solveur Adam est défini par un scalaire non négatif inférieur à 1. Le taux de décroissance du gradient est désigné par β1 dans la section Estimation adaptative des moments.

Cette option supporte uniquement le solveur Adam (lorsque l’argument solverName est "adam").

Pour plus d’informations, veuillez consulter Estimation adaptative des moments.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

SquaredGradientDecayFactor — Taux de décroissance de la moyenne mobile du gradient au carré

scalaire non négatif inférieur à 1

Le taux de décroissance de la moyenne mobile du gradient au carré pour les solveurs Adam et RMSProp est défini par un scalaire non négatif inférieur à 1. Le taux de décroissance du gradient au carré est désigné par β2 dans [4].

Les valeurs typiques du taux de décroissance sont 0.9, 0.99 et 0.999, ce qui correspond respectivement aux longueurs moyennes de 10, 100 et 1000 mises à jour de paramètres.

Cette option supporte uniquement les solveurs Adam et RMSProp (lorsque l’argument solverName est "adam" ou "rmsprop").

La valeur par défaut est 0.999 pour le solveur Adam. La valeur par défaut est 0.9 pour le solveur RMSProp.

Pour plus d’informations, veuillez consulter Estimation adaptative des moments et Propagation de la moyenne quadratique.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Epsilon — Offset du dénominateur

1e-8 (par défaut) | scalaire positif

L'offset du dénominateur pour les solveurs Adam et RMSProp est spécifié comme un scalaire positif.

Le solveur ajoute l’offset au dénominateur dans les mises à jour des paramètres du réseau de neurones pour éviter la division par zéro. La valeur par défaut fonctionne bien pour la plupart des tâches.

Cette option supporte uniquement les solveurs Adam et RMSProp (lorsque l’argument solverName est "adam" ou "rmsprop").

Pour plus d’informations, veuillez consulter Estimation adaptative des moments et Propagation de la moyenne quadratique.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LearnRateDropFactor — Facteur pour la réduction du taux d’apprentissage

0.1 (par défaut) | scalaire entre 0 et 1

Le facteur pour la réduction du taux d’apprentissage est spécifié comme un scalaire compris entre 0 et 1. Cette option est valide uniquement si l’option d’apprentissage LearnRateSchedule est "piecewise".

LearnRateDropFactor est un facteur de multiplication à appliquer au taux d’apprentissage chaque fois qu’un certain nombre d’epochs est atteint. Spécifiez le nombre d’epochs avec l’option d’apprentissage LearnRateDropPeriod.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Conseil

Pour personnaliser la programmation du taux d’apprentissage par morceaux, utilisez un objet piecewiseLearnRate. Un objet piecewiseLearnRate est recommandé par rapport aux options d’apprentissage LearnRateDropFactor et LearnRateDropPeriod car il offre un contrôle supplémentaire de la fréquence de réduction. (depuis R2024b)

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LearnRateDropPeriod — Nombre d’epochs pour la réduction du taux d’apprentissage

10 (par défaut) | entier positif

Le nombre d’epochs pour la réduction du taux d’apprentissage est spécifié en tant qu'un entier positif. Cette option est valide uniquement si l’option d’apprentissage LearnRateSchedule est "piecewise".

Le software multiplie le taux d’apprentissage global par le facteur de réduction chaque fois que le nombre spécifié d’epochs est atteint. Spécifiez le facteur de réduction avec l’option d’apprentissage LearnRateDropFactor.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Conseil

Pour personnaliser la programmation du taux d’apprentissage par morceaux, utilisez un objet piecewiseLearnRate. Un objet piecewiseLearnRate est recommandé par rapport aux options d’apprentissage LearnRateDropFactor et LearnRateDropPeriod car il offre un contrôle supplémentaire de la fréquence de réduction. (depuis R2024b)

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Options du solveur en batch

MaxIterations — Nombre maximal d’itérations

1000 (par défaut) | entier positif

Depuis R2023b

Nombre maximal d’itérations à utiliser pour l’apprentissage, spécifié comme un entier positif.

Le solveur L-BFGS est un solveur en batch complet, ce qui signifie qu’il traite l’intégralité du jeu d’apprentissage en une seule itération.

Cette option supporte uniquement les solveurs en batch (lorsque l’argument solverName est "lbfgs" ou "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

GradientTolerance — Tolérance du gradient relatif

1e-5 (par défaut) | scalaire positif

Depuis R2023b

Tolérance du gradient relatif, défini par un scalaire positif.

Le software arrête l’apprentissage lorsque le gradient relatif est inférieur ou égal à GradientTolerance.

Cette option supporte uniquement les solveurs en batch (lorsque l’argument solverName est "lbfgs" ou "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

StepTolerance — Tolérance du pas

1e-5 (par défaut) | scalaire positif

Depuis R2023b

Tolérance du pas, défini par un scalaire positif.

Le software arrête l’apprentissage lorsque le pas pris par l’algorithme est inférieur ou égal à StepTolerance.

Cette option supporte uniquement les solveurs en batch (lorsque l’argument solverName est "lbfgs" ou "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LineSearchMethod — Méthode pour trouver un taux d’apprentissage adapté

"weak-wolfe" (par défaut) | "strong-wolfe" | "backtracking"

Depuis R2023b

Méthode pour trouver un taux d’apprentissage adapté, spécifiée comme l’une des valeurs suivantes :

• "weak-wolfe" — Rechercher un taux d’apprentissage satisfaisant aux conditions faibles de Wolfe. Cette méthode maintient une approximation définie positive de la matrice hessienne inverse.

• "strong-wolfe" — Rechercher un taux d’apprentissage satisfaisant aux conditions fortes de Wolfe. Cette méthode maintient une approximation définie positive de la matrice hessienne inverse.

• "backtracking" — Rechercher un taux d’apprentissage satisfaisant aux conditions de décroissance suffisante. Cette méthode ne maintient pas une approximation définie positive de la matrice hessienne inverse.

Cette option supporte uniquement le solveur L-BFGS (lorsque l’argument solverName est "lbfgs").

HistorySize — Nombre de mises à jour d’état à stocker

10 (par défaut) | entier positif

Depuis R2023b

Nombre de mises à jour d’état à stocker, défini par un entier positif. Des valeurs comprises entre 3 et 20 conviennent à la plupart des tâches.

L’algorithme L-BFGS utilise un historique de calculs de gradient pour approximer la matrice hessienne de manière récursive. Pour plus d’informations, veuillez consulter Limited-Memory BFGS.

Cette option supporte uniquement le solveur L-BFGS (lorsque l’argument solverName est "lbfgs").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

InitialInverseHessianFactor — Valeur initiale caractérisant la matrice hessienne inverse approximée

1 (par défaut) | scalaire positif

Depuis R2023b

Valeur initiale caractérisant la matrice hessienne inverse approximée, spécifiée comme un scalaire positif.

Pour économiser de la mémoire, l’algorithme L-BFGS ne stocke et n’inverse pas la matrice hessienne dense B. Au lieu de cela, il utilise l’approximation $$B_{k-m}^{-1}\approx {\lambda }_{k}I$$, où m est la taille de l’historique, le facteur hessien inverse $${\lambda }_k$$ est un scalaire et I est la matrice d’identité. Ensuite, l’algorithme stocke uniquement le facteur hessien inverse scalaire et le met à jour à chaque pas.

Le facteur hessien inverse initial est la valeur de $${\lambda }_0$$.

Pour plus d’informations, veuillez consulter Limited-Memory BFGS.

Cette option supporte uniquement le solveur L-BFGS (lorsque l’argument solverName est "lbfgs").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

MaxNumLineSearchIterations — Nombre maximal d’itérations de recherche linéaire

20 (par défaut) | entier positif

Depuis R2023b

Nombre maximal d’itérations de recherche linéaire pour déterminer le taux d’apprentissage, défini par un entier positif.

Cette option supporte uniquement le solveur L-BFGS (lorsque l’argument solverName est "lbfgs").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

InitialStepSize — Approximer la valeur absolue maximale de la première étape d’optimisation

[] (par défaut) | "auto" | scalaire fini réel

Depuis R2024b

Taille de pas initiale, spécifiée comme l’une des valeurs suivantes :

• [] — N'utilisez pas une taille de pas initiale pour déterminer l'approximation hessienne initiale.

• "auto" — Déterminez la taille de pas initiale automatiquement. Le logiciel utilise une taille de pas initiale de $$\Vert s_0{\Vert }_{\infty }=\frac{1}{2}\Vert W_0{\Vert }_{\infty }+0.1$$, où W₀ correspondent aux paramètres entraînables initiaux du réseau.

• Scalaire réel positif — Utilisez la valeur spécifiée en tant que taille de pas initiale $$\Vert s_0{\Vert }_{\infty }$$.

Si InitialStepSize est "auto" ou un scalaire réel positif, le logiciel approxime le hessien inverse initial en utilisant $${\lambda }_0=\frac{\Vert s_0{\Vert }_{\infty }}{\Vert \nabla J(W_0){\Vert }_{\infty }}$$, où λ₀ désigne le facteur hessien inverse initial et $$\nabla J(W_0)$$ représente les gradients de la perte par rapport aux paramètres entraînables initiaux. Pour plus d’informations, veuillez consulter BFGS à mémoire limitée.

Cette option supporte uniquement le solveur L-BFGS (lorsque l’argument solverName est "lbfgs").

InitialDampingFactor — Facteur d’amortissement initial

0.001 (par défaut) | scalaire positif

Depuis R2024b

Facteur d’amortissement initial, défini par un scalaire positif.

Cette option supporte uniquement le solveur LM (lorsque l’argument solverName est "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

MaxDampingFactor — Facteur d’amortissement maximal

1e10 (par défaut) | scalaire positif

Depuis R2024b

Facteur d’amortissement maximal, défini par un scalaire positif.

Cette option supporte uniquement le solveur LM (lorsque l’argument solverName est "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

DampingIncreaseFactor — Facteur d’augmentation du facteur d’amortissement

10 (par défaut) | scalaire positif supérieur à 1

Depuis R2024b

Facteur d'augmentation du facteur d’amortissement, défini par un scalaire positif supérieur à 1.

Cette option supporte uniquement le solveur LM (lorsque l’argument solverName est "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

DampingDecreaseFactor — Facteur de réduction du facteur d’amortissement

0.1 (par défaut) | scalaire positif inférieur à 1

Depuis R2024b

Facteur de réduction du facteur d’amortissement, défini par un scalaire positif inférieur à 1.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Validation

ValidationData — Données à utiliser pour la validation pendant l’apprentissage

[] (par défaut) | datastore | table | cell array | objet minibatchqueue (depuis R2024a)

Données à utiliser pour la validation pendant l’apprentissage, définies par [], un datastore, une table, un cell array ou un objet minibatchqueue contenant les prédicteurs et cibles de validation.

Pendant l’apprentissage, le software utilise les données de validation pour calculer la perte et les métriques de validation. Pour spécifier la fréquence de validation, utilisez l’option d’apprentissage ValidationFrequency. Vous pouvez également utiliser les données de validation pour arrêter automatiquement l’apprentissage lorsque la métrique d'évaluation de la validation cesse de s’améliorer. Par défaut, la métrique d'évaluation est définie comme étant la perte (loss). Pour activer l’arrêt automatique de la validation, utiliser l’option d’apprentissage ValidationPatience.

Si ValidationData est [], le software ne valide pas le réseau de neurones pendant l’apprentissage.

Si votre réseau de neurones possède des couches qui se comportent différemment entre la prédiction et l’apprentissage (par exemple des couches de décrochage (dropout)), la perte de la validation peut être inférieure à la perte de l’apprentissage.

Le software mélange les données de validation selon l’option d’apprentissage Shuffle. Si Shuffle est "every-epoch", le software mélange les données de validation avant chaque validation du réseau de neurones.

Les formats supportés dépendent de la fonction d’apprentissage utilisée.

Fonction trainnet

Spécifiez les données de validation comme un datastore, un objet minibatchqueue ou le cell array {predictors,targets}, où predictors contient les prédicteurs de la validation et targets contient les cibles de la validation. Spécifiez les prédicteurs et les cibles de la validation avec les formats supportés par la fonction trainnet.

Pour plus d’informations, veuillez consulter les arguments en entrée de la fonction trainnet.

Fonction trainBERTDocumentClassifier (Text Analytics Toolbox)

Spécifiez les données de validation comme l’une des valeurs suivantes :

• Cell array {documents,targets}, où documents contient les documents en entrée et targets contient les étiquettes de document.

• Table, où la première variable contient les documents en entrée et la deuxième variable contient les étiquettes de document.

Pour plus d’informations, veuillez consulter les arguments en entrée de la fonction trainBERTDocumentClassifier (Text Analytics Toolbox).

ValidationFrequency — Fréquence de validation du réseau de neurones

50 (par défaut) | entier positif

Fréquence de validation du réseau de neurones en nombre d’itérations, spécifiée comme un entier positif.

La valeur ValidationFrequency est le nombre d’itérations entre les évaluations des métriques de validation. Pour spécifier les données de validation, utilisez l’option d’apprentissage ValidationData.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

ValidationPatience — Patience pour l’arrêt de la validation

Inf (par défaut) | entier positif

Patience de l’arrêt de la validation de l’apprentissage du réseau de neurones, définie par un entier positif ou Inf.

ValidationPatience détermine combien de fois la performance sur le jeu de validation peut être inférieure ou égale à la meilleure performance déjà obtenue sans que cela entraîne l'arrêt de l'apprentissage du réseau de neurones. Si ValidationPatience est Inf, les valeurs de la métrique de validation n’entraînent pas l’arrêt précoce de l’apprentissage. Le software cherche à maximiser ou minimiser la métrique selon ce qu’indique la propriété Maximize de cette métrique. Lorsque la métrique d'évaluation est "loss", le software cherche à minimiser la valeur de la perte.

Le réseau de neurones renvoyé dépend de l’option d’apprentissage OutputNetwork. Pour renvoyer le réseau de neurones avec la meilleure valeur de métrique de validation, définissez l’option d’apprentissage OutputNetwork à "best-validation".

Avant R2024a : Le software calcule la patience de la validation en utilisant la valeur de perte de la validation.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

OutputNetwork — Réseau de neurones à renvoyer lorsque l’apprentissage est terminé

"auto" (par défaut) | "last-iteration" | "best-validation"

Réseau de neurones à renvoyer lorsque l’apprentissage est terminé, spécifié comme l’un des éléments suivants :

• "auto" – Utilise "best-validation" si ValidationData est spécifié. Sinon, utilise "last-iteration".

• "best-validation" – Renvoie le réseau de neurones correspondant à l’itération d’apprentissage avec la meilleure valeur de métrique de validation, la métrique à optimiser étant spécifiée par l’option ObjectiveMetricName. Pour utiliser cette option, vous devez spécifier l’option d’apprentissage ValidationData.

• "last-iteration" – Renvoie le réseau de neurones correspondant à la dernière itération d’apprentissage.

Régularisation et normalisation

L2Regularization — Facteur de régularisation L₂

0.0001 (par défaut) | scalaire non négatif

Le facteur de régularisation L₂ (décroissance du poids) est spécifié comme un scalaire non négatif. Pour plus d’informations, veuillez consulter Régularisation L2.

Cette option ne supporte pas le solveur LM (lorsque l’argument solverName est "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

ResetInputNormalization — Option de réinitialisation de la normalisation de la couche d’entrée

1 (true) (par défaut) | 0 (false)

Option de réinitialisation de la normalisation de la couche d’entrée, définie par l'un des éléments suivants :

• 1 (true) — Réinitialise les statistiques de normalisation de la couche d’entrée et les recalcule au moment de l’apprentissage.

• 0 (false) — Calcule les statistiques de normalisation au moment de l’apprentissage lorsqu’elles sont vides.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

BatchNormalizationStatistics — Mode d’évaluation des statistiques dans les couches de normalisation par batchs

"auto" (par défaut) | "population" | "moving"

Mode d’évaluation des statistiques dans les couches de normalisation par batchs, défini par l’un des éléments suivants :

• "population" — Utilise les statistiques de population. Après l’apprentissage, le software finalise les statistiques en passant à nouveau par les données d’apprentissage et utilise la moyenne et la variance correspondantes.

• "moving" — Approxime les statistiques pendant l’apprentissage avec une estimation continue donnée par les étapes de mises à jour

  $$\begin{array}{l}{\mu }^{*}={\lambda }_{\mu }\widehat{\mu }+(1-{\lambda }_{\mu })\mu \\ {\sigma }^2{}^{*}={\lambda }_{{\sigma }^2}\widehat{{\sigma }^2}\text{}\text{+}\text{}\text{(1-}{\lambda }_{{\sigma }^2})\text{}{\sigma }^2\end{array}$$

  où $${\mu }^{*}$$ et $${\sigma }^2{}^{*}$$ désignent respectivement la moyenne et la variance mises à jour, $${\lambda }_{\mu }$$ et $${\lambda }_{{\sigma }^2}$$ désignent respectivement les valeurs de décroissance de la moyenne et de la variance, $$\widehat{\mu }$$ et $$\widehat{{\sigma }^2}$$ désignent respectivement la moyenne et la variance de la couche d’entrée, et $$\mu$$ et $${\sigma }^2$$ désignent respectivement les dernières valeurs de la moyenne et de la variance mobiles. Après l’apprentissage, le software utilise la valeur la plus récente des statistiques de moyenne mobile et de variance. Cette option supporte seulement l’apprentissage sur CPU ou sur un GPU unique.

• "auto" — Utilise l’option "moving".

Écrêtage de gradient

GradientThreshold — Seuil de gradient

Inf (par défaut) | scalaire positif

Le seuil de gradient est défini par Inf ou un scalaire positif. Si le gradient dépasse la valeur de GradientThreshold, le gradient est écrêté selon l’option d’apprentissage GradientThresholdMethod.

Pour plus d’informations, veuillez consulter Écrêtage de gradient.

Cette option ne supporte pas le solveur LM (lorsque l’argument solverName est "lm").

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

GradientThresholdMethod — Méthode de seuil de gradient

"l2norm" (par défaut) | "global-l2norm" | "absolute-value"

La méthode de seuil de gradient utilisée pour écrêter des valeurs de gradients dépassant le seuil de gradient est spécifiée comme l’un des éléments suivants :

• "l2norm" — Si la norme L₂ du gradient d’un paramètre entraînable est supérieure à GradientThreshold, mettre à l’échelle le gradient pour que la norme L₂ soit égale à GradientThreshold.

• "global-l2norm" — Si la norme L₂ globale, L, est supérieure à GradientThreshold, mettre à l’échelle tous les gradients par un facteur de GradientThreshold/L. La norme L₂ globale prend en compte tous les paramètres entraînables.

• "absolute-value" — Si la valeur absolue d’une dérivée partielle individuelle dans le gradient d’un paramètre entraînable est supérieure à GradientThreshold, mettre à l’échelle la dérivée partielle pour avoir une amplitude égale à GradientThreshold et conserver le signe de la dérivée partielle.

Pour plus d’informations, veuillez consulter Écrêtage de gradient.

Cette option ne supporte pas le solveur LM (lorsque l’argument solverName est "lm").

Séquence

SequenceLength — Options de remplissage et de troncature des séquences

"longest" (par défaut) | "shortest"

Options de remplissage, de troncature et de division des séquences d’entrée, spécifiées comme l’une des valeurs suivantes :

• "longest" — Remplir les séquences dans chaque mini-batch afin qu’elles aient la même longueur que la séquence la plus longue. Cette option n’ignore aucune donnée mais le remplissage peut introduire du bruit dans le réseau de neurones.

• "shortest" — Tronquer les séquences dans chaque mini-batch afin qu’elles aient la même longueur que la séquence la plus courte. Cette option garantit qu’il n’y a pas de remplissage, mais des données seront ignorées.

Pour en savoir plus sur l’effet du remplissage et de la troncature des séquences, veuillez consulter Sequence Padding and Truncation.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | char | string

SequencePaddingDirection — Direction du remplissage ou de la troncature

"right" (par défaut) | "left"

La direction du remplissage ou de la troncature est spécifiée comme étant l’une des options suivantes :

• "right" — Remplir ou tronquer les séquences sur la droite. Les séquences commencent au même pas de temps et le logiciel tronque ou fait du remplissage à la fin de chaque séquence.

• "left" — Remplir ou tronquer les séquences sur la gauche. Le logiciel tronque ou fait du remplissage au début de chaque séquence afin que les séquences finissent au même pas de temps.

Les couches récurrentes traitant les données des séquences un pas de temps à la fois, lorsque la propriété OutputMode de la couche récurrente est "last", le remplissage des derniers pas de temps peut influencer négativement la sortie de la couche. Pour remplir ou tronquer les données des séquences sur la gauche, définissez l’argument SequencePaddingDirection sur "left".

Pour les réseaux de neurones de séquence à séquence (lorsque la propriété OutputMode est "sequence" pour chaque couche récurrente), le remplissage des premiers pas de temps peut influencer négativement les prédictions des pas de temps précédents. Pour remplir ou tronquer les données des séquences sur la droite, définissez l’option SequencePaddingDirection à "right".

Pour en savoir plus sur les effets du remplissage et de la troncature des séquences, veuillez consulter Sequence Padding and Truncation.

SequencePaddingValue — Valeur avec laquelle le remplissage des séquences en entrée sera effectué

0 (par défaut) | scalaire

La valeur avec laquelle le remplissage des séquences en entrée sera effectué, définie par un scalaire.

Ne remplissez pas des séquences avec NaN, car cela peut propager des erreurs à travers tout le réseau de neurones.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Hardware et accélération

ExecutionEnvironment — Ressource hardware pour l'apprentissage du réseau de neurones

"auto" (par défaut) | "cpu" | "gpu" | "multi-gpu" | "parallel-auto" | "parallel-cpu" | "parallel-gpu"

Ressource hardware pour l'apprentissage du réseau de neurones, définie par l’une des valeurs suivantes :

• "auto" – Utiliser un GPU local si disponible. Sinon, utiliser le CPU local.

• "cpu" – Utiliser le CPU local.

• "gpu" – Utiliser le GPU local.

• "multi-gpu" – Utiliser plusieurs GPU sur une machine, avec un pool parallèle local basé sur votre profil de cluster par défaut. S’il n’y a pas de pool parallèle, le software démarre un pool parallèle avec une taille de pool égale au nombre de GPU disponibles.

• "parallel-auto" – Utiliser un pool parallèle local ou distant. S’il n’y a pas de pool parallèle, le software en démarre un avec le profil de cluster par défaut. Si le pool a accès aux GPU, seuls les workers avec un GPU unique réalisent le calcul d’apprentissage. Les workers en trop deviennent inactifs. Si le pool n’a pas de GPU, l’apprentissage a lieu sur tous les travailleurs CPU disponibles. (depuis R2024a)

  Avant R2024a : Utilisez "parallel" à la place.

• "parallel-cpu" – Utiliser les ressources CPU dans un pool parallèle local ou distant en ignorant les GPU. S’il n’y a pas de pool parallèle, le software en démarre un avec le profil de cluster par défaut. (depuis R2023b)

• "parallel-gpu" – Utiliser les GPU dans un pool parallèle local ou distant. Les workers en trop deviennent inactifs. S’il n’y a pas de pool parallèle, le software en démarre un avec le profil de cluster par défaut. (depuis R2023b)

Les options "gpu", "multi-gpu", "parallel-auto", "parallel-cpu" et "parallel-gpu" nécessitent Parallel Computing Toolbox™. Pour utiliser un GPU pour le Deep Learning, vous devez également disposer d’un équipement GPU supporté. Pour plus d'information sur les dispositifs supportés, veuillez consulter Exigences de calcul du GPU (Parallel Computing Toolbox). Si vous choisissez une de ces options et que Parallel Computing Toolbox ou un GPU adapté n’est pas disponible, le software renvoie une erreur.

Pour plus d’informations sur l’utilisation des différents environnements d’exécution, veuillez consulter Scale Up Deep Learning in Parallel, on GPUs, and in the Cloud.

Pour améliorer les performances de l’apprentissage en parallèle, essayez d’augmenter les options d’apprentissage MiniBatchSize et InitialLearnRate par le nombre de GPU.

Les options "multi-gpu", "parallel-auto", "parallel-cpu" et "parallel-gpu" supportent uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

PreprocessingEnvironment — Environnement d’extraction et de prétraitement des données

"serial" (par défaut) | "background" | "parallel"

Depuis R2024a

Environnement d’extraction et de prétraitement des données à partir d’un datastore pendant l’apprentissage, défini par l’une des valeurs suivantes :

• "serial" – Extraire et prétraiter les données en série.

• "background" – Extraire et prétraiter les données avec le backgroundPool.

• "parallel" – Extraire et prétraiter les données avec des workers parallèles. Le software ouvre un pool parallèle avec le profil par défaut si aucun pool local n’est actuellement ouvert. Les pools parallèles non locaux ne sont pas supportés. L’utilisation de cette option nécessite Parallel Computing Toolbox. Cette option n’est pas supportée lors de l’apprentissage en parallèle (lorsque l’option ExecutionEnvironment est "parallel-auto", "parallel-cpu", "parallel-gpu" ou "multi-gpu").

L’utilisation des options "background" ou "parallel" nécessite que le datastore en entrée puisse être divisé en sous-ensembles ou partitionné. Les datastores personnalisés doivent implémenter la classe matlab.io.datastore.Subsettable.

Les options "background" et "parallel" ne sont pas supportées lorsque l’option Shuffle est "never".

Si vous utilisez les options "background" et "parallel", l’apprentissage est non déterministe même si vous utilisez la fonction deep.gpu.deterministicAlgorithms.

Utilisez l’option "background" lorsque vos mini-batchs nécessitent un prétraitement important. Si votre prétraitement n’est pas supporté sur les threads ou si vous avez besoin de contrôler le nombre de workers, utilisez l’option "parallel". Pour plus d’informations sur l’environnement de prétraitement, veuillez consulter Preprocess Data in the Background or in Parallel.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Avant R2024a : Pour prétraiter les données en parallèle, définissez l’option d’apprentissage DispatchInBackground à 1 (true).

Acceleration — Optimisation des performances

"auto" (par défaut) | "none"

Depuis R2024a

Optimisation des performances, spécifiée comme l’une des valeurs suivantes :

• "auto" – Appliquer automatiquement un certain nombre d’optimisations adaptées au réseau en entrée et aux ressources hardware.

• "none" – Désactiver toutes les optimisations.

Points de contrôle

CheckpointPath — Chemin de sauvegarde des réseaux de neurones de point de contrôle

"" (par défaut) | string scalar | vecteur de caractères

Chemin de sauvegarde des réseaux de neurones de point de contrôle, spécifié comme un string scalar ou un vecteur de caractères.

• Si vous ne spécifiez pas de chemin (c’est-à-dire que vous utilisez le "" par défaut), le software ne sauvegarde pas de réseau de neurones de point de contrôle.

• Si vous spécifiez un chemin, le software sauvegarde des réseaux de neurones de point de contrôle dans ce chemin et attribue un nom unique à chaque réseau. Vous pouvez ensuite charger un réseau de neurones de point de contrôle et reprendre l’apprentissage à partir ce réseau.

  Si le dossier n’existe pas, vous devez le créer avant de spécifier le chemin de sauvegarde des réseaux de neurones de point de contrôle. Si le chemin que vous spécifiez n’existe pas, le software renvoie une erreur.

Types de données : char | string

CheckpointFrequency — Fréquence de sauvegarde des réseaux de neurones de point de contrôle

entier positif

Fréquence de sauvegarde des réseaux de neurones de point de contrôle, définie par un entier positif.

Si solverName est "lbfgs" ou si CheckpointFrequencyUnit est "iteration", le software sauvegarde les réseaux de neurones de point de contrôle pour toutes les itérations définies par CheckpointFrequency. Sinon, le software sauvegarde des réseaux de neurones de point de contrôle pour tous les epochs définis par CheckpointFrequency.

Lorsque solverName est "sgdm", "adam" ou "rmsprop", la valeur par défaut est 1. Lorsque solverName est "lbfgs" ou "lm", la valeur par défaut est 30.

Cette option a un effet uniquement si CheckpointPath n’est pas vide.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

CheckpointFrequencyUnit — Unité de fréquence des points de contrôle

"epoch" (par défaut) | "iteration"

Unité de fréquence des points de contrôle, définie par "epoch" ou "iteration".

Si CheckpointFrequencyUnit est "epoch", le software sauvegarde des réseaux de neurones de point de contrôle pour tous les epochs définis par CheckpointFrequency.

Si CheckpointFrequencyUnit est "iteration", le software sauvegarde des réseaux de neurones de point de contrôle toutes les itérations définies par CheckpointFrequency.

Cette option a un effet uniquement si CheckpointPath n’est pas vide.

Cette option supporte uniquement les solveurs stochastiques (lorsque l’argument solverName est "sgdm", "adam" ou "rmsprop").

Arguments de sortie

options — Options d’apprentissage

TrainingOptionsSGDM | TrainingOptionsRMSProp | TrainingOptionsADAM | TrainingOptionsLBFGS | TrainingOptionsLM

Options d’apprentissage, renvoyées sous la forme d'un objet TrainingOptionsSGDM, TrainingOptionsRMSProp, TrainingOptionsADAM, TrainingOptionsLBFGS, TrainingOptionsLM. Pour entraîner un réseau de neurones, utilisez les options d’apprentissage comme argument en entrée de la fonction trainnet.

Conseils

• Pour la plupart des tâches de Deep Learning, vous pouvez utiliser un réseau de neurones préentraîné et l’adapter à vos propres données. Vous trouverez un exemple illustrant comment utiliser l’apprentissage par transfert pour entraîner un réseau de neurones à convolution afin de classer un nouveau jeu d’images dans Retrain Neural Network to Classify New Images. Vous pouvez également créer et entraîner des réseaux de neurones à partir de zéro avec les fonctions trainnet et trainingOptions.

  Si la fonction trainingOptions ne propose pas les options d’apprentissage dont vous avez besoin pour votre tâche, vous pouvez créer une boucle d’apprentissage personnalisée avec la différenciation automatique. Pour en savoir plus, veuillez consulter Train Network Using Custom Training Loop.

  Si la fonction trainnet ne propose pas la fonction de perte dont vous avez besoin pour votre tâche, vous pouvez spécifier une fonction de perte personnalisée à trainnet via un handle de fonction. Pour les fonctions de perte nécessitant davantage d’entrées que les prédictions et les cibles (par exemple celles nécessitant d’accéder au réseau de neurones ou à des entrées supplémentaires), entraînez le modèle avec une boucle d’apprentissage personnalisée. Pour en savoir plus, veuillez consulter Train Network Using Custom Training Loop.

  Si la fonction Deep Learning Toolbox™ ne propose pas les couches dont vous avez besoin pour votre tâche, vous pouvez créer une couche personnalisée. Pour en savoir plus, veuillez consulter Define Custom Deep Learning Layers. Si un modèle ne peut pas être spécifié comme un réseau de couches, vous pouvez le définir comme une fonction. Pour en savoir plus, veuillez consulter Train Network Using Model Function.

  Pour plus d’informations sur la méthode d’apprentissage à utiliser selon la tâche, veuillez consulter Train Deep Learning Model in MATLAB.

Algorithmes

Poids et biais initiaux

Pour les couches de convolution et entièrement connectés, l’initialisation des poids et des biais est donnée respectivement par les propriétés WeightsInitializer et BiasInitializer des couches. Vous trouverez des exemples illustrant comme modifier l’initialisation des poids et des biais dans Specify Initial Weights and Biases in Convolutional Layer et Specify Initial Weights and Biases in Fully Connected Layer.

Descente de gradient stochastique

L’algorithme de descente de gradient standard met à jour les paramètres du réseau (poids et biais) pour minimiser la fonction de perte en effectuant de petits pas à chaque itération dans la direction du gradient négatif de la perte,

$${\theta }_{\ell +1}={\theta }_{\ell }-\alpha \nabla E\left({\theta }_{\ell }\right),$$

où $$\ell$$est le nombre itérations, $$\alpha >0$$ est le taux d’apprentissage, $$\theta$$ est le vecteur de paramètres et $$E\left(\theta \right)$$ est la fonction de perte. Dans l’algorithme de descente de gradient standard, le gradient de la fonction de perte, $$\nabla E\left(\theta \right)$$, est évalué avec l’ensemble du jeu d’apprentissage et l’algorithme de descente de gradient standard utilise l’ensemble du jeu de données en une seule fois.

En revanche, à chaque itération, l’algorithme de descente de gradient stochastique évalue le gradient et met à jour les paramètres avec un sous-ensemble des données d’apprentissage. Un sous-ensemble différent, appelé mini-batch, est utilisé à chaque itération. Le passage complet de l’algorithme d’apprentissage sur l’ensemble du jeu d’apprentissage avec des mini-batchs est un epoch. La descente de gradient stochastique est stochastique car la mise à jour des paramètres calculée avec un mini-batch est une estimation bruitée de la mise à jour des paramètres qui résulterait du jeu de données complet.

Descente de gradient stochastique avec momentum

L’algorithme de descente de gradient stochastique peut osciller le long de la trajectoire de la descente la plus forte vers l’optimum. L’ajout d’un terme de momentum à la mise à jour des paramètres est une manière de réduire cette oscillation [2]. La mise à jour de la descente de gradient stochastique avec momentum (SGDM) est

$${\theta }_{\ell +1}={\theta }_{\ell }-\alpha \nabla E\left({\theta }_{\ell }\right)+\gamma \left({\theta }_{\ell }-{\theta }_{\ell -1}\right),$$

où le taux d’apprentissage α et la valeur de momentum $$\gamma$$ déterminent la contribution du pas de gradient précédent à l’itération actuelle.

Propagation de la moyenne quadratique

La descente de gradient stochastique avec momentum utilise un seul taux d’apprentissage pour tous les paramètres. D’autres algorithmes d’optimisation cherchent à améliorer l’apprentissage du réseau avec des taux d’apprentissage différents selon le paramètre et peuvent s’adapter automatiquement à la fonction de perte en cours d’optimisation. La propagation de la moyenne quadratique (RMSProp) est l’un de ces algorithmes. Elle conserve une moyenne mobile des carrés éléments par éléments des gradients des paramètres,

$$v_{\ell }={\beta }_2{v}_{\ell -1}+(1-{\beta }_2){[\nabla E\left({\theta }_{\ell }\right)]}^2$$

β₂ est le facteur de décroissance du gradient au carré de la moyenne mobile. Les valeurs courantes du taux de décroissance sont 0,9, 0,99 et 0,999. Les longueurs moyennes correspondantes des gradients au carré sont égales à 1/(1-β₂), soit respectivement 10, 100 et 1 000 mises à jour des paramètres. L’algorithme RMSProp utilise cette moyenne mobile pour normaliser les mises à jour de chaque paramètre individuellement,

$${\theta }_{\ell +1}={\theta }_{\ell }-\frac{\alpha \nabla E\left({\theta }_{\ell }\right)}{\sqrt{v_{\ell }}+ϵ}$$

où la division est effectuée éléments par éléments. L’utilisation de RMSProp diminue efficacement les taux d’apprentissage des paramètres avec des grands gradients, et augmente les taux d’apprentissage des paramètres avec des petits gradients. ɛ est une petite constante ajoutée pour éviter la division par zéro.

Estimation adaptative des moments

L’estimation adaptative des moments (Adam) [4] utilise une mise à jour des paramètres semblable à RMSProp mais avec un terme de momentum supplémentaire. Elle conserve une moyenne mobile éléments par éléments des gradients des paramètres et de leurs valeurs au carré,

$$m_{\ell }={\beta }_1{m}_{\ell -1}+(1-{\beta }_1)\nabla E\left({\theta }_{\ell }\right)$$

$$v_{\ell }={\beta }_2{v}_{\ell -1}+(1-{\beta }_2){[\nabla E\left({\theta }_{\ell }\right)]}^2$$

Les taux de décroissance β₁ et β₂ sont respectivement les facteurs de décroissance du gradient et du gradient au carré. Adam utilise les moyennes mobiles pour mettre à jour les paramètres du réseau comme

$${\theta }_{\ell +1}={\theta }_{\ell }-\frac{\alpha m_l}{\sqrt{v_l}+ϵ}$$

La valeur α est le taux d’apprentissage. Si des gradients sont similaires sur de nombreuses itérations, l’utilisation d’une moyenne mobile du gradient permet aux mises à jour des paramètres d’établir un momentum dans une certaine direction. Si les gradients contiennent principalement du bruit, la moyenne mobile du gradient devient plus petite, de sorte que les mises à jour des paramètres diminuent également. La mise à jour Adam complète inclut également un mécanisme de correction d’un biais qui apparaît au début de l’apprentissage. Pour plus d’informations, veuillez consulter [4].

BFGS à mémoire limitée

L’algorithme L-BFGS [5] est une méthode quasi-Newton qui approxime l’algorithme Broyden-Fletcher-Goldfarb-Shanno (BFGS). Utilisez l’algorithme L-BFGS pour les réseaux et jeux de données de petite taille que vous pouvez traiter en un seul batch.

L’algorithme met à jour les paramètres entraînables W à l’itération k+1, conformément à l’étape de mise à jour donnée par

$$W_{k+1}=W_k-{\eta }_k{B}_k^{-1}\nabla J(W_k),$$

où W_k désigne les poids à l’itération k, $${\eta }_k$$ est le taux d’apprentissage à l’itération k, B_k est une approximation de la matrice hessienne à l’itération k et $$\nabla J(W_k)$$ désigne les gradients de la perte par rapport aux paramètres entraînables à l’itération k.

L’algorithme L-BFGS calcule directement le produit matrice-vecteur $$B_k^{-1}\nabla J(W_k)$$. L’algorithme ne nécessite pas de calculer l’inverse de B_k.

Pour économiser de la mémoire, l’algorithme L-BFGS ne stocke et n’inverse pas la matrice hessienne dense B. Au lieu de cela, il utilise l’approximation $$B_{k-m}^{-1}\approx {\lambda }_{k}I$$, où m est la taille de l’historique, le facteur hessien inverse $${\lambda }_k$$ est un scalaire et I est la matrice d’identité. Ensuite, l’algorithme stocke uniquement le facteur hessien inverse scalaire et le met à jour à chaque pas.

Pour calculer directement le produit matrice-vecteur $$B_k^{-1}\nabla J(W_k)$$, l’algorithme L-BFGS utilise l’algorithme récursif suivant :

1. Définissez $$r=B_{k-m}^{-1}\nabla J(W_k)$$, où m est la taille de l’historique.

2. Pour $$i=m,\dots ,1$$ :

   1. Soit $$\beta =\frac{1}{s_{k-i}^{\top }{y}_{k-i}}{y}_{k-i}^{\top }r$$, où $$s_{k-i}$$ et $$y_{k-i}$$ sont respectivement les différences de pas et de gradient pour l’itération $$k-i$$.

   2. Définissez $$r=r+\text{}{s}_{k-i}\text{}\left(a_{k-i}-\beta \right)$$, où $$a$$ est dérivé de $$s$$, de $$y$$ et des gradients de la perte par rapport à la fonction de perte. Pour plus d’informations, veuillez consulter [5].

3. Renvoyez $$B_k^{-1}\nabla J(W_k)=r$$.

Levenberg–Marquardt

L'algorithme LM [6] combine les méthodes de descente de gradient et de Gauss-Newton, et peut être plus robuste pour les petits réseaux de neurones. Il approxime les dérivées de deuxième ordre en utilisant un produit extérieur Jacobien. Utilisez l’algorithme LM pour les réseaux de régression comptant de petits nombres de paramètres entraînables pour lesquels vous pouvez traiter le jeu de données en un seul batch.

L'algorithme met à jour les paramètres entraînables W au niveau de l'itération k+1 avec l'étape de mise à jour donnée par

$$W_{k+1}=W_k+\Delta W_k,$$

où ΔW_k désigne la modification des poids à l'itération k donnée par

$$\Delta W_k=-{\left(H_k\right)}^{-1}\nabla E_k.$$

Ici, H_k désigne le hessien approximé à l'itération k tandis que $$\nabla E_k$$ représente le gradient de la perte à l'itération k par rapport aux paramètres entraînables. L'algorithme approxime le hessien en utilisant

$$H_k=J_k^{\top }{J}_k+{\mu }_{k}I,$$

où J_k désigne la matrice jacobienne à l'itération k, μ_k, le facteur d'amortissement à l'itération k, et I, la matrice d'identité.

Le solveur utilise le facteur d'amortissement pour ajuster la taille du pas pris à chaque itération et la met à jour de manière adaptative à chaque itération. Il augmente et réduit le facteur d'amortissement lorsque les itérations augmentent et réduisent respectivement la perte. Avec ces ajustements, l'optimisation prend des pas plus grands et plus petits lorsque la perte augmente et diminue, respectivement.

Lorsque la perte augmente ou diminue, le solveur augmente ou réduit de manière adaptative le facteur d'amortissement en le multipliant respectivement par DampingIncreaseFactor et DampingDecreaseFactor.

Écrêtage de gradient

Si l’amplitude des gradients augmente de manière exponentielle, l’apprentissage est instable et peut diverger au bout de quelques itérations. Cette « explosion des gradients » est indiquée par une perte de l’apprentissage qui devient NaN ou Inf. L’écrêtage de gradient permet d’éviter l’explosion des gradients en stabilisant l’apprentissage à des taux d’apprentissage élevés et en présence de valeurs aberrantes [3]. L’écrêtage de gradient permet d’entraîner plus rapidement les réseaux et n’a généralement aucun impact sur la précision de la tâche apprise.

Il existe deux types d’écrêtage de gradient.

• L’écrêtage de gradient en fonction de la norme met à l’échelle le gradient en fonction d’un seuil et ne modifie pas la direction du gradient. Les valeurs "l2norm" et "global-l2norm" de GradientThresholdMethod sont des méthodes d’écrêtage de gradient en fonction de la norme.

• L’écrêtage de gradient en fonction de la valeur écrête toute dérivée partielle supérieure au seuil, ce qui peut entraîner un changement arbitraire de la direction du gradient. L’écrêtage de gradient en fonction de la valeur peut avoir un comportement imprévisible, mais des changements suffisamment petits ne provoquent pas de divergence du réseau. La valeur "absolute-value" de GradientThresholdMethod est une méthode d’écrêtage du gradient en fonction d'une valeur.

Régularisation L₂

L’ajout d’un terme de régularisation des poids à la fonction de perte $$E\left(\theta \right)$$ est une manière de réduire le surajustement [1], [2]. Le terme de régularisation est également appelé décroissance du poids. La fonction de perte avec le terme de régularisation prend la forme

$$E_R\left(\theta \right)=E\left(\theta \right)+\lambda \Omega \left(w\right),$$

où $$w$$ est le vecteur de poids, $$\lambda$$ est le facteur (coefficient) de régularisation et la fonction de régularisation $$\Omega \left(w\right)$$ est

$$\Omega \left(w\right)=\frac{1}{2}{w}^{T}w.$$

Notez que les biais ne sont pas régularisés[2]. Vous pouvez spécifier le facteur de régularisation $$\lambda$$ avec l’option d’apprentissage L2Regularization. Vous pouvez également spécifier différents facteurs de régularisation pour différentes couches et différents paramètres.

La fonction de perte que le software utilise pour l’apprentissage du réseau inclut le terme de régularisation. Cependant, la valeur de la perte affichée dans la fenêtre de commande et dans le tracé de la progression de l’apprentissage pendant l’apprentissage est la perte sur les données uniquement et n’inclut pas le terme de régularisation.

Références

[1] Bishop, C. M. Pattern Recognition and Machine Learning. Springer, New York, NY, 2006.

[2] Murphy, K. P. Machine Learning: A Probabilistic Perspective. The MIT Press, Cambridge, Massachusetts, 2012.

[3] Pascanu, R., T. Mikolov, and Y. Bengio. "On the difficulty of training recurrent neural networks". Proceedings of the 30th International Conference on Machine Learning. Vol. 28(3), 2013, pp. 1310–1318.

[4] Kingma, Diederik, and Jimmy Ba. "Adam: A method for stochastic optimization." arXiv preprint arXiv:1412.6980 (2014).

[5] Liu, Dong C., and Jorge Nocedal. "On the limited memory BFGS method for large scale optimization." Mathematical programming 45, no. 1 (August 1989): 503-528. https://doi.org/10.1007/BF01589116.

[6] Marquardt, Donald W. “An Algorithm for Least-Squares Estimation of Nonlinear Parameters.” Journal of the Society for Industrial and Applied Mathematics 11, no. 2 (June 1963): 431–41. https://doi.org/10.1137/0111030.

Historique des versions

Introduit dans R2016a

R2024b: Entraîner les réseaux de neurones avec davantage de programmations de taux d’apprentissage

Entraînez des réseaux de neurones avec ces programmations de taux d'apprentissage en les spécifiant en tant qu'argument LearnRateSchedule de la fonction trainingOptions :

• "warmup" — Programmation du taux d’apprentissage d’échauffement

• "polynomial" — Programmation du taux d’apprentissage polynomiale

• "exponential" — Programmation du taux d’apprentissage exponentielle

• "cosine" — Programmation du taux d’apprentissage en cosinus

• "cyclical" — Programmation du taux d’apprentissage cyclique

Pour personnaliser ces programmations de taux d’apprentissage, utilisez ces objets :

• warmupLearnRate — Programmation du taux d’apprentissage d’échauffement

• polynomialLearnRate — Programmation du taux d’apprentissage polynomiale

• exponentialLearnRate — Programmation du taux d’apprentissage exponentielle

• cosineLearnRate — Programmation du taux d’apprentissage en cosinus

• cyclicalLearnRate — Programmation du taux d’apprentissage cyclique

Dans les versions précédentes, vous pouviez effectuer un apprentissage avec une programmation du taux d'apprentissage par morceaux ou aucune programmation.

Pour personnaliser la programmation du taux d’apprentissage par morceaux existant, utilisez un objet piecewiseLearnRate.

Pour spécifier une programmation personnalisée, utilisez un handle de fonction avec la syntaxe learnRate = f(initialLearnRate,epoch) ou définissez votre propre objet de programmation du taux d’apprentissage personnalisée en définissant une classe qui hérite de deep.LearnRateSchedule.

R2024b: Utiliser le solveur Levenberg–Marquardt pour l’apprentissage

Entraînez un réseau de neurones avec le solveur Levenberg–Marquardt (LM). Utilisez l’algorithme LM pour les réseaux de régression comptant de petits nombres de paramètres entraînables pour lesquels vous pouvez traiter le jeu de données en un seul batch.

Pour utiliser le solveur LM avec la fonction trainnet, créez un objet TrainingOptionsLM en spécifiant l’argument solverName en tant que "lm". Vous pouvez personnaliser le solveur LM en utilisant ces nouvelles options d’apprentissage :

• InitialDampingFactor — Facteur d’amortissement initial

• MaxDampingFactor — Facteur d’amortissement maximal

• DampingDecreaseFactor — Facteur de réduction de l’amortissement

• DampingIncreaseFactor — Facteur d‘augmentation de l’amortissement

R2024b: Surveiller et tracer davantage de métriques pendant l’apprentissage

Utilisez de nouveaux objets métriques et des objets métriques mis à jour pendant l’apprentissage et le test.

• MAPEMetric — Erreur absolue moyenne en pourcentage (MAPE)

• AccuracyMetric avec la nouvelle option NumTopKClasses — Précision Top-k

• FScoreMetric avec la nouvelle option Beta — F_β-score

Vous pouvez également spécifier directement ces nouveaux noms de métriques et de perte prédéfinis :

• "mape" — Erreur absolue moyenne en pourcentage (MAPE)

• "crossentropy" — Perte d’entropie croisée

• "index-crossentropy" — Perte d’entropie croisée d’indice

• "binary-crossentropy" — Perte d’entropie croisée binaire

• "mse" / "mean-squared-error" / "l2loss" — Erreur quadratique moyenne

• "mae" / "mean-absolute-error" / "l1loss" — Erreur absolue moyenne

• "huber" — Perte de Huber

R2024b: Spécifier la taille de pas initiale pour le solveur L-BFGS

Spécifiez la taille de pas initiale pour le solveur L-BFGS en utilisant l’argument InitialStepSize.

R2024a: Spécifier des données de validation avec un objet minibatchqueue

Spécifiez des données de validation comme un objet minibatchqueue avec l’argument ValidationData.

R2024a: Optimisation automatique des performances

Accélérez l’apprentissage grâce à l’optimisation automatique de la performance. Lorsque vous entraînez un réseau avec la fonction trainnet, l’optimisation automatique de la performances est activée par défaut. Vous pouvez la désactiver en définissant l’option Acceleration à "none" avec la fonction trainingOptions.

R2024a: Spécifier les métriques comme un objet deep.DifferentiableFunction

Spécifiez les métriques comme un objet deep.DifferentiableFunction.

R2024a: La définition de SequenceLength à un nombre entier est déconseillée

Il est déconseillé de définir SequenceLength à un nombre entier. Définissez plutôt SequenceLength à "longest" ou "shortest".

Pour les workflows trainNetwork (déconseillés), vous pouvez définir SequenceLength à un nombre entier. Si SequenceLength est un nombre entier, le software remplit les séquences de chaque mini-batch à la longueur de la séquence la plus longue de ce mini-batch puis il divise les séquences en séquences plus petites de la longueur spécifiée. En cas de division, le software crée des mini-batchs supplémentaires et met à jour l’état récurrent du réseau entre ces mini-batchs. Si la longueur de séquence spécifiée ne divise pas uniformément les longueurs des séquences des données, les mini-batchs contenant les fins de ces séquences auront une longueur plus courte que la longueur de séquence spécifiée.

R2024a: L’option d’apprentissage DispatchInBackground est déconseillée

L’option d’apprentissage DispatchInBackground est déconseillée. Utilisez l’option PreprocessingEnvironment à la place.

L’option PreprocessingEnvironment propose les mêmes fonctionnalités et permet également d’utiliser le backgroundPool pour le prétraitement lorsque vous définissez PreprocessingEnvironment à "background".

Le tableau suivant indique comment mettre à jour votre code :

Déconseillé	Recommandé
trainingOptions(solverName,DispatchInBackground=false) (par défaut)	trainingOptions(solverName,PreprocessingEnvironment="serial") (par défaut)
trainingOptions(solverName,DispatchInBackground=true)	trainingOptions(solverName,PreprocessingEnvironment="parallel")

Il n’est pas prévu de supprimer l’option DispatchInBackground.

R2024a: La valeur par défaut de OutputNetwork est "auto"

À partir de R2024a, la valeur par défaut de l’option d’apprentissage OutputNetwork est "auto". Si vous avez spécifié des données de validation, le software renvoie le réseau correspondant à la meilleure valeur de métrique lors de la validation. Si vous n’avez pas spécifié de données de validation, le software renvoie le réseau correspondant à la dernière itération d’apprentissage. Si vous avez des données de validation et souhaitez reproduire le comportement par défaut précédent, définissez OutputNetwork à "last-iteration".

Ce changement s’applique uniquement lors de l’utilisation des options d’apprentissage avec trainnet. Si vous utilisez les options d’apprentissage avec la fonction trainNetwork, le comportement ne change pas et le software renvoie par défaut le réseau correspondant à la dernière itération d’apprentissage.

R2024a: Pour OutputNetwork, la valeur "best-validation-loss" est déconseillée

Il est déconseillé de définir OutputNetwork à "best-validation-loss". Si vous avez un code qui définit OutputNetwork à "best-validation-loss", utilisez "best-validation" à la place. Le software renvoie le réseau correspondant à la meilleure valeur de métrique lors de la validation selon ce que spécifie l’option ObjectiveMetricName. Par défaut, la valeur de ObjectiveMetricName est définie à "loss". Ce comportement s’applique uniquement lors de l’utilisation des options d’apprentissage avec la fonction trainnet.

Lorsque vous utilisez les options d’apprentissage avec la fonction trainNetwork, si vous définissez OutputNetwork à "best-validation", le software renvoie toujours le réseau avec la meilleure valeur de perte lors de la validation.

R2024a: Pour ExecutionEnvironment, la valeur "parallel" est déconseillée

À partir de R2024a, il est déconseillé de définir l’option ExecutionEnvironment à "parallel". Utilisez "parallel-auto" à la place.

"parallel-auto" présente les avantages suivants par rapport à "parallel" :

• Le nom de l’option décrit plus précisément l’environnement d’exécution car le software effectue automatiquement un apprentissage parallèle avec le hardware disponible.

• Le nom de l’option est cohérent avec son équivalent série "auto".

Il n’est pas prévu de supprimer l’option "parallel". "parallel-auto" supporte uniquement la fonction trainnet. Si vous utilisez les options d’apprentissage avec la fonction trainNetwork, continuez à utiliser "parallel".

R2024a: L’option d’apprentissage WorkerLoad est déconseillée

À partir de R2024a, il est déconseillé de spécifier l’option d’apprentissage WorkerLoad. Utilisez spmd (Parallel Computing Toolbox) ou la variable d’environnement CUDA_VISIBLE_DEVICES à la place.

Il n’est pas prévu de supprimer le support de WorkerLoad pour l’apprentissage de réseaux avec la fonction trainNetwork. WorkerLoad n’est pas supporté pour l’apprentissage de réseaux avec la fonction trainnet.

Le tableau suivant indique quelques utilisations courantes des objets WorkerLoad et comment mettre à jour votre code pour qu’il utilise spmd ou la variable d’environnement CUDA_VISIBLE_DEVICES à la place.

Déconseillé	Recommandé
options = trainingOptions(solver, ... ExecutionEnvironment="multi-gpu", ... WorkerLoad=[1 1 0 1]);	% Alternative 1 pool = parpool(3); spmd if spmdIndex == 3 gpuDevice(spmdIndex + 1); else gpuDevice(spmdIndex); end end options = trainingOptions(solver, ... ExecutionEnvironment="multi-gpu"); % Alternative 2 % Set this environment variable immediately after your start MATLAB. setenv("CUDA_VISIBLE_DEVICES","0,1,3"); options = trainingOptions(solver, ... ExecutionEnvironment="multi-gpu");
options = trainingOptions(solver, ... ExecutionEnvironment="parallel", ... WorkerLoad=[1 1 0 1]);	pool = parpool(3); spmd if spmdIndex == 3 gpuDevice(spmdIndex + 1); else gpuDevice(spmdIndex); end end options = trainingOptions(solver, ... ExecutionEnvironment="parallel-auto");

Si vous utilisiez précédemment l’option WorkerLoad pour réserver un worker afin de prétraiter vos données, envisagez également de les prétraiter en arrière-plan en définissant l’option PreprocessingEnvironment à "background".

R2023b: Entraîner un réseau de neurones avec le solveur L-BFGS

Entraînez un réseau de neurones avec le solveur L-BFGS en définissant solverName à "lbfgs". Utilisez l’algorithme L-BFGS pour les réseaux et jeux de données de petite taille que vous pouvez traiter en un seul batch. Pour personnaliser le solveur L-BFGS, utilisez les propriétés Options du solveur en batch.

Cette option supporte uniquement la fonction trainnet.

R2023b: Spécifier les formats de données en entrée et cibles

Spécifiez les formats de données en entrée et cibles en utilisant respectivement les options InputDataFormats et TargetDataFormats.

Cette option supporte uniquement la fonction trainnet.

R2023b: Entraîner un réseau de neurones en parallèle avec uniquement les ressources CPU ou GPU

Entraînez un réseau de neurones en parallèle avec des ressources hardware spécifiques en définissant ExecutionEnvironment à "parallel-cpu" ou "parallel-gpu".

Cette option supporte uniquement la fonction trainnet.

R2023b: La valeur par défaut de BatchNormalizationStatistics est "auto"

À partir de R2023b, la valeur par défaut de l’option d’apprentissage BatchNormalizationStatistics est "auto".

Ce changement n’affecte pas le comportement de la fonction. Si vous avez un code qui vérifie la propriété BatchNormalizationStatistics, mettez-le à jour pour tenir compte de l’option "auto".

R2022b: trainNetwork remplit les mini-batchs à la longueur de la séquence la plus longue avant division lorsque vous spécifiez l’option d’apprentissage SequenceLength comme un entier

À partir de R2022b, lorsque vous entraînez un réseau de neurones avec des données de séquence avec la fonction trainNetwork et que l’option SequenceLength est un entier, le software remplit les séquences à la longueur de la séquence la plus longue dans chaque mini-batch puis divise les séquences en mini-batchs avec la longueur de séquence spécifiée. Si SequenceLength ne divise pas uniformément la longueur des séquences des mini-batchs, le dernier mini-batch divisé a une longueur plus courte que SequenceLength. Ce comportement évite l’apprentissage du réseau de neurones sur des pas de temps contenant uniquement des valeurs de remplissage.

Pour les versions antérieures, le software remplit les mini-batchs de séquences afin qu’ils aient une longueur correspondant au multiple le plus proche de SequenceLength supérieur ou égal à la longueur des mini-batchs, puis divise les données. Pour reproduire ce comportement, utilisez une boucle d’apprentissage personnalisée et implémentez ce comportement lorsque vous prétraitez les mini-batchs de données.

R2018b: L’option d’apprentissage ValidationPatience par défaut est Inf

À partir de R2018b, la valeur par défaut de l’option d’apprentissage ValidationPatience est Inf, ce qui signifie que l’arrêt automatique via la validation est désactivé. Ce comportement évite que la phase d'apprentissage s’arrête avant que l’apprentissage à partir des données soit suffisant.

Dans les versions précédentes, la valeur par défaut est 5. Pour reproduire ce comportement, définissez l’option ValidationPatience sur 5.

R2018b: Nom de fichier différent pour des réseaux de point de contrôle

À partir de R2018b, lors de la sauvegarde de réseaux de points de contrôle, le software attribue des noms de fichier commençant par net_checkpoint_. Pour les versions antérieures, le software attribue des noms de fichier commençant par convnet_checkpoint_.

Si vous avez un code qui sauvegarde et charge des réseaux de point de contrôle, mettez à jour votre code pour charger les fichiers avec le nouveau nom.

Voir aussi

trainnet | dlnetwork | analyzeNetwork | Deep Network Designer

Rubriques

• Créer un réseau de neurones simple de Deep Learning pour la classification
• Retrain Neural Network to Classify New Images
• Resume Training from Checkpoint Network
• Deep Learning with Big Data on CPUs, GPUs, in Parallel, and on the Cloud
• Define Custom Training Loops, Loss Functions, and Networks