Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Addestramento di un modello con Neptune ML. Dopo aver esportato da Neptune i dati da utilizzare per l'addestramento dei modelli, puoi avviare un processo di elaborazione dei dati utilizzando un comando `curl` (o `awscurl`) come il seguente: ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" }' ``` I dettagli su come utilizzare questo comando sono illustrati in [Comando modeltraining](machine-learning-api-modeltraining.md), insieme a informazioni su come recuperare lo stato di un processo in esecuzione, come arrestare un processo in esecuzione e come elencare tutti i processi in esecuzione. È inoltre possibile fornire un `previousModelTrainingJobId` per usare le informazioni provenienti dal processo di addestramento di un modello Neptune ML completato per accelerare la ricerca degli iperparametri in un nuovo processo di addestramento. Questo è utile durante il [riaddestramento del modello su nuovi dati del grafo](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-model-retraining), nonché per l'[addestramento incrementale sugli stessi dati del grafo](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental). Usa un comando come questo: ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "previousModelTrainingJobId" : "(the model-training job-id of a completed job)" }' ``` Puoi addestrare l'implementazione di un modello personalizzato sull'infrastruttura di addestramento di Neptune ML specificando un oggetto `customModelTrainingParameters`, in questo modo: ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "modelName": "custom", "customModelTrainingParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "trainingEntryPointScript": "(your training script entry-point name in the Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` Per ulteriori informazioni, ad esempio su come recuperare lo stato di un processo in esecuzione, su come arrestare un processo in esecuzione e su come elencare tutti i lavori in esecuzione, consulta [Comando modeltraining](machine-learning-api-modeltraining.md). Per ulteriori informazioni su come implementare e usare un modello personalizzato, consulta [Modelli personalizzati in Neptune ML.](machine-learning-custom-models.md). **Topics** + [ # Modelli e addestramento dei modelli in Amazon Neptune ML ](machine-learning-models-and-training.md) + [ # Personalizzazione delle configurazioni degli iperparametri dei modelli in Neptune ML ](machine-learning-customizing-hyperparams.md) + [ # Best practice per l'addestramento dei modelli ](machine-learning-improve-model-performance.md) # Modelli e addestramento dei modelli in Amazon Neptune ML Neptune ML utilizza reti neurali a grafo (GNN) per creare modelli per le varie attività di machine learning. È stato dimostrato che le reti neurali grafiche ottengono state-of-the-art risultati per le attività di apprendimento automatico dei grafi e sono eccellenti nell'estrarre modelli informativi da dati strutturati a grafi. ## Reti neurali grafiche (GNNs) in Neptune ML Le reti neurali a grafo (GNNs) appartengono a una famiglia di reti neurali che calcolano le rappresentazioni dei nodi tenendo conto della struttura e delle caratteristiche dei nodi vicini. GNNs integrano altri metodi tradizionali di apprendimento automatico e di rete neurale che non sono adatti per i dati grafici. GNNs vengono utilizzati per risolvere attività di apprendimento automatico come la classificazione e la regressione dei nodi (previsione delle proprietà dei nodi), la classificazione e la regressione dei bordi (previsione delle proprietà degli spigoli) o la previsione dei link (previsione della connessione o meno di due nodi del grafico). In generale, l'utilizzo di una GNN per un'attività di machine learning prevede due fasi: + Una fase di codifica, in cui la GNN calcola un vettore d-dimensionale per ogni nodo del grafo. Questi vettori sono anche chiamati *rappresentazioni* o *incorporamenti*. + Una fase di decodifica, che effettua previsioni basate sulle rappresentazioni codificate. Per la classificazione e la regressione dei nodi, le rappresentazioni dei nodi vengono utilizzate direttamente per le attività di classificazione e regressione. Per la classificazione e la regressione degli archi, le rappresentazioni dei nodi incidenti su un arco vengono utilizzate come input per la classificazione o la regressione. Per la previsione dei collegamenti, viene calcolato un punteggio di probabilità degli archi utilizzando una coppia di rappresentazioni di nodi e una rappresentazione del tipo di arco. La [Deep Graph Library (DGL)](https://www.dgl.ai/) facilita la definizione e la formazione efficienti di queste attività. GNNs Diversi modelli di GNN sono unificati sotto la formulazione del passaggio dei messaggi. Da questo punto di vista, la rappresentazione di un nodo in un grafo viene calcolata utilizzando le rappresentazioni dei vicini del nodo (i messaggi), insieme alla rappresentazione iniziale del nodo. In Neptune ML la rappresentazione iniziale di un nodo deriva dalle funzionalità estratte dalle proprietà del nodo oppure è apprendibile e dipende dall'identità del nodo. Neptune ML consente inoltre di concatenare le funzionalità dei nodi e le rappresentazioni dei nodi apprendibili per fungere da rappresentazione del nodo originale. Per le varie attività di Neptune ML che coinvolgono grafi con proprietà dei nodi, viene usata la rete [Relational Graph Convolutional Network](https://arxiv.org/abs/1703.06103) (R-GCN) per eseguire la fase di codifica. La R-GCN è un'architettura GNN adatta per i grafi con più tipi di nodi e archi (noti come grafi eterogenei). La rete R-GCN è costituita da un numero fisso di livelli, impilati uno dopo l'altro. Ogni livello della rete R-GCN utilizza i relativi parametri del modello apprendibili per aggregare informazioni dal neighborhood a 1 hop di un nodo. Poiché i livelli successivi utilizzano le rappresentazioni di output del livello precedente come input, il raggio del neighborhood del grafo che influenza l'incorporamento finale di un nodo dipende dal numero di livelli (`num-layer`) della rete R-GCN. Questo significa ad esempio che una rete a 2 livelli utilizza le informazioni provenienti da nodi che si trovano a 2 hop di distanza. Per saperne di più GNNs, consulta [A Comprehensive Survey on Graph Neural](https://arxiv.org/abs/1901.00596) Networks. Per ulteriori informazioni sulla Deep Graph Library (DGL), visita la [pagina web](https://www.dgl.ai/) di DGL. Per un tutorial pratico sull'uso di DGL con GNNs, vedi [Apprendimento delle reti neurali grafiche](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library) con Deep Graph Library. ## Addestramento delle reti neurali a grafo Nel machine learning il processo che consente a un modello di apprendere come fare previsioni valide per un'attività è denominato addestramento del modello. Questa operazione viene in genere eseguita specificando un obiettivo particolare da ottimizzare e un algoritmo da utilizzare per eseguire tale ottimizzazione. Questo processo viene impiegato anche per addestrare una rete GNN ad apprendere rappresentazioni valide anche per l'attività a valle. Per tale attività viene creata una funzione obiettivo che viene ridotta al minimo durante l'addestramento del modello. Ad esempio, per la classificazione dei nodi, utilizziamo [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)come obiettivo, il che penalizza le classificazioni errate, mentre per la regressione dei nodi riduciamo al minimo. [MeanSquareError](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html) L'obiettivo è in genere una funzione di perdita che accetta le previsioni del modello per un punto dati specifico e le confronta con il valore ground-truth per tale punto dati. Restituisce il valore di perdita, che mostra quanto siano lontane le previsioni del modello. L'obiettivo del processo di addestramento è ridurre al minimo le perdite e garantire che le previsioni dei modelli siano vicine al valore ground-truth. L'algoritmo di ottimizzazione utilizzato nel deep learning per il processo di addestramento è in genere una variante della discesa del gradiente. In Neptune ML, [utilizziamo](https://arxiv.org/pdf/1412.6980.pdf) Adam, un algoritmo per l'ottimizzazione basata su gradiente del primo ordine di funzioni obiettivo stocastiche basate su stime adattive di momenti di ordine inferiore. Sebbene il processo di addestramento del modello tenti di garantire che i parametri del modello appresi siano vicini ai minimi della funzione obiettivo, le prestazioni complessive di un modello dipendono anche dagli *iperparametri* del modello, che sono impostazioni del modello che non vengono apprese dall'algoritmo di addestramento. Ad esempio, la dimensionalità della rappresentazione del nodo appresa, `num-hidden`, è un iperparametro che influisce sulle prestazioni del modello. Pertanto, nel machine learning è comune eseguire l'ottimizzazione degli iperparametri per scegliere gli iperparametri adatti. Neptune ML utilizza SageMaker un processo di ottimizzazione degli iperparametri AI per avviare più istanze di addestramento dei modelli con diverse configurazioni di iperparametri per cercare di trovare il modello migliore per una serie di impostazioni di iperparametri. Consultare [Personalizzazione delle configurazioni degli iperparametri dei modelli in Neptune ML](machine-learning-customizing-hyperparams.md). ## Modelli di incorporamento del grafo della conoscenza in Neptune ML I Knowledge graphs (KGs) sono grafici che codificano informazioni su diverse entità (nodi) e le relative relazioni (bordi). In Neptune ML i modelli di incorporamento del grafo della conoscenza vengono applicati per impostazione predefinita per eseguire la previsione dei collegamenti quando il grafo non contiene proprietà dei nodi, ma solo relazioni con altri nodi. Tuttavia, anche i modelli R-GCN con incorporamenti apprendibili possono essere utilizzati per questi grafi specificando il tipo di modello `"rgcn"`, poiché i modelli di incorporamento dei grafi della conoscenza sono più semplici e progettati per essere efficaci per l'apprendimento di rappresentazioni per grafi della conoscenza su larga scala. I modelli di incorporamento dei grafi della conoscenza vengono usati in un'attività di previsione dei collegamenti per prevedere i nodi o le relazioni che completano una tripla `(h, r, t)`, dove `h` è il nodo di origine, `r` è il tipo di relazione e `t` è il nodo di destinazione. I modelli di incorporamento del grafo della conoscenza implementati in Neptune ML sono `distmult`, `transE` e `rotatE`. Per ulteriori informazioni sui modelli di incorporamento del grafo della conoscenza, consulta [DGL-KE](https://github.com/awslabs/dgl-ke). ## Addestramento di modelli personalizzati in Neptune ML. Neptune ML consente di definire e implementare modelli personalizzati, per scenari specifici. Per informazioni su come implementare un modello personalizzato e su come utilizzare l'infrastruttura di Neptune ML per addestrarlo, consulta [Modelli personalizzati in Neptune ML.](machine-learning-custom-models.md). # Personalizzazione delle configurazioni degli iperparametri dei modelli in Neptune ML Quando si avvia un processo di addestramento dei modelli Neptune ML, Neptune ML utilizza automaticamente le informazioni dedotte dal precedente processo di [elaborazione dei dati](machine-learning-on-graphs-processing.md). Utilizza le informazioni per generare intervalli di configurazione iperparametrici che vengono utilizzati per creare un [processo di ottimizzazione degli iperparametri SageMaker AI per addestrare](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html) più modelli per l'attività. In questo modo, non è necessario specificare un lungo elenco di valori di iperparametri da usare per l'addestramento dei modelli. Gli intervalli e i valori predefiniti degli iperparametri del modello vengono invece selezionati in base al tipo di attività, al tipo di grafo e alle impostazioni del processo di ottimizzazione. Tuttavia, è anche possibile ignorare la configurazione degli iperparametri predefinita e specificare iperparametri personalizzati modificando un file di configurazione JSON generato dal processo di elaborazione dei dati. Utilizzando l'API [modelTraining](machine-learning-api-modeltraining.md) di Neptune ML, puoi controllare diverse impostazioni generali degli iperparametri del processo di ottimizzazione, come `maxHPONumberOfTrainingJobs`, `maxHPOParallelTrainingJobs` e `trainingInstanceType`. Per un controllo più granulare sugli iperparametri del modello, è possibile personalizzare il file `model-HPO-configuration.json` generato dal processo di elaborazione dei dati. Il file viene salvato nella posizione Amazon S3 specificata per l'output del processo di elaborazione. Puoi scaricare il file, modificarlo per sovrascrivere le configurazioni degli iperparametri predefinite e caricarlo nuovamente nella stessa posizione Amazon S3. Non modificare il nome del file e presta attenzione a seguire queste istruzioni durante la modifica. Per scaricare il file da S3 ``` aws s3 cp \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json \ ./ ``` Al termine della modifica, carica nuovamente il file nella posizione originale: ``` aws s3 cp \ model-HPO-configuration.json \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json ``` ## Struttura del file `model-HPO-configuration.json` Il file `model-HPO-configuration.json` specifica il modello da addestrare, il tipo di attività `task_type` di machine learning e gli iperparametri che devono essere variati o fissi per le varie esecuzioni di addestramento del modello. Gli iperparametri sono classificati come appartenenti a vari livelli che indicano la precedenza assegnata agli iperparametri quando viene richiamato il processo di ottimizzazione degli iperparametri: + Gli iperparametri di livello 1 hanno la precedenza più alta. Se imposti `maxHPONumberOfTrainingJobs` su un valore minore di 10, vengono ottimizzati solo gli iperparametri di livello 1 e gli altri assumono i valori predefiniti. + Gli iperparametri di livello 2 hanno una precedenza inferiore, quindi se sono presenti più di 10 ma meno di 50 processi di addestramento totali per un processo di ottimizzazione, vengono ottimizzati sia gli iperparametri di livello 1 che di livello 2. + Gli iperparametri di livello 3 vengono ottimizzati insieme a quelli di livello 1 e 2 solo se sono presenti più di 50 processi di addestramento totali. + Infine, gli iperparametri fissi non vengono mai ottimizzati e assumono sempre i valori predefiniti. ### Esempio di file `model-HPO-configuration.json` Di seguito è riportato un file `model-HPO-configuration.json` di esempio. ``` { "models": [ { "model": "rgcn", "task_type": "node_class", "eval_metric": { "metric": "acc" }, "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, "1-tier-param": [ { "param": "num-hidden", "range": [16, 128], "type": "int", "inc_strategy": "power2" }, { "param": "num-epochs", "range": [3,30], "inc_strategy": "linear", "inc_val": 1, "type": "int", "node_strategy": "perM" }, { "param": "lr", "range": [0.001,0.01], "type": "float", "inc_strategy": "log" } ], "2-tier-param": [ { "param": "dropout", "range": [0.0,0.5], "inc_strategy": "linear", "type": "float", "default": 0.3 }, { "param": "layer-norm", "type": "bool", "default": true } ], "3-tier-param": [ { "param": "batch-size", "range": [128, 4096], "inc_strategy": "power2", "type": "int", "default": 1024 }, { "param": "fanout", "type": "int", "options": [[10, 30],[15, 30], [15, 30]], "default": [10, 15, 15] }, { "param": "num-layer", "range": [1, 3], "inc_strategy": "linear", "inc_val": 1, "type": "int", "default": 2 }, { "param": "num-bases", "range": [0, 8], "inc_strategy": "linear", "inc_val": 2, "type": "int", "default": 0 } ], "fixed-param": [ { "param": "concat-node-embed", "type": "bool", "default": true }, { "param": "use-self-loop", "type": "bool", "default": true }, { "param": "low-mem", "type": "bool", "default": true }, { "param": "l2norm", "type": "float", "default": 0 } ] } ] } ``` ### Elementi di un file `model-HPO-configuration.json` Il file contiene un oggetto JSON con un singolo array di primo livello denominato `models` che contiene un singolo oggetto configurazione del modello. Quando personalizzi il file, assicurati che l'array `models` contenga solo un oggetto configurazione del modello. Se il file contiene più di un oggetto configurazione del modello, il processo di ottimizzazione avrà esito negativo e verrà visualizzato un avviso. L'oggetto configurazione del modello contiene i seguenti elementi di primo livello: + **`model`** (*stringa*): tipo di modello da addestrare (**da non modificare**). I valori validi sono: + `"rgcn"`: impostazione predefinita per le attività di classificazione e regressione dei nodi e per le attività di previsione dei collegamenti eterogenee. + `"transe"`: impostazione predefinita per le attività di previsione dei collegamenti di incorporamento del grafo della conoscenza. + `"distmult"`: tipo di modello alternativo per le attività di previsione dei collegamenti di incorporamento del grafo della conoscenza. + `"rotate"`: tipo di modello alternativo per le attività di previsione dei collegamenti di incorporamento del grafo della conoscenza. In generale, è consigliabile non modificare direttamente il valore `model`, in quanto diversi tipi di modello hanno spesso iperparametri applicabili sostanzialmente diversi e ciò può causare un errore di analisi dopo l'avvio del processo di addestramento. Per modificare il tipo di modello, usa il parametro `modelName` nell'[API modelTraining](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) anziché modificarlo nel file `model-HPO-configuration.json`. Un modo per modificare il tipo di modello e apportare modifiche granulari agli iperparametri consiste nel copiare il modello di configurazione del modello predefinito per il modello da usare e incollarlo nel file `model-HPO-configuration.json`. Esiste una cartella denominata `hpo-configuration-templates` nella stessa posizione Amazon S3 del file `model-HPO-configuration.json` se il tipo di attività dedotto supporta più modelli. Questa cartella contiene tutte le configurazioni di iperparametri predefinite per gli altri modelli applicabili all'attività. Ad esempio, per modificare le configurazioni del modello e degli iperparametri per un'attività di previsione dei collegamenti `KGE` dal modello predefinito `transe` a un modello `distmult`, è sufficiente incollare il contenuto del file `hpo-configuration-templates/distmult.json` nel file `model-HPO-configuration.json` e quindi modificare gli iperparametri in base alle esigenze. **Nota** Se imposti il parametro `modelName` nell'API `modelTraining` e modifichi il `model` e la specifica degli iperparametri nel file `model-HPO-configuration.json` e questi sono diversi, il valore `model` nel file `model-HPO-configuration.json` ha la precedenza e il valore `modelName` viene ignorato. + **`task_type`** (*stringa*): tipo di attività di machine learning dedotto o passato direttamente al processo di elaborazione dei dati (**da non modificare**). I valori validi sono: + `"node_class"` + `"node_regression"` + `"link_prediction"` Il processo di elaborazione dei dati deduce il tipo di attività esaminando il set di dati esportato e il file di configurazione del processo di apprendimento generato per verificare le proprietà del set di dati. Questo valore non deve essere modificato. Se si desidera addestrare un'attività diversa, è necessario [eseguire un nuovo processo di elaborazione dei dati](machine-learning-on-graphs-processing.md). Se il valore `task_type` non è quello previsto, è consigliabile verificare gli input del processo di elaborazione dati per assicurarsi che siano corretti. Sono inclusi i parametri nell'API `modelTraining` e il file di configurazione del processo di addestramento generato dal processo di esportazione dei dati. + **`eval_metric`** (*stringa*): la metrica di valutazione deve essere utilizzata per valutare le prestazioni del modello e per selezionare il modello con le migliori prestazioni tra le esecuzioni di ottimizzazione degli iperparametri. I valori validi sono: + `"acc"`: accuratezza della classificazione standard. Si tratta dell'impostazione predefinita per le attività di classificazione a etichetta singola, a meno che non vengano rilevate etichette sbilanciate durante l'elaborazione dei dati, nel qual caso l'impostazione predefinita è `"F1"`. + `"acc_topk"`: numero di volte in cui l'etichetta corretta compare tra le prime **`k`** previsioni. Puoi anche impostare il valore **`k`** passando `topk` come chiave aggiuntiva. + `"F1"`: [punteggio F1](https://en.wikipedia.org/wiki/F-score). + `"mse"`: [metrica dell'errore quadratico medio](https://en.wikipedia.org/wiki/Mean_squared_error), per le attività di regressione. + `"mrr"`: [metrica della classificazione reciproca media.](https://en.wikipedia.org/wiki/Mean_reciprocal_rank) + `"precision"`: precisione del modello, calcolata come rapporto tra veri positivi e positivi previsti: `= true-positives / (true-positives + false-positives)`. + `"recall"`: sensibilità del modello, calcolata come rapporto tra veri positivi e positivi effettivi: `= true-positives / (true-positives + false-negatives)`. + `"roc_auc"`: area sotto la [curva ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic). Questa è l'impostazione predefinita per la classificazione multi-etichetta. Ad esempio, per modificare la metrica in `F1`, modifica il valore `eval_metric` come indicato di seguito: ``` " eval_metric": { "metric": "F1", }, ``` In alternativa, per modificare la metrica in un punteggio di accuratezza `topk`, dovrai modificare `eval_metric` come indicato di seguito: ``` "eval_metric": { "metric": "acc_topk", "topk": 2 }, ``` + **`eval_frequency`** (*oggetto*): specifica con quale frequenza durante l'addestramento devono essere verificate le prestazioni del modello sul set di convalida. In base alle prestazioni di convalida, è quindi possibile avviare l'arresto anticipato e salvare il modello migliore. L'oggetto `eval_frequency` contiene due elementi, ovvero `"type"` e `"value"`. Esempio: ``` "eval_frequency": { "type": "evaluate_every_pct", "value": 0.1 }, ``` I valori `type` validi sono: + **`evaluate_every_pct`**: specifica la percentuale di addestramento da completare per ogni valutazione. Per `evaluate_every_pct`, il campo `"value"` contiene un numero a virgola mobile compreso tra zero e uno che esprime tale percentuale. + **`evaluate_every_batch`**: specifica il numero di batch di addestramento da completare per ogni valutazione. Per `evaluate_every_batch`, il campo `"value"` contiene un numero intero che esprime il numero di batch. + **`evaluate_every_epoch`**: specifica il numero di epoche per valutazione, dove una nuova epoca inizia a mezzanotte. Per `evaluate_every_epoch`, il campo `"value"` contiene un numero intero che esprime il numero di epoche. L'impostazione predefinita per `eval_frequency` è: ``` "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, ``` + **`1-tier-param`** (*obbligatorio*): array di iperparametri di livello 1. Se non si desidera ottimizzare alcun iperparametro, è possibile impostare questo parametro su un array vuoto. Ciò non influisce sul numero totale di processi di formazione avviati dal processo di ottimizzazione degli SageMaker iperparametri AI. Significa solo che tutti i processi di addestramento, se ne esistono più di 1 ma meno di 10, verranno eseguiti con lo stesso set di iperparametri. D'altra parte, per trattare tutti gli iperparametri ottimizzabili con uguale importanza, puoi includere tutti gli iperparametri in questo array. + **`2-tier-param`** (*obbligatorio*): array di iperparametri di livello 2. Questi parametri vengono ottimizzati solo se il valore di `maxHPONumberOfTrainingJobs` è maggiore di 10. In caso contrario, assumono i valori predefiniti. Se disponi di un budget di addestramento di almeno 10 processi di addestramento o se non desideri iperparametri di livello 2 per altri motivi, ma desideri ottimizzare tutti gli iperparametri ottimizzabili, puoi impostare questo parametro su un array vuoto. + **`3-tier-param`** (*obbligatorio*): array di iperparametri di livello 3. Questi parametri vengono ottimizzati solo se il valore di `maxHPONumberOfTrainingJobs` è maggiore di 50. In caso contrario, assumono i valori predefiniti. Se non si desiderano iperparametri di livello 3, è possibile impostare questo parametro su un array vuoto. + **`fixed-param`** (*obbligatorio*): array di iperparametri fissi che accettano solo i relativi valori predefiniti e non variano in processi di addestramento diversi. Per variare tutti gli iperparametri, puoi impostare questo parametro su un array vuoto e impostare il valore per `maxHPONumberOfTrainingJobs` su un numero sufficientemente elevato per variare tutti i livelli o impostare tutti gli iperparametri come di livello 1. L'oggetto JSON che rappresenta ogni iperparametro in `1-tier-param`, `2-tier-param`, `3-tier-param` e `fixed-param` contiene i seguenti elementi: + **`param`** (*stringa*): nome dell'iperparametro (**da non modificare**). Vedi l'[elenco dei nomi di iperparametri validi in Neptune ML](#machine-learning-hyperparams-list). + **`type`** (*stringa*): tipo dell'iperparametro (**da non modificare**). I tipi validi sono `bool`, `int` e `float`. + **`default`** (*stringa*): valore predefinito per l'iperparametro. È possibile impostare un nuovo valore predefinito. Gli iperparametri ottimizzabili possono contenere anche i seguenti elementi: + **`range`** (*array*): intervallo per un iperparametro ottimizzabile in modo continuo. Deve essere un array con due valori, ovvero il valore minimo e il valore massimo dell'intervallo (`[min, max]`). + **`options`** (*array*): opzioni per un iperparametro categoriale ottimizzabile. Questo array deve contenere tutte le opzioni da considerare: ``` "options" : [value1, value2, ... valuen] ``` + **`inc_strategy`** (*stringa*): tipo di modifica incrementale per gli intervalli di iperparametri ottimizzabili in modo continuo (**da non modificare**). I valori validi sono `log`, `linear` e `power2`. Si applica solo quando è impostata la chiave di intervallo. La modifica di questo elemento può determinare il mancato utilizzo dell'intero intervallo dell'iperparametro per l'ottimizzazione. + **`inc_val`** (*float*): quantità in base alla differiscono gli incrementi successivi per gli iperparametri ottimizzabili in modo continuo (**da non modificare**). Si applica solo quando è impostata la chiave di intervallo. La modifica di questo elemento può determinare il mancato utilizzo dell'intero intervallo dell'iperparametro per l'ottimizzazione. + **`node_strategy`** (*stringa*): indica che l'intervallo effettivo per questo iperparametro deve cambiare in base al numero di nodi nel grafo (**da non modificare**). I valori validi sono `"perM"` (per milione), `"per10M"` (per 10 milioni) e `"per100M"` (per 100 milioni). Invece di modificare questo valore, prova a modificare `range`. + **`edge_strategy`** (*stringa*): indica che l'intervallo effettivo per questo iperparametro deve cambiare in base al numero di archi nel grafo (**da non modificare**). I valori validi sono `"perM"` (per milione), `"per10M"` (per 10 milioni) e `"per100M"` (per 100 milioni). Invece di modificare questo valore, prova a modificare `range`. ### Elenco di tutti gli iperparametri in Neptune ML L'elenco seguente contiene tutti gli iperparametri che possono essere impostati ovunque in Neptune ML, per qualsiasi tipo di modello e attività. Poiché non sono tutti applicabili a ogni tipo di modello, è importante impostare nel file `model-HPO-configuration.json` solo gli iperparametri disponibili nel modello in uso. + **`batch-size`**: dimensioni del batch dei nodi di destinazione utilizzati in un unico passaggio in avanti. *Tipo*: `int`. L'impostazione di questo elemento su un valore molto elevato può causare problemi di memoria per l'addestramento sulle istanze GPU. + **`concat-node-embed`**: indica se ottenere o meno la rappresentazione iniziale di un nodo concatenando le relative funzionalità elaborate con incorporamenti iniziali del nodo apprendibili per aumentare l'espressività del modello. *Tipo*: `bool`. + **`dropout`**: probabilità di abbandono applicata ai livelli di abbandono. *Tipo*: `float`. + **`edge-num-hidden`**: dimensioni del livello nascosto o il numero di unità per il modulo della funzionalità arco. Usato solo quando `use-edge-features` è impostato su `True`. *Tipo*: float. + **`enable-early-stop`**: attiva/disattiva l'utilizzo della funzionalità di arresto anticipato. *Tipo*: `bool`. *Default*: `true` Usa questo parametro booleano per disattivare la funzionalità di arresto anticipato. + **`fanout`**: numero di neighbor da campionare per un nodo di destinazione durante il campionamento dei neighbor. *Tipo*: `int`. Questo valore è strettamente associato a `num-layers` e deve trovarsi sempre nello stesso livello di iperparametri. Questo perché puoi specificare un fanout per ogni potenziale livello GNN. Poiché questo iperparametro può causare ampie variazioni nelle prestazioni del modello, deve essere fisso o impostato come iperparametro di livello 2 o di livello 3. L'impostazione di questo elemento su un valore elevato può causare problemi di memoria per l'addestramento sulle istanze GPU. + **`gamma`**: valore del margine nella funzione di punteggio. *Tipo*: `float`. Si applica solo ai modelli di previsione dei collegamenti `KGE`. + **`l2norm`**: valore di decadimento del peso utilizzato nell'ottimizzatore che impone una penalità di normalizzazione L2 ai pesi. *Tipo*: `bool`. + **`layer-norm`**: indica se utilizzare la normalizzazione dei livelli per i modelli `rgcn`. *Tipo*: `bool`. + **`low-mem`**: indica se utilizzare un'implementazione a bassa memoria della funzione di passaggio dei messaggi di relazione a scapito della velocità. *Tipo*: `bool`. + **`lr`**: velocità di apprendimento. *Tipo*: `float`. Deve essere impostato come un iperparametro di primo livello. + **`neg-share`**: nella previsione dei collegamenti, indica se gli archi campionati positivi possono condividere campioni di archi negativi. *Tipo*: `bool`. + **`num-bases`**: numero di basi per la scomposizione delle basi in un modello `rgcn`. L'utilizzo di un valore `num-bases` inferiore al numero di tipi di archi nel grafo funge da regolarizzatore per il modello `rgcn`. *Tipo*: `int`. + **`num-epochs`**: numero di epoche di addestramento da eseguire. *Tipo*: `int`. Un'epoca è un passaggio di addestramento completo attraverso il grafo. + **`num-hidden`**: dimensioni del livello nascosto o numero di unità. *Tipo*: `int`. Questo elemento imposta anche le dimensioni dell'incorporamento iniziale per i nodi senza funzionalità. Impostarlo su un valore molto più grande senza ridurlo `batch-size` può causare out-of-memory problemi di formazione sull'istanza GPU. + **`num-layer`**: numero di livelli GNN nel modello. *Tipo*: `int`. Questo valore è strettamente associato al parametro fanout e deve essere posizionato dopo aver impostato il fanout nello stesso livello di iperparametri. Poiché questo iperparametro può causare ampie variazioni nelle prestazioni del modello, deve essere fisso o impostato come iperparametro di livello 2 o di livello 3. + **`num-negs`**: nella previsione dei collegamenti, il numero di campioni negativi per campione positivo. *Tipo*: `int`. + **`per-feat-name-embed`**: indica se incorporare ogni funzionalità trasformandola in modo indipendente prima di combinare le funzionalità. *Tipo*: `bool`. Se questo elemento è impostato su `true`, ogni funzionalità per nodo viene trasformata in modo indipendente in in dimensioni di dimensione fissa prima che tutte le funzionalità trasformate per il nodo vengano concatenate e ulteriormente trasformate nella dimensione `num_hidden`. Se questo elemento è impostato su `false`, le funzionalità vengono concatenate senza trasformazioni specifiche delle funzionalità. + **`regularization-coef`**: nella previsione dei collegamenti, il coefficiente di perdita di regolarizzazione. *Tipo*: `float`. + **`rel-part`**: indica se utilizzare la partizione di relazione per la previsione dei collegamenti `KGE`. *Tipo*: `bool`. + **`sparse-lr`**: velocità di apprendimento per gli incorporamenti di nodi apprendibili. *Tipo*: `float`. Gli incorporamenti iniziali dei nodi apprendibili vengono utilizzati per i nodi senza funzionalità o quando è impostato il parametro `concat-node-embed`. I parametri del livello di incorporamento dei nodi apprendibili sparse vengono addestrati utilizzando un ottimizzatore separato che può avere una velocità di apprendimento distinta. + **`use-class-weight`**: indica se applicare i pesi di classe per attività di classificazione non bilanciate. Se impostato su `true`, viene usato il numero di etichette per impostare un peso per ogni etichetta di classe. *Tipo*: `bool`. + **`use-edge-features`**: indica se utilizzare le funzionalità degli archi durante il passaggio dei messaggi. Se impostato su `true`, viene aggiunto un modulo di funzionalità degli archi personalizzato al livello RGCN per i tipi di archi che dispongono di funzionalità. *Tipo*: `bool`. + **`use-self-loop`**: indica se includere i cappi nell'addestramento di un modello `rgcn`. *Tipo*: `bool`. + **`window-for-early-stop`**: controlla il numero degli ultimi punteggi di convalida in base a cui calcolare la media per decidere se effettuare un arresto anticipato. Il valore predefinito è 3. type=int. Consulta anche [Arresto anticipato del processo di addestramento dei modelli in Neptune ML](machine-learning-improve-model-performance.md#machine-learning-model-training-early-stop). *Tipo*: `int`. *Default*: `3` Per informazioni, consulta . ## Personalizzazione degli iperparametri in Neptune ML Quando si modifica il file `model-HPO-configuration.json`, i tipi di modifiche più comuni sono i seguenti: + Modifica i valori and/or massimi minimi degli `range` iperparametri. + Impostare un iperparametro su un valore fisso spostandolo nella sezione `fixed-param` e impostando il relativo valore predefinito sul valore fisso che dovrà assumere. + Modificare la priorità di un iperparametro posizionandolo in un livello specifico, modificandone l'intervallo e assicurandosi che il valore predefinito sia impostato in modo appropriato. # Best practice per l'addestramento dei modelli Esistono diverse operazioni consigliate per migliorare le prestazioni dei modelli Neptune ML. ## Scelta della proprietà del nodo corretta Non tutte le proprietà del grafo sono significative o pertinenti per le attività di machine learning. Tutte le proprietà non pertinenti devono essere escluse durante l'esportazione dei dati. Ecco alcune best practice: + Rivolgiti a esperti del settore per valutare l'importanza delle funzionalità e la fattibilità del relativo utilizzo per le previsioni. + Rimuovi le funzionalità che ritieni ridondanti o irrilevanti per ridurre il rumore nei dati e le correlazioni non importanti. + Esegui iterazioni mentre costruisci il tuo modello. Modifica le funzionalità, le combinazioni di funzionalità e gli obiettivi di ottimizzazione man mano che procedi. La sezione relativa all'[elaborazione delle funzionalità](https://docs.aws.amazon.com/machine-learning/latest/dg/feature-processing.html) in Amazon Machine Learning Developer Guide fornisce linee guida aggiuntive per l'elaborazione delle funzionalità pertinenti per Neptune ML. ## Gestione degli outlier nei punti dati Un outlier è un punto dati che è significativamente diverso dai dati rimanenti. Gli outlier nei dati possono compromettere o fuorviare il processo di addestramento causando tempi di addestramento più lunghi o modelli meno accurati. A meno che non siano veramente importanti, è consigliabile eliminare gli outlier prima di esportare i dati. ## Rimozione di nodi e archi duplicati Nei grafi archiviati in Neptune possono essere presenti nodi o archi duplicati. Questi elementi ridondanti introdurranno rumore nell'addestramento dei modelli di machine learning. Elimina i nodi o gli archi duplicati prima di esportare i dati. ## Ottimizzazione della struttura del grafo Quando il grafo viene esportato, è possibile modificare la modalità di elaborazione delle funzionalità e la modalità di creazione del grafo, per migliorare le prestazioni del modello. Ecco alcune best practice: + Quando una proprietà dell'arco ha lo stesso significato di categorie di archi, in alcuni casi vale la pena trasformarla in tipi di archi. + La policy di normalizzazione predefinita utilizzata per una proprietà numerica è `min-max`, ma in alcuni casi altre policy di normalizzazione garantiscono un risultato migliore. È possibile pre-elaborare la proprietà e modificare la policy di normalizzazione come spiegato in [Elementi di un file `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements). + Il processo di esportazione genera automaticamente i tipi di funzionalità in base ai tipi delle proprietà. Ad esempio, tratta le proprietà `String` come funzionalità categoriali e le proprietà `Float` e `Int` come funzionalità numeriche. Se necessario, è possibile modificare il tipo di funzionalità dopo l'esportazione (consulta [Elementi di un file `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements)). ## Ottimizzazione degli intervalli e dei valori predefiniti degli iperparametri L'operazione di elaborazione dei dati deduce gli intervalli di configurazione degli iperparametri dal grafo. Se gli intervalli di iperparametri e i valori predefiniti del modello generati non sono adatti ai dati del grafo, puoi modificare il file di configurazione dell'ottimizzazione degli iperparametri per creare una strategia di ottimizzazione degli iperparametri personalizzata. Ecco alcune best practice: + Quando il grafo diventa grande, le dimensioni predefinite della dimensione nascosta potrebbero non essere sufficienti per contenere tutte le informazioni. Puoi modificare l'iperparametro `num-hidden` per controllare le dimensioni della dimensione nascosta. + Per i modelli di incorporamento del grafo della conoscenza, potrebbe essere necessario modificare il modello specifico usato in base alla struttura del grafo e al budget. `TrainsE`i modelli hanno difficoltà a gestire le relazioni one-to-many (1-N), many-to-one (N-1) e many-to-many (N-N). `DistMult`i modelli hanno difficoltà a gestire le relazioni simmetriche. `RotatE`è bravo a modellare tutti i tipi di relazioni ma è più costoso rispetto `TrainsE` e `DistMult` durante la formazione. + In alcuni casi, quando sono importanti sia l'identificazione dei nodi che le informazioni sulle funzionalità del nodo, è necessario usare ``concat-node-embed`` per indicare al modello Neptune ML di recuperare la rappresentazione iniziale di un nodo concatenando le sue funzionalità con gli incorporamenti iniziali. + Quando si ottengono prestazioni ragionevolmente buone su alcuni iperparametri, è possibile regolare lo spazio di ricerca degli iperparametri in base a tali risultati. ## Arresto anticipato del processo di addestramento dei modelli in Neptune ML L'arresto anticipato può ridurre in modo significativo il tempo di esecuzione dell'addestramento del modello e i costi associati senza compromettere le prestazioni del modello. Inoltre, impedisce l'overfitting del modello sui dati di addestramento. L'arresto anticipato dipende dalle misurazioni regolari delle prestazioni del set di convalida. Inizialmente, le prestazioni migliorano con il procedere dell'addestramento, ma quando si verifica l'overfitting, peggiora nuovamente. La funzionalità di arresto anticipato identifica il punto di overfitting del modello e arresta l'addestramento del modello in quel momento. Neptune ML monitora le chiamate alle metriche di convalida e confronta la metrica di convalida più recente con la media delle metriche di convalida delle ultime **`n`** valutazioni, dove **`n`** è un numero impostato utilizzando il parametro `window-for-early-stop`. Non appena la metrica di convalida è peggiore di quella media, Neptune ML arresta l'addestramento del modello e salva il miglior modello generato fino a quel momento. Puoi controllare l'arresto anticipato utilizzando i seguenti parametri: + **`window-for-early-stop`**: il valore di questo parametro è un numero intero che specifica il numero di punteggi di convalida recenti in base a cui calcolare la media per decidere se effettuare un arresto anticipato. Il valore predefinito è `3`. + **`enable-early-stop`**: usa questo parametro booleano per disattivare la funzionalità di arresto anticipato. Per impostazione predefinita, il suo valore è `true`. ## Arresto anticipato del processo di ottimizzazione degli iperparametri in Neptune ML La funzione di interruzione anticipata di Neptune ML interrompe anche i lavori di formazione che non funzionano bene rispetto ad altri lavori di formazione, utilizzando SageMaker la funzione di avvio a caldo AI HPO. Anche questa operazione consente di ridurre i costi e migliorare la qualità dell'ottimizzazione degli iperparametri. Per una descrizione del funzionamento, consulta [Esecuzione di un processo di ottimizzazione degli iperparametri con avvio a caldo](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html). L'avvio a caldo permette di trasferire le informazioni apprese dai processi di addestramento precedenti ai processi di addestramento successivi e offre due vantaggi distinti: + Innanzitutto, i risultati dei processi di ottimizzazione precedenti vengono utilizzati per indicare le combinazioni di iperparametri valide da cercare nel nuovo processo di ottimizzazione. + In secondo luogo, consente l'arresto anticipato per accedere a più esecuzioni del modello, riducendo così i tempi di ottimizzazione. Questa funzionalità è abilitata automaticamente in Neptune ML e consente di trovare un equilibrio tra il tempo di addestramento del modello e le prestazioni. Se sei soddisfatto delle prestazioni del modello corrente, puoi utilizzare tale modello. Altrimenti, se ne eseguono di più, HPOs avviate a caldo con i risultati delle esecuzioni precedenti, in modo da scoprire un modello migliore. ## Servizi di supporto professionali AWS offre servizi di supporto professionale per aiutarti a risolvere i problemi relativi all'apprendimento automatico sui progetti Neptune. Se rimani bloccato, contatta il [Supporto AWS](https://aws.amazon.com/premiumsupport/).