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

# Modelli di classificazione della formazione
<a name="training-classifier-model"></a>

Per addestrare un modello per la classificazione personalizzata, è necessario definire le categorie e fornire documenti di esempio per addestrare il modello personalizzato. Il modello viene addestrato in modalità multiclasse o multi-etichetta. La modalità multiclasse associa una singola classe a ciascun documento. La modalità multi-etichetta associa una o più classi a ciascun documento.

La classificazione personalizzata supporta due tipi di modelli di classificazione: modelli di testo semplice e modelli di documenti nativi. Un modello di testo semplice classifica i documenti in base al loro contenuto testuale. Un modello di documento nativo classifica anche i documenti in base al contenuto del testo. Un modello di documento nativo può anche utilizzare segnali aggiuntivi, ad esempio dal layout del documento. Si addestra un modello di documento nativo con documenti nativi affinché il modello apprenda le informazioni sul layout. 

I modelli in testo semplice hanno le seguenti caratteristiche: 
+ Il modello viene addestrato utilizzando documenti di testo con codifica UTF-8. 
+ È possibile addestrare il modello utilizzando documenti in una delle seguenti lingue: inglese, spagnolo, tedesco, italiano, francese o portoghese. 
+ I documenti di formazione per un determinato classificatore devono utilizzare tutti la stessa lingua. 
+ I documenti di formazione sono in testo semplice, quindi non ci sono costi aggiuntivi per l'estrazione del testo. 

I modelli di documenti nativi hanno le seguenti caratteristiche: 
+ Il modello viene addestrato utilizzando documenti semistrutturati, che includono i seguenti tipi di documenti:
  + Documenti PDF digitali e scansionati.
  + Documenti Word (DOCX).
  + Immagini: file JPG, file PNG e file TIFF a pagina singola.
  + L'API Textract genera file JSON.
+ Il modello viene addestrato utilizzando documenti in inglese. 
+ Se i documenti di formazione includono file di documenti scansionati, dovrai sostenere costi aggiuntivi per l'estrazione del testo. Per ulteriori informazioni, consulta la pagina [dei prezzi di Amazon Comprehend](https://aws.amazon.com/comprehend/pricing). 

Puoi classificare qualsiasi tipo di documento supportato utilizzando entrambi i tipi di modello. Tuttavia, per risultati più accurati, consigliamo di utilizzare un modello di testo semplice per classificare i documenti in testo semplice e un modello di documento nativo per classificare i documenti semistrutturati.

**Topics**
+ [Addestra classificatori personalizzati (console)](create-custom-classifier-console.md)
+ [Addestra classificatori personalizzati (API)](train-custom-classifier-api.md)
+ [Verifica i dati di allenamento](testing-the-model.md)
+ [Risultati formativi di Classifier](train-classifier-output.md)
+ [Metriche di classificazione personalizzate](cer-doc-class.md)

# Addestra classificatori personalizzati (console)
<a name="create-custom-classifier-console"></a>

È possibile creare e addestrare un classificatore personalizzato utilizzando la console e quindi utilizzare il classificatore personalizzato per analizzare i documenti.

Per addestrare un classificatore personalizzato, è necessario un set di documenti di formazione. Etichettate questi documenti con le categorie che desiderate che il classificatore di documenti riconosca. Per informazioni sulla preparazione dei documenti di formazione, consulta[Preparazione dei dati di addestramento del classificatore](prep-classifier-data.md).



**Per creare e addestrare un modello di classificazione dei documenti**

1. Accedi Console di gestione AWS e apri la console Amazon Comprehend all'indirizzo [https://console.aws.amazon.com/comprehend/](https://console.aws.amazon.com/comprehend/)

1. Dal menu a sinistra, scegli **Personalizzazione**, quindi scegli Classificazione **personalizzata**.

1. Scegli **Crea nuovo modello**.

1. In **Impostazioni modello**, inserisci un nome di modello per il classificatore. Il nome deve essere univoco all'interno del tuo account e della regione corrente.

   (Facoltativo) Inserisci il nome della versione. Il nome deve essere univoco all'interno del tuo account e della regione corrente.

1. Seleziona la lingua dei documenti di formazione. Per vedere le lingue supportate dai classificatori, vedi. [Modelli di classificazione della formazione](training-classifier-model.md) 

1. (Facoltativo) Se desideri crittografare i dati nel volume di storage mentre Amazon Comprehend elabora il tuo processo di formazione, **scegli** la crittografia Classifier. Quindi scegli se utilizzare una chiave KMS associata al tuo account corrente o una di un altro account.
   + Se utilizzi una chiave associata all'account corrente, scegli l'ID della chiave per l'ID della **chiave KMS**.
   + Se utilizzi una chiave associata a un altro account, inserisci l'ARN per l'ID della chiave in ARN della **chiave KMS**.
