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-Means
K-means è un algoritmo di apprendimento non supervisionato. Cerca di trovare raggruppamenti discreti all'interno di dati, dove i membri di un gruppo sono il più possibile simili l'uno all'altro e il più possibile diversi dai membri di altri gruppi. Definisci gli attributi che desideri che l'algoritmo utilizzi per determinare la somiglianza.
Amazon SageMaker AI utilizza una versione modificata dell'algoritmo di clustering k-means su scala web. Rispetto alla versione originale dell'algoritmo, la versione utilizzata da Amazon SageMaker AI è più accurata. Come l'algoritmo originale, si adatta alle grandi quantità di set di dati e fornisce miglioramenti al momento dell’addestramento. A tale scopo, la versione utilizzata da Amazon SageMaker AI trasmette in streaming mini-batch (piccoli sottoinsiemi casuali) dei dati di addestramento. Per ulteriori informazioni su mini-batch k-means, consulta [Web-scale k-means Clustering](https://dl.acm.org/doi/10.1145/1772690.1772862).
L'algoritmo k-means si aspetta i dati tabulari, dove le righe rappresentano le osservazioni da raggruppare e le colonne rappresentano gli attributi delle osservazioni. Gli attributi *n* in ogni riga rappresentano un punto in spazio dimensionale-*n*. La distanza euclidea tra questi punti rappresenta la somiglianza delle osservazioni corrispondente. L'algoritmo raggruppa le osservazioni con valori di attributo simili (i punti corrispondenti a tali osservazioni sono raggruppati). Per ulteriori informazioni su come funziona k-means in Amazon SageMaker AI, consulta[Come funziona k-means clustering](algo-kmeans-tech-notes.md).
**Topics**
+ [Interfaccia di input/output per l'algoritmo K-Means](#km-inputoutput)
+ [Raccomandazione istanza EC2 per l'algoritmo K-Means](#km-instances)
+ [Notebook di esempio K-Means](#kmeans-sample-notebooks)
+ [Come funziona k-means clustering](algo-kmeans-tech-notes.md)
+ [Iperparametri k-means](k-means-api-config.md)
+ [Ottimizzazione di un modello K-Means](k-means-tuning.md)
+ [Formati di risposta k-Means](km-in-formats.md)
## Interfaccia di input/output per l'algoritmo K-Means
L'algoritmo k-means si aspetta che i dati da fornire nel canale di *addestramento* (consigliato `S3DataDistributionType=ShardedByS3Key`), con un canale di *test* opzionale (consigliato `S3DataDistributionType=FullyReplicated`) su cui registrare i dati. I formati `recordIO-wrapped-protobuf` e `CSV` sono supportati per l’addestramento. Puoi utilizzare la modalità file o la modalità pipe per addestrare i modelli sui dati formattati come `recordIO-wrapped-protobuf` o `CSV`.
Per l'inferenza, sono supportati `text/csv`, `application/json` e `application/x-recordio-protobuf`. k-means restituisce un'etichetta `closest_cluster`e la `distance_to_cluster` per ogni osservazione.
Per ulteriori informazioni sui formati di file di input e output, consulta [Formati di risposta k-Means](km-in-formats.md) per l'inferenza e i [Notebook di esempio K-Means](#kmeans-sample-notebooks). L'algoritmo k-means non supporta più istanze di apprendimento, in cui il set di addestramento è costituito da etichette “bags”, ciascuna delle quali è una raccolta di istanze non etichettate.
## Raccomandazione istanza EC2 per l'algoritmo K-Means
Consigliamo di eseguire l’addestramento di k-means sulle istanze di CPU. Puoi eseguire l’addestramento sulle istanze GPU, ma devi limitare l’addestramento di GPU a singole istanze GPU (ad esempio, ml.g4dn.xlarge) perché viene utilizzata solo una GPU per ogni istanza. L'algoritmo k-means supporta istanze P2, P3, G4dn e G5 per l'addestramento e l'inferenza.
## Notebook di esempio K-Means
Per un taccuino di esempio che utilizza l'algoritmo SageMaker AI K-means per segmentare la popolazione delle contee degli Stati Uniti in base ad attributi identificati utilizzando l'analisi dei componenti principali, consulta [Analizzare i dati del censimento degli Stati Uniti per la segmentazione](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_applying_machine_learning/US-census_population_segmentation_PCA_Kmeans/sagemaker-countycensusclustering.html) della popolazione utilizzando Amazon AI. SageMaker Per istruzioni su come creare e accedere alle istanze di notebook Jupyter da utilizzare per eseguire l'esempio in AI, consulta. SageMaker [Istanze SageMaker per notebook Amazon](nbi.md) Dopo aver creato un'istanza di notebook e averla aperta, seleziona la scheda **Esempi SageMaker AI** per visualizzare un elenco di tutti gli esempi di IA. SageMaker Per aprire un notebook, fai clic sulla relativa scheda **Use (Utilizza)** e seleziona **Create copy (Crea copia)**.
# Come funziona k-means clustering
K-means è un algoritmo che esegue l’addestramento di un modello che raggruppa oggetti simili. L'algoritmo k-means ottiene ciò mappando ogni osservazione nel set di dati di input a un punto nello *n*-spazio bidimensionale (dove *n* è il numero di attributi dell'osservazione). Ad esempio, il set di dati può contenere osservazioni di temperatura e umidità in una determinata posizione, che sono mappate a punti (*t, h*) in uno spazio bidimensionale.
**Nota**
Gli algoritmi clustering sono supervisionati. Nell'apprendimento non supervisionato, le etichette che possono essere associate con gli oggetti nel set di dati di addestramento non verranno utilizzate. Per ulteriori informazioni, consulta [Apprendimento non supervisionato](algorithms-choose.md#algorithms-choose-unsupervised-learning).
In k-means clustering, ogni cluster ha un centro. Durante l’addestramento del modello, l'algoritmo k-means utilizza la distanza del punto che corrisponde a ogni osservazione nel set di dati per i centri del cluster come base per il clustering. Tu scegli il numero di cluster (*k*) da creare.
Ad esempio, supponiamo che desideri creare un modello per riconoscere cifre scritte a mano e scegli il set di dati MNIST per l’addestramento. Il set di dati fornisce migliaia di immagini di cifre scritte a mano (da 0 a 9). In questo esempio, puoi scegliere di creare 10 cluster, uno per ogni cifra (0, 1,..., 9). Come parte del modello di addestramento, l'algoritmo k-means raggruppa le immagini in ingresso in 10 cluster.
Ogni immagine nel set di dati MNIST è un'immagine a 28 x 28 pixel, con un totale di 784 pixel. Ogni immagine corrisponde a un punto in un spazio a 784 dimensioni, simile a un punto in uno spazio bidimensionale (x, y). Per trovare un cluster a cui appartiene un punto, l'algoritmo k-means rileva la distanza di quel punto, da tutti i centri di cluster. Poi sceglie il cluster con il centro più vicino come il cluster a cui appartiene l'immagine.
**Nota**
Amazon SageMaker AI utilizza una versione personalizzata dell'algoritmo in cui, invece di specificare che l'algoritmo crea *k* cluster, puoi scegliere di migliorare la precisione del modello specificando centri cluster aggiuntivi *(K = k\$1x*). Tuttavia, l'algoritmo li riduce sostanzialmente a cluster *k*.
Nell' SageMaker intelligenza artificiale, specifichi il numero di cluster quando crei un lavoro di formazione. Per ulteriori informazioni, consulta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Nel corpo della richiesta, la mappa di stringhe `HyperParameters` per specificare le stringhe `k` e `extra_center_factor`.
Di seguito è riportato un riepilogo di come k-means funziona per la formazione dei modelli nell' SageMaker IA:
1. Determina i centri di cluster iniziali *K*.
**Nota**
Nei seguenti argomenti, i cluster *K* si riferiscono a *k\$1 x*, dove specifichi *k* e *x* durante la creazione di un processo di addestramento del modello.
1. Itera sui dati di addestramento di input e ricalcola i centri di cluster.
1. Riduce i cluster risultanti per *k* (se il tecnico addetto alla gestione dei dati ha specificato la creazione di cluster *k\$1x* nella richiesta).
Le seguenti sezioni spiegano anche alcuni dei parametri che un tecnico addetto alla gestione dei dati può specificare i dati per configurare un processo di addestramento del modello come parte della mappa di stringhe `HyperParameters`.
**Topics**
+ [Fase 1: determinare i centri di cluster iniziali](#kmeans-step1)
+ [Fase 2: iterare i set di dati di addestramento e calcolare i centri di cluster](#kmeans-step2)
+ [Fase 3: ridurre i cluster da *K* a *k*](#kmeans-step3)
## Fase 1: determinare i centri di cluster iniziali
Quando si utilizza k-means nell' SageMaker intelligenza artificiale, i centri di cluster iniziali vengono scelti tra le osservazioni in un piccolo lotto campionato casualmente. Scegli una delle seguenti strategie per determinare come questi centri di cluster iniziali sono selezionati:
+ L'approccio casuale: scegli casualmente *K* osservazioni nel tuo set di dati di input come centri di cluster. Ad esempio, puoi scegliere un centro di cluster che punta allo spazio a 784 dimensioni che corrisponde a qualsiasi 10 immagini nel set di dati di addestramento MNIST.
+ L'approccio k-means\$1\$1, che funziona come segue:
1. Inizia con un cluster e determina il suo centro. Selezioni casualmente un'osservazione dal tuo set di dati di addestramento e utilizzi il punto corrispondente all'osservazione come il centro di cluster. Ad esempio, nel set di dati MNIST, scegli casualmente un'immagine di cifre scritte a mano. Poi scegli il punto nello spazio a 784 dimensioni che corrisponde all'immagine come tuo centro di cluster. Si tratta del centro di cluster 1.
1. Determina il centro per il cluster 2. Dalle osservazioni rimanenti nel set di dati di addestramento, scegli un'osservazione a caso. Scegli uno che è diverso rispetto a quello selezionato in precedenza. Questa osservazione corrisponde a un punto lontano dal centro di cluster 1. Utilizzando il set di dati MNIST come esempio, esegui le operazioni seguenti:
+ Per ognuna delle immagini rimanenti, trova la distanza del punto corrispondente dal centro di cluster 1. Pareggia la distanza e assegna una probabilità che è proporzionale al quadrato della distanza. In questo modo, un'immagine che è diversa da quella selezionata in precedenza ha una maggiore probabilità di essere selezionata come centro di cluster 2.
+ Scegli una delle immagini casualmente, in base alla probabilità assegnate nella fase precedente. Il punto che corrisponde all'immagine è il centro di cluster 2.
1. Ripeti la fase 2 per trovare il centro di cluster 3. Questa volta trova le distanze delle immagini rimanenti dal centro di cluster 2.
1. Ripeti il processo finché non disponi dei centri di cluster *K*.
Per addestrare un modello nell' SageMaker intelligenza artificiale, crei un lavoro di formazione. Nella richiesta, fornisci informazioni sulla configurazione specificando le seguenti mappe di stringa `HyperParameters`:
+ Per specificare il numero di cluster da creare, aggiungi la stringa `k`.
+ Per maggiore accuratezza, aggiungi la stringa opzionale `extra_center_factor`.
+ Per specificare la strategia che desideri utilizzare per determinare i centri di cluster iniziali, aggiungi la stringa `init_method` e imposta il valore su `random` o `k-means++`.
Per ulteriori informazioni sullo stimatore SageMaker AI k-means, consulta [K-means](https://sagemaker.readthedocs.io/en/stable/algorithms/unsupervised/kmeans.html) nella documentazione di Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable) SDK.
Adesso hai un set iniziale di centri di cluster.
## Fase 2: iterare i set di dati di addestramento e calcolare i centri di cluster
I centri di cluster che hai creato nella fase precedente sono per lo più casuali, con un po' di considerazione per il set di dati di addestramento. In questa fase, utilizzi i set di dati di addestramento per spostare questi centri verso i veri centri di cluster. L'algoritmo itera sul set di dati di addestramento e ricalcola i centri di cluster *K*.
1. Leggi un mini-batch di osservazioni (un sottoinsieme piccolo e scelto casualmente di tutti i record) dal set di dati di addestramento ed esegui le seguenti operazioni.
**Nota**
Quando crei un processo di addestramento del modello, specifichi le dimensioni del batch nella stringa `mini_batch_size` nella mappa di stringhe `HyperParameters`.
1. Assegna tutte le osservazioni nel mini batch a uno dei cluster con il centro del cluster più vicino.
1. Calcola il numero di osservazioni assegnate a ogni cluster. Poi calcola la proporzione dei nuovi punti assegnati per cluster.
Ad esempio, considera i seguenti cluster:
Cluster c1 = 100 punti assegnati in precedenza. Hai aggiunto 25 punti dal mini-batch in questa fase.
Cluster c2 = 150 punti assegnati in precedenza. Hai aggiunto 40 punti dal mini-batch in questa fase.
Cluster c3 = 450 punti assegnati in precedenza. Hai aggiunto 5 punti dal mini-batch in questa fase.
Calcola la proporzione di nuovi punti assegnati a ogni cluster come segue:
```
p1 = proportion of points assigned to c1 = 25/(100+25)
p2 = proportion of points assigned to c2 = 40/(150+40)
p3 = proportion of points assigned to c3 = 5/(450+5)
```
1. Calcola il centro dei nuovi punti aggiunti a ogni cluster:
```
d1 = center of the new points added to cluster 1
d2 = center of the new points added to cluster 2
d3 = center of the new points added to cluster 3
```
1. Calcola la media ponderata per trovare i centri di cluster aggiornati come segue:
```
Center of cluster 1 = ((1 - p1) * center of cluster 1) + (p1 * d1)
Center of cluster 2 = ((1 - p2) * center of cluster 2) + (p2 * d2)
Center of cluster 3 = ((1 - p3) * center of cluster 3) + (p3 * d3)
```
1. Leggi il prossimo mini-batch e ripeti la fase 1 per ricalcolare i centri del cluster.
1. Per ulteriori informazioni su mini-batch *k*-means, consulta [Web-Scale k-means Clustering](https://citeseerx.ist.psu.edu/document?repid=rep1type=pdf&doi=b452a856a3e3d4d37b1de837996aa6813bedfdcf)).
## Fase 3: ridurre i cluster da *K* a *k*
Se l'algoritmo ha creato *K* cluster, *(K = k\$1 x),* dove *x* è maggiore di 1, riduce i cluster * K * a cluster *k*. (Per ulteriori informazioni, consulta `extra_center_factor` nella discussione precedente.) Ciò avviene tramite l'applicazione del metodo di Lloyd con l'inizializzazione di `kmeans++` ai centri di cluster *K*. Per ulteriori informazioni sulle modalità di Lloyd's, consulta [k-significa clustering](https://pdfs.semanticscholar.org/0074/4cb7cc9ccbbcdadbd5ff2f2fee6358427271.pdf).
# Iperparametri k-means
Nella richiesta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html), specifichi l'algoritmo di addestramento che desideri utilizzare. Puoi anche specificare iperparametri specifici dell'algoritmo come mappe. string-to-string La tabella seguente elenca gli iperparametri per l'algoritmo di addestramento k-means fornito da Amazon SageMaker AI. Per ulteriori informazioni su come funzione k-means clustering, consulta [Come funziona k-means clustering](algo-kmeans-tech-notes.md).
| Nome parametro | Description |
| --- | --- |
| feature\$1dim | Il numero di caratteristiche nei dati di input. **Campo obbligatorio** Valori validi: numeri interi positivi |
| k | Il numero di cluster necessari. **Campo obbligatorio** Valori validi: numeri interi positivi |
| epochs | Il numero di pass sui dati di addestramento. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 1 |
| eval\$1metrics | Un elenco JSON dei tipi di parametro utilizzati per restituire un punteggio per il modello. I valori consentiti sono `msd` per la deviazione quadratica media e `ssd` per la somma della distanza quadratica. Se vengono forniti dati di test, il punteggio viene restituito per ciascun parametro richiesto. **Opzionale** Valori validi: `[\"msd\"]` o `[\"ssd\"]` oppure `[\"msd\",\"ssd\"]`. Valore predefinito: `[\"msd\"]` |
| extra\$1center\$1factor | L'algoritmo crea K centers = `num_clusters` \$1 `extra_center_factor` mentre viene eseguito e riduce il numero di centri da K a `k` durante la finalizzazione del modello. **Opzionale** Valori validi: un numero intero o `auto`. Valore predefinito: `auto` |
| half\$1life\$1time\$1size | Viene utilizzato per determinare il peso specificato per un'osservazione quando si calcola la media di un cluster. Questo peso decade esponenzialmente quando più punti vengono osservati. Quando un punto viene osservato per la prima volta, viene assegnato un peso pari a 1 quando si calcola la media del cluster. La costante di decadimento per la funzione di decadimento esponenziale viene scelta in modo che dopo l'osservazione dei punti `half_life_time_size` il peso sia dimezzato. Se è impostato su 0, non vi è alcun decadimento. **Opzionale** Valori validi: numeri interi non negativi Valore predefinito: 0 |
| init\$1method | Metodo con cui l'algoritmo sceglie i centri di cluster iniziali. L'approccio k-means standard li sceglie casualmente. Un metodo alternativo k-means \$1\$1 sceglie casualmente il primo centro di cluster. Quindi distribuisce la posizione dei restanti cluster iniziali pesando la selezione dei centri con una distribuzione di probabilità che è proporzionale al quadrato della distanza dei restanti punti di dati dai centri esistenti. **Opzionale** Valori validi: `random` o `kmeans++`. Valore predefinito: `random` |
| local\$1lloyd\$1init\$1method | Il metodo di inizializzazione per la procedura di massimizzazione dell'aspettativa (EM, Expectation Maximization) di Lloyd utilizzato per creare il modello finale contenente i centri `k`. **Opzionale** Valori validi: `random` o `kmeans++`. Valore predefinito: `kmeans++` |
| local\$1lloyd\$1max\$1iter | Il numero massimo di iterazioni per la procedura di massimizzazione dell'aspettativa (EM, Expectation Maximization) di Lloyd utilizzato per creare il modello finale contenente centri `k`. **Opzionale** Valori validi: numeri interi positivi Valore predefinito: 300 |
| local\$1lloyd\$1num\$1trials | Il numero di volte in cui viene eseguita la procedura di massimizzazione dell'aspettativa (EM) di Lloyd con la perdita minore quando si costruisce il modello finale contenente centri `k`. **Opzionale** Valori validi: un numero intero o `auto`. Valore predefinito: `auto` |
| local\$1lloyd\$1tol | La tolleranza per il cambiamento di perdita per l'arresto precoce della procedura di massimizzazione dell'aspettativa (EM, Expectation Maximization) di Lloyd utilizzato per creare il modello finale contenente centri `k`. **Opzionale** Valori validi: Float. Intervallo in [0, 1]. Valore predefinito: 0.0001 |
| 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-Means
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. Puoi scegliere il parametro obiettivo tra i parametri calcolati dall'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.
L'algoritmo Amazon SageMaker AI k-means è un algoritmo non supervisionato che raggruppa i dati in cluster i cui membri sono il più simili possibile. Poiché non è supervisionato, non utilizza un set di dati di convalida per ottimizzare gli iperparametri. Richiede invece un set di dati di test ed emette parametri che dipendono dalla distanza quadratica tra i punti di dati e i centroidi del cluster finale alla fine di ogni esecuzione di addestramento. Per trovare il modello che restituisce i cluster più stretti nel set di dati di test, puoi utilizzare un processo di ottimizzazione iperparametri. I cluster ottimizzano la somiglianza dei membri.
Per ulteriori informazioni sull'ottimizzazione del modello, consulta [Ottimizzazione automatica dei modelli con AI SageMaker](automatic-model-tuning.md).
## Parametri calcolati dall'algoritmo K-Means
L'algoritmo k-means calcola i seguenti parametri durante l’addestramento. Quando ottimizzi un modello, scegli uno di questi parametri come obiettivo.
| Nome parametro | Description | Direzione dell'ottimizzazione |
| --- | --- | --- |
| test:msd | Distanza quadratica media tra ciascun record nel set di test e il centro più vicino del modello. | Minimizza |
| test:ssd | Somma delle distanze quadratiche medie tra ciascun record nel set di test e il centro più vicino del modello. | Minimizza |
## Iperparametri K-Means ottimizzabili
Ottimizza il modello Amazon SageMaker AI k-means con i seguenti iperparametri. Gli iperparametri che hanno il maggiore impatto sui parametri obiettivo k-means sono: `mini_batch_size`, `extra_center_factor` e `init_method`. L'ottimizzazione dell'iperparametro `epochs` generalmente produce miglioramenti minori.
| Nome parametro | Tipo parametro | Intervalli consigliati |
| --- | --- | --- |
| epochs | IntegerParameterRanges | MinValue: 1:10 MaxValue |
| extra\$1center\$1factor | IntegerParameterRanges | MinValue: 4, 10 MaxValue |
| init\$1method | CategoricalParameterRanges | ['kmeans\$1\$1', 'random'] |
| mini\$1batch\$1size | IntegerParameterRanges | MinValue: 3000, 1500 MaxValue |
# Formati di risposta k-Means
[Tutti gli algoritmi integrati nell' SageMaker intelligenza artificiale aderiscono al formato di inferenza di input comune descritto in Common Data Formats - Inference.](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html) Questo argomento contiene un elenco dei formati di output disponibili per l'algoritmo AI k-means. SageMaker
## Formato della risposta JSON
```
{
"predictions": [
{
"closest_cluster": 1.0,
"distance_to_cluster": 3.0,
},
{
"closest_cluster": 2.0,
"distance_to_cluster": 5.0,
},
....
]
}
```
## Formato della risposta JSONLINES
```
{"closest_cluster": 1.0, "distance_to_cluster": 3.0}
{"closest_cluster": 2.0, "distance_to_cluster": 5.0}
```
## Formato della risposta RECORDIO
```
[
Record = {
features = {},
label = {
'closest_cluster': {
keys: [],
values: [1.0, 2.0] # float32
},
'distance_to_cluster': {
keys: [],
values: [3.0, 5.0] # float32
},
}
}
]
```
## Formato della risposta CSV
Il primo valore in ogni riga corrisponde a `closest_cluster`.
Il secondo valore in ogni riga corrisponde a `distance_to_cluster`.
```
1.0,3.0
2.0,5.0
```