La traduzione di questa pagina non è aggiornata. Fai clic qui per vedere l'ultima versione in inglese.

trainingOptions

Opzioni per l’addestramento della rete neurale di Deep Learning

Sintassi

options = trainingOptions(solverName)

options = trainingOptions(solverName,Name=Value)

Descrizione

options = trainingOptions(solverName) restituisce le opzioni di addestramento per l'ottimizzatore specificato da solverName. Per addestrare una rete neurale, utilizzare le opzioni di addestramento come un argomento di input nella funzione trainnet.

options = trainingOptions(solverName,Name=Value) restituisce le opzioni di addestramento con ulteriori opzioni specificate da uno o più argomenti nome-valore.

Esempi

Specificazione delle opzioni di addestramento

Creare un set di opzioni per l’addestramento di una rete usando la discesa stocastica del gradiente con momento. Ridurre la velocità di apprendimento di un fattore di 0,2 ogni 5 epoche. Impostare il numero massimo di epoche per l’addestramento su 20 e utilizzare un mini-batch con 64 osservazioni a ogni iterazione. Attivare il grafico dei progressi dell’addestramento.

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"

Monitoraggio dei progressi dell’addestramento in Deep Learning

Questo esempio mostra come monitorare i progressi dell'addestramento delle reti di Deep Learning.

Quando si addestrano le reti per il Deep Learning, il plottaggio di varie metriche durante l'addestramento consente di comprendere come progredisce l'addestramento stesso. Ad esempio, è possibile determinare se e quanto velocemente la precisione della rete stia migliorando e se la rete stia iniziando a sovradimensionare i dati di addestramento.

Questo esempio mostra come monitorare i progressi dell’addestramento delle reti addestrate utilizzando la funzione trainnet. Se si sta addestrando una rete utilizzando un loop di addestramento personalizzato, utilizzare invece un oggetto trainingProgressMonitor per tracciare le metriche durante l'addestramento. Per ulteriori informazioni, vedere Monitor Custom Training Loop Progress.

Quando si imposta l'opzione di addestramento Plots su "training-progress" in trainingOptions e si avvia l'addestramento della rete, la funzione trainnet crea una figura e visualizza le metriche di addestramento a ciascuna iterazione. Ogni iterazione è una stima del gradiente e un aggiornamento dei parametri della rete. Se si specificano i dati di convalida in trainingOptions, la figura mostrerà le metriche di convalida ogni volta che trainnet convalida la rete. La figura traccia la perdita e qualsiasi metrica specificata dall'opzione nome-valore Metrics. Per impostazione predefinita, il software utilizza una scala lineare per i grafici. Per specificare una scala logaritmica per l'asse y, selezionare il pulsante scala log nella barra degli strumenti degli assi.

Durante l'addestramento è possibile interromperlo e ripristinare lo stato attuale della rete facendo clic sul pulsante di stop, situato nell'angolo in alto a destra. Dopo aver fatto clic sul pulsante di stop, l'addestramento può richiedere un certo tempo per essere completato. Al termine dell'addestramento, trainnet restituisce la rete addestrata.

Specificare l'opzione di addestramento OutputNetwork come "best-validation" per ottenere valori finalizzati che corrispondano all'iterazione con il miglior valore della metrica di convalida, dove la metrica ottimizzata è specificata dalle opzioni di addestramento ObjectiveMetricName. Specificare l'opzione di addestramento OutputNetwork come "last-iteration" per ottenere metriche finalizzate che corrispondano all'ultima iterazione di addestramento.

Le informazioni relative al tempo di addestramento e alle impostazioni possono essere visualizzate a destra del pannello. Per saperne di più sulle opzioni di addestramento, vedere Set Up Parameters and Train Convolutional Neural Network.

Per salvare il grafico sui progressi dell'addestramento, fare clic su Export as Image (Esporta come immagine) nella finestra di addestramento. È possibile salvare il grafico come file PNG, JPEG, TIFF o PDF. È inoltre possibile salvare i singoli grafici utilizzando la barra degli strumenti degli assi.

Tracciamento dei progressi dell’addestramento durante l’addestramento

Addestrare una rete e tracciare i progressi dell'addestramento durante l’addestramento.

Caricare i dati di addestramento e di test rispettivamente dai file MAT DigitsDataTrain.mat e DigitsDataTest.mat. Gli insiemi di dati di addestramento e di test contengono ciascuno 5000 immagini.

load DigitsDataTrain.mat
load DigitsDataTest.mat

Creare un oggetto dlnetwork.

net = dlnetwork;

Specificare i livelli del ramo di classificazione e aggiungerli alla rete.

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);

Specificare le opzioni per l'addestramento della rete. Specificare i dati di convalida per convalidare la rete a intervalli regolari durante l’addestramento. Registrare i valori della metrica per la precisione e l'F-score. Per tracciare i progressi dell'addestramento durante l’addestramento, impostare l'opzione di addestramento Plots su "training-progress".

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

Addestrare la rete.

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

Arresto anticipato dell'addestramento utilizzando le metriche

Utilizzare le metriche per l'arresto anticipato e per la restituzione della rete migliore.

Caricare i dati di addestramento, che contengono 5000 immagini di cifre. Mettere da parte 1000 immagini per la convalida della rete.

[XTrain,YTrain] = digitTrain4DArrayData;

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

Costruire una rete per classificare i dati delle immagini di cifre.

net = dlnetwork;

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

net = addLayers(net,layers);

Specificare le opzioni di addestramento:

• Utilizzare un solver SGDM per l'addestramento.

• Monitorare la performance dell'addestramento specificando i dati di convalida e la frequenza di convalida.

• Tracciare la precisione e richiamare durante l'addestramento. Per ripristinare la rete con il miglior valore di richiamo, specificare "recall" come metrica dell'obiettivo e impostare la rete di output su "best-validation".

• Specificare l'attesa di convalida come 5, in modo che l'addestramento si arresti se il richiamo non è diminuito per cinque iterazioni.

• Visualizzare il grafico dei progressi dell'addestramento della rete.

• Sopprimere l'output verboso.

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

Addestrare la rete.

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

Argomenti di input

solverName — Solver per l’addestramento della rete neurale

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

Solver per l'addestramento della rete neurale, specificato come uno di questi valori:

• "sgdm": discesa stocastica del gradiente con momento (SGDM). L'SGDM è un solver stocastico. Per ulteriori opzioni di addestramento, vedere Opzioni del solver stocastico. Per ulteriori informazioni, vedere Discesa stocastica del gradiente con momento.

• "rmsprop": propagazione quadratica media (RMSProp). L'RMSProp è un solver stocastico. Per ulteriori opzioni di addestramento, vedere Opzioni del solver stocastico. Per ulteriori informazioni, vedere Propagazione quadratica media.

• "adam": stima adattiva del momento (Adam). L'Adam è un solver stocastico. Per ulteriori opzioni di addestramento, vedere Opzioni del solver stocastico. Per ulteriori informazioni, vedere Stima adattiva del momento.

• "lbfgs" (da R2023b): memoria limitata Broyden–Fletcher–Goldfarb–Shanno (L-BFGS). L-BFGS è un solver batch. Utilizzare l'algoritmo L-BFGS per reti e set di dati di piccole dimensioni che possono essere elaborati in un unico batch. Per ulteriori opzioni di addestramento, vedere Opzioni del solver batch. Per ulteriori informazioni, vedere Memoria limitata BFGS.

• "lm" (da R2024b): Levenberg–Marquardt (LM). LM è un solver batch. Utilizzare l'algoritmo LM per reti di regressione con un numero ridotto di parametri apprendibili, dove è possibile elaborare il set di dati in un unico batch. Se solverName è "lm", l'argomento lossFcn della funzione trainnet deve essere "mse" o "l2loss". Per ulteriori opzioni di addestramento, vedere Opzioni del solver batch. Per ulteriori informazioni, vedere Levenberg–Marquardt.

La funzione trainBERTDocumentClassifier (Text Analytics Toolbox) supporta solo i solver "sgdm", "rmsprop" e "adam".

Argomenti nome-valore

Specificare coppie opzionali di argomenti come Name1=Value1,...,NameN=ValueN, dove Name è il nome dell’argomento e Value è il valore corrispondente. Gli argomenti nome-valore devono comparire dopo gli altri argomenti, ma l'ordine delle coppie non ha importanza.

Prima della release R2021a, utilizzare le virgole per separare ciascun nome e valore e racchiudere Name tra virgolette.

Esempio Plots="training-progress",Metrics="accuracy",Verbose=false specifica di disabilitare l'output verboso e di visualizzare i progressi dell'addestramento in un grafico che includa inoltre la metrica di precisione.

Monitoraggio

Plots — Grafici da visualizzare durante l’addestramento della rete neurale

"none" (predefinito) | "training-progress"

Grafici da visualizzare durante l'addestramento della rete neurale, specificati come uno di questi valori:

• "none": nessuna visualizzazione dei grafici durante l’addestramento.

• "training-progress": grafico dei progressi dell’addestramento.

Il contenuto del grafico dipende dal solver utilizzato.

• Quando l'argomento solverName è "sgdm", "adam" o "rmsprop", il grafico mostra la perdita del mini-batch, la perdita di convalida, le metriche del mini-batch di addestramento e di convalida, specificate dall'opzione Metrics, nonché ulteriori informazioni sui progressi dell'addestramento.

• Quando l'argomento solverName è "lbfgs" o "lm", il grafico mostra la perdita di addestramento e di validazione, le metriche di addestramento e di validazione, specificate dall'opzione Metrics, nonché ulteriori informazioni sui progressi dell'addestramento.

Per aprire e chiudere il grafico sui progressi dell'addestramento in modo programmatico, utilizzare le funzioni show e close con il secondo output della funzione trainnet. È possibile utilizzare la funzione show per visualizzare i progressi dell'addestramento anche se l'opzione di addestramento Plots è specificata come "none".

Per commutare la scala dell'asse y in logaritmica, utilizzare la barra degli strumenti degli assi.

Per ulteriori informazioni sul grafico, vedere Monitoraggio dei progressi dell’addestramento in Deep Learning.

Metrics — Metriche da monitorare

[] (predefinito) | vettore di carattere | array di stringhe | handle delle funzioni | Oggetto deep.DifferentiableFunction (da R2024a) | array di celle | oggetto metrica

Da R2023b

Metriche da monitorare, specificate come uno di questi valori:

• Nome della metrica integrata o della funzione di perdita: specifica delle metriche come scalare di stringa, vettore di carattere oppure come array di celle o array di stringhe, di uno o più di questi nomi:

  • Metriche:

    • "accuracy": accuratezza (nota anche come accuratezza top-1)

    • "auc": area sotto la curva ROC (AUC)

    • "fscore": F-score (noto anche come F₁-score)

    • "precision": precisione

    • "recall": richiamo

    • "rmse": errore quadratico medio

    • "mape": errore medio assoluto percentuale (MAPE) (da R2024b)

  • Funzioni di perdita:

    • "crossentropy": perdita di entropia incrociata per le attività di classificazione. (da R2024b)

    • "indexcrossentropy": perdita di entropia incrociata basata sugli indici per le attività di classificazione. (da R2024b)

    • "binary-crossentropy": perdita di entropia incrociata binaria per le attività di classificazione binaria e a etichetta multipla. (da R2024b)

    • "mae" / "mean-absolute-error" / "l1loss": errore assoluto medio per le attività di regressione. (da R2024b)

    • "mse" / "mean-squared-error" / "l2loss": errore quadratico medio per le attività di regressione. (da R2024b)

    • "huber": perdita di Huber per le attività di regressione (da R2024b)

  Si noti che l'impostazione della funzione di perdita come "crossentropy" e la specifica di "index-crossentropy" come metrica o l'impostazione della funzione di perdita come "index-crossentropy" e la specifica di "crossentropy" come metrica non è supportata.

• Oggetto metrica integrato: se è necessaria una maggiore flessibilità, è possibile utilizzare gli oggetti metrici integrati. Il software supporta questi oggetti metrici integrati:

  • AccuracyMetric

  • AUCMetric

  • FScoreMetric

  • PrecisionMetric

  • RecallMetric

  • RMSEMetric

  • MAPEMetric (da R2024b)

  Quando si crea un oggetto metrica integrato, è possibile specificare ulteriori opzioni, come il tipo di media e se l'attività è a etichetta singola o multipla.

• Handle della funzione metrica personalizzata: se la metrica necessaria non è una metrica integrata, è possibile specificare delle metriche personalizzate utilizzando l'handle delle funzioni. La funzione deve presentare la sintassi metric = metricFunction(Y,T), dove Y corrisponde alle previsioni della rete e T corrisponde alle risposte target. Per le reti con più output, la sintassi deve essere metric = metricFunction(Y1,…,YN,T1,…TM), dove N è il numero di output e M è il numero di target. Per ulteriori informazioni, vedere Define Custom Metric Function.

  Nota

  Quando si dispone di dati suddivisi in mini-batch, il software calcola la metrica per ciascun mini-batch e restituisce la media di tali valori. Per alcune metriche, questo comportamento può portare a un valore di metrica diverso rispetto a quello che si otterrebbe calcolando la metrica utilizzando l'intero set di dati in una sola volta. Nella maggior parte dei casi, i valori sono comunque simili. Per utilizzare una metrica personalizzata non mediata dal batch per i dati, è necessario creare un oggetto metrica personalizzato. Per ulteriori informazioni, vedere Define Custom Deep Learning Metric Object.

• Oggetto deep.DifferentiableFunction (da R2024a): oggetto funzione con funzione di retropropagazione personalizzata. Per i target categorici, il software converte automaticamente i valori categorici in vettori codificati one-hot e li passa alla funzione metrica. Per ulteriori informazioni, vedere Define Custom Deep Learning Operations.

• Oggetto metrica personalizzato: se è necessaria una maggiore personalizzazione, è possibile definire un oggetto metrica personalizzato. Per un esempio che mostra come creare una metrica personalizzata, vedere Define Custom Metric Object. Per informazioni generali sulla creazione di metriche personalizzate, vedere Define Custom Deep Learning Metric Object.

Se si specifica una metrica come handle della funzione, oggetto deep.DifferentiableFunction o oggetto metrica personalizzato e si addestra la rete neurale utilizzando la funzione trainnet, il layout dei target che il software passa alla metrica dipende dal tipo di dati dei target, dalla funzione di perdita specificata nella funzione trainnet e dalle altre metriche specificate:

• Se i target sono array numerici, il software passa direttamente i target alla metrica.

• Se la funzione di perdita è "index-crossentropy" e i target sono array categorici, il software li converte automaticamente in indici di classe numerici e li passa alla metrica.

• Per le altre funzioni di perdita, se i target sono array categorici, il software li converte automaticamente in vettori codificati one-hot e li passa alla metrica.

Questa opzione supporta solo le funzioni trainnet e trainBERTDocumentClassifier (Text Analytics Toolbox).

Esempio Metrics=["accuracy","fscore"]

Esempio Metrics={"accuracy",@myFunction,precisionObj}

ObjectiveMetricName — Nome della metrica dell'obiettivo

"loss" (predefinito) | scalare di stringa | vettore di carattere

Da R2024a

Nome della metrica dell'obiettivo da utilizzare per l'arresto anticipato e la restituzione della rete migliore, specificata come scalare di stringa o vettore di carattere.

Il nome della metrica deve essere "loss" o deve corrispondere al nome di una metrica specificata dall'argomento Metrics. Le metriche specificate utilizzando gli handle delle funzioni non sono supportate. Per specificare il valore ObjectiveMetricName come nome di una metrica personalizzata, il valore della proprietà Maximize dell'oggetto metrica personalizzato non deve essere vuoto. Per ulteriori informazioni, vedere Define Custom Deep Learning Metric Object.

Per ulteriori informazioni sulla definizione della metrica dell'obiettivo per l'arresto anticipato, vedere ValidationPatience. Per ulteriori informazioni sulla restituzione della rete migliore utilizzando la metrica dell'obiettivo, vedere OutputNetwork.

Tipi di dati: char | string

Verbose — Contrassegno per visualizzare le informazioni sui progressi dell'addestramento

1 (true) (predefinito) | 0 (false)

Contrassegno per visualizzare le informazioni sui progressi dell'addestramento nella finestra di comando, specificato come 1 (true) o 0 (false).

Il contenuto dell'output verboso dipende dal tipo di solver.

Per i solver stocastici (SGDM, Adam e RMSProp), la tabella contiene queste variabili:

Variabile	Descrizione
Iteration	Numero di iterazioni.
Epoch	Numero di epoche.
TimeElapsed	Tempo trascorso in ore, minuti e secondi.
LearnRate	Velocità di apprendimento.
TrainingLoss	Perdita di addestramento.
ValidationLoss	Perdita di convalida. Se non si specificano i dati di convalida, il software non visualizza questa informazione.

Per i solver batch (L-BFGS e LM), la tabella contiene queste variabili:

Variabile	Descrizione
Iteration	Numero di iterazioni.
TimeElapsed	Tempo trascorso in ore, minuti e secondi.
TrainingLoss	Perdita di addestramento.
ValidationLoss	Perdita di convalida. Se non si specificano i dati di convalida, il software non visualizza questa informazione.
GradientNorm	Norma dei gradienti.
StepNorm	Norma delle fasi.

Se si specificano ulteriori metriche nelle opzioni di addestramento, le stesse sono inoltre visualizzate nell'output verboso. Ad esempio, se si imposta l'opzione di addestramento Metrics su "accuracy", le informazioni includono le variabili TrainingAccuracy e ValidationAccuracy.

Quando l’apprendimento si arresta, l’output verboso visualizza il motivo dell’arresto.

Per specificare i dati di convalida, utilizzare l’opzione di addestramento ValidationData.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

VerboseFrequency — Frequenza di stampa del verboso

50 (predefinito) | intero positivo

Frequenza di stampa del verboso, ossia il numero di iterazioni tra le stampe nella finestra di comando, specificato come numero intero positivo.

Se si convalida la rete neurale durante l'addestramento, il software stampa anche nella finestra di comando ogni volta che avviene una convalida.

Per abilitare questa proprietà, impostare l'opzione di addestramento Verbose su 1 (true).

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

OutputFcn — Funzioni di output

handle delle funzioni | array di celle degli handle delle funzioni

Funzioni di output da chiamare durante l'addestramento, specificate come handle della funzione o array di celle degli handle delle funzioni. Il software chiama le funzioni una volta prima dell'inizio dell'addestramento, dopo ciascuna iterazione e una volta al termine dell'addestramento.

Le funzioni devono presentare la sintassi stopFlag = f(info), dove info è una struttura contenente informazioni sui progressi dell'addestramento e stopFlag è uno scalare che indica l'arresto anticipato dell'addestramento. Se stopFlag è 1 (true), il software arresta l'addestramento. In caso contrario, il software continua l'addestramento.

La funzione trainnet trasferisce la struttura info alla funzione di output.

Per i solver stocastici (SGDM, Adam e RMSProp), info contiene questi campi:

Campo	Descrizione
Epoch	Numero di epoche
Iteration	Numero di iterazioni
TimeElapsed	Tempo trascorso dall'inizio dell'addestramento
LearnRate	Velocità di apprendimento dell'iterazione
TrainingLoss	Perdita di addestramento dell'iterazione
ValidationLoss	Perdita di convalida, se specificata e valutata all'iterazione.
State	Stato di addestramento dell'iterazione, specificato come "start", "iteration" o "done".

Per i solver batch (L-BFGS e LM), info contiene questi campi:

Campo	Descrizione
Iteration	Numero di iterazioni
TimeElapsed	Tempo trascorso in ore, minuti e secondi
TrainingLoss	Perdita di addestramento
ValidationLoss	Perdita di convalida. Se non si specificano i dati di convalida, il software non visualizza questa informazione.
GradientNorm	Norma dei gradienti
StepNorm	Norma delle fasi
State	Stato di addestramento dell'iterazione, specificato come "start", "iteration" o "done".

Se si specificano ulteriori metriche nelle opzioni di addestramento, le stesse sono inoltre visualizzate nelle informazioni sull'addestramento. Ad esempio, se si imposta l'opzione di addestramento Metrics su "accuracy", le informazioni includono i campi TrainingAccuracy e ValidationAccuracy.

Se un campo non viene calcolato o non è pertinente per una certa chiamata delle funzioni di output, tale campo contiene un array vuoto.

Per un esempio di utilizzo delle funzioni di output, vedere Custom Stopping Criteria for Deep Learning Training.

Tipi di dati: function_handle | cell

Formati dei dati

InputDataFormats — Descrizione delle dimensioni dei dati di input

"auto" (predefinito) | array di stringhe | array di celle dei vettori di carattere | vettore di carattere

Da R2023b

Descrizione delle dimensioni dei dati di input, specificate come array di stringhe, vettore di carattere o array di celle dei vettori di carattere.

Se InputDataFormats è "auto", il software utilizza i formati previsti dall'input di rete. In caso contrario, il software utilizza i formati specificati per il corrispondente input di rete.

Un formato di dati è una stringa di caratteri, dove ciascun carattere descrive il tipo della dimensione di dati corrispondente.

I caratteri sono:

• "S": spaziale

• "C": canale

• "B": batch

• "T": tempo

• "U": non specificato

Ad esempio, si consideri un array contenente un batch di sequenze dove la prima, la seconda e la terza dimensione corrispondono rispettivamente a canali, osservazioni e fasi temporali. È possibile specificare che questo array abbia il formato "CBT" (canale, batch, tempo).

È possibile specificare più dimensioni etichettate "S" o "U". È possibile utilizzare le etichette "C", "B" e "T" una sola volta ciascuna, al massimo. Il software ignora le dimensioni singole finali "U" dopo la seconda dimensione.