**Nota**  
[Per ulteriori informazioni sulla creazione e l'utilizzo delle chiavi KMS e sulla crittografia associata, vedi ().AWS Key Management ServiceAWS KMS](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html)

1. In **Specifiche dei dati**, scegli il **tipo di modello di addestramento** da utilizzare.
   + **Documenti di testo semplice:** scegliete questa opzione per creare un modello di testo semplice. Addestra il modello utilizzando documenti di testo semplice.
   + **Documenti nativi:** scegliete questa opzione per creare un modello di documento nativo. Addestra il modello utilizzando documenti nativi (PDF, Word, immagini). 

1. Scegli il **formato** dei dati di allenamento. Per informazioni sui formati dei dati, vedere[Formati di file di formazione Classifier](prep-class-data-format.md).
   + **File CSV:** scegliete questa opzione se i dati di allenamento utilizzano il formato di file CSV.
   + **Manifesto aumentato:** scegli questa opzione se hai utilizzato Ground Truth per creare file manifest aumentati per i tuoi dati di allenamento. Questo formato è disponibile se avete scelto **Documenti in testo semplice come tipo** di modello di allenamento.

1. Scegliete la **modalità Classifier** da usare.
   + **Modalità etichetta singola:** scegli questa modalità se le categorie che stai assegnando ai documenti si escludono a vicenda e stai addestrando il tuo classificatore ad assegnare un'etichetta a ciascun documento. Nell'API Amazon Comprehend, la modalità a etichetta singola è nota come modalità multiclasse.
   + **Modalità multi-etichetta:** scegli questa modalità se è possibile applicare più categorie a un documento contemporaneamente e stai addestrando il classificatore ad assegnare una o più etichette a ciascun documento. 

1. **Se scegli la **modalità Multi-etichetta**, puoi selezionare il Delimitatore per le etichette.** Utilizzate questo carattere delimitatore per separare le etichette quando vi sono più classi per un documento di formazione. Il delimitatore predefinito è il carattere pipe.

1. (Facoltativo) Se avete scelto **Augmented manifest** come formato di dati, potete inserire fino a cinque file manifest aumentati. Ogni file manifesto aumentato contiene un set di dati di addestramento o un set di dati di test. È necessario fornire almeno un set di dati di addestramento. I set di dati di test sono facoltativi. Utilizzate i seguenti passaggi per configurare i file manifest aumentati:

   1. In **Training and test dataset**, espandi il pannello **Input location**.

   1. In **Tipo di set di** dati, scegli Dati di **addestramento o Dati** di **test**.

   1. **Per la **posizione S3 del file manifesto aumentato SageMaker AI Ground Truth**, inserisci la posizione del bucket Amazon S3 che contiene il file manifest o accedi ad esso scegliendo Browse S3.** Il ruolo IAM che stai utilizzando per le autorizzazioni di accesso per il processo di formazione deve avere autorizzazioni di lettura per il bucket S3. 

   1. Per i **nomi degli attributi**, inserisci il nome dell'attributo che contiene le tue annotazioni. Se il file contiene annotazioni provenienti da più lavori di etichettatura concatenati, aggiungi un attributo per ogni lavoro.

   1. Per aggiungere un'altra posizione di input, scegliete **Aggiungi posizione di input** e quindi configurate la posizione successiva.

1. (Facoltativo) Se hai scelto il **file CSV** come formato di dati, utilizza i seguenti passaggi per configurare il set di dati di addestramento e il set di dati di test opzionale:

   1. **In **Training dataset**, inserisci la posizione del bucket Amazon S3 che contiene il file CSV dei dati di allenamento o accedi al file selezionando Browse S3.** Il ruolo IAM che stai utilizzando per le autorizzazioni di accesso al processo di formazione deve disporre delle autorizzazioni di lettura per il bucket S3. 

      (Facoltativo) Se hai scelto **Documenti nativi** come tipo di modello di formazione, fornisci anche l'URL della cartella Amazon S3 che contiene i file di esempio di formazione.

   1. In **Set di dati di test**, seleziona se stai fornendo dati aggiuntivi ad Amazon Comprehend per testare il modello addestrato.
      + **Autosplit**: Autosplit seleziona automaticamente il 10% dei dati di allenamento da riservare per l'uso come dati di test.
      + (Facoltativo) **Fornito dal cliente**: inserisci l'URL del file CSV dei dati di test in Amazon S3. Puoi anche accedere alla sua posizione in Amazon S3 e scegliere **Seleziona** cartella.

        (Facoltativo) Se scegli **Documenti nativi** come tipo di modello di formazione, fornisci anche l'URL della cartella Amazon S3 che contiene i file di test.

1. (Facoltativo) Per la **modalità di lettura dei documenti**, puoi sovrascrivere le azioni di estrazione del testo predefinite. Questa opzione non è richiesta per i modelli con testo semplice, poiché si applica all'estrazione del testo per i documenti scansionati. Per ulteriori informazioni, consulta [Impostazione delle opzioni di estrazione del testo](idp-set-textract-options.md). 

1. (Facoltativo per i modelli in testo semplice) Per **i dati di output**, inserisci la posizione di un bucket Amazon S3 per salvare i dati di output dell'allenamento, come la matrice di confusione. Per ulteriori informazioni, consulta [Matrice di confusione](train-classifier-output.md#conf-matrix).

   **(Facoltativo) Se scegli di crittografare il risultato dell'output del tuo processo di formazione, scegli Crittografia.** Quindi scegli se utilizzare una chiave KMS associata all'account corrente o una di un altro account.
   + Se utilizzi una chiave associata all'account corrente, scegli l'alias della chiave per l'ID della chiave **KMS**.
   + Se utilizzi una chiave associata a un altro account, inserisci l'ARN per l'alias o l'ID della chiave in **KMS** key ID.

1. Per il **ruolo IAM**, scegli **Scegli un ruolo IAM esistente**, quindi scegli un ruolo IAM esistente con autorizzazioni di lettura per il bucket S3 che contiene i tuoi documenti di formazione. Il ruolo deve avere una politica di fiducia che inizi con `comprehend.amazonaws.com` per essere valido.

   Se non disponi già di un ruolo IAM con queste autorizzazioni, scegli **Crea un ruolo IAM** per crearne uno. Scegli le autorizzazioni di accesso per concedere questo ruolo, quindi scegli un suffisso di nome per distinguere il ruolo dai ruoli IAM nel tuo account.
**Nota**  
Per i documenti di input crittografati, anche il ruolo IAM utilizzato deve disporre dell'autorizzazione. `kms:Decrypt` Per ulteriori informazioni, consulta [Autorizzazioni necessarie per utilizzare la crittografia KMS](security_iam_id-based-policy-examples.md#auth-kms-permissions).

1. (Facoltativo) Per avviare le tue risorse in Amazon Comprehend da un VPC, inserisci l'ID VPC in **VPC** o scegli l'ID dall'elenco a discesa. 

   1. **Scegli la sottorete in Sottoreti.** Dopo aver selezionato la prima sottorete, è possibile sceglierne altre.

   1. In **Gruppi di sicurezza**, scegli il gruppo di sicurezza da utilizzare, se ne hai specificato uno. Dopo aver selezionato il primo gruppo di sicurezza, puoi sceglierne altri.
**Nota**  
Quando utilizzi un VPC con il tuo lavoro di classificazione, quello `DataAccessRole` utilizzato per le operazioni di creazione e avvio deve disporre delle autorizzazioni per il VPC che accede ai documenti di input e al bucket di output.

1. **(Facoltativo) Per aggiungere un tag al classificatore personalizzato, inserite una coppia chiave-valore in Tag.** Seleziona **Aggiungi tag**. **Per rimuovere questa coppia prima di creare il classificatore, scegliete Rimuovi tag.** Per ulteriori informazioni, consulta [Tagging delle risorse](tagging.md).

1. Scegli **Create** (Crea).

La console visualizza la pagina **Classificatori**. Il nuovo classificatore viene visualizzato nella tabella e ne viene visualizzato lo `Submitted` stato. Quando il classificatore inizia a elaborare i documenti di formazione, lo stato cambia in. `Training` Quando un classificatore è pronto per l'uso, lo stato diventa o. `Trained` `Trained with warnings` Se lo stato è`TRAINED_WITH_WARNINGS`, esamina la cartella dei file ignorati in. [Risultati formativi di Classifier](train-classifier-output.md)

Se Amazon Comprehend ha riscontrato errori durante la creazione o la formazione, lo stato cambia in. `In error` Puoi scegliere un lavoro di classificatore nella tabella per ottenere maggiori informazioni sul classificatore, inclusi eventuali messaggi di errore.

![\[L'elenco dei classificatori personalizzati.\]](http://docs.aws.amazon.com/it_it/comprehend/latest/dg/images/class-list.png)


# Addestra classificatori personalizzati (API)
<a name="train-custom-classifier-api"></a>

Per creare e addestrare un classificatore personalizzato, utilizzate l'[CreateDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_CreateDocumentClassifier.html)operazione.

È possibile monitorare l'avanzamento della richiesta utilizzando l'[DescribeDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeDocumentClassifier.html)operazione. Dopo la transizione del `Status` campo a`TRAINED`, è possibile utilizzare il classificatore per classificare i documenti. Se lo stato è`TRAINED_WITH_WARNINGS`, esaminate la cartella dei file ignorati contenuta nel modulo dell'[Risultati formativi di Classifier](train-classifier-output.md)operazione. `CreateDocumentClassifier`

**Topics**
+ [Addestramento: classificazione personalizzata utilizzando il AWS Command Line Interface](#get-started-api-customclass-cli)
+ [Usare AWS SDK per Java o SDK per Python](#get-started-api-customclass-java)

## Addestramento: classificazione personalizzata utilizzando il AWS Command Line Interface
<a name="get-started-api-customclass-cli"></a>

Negli esempi seguenti viene illustrato come utilizzare l'`CreateDocumentClassifier`operazione, l'`DescribeDocumentClassificationJob`operazione e altri classificatori personalizzati APIs con. AWS CLI

Gli esempi sono formattati per Unix, Linux e macOS. Per Windows, sostituisci il carattere di continuazione UNIX barra rovesciata (\$1) al termine di ogni riga con un accento circonflesso (^).

Crea un classificatore personalizzato in testo semplice utilizzando l'operazione. `create-document-classifier`

```
aws comprehend create-document-classifier \
     --region region \
     --document-classifier-name testDelete \
     --language-code en \
     --input-data-config S3Uri=s3://S3Bucket/docclass/file name \
     --data-access-role-arn arn:aws:iam::account number:role/testFlywheelDataAccess
```

Per creare un classificatore personalizzato nativo, fornite i seguenti parametri aggiuntivi nella richiesta. `create-document-classifier`

1. DocumentType: impostate il valore su SEMI\$1STRUCTURED\$1DOCUMENT.

1. Documenti: la posizione S3 per i documenti di formazione (e, facoltativamente, i documenti dei test).

1. OutputDataConfig: fornisce la posizione S3 per i documenti di output (e una chiave KMS opzionale). 

1. DocumentReaderConfig: Campo opzionale per le impostazioni di estrazione del testo.

```
aws comprehend create-document-classifier \
     --region region \
     --document-classifier-name testDelete \
     --language-code en \
     --input-data-config 
          S3Uri=s3://S3Bucket/docclass/file name \
           DocumentType \
             Documents  \
     --output-data-config S3Uri=s3://S3Bucket/docclass/file name \
     --data-access-role-arn arn:aws:iam::account number:role/testFlywheelDataAccess
```

Ottieni informazioni su un classificatore personalizzato con il classificatore di documenti ARN utilizzando l'operazione. `DescribeDocumentClassifier`

```
aws comprehend describe-document-classifier \
     --region region \
     --document-classifier-arn arn:aws:comprehend:region:account number:document-classifier/file name
```

Eliminare un classificatore personalizzato utilizzando l'operazione. `DeleteDocumentClassifier`

```
aws comprehend delete-document-classifier \
     --region region \
     --document-classifier-arn arn:aws:comprehend:region:account number:document-classifier/testDelete
```

Elenca tutti i classificatori personalizzati presenti nell'account utilizzando l'operazione. `ListDocumentClassifiers`

```
aws comprehend list-document-classifiers
     --region region
```

## Usare AWS SDK per Java o SDK per Python
<a name="get-started-api-customclass-java"></a>

Per esempi SDK su come creare e addestrare un classificatore personalizzato, consulta. [Utilizzo `CreateDocumentClassifier` con un AWS SDK o una CLI](example_comprehend_CreateDocumentClassifier_section.md)

# Verifica i dati di allenamento
<a name="testing-the-model"></a>

Dopo aver addestrato il modello, Amazon Comprehend verifica il modello di classificatore personalizzato. Se non fornisci un set di dati di test, Amazon Comprehend addestra il modello con il 90% dei dati di addestramento. Riserva il 10 percento dei dati di addestramento da utilizzare per i test. Se fornite un set di dati di test, i dati del test devono includere almeno un esempio per ogni etichetta univoca nel set di dati di addestramento. 

Il test del modello fornisce metriche che è possibile utilizzare per stimare l'accuratezza del modello. La console visualizza le metriche nella sezione delle **prestazioni del classificatore** della pagina dei **dettagli del classificatore** nella console. Vengono inoltre restituite nei `Metrics` campi restituiti dall'operazione. [DescribeDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeDocumentClassifier.html)

Nel seguente esempio di dati di formazione, ci sono cinque etichette: DOCUMENTARY, DOCUMENTARY, SCIENCE\$1FICTION, DOCUMENTARY, ROMANTIC\$1COMEDY. Esistono tre classi uniche: DOCUMENTARY, SCIENCE\$1FICTION, ROMANTIC\$1COMMEDIA. 


| Colonna 1 | Colonna 2 | 
| --- | --- | 
| DOCUMENTARIO | testo del documento 1 | 
| DOCUMENTARIO | testo del documento 2 | 
| FANTASCIENZA | testo del documento 3 | 
| DOCUMENTARIO | testo del documento 4 | 
| COMMEDIA ROMANTICA | testo del documento 5 | 

Per la suddivisione automatica (in cui Amazon Comprehend riserva il 10% dei dati di addestramento da utilizzare per i test), se i dati di addestramento contengono esempi limitati di un'etichetta specifica, il set di dati di test può contenere zero esempi di tale etichetta. Ad esempio, se il set di dati di addestramento contiene 1000 istanze della classe DOCUMENTARY, 900 istanze di SCIENCE\$1FICTION e una singola istanza della classe ROMANTIC\$1COMEDY, il set di dati di test potrebbe contenere 100 istanze DOCUMENTARY e 90 istanze SCIENCE\$1FICTION, ma nessuna istanza ROMANTIC\$1COMEDY, poiché è disponibile un solo esempio. 

Dopo aver completato l'addestramento del modello, le metriche di addestramento forniscono informazioni che è possibile utilizzare per decidere se il modello è sufficientemente preciso per le proprie esigenze. 

# Risultati formativi di Classifier
<a name="train-classifier-output"></a>

Dopo aver completato la formazione sul modello di classificatore personalizzato, Amazon Comprehend crea file di output nella posizione di output di Amazon S3 specificata nella richiesta [CreateDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_CreateDocumentClassifier.html)API o nella richiesta di console equivalente.

Amazon Comprehend crea una matrice di confusione quando si addestra un modello di testo semplice o un modello di documento nativo. Può creare file di output aggiuntivi quando si addestra un modello di documento nativo.

**Topics**
+ [Matrice di confusione](#conf-matrix)
+ [Output aggiuntivi per modelli di documenti nativi](#train-class-output-native)

## Matrice di confusione
<a name="conf-matrix"></a>

Quando si addestra un modello di classificatore personalizzato, Amazon Comprehend crea una matrice di confusione che fornisce metriche sulle prestazioni del modello durante la formazione. Questa matrice mostra una matrice di etichette prevista dal modello rispetto alle etichette effettive dei documenti. Amazon Comprehend utilizza una parte dei dati di addestramento per creare la matrice di confusione.

Una matrice di confusione fornisce un'indicazione di quali classi potrebbero utilizzare più dati per migliorare le prestazioni del modello. Una classe con un'alta percentuale di previsioni corrette ha il maggior numero di risultati lungo la diagonale della matrice. Se il numero sulla diagonale è un numero inferiore, la classe ha una frazione inferiore di previsioni corrette. Puoi aggiungere altri esempi di formazione per questa classe e addestrare nuovamente il modello. Ad esempio, se il 40 percento dei campioni dell'etichetta A viene classificato come etichetta D, l'aggiunta di altri campioni per l'etichetta A e l'etichetta D migliora le prestazioni del classificatore.

Dopo che Amazon Comprehend ha creato il modello di classificazione, la matrice di confusione è disponibile nel `confusion_matrix.json` file nella posizione di output di S3. 

Il formato della matrice di confusione varia a seconda che il classificatore sia stato addestrato utilizzando la modalità multiclasse o la modalità multi-etichetta.

**Topics**
+ [Matrice di confusione per la modalità multiclasse](#m-c-matrix)
+ [Matrice di confusione per la modalità multietichetta](#m-l-matrix)

### Matrice di confusione per la modalità multiclasse
<a name="m-c-matrix"></a>

In modalità multiclasse, le singole classi si escludono a vicenda, pertanto la classificazione assegna un'etichetta a ciascun documento. Ad esempio, un animale può essere un cane o un gatto, ma non entrambi allo stesso tempo.

Considera il seguente esempio di matrice di confusione per un classificatore addestrato multiclasse:

```
  A B X Y <-(predicted label)
A 1 2 0 4
B 0 3 0 1
X 0 0 1 0
Y 1 1 1 1
^
|
(actual label)
```

In questo caso, il modello prevedeva quanto segue:
+ Un'etichetta «A» è stata prevista con precisione, due etichette «A» sono state erroneamente previste come etichette «B» e quattro etichette «A» sono state previste erroneamente come etichette «Y».
+ Tre etichette «B» sono state previste con precisione e un'etichetta «B» è stata erroneamente prevista come etichetta «Y».
+ Una «X» è stata prevista con precisione.
+ Un'etichetta «Y» è stata prevista con precisione, una è stata prevista erroneamente come etichetta «A», una è stata prevista erroneamente come etichetta «B» e un'altra è stata prevista erroneamente come etichetta «X».

La linea diagonale nella matrice (A:A, B:B, X:X e Y:Y) mostra le previsioni accurate. Gli errori di previsione sono i valori esterni alla diagonale. In questo caso, la matrice mostra i seguenti tassi di errore di previsione: 
+ Etichette A: 86%
+ Etichette B: 25%
+ Etichette X: 0%
+ Etichette Y: 75%

Il classificatore restituisce la matrice di confusione come file in formato JSON. Il seguente file JSON rappresenta la matrice dell'esempio precedente.

```
{
 "type": "multi_class",
 "confusion_matrix": [
 [1, 2, 0,4],
 [0, 3, 0, 1],
 [0, 0, 1, 0],
 [1, 1, 1, 1]],
 "labels": ["A", "B", "X", "Y"],
 "all_labels": ["A", "B", "X", "Y"]
}
```

### Matrice di confusione per la modalità multietichetta
<a name="m-l-matrix"></a>

In modalità multietichetta, la classificazione può assegnare una o più classi a un documento. Considerate il seguente esempio di matrice di confusione per un classificatore addestrato a più classi.

In questo esempio, ci sono tre etichette possibili: `Comedy``Action`, e. `Drama` La matrice di confusione multietichetta crea una matrice 2x2 per ogni etichetta.

```
Comedy                   Action                   Drama 
     No Yes                   No Yes                   No Yes   <-(predicted label)                                      
 No  2   1                No  1   1                No  3   0                                                         
Yes  0   2               Yes  2   1               Yes  1   1   
 ^                        ^                        ^
 |                        |                        |
 |-----------(was this label actually used)--------|
```

In questo caso, il modello ha restituito quanto segue per l'etichetta: `Comedy`
+ Due casi in cui è stata prevista con precisione la presenza di `Comedy` un'etichetta. Vero positivo (TP). 
+ Due casi in cui è stata prevista con precisione l'assenza di `Comedy` un'etichetta. Vero negativo (TN).
+ Zero casi in cui era stata erroneamente prevista la presenza di `Comedy` un'etichetta. Falso positivo (FP).
+ Un caso in cui era stata erroneamente prevista l'assenza di un'`Comedy`etichetta. Falso negativo (FN).

Come in una matrice di confusione multiclasse, la linea diagonale di ogni matrice mostra le previsioni accurate.

In questo caso, il modello ha previsto con precisione `Comedy` le etichette l'80% delle volte (TP più TN) e le ha previste erroneamente il 20% delle volte (FP più FN).



Il classificatore restituisce la matrice di confusione come file in formato JSON. Il seguente file JSON rappresenta la matrice dell'esempio precedente.

```
{
"type": "multi_label",
"confusion_matrix": [
 [[2, 1],        
 [0, 2]],
 [[1, 1],        
 [2, 1]],      
 [[3, 0],        
 [1, 1]]
], 
"labels": ["Comedy", "Action", "Drama"]
"all_labels": ["Comedy", "Action", "Drama"]
}
```

## Output aggiuntivi per modelli di documenti nativi
<a name="train-class-output-native"></a>

Amazon Comprehend può creare file di output aggiuntivi durante l'addestramento di un modello di documento nativo.

### Output di Amazon Textract
<a name="textract-output"></a>

Se Amazon Comprehend ha richiamato Amazon Textract per estrarre il testo APIs da uno qualsiasi dei documenti di formazione, salva i file di output di Amazon Textract nella posizione di output di S3. Utilizza la seguente struttura di directory:
+ **Documenti di formazione:** 

  `amazon-textract-output/train/<file_name>/<page_num>/textract_output.json` 
+ **Documenti di prova:** 

  `amazon-textract-output/test/<file_name>/<page_num>/textract_output.json`

Amazon Comprehend compila la cartella di test se hai fornito documenti di test nella richiesta API.

### Errori di annotazione dei documenti
<a name="failed-files-output"></a>

 **Amazon Comprehend crea i seguenti file nella posizione di output di Amazon S3 (nella cartella skipped\$1documents/) in caso di annotazioni non riuscite:**
+ failed\$1annotations\$1train.jsonl

  Il file esiste se qualche annotazione non è riuscita nei dati di addestramento.
+ failed\$1annotations\$1test.jsonl

  Il file esiste se la richiesta includeva dati di test e qualsiasi annotazione non è riuscita nei dati di test.

I file di annotazione non riusciti sono file JSONL con il seguente formato:

```
{
     "File": "String", "Page": Number, "ErrorCode": "...", "ErrorMessage": "..."}
    {"File": "String", "Page": Number, "ErrorCode": "...", "ErrorMessage": "..."
  }
```

# Metriche di classificazione personalizzate
<a name="cer-doc-class"></a>

Amazon Comprehend fornisce metriche per aiutarti a stimare le prestazioni di un classificatore personalizzato. Amazon Comprehend calcola le metriche utilizzando i dati di test del processo di formazione del classificatore. Le metriche rappresentano accuratamente le prestazioni del modello durante l'allenamento, quindi approssimano le prestazioni del modello per la classificazione di dati simili. 

Utilizza operazioni API, ad esempio [DescribeDocumentClassifier](https://docs.aws.amazon.com/comprehend/latest/APIReference/API_DescribeDocumentClassifier.html)per recuperare le metriche per un classificatore personalizzato.

**Nota**  
Fai riferimento a [Metrics: Precision, recall e FScore](https://scikit-learn.org/stable/modules/generated/sklearn.metrics.precision_recall_fscore_support.html) per una comprensione delle metriche sottostanti del punteggio Precision, Recall e F1. Queste metriche sono definite a livello di classe. Amazon Comprehend utilizza la media delle **macro** per combinare questi parametri nel set di test P, R e F1, come illustrato di seguito.

**Topics**
+ [Metriche](#cer-doc-class-metrics)
+ [Miglioramento delle prestazioni del classificatore personalizzato](#improving-metrics-doc)

## Metriche
<a name="cer-doc-class-metrics"></a>

Amazon Comprehend supporta le seguenti metriche: 

**Topics**
+ [Accuratezza](#class-accuracy-metric)
+ [Precisione (precisione macro)](#class-macroprecision-metric)
+ [Richiamo (richiamo di macro)](#class-macrorecall-metric)
+ [Punteggio F1 (punteggio macro F1)](#class-macrof1score-metric)
+ [Perdita di Hamming](#class-hammingloss-metric)
+ [Micro precisione](#class-microprecision-metric)
+ [Micro richiamo](#class-microrecall-metric)
+ [Punteggio Micro F1](#class-microf1score-metric)

Per visualizzare le metriche di un classificatore, apri la pagina dei **dettagli del classificatore** nella console.

![\[Metriche personalizzate del classificatore\]](http://docs.aws.amazon.com/it_it/comprehend/latest/dg/images/classifierperformance.png)


### Accuratezza
<a name="class-accuracy-metric"></a>

La precisione indica la percentuale di etichette dei dati di test che il modello ha previsto con precisione. Per calcolare l'accuratezza, dividi il numero di etichette previste con precisione nei documenti di test per il numero totale di etichette nei documenti di test.

Ad esempio


| Etichetta effettiva | Etichetta prevista | Preciso/errato | 
| --- | --- | --- | 
|  1  |  1  |  Preciso  | 
|  0  |  1  |  Errato  | 
|  2  |  3  |  Errato  | 
|  3  |  3  |  Preciso  | 
|  2  |  2  |  Preciso  | 
|  1  |  1  |  Preciso  | 
|  3  |  3  | Preciso | 

L'accuratezza è costituita dal numero di previsioni accurate diviso per il numero di campioni complessivi dei test = 5/7 = 0,714 o 71,4%

### Precisione (precisione macro)
<a name="class-macroprecision-metric"></a>

La precisione è una misura dell'utilità dei risultati del classificatore nei dati del test. È definito come il numero di documenti classificati accuratamente, diviso per il numero totale di classificazioni per la classe. L'alta precisione significa che il classificatore ha restituito risultati significativamente più pertinenti rispetto a quelli non pertinenti. 

*La `Precision` metrica è anche nota come Macro Precision.* 

L'esempio seguente mostra i risultati di precisione per un set di test.


| Etichetta | Dimensione del campione | Precisione dell'etichetta | 
| --- | --- | --- | 
|  Etichetta\$11  |  400  |  0.75  | 
|  Etichetta\$12  |  300  |  0,80  | 
|  Etichetta\$13  |  30000  |  0.90  | 
|  Etichetta\$14  |  20  |  0.50  | 
|  Etichetta\$15  |  10  |  0,40  | 

La metrica Precision (Macro Precision) per il modello è quindi:

```
Macro Precision = (0.75 + 0.80 + 0.90 + 0.50 + 0.40)/5 = 0.67
```

### Richiamo (richiamo di macro)
<a name="class-macrorecall-metric"></a>

Indica la percentuale di categorie corrette nel testo che il modello è in grado di prevedere. Questa metrica deriva dalla media dei punteggi di richiamo di tutte le etichette disponibili. Il richiamo è una misura della completezza dei risultati del classificatore per i dati del test. 

Un richiamo elevato significa che il classificatore ha restituito la maggior parte dei risultati pertinenti. 

La `Recall` metrica è anche nota come *Macro* Recall.

L'esempio seguente mostra i risultati di richiamo per un set di test.


| Etichetta | Dimensione del campione | Richiamo dell'etichetta | 
| --- | --- | --- | 
|  Etichetta\$11  |  400  |  0,70  | 
|  Etichetta\$12  |  300  |  0,70  | 
|  Etichetta\$13  |  30000  |  0,98  | 
|  Etichetta\$14  |  20  |  0,80  | 
|  Etichetta\$15  |  10  |  0.10  | 

La metrica Recall (Macro Recall) per il modello è quindi:

```
Macro Recall = (0.70 + 0.70 + 0.98 + 0.80 + 0.10)/5 = 0.656
```

### Punteggio F1 (punteggio macro F1)
<a name="class-macrof1score-metric"></a>

Il punteggio F1 è derivato dai valori and. `Precision` `Recall` Misura la precisione complessiva del classificatore. Il punteggio più alto è 1 e il punteggio più basso è 0. 

Amazon Comprehend calcola il punteggio *Macro* F1. È la media non ponderata dei punteggi F1 dell'etichetta. Utilizzando il seguente set di test come esempio:


| Etichetta | Dimensione del campione | Etichetta il punteggio F1 | 
| --- | --- | --- | 
|  Etichetta\$11  |  400  |  0,724  | 
|  Etichetta\$12  |  300  |  0,824  | 
|  Etichetta\$13  |  30000  |  0,94  | 
|  Etichetta\$14  |  20  |  0,62  | 
|  Etichetta\$15  |  10  |  0,16  | 

Il punteggio F1 (Macro F1 Score) per il modello viene calcolato come segue:

```
Macro F1 Score = (0.724 + 0.824 + 0.94 + 0.62 + 0.16)/5 = 0.6536
```

### Perdita di Hamming
<a name="class-hammingloss-metric"></a>

La frazione di etichette prevista in modo errato. Considerata anche come la frazione di etichette errate rispetto al numero totale di etichette. I punteggi più vicini allo zero sono migliori.

### Micro precisione
<a name="class-microprecision-metric"></a>

Originale: 

Simile alla metrica di precisione, tranne per il fatto che la microprecisione si basa sul punteggio complessivo di tutti i punteggi di precisione sommati.

### Micro richiamo
<a name="class-microrecall-metric"></a>

Simile alla metrica di richiamo, tranne per il fatto che il micro richiamo si basa sul punteggio complessivo di tutti i punteggi di richiamo sommati.

### Punteggio Micro F1
<a name="class-microf1score-metric"></a>

Il punteggio Micro F1 è una combinazione delle metriche Micro Precision e Micro Recall.

## Miglioramento delle prestazioni del classificatore personalizzato
<a name="improving-metrics-doc"></a>

Le metriche forniscono una panoramica delle prestazioni del classificatore personalizzato durante un processo di classificazione. Se le metriche sono basse, il modello di classificazione potrebbe non essere efficace per il tuo caso d'uso. Sono disponibili diverse opzioni per migliorare le prestazioni del classificatore:

1. Nei dati di allenamento, fornisci esempi concreti che definiscano una netta separazione delle categorie. Ad esempio, fornite documenti che utilizzano Unique words/sentences per rappresentare la categoria. 

1. Aggiungi altri dati per le etichette sottorappresentate nei dati di allenamento.

1. Cerca di ridurre l'inclinazione nelle categorie. Se l'etichetta più grande dei tuoi dati contiene più di 10 volte i documenti nell'etichetta più piccola, prova ad aumentare il numero di documenti per l'etichetta più piccola. Assicurati di ridurre il rapporto di inclinazione a un massimo di 10:1 tra le classi altamente rappresentate e quelle meno rappresentate. Puoi anche provare a rimuovere i documenti di input dalle classi altamente rappresentate.