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
Syntaxe
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
.
[
entraîne un réseau avec des options complémentaires spécifiées par un ou plusieurs arguments de type nom-valeur.trainedNet
,tr
] = train(net
,X
,T
,Xi
,Ai
,EW
,Name,Value
)
Exemples
Entraîner et tracer des réseaux
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,'*')
Entraîner un réseau NARX pour les séries temporelles
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);
Entraîner un réseau en parallèle sur un pool parallèle
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.
Entraîner un réseau sur des GPU
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);
Entraîner le réseau avec des enregistrements de points de contrôle
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
net
— Réseau d’entrée
objet network
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
.
X
— Entrées du réseau
matrice | cell array | données composites | gpuArray
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éeQ
est la taille du batchNi = 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 deRi
) xQ
.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 dimensionRi
xQ
, 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.
T
— Cibles du réseau
zéros (par défaut) | matrice | cell array | données composites | gpuArray
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 sortieQ
est la taille du batchNo = 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 deUi
) xQ
.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 matriceUi
xQ
, 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.
Xi
— Conditions initiales de retard d’entrée
zéros (par défaut) | cell array | matrice
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éeQ
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.
Ai
— Conditions initiales de retard de couche
zéros (par défaut) | cell array | matrice
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
.
EW
— Poids des erreurs
cell array
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 tempsUi = 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'
useParallel
— Option pour spécifier des calculs parallèles
'no'
(par défaut) | '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.
useGPU
— Option pour spécifier des calculs sur GPU
'no'
(par défaut) | 'yes'
| 'only'
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 legpuDevice
courant s’il s’agit d’un GPU supporté (veuillez consulter Parallel Computing Toolbox pour les exigences relatives aux GPU). Si legpuDevice
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.
showResources
— Option pour afficher des ressources
'no'
(par défaut) | 'yes'
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.
reduction
— Réduction de la mémoire
1 (par défaut) | entier positif
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.
CheckpointFile
— Fichier de points de contrôle
''
(par défaut) | vecteur de caractères
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).
CheckpointDelay
— Retard des points de contrôle
60 (par défaut) | entier non négatif
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
trainedNet
— Réseau entraîné
objet network
Le réseau entraîné est retourné comme un objet network
.
tr
— Enregistrement de l’apprentissage
structure
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
Commande MATLAB
Vous avez cliqué sur un lien qui correspond à cette commande MATLAB :
Pour exécuter la commande, saisissez-la dans la fenêtre de commande de MATLAB. Les navigateurs web ne supportent pas les commandes MATLAB.
Select a Web Site
Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .
You can also select a web site from the following list:
How to Get Best Site Performance
Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.
Americas
- América Latina (Español)
- Canada (English)
- United States (English)
Europe
- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)
- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)