Main Content

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

train

Entraîner un réseau de neurones peu profond

Description

Cette fonction entraîne un réseau de neurones peu profond. Pour le Deep Learning avec des réseaux de neurones à convolution ou LSTM, veuillez plutôt consulter trainNetwork.

exemple

trainedNet = train(net,X,T,Xi,Ai,EW) entraîne un réseau net selon net.trainFcn et net.trainParam.

[trainedNet,tr] = train(net,X,T,Xi,Ai,EW) renvoie également un enregistrement de l’apprentissage.

exemple

[trainedNet,tr] = train(net,X,T,Xi,Ai,EW,Name,Value) entraîne un réseau avec des options complémentaires spécifiées par un ou plusieurs arguments de type nom-valeur.

Exemples

réduire tout

Ici, l’entrée x et les cibles t définissent une simple fonction que vous pouvez tracer :

x = [0 1 2 3 4 5 6 7 8];
t = [0 0.84 0.91 0.14 -0.77 -0.96 -0.28 0.66 0.99];
plot(x,t,'o')

Ici, feedforwardnet crée un réseau feedforward à deux couches. Le réseau a une couche cachée avec dix neurones.

net = feedforwardnet(10);
net = configure(net,x,t);
y1 = net(x)
plot(x,t,'o',x,y1,'x')

Le réseau est entraîné puis simulé à nouveau.

net = train(net,x,t);
y2 = net(x)
plot(x,t,'o',x,y1,'x',x,y2,'*')

Cet exemple entraîne un réseau autorégressif non linéaire en boucle ouverte avec une entrée externe afin de modéliser un système magnétique en lévitation défini par un courant de contrôle x et la réponse de la position verticale de l’aimant t, puis simule le réseau. La fonction preparets prépare les données avant l’apprentissage et la simulation. Elle crée les entrées combinées du réseau en boucle ouverte xo, qui contient l’entrée externe x et les valeurs précédentes de la position t. Elle prépare également les états de retard xi.

[x,t] = maglev_dataset;
net = narxnet(10);
[xo,xi,~,to] = preparets(net,x,{},t);
net = train(net,xo,to,xi);
y = net(xo,xi)

Le même système peut aussi être simulé en boucle fermée.

netc = closeloop(net);
view(netc)
[xc,xi,ai,tc] = preparets(netc,x,{},t);
yc = netc(xc,xi,ai);

Parallel Computing Toolbox™ permet à Deep Learning Toolbox™ de simuler et entraîner des réseaux plus rapidement et sur des jeux de données plus grands qui peuvent être stockés sur un PC. L’apprentissage parallèle est actuellement supporté pour l’apprentissage par rétropropagation, mais pas pour les cartes auto-organisatrices.

Ici, l’apprentissage et la simulation se produisent sur des workers MATLAB parallèles.

parpool
[X,T] = vinyl_dataset;
net = feedforwardnet(10);
net = train(net,X,T,'useParallel','yes','showResources','yes');
Y = net(X);

Utilisez des valeurs composites pour distribuer les données manuellement et renvoyez les résultats comme une valeur composite. Si les données sont chargées au fur et à mesure qu’elles sont distribuées, bien que chaque partie du jeu de données doive pouvoir être stockée dans la RAM, le jeu de données complet est limité par la RAM totale de tous les workers.

[X,T] = vinyl_dataset;
Q = size(X,2);
Xc = Composite;
Tc = Composite;
numWorkers = numel(Xc);
ind = [0 ceil((1:numWorkers)*(Q/numWorkers))];
for i=1:numWorkers
    indi = (ind(i)+1):ind(i+1);
    Xc{i} = X(:,indi);
    Tc{i} = T(:,indi);
end
net = feedforwardnet;
net = configure(net,X,T);
net = train(net,Xc,Tc);
Yc = net(Xc);

Dans l’exemple ci-dessus, notez que la fonction « configure » a été utilisée pour définir les dimensions et les paramètres de traitement des entrées du réseau. Normalement, cela se produit automatiquement lorsque la fonction « train » est appelée, mais lorsque des données composites sont fournies, cette étape doit être effectuée manuellement avec des données non composites.

Des réseaux peuvent être entraînés avec l'équipement GPU actuel, s’il est supporté par Parallel Computing Toolbox. L’apprentissage sur GPU est actuellement supporté pour l’apprentissage par rétropropagation, mais pas pour les cartes auto-organisatrices.

[X,T] = vinyl_dataset;
net = feedforwardnet(10);
net = train(net,X,T,'useGPU','yes');
y = net(X); 

Pour placer les données sur un GPU manuellement :