Per le reti neurali con più input net, specificare un array di formati dei dati di input, dove InputDataFormats(i) corrisponde all'input net.InputNames(i).

Per ulteriori informazioni, vedere Deep Learning Data Formats.

Tipi di dati: char | string | cell

TargetDataFormats — Descrizione delle dimensioni dei dati target

"auto" (predefinito) | array di stringhe | array di celle dei vettori di carattere | vettore di carattere

Da R2023b

Descrizione delle dimensioni dei dati target, specificate come uno di questi valori:

• "auto": se i dati target presentano lo stesso numero di dimensioni dei dati di input, la funzione trainnet utilizza il formato specificato da InputDataFormats. Se i dati target presentano un numero di dimensioni diverso da quello dei dati di input, la funzione trainnet utilizza il formato previsto dalla funzione di perdita.

• Array di stringhe, vettore di carattere o array di celle dei vettori di carattere: la funzione trainnet utilizza i formati di dati specificati dall'utente.

Un formato di dati è una stringa di caratteri, dove ciascun carattere descrive il tipo della dimensione di dati corrispondente.

I caratteri sono:

• "S": spaziale

• "C": canale

• "B": batch

• "T": tempo

• "U": non specificato

Ad esempio, si consideri un array contenente un batch di sequenze dove la prima, la seconda e la terza dimensione corrispondono rispettivamente a canali, osservazioni e fasi temporali. È possibile specificare che questo array abbia il formato "CBT" (canale, batch, tempo).

È possibile specificare più dimensioni etichettate "S" o "U". È possibile utilizzare le etichette "C", "B" e "T" una sola volta ciascuna, al massimo. Il software ignora le dimensioni singole finali "U" dopo la seconda dimensione.

Per ulteriori informazioni, vedere Deep Learning Data Formats.

Tipi di dati: char | string | cell

Opzioni del solver stocastico

MaxEpochs — Numero massimo di epoche

30 (predefinito) | intero positivo

Numero massimo di epoche (passaggi completi dei dati) da utilizzare per l'addestramento, specificato come numero intero positivo.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

MiniBatchSize — Dimensione del mini-batch

128 (predefinito) | intero positivo

Dimensione del mini-batch da utilizzare per ogni iterazione di addestramento, specificata come un numero intero positivo. Un mini-batch è un sottoinsieme del set di addestramento, utilizzato per valutare il gradiente della funzione di perdita e per aggiornare i pesi.

Se la dimensione del mini-batch non suddivide in modo uniforme il numero di campioni di addestramento, il software scarta i dati di addestramento che non si adattano al mini-batch finale completo di ciascuna epoca. Se la dimensione del mini-batch è inferiore al numero di campioni di addestramento, il software non scarta alcun dato.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Suggerimento

Per ottenere prestazioni ottimali, se si sta addestrando una rete utilizzando un datastore con una proprietà ReadSize, ad esempio imageDatastore, impostare la proprietà ReadSize e l'opzione di addestramento MiniBatchSize sullo stesso valore. Se si sta addestrando una rete utilizzando un datastore con una proprietà MiniBatchSize, ad esempio augmentedImageDatastore, impostare la proprietà MiniBatchSize del datastore e l'opzione di addestramento MiniBatchSize sullo stesso valore.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Shuffle — Opzione per il mescolamento dei dati

"once" (predefinito) | "never" | "every-epoch"

Opzione per il mescolamento dei dati, specificata come uno di questi valori:

• "once": mescolamento dei dati di addestramento e di convalida una volta prima dell’addestramento.

• "never": nessun mescolamento dei dati.

• "every-epoch": mescolamento dei dati di addestramento prima di ogni epoca di addestramento e mescolamento dei dati di convalida prima di ogni convalida della rete neurale. Se la dimensione del mini-batch non suddivide in modo uniforme il numero di campioni di addestramento, il software scarta i dati di addestramento che non si adattano al mini-batch finale completo di ciascuna epoca. Per evitare di scartare gli stessi dati per ogni epoca, impostare l’opzione di addestramento Shuffle su "every-epoch".

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

InitialLearnRate — Velocità di apprendimento iniziale

scalare positivo

Velocità di apprendimento iniziale usata per l’addestramento, specificata come uno scalare positivo.

Se la velocità di apprendimento è troppo bassa, l’addestramento può richiedere più tempo. Se la velocità di apprendimento è troppo alta, l’addestramento potrebbe raggiungere un risultato non ottimale o deviare.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Quando solverName è "sgdm", il valore predefinito è 0.01. Quando solverName è "rmsprop" o "adam", il valore predefinito è 0.001.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LearnRateSchedule — Programma della velocità di apprendimento

"none" (predefinito) | vettore di carattere | array di stringhe | oggetto integrato o personalizzato programma della velocità di apprendimento | handle delle funzioni | array di celle

Programma della velocità di apprendimento, specificato come vettore di carattere o scalare di stringa di un nome di programma della velocità di apprendimento integrato, array di stringhe di nomi, oggetto integrato o personalizzato programma della velocità di apprendimento, handle della funzione o array di celle di nomi, oggetti metrici e handle delle funzioni.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Nomi del programma della velocità di apprendimento integrato

Specificare i programmi della velocità di apprendimento come scalare di stringa, vettore di carattere o array di stringhe o celle contenente uno o più di questi nomi:

Nome	Descrizione	Grafico
"none"	Nessun programma della velocità di apprendimento. Questo programma mantiene la velocità di apprendimento costante.
"piecewise"	Programma di velocità di apprendimento a tratti. Ogni 10 epoche, questo programma riduce la velocità di apprendimento di un fattore di 10.
"warmup" (da R2024b)	Programma della velocità di apprendimento con avvio graduale. Per 5 iterazioni, questo programma aumenta la velocità di apprendimento fino alla velocità di base.
"polynomial" (da R2024b)	Programma della velocità di apprendimento polinomiale. Ogni epoca, questo programma riduce la velocità di apprendimento utilizzando una legge esponenziale con un esponente unitario.
"exponential" (da R2024b)	Programma della velocità di apprendimento esponenziale. Ad ogni epoca, questo programma fa decadere la velocità di apprendimento di un fattore di 10.
"cosine" (da R2024b)	Programma della velocità di apprendimento basato sul coseno. Ogni epoca, questo programma riduce la velocità di apprendimento utilizzando una formula del coseno.
"cyclical" (da R2024b)	Programma della velocità di apprendimento ciclico. Per periodi di 10 epoche, questo programma aumenta la velocità di apprendimento rispetto alla velocità di base per 5 epoche e poi la diminuisce per 5 epoche.

Oggetto programma della velocità di apprendimento integrato (da R2024b)

Se si desidera una maggiore flessibilità rispetto a quella offerta dalle opzioni di stringa, è possibile utilizzare gli oggetti integrati programma della velocità di apprendimento:

• piecewiseLearnRate: un oggetto programma della velocità di apprendimento a tratti riduce periodicamente la velocità di apprendimento moltiplicandola per un fattore specificato. Utilizzare questo oggetto per personalizzare il fattore di riduzione e il periodo del programma a tratti.

  Prima di R2024b: Personalizzare il fattore di riduzione e il periodo utilizzando rispettivamente le opzioni di addestramento LearnRateDropFactor e LearnRateDropPeriod.

• warmupLearnRate: un oggetto programma della velocità di apprendimento graduale aumenta l'apprendimento per un numero specificato di iterazioni. Utilizzare questo oggetto per personalizzare i fattori della velocità di apprendimento iniziale e finale e il numero di passi del programma graduale.

• polynomialLearnRate: un programma della velocità di apprendimento polinomiale riduce la velocità di apprendimento utilizzando una legge esponenziale. Utilizzare questo oggetto per personalizzare i fattori della velocità di apprendimento iniziale e finale, l'esponente e il numero di passi del programma polinomiale.

• exponentialLearnRate: un programma della velocità di apprendimento esponenziale fa decadere la velocità di apprendimento di un fattore specificato. Utilizzare questo oggetto per personalizzare il fattore di riduzione e il periodo del programma esponenziale.

• cosineLearnRate: un oggetto programma della velocità di apprendimento basato sul coseno riduce la velocità di apprendimento utilizzando una curva del coseno e incorpora i riavvii graduali. Utilizzare questo oggetto per personalizzare i fattori della velocità di apprendimento iniziale e finale, il periodo e il fattore di crescita del periodo del programma basato sul coseno.

• cyclicalLearnRate: un programma della velocità di apprendimento ciclico aumenta e diminuisce periodicamente la velocità di apprendimento. Utilizzare questa opzione per personalizzare il fattore massimo, il periodo e il rapporto di passo del programma ciclico.

Programma delle velocità di apprendimento personalizzato (da R2024b)

Per una maggiore flessibilità, è possibile definire un programma della velocità di apprendimento personalizzato come handle della funzione o classe personalizzata che eredita da deep.LearnRateSchedule.

• Handle della funzione del programma della velocità di apprendimento personalizzato: se il programma della velocità di apprendimento necessario non è un programma integrato, è possibile specificare programmi della velocità di apprendimento personalizzati utilizzando un handle della funzione. Per specificare un programma personalizzato, utilizzare un handle della funzione con la sintassi learningRate = f(baseLearningRate,epoch), dove baseLearningRate è la velocità di apprendimento di base e epoch è il numero di epoche.

• Oggetto programma della velocità di apprendimento personalizzato: se si necessita di una maggiore flessibilità rispetto a quella offerta dagli handle della funzione, è possibile definire una classe del programma della velocità di apprendimento personalizzato che eredita da deep.LearnRateSchedule.

Programmi della velocità di apprendimento multipli (da R2024b)

