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à.
# Algoritmo K-Nearest Neighbors (k-NN)
L'algoritmo k-NN (k-NN) di Amazon SageMaker AI è un algoritmo basato su indici. Utilizza un metodo non parametrico per la classificazione o la regressione. Per la classificazione dei problemi, l'algoritmo esegue la query dei punti *k* più vicini al punto di esempio e restituisce l'etichetta più utilizzata della classe come etichetta prevista. Per i problemi di regressione, l'algoritmo esegue la query dei punti *k* più vicini al punto di esempio e restituisce la media dei valori di caratteristiche e il valore previsto.
L’addestramento con l'algoritmo k-NN ha tre fasi: campionamento, riduzione della dimensione e costruzione dell'indice. Il campionamento riduce la dimensione del set di dati iniziale in modo che possa essere contenuto in memoria. Per la riduzione della dimensione, l'algoritmo diminuisce la dimensione della caratteristica dei dati per ridurre il footprint del modello k-NN nella latenza della memoria e dell'inferenza. Sono forniti due metodi di riduzione della dimensione: la proiezione casuale e la trasformazione veloce Johnson-Lindenstrauss. In genere, si utilizza la riduzione della dimensione per set di dati ad alta dimensionalità (d> 1000) per evitare la "maledizione della dimensionalità" che disturba l'analisi statistica dei dati che diventa sparsa con l'aumentare della dimensionalità. L'obiettivo principale dell’addestramento k-NN è quello di costruire l'indice. L'indice consente ricerche efficienti di distanze tra i punti i cui valori o etichette di classe non sono ancora stati determinati e i k punti più vicini da utilizzare per l'inferenza.
**Topics**
+ [Interfaccia di input/output per l'algoritmo k-NN](#kNN-input_output)
+ [Notebook di esempio k-NN](#kNN-sample-notebooks)
+ [Come funziona l'algoritmo k-NN](kNN_how-it-works.md)
+ [Raccomandazione istanza EC2 per l'algoritmo K-nn](#kNN-instances)
+ [Iperparametri k-NN](kNN_hyperparameters.md)
+ [Ottimizzazione di un modello k-NN](kNN-tuning.md)
+ [Formati di dati per l'input di addestramento k-NN](kNN-in-formats.md)
+ [Formati di richieste e risposte k-NN](kNN-inference-formats.md)
## Interfaccia di input/output per l'algoritmo k-NN
SageMaker AI k-NN supporta canali di dati di addestramento e test.
+ Usa un *canale di addestramento* per i dati che vuoi campionare e costruire nell'indice k-NN.
+ Utilizza un *canale di test* per emettere i punteggi nel file di log. I punteggi sono elencati come una riga per mini-lotto: accuratezza per `classifier`, errore quadratico medio (mse) per `regressor` per il punteggio.
Per gli input di addestramento, k-NN supporta i formati di dati `text/csv` e `application/x-recordio-protobuf`. Per il tipo di input `text/csv`, le prime colonne `label_size` sono interpretate come il vettore delle etichette per la riga. Puoi utilizzare la modalità file o la modalità pipe per addestrare i modelli sui dati formattati come `recordIO-wrapped-protobuf` o `CSV`.
Per gli input di inferenza, k-NN supporta i formati di dati `application/json`, `application/x-recordio-protobuf` e `text/csv`. Il formato `text/csv` accetta un `label_size` e il parametro di codifica. Presuppone che `label_size` sia 0 e la codifica UTF-8.
Per gli output di inferenza, k-NN supporta i formati di dati `application/json` e `application/x-recordio-protobuf`. Questi due formati di dati supportano anche la modalità di output dettagliato. Nella modalità di output dettagliato, l'API fornisce i risultati della ricerca con il vettore delle distanze ordinato dal più piccolo al più grande e gli elementi corrispondenti nel vettore delle etichette.
Per la trasformazione in batch, k-NN supporta il formato `application/jsonlines` per l'input e l'output. Di seguito viene riportato un input di esempio:
```
content-type: application/jsonlines
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
Di seguito viene riportato un output di esempio:
```
accept: application/jsonlines
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
Per ulteriori informazioni sui formati di file di input e output, consulta [Formati di dati per l'input di addestramento k-NN](kNN-in-formats.md) per l’addestramento, [Formati di richieste e risposte k-NN](kNN-inference-formats.md) per l'inferenza e [Notebook di esempio k-NN](#kNN-sample-notebooks).
## Notebook di esempio k-NN
[Per un notebook di esempio che utilizza l'algoritmo SageMaker AI k-Nearest Neighbor per prevedere i tipi di copertura delle aree naturali sulla base dei dati dei servizi geologici e forestali, vedi K-Nearest Neighbor Covertype.](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/k_nearest_neighbors_covtype/k_nearest_neighbors_covtype.html)
Usa un'istanza di notebook Jupyter per eseguire l'esempio in AI. SageMaker Per informazioni su come creare e aprire un'istanza di notebook Jupyter in AI, vedi. SageMaker [Istanze SageMaker per notebook Amazon](nbi.md) Dopo aver creato un'istanza di notebook e averla aperta, seleziona la scheda **SageMaker AI Examples** per visualizzare un elenco di tutti i notebook di esempio SageMaker AI. Trova i notebook K-Nearest Neighbor nella sezione **Introduzione agli algoritmi di Amazon**. Per aprire un notebook, fai clic sulla relativa scheda **Use (Utilizza)** e seleziona **Create copy (Crea copia)**.
# Come funziona l'algoritmo k-NN
L'algoritmo Amazon SageMaker AI k-Nearest Neighbors (k-NN) segue un processo di formazione in più fasi che include il campionamento dei dati di input, l'esecuzione della riduzione delle dimensioni e la creazione di un indice. I dati indicizzati vengono quindi utilizzati durante l’inferenza per individuare con efficienza i k-nearest neighbors più vicini per un determinato punto dati e fare previsioni basate su etichette o valori adiacenti.
## Fase 1: campionamento
Per specificare il numero totale di punti di dati da campionare dal set di dati di addestramento, utilizza il parametro `sample_size`. Ad esempio, se il set di dati iniziale ha 1.000 punti dati e `sample_size` è impostato su 100, dove il numero totale di istanze è 2, ogni worker avrebbe 50 punti di campionamento. Verrebbe raccolto un totale di 100 punti dati. Il campionamento viene eseguito linearmente rispetto al numero di dati.
## Fase 2: esecuzione della riduzione della dimensione
L'implementazione corrente dell'algoritmo k-NN ha due metodi di riduzione della dimensione. Devi specificare il metodo nell'iperparametro `dimension_reduction_type`. Il metodo `sign` specifica una proiezione casuale che utilizza una proiezione lineare con una matrice dei segni casuali e il metodo `fjlt` specifica una trasformazione veloce Johnson-Lindenstrauss, un metodo basato sulla trasformazione Fourier. Entrambi i metodi conservano le distanze del prodotto interne e L2. Il metodo `fjlt` deve essere utilizzato quando la dimensione di target è ampia e ha prestazioni migliori con l'inferenza della CPU. I metodi differiscono tra loro nella complessità di calcolo. Il metodo `sign` richiede il tempo O(ndk) per ridurre la dimensione di un batch di n punti di dimensione d in una dimensione target k. Il metodo `fjlt` richiede il tempo O(nd log(d)), ma le costanti coinvolte sono più grandi. L'uso della riduzione delle dimensioni introduce disturbo nei dati e questo disturbo può ridurre l'accuratezza della previsione.
## Fase 3: creazione di un indice
Durante l'inferenza, l'algoritmo interroga l'indice per il punto di campionamento. k-nearest-neighbors Sulla base dei riferimenti ai punti, l'algoritmo effettua la previsione di regressione o classificazione. Rende la predizione basata sulle etichette di classe o sui valori forniti. k-NN fornisce tre diversi tipi di indici: un indice flat, un indice invertito e un indice invertito con quantizzazione del prodotto. Puoi specificare il tipo con il parametro `index_type`.
## Serializzazione del modello
Quando l'algoritmo k-NN termina l’addestramento, serializza tre file per prepararsi all'inferenza.
+ model\$1algo-1: contiene l'indice serializzato per calcolare i neighbors più vicini.
+ model\$1algo-1.labels: contiene le etichette serializzate (formato binario np.float32) per calcolare l'etichetta prevista in base al risultato della query dell'indice.
+ model\$1algo-1.json: contiene i metadati del modello con formattazione JSON che memorizza gli iperparametri `k` e `predictor_type` dell’addestramento per l'inferenza insieme ad altri stati rilevanti.
Con l'attuale implementazione di k-NN, puoi modificare il file dei metadati per cambiare il modo in cui le previsioni vengono calcolate. Ad esempio, puoi modificare `k` su 10 o `predictor_type` su *regressor*.
```
{
"k": 5,
"predictor_type": "classifier",
"dimension_reduction": {"type": "sign", "seed": 3, "target_dim": 10, "input_dim": 20},
"normalize": False,
"version": "1.0"
}
```
## Raccomandazione istanza EC2 per l'algoritmo K-nn
Consigliamo l'addestramento su un'istanza CPU (come ml.m5.2xlarge) o su un'istanza GPU. L'algoritmo k-NN supporta famiglie di istanze GPU P2, P3, G4dn e G5 per l'addestramento e l'inferenza.
Le richieste di inferenza provenienti CPUs in genere hanno una latenza media inferiore rispetto a quelle provenienti da, GPUs poiché quando si utilizza hardware GPU viene applicata una tassa sulla CPU-to-GPU comunicazione. Tuttavia, GPUs in genere hanno un throughput più elevato per batch più grandi.
# Iperparametri k-NN
La tabella seguente elenca gli iperparametri che puoi impostare per l'algoritmo k-NN (k-NN) di Amazon SageMaker AI.
| Nome parametro | Description |
| --- | --- |
| feature\$1dim | Il numero di caratteristiche nei dati di input. **Campo obbligatorio** Valori validi: numeri interi positivi. |
| k | Il numero di neighbors più vicini. **Campo obbligatorio** Valori validi: numeri interi positivi |
| predictor\$1type | Il tipo di inferenza da utilizzare sulle etichette dei dati. **Campo obbligatorio** Valori validi: *classifier* per la classificazione o *regressor* per la regressione. |
| sample\$1size | Il numero di punti di dati da campionare dal set di dati di addestramento. **Campo obbligatorio** Valori validi: numeri interi positivi |
| dimension\$1reduction\$1target | La dimensione di target ridotta da impostare. **Obbligatorio** quando viene specificato il parametro `dimension_reduction_type`. Valori validi: numeri interi positivi maggiori di 0 e minori di `feature_dim`. |
| dimension\$1reduction\$1type | Il tipo di metodo di riduzione delle dimensioni. **Opzionale** Valori validi: *sign* per la proiezione casuale o *fjlt* per la trasformazione veloce Johnson-Lindenstrauss. Valore predefinito: nessuna riduzione della dimensione |
| faiss\$1index\$1ivf\$1nlists | *Il numero di centroidi da costruire nell'indice quando è fisso. `index_type` *IVFFlat*o* Faiss.IVFPQ. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: *auto*, che viene risolto in `sqrt(sample_size)`. |
| faiss\$1index\$1pq\$1m | Il numero di sottocomponenti vettoriali da costruire nell'indice quando `index_type` è impostato su *faiss.IVFPQ*. La libreria FaceBook AI Similarity Search (FAISS) richiede che il valore di sia un divisore della dimensione dei `faiss_index_pq_m` dati. Se `faiss_index_pq_m` non è un divisore della dimensione dati, la dimensione dati viene aumentata al più piccolo intero divisibile per `faiss_index_pq_m`. Se non viene applicata nessuna riduzione di dimensione, l'algoritmo aggiunge un riempimento di zeri. Se viene applicata la riduzione di dimensione, l'algoritmo aumenta il valore dell'iperparametro `dimension_reduction_target`. **Opzionale** Valori validi: uno dei seguenti numeri interi positivi: 1, 2, 3, 4, 8, 12, 16, 20, 24, 28, 32, 40, 48, 56, 64, 96 |
| index\$1metric | Il parametro per misurare la distanza tra i punti nella ricerca dei neighbors più vicini. Per l’addestramento con `index_type` impostato su `faiss.IVFPQ`, la distanza `INNER_PRODUCT` e la similarità `COSINE`non sono supportate. **Opzionale** Valori validi: *L2* per la distanza euclidea, *INNER\$1PRODUCT* per la distanza del prodotto interno, *COSINE* per la similarità del coseno. Valore predefinito: *L2* |
| index\$1type | Tipo di indice. **Opzionale** *Valori validi: *faiss.flat, faiss*. *IVFFlat*, faiss.IVFPQ.* Valore predefinito: *faiss.Flat* |
| mini\$1batch\$1size | Il numero di osservazioni per ogni mini batch per l'iterazione di dati. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 5000 |
# Ottimizzazione di un modello k-NN
L'algoritmo Amazon SageMaker AI k-nearest neighbors è un algoritmo supervisionato. L'algoritmo usa un set di dati di test ed emette un parametro sull'accuratezza per un'attività di classificazione o sull'errore quadratico medio per un'attività di regressione. Questi parametri di accuratezza confrontano le previsioni del modello per la rispettiva attività con i dati acquisiti sul campo dai dati di test empirici. Per individuare il modello migliore che restituisce la massima accuratezza o l'errore minore nel set di dati di test, esegui un processo di ottimizzazione iperparametri per k-NN.
L'*ottimizzazione automatica dei modelli*, nota anche come ottimizzazione degli iperparametri, trova la versione migliore di un modello eseguendo molti processi che testano un intervallo di iperparametri sul set di dati. Scegli gli iperparametri ottimizzabili, un intervallo di valori per ciascuno di essi e un parametro obiettivo. Scegli il parametro obiettivo appropriato per l'attività di previsione dell'algoritmo. L'ottimizzazione automatica del modello ricerca gli iperparametri scelti per trovare la combinazione di valori che restituisce il modello che ottimizza il parametro obiettivo. Gli iperparametri vengono utilizzati solo per aiutare a stimare i parametri del modello e non vengono utilizzati dal modello addestrato per fare previsioni.
Per ulteriori informazioni sull'ottimizzazione del modello, consulta [Ottimizzazione automatica dei modelli con AI SageMaker](automatic-model-tuning.md).
## Parametri calcolati dall'algoritmo k-NN
L'algoritmo k-nearest neighbors calcola uno dei due parametri nella tabella seguente durante l’addestramento, a seconda del tipo di attività specificato dall'iperparametro `predictor_type`.
+ *classifier* specifica un'attività di classificazione e calcola `test:accuracy`
+ *regressor* specifica un'attività di regressione e calcola `test:mse`.
Scegli il valore `predictor_type` appropriato per il tipo di attività intrapresa per calcolare il parametro obiettivo pertinente quando si ottimizza un modello.
| Nome parametro | Description | Direzione dell'ottimizzazione |
| --- | --- | --- |
| test:accuracy | Quando `predictor_type` è impostato su *classifier*, k-NN confronta l'etichetta prevista, in base alla media delle etichette dei k-nearest neighbors, con l'etichetta dei dati acquisiti sul campo fornita nei dati del canale di test. L'accuratezza restituita varia da 0,0 (0%) a 1,0 (100%). | Massimizza |
| test:mse | Quando `predictor_type` è impostato su *regressor*, k-NN confronta l'etichetta prevista, in base alla media delle etichette dei k-nearest neighbors, con l'etichetta dei dati acquisiti sul campo fornita nei dati del canale di test. L'errore quadratico medio viene calcolato confrontando le due etichette. | Minimizza |
## Iperparametri k-NN ottimizzabili
Ottimizza il modello Amazon SageMaker AI k-nearest neighbor con i seguenti iperparametri.
| Nome parametro | Tipo parametro | Intervalli consigliati |
| --- | --- | --- |
| k | IntegerParameterRanges | MinValue: 1, 1024 MaxValue |
| sample\$1size | IntegerParameterRanges | MinValue: 256, MaxValue 20000000 |
# Formati di dati per l'input di addestramento k-NN
Tutti gli algoritmi integrati di Amazon SageMaker AI aderiscono ai comuni formati di addestramento degli input descritti in [Common Data Formats -](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-training.html) Training. Questo argomento contiene un elenco dei formati di input disponibili per l'algoritmo SageMaker AI k-nearest-neighbor.
## Formato dei dati CSV
content-type: text/csv; label\$1size=1
```
4,1.2,1.3,9.6,20.3
```
Le prime colonne `label_size` sono interpretate come il vettore delle etichette per la riga.
## Formato dei dati RECORDIO
tipo di contenuto: applicazione/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [1.2, 1.3, 9.6, 20.3] # float32
}
},
label = {
'values': {
values: [4] # float32
}
}
}
]
}
```
# Formati di richieste e risposte k-NN
Tutti gli algoritmi integrati di Amazon SageMaker AI aderiscono al formato di inferenza di input comune descritto in Common [Data Formats](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) - Inference. Questo argomento contiene un elenco dei formati di output disponibili per l'algoritmo AI. SageMaker k-nearest-neighbor
## INPUT: formato della richiesta CSV
content-type: text/csv
```
1.2,1.3,9.6,20.3
```
Accetta `label_size` o un parametro di codifica. Presuppone che `label_size` sia 0 e la codifica UTF-8.
## INPUT: formato della richiesta JSON
content-type: application/json
```
{
"instances": [
{"data": {"features": {"values": [-3, -1, -4, 2]}}},
{"features": [3.0, 0.1, 0.04, 0.002]}]
}
```
## INPUT: formato della richiesta JSONLINES
content-type: application/jsonlines
```
{"features": [1.5, 16.0, 14.0, 23.0]}
{"data": {"features": {"values": [1.5, 16.0, 14.0, 23.0]}}
```
## INPUT: formato della richiesta RECORDIO
tipo di contenuto: applicazione/ x-recordio-protobuf
```
[
Record = {
features = {
'values': {
values: [-3, -1, -4, 2] # float32
}
},
label = {}
},
Record = {
features = {
'values': {
values: [3.0, 0.1, 0.04, 0.002] # float32
}
},
label = {}
},
]
```
## OUTPUT: formato della risposta JSON
accept: application/json
```
{
"predictions": [
{"predicted_label": 0.0},
{"predicted_label": 2.0}
]
}
```
## OUTPUT: formato della risposta JSONLINES
accept: application/jsonlines
```
{"predicted_label": 0.0}
{"predicted_label": 2.0}
```
## OUTPUT: formato della risposta VERBOSE JSON
Nella modalità di output dettagliato, l'API fornisce i risultati della ricerca con il vettore delle distanze ordinato dal più piccolo al più grande con gli elementi corrispondenti nel vettore delle etichette. In questo esempio, k è impostato su 3.
accept: application/json; verbose=true
```
{
"predictions": [
{
"predicted_label": 0.0,
"distances": [3.11792408, 3.89746071, 6.32548437],
"labels": [0.0, 1.0, 0.0]
},
{
"predicted_label": 2.0,
"distances": [1.08470316, 3.04917915, 5.25393973],
"labels": [2.0, 2.0, 0.0]
}
]
}
```
## OUTPUT: formato della risposta RECORDIO-PROTOBUF
tipo di contenuto: applicazione/ x-recordio-protobuf
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [2.0] # float32
}
}
}
]
```
## OUTPUT: formato della risposta VERBOSE RECORDIO-PROTOBUF
Nella modalità di output dettagliato, l'API fornisce i risultati della ricerca con il vettore delle distanze ordinato dal più piccolo al più grande con gli elementi corrispondenti nel vettore delle etichette. In questo esempio, k è impostato su 3.
accetta: applicazione/; verbose=true x-recordio-protobuf
```
[
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [3.11792408, 3.89746071, 6.32548437] # float32
},
'labels': {
values: [0.0, 1.0, 0.0] # float32
}
}
},
Record = {
features = {},
label = {
'predicted_label': {
values: [0.0] # float32
},
'distances': {
values: [1.08470316, 3.04917915, 5.25393973] # float32
},
'labels': {
values: [2.0, 2.0, 0.0] # float32
}
}
}
]
```
## OUTPUT DI ESEMPIO per l'algoritmo k-NN
Per attività di regressione:
```
[06/08/2018 20:15:33 INFO 140026520049408] #test_score (algo-1) : ('mse', 0.013333333333333334)
```
Per attività di classificazione:
```
[06/08/2018 20:15:46 INFO 140285487171328] #test_score (algo-1) : ('accuracy', 0.98666666666666669)
```