[X,T] = vinyl_dataset;
Xgpu = gpuArray(X);
Tgpu = gpuArray(T);
net = configure(net,X,T);
net = train(net,Xgpu,Tgpu);
Ygpu = net(Xgpu);
Y = gather(Ygpu); 

Dans l’exemple ci-dessus, notez que la fonction « configure » a été utilisée pour définir les dimensions et les paramètres de traitement des entrées du réseau. Normalement, cela se produit automatiquement lorsqu'on appelle la fonction « train », mais lorsque des données gpuArray sont fournies, cette étape doit être effectuée manuellement avec des données non gpuArray.

Pour une exécution en parallèle avec des workers attribués chacun à un GPU unique différent et les workers supplémentaires exécutés sur le CPU :

net = train(net,X,T,'useParallel','yes','useGPU','yes');
y = net(X);

L’utilisation exclusive de workers avec des GPU uniques peut avoir pour résultat une vitesse plus élevée, car les workers sur CPU peuvent ne pas tenir le rythme.

net = train(net,X,T,'useParallel','yes','useGPU','only');
Y = net(X);

Ici, un réseau est entraîné avec des points de contrôle enregistrés à une fréquence maximale d’un toutes les deux minutes.

[x,t] = vinyl_dataset;
net = fitnet([60 30]);
net = train(net,x,t,'CheckpointFile','MyCheckpoint','CheckpointDelay',120);

Après une défaillance informatique, le dernier réseau peut être récupéré et utilisé pour continuer l’apprentissage à partir du point de défaillance. Le fichier de points de contrôle inclut une variable de structure checkpoint qui comprend le réseau, l’enregistrement de l’apprentissage, un nom de fichier, l’heure et un numéro.

[x,t] = vinyl_dataset;
load MyCheckpoint
net = checkpoint.net;
net = train(net,x,t,'CheckpointFile','MyCheckpoint');

Vous pouvez également utiliser la fonctionnalité de point de contrôle lorsque vous arrêtez une session d’apprentissage parallèle (commencée avec le paramètre 'UseParallel') alors que l’outil d’apprentissage de réseau de neurones n’est pas disponible pendant l’apprentissage parallèle. Dans ce cas, définissez un 'CheckpointFile', utilisez Ctrl+C pour arrêter l’apprentissage à tout moment, puis chargez votre fichier de points de contrôle pour obtenir le réseau et l’enregistrement de l’apprentissage.

Arguments d'entrée

réduire tout

Le réseau d’entrée est spécifié comme un objet network. Pour créer un objet network, utilisez par exemple feedforwardnet ou narxnet.

Les entrées du réseau sont spécifiées comme une matrice de dimension R x Q ou un cell array de dimension Ni x TS, où

  • R est la taille de l'entrée

  • Q est la taille du batch

  • Ni = net.numInputs

  • TS est le nombre de pas de temps

Les arguments de train peuvent avoir deux formats : matrices, pour des problèmes statiques et des réseaux avec des entrées et sorties uniques, et cell arrays, pour des pas de temps multiples et des réseaux avec des entrées et sorties multiples.

  • Le format matrice peut être utilisé s’il faut simuler un seul pas de temps (TS = 1). Il est pratique pour des réseaux avec seulement une entrée et une sortie, mais peut être utilisé avec des réseaux qui en possèdent davantage. Lorsque le réseau a plusieurs entrées, la taille de la matrice est (somme de Ri) x Q.

  • Le format cell array est plus général, plus pratique pour des réseaux avec des entrées et sorties multiples et permet de présenter des séquences d’entrées. Chaque élément X{i,ts} est une matrice de dimension Ri x Q, où Ri = net.inputs{i}.size.

En cas d’utilisation des données de type Composite, 'useParallel' est automatiquement défini à 'yes'. La fonction prend des données de type Composite et renvoie des résultats de type Composite.

En cas d’utilisation de données de type gpuArray, 'useGPU' est automatiquement défini à 'yes'. La fonction prend des données de type gpuArray et renvoie des résultats de type gpuArray.

Remarque

Si une colonne de X contient au moins un NaN, train n’utilise pas cette colonne pour l’apprentissage, les tests ou la validation.

Cibles du réseau, spécifiées comme une matrice de dimension U x Q ou un cell array de dimension No x TS, où

  • U est la taille de la sortie

  • Q est la taille du batch

  • No = net.numOutputs

  • TS est le nombre de pas de temps

Les arguments de train peuvent avoir deux formats : matrices, pour des problèmes statiques et des réseaux avec des entrées et sorties uniques, et cell arrays, pour des pas de temps multiples et des réseaux avec des entrées et sorties multiples.

  • Le format matrice peut être utilisé s’il faut simuler un seul pas de temps (TS = 1). Il est pratique pour des réseaux avec seulement une entrée et une sortie, mais peut être utilisé avec des réseaux qui en possèdent davantage. Lorsque le réseau a plusieurs entrées, la taille de la matrice est (somme de Ui) x Q.

  • Le format cell array est plus général, plus pratique pour des réseaux avec des entrées et sorties multiples et permet de présenter des séquences d’entrées. Chaque élément T{i,ts} est une matrice Ui x Q, où Ui = net.outputs{i}.size.