È possibile combinare programmi della velocità di apprendimento multipli specificando più programmi come array di stringhe o di celle; il software applica poi i programmi in ordine, partendo dal primo elemento. Al massimo uno dei programmi può essere infinito (programmi che continuano all'infinito, come "cyclical" e oggetti con la proprietà NumSteps impostata su Inf); il programma infinito deve essere l'ultimo elemento dell'array.

Momentum — Contributo della fase precedente

0.9 (predefinito) | scalare da 0 a 1

Contributo della fase di aggiornamento dei parametri dell’iterazione precedente a quella attuale della discesa stocastica del gradiente con momento, specificato come uno scalare da 0 a 1.

Un valore di 0 indica l’assenza di contributo dalla fase precedente, mentre un valore di 1 indica un contributo massimo dalla fase precedente. Il valore predefinito funziona bene per la maggior parte delle attività.

Questa opzione supporta solo il solver SGDM (quando l'argomento solverName è "sgdm").

Per ulteriori informazioni, vedere Discesa stocastica del gradiente con momento.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

GradientDecayFactor — Velocità di decadimento della media mobile del gradiente

0.9 (predefinito) | scalare non negativo inferiore a 1

Velocità di decadimento della media mobile del gradiente per il solver Adam, specificata come uno scalare non negativo inferiore a 1. La velocità di decadimento del gradiente è indicata da β1 nella sezione Stima adattiva del momento.

Questa opzione supporta solo il solver Adam (quando l'argomento solverName è "adam").

Per ulteriori informazioni, vedere Stima adattiva del momento.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

SquaredGradientDecayFactor — Velocità di decadimento della media mobile del gradiente quadratico

scalare non negativo inferiore a 1

Velocità di decadimento della media mobile del gradiente quadratico per i solver Adam e RMSProp, specificata come uno scalare non negativo inferiore a 1. La velocità di decadimento del gradiente quadratico è indicata con β2 in [4].

Valori tipici della velocità di decadimento 0.9, 0.99 e 0.999, che corrispondono rispettivamente alle lunghezze medie degli aggiornamenti dei parametri 10, 100 e 1000.

Questa opzione supporta solo i solver Adam e RMSProp (quando l'argomento solverName è "adam" o "rmsprop").

Il valore predefinito per il solver Adam è 0.999. Il valore predefinito per il solver RMSProp è 0.9.

Per ulteriori informazioni, vedere Stima adattiva del momento e Propagazione quadratica media.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Epsilon — Offset del denominatore

1e-8 (predefinito) | scalare positivo

Offset del denominatore per i solver Adam e RMSProp, specificato come uno scalare positivo.

Il solver aggiunge l’offset al denominatore negli aggiornamenti dei parametri della rete neurale per evitare una divisione per zero. Il valore predefinito funziona bene per la maggior parte delle attività.

Questa opzione supporta solo i solver Adam e RMSProp (quando l'argomento solverName è "adam" o "rmsprop").

Per ulteriori informazioni, vedere Stima adattiva del momento e Propagazione quadratica media.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LearnRateDropFactor — Fattore per la riduzione della velocità di apprendimento

0.1 (predefinito) | scalare da 0 a 1

Fattore per la riduzione della velocità di apprendimento, specificato come uno scalare da 0 a 1. Questa opzione è valida solo quando l’opzione di addestramento LearnRateSchedule è "piecewise".

LearnRateDropFactor è un fattore di moltiplicazione da applicare alla velocità di apprendimento ogni volta che passa un certo numero di epoche. Specificare il numero di epoche utilizzando l’opzione di addestramento LearnRateDropPeriod.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Suggerimento

Per personalizzare il programma della velocità di apprendimento a tratti, utilizzare un oggetto piecewiseLearnRate. Un oggetto piecewiseLearnRate è consigliato rispetto alle opzioni di addestramento LearnRateDropFactor e LearnRateDropPeriod poiché fornisce un ulteriore controllo sulla velocità di riduzione. (da R2024b)

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LearnRateDropPeriod — Numero di epoche per la riduzione della velocità di apprendimento

10 (predefinito) | intero positivo

Numero di epoche per la riduzione della velocità di apprendimento, specificata come numero intero positivo. Questa opzione è valida solo quando l’opzione di addestramento LearnRateSchedule è "piecewise".

Il software moltiplica la velocità di apprendimento globale per il fattore di riduzione ogni volta che passa il numero di epoche specificato. Specificare il fattore di riduzione utilizzando l’opzione di addestramento LearnRateDropFactor.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Suggerimento

Per personalizzare il programma della velocità di apprendimento a tratti, utilizzare un oggetto piecewiseLearnRate. Un oggetto piecewiseLearnRate è consigliato rispetto alle opzioni di addestramento LearnRateDropFactor e LearnRateDropPeriod poiché fornisce un ulteriore controllo sulla velocità di riduzione. (da R2024b)

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Opzioni del solver batch

MaxIterations — Numero massimo di iterazioni

1000 (predefinito) | intero positivo

Da R2023b

Numero massimo di iterazioni da utilizzare per l'addestramento, specificato come numero intero positivo.

Il solver L-BFGS è un solver full-batch, ossia elabora l'intero set di addestramento in un'unica iterazione.

Questa opzione supporta solo i solver batch (quando l'argomento solverName è "lbfgs" o "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

GradientTolerance — Tolleranza del gradiente relativo

1e-5 (predefinito) | scalare positivo

Da R2023b

Tolleranza del gradiente relativo, specificata come scalare positivo.

Il software arresta l'addestramento quando il gradiente relativo è inferiore o uguale a GradientTolerance.

Questa opzione supporta solo i solver batch (quando l'argomento solverName è "lbfgs" o "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

StepTolerance — Tolleranza della dimensione del passo

1e-5 (predefinito) | scalare positivo

Da R2023b

Tolleranza della dimensione del passo, specificata come scalare positivo.

Il software arresta l'addestramento quando il passo che l'algoritmo compie è inferiore o uguale a StepTolerance.

Questa opzione supporta solo i solver batch (quando l'argomento solverName è "lbfgs" o "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

LineSearchMethod — Metodo per trovare la velocità di apprendimento adatta

"weak-wolfe" (predefinito) | "strong-wolfe" | "backtracking"

Da R2023b

Metodo per trovare la velocità di apprendimento adatta, specificato come uno di questi valori:

• "weak-wolfe": ricerca di una velocità di apprendimento che soddisfi le condizioni deboli di Wolfe. Questo metodo mantiene un'approssimazione definita positiva della matrice hessiana inversa.

• "strong-wolfe": ricerca di una velocità di apprendimento che soddisfi le condizioni forti di Wolfe. Questo metodo mantiene un'approssimazione definita positiva della matrice hessiana inversa.

• "backtracking": ricerca di una velocità di apprendimento che soddisfi sufficienti condizioni di diminuzione. Questo metodo non mantiene un'approssimazione definita positiva della matrice hessiana inversa.

Questa opzione supporta solo il solver L-BFGS (quando l'argomento solverName è "lbfgs").

HistorySize — Numero di aggiornamenti di stato da memorizzare

10 (predefinito) | intero positivo

Da R2023b

Numero di aggiornamenti di stato da memorizzare, specificato come numero intero positivo. I valori compresi tra 3 e 20 sono adatti per la maggior parte delle attività.

L'algoritmo L-BFGS utilizza uno storico dei calcoli del gradiente per approssimare la matrice hessiana in modo ricorsivo. Per ulteriori informazioni, vedere Limited-Memory BFGS.

Questa opzione supporta solo il solver L-BFGS (quando l'argomento solverName è "lbfgs").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

InitialInverseHessianFactor — Valore iniziale che caratterizza la matrice hessiana inversa approssimata

1 (predefinito) | scalare positivo

Da R2023b

Valore iniziale che caratterizza la matrice hessiana inversa approssimata, specificato come scalare positivo.

Per limitare l'utilizzo della memoria, l'algoritmo L-BFGS non memorizza e inverte la matrice hessiana densa B. L'algoritmo utilizza invece l'approssimazione $$B_{k-m}^{-1}\approx {\lambda }_{k}I$$, dove m è la dimensione storica, il fattore hessiano inverso $${\lambda }_k$$ è uno scalare e I è la matrice di identità. L'algoritmo memorizza quindi solo il fattore hessiano scalare inverso. L'algoritmo aggiorna il fattore hessiano inverso a ciascuna fase temporale.

Il fattore hessiano iniziale inverso è il valore di $${\lambda }_0$$.

Per ulteriori informazioni, vedere Limited-Memory BFGS.

Questa opzione supporta solo il solver L-BFGS (quando l'argomento solverName è "lbfgs").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

MaxNumLineSearchIterations — Numero massimo di iterazioni della ricerca lineare

20 (predefinito) | intero positivo

Da R2023b

Numero massimo di iterazioni della ricerca lineare per la determinazione della velocità di apprendimento, specificato come numero intero positivo.

Questa opzione supporta solo il solver L-BFGS (quando l'argomento solverName è "lbfgs").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

InitialStepSize — Valore assoluto massimo approssimativo del primo passo di ottimizzazione

[] (predefinito) | "auto" | scalare reale finito

Da R2024b

Grandezza del passo iniziale, specificata come uno di questi valori:

• []: non utilizzare una grandezza del passo iniziale per determinare l'approssimazione iniziale dell'hessiana.

• "auto": determinare automaticamente la grandezza del passo iniziale. Il software utilizza una grandezza del passo iniziale di $$\Vert s_0{\Vert }_{\infty }=\frac{1}{2}\Vert W_0{\Vert }_{\infty }+0.1$$, dove W₀ sono i parametri iniziali apprendibili della rete.

• Scalare reale positivo: utilizzare il valore specificato come grandezza del passo iniziale $$\Vert s_0{\Vert }_{\infty }$$.

Se InitialStepSize è "auto" o uno scalare reale positivo, il software approssima l'hessiana inversa iniziale utilizzando $${\lambda }_0=\frac{\Vert s_0{\Vert }_{\infty }}{\Vert \nabla J(W_0){\Vert }_{\infty }}$$, dove λ₀ è il fattore hessiano inverso iniziale e $$\nabla J(W_0)$$ denota i gradienti della perdita rispetto ai parametri iniziali apprendibili. Per ulteriori informazioni, vedere Memoria limitata BFGS.

Questa opzione supporta solo il solver L-BFGS (quando l'argomento solverName è "lbfgs").

InitialDampingFactor — Fattore di smorzamento iniziale

0.001 (predefinito) | scalare positivo

Da R2024b

Fattore di smorzamento iniziale, specificato come scalare positivo.

Questa opzione supporta solo il solver LM (quando l'argomento solverName è "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

MaxDampingFactor — Fattore di smorzamento massimo

1e10 (predefinito) | scalare positivo

Da R2024b

Fattore di smorzamento massimo, specificato come scalare positivo.

Questa opzione supporta solo il solver LM (quando l'argomento solverName è "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

DampingIncreaseFactor — Fattore di aumento del fattore di smorzamento

10 (predefinito) | scalare positivo maggiore di 1

Da R2024b

Fattore di aumento del fattore di smorzamento, specificato come scalare positivo maggiore di 1.

Questa opzione supporta solo il solver LM (quando l'argomento solverName è "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

DampingDecreaseFactor — Fattore di diminuzione del fattore di smorzamento

0.1 (predefinito) | scalare positivo minore di 1

Da R2024b

Fattore di diminuzione del fattore di smorzamento, specificato come scalare positivo minore di 1.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Convalida

ValidationData — Dati da utilizzare per la convalida durante l’addestramento

[] (predefinito) | datastore | tabella | array di celle | Oggetto minibatchqueue (da R2024a)

Dati da utilizzare per la convalida durante l'addestramento, specificati come [], datastore, tabella, array di celle o oggetto minibatchqueue contenente i predittori e i target di convalida.

Durante l'addestramento, il software utilizza i dati di convalida per calcolare la perdita di convalida e i valori della metrica. Per specificare la frequenza di convalida, utilizzare l’opzione di addestramento ValidationFrequency. È inoltre possibile utilizzare i dati di convalida per arrestare automaticamente l'addestramento quando la metrica dell'obiettivo di convalida smette di migliorare. Per impostazione predefinita, la metrica dell'obiettivo è impostata su perdita. Per abilitare l’arresto automatico della convalida, utilizzare l’opzione di addestramento ValidationPatience.

Se ValidationData è [], il software non convalida la rete neurale durante l’addestramento.

Se la rete neurale presenta dei livelli che si comportano in modo diverso durante la previsione rispetto all'addestramento (ad esempio, i livelli di dropout), la perdita della validazione può essere inferiore a quella dell'addestramento.

Il software rimescola i dati di convalida in base all'opzione di addestramento Shuffle. Se Shuffle è "every-epoch", il software rimescola i dati di convalida prima di ciascuna convalida della rete neurale.

I formati supportati dipendono dalla funzione di addestramento utilizzata.

Funzione trainnet

Specificare i dati di convalida come datastore, oggetto minibatchqueue o array di celle {predictors,targets}, dove predictors contiene i predittori di convalida e targets contiene i target di convalida. Specificare i predittori e i target di convalida utilizzando uno dei formati supportati dalla funzione trainnet.

Per ulteriori informazioni, vedere gli argomenti di input della funzione trainnet.

Funzione trainBERTDocumentClassifier (Text Analytics Toolbox)

Specificare i dati di convalida come uno di questi valori:

• Array di celle {documents,targets}, dove documents contiene i documenti di input e targets contiene le etichette dei documenti.

• Tabella, dove la prima variabile contiene i documenti di input e la seconda le etichette dei documenti.

Per ulteriori informazioni, vedere gli argomenti di input della funzione trainBERTDocumentClassifier (Text Analytics Toolbox).

ValidationFrequency — Frequenza di convalida della rete neurale

50 (predefinito) | intero positivo

Frequenza di convalida della rete neurale in numero di interazioni, specificata come un numero intero positivo.

Il valore ValidationFrequency è il numero di iterazioni tra le valutazioni delle metriche di convalida. Per specificare i dati di convalida, utilizzare l’opzione di addestramento ValidationData.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

ValidationPatience — Attesa dell’arresto della convalida

Inf (predefinito) | intero positivo

Attesa dell’arresto della convalida dell’addestramento della rete neurale, specificata come un numero intero positivo o Inf.

ValidationPatience specifica il numero di volte in cui la metrica dell'obiettivo sul set di convalida può essere peggiore o uguale al valore migliore precedente prima che l'addestramento della rete neurale si arresti. Se ValidationPatience è Inf, i valori della metrica di convalida non comportano l'arresto anticipato dell'addestramento. Il software mira a massimizzare o minimizzare la metrica, come specificato dalla proprietà Maximize della metrica. Quando la metrica dell'obiettivo è "loss", il software mira a minimizzare il valore della perdita.

La rete neurale ripristinata dipende dall’opzione di addestramento OutputNetwork. Per ripristinare la rete neurale con il miglior valore della metrica di convalida, impostare l'opzione di addestramento OutputNetwork su "best-validation".

Prima di R2024a: Il software calcola l'attesa di convalida utilizzando il valore della perdita di convalida.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

OutputNetwork — Rete neurale da ripristinare al completamento dell’addestramento

"auto" (predefinito) | "last-iteration" | "best-validation"

Rete neurale da ripristinare al completamento dell’addestramento, specificata come uno dei seguenti:

• "auto": utilizzo di "best-validation" se ValidationData è specificato. In caso contrario, utilizzo di "last-iteration".

• "best-validation": ripristino della rete neurale corrispondente all'iterazione di addestramento con il miglior valore della metrica di convalida, dove la metrica da ottimizzare è specificata dall'opzione ObjectiveMetricName. Per utilizzare questa opzione, specificare l’opzione di addestramento ValidationData.

• "last-iteration": ripristino della rete neurale che corrisponde all’ultima iterazione di addestramento.

Regolarizzazione e normalizzazione

L2Regularization — Fattore per la regolarizzazione L₂

0.0001 (predefinito) | scalare non negativo

Fattore per la regolarizzazione L₂ (decadimento dei pesi), specificato come scalare non negativo. Per ulteriori informazioni, vedere Regolarizzazione L2.

Questa opzione non supporta il solver LM (quando l'argomento solverName è "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

ResetInputNormalization — Opzione per ripristinare la normalizzazione del livello di input

1 (true) (predefinito) | 0 (false)

Opzione per ripristinare la normalizzazione del livello di input, specificata come uno dei seguenti:

• 1 (true): ripristino delle statistiche di normalizzazione del livello di input e ricalcolo al momento dell'addestramento.

• 0 (false): calcolo delle statistiche di normalizzazione al momento dell'addestramento quando queste sono vuote.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | logical

BatchNormalizationStatistics — Modalità per valutare le statistiche nei livelli di normalizzazione batch

"auto" (predefinito) | "population" | "moving"

Modalità per valutare le statistiche nei livelli di normalizzazione batch, specificata come uno dei seguenti:

• "population": utilizzo delle statistiche sulla popolazione. Dopo l'addestramento, il software finalizza le statistiche passando ancora una volta per i dati di addestramento e utilizza la media e la varianza risultanti.

• "moving": approssimazione delle statistiche durante l'addestramento utilizzando una stima corrente data dalle fasi di aggiornamento

  $$\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}$$

  , dove $${\mu }^{*}$$ e $${\sigma }^2{}^{*}$$ indicano rispettivamente la media aggiornata e la varianza, $${\lambda }_{\mu }$$ e $${\lambda }_{{\sigma }^2}$$ indicano rispettivamente i valori di decadimento della media e della varianza, $$\widehat{\mu }$$ e $$\widehat{{\sigma }^2}$$ indicano rispettivamente la media e la varianza del livello di input e $$\mu$$ e $${\sigma }^2$$ indicano rispettivamente i valori più recenti della media mobile e della varianza. Dopo l'addestramento, il software utilizza il valore più recente delle statistiche della media mobile e della varianza. Questa opzione supporta unicamente l’addestramento di CPU e GPU singole.

• "auto": utilizzo dell'opzione "moving".

Ridimensionamento del gradiente

GradientThreshold — Soglia del gradiente

Inf (predefinito) | scalare positivo

Soglia del gradiente, specificata come Inf o uno scalare positivo. Se il gradiente supera il valore di GradientThreshold, il gradiente viene ridimensionato secondo l’opzione di addestramento GradientThresholdMethod.

Per ulteriori informazioni, vedere Gradient Clipping (Ridimensionamento del gradiente).

Questa opzione non supporta il solver LM (quando l'argomento solverName è "lm").

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

GradientThresholdMethod — Metodo di soglia del gradiente

"l2norm" (predefinito) | "global-l2norm" | "absolute-value"

Metodo di soglia del gradiente usato per ridimensionare i valori del gradiente che superano la soglia, specificato come uno dei seguenti:

• "l2norm": se la norma L₂ del gradiente di un parametro apprendibile è superiore a GradientThreshold, ridimensionare il gradiente affinché la norma L₂ sia uguale a GradientThreshold.

• "global-l2norm": se la norma globale L₂, L, è superiore a GradientThreshold, ridimensionare tutti i gradienti di un fattore di GradientThreshold/L. La norma globale L₂ tiene in considerazione tutti i parametri apprendibili.

• "absolute-value": se il valore assoluto di una singola derivata parziale nel gradiente di un parametro apprendibile è superiore a GradientThreshold, ridimensionare la derivata parziale affinché abbia una magnitudine uguale a GradientThreshold e conservi il segno della derivata parziale.

Per ulteriori informazioni, vedere Gradient Clipping (Ridimensionamento del gradiente).

Questa opzione non supporta il solver LM (quando l'argomento solverName è "lm").

Sequenza

SequenceLength — Opzione per riempire o troncare le sequenze

"longest" (predefinito) | "shortest"

Opzione per riempire, troncare o suddividere le sequenze di input, specificata come uno di questi valori:

• "longest": riempimento delle sequenze in ogni mini-batch in modo che abbiano la stessa lunghezza della sequenza più lunga. Questa opzione non scarta nessun dato, sebbene il riempimento possa introdurre rumore nella rete neurale.

• "shortest": troncamento delle sequenze in ogni mini-batch in modo che abbiano la stessa lunghezza della sequenza più corta. Questa opzione garantisce che non venga aggiunto alcun riempimento, con il rischio di scartare dei dati.

Per saperne di più sugli effetti di riempimento e troncamento delle sequenze, vedere Riempimento e troncamento delle sequenze.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64 | char | string

SequencePaddingDirection — Direzione di inserimento o troncamento

"right" (predefinito) | "left"

Direzione del riempimento o del troncamento, specificata come una di queste opzioni:

• "right": riempimento o troncamento delle sequenze a destra. Le sequenze hanno inizio nella stessa fase temporale e il software tronca o aggiunge riempimenti al termine di ogni sequenza.

• "left": riempimento o troncamento delle sequenze a sinistra. Il software tronca o aggiunge riempimenti all’inizio di ogni sequenza in modo tale che queste terminino nella stessa fase temporale.

Dato che i livelli ricorrenti elaborano i dati sequenziali una fase temporale alla volta, quando la proprietà OutputMode del livello ricorrente è "last", qualsiasi riempimento nelle fasi temporali finali può influire negativamente sull’output del livello. Per riempire o troncare i dati sequenziali a sinistra, impostare l'argomento SequencePaddingDirection su "left".

Per le reti neurali sequenza-sequenza (quando la proprietà OutputMode è "sequence" per ogni livello ricorrente), qualsiasi riempimento nelle fasi temporali iniziali può influire negativamente sulle previsioni per le fasi temporali precedenti. Per riempire o troncare i dati sequenziali a destra, impostare l’opzione SequencePaddingDirection su "right".

Per saperne di più sugli effetti di riempimento e troncamento delle sequenze, vedere Riempimento e troncamento delle sequenze.

SequencePaddingValue — Valore in base al quale riempire le sequenze di input

0 (predefinito) | scalare

Valore in base al quale riempire le sequenze di input, specificato come scalare.

Non riempire le sequenze con NaN, perché altrimenti si potrebbero produrre errori in tutta la rete neurale.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Hardware e accelerazione

ExecutionEnvironment — Risorsa hardware per l’addestramento della rete neurale

"auto" (predefinito) | "cpu" | "gpu" | "multi-gpu" | "parallel-auto" | "parallel-cpu" | "parallel-gpu"

Risorsa hardware per l'addestramento della rete neurale, specificata come uno di questi valori:

• "auto": utilizzo di una GPU locale, se disponibile. In caso contrario, utilizzo della CPU locale.

• "cpu": utilizzo della CPU locale.

• "gpu": utilizzo della GPU locale.

• "multi-gpu": utilizzo di più GPU su una macchina, usando un pool parallelo locale basato sul profilo cluster predefinito. In caso di assenza di un pool parallelo attuale, il software avvia un pool parallelo con una dimensione pari al numero di GPU disponibili.

• "parallel-auto": utilizzo di un pool parallelo locale o remoto. In caso di assenza di un pool parallelo attuale, il software ne avvia uno utilizzando il profilo cluster predefinito. Se il pool ha accesso alle GPU, unicamente i worker con una sola GPU eseguono i calcoli per l'addestramento e i worker in eccesso diventano inattivi. Se il pool non ha GPU, l’addestramento avviene invece su tutti i worker della CUP disponibili. (da R2024a)

  Prima di R2024a: Utilizzare "parallel" in sostituzione.

• "parallel-cpu": utilizzo delle risorse della CPU in un pool parallelo locale o remoto, ignorando qualsiasi GPU. In caso di assenza di un pool parallelo attuale, il software ne avvia uno utilizzando il profilo cluster predefinito. (da R2023b)

• "parallel-gpu": utilizzo delle GPU in un pool parallelo locale o remoto. I worker in eccesso diventano inattivi. In caso di assenza di un pool parallelo attuale, il software ne avvia uno utilizzando il profilo cluster predefinito. (da R2023b)

Le opzioni "gpu", "multi-gpu", "parallel-auto", "parallel-cpu" e "parallel-gpu" richiedono Parallel Computing Toolbox™. Per utilizzare una GPU per il Deep Learning, occorre avere anche un dispositivo GPU supportato. Per informazioni sui dispositivi supportati, vedere GPU Computing Requirements (Parallel Computing Toolbox). Se si sceglie una di queste opzioni e Parallel Computing Toolbox o se una GPU adatta non è disponibile, il software restituisce un errore.

Per ulteriori informazioni su quando utilizzare i diversi ambienti di esecuzione, vedere Scale Up Deep Learning in Parallel, on GPUs, and in the Cloud.

Per vedere un miglioramento nelle performance durante l’addestramento in parallelo, cercare di ridimensionare le opzioni di addestramento MiniBatchSize e InitialLearnRate del numero di GPU.

Le opzioni "multi-gpu", "parallel-auto", "parallel-cpu" e "parallel-gpu" supportano solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

PreprocessingEnvironment — Ambiente per l'acquisizione e la pre-elaborazione dei dati

"serial" (predefinito) | "background" | "parallel"

Da R2024a

Ambiente per l'acquisizione e la pre-elaborazione dei dati da un datastore durante l'addestramento, specificato come uno di questi valori:

• "serial": acquisizione e pre-elaborazione dei dati in seriale.

• "background": acquisizione e pre-elaborazione dei dati utilizzando il pool in background.

• "parallel": acquisizione e pre-elaborazione dei dati utilizzando i worker in parallelo. Se non è ancora aperto un pool locale, il software apre un pool parallelo utilizzando il profilo predefinito. I pool paralleli non locali non sono supportati. L'utilizzo di questa opzione richiede Parallel Computing Toolbox. Questa opzione non è supportata quando l'addestramento avviene in parallelo (quando l'opzione ExecutionEnvironment è "parallel-auto", "parallel-cpu", "parallel-gpu" o "multi-gpu").

Per utilizzare le opzioni "background" o "parallel", il datastore di input deve essere suddivisibile o divisibile in partizioni. I datastore personalizzati devono implementare la classe matlab.io.datastore.Subsettable.

Le opzioni "background" e "parallel" non sono supportate quando l'opzione Shuffle è "never".

Se si utilizzano le opzioni "background" e "parallel", l'addestramento non è deterministico anche se si utilizza la funzione deep.gpu.deterministicAlgorithms.

Utilizzare l'opzione "background" quando i mini-batch richiedono una pre-elaborazione significativa. Se la pre-elaborazione non è supportata dai thread o se è necessario controllare il numero di worker, utilizzare l'opzione "parallel". Per ulteriori informazioni sull'ambiente di pre-elaborazione, vedere Preprocess Data in the Background or in Parallel.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Prima di R2024a: Per pre-elaborare i dati in parallelo, impostare l'opzione di addestramento DispatchInBackground su 1 (true).

Acceleration — Ottimizzazione della performance

"auto" (predefinito) | "none"

Da R2024a

Ottimizzazione della performance, specificata come uno di questi valori:

• "auto": applicazione automatica di una serie di ottimizzazioni adatte alla rete di input e alle risorse hardware.

• "none": disabilitazione di tutte le ottimizzazioni.

Checkpoint

CheckpointPath — Percorso per salvare le reti neurali con checkpoint

"" (predefinito) | scalare di stringa | vettore di carattere

Percorso per salvare le reti neurali con checkpoint, specificato come scalare di stringa o vettore di carattere.

• Se non si specifica un percorso (ossia si usa il "" predefinito), il software non salva nessuna rete neurale con checkpoint.

• Se si specifica un percorso, il software salva le reti neurali con checkpoint in questo percorso e assegna un nome univoco a ciascuna rete neurale. È quindi possibile caricare qualsiasi rete neurale con checkpoint e riprendere l’addestramento da quella rete neurale.

  Se la cartella non esiste, occorre innanzitutto crearla prima di specificare il percorso per salvare le reti neurali con checkpoint. Se il percorso specificato non esiste, il software lancia un errore.

Tipi di dati: char | string

CheckpointFrequency — Frequenza di salvataggio delle reti neurali con checkpoint

intero positivo

Frequenza di salvataggio delle reti neurali con checkpoint, specificata come un numero intero positivo.

Se solverName è "lbfgs" o CheckpointFrequencyUnit è "iteration", il software salva le reti neurali con checkpoint ogni CheckpointFrequency iterazioni. In caso contrario, il software salva le reti neurali con checkpoint ogni CheckpointFrequency epoche.

Quando solverName è "sgdm", "adam" o "rmsprop", il valore predefinito è 1. Quando solverName è "lbfgs" o "lm", il valore predefinito è 30.

Questa opzione ha effetto solo quando CheckpointPath non è vuoto.

Tipi di dati: single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

CheckpointFrequencyUnit — Unità di frequenza del checkpoint

"epoch" (predefinito) | "iteration"

Unità di frequenza del checkpoint, specificata come "epoch" o "iteration".

Se CheckpointFrequencyUnit è "epoch", il software salva le reti neurali con checkpoint ogni CheckpointFrequency epoche.

Se CheckpointFrequencyUnit è "iteration", il software salva le reti neurali con checkpoint ogni CheckpointFrequency iterazioni.

Questa opzione ha effetto solo quando CheckpointPath non è vuoto.

Questa opzione supporta solo i solver stocastici (quando l'argomento solverName è "sgdm", "adam" o "rmsprop").

Argomenti di output

options — Opzioni di addestramento

TrainingOptionsSGDM | TrainingOptionsRMSProp | TrainingOptionsADAM | TrainingOptionsLBFGS | TrainingOptionsLM

Opzioni di addestramento, restituite come oggetto TrainingOptionsSGDM, TrainingOptionsRMSProp, TrainingOptionsADAM, TrainingOptionsLBFGS, TrainingOptionsLM. Per addestrare una rete neurale, utilizzare le opzioni di addestramento come un argomento di input nella funzione trainnet.

Suggerimenti

• Per la maggior parte delle attività di Deep Learning, è possibile utilizzare una rete neurale preaddestrata e adattarla ai propri dati. Per un esempio su come utilizzare il transfer learning per riaddestrare una rete neurale convoluzionale per classificare un nuovo set di immagini, vedere Retrain Neural Network to Classify New Images. In alternativa, è possibile creare e addestrare reti neurali da zero utilizzando le funzioni trainnet e trainingOptions.

  Se la funzione trainingOptions non fornisce le opzioni di addestramento necessarie per l’attività, è possibile creare un loop di addestramento personalizzato usando la differenziazione automatica. Per saperne di più, vedere Train Network Using Custom Training Loop.

  Se la funzione trainnet non fornisce la funzione di perdita necessaria per l'attività, è possibile specificare una funzione di perdita personalizzata su trainnet come handle della funzione. Per le funzioni di perdita che richiedono più input rispetto alle previsioni e ai target (ad esempio, le funzioni di perdita che richiedono l'accesso alla rete neurale o ulteriori input), addestrare il modello utilizzando un loop di addestramento personalizzato. Per saperne di più, vedere Train Network Using Custom Training Loop.

  Se Deep Learning Toolbox™ non fornisce i livelli necessari per l’attività, è possibile creare un livello personalizzato. Per saperne di più, vedere Define Custom Deep Learning Layers. Per i modelli che non possono essere specificati come reti di livelli, è possibile definire il modello come funzione. Per saperne di più, vedere Train Network Using Model Function.

  Per ulteriori informazioni sul metodo di addestramento da utilizzare per un determinato compito, vedere Train Deep Learning Model in MATLAB.

Algoritmi

Pesi e bias iniziali

Per i livelli convoluzionali e completamente connessi, l’inizializzazione dei pesi e dei bias è data rispettivamente dalle proprietà dei livelli WeightsInitializer e BiasInitializer. Per esempi che mostrano come modificare l’inizializzazione dei pesi e dei bias, vedere Specify Initial Weights and Biases in Convolutional Layer e Specify Initial Weights and Biases in Fully Connected Layer.

Discesa stocastica del gradiente

L’algoritmo di discesa del gradiente standard aggiorna i parametri della rete (pesi e bias) per minimizzare la funzione di perdita spostandosi di poco a ogni iterazione nella direzione del gradiente negativo della perdita,

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

dove $$\ell$$ è il numero di iterazioni, $$\alpha >0$$ è la velocità di apprendimento, $$\theta$$ è il vettore del parametro e $$E\left(\theta \right)$$ è la funzione di perdita. Nell’algoritmo di discesa del gradiente standard, il gradiente della funzione di perdita, $$\nabla E\left(\theta \right)$$, viene valutato usando l’intero set di addestramento e l’algoritmo di discesa del gradiente standard usa subito l’intero set di dati.

Invece, a ogni iterazione l’algoritmo di discesa stocastica del gradiente valuta il gradiente e aggiorna i parametri utilizzando un sottoinsieme dei dati di addestramento. A ogni iterazione viene usato un sottoinsieme diverso, chiamato mini-batch. Un passaggio completo dell'algoritmo di addestramento lungo l’intero set di addestramento usando mini-batch è un’epoca. La discesa stocastica del gradiente è stocastica perché gli aggiornamenti dei parametri calcolati usando un mini-batch sono una stima del rumore dell’aggiornamento dei parametri che risulterebbe usando l’intero set di dati.

Discesa stocastica del gradiente con momento

L’algoritmo di discesa stocastica del gradiente può oscillare lungo il percorso di discesa più ripida verso il valore ottimale. Aggiungere un termine di momento all’aggiornamento dei parametri è un modo per ridurre questa oscillazione [2]. L'aggiornamento della discesa stocastica del gradiente con momento (SGDM) è

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

dove la velocità di apprendimento α e il valore del momento $$\gamma$$ determinano il contributo della fase del gradiente precedente all'iterazione attuale.

Propagazione quadratica media

La discesa stocastica del gradiente con momento usa un’unica velocità di apprendimento per tutti i parametri. Gli altri algoritmi di ottimizzazione cercano di migliorare l’addestramento della rete usando velocità di apprendimento diverse per parametro e possono adattarsi automaticamente alla funzione di perdita ottimizzata. La propagazione quadratica media (RMSProp) è uno di questi algoritmi. Mantiene una media mobile dei quadrati elemento per elemento dei gradienti del parametro,

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

β₂ è il fattore di decadimento del gradiente quadratico della media mobile. Valori comuni della velocità di decadimento sono 0,9, 0,99 e 0,999. Le lunghezze medie corrispondenti dei gradienti quadratici uguali a 1/(1-β₂), ossia rispettivamente gli aggiornamenti dei parametri 10, 100 e 1000. L’algoritmo RMSProp usa questa media mobile per normalizzare gli aggiornamenti di ogni parametro singolarmente,

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

dove la divisione avviene elemento per elemento. Utilizzare RMSProp in modo efficace riduce le velocità di apprendimento dei parametri con gradienti grandi e aumenta i parametri di apprendimento dei parametri con gradienti piccoli. ɛ è una costante ridotta aggiunta per evitare una divisione per zero.

Stima adattiva del momento

La stima adattiva del momento (Adam) [4] utilizza un aggiornamento del parametro simile a RMSProp, ma con un termine di momento aggiunto. Mantiene una media mobile elemento per elemento sia dei gradienti del parametro che dei relativi valori quadratici,

$$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$$

Le velocità di decadimento β₁ e β₂ sono rispettivamente i fattori di decadimento del gradiente e di decadimento del gradiente quadratico. Adam utilizza le medie mobili per aggiornare i parametri della rete come

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

Il valore α è la velocità di apprendimento. Se i gradienti di diverse iterazioni sono simili, l'utilizzo di una media mobile del gradiente consente agli aggiornamenti dei parametri di acquisire il momento in una certa direzione. Se i gradienti contengono soprattutto rumore, la media mobile del gradiente si riduce e di conseguenza si riducono anche gli aggiornamenti dei parametri. L'aggiornamento di Adam completo include anche un meccanismo per correggere un bias che compare all'inizio dell'addestramento. Per ulteriori informazioni, vedere [4].

Memoria limitata BFGS

L'algoritmo L-BFGS [5] è un metodo quasi-Newton che approssima l'algoritmo Broyden-Fletcher-Goldfarb-Shanno (BFGS). Utilizzare l'algoritmo L-BFGS per reti e set di dati di piccole dimensioni che possono essere elaborati in un unico batch.

L'algoritmo aggiorna i parametri apprendibili W all'iterazione k+1 utilizzando il passo di aggiornamento dato da

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

dove W_k specifica i pesi all'iterazione k, $${\eta }_k$$ è la velocità di apprendimento all'iterazione k, B_k è un'approssimazione della matrice hessiana all'iterazione k e $$\nabla J(W_k)$$ specifica i gradienti della perdita rispetto ai parametri apprendibili all'iterazione k.

L'algoritmo L-BFGS calcola direttamente il prodotto matrice-vettore $$B_k^{-1}\nabla J(W_k)$$. L'algoritmo non richiede il calcolo dell'inverso di B_k.

Per limitare l'utilizzo della memoria, l'algoritmo L-BFGS non memorizza e inverte la matrice hessiana densa B. L'algoritmo utilizza invece l'approssimazione $$B_{k-m}^{-1}\approx {\lambda }_{k}I$$, dove m è la dimensione storica, il fattore hessiano inverso $${\lambda }_k$$ è uno scalare e I è la matrice di identità. L'algoritmo memorizza quindi solo il fattore hessiano scalare inverso. L'algoritmo aggiorna il fattore hessiano inverso a ciascuna fase temporale.

Per calcolare direttamente il prodotto matrice-vettore $$B_k^{-1}\nabla J(W_k)$$, l'algoritmo L-BFGS utilizza questo algoritmo ricorsivo:

1. Impostare $$r=B_{k-m}^{-1}\nabla J(W_k)$$, dove m è la dimensione storica.

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

   1. Lasciare $$\beta =\frac{1}{s_{k-i}^{\top }{y}_{k-i}}{y}_{k-i}^{\top }r$$, dove $$s_{k-i}$$ e $$y_{k-i}$$ sono rispettivamente le differenze di passo e di gradiente per l'iterazione $$k-i$$.

   2. Impostare $$r=r+\text{}{s}_{k-i}\text{}\left(a_{k-i}-\beta \right)$$, dove $$a$$ è derivata da $$s$$, $$y$$ e dai gradienti della perdita rispetto alla funzione di perdita. Per ulteriori informazioni, vedere [5].

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

Levenberg–Marquardt

L'algoritmo LM [6] interpola tra i metodi di discesa del gradiente e i metodi Gauss-Newton e può essere più robusto per le reti neurali di piccole dimensioni. Approssima le derivate del secondo ordine utilizzando un prodotto esterno jacobiano. Utilizzare l'algoritmo LM per reti di regressione con un numero ridotto di parametri apprendibili, dove è possibile elaborare il set di dati in un unico batch.

L'algoritmo aggiorna i parametri apprendibili W all'iterazione k+1 utilizzando il passo di aggiornamento dato da

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

dove ΔW_k specifica la modifica dei pesi all'iterazione k data da

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

. In questo caso, H_k è l'hessiana approssimata all'iterazione k e $$\nabla E_k$$ è il gradiente della perdita all'iterazione k rispetto ai parametri apprendibili. L'algoritmo approssima l'hessiana utilizzando

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

, dove J_k è la matrice jacobiana all'iterazione k, μ_k è il fattore di smorzamento all'iterazione k e I è la matrice di identità.

Il solver utilizza il fattore di smorzamento per regolare la grandezza del passo adottato a ogni iterazione e lo aggiorna in modo adattivo a ciascuna iterazione. Aumenta e diminuisce il fattore di smorzamento rispettivamente quando aumentano le iterazioni e diminuisce la perdita. Queste regolazioni fanno sì che l'ottimizzatore esegua passi più grandi e più piccoli quando la perdita è rispettivamente crescente e decrescente.

Quando la perdita aumenta o diminuisce, il solver aumenta o diminuisce il fattore di smorzamento in modo adattivo, moltiplicandolo rispettivamente per DampingIncreaseFactor e DampingDecreaseFactor.

Ridimensionamento del gradiente

Se i gradienti aumentano esponenzialmente in magnitudine, l’addestramento è instabile e può deviare nel giro di qualche iterazione. Questa “esplosione del gradiente” è indicata da una perdita di addestramento che va verso NaN o Inf. Il ridimensionamento del gradiente aiuta a evitare l’esplosione del gradiente stabilizzando l’addestramento a velocità di apprendimento superiori e in presenza di outlier [3]. Il ridimensionamento del gradiente permette alle reti di essere addestrate più velocemente e di solito non influisce sulla precisione dell’attività appresa.

Esistono due tipi di ridimensionamento del gradiente.

• Il ridimensionamento del gradiente basato sulla norma ridimensiona il gradiente in base a una soglia e non modifica la direzione del gradiente. I valori "l2norm" e "global-l2norm" di GradientThresholdMethod sono metodi di ridimensionamento del gradiente basato sulla norma.

• Il ridimensionamento del gradiente basato sul valore ridimensiona una derivata parziale superiore alla soglia, che può risultare in un cambiamento arbitrario di direzione del gradiente. Il ridimensionamento del gradiente basato sul valore può avere un comportamento imprevedibile, ma cambiamenti sufficientemente piccoli non causano la deviazione della rete. Il valore "absolute-value" di GradientThresholdMethod è un metodo di ridimensionamento del gradiente basato sul valore.

Regolarizzazione L₂

Aggiungere un termine di regolarizzazione per i pesi alla funzione di perdita $$E\left(\theta \right)$$ è un modo per ridurre il sovraadattamento [1], [2]. Il termine di regolarizzazione è chiamato anche decadimento dei pesi. La funzione di perdita con il termine di regolarizzazione assume la forma

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

dove $$w$$ è il vettore di peso, $$\lambda$$ è il fattore di regolarizzazione (coefficiente) e la funzione di regolarizzazione $$\Omega \left(w\right)$$ è

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

Si noti che i bias non sono regolarizzati [2]. È possibile specificare il fattore di regolarizzazione $$\lambda$$ usando l’opzione di addestramento L2Regularization. È inoltre possibile specificare diversi fattori di regolarizzazione per livelli e parametri diversi.

La funzione di perdita che il software usa per l’addestramento della rete include il termine di regolarizzazione. Tuttavia, il valore di perdita visualizzato nella finestra di comando e nel grafico dei progressi dell’addestramento durante l’addestramento indica unicamente la perdita sui dati e non include il termine di regolarizzazione.

Riferimenti

[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.

Cronologia versioni

Introdotto in R2016a

R2024b: Addestramento delle reti neurali utilizzando più programmi della velocità di apprendimento

Addestrare le reti neurali utilizzando questi programmi della velocità di apprendimento specificandoli come argomento LearnRateSchedule della funzione trainingOptions:

• "warmup": programma della velocità di apprendimento con avvio graduale

• "polynomial": programma della velocità di apprendimento polinomiale

• "exponential": programma della velocità di apprendimento esponenziale

• "cosine": programma della velocità di apprendimento basato sul coseno

• "cyclical": programma della velocità di apprendimento ciclico

Per personalizzare questi programmi della velocità di apprendimento, utilizzare questi oggetti:

• warmupLearnRate: oggetto programma della velocità di apprendimento con avvio graduale

• polynomialLearnRate: programma della velocità di apprendimento polinomiale

• exponentialLearnRate: programma della velocità di apprendimento esponenziale

• cosineLearnRate: programma della velocità di apprendimento basato sul coseno

• cyclicalLearnRate: programma della velocità di apprendimento ciclico

Nelle versioni precedenti, era possibile eseguire l'addestramento utilizzando un programma della velocità di apprendimento a tratti o nessun programma.

Per personalizzare il programma della velocità di apprendimento a tratti esistente, utilizzare un oggetto piecewiseLearnRate.

Per specificare un programma personalizzato, utilizzare un handle della funzione con la sintassi learnRate = f(initialLearnRate,epoch) oppure definire un oggetto programma della velocità di apprendimento personalizzato definendo una classe che erediti da deep.LearnRateSchedule.

R2024b: Addestramento utilizzando il solver Levenberg-Marquardt

Addestrare una rete neurale utilizzando il solver Levenberg-Marquardt (LM). Utilizzare l'algoritmo LM per reti di regressione con un numero ridotto di parametri apprendibili, dove è possibile elaborare il set di dati in un unico batch.

Per utilizzare il solver LM con la funzione trainnet, creare un oggetto TrainingOptionsLM specificando l'argomento solverName come "lm". È possibile personalizzare il solver LM utilizzando queste nuove opzioni di addestramento:

• InitialDampingFactor: fattore di smorzamento iniziale

• MaxDampingFactor: fattore di smorzamento massimo

• DampingDecreaseFactor: fattore di diminuzione dello smorzamento

• DampingIncreaseFactor: fattore di aumento dello smorzamento

R2024b: Monitoraggio e plottaggio di più metriche durante l'addestramento

Utilizzare oggetti metrici nuovi e aggiornati durante l'addestramento e il test.

• MAPEMetric: errore medio assoluto percentuale (MAPE)

• AccuracyMetric con la nuova opzione NumTopKClasses: precisione top-k

• FScoreMetric con la nuova opzione Beta: F_β-score

È inoltre possibile specificare direttamente questi nuovi nomi integrati di metriche e perdite:

• "mape": errore medio assoluto percentuale (MAPE)

• "crossentropy": perdita di entropia incrociata

• "index-crossentropy": perdita di entropia incrociata basata sugli indici

• "binary-crossentropy": perdita di entropia incrociata binaria

• "mse" / "mean-squared-error" / "l2loss": errore quadratico medio

• "mae" / "mean-absolute-error" / "l1loss": errore assoluto medio

• "huber": perdita di Huber

R2024b: Specifica della grandezza del passo iniziale per il solver L-BFGS

Specificare la grandezza del passo iniziale per il solver L-BFGS utilizzando l'argomento InitialStepSize

R2024a: Specifica dei dati di convalida utilizzando l'oggetto minibatchqueue

Specificare i dati di convalida come oggetto minibatchqueue utilizzando l'argomento ValidationData.

R2024a: Ottimizzazione automatica della performance

Accelerate l'addestramento con l'ottimizzazione automatica della performance. Quando si addestra una rete utilizzando la funzione trainnet, l'ottimizzazione automatica della performance è abilitata per impostazione predefinita. È possibile disattivare l'ottimizzazione della performance impostando l'opzione Acceleration su "none" utilizzando la funzione trainingOptions.

R2024a: Specifica delle metriche come oggetto deep.DifferentiableFunction

Specificare le metriche come oggetto deep.DifferentiableFunction.

R2024a: Impostazione di SequenceLength su un numero intero, non consigliata

L'impostazione di SequenceLength su un numero intero non è consigliata, impostare invece SequenceLength su "longest" o "shortest".

Per i workflow trainNetwork (non consigliato), è possibile impostare SequenceLength su un numero intero. Se SequenceLength è un intero positivo, per ogni mini-batch, il software riempie le sequenze fino a raggiungere la lunghezza della sequenza più lunga nel mini-batch e suddivide le sequenze in sequenze più brevi della lunghezza specificata. In caso di suddivisione, il software crea ulteriori mini-batch e aggiorna lo stato ricorrente della rete tra questi mini-batch. Se la lunghezza della sequenza specificata non suddivide in modo uniforme le lunghezze della sequenza dei dati, i mini-batch che contengono le estremità di quelle sequenze hanno lunghezze più brevi rispetto alla lunghezza della sequenza specificata.

R2024a: Opzione di addestramento DispatchInBackground, non consigliata

L'opzione di addestramento DispatchInBackground non è consigliata. Utilizzare invece l'opzione PreprocessingEnvironment.

L'opzione PreprocessingEnvironment fornisce la stessa funzionalità e consente inoltre di utilizzare backgroundPool per la pre-elaborazione quando si imposta PreprocessingEnvironment su "background".

Questa tabella mostra come aggiornare il codice:

Non consigliato	Consigliato
trainingOptions(solverName,DispatchInBackground=false) (predefinita)	trainingOptions(solverName,PreprocessingEnvironment="serial") (predefinita)
trainingOptions(solverName,DispatchInBackground=true)	trainingOptions(solverName,PreprocessingEnvironment="parallel")

Non è prevista la sospensione dell'opzione DispatchInBackground.

R2024a: Impostazione predefinita di OutputNetwork su "auto"

A partire dalla release R2024a, il valore predefinito dell'opzione di addestramento OutputNetwork è "auto". Se sono stati specificati i dati di convalida, il software restituisce la rete corrispondente al miglior valore della metrica di convalida. Se non sono stati specificati i dati di convalida, il software restituisce la rete corrispondente all'ultima iterazione di addestramento. Se si dispone di dati di convalida e si desidera replicare l'impostazione predefinita precedente, impostare OutputNetwork su "last-iteration".

Questa modifica si applica solo quando si utilizzano le opzioni di addestramento con trainnet. Se si utilizzano le opzioni di addestramento con la funzione trainNetwork non si verifica alcun cambiamento di comportamento e, per impostazione predefinita, il software restituisce la rete corrispondente all'ultima iterazione di addestramento.

R2024a: Valore di OutputNetwork come "best-validation-loss", non consigliato

La specifica di OutputNetwork come "best-validation-loss" non è consigliata. Se si dispone di codice che imposta OutputNetwork su "best-validation-loss", utilizzare invece "best-validation". Il software restituisce la rete corrispondente al miglior valore della metrica di convalida, come specificato dall'opzione ObjectiveMetricName. Per impostazione predefinita, il valore ObjectiveMetricName è impostato su "loss". Questo comportamento si applica solo quando si utilizzano le opzioni di addestramento con la funzione trainnet.

Quando si utilizzano le opzioni di addestramento con la funzione trainNetwork, se si specifica OutputNetwork come "best-validation", il software restituisce sempre la rete con il miglior valore della perdita di convalida.

R2024a: Valore di ExecutionEnvironment come "parallel", non consigliato

A partire dalla release R2024a, la specifica di ExecutionEnvironment come "parallel" non è consigliata. Utilizzare "parallel-auto" in sostituzione.

"parallel-auto" presenta questi vantaggi rispetto a "parallel":

• Il nome dell'opzione descrive in maniera più accurata l'ambiente di esecuzione in quanto il software viene addestrato automaticamente in parallelo utilizzando qualsiasi hardware disponibile.

• Il nome dell'opzione è coerente con l'equivalente seriale "auto".

Non è prevista la sospensione dell'opzione "parallel". "parallel-auto" supporta solo la funzione trainnet. Se si utilizzano le opzioni di addestramento con la funzione trainNetwork, continuare a utilizzare "parallel"

R2024a: Opzione di addestramento WorkerLoad, non consigliata

A partire dalla release R2024a, la specifica dell'opzione di addestramento WorkerLoad non è consigliata. Utilizzare invece spmd (Parallel Computing Toolbox) o la variabile di ambiente CUDA_VISIBLE_DEVICES.

Non è prevista la sospensione dell'assistenza per WorkerLoad per l'addestramento di reti che utilizzano la funzione trainNetwork. WorkerLoad non è supportato per l'addestramento di reti che utilizzano la funzione trainnet.

Questa tabella mostra alcuni usi tipici di WorkerLoad e come aggiornare il codice per utilizzare invece spmd o la variabile di ambiente CUDA_VISIBLE_DEVICES.

Non consigliato	Consigliato
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");

Se in precedenza veniva utilizzata l'opzione WorkerLoad per riservare un worker alla pre-elaborazione dei dati, si consideri la possibilità di pre-elaborare i dati in background specificando l'opzione PreprocessingEnvironment come "background".

R2023b: Addestramento della rete neurale utilizzando il solver L-BFGS

Addestrare una rete neurale utilizzando il solver L-BFGS specificando solverName come "lbfgs". Utilizzare l'algoritmo L-BFGS per reti e set di dati di piccole dimensioni che possono essere elaborati in un unico batch. Per personalizzare il solver L-BFGS, utilizzare le proprietà Opzioni del solver batch.

Questa opzione supporta solo la funzione trainnet.

R2023b: Specifica dei formati dei dati di input e di destinazione

Specificare i formati dei dati di input e di destinazione utilizzando rispettivamente le opzioni InputDataFormats e TargetDataFormats.

Questa opzione supporta solo la funzione trainnet.

R2023b: Addestramento della rete neurale in parallelo utilizzando solo la CPU o solo le risorse della GPU

Addestrare una rete neurale in parallelo utilizzando risorse hardware specifiche specificando ExecutionEnvironment come "parallel-cpu" o "parallel-gpu".

Questa opzione supporta solo la funzione trainnet.

R2023b: Impostazione predefinita di BatchNormalizationStatistics su "auto"

A partire dalla release R2023b, il valore predefinito dell'opzione di addestramento BatchNormalizationStatistics è "auto".

Questa modifica non influisce sul comportamento della funzione. Se si dispone di un codice che controlla la proprietà BatchNormalizationStatistics, aggiornare il codice per tenere conto dell'opzione "auto".

R2022b: trainNetwork riempie i mini-batch fino a raggiungere la lunghezza della sequenza più lunga prima della suddivisione quando si specifica l’opzione di addestramento SequenceLength come un numero intero

Cominciando da R2022b, quando si addestra una rete neurale con dati sequenziali che utilizzano la funzione trainNetwork e l’opzione SequenceLength è un numero intero, il software riempie le sequenze fino a raggiungere la lunghezza della sequenza più lunga in ogni mini-batch, quindi suddividere le sequenze in mini-batch della lunghezza della sequenza specificata. Se SequenceLength non suddivide in modo uniforme la lunghezza della sequenza del mini-batch, l’ultimo mini-batch diviso ha una lunghezza inferiore a SequenceLength. Questo comportamento impedisce l’addestramento della rete neurale su fasi temporali che contengono solo valori di riempimento.

In release precedenti, il software riempie i mini-batch delle sequenze affinché abbiano una lunghezza corrispondente al multiplo più vicino di SequenceLength che è maggiore o uguale alla lunghezza del mini-batch e poi suddivide i dati. Per riprodurre questo comportamento, utilizzare un loop di addestramento personalizzato e implementare questo comportamento quando si pre-elaborano i mini-batch dei dati.

R2018b: L’opzione di addestramento ValidationPatience predefinita è Inf

Cominciando da R2018b, il valore predefinito dell’opzione di addestramento ValidationPatience è Inf, ad indicare che l’arresto automatico per mezzo della convalida è disabilitato. Questo comportamento impedisce che l’addestramento si interrompa prima di un apprendimento sufficiente dei dati.

Nelle versioni precedenti, il valore predefinito è 5. Per riprodurre questo comportamento, impostare l’opzione ValidationPatience su 5.

R2018b: Nome del file diverso per le reti con checkpoint

Cominciando da R2018b, quando si salvano delle reti con checkpoint, il software assegna i nomi dei file iniziando da net_checkpoint_. Nelle versioni precedenti, il software assegna i nomi dei file iniziando da convnet_checkpoint_.

Se si possiede un codice che salva e carica le reti con checkpoint, aggiornare il codice per caricare i file con il nuovo nome.

Vedi anche

trainnet | dlnetwork | analyzeNetwork | Deep Network Designer

Argomenti

• Creazione di una rete neurale semplice di Deep Learning per la classificazione
• Retrain Neural Network to Classify New Images
• Resume Training from Checkpoint Network
• Deep Learning con Big Data su CPU, GPU, in parallelo e nel cloud
• Define Custom Training Loops, Loss Functions, and Networks