En cas d’utilisation des données de type Composite, 'useParallel' est automatiquement défini à 'yes'. La fonction prend des données de type Composite et renvoie des résultats de type composite.

En cas d’utilisation de données de type gpuArray, 'useGPU' est automatiquement défini à 'yes'. La fonction prend des données de type gpuArray et renvoie des résultats de type gpuArray.

Notez que T est facultatif et doit être utilisé uniquement pour les réseaux qui nécessitent des cibles.

Remarque

Les valeurs NaN des cibles T sont traitées comme des données manquantes. Si un élément de T est NaN, cet élément n’est pas utilisé pour l’apprentissage, les tests ou la validation.

Les conditions initiales de retard en entrée sont spécifiées comme un cell array de dimension Ni x ID ou une matrice de dimension R x (ID*Q), où

  • ID = net.numInputDelays

  • Ni = net.numInputs

  • R est la taille de l'entrée

  • Q est la taille du batch

Pour l’entrée du cell array, les colonnes de Xi sont triées de la condition de retard la plus ancienne à la plus récente : Xi{i,k} est l’entrée i à l’instant ts = k - ID.

Xi est également facultatif et doit être utilisé uniquement pour les réseaux qui ont des retards en entrée ou des retards de couche.

Les conditions initiales de retard de couche sont spécifiées comme un cell array de dimension Nl x LD ou une matrice de dimension (somme de Si) x (LD*Q), où

  • Nl = net.numLayers

  • LD = net.numLayerDelays

  • Si = net.layers{i}.size

  • Q est la taille du batch

Pour l’entrée du cell array, les colonnes de Ai sont triées de la condition de retard la plus ancienne à la plus récente : Ai{i,k} est la sortie de la couche i à l’instant ts = k - LD.

Les poids des erreurs sont spécifiés comme un cell array de dimension No x TS ou une matrice de dimension (somme de Ui) x Q, où

  • No = net.numOutputs

  • TS est le nombre de pas de temps

  • Ui = net.outputs{i}.size

  • Q est la taille du batch

Pour l’entrée du cell array, chaque élément EW{i,ts} est une matrice de dimension Ui x Q, où

  • Ui = net.outputs{i}.size

  • Q est la taille du batch

Les poids des erreurs EW peuvent également avoir une taille de 1 pour tous les éléments ou une partie des éléments de No, TS, Ui ou Q. Dans ce cas, la dimension de EW est automatiquement étendue pour correspondre aux cibles T. Cela permet une pondération pratique de l’importance dans une dimension (par exemple par échantillon) tout en conservant la même importance dans une autre (comme le temps, avec TS=1). Si toutes les dimensions sont égales à 1, par exemple si EW = {1}, toutes les valeurs cibles sont traitées avec la même importance. Il s’agit de la valeur par défaut de EW.

Comme indiqué ci-dessus, les poids des erreurs EW peuvent être de mêmes dimensions que les cibles T ou avoir certaines dimensions égales à 1. Par exemple, si EW est de dimension 1 x Q, les échantillons cibles auront des importances différentes, mais chaque élément d’un échantillon aura la même importance. Si EW est de dimension (somme de Ui) x 1, chaque élément de sortie a une importance différente et tous les échantillons sont traités avec la même importance.

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 : 'useParallel','yes'

L'option pour indiquer des calculs parallèles, est spécifiée comme 'yes' ou 'no'.

  • 'no' – Les calculs ont lieu sur un thread MATLAB normal. Il s’agit du paramètre 'useParallel' par défaut.

  • 'yes' – Les calculs ont lieu sur des workers parallèles si un pool parallèle est ouvert. Sinon, les calculs ont lieu sur le thread MATLAB® normal.

L'option pour indiquer des calculs sur GPU, est spécifiée comme 'yes', 'no' ou 'only'.

  • 'no' – Les calculs ont lieu sur le CPU. Il s’agit du paramètre 'useGPU' par défaut.

  • 'yes' – Les calculs ont lieu sur le gpuDevice courant s’il s’agit d’un GPU supporté (veuillez consulter Parallel Computing Toolbox pour les exigences relatives aux GPU). Si le gpuDevice courant n’est pas supporté, les calculs restent sur le CPU. Si 'useParallel' est également 'yes' et qu’un pool parallèle est ouvert, tous les workers avec un GPU unique utilisent ce GPU, les autres workers effectuent des calculs sur leur cœur de CPU respectif.

  • 'only' – Si aucun pool parallèle n’est ouvert, ce paramètre est équivalent à 'yes'. Si un pool parallèle est ouvert, seuls les workers avec un GPU unique sont utilisés. Cependant, si un pool parallèle est ouvert mais qu’aucun GPU supporté n’est disponible, les calculs sont à nouveau exécutés sur tous les CPU des workers.

L'option pour afficher des ressources est spécifiée comme étant 'yes' ou 'no'.

  • 'no' – Ne pas afficher les ressources informatiques utilisées en ligne de commande. Il s’agit du paramètre par défaut.

  • 'yes' – Montrer en ligne de commande un résumé des ressources informatiques actuellement utilisées. Les ressources actuelles peuvent différer des ressources demandées si des calculs parallèles ou sur GPU sont demandés mais qu’aucun pool parallèle n’est ouvert ou qu’aucun GPU supporté n’est disponible. Lorsque des workers parallèles sont utilisés, le mode de calcul de chaque worker est décrit, y compris les workers du pool qui ne sont pas utilisés.

la réduction de la mémoire est spécifiée comme un entier positif.

Pour la plupart des réseaux de neurones, le mode de calcul d’apprentissage du CPU par défaut est un algorithme MEX compilé. Cependant, pour les grands réseaux, les calculs peuvent avoir lieu avec un mode de calcul MATLAB. Vous pouvez le confirmer avec 'showResources'. Si MATLAB est utilisé et que la mémoire pose problème, la définition de l’option de réduction à une valeur N supérieure à 1 réduit le stockage temporaire requis par l’apprentissage d’un facteur N ; en contrepartie, les temps d’apprentissage sont plus longs.

Le fichier de points de contrôle est spécifié comme un vecteur de caractères.

La valeur de 'CheckpointFile' peut être définie comme un nom de fichier pour enregistrer le dossier de travail actuel, comme un chemin d’accès à un fichier dans un autre dossier ou comme une chaîne de caractères vide pour désactiver les enregistrements de points de contrôle (valeur par défaut).

Le retard des points de contrôle est spécifié comme un entier non négatif.

Le paramètre optionnel 'CheckpointDelay' limite la fréquence des enregistrements. La limitation de la fréquence des points de contrôle peut améliorer l’efficacité en gardant un temps d’enregistrement des points de contrôle faible par rapport au temps consacré aux calculs. La valeur par défaut est 60, ce qui signifie que les enregistrements des points de contrôle n’ont pas lieu plus d’une fois par minute. Définissez la valeur de 'CheckpointDelay' à 0 si vous voulez que les enregistrements des points de contrôle aient lieu une fois par epoch.

Arguments de sortie

réduire tout

Le réseau entraîné est retourné comme un objet network.

L'enregistrement de l’apprentissage (epoch et perf) est renvoyé comme une structure dont les champs dépendent de la fonction d’apprentissage du réseau (net.NET.trainFcn). Il peut inclure des champs comme :

  • Fonctions et paramètres d’apprentissage, de division de données et de performance

  • Indices de division des données pour les jeux d’apprentissage, de validation et de test

  • Masques de division des données pour les jeux d’apprentissage, de validation et de test

  • Nombre d’epochs (num_epochs) et le meilleur epoch (best_epoch)

  • Liste des noms des états d’apprentissage (states)

  • Champs pour chaque nom d’état enregistrant sa valeur pendant l’apprentissage

  • Meilleures performances du réseau, évaluées à chaque epoch : meilleure performance sur le jeu d’apprentissage (best_perf), meilleure performance sur le jeu de validation (best_vperf) et meilleure performance sur le jeu de test (best_tperf)

Algorithmes

train appelle la fonction indiquée par net.trainFcn, avec les valeurs de paramètres d’apprentissage indiquées par net.trainParam.

Typiquement, un epoch d’apprentissage est défini comme une présentation simple de tous les vecteurs en entrée du réseau. Le réseau est ensuite mis à jour selon les résultats de toutes ces présentations.

L’apprentissage a lieu jusqu’à ce que le nombre maximal d’epochs soit atteint, que l’objectif de performance soit atteint ou que n’importe quelle condition d’arrêt de la fonction net.trainFcn se produise.

Certaines fonctions d’apprentissage s’écartent de cette norme en présentant un seul vecteur (ou séquence) en entrée à chaque epoch. Un vecteur (ou séquence) en entrée est choisi aléatoirement pour chaque epoch parmi des vecteurs (ou séquences) concurrents en entrée. competlayer renvoie des réseaux qui utilisent trainru, une fonction d’apprentissage prévue à cet effet.

Historique des versions

Introduit avant R2006a

Voir aussi

| | |