Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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à.
# Tutorial per Amazon Redshift ML
Con funzionalità di machine learning di Amazon Redshift, è possibile addestrare modelli di machine learning utilizzando istruzioni SQL e quindi richiamarli nelle query SQL per generare previsioni. Il machine learning in Amazon Redshift addestra un modello con un comando SQL. Amazon Redshift avvia automaticamente un processo di formazione in Amazon SageMaker AI e genera un modello. Dopo aver creato un modello, è possibile eseguire previsioni in Amazon Redshift utilizzando la funzione di previsione del modello.
Seguire la procedura descritta in questi tutorial per scoprire le funzionalità di funzionalità di machine learning di Amazon Redshift.
+ [Tutorial: Creazione di modelli di abbandono dei clienti](tutorial_customer_churn.md): in questo tutorial utilizzi Amazon Redshift ML per creare un modello di abbandono dei clienti con il comando CREATE MODEL ed eseguire query di previsione per gli scenari utente. Implementerai quindi le query utilizzando la funzione SQL generata dal comando CREATE MODEL.
+ [Tutorial: Creazione di modelli di clustering K-means](tutorial_k-means_clustering.md): in questo tutorial utilizzi Amazon Redshift ML per creare, addestrare e implementare un modello di machine learning basato sull’[algoritmo K-means](url-sm-dev;k-means.html).
+ [Tutorial: Creazione di modelli di classificazione multi-classe](tutorial_multi-class_classification.md): in questo tutorial utilizzi Amazon Redshift ML per creare un modello di machine learning che risolva i problemi di classificazione multiclasse. L'algoritmo di classificazione multi-classe classifica i punti dati in una delle tre o più classi. Implementerai quindi le query utilizzando la funzione SQL generata dal comando CREATE MODEL.
+ [Tutorial: creazione di modelli XGBoost](tutorial_xgboost.md): in questo tutorial crei un modello con i dati di Amazon S3 ed esegui query di previsione con il modello utilizzando Amazon Redshift ML. L' XGBoost algoritmo è un'implementazione ottimizzata dell'algoritmo Gradient Boosted Trees.
+ [Tutorial: Creazione di modelli di regressione](tutorial_regression.md): in questo tutorial utilizzi Amazon Redshift ML per creare un modello di regressione basato sul machine learning ed eseguire query di previsione sul modello. I modelli di regressione consentono di prevedere risultati numerici, ad esempio il prezzo di un immobile o quante persone utilizzeranno il servizio di noleggio biciclette di una città.
+ [Tutorial: Creazione di modelli di regressione con Linear Learner](tutorial_linear_learner_regression.md): in questo tutorial crei un modello basato sull’algoritmo Linear Learner con i dati di Amazon S3 ed esegui query di previsione con il modello utilizzando Amazon Redshift ML. L'algoritmo SageMaker AI linear learner risolve problemi di regressione o di classificazione multiclasse.
+ [Tutorial: Creazione di modelli di classificazione multi-classe con Linear Learner](tutorial_linear_learner_multi-class_classification.md): in questo tutorial crei un modello Linear Learner con i dati di Amazon S3, quindi esegui query di previsione con il modello utilizzando Amazon Redshift ML. L'algoritmo SageMaker AI linear learner risolve problemi di regressione o classificazione.
# Tutorial: Creazione di modelli di abbandono dei clienti
In questo tutorial, utilizzi Amazon Redshift ML per creare un modello di abbandono dei clienti con il comando CREATE MODEL ed eseguire query di previsione per gli scenari utente. Implementerai quindi le query utilizzando la funzione SQL generata dal comando CREATE MODEL.
È possibile usare un semplice comando CREATE MODEL per esportare i dati di addestramento, addestrare un modello, importare il modello e preparare una funzione di previsione Amazon Redshift. Utilizzare l'istruzione CREATE MODEL per specificare i dati di addestramento come tabella o istruzione SELECT.
L'esempio utilizza queste informazioni cronologiche per creare un modello di machine learning per le previsioni di abbandono dei clienti di un operatore di telefonia mobile. Innanzitutto, l' SageMaker intelligenza artificiale addestra il tuo modello di apprendimento automatico e poi lo testa utilizzando le informazioni del profilo di un cliente arbitrario. Dopo la convalida del modello, Amazon SageMaker AI distribuisce il modello e la funzione di previsione su Amazon Redshift. È possibile utilizzare la funzione di previsione per prevedere se un cliente intende o meno abbandonare il servizio.
## Esempi di casi d'uso
Puoi risolvere altri problemi di classificazione binaria utilizzando Amazon Redshift ML, ad esempio prevedere se un lead di vendita verrà chiuso o meno. Puoi anche prevedere se una transazione finanziaria è legale o meno.
**Attività**
+ Prerequisiti
+ Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
+ Passaggio 2: creazione del modello di machine learning
+ Passaggio 3: esecuzione di previsioni con il modello
## Prerequisiti
I prerequisiti per il completamento di questo sono elencati di seguito:
+ Devi configurare un cluster Amazon Redshift per Amazon Redshift ML. A questo scopo, utilizza la documentazione per [configurare il cluster e le impostazioni per l'amministrazione di Amazon Redshift ML.](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html)
+ Il cluster Amazon Redshift usato per creare il modello e il bucket Amazon S3 usato per la gestione temporanea dei dati di addestramento e per l'archiviazione degli artefatti del modello devono trovarsi nella stessa regione AWS .
+ Per scaricare i comandi SQL e i set di dati di esempio utilizzati nella documentazione, esegui una delle seguenti operazioni:
+ Scaricare i [comandi SQL](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql), il [file delle attività dei clienti](https://s3.amazonaws.com/redshift-downloads/redshift-ml/customer_activity/customer_activity.csv) e il [file Abalone](https://s3.amazonaws.com/redshift-downloads/redshift-ml/abalone_xg/abalone.csv).
+ Utilizzando il AWS CLI per Amazon S3, esegui il comando seguente. È possibile utilizzare il proprio percorso di destinazione.
```
aws s3 cp s3://redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql
aws s3 cp s3://redshift-downloads/redshift-ml/customer_activity/customer_activity.csv
aws s3 cp s3://redshift-downloads/redshift-ml/abalone_xgb/abalone_xgb.csv
```
## Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
Utilizza l'[editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) per modificare ed eseguire query e visualizzare i risultati.
L'esecuzione delle seguenti query consente di creare una tabella denominata `customer_activity` e acquisisce il set di dati di esempio da Amazon S3.
```
DROP TABLE IF EXISTS customer_activity;
CREATE TABLE customer_activity (
state varchar(2),
account_length int,
area_code int,
phone varchar(8),
intl_plan varchar(3),
vMail_plan varchar(3),
vMail_message int,
day_mins float,
day_calls int,
day_charge float,
total_charge float,
eve_mins float,
eve_calls int,
eve_charge float,
night_mins float,
night_calls int,
night_charge float,
intl_mins float,
intl_calls int,
intl_charge float,
cust_serv_calls int,
churn varchar(6),
record_date date
);
COPY customer_activity
FROM 's3://redshift-downloads/redshift-ml/customer_activity/'
REGION 'us-east-1' IAM_ROLE default
FORMAT AS CSV IGNOREHEADER 1;
```
## Passaggio 2: creazione del modello di machine learning
L'abbandono è l'input di destinazione in questo modello. Tutti gli altri input per il modello sono attributi che aiutano a creare una funzione per prevedere la perdita di clienti.
L'esempio seguente utilizza l'operazione CREATE MODEL per restituire un modello che prevede se un cliente sarà attivo, utilizzando input come l'età del cliente, il codice postale, le spese e i casi. Nell’esempio seguente sostituisci amzn-s3-demo-bucket con il bucket Amazon S3.
```
CREATE MODEL customer_churn_auto_model
FROM
(
SELECT state,
account_length,
area_code,
total_charge/account_length AS average_daily_spend,
cust_serv_calls/account_length AS average_daily_cases,
churn
FROM customer_activity
WHERE record_date < '2020-01-01'
)
TARGET churn FUNCTION ml_fn_customer_churn_auto
IAM_ROLE default SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket'
);
```
La query SELECT nell'esempio precedente crea i dati di addestramento. La clausola TARGET specifica quale colonna è una "etichetta" di machine learning usato dall'operazione CREATE MODEL per imparare a eseguire le previsioni. La colonna di destinazione "abbandono" indica se il cliente ha ancora un'iscrizione attiva o se l'ha sospesa. Il campo S3\$1BUCKET è il nome del bucket Amazon S3 creato in precedenza. Il bucket Amazon S3 viene utilizzato per condividere dati e artefatti di formazione tra Amazon Redshift e Amazon AI. SageMaker Le colonne rimanenti sono le funzionalità (input) utilizzate per la previsione.
Per un riepilogo della sintassi e delle funzionalità di un caso d'uso di base del comando CREATE MODEL, consulta [CREATE MODEL semplice](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model).
### Aggiunta delle autorizzazioni per la crittografia lato server (facoltativo)
Amazon Redshift per impostazione predefinita utilizza Amazon SageMaker AI Autopilot per la formazione. In particolare, Amazon Redshift esporta in modo sicuro i dati di addestramento nel bucket Amazon S3 specificato dal cliente. Se non si specifica `KMS_KEY_ID`, per impostazione predefinita i dati vengono crittografati utilizzando la crittografia lato server SSE-S3.
Quando crittografi l'input utilizzando la crittografia lato server con una chiave AWS KMS gestita (SSE-MMS), aggiungi le seguenti autorizzazioni:
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
Per ulteriori informazioni sui ruoli di Amazon SageMaker AI, consulta i [ruoli di Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) nella *Amazon SageMaker AI Developer Guide*.
### Verifica dello stato dell'addestramento del modello (facoltativo)
È possibile utilizzare il comando SHOW MODEL per verificare quando il modello è pronto.
Utilizza l'operazione seguente per visualizzare lo stato del modello.
```
SHOW MODEL customer_churn_auto_model;
```
Di seguito è riportato un esempio di output dell'operazione precedente.
```
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | customer_churn_auto_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 14.06.2022 17:15:52 |
| Model State | TRAINING |
| | |
| TRAINING DATA: | |
| Query | SELECT STATE, ACCOUNT_LENGTH, AREA_CODE, TOTAL_CHARGE / ACCOUNT_LENGTH AS AVERAGE_DAILY_SPEND, CUST_SERV_CALLS / ACCOUNT_LENGTH AS AVERAGE_DAILY_CASES, CHURN |
| | FROM CUSTOMER_ACTIVITY |
| | WHERE RECORD_DATE < '2020-01-01' |
| Target Column | CHURN |
| | |
| PARAMETERS: | |
| Model Type | auto |
| Problem Type | |
| Objective | |
| AutoML Job Name | redshiftml-20220614171552640901 |
| Function Name | ml_fn_customer_churn_auto |
| Function Parameters | state account_length area_code average_daily_spend average_daily_cases |
| Function Parameter Types | varchar int4 int4 float8 int4 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Al completamento dell'addestramento del modello, la variabile `model_state` diventa `Model is Ready` e la funzione di previsione diventa disponibile.
## Passaggio 3: esecuzione di previsioni con il modello
È possibile utilizzare le istruzioni SQL per visualizzare le previsioni generate dal modello di previsione. In questo esempio, la funzione di previsione creata dall'operazione CREATE MODEL è denominata `ml_fn_customer_churn_auto`. Gli argomenti di input per la funzione di previsione corrispondono ai tipi di funzionalità, ad esempio varchar per `state` e integer per `account_length`. L'output della funzione di previsione è dello stesso tipo della colonna TARGET dell'istruzione CREATE MODEL.
1. Hai eseguito l'addestramento del modello usando dati anteriori alla data 01/01/2020, quindi ora usi la funzione di previsione sul set di test. La query seguente visualizza le previsioni relative alla possibilità di abbandono dei clienti registrati dopo la data 01/01/2020.
```
SELECT
phone,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01';
```
1. L'esempio seguente utilizza la stessa funzione di previsione per un caso d'uso diverso. In questo caso, Amazon Redshift prevede la percentuale di abbandoni e non abbandoni tra clienti provenienti da stati diversi in cui la data di registrazione è successiva a 01/01/2020.
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
) AS churners,
SUM(
CASE
WHEN active = 'False.' THEN 1
ELSE 0
END
) AS nonchurners,
COUNT(*) AS total_per_state
FROM
predicted
GROUP BY
state
ORDER BY
state;
```
1. Nell'esempio seguente viene utilizzata la funzione di previsione per il caso d'uso di previsione della percentuale di clienti persi in uno stato. In questo caso, Amazon Redshift prevede la percentuale di abbandono associata a una data di registrazione successiva a 01/01/2020.
```
WITH predicted AS (
SELECT
state,
ml_fn_customer_churn_auto(
state,
account_length,
area_code,
total_charge / account_length,
cust_serv_calls / account_length
) :: varchar(6) AS active
FROM
customer_activity
WHERE
record_date > '2020-01-01'
)
SELECT
state,
CAST((CAST((SUM(
CASE
WHEN active = 'True.' THEN 1
ELSE 0
END
)) AS FLOAT) / CAST(COUNT(*) AS FLOAT)) AS DECIMAL (3, 2)) AS pct_churn,
COUNT(*) AS total_customers_per_state
FROM
predicted
GROUP BY
state
ORDER BY
3 DESC;
```
## Argomenti correlati
Per ulteriori informazioni su Amazon Redshift ML, fare riferimento ai seguenti collegamenti:
+ [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Comando CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:
+ [Panoramica del machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning per principianti ed esperti](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Che cos'è l'equità e la spiegabilità dei modelli per le previsioni di Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Creazione di modelli di clustering K-means
In questo tutorial, viene utilizzato Amazon Redshift ML per creare, addestrare e distribuire un modello di machine learning basato sull'[algoritmo k-means](url-sm-dev;k-means.html). Questo algoritmo risolve i problemi di clustering in cui si desidera individuare i raggruppamenti nei dati. K-means aiuta a raggruppare i dati non ancora etichettati. Per ulteriori informazioni sul clustering K-means, consulta [How K-means Clustering Works nella](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html) Amazon SageMaker AI Developer Guide.
Utilizzerai un'operazione CREATE MODEL per creare un modello K-means da un cluster Amazon Redshift. È possibile usare un comando CREATE MODEL per esportare i dati di addestramento, addestrare un modello, importare il modello e preparare una funzione di previsione Amazon Redshift. Usa l'istruzione CREATE MODEL per specificare i dati di addestramento come tabella o istruzione SELECT.
In questo tutorial, utilizzi K-means sul set di dati [GDELT (Global Database of Events, Language, and Tone)](https://aws.amazon.com/public-datasets/gdelt/), che monitora le notizie a livello mondiale e i dati archiviati in ogni momento del giorno. K-means raggrupperà eventi con toni, soggetti o luoghi simili. I dati vengono archiviati in più file su Amazon Simple Storage Service, in due cartelle diverse. Le cartelle sono storiche, ovvero riferite agli 1979-2013, con aggiornamenti quotidiani riferiti agli anni 2013 e successivi. In questo esempio, viene usato formato storico e vengono acquisiti i dati relativi al 1979.
## Esempi di casi d'uso
Puoi risolvere altri problemi di clustering con Amazon Redshift ML, ad esempio il raggruppamento di clienti con abitudini di visualizzazione simili su un servizio di streaming. Puoi anche utilizzare Redshift ML per prevedere il numero ottimale di centri di spedizione per un servizio di consegna.
**Attività**
+ Prerequisiti
+ Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
+ Passaggio 2: creazione del modello di machine learning
+ Passaggio 3: esecuzione di previsioni con il modello
## Prerequisiti
Per completare questo tutorial, è necessario completare la [configurazione amministrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) di Amazon Redshift ML.
## Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
1. Utilizza l'[editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) per eseguire la seguente query. La query elimina la tabella `gdelt_data` nello schema pubblico, se esiste, e crea una tabella con lo stesso nome nello schema pubblico.
```
DROP TABLE IF EXISTS gdelt_data CASCADE;
CREATE TABLE gdelt_data (
GlobalEventId bigint,
SqlDate bigint,
MonthYear bigint,
Year bigint,
FractionDate double precision,
Actor1Code varchar(256),
Actor1Name varchar(256),
Actor1CountryCode varchar(256),
Actor1KnownGroupCode varchar(256),
Actor1EthnicCode varchar(256),
Actor1Religion1Code varchar(256),
Actor1Religion2Code varchar(256),
Actor1Type1Code varchar(256),
Actor1Type2Code varchar(256),
Actor1Type3Code varchar(256),
Actor2Code varchar(256),
Actor2Name varchar(256),
Actor2CountryCode varchar(256),
Actor2KnownGroupCode varchar(256),
Actor2EthnicCode varchar(256),
Actor2Religion1Code varchar(256),
Actor2Religion2Code varchar(256),
Actor2Type1Code varchar(256),
Actor2Type2Code varchar(256),
Actor2Type3Code varchar(256),
IsRootEvent bigint,
EventCode bigint,
EventBaseCode bigint,
EventRootCode bigint,
QuadClass bigint,
GoldsteinScale double precision,
NumMentions bigint,
NumSources bigint,
NumArticles bigint,
AvgTone double precision,
Actor1Geo_Type bigint,
Actor1Geo_FullName varchar(256),
Actor1Geo_CountryCode varchar(256),
Actor1Geo_ADM1Code varchar(256),
Actor1Geo_Lat double precision,
Actor1Geo_Long double precision,
Actor1Geo_FeatureID bigint,
Actor2Geo_Type bigint,
Actor2Geo_FullName varchar(256),
Actor2Geo_CountryCode varchar(256),
Actor2Geo_ADM1Code varchar(256),
Actor2Geo_Lat double precision,
Actor2Geo_Long double precision,
Actor2Geo_FeatureID bigint,
ActionGeo_Type bigint,
ActionGeo_FullName varchar(256),
ActionGeo_CountryCode varchar(256),
ActionGeo_ADM1Code varchar(256),
ActionGeo_Lat double precision,
ActionGeo_Long double precision,
ActionGeo_FeatureID bigint,
DATEADDED bigint
);
```
1. La seguente query carica i dati di esempio nella tabella `gdelt_data`.
```
COPY gdelt_data
FROM 's3://gdelt-open-data/events/1979.csv'
REGION 'us-east-1'
IAM_ROLE default
CSV
DELIMITER '\t';
```
### Verifica dei dati di addestramento (facoltativo)
Per vedere in base a quali dati verrà addestrato il modello, usa la seguente query.
```
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data LIMIT 100;
```
## Passaggio 2: creazione del modello di machine learning
Nell'esempio seguente viene utilizzato il comando CREATE MODEL per creare un modello che raggruppa i dati in sette cluster. Il valore K è il numero di cluster in cui sono suddivisi i punti dati. Il modello classifica i punti dati in cluster in cui i punti dati sono più simili tra loro. Suddividendo i punti dati in gruppi, l'algoritmo K-Means determina iterativamente il centroide del cluster migliore. L'algoritmo assegna quindi ogni punto dati al centroide del cluster più vicino. I membri più vicini allo stesso centroide del cluster appartengono allo stesso gruppo. I membri di un gruppo sono il più simili possibile agli altri membri dello stesso gruppo e il più possibile diversi dai membri di altri gruppi. Il valore K è soggettivo e dipende dai metodi che misurano le somiglianze tra i punti dati. È possibile modificare il valore K per uniformare le dimensioni dei cluster se i cluster sono distribuiti in modo non uniforme.
Nell’esempio seguente sostituisci amzn-s3-demo-bucket con il bucket Amazon S3.
```
CREATE MODEL news_data_clusters
FROM
(
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data
) FUNCTION news_monitoring_cluster
IAM_ROLE default
AUTO OFF
MODEL_TYPE KMEANS
PREPROCESSORS 'none'
HYPERPARAMETERS DEFAULT
EXCEPT
(K '7')
SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket');
```
### Verifica dello stato dell'addestramento del modello (facoltativo)
È possibile utilizzare il comando SHOW MODEL per verificare quando il modello è pronto.
Per verificare lo stato del modello, usa la seguente operazione SHOW MODEL e verifica se `Model State` è `Ready`.
```
SHOW MODEL NEWS_DATA_CLUSTERS;
```
Se il modello è pronto, l'output dell'operazione precedente dovrebbe indicare che `Model State` è `Ready`. Di seguito è riportato un esempio di output dell'operazione SHOW MODEL.
```
+--------------------------+------------------------------------------------------------------------------------------------------+
| Model Name | news_data_clusters |
+--------------------------+------------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Fri, 17.06.2022 16:32:19 |
| Model State | READY |
| train:msd | 2973.822754 |
| train:progress | 100.000000 |
| train:throughput | 237114.875000 |
| Estimated Cost | 0.004983 |
| | |
| TRAINING DATA: | |
| Query | SELECT AVGTONE, EVENTCODE, NUMARTICLES, ACTOR1GEO_LAT, ACTOR1GEO_LONG, ACTOR2GEO_LAT, ACTOR2GEO_LONG |
| | FROM GDELT_DATA |
| | |
| PARAMETERS: | |
| Model Type | kmeans |
| Training Job Name | redshiftml-20220617163219978978-kmeans |
| Function Name | news_monitoring_cluster |
| Function Parameters | avgtone eventcode numarticles actor1geo_lat actor1geo_long actor2geo_lat actor2geo_long |
| Function Parameter Types | float8 int8 int8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
| | |
| HYPERPARAMETERS: | |
| feature_dim | 7 |
| k | 7 |
+--------------------------+------------------------------------------------------------------------------------------------------+
```
## Passaggio 3: esecuzione di previsioni con il modello
### Identificazione dei cluster
È possibile trovare raggruppamenti discreti, noti anche come cluster, identificati nei dati dal modello. Un cluster è l'insieme di punti dati più vicini al centroide del cluster rispetto a qualsiasi altro centroide. Poiché il valore K rappresenta il numero di cluster nel modello, rappresenta anche il numero di centroidi del cluster. La seguente query identifica i cluster mostrando il cluster associato a ciascuno `globaleventid`.
```
SELECT
globaleventid,
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS cluster
FROM
gdelt_data;
```
### Verifica della distribuzione dei dati
Puoi controllare la distribuzione dei dati tra i cluster per vedere se il valore K scelto ha causato una distribuzione uniforme dei dati. Utilizza la seguente query per determinare se i dati sono distribuiti uniformemente tra i cluster.
```
SELECT
events_cluster,
COUNT(*) AS nbr_events
FROM
(
SELECT
globaleventid,
news_monitoring_cluster(
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster
FROM
gdelt_data
)
GROUP BY
1;
```
Nota: è possibile modificare il valore K per uniformare le dimensioni dei cluster se i cluster sono distribuiti in modo non uniforme.
### Determinazione dei centroidi dei cluster
Un punto dati è più vicino al relativo centroide del cluster rispetto a qualsiasi altro centroide. Pertanto, la ricerca dei centroidi consente di definire i cluster.
Esegui la seguente query per determinare i centroidi dei cluster in base al numero di articoli per codice evento.
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
eventcode,
SUM(numArticles) AS numArticles
FROM
gdelt_data
GROUP BY
1,
2;
```
### Visualizzazione delle informazioni sui punti dati in un cluster
Utilizza la seguente query per restituire i dati per i punti assegnati al quinto cluster. Gli articoli selezionati devono avere due soggetti.
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
eventcode,
actor1name,
actor2name,
SUM(numarticles) AS totalarticles
FROM
gdelt_data
WHERE
events_cluster = 5
AND actor1name <> ' '
AND actor2name <> ' '
GROUP BY
1,
2,
3,
4
ORDER BY
5 desc;
```
### Visualizzazione dei dati sugli eventi con soggetti aventi lo stesso codice etnico
La seguente query conteggia il numero di articoli scritti sugli eventi con un tono positivo. La query richiede inoltre che i due soggetti abbiano lo stesso codice etnico e restituisce il cluster a cui è assegnato ciascun evento.
```
SELECT
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS events_cluster,
SUM(numarticles) AS total_articles,
eventcode AS event_code,
Actor1EthnicCode AS ethnic_code
FROM
gdelt_data
WHERE
Actor1EthnicCode = Actor2EthnicCode
AND Actor1EthnicCode <> ' '
AND Actor2EthnicCode <> ' '
AND AvgTone > 0
GROUP BY
1,
3,
4
HAVING
(total_articles) > 4
ORDER BY
1,
2 ASC;
```
## Argomenti correlati
Per ulteriori informazioni su Amazon Redshift ML, fare riferimento ai seguenti collegamenti:
+ [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operazione CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:
+ [Panoramica del machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning per principianti ed esperti](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Che cos'è l'equità e la spiegabilità dei modelli per le previsioni di Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Creazione di modelli di classificazione multi-classe
In questo tutorial, utilizzi Amazon Redshift ML per creare un modello di machine learning che risolva i problemi di classificazione multi-classe. L'algoritmo di classificazione multi-classe classifica i punti dati in una delle tre o più classi. Implementerai quindi le query utilizzando la funzione SQL generata dal comando CREATE MODEL.
È possibile usare un comando CREATE MODEL per esportare i dati di addestramento, addestrare un modello, importare il modello e preparare una funzione di previsione Amazon Redshift. Usa l'istruzione CREATE MODEL per specificare i dati di addestramento come tabella o istruzione SELECT.
Per eseguire il tutorial, è possibile utilizzare il set di dati pubblico [E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast), che include i dati di vendita di un rivenditore online del Regno Unito. Il modello generato fa riferimento ai clienti più attivi per uno speciale programma di fidelizzazione dei clienti. Con la classificazione multi-classe, è possibile utilizzare il modello per prevedere per quanti mesi un cliente sarà attivo in un periodo di 13 mesi. La funzione di previsione individua i clienti che si prevede siano attivi per 7 o più mesi ai fini dell'ammissione al programma.
## Esempi di casi d'uso
Puoi risolvere altri problemi di classificazione multi-classe con Amazon Redshift ML, ad esempio la previsione relativa al prodotto più venduto di una linea di prodotti. Puoi anche prevedere quale frutto include un'immagine, ad esempio selezionando mele, pere o arance.
**Attività**
+ Prerequisiti
+ Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
+ Passaggio 2: creazione del modello di machine learning
+ Passaggio 3: esecuzione di previsioni con il modello
## Prerequisiti
Per completare questo tutorial, è necessario completare la [configurazione amministrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) di Amazon Redshift ML.
## Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
Utilizza l'[editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) per eseguire le seguenti query. Queste query caricano i dati di esempio in Amazon Redshift.
1. La query seguente crea una tabella denominata `ecommerce_sales`.
```
CREATE TABLE IF NOT EXISTS ecommerce_sales (
invoiceno VARCHAR(30),
stockcode VARCHAR(30),
description VARCHAR(60),
quantity DOUBLE PRECISION,
invoicedate VARCHAR(30),
unitprice DOUBLE PRECISION,
customerid BIGINT,
country VARCHAR(25)
);
```
1. La seguente query copia i dati di esempio dal [set di dati E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast) nella tabella `ecommerce_sales`.
```
COPY ecommerce_sales
FROM
's3://redshift-ml-multiclass/ecommerce_data.txt'
IAM_ROLE default
DELIMITER '\t'
IGNOREHEADER 1
REGION 'us-east-1'
MAXERROR 100;
```
### Suddivisione dei dati
Quando crei un modello in Amazon Redshift ML, l' SageMaker intelligenza artificiale divide automaticamente i dati in set di training e test, in modo che l' SageMaker intelligenza artificiale possa determinare la precisione del modello. Suddividendo manualmente i dati in questa fase, sarai in grado di verificare l'accuratezza del modello assegnando un set di previsione aggiuntivo.
Utilizza l'istruzione SQL seguente per suddividere i dati in tre set per l'addestramento, la convalida e la previsione.
```
--creates table with all data
CREATE TABLE ecommerce_sales_data AS (
SELECT
t1.stockcode,
t1.description,
t1.invoicedate,
t1.customerid,
t1.country,
t1.sales_amt,
CAST(RANDOM() * 100 AS INT) AS data_group_id
FROM
(
SELECT
stockcode,
description,
invoicedate,
customerid,
country,
SUM(quantity * unitprice) AS sales_amt
FROM
ecommerce_sales
GROUP BY
1,
2,
3,
4,
5
) t1
);
--creates training set
CREATE TABLE ecommerce_sales_training AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id < 80
);
--creates validation set
CREATE TABLE ecommerce_sales_validation AS (
SELECT
a.customerid,
a.country,
a.stockcode,
a.description,
a.invoicedate,
a.sales_amt,
(b.nbr_months_active) AS nbr_months_active
FROM
ecommerce_sales_data a
INNER JOIN (
SELECT
customerid,
COUNT(
DISTINCT(
DATE_PART(y, CAST(invoicedate AS DATE)) || '-' || LPAD(
DATE_PART(mon, CAST(invoicedate AS DATE)),
2,
'00'
)
)
) AS nbr_months_active
FROM
ecommerce_sales_data
GROUP BY
1
) b ON a.customerid = b.customerid
WHERE
a.data_group_id BETWEEN 80
AND 90
);
--creates prediction set
CREATE TABLE ecommerce_sales_prediction AS (
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
FROM
ecommerce_sales_data
WHERE
data_group_id > 90);
```
## Passaggio 2: creazione del modello di machine learning
In questo passaggio, si utilizza l'istruzione CREATE MODEL per creare il modello di machine learning utilizzando la classificazione multi-classe.
La seguente query crea il modello di classificazione multi-classe con il set di addestramento utilizzando l'operazione CREATE MODEL. Sostituisci amzn-s3-demo-bucket con il bucket Amazon S3.
```
CREATE MODEL ecommerce_customer_activity
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active
FROM
ecommerce_sales_training
) TARGET nbr_months_active FUNCTION predict_customer_activity IAM_ROLE default PROBLEM_TYPE MULTICLASS_CLASSIFICATION SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF
);
```
In questa query, specifica il tipo di problema come `Multiclass_Classification`. L'obiettivo previsto per il modello è `nbr_months_active`. Quando l' SageMaker intelligenza artificiale termina l'addestramento del modello`predict_customer_activity`, crea la funzione che utilizzerai per fare previsioni in Amazon Redshift.
### Visualizzazione dello stato dell'addestramento del modello (facoltativo)
È possibile utilizzare il comando SHOW MODEL per verificare quando il modello è pronto.
Utilizza la seguente query per restituire i vari parametri del modello, inclusi lo stato e la precisione.
```
SHOW MODEL ecommerce_customer_activity;
```
Se il modello è pronto, l'output dell'operazione precedente dovrebbe indicare che `Model State` è `Ready`. Di seguito è riportato un esempio di output dell'operazione SHOW MODEL.
```
+--------------------------+-----------------------------------------------------------------------------------------------+
| Model Name | ecommerce_customer_activity |
+--------------------------+-----------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Fri, 17.06.2022 19:02:15 |
| Model State | READY |
| Training Job Status | MaxAutoMLJobRuntimeReached |
| validation:accuracy | 0.991280 |
| Estimated Cost | 7.897689 |
| | |
| TRAINING DATA: | |
| Query | SELECT CUSTOMERID, COUNTRY, STOCKCODE, DESCRIPTION, INVOICEDATE, SALES_AMT, NBR_MONTHS_ACTIVE |
| | FROM ECOMMERCE_SALES_TRAINING |
| Target Column | NBR_MONTHS_ACTIVE |
| | |
| PARAMETERS: | |
| Model Type | xgboost |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220617190215268770 |
| Function Name | predict_customer_activity |
| Function Parameters | customerid country stockcode description invoicedate sales_amt |
| Function Parameter Types | int8 varchar varchar varchar varchar float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
+--------------------------+-----------------------------------------------------------------------------------------------+
```
## Passaggio 3: esecuzione di previsioni con il modello
La seguente query mostra quali clienti si qualificano per il programma di fidelizzazione. Se il modello prevede che il cliente sia attivo per almeno sette mesi, tale modello seleziona il cliente per il programma fedeltà.
```
SELECT
customerid,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active >= 7
GROUP BY
1,
2
LIMIT
10;
```
### Esecuzione di query di previsione sui dati di convalida (facoltativo)
Esegui le seguenti query di previsione sui dati di convalida per visualizzare il livello di precisione del modello.
```
SELECT
CAST(SUM(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(SUM(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(SUM(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt,
nbr_months_active,
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
CASE
WHEN nbr_months_active = predicted_months_active THEN 1
ELSE 0
END AS match,
CASE
WHEN nbr_months_active <> predicted_months_active THEN 1
ELSE 0
END AS nonmatch
FROM
ecommerce_sales_validation
)t1;
```
### Previsione del numero di clienti che non riescono a entrare (opzionale)
La seguente query confronta il numero di clienti che si prevede siano attivi solo per 5 o 6 mesi. Il modello prevede che questi clienti perdano l'iscrizione al programma fedeltà. La query confronta quindi l'importo mancante all'iscrizione al programma con il numero che si prevede sia idoneo per il programma fedeltà. Questa query potrebbe essere utilizzata per formulare una decisione relativa all'abbassamento della soglia per il programma fedeltà. Puoi anche determinare se esiste un numero significativo di clienti che si prevede non rientrino per poco nel programma. Potresti quindi incoraggiare questi clienti ad aumentare la loro attività per ottenere l''iscrizione al programma fedeltà.
```
SELECT
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) AS predicted_months_active,
COUNT(customerid)
FROM
ecommerce_sales_prediction
WHERE
predicted_months_active BETWEEN 5 AND 6
GROUP BY
1
ORDER BY
1 ASC
LIMIT
10)
UNION
(SELECT
NULL AS predicted_months_active,
COUNT (customerid)
FROM
ecommerce_sales_prediction
WHERE
predict_customer_activity(
customerid,
country,
stockcode,
description,
invoicedate,
sales_amt
) >=7);
```
## Argomenti correlati
Per ulteriori informazioni su Amazon Redshift ML, fare riferimento ai seguenti collegamenti:
+ [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operazione CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:
+ [Panoramica del machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning per principianti ed esperti](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Che cos'è l'equità e la spiegabilità dei modelli per le previsioni di Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: creazione di modelli XGBoost
In questo tutorial, crei un modello con i dati di Amazon S3 ed esegui query di previsione con il modello utilizzando Amazon Redshift ML. L' XGBoost algoritmo è un'implementazione ottimizzata dell'algoritmo Gradient Boosted Trees. XGBoost gestisce più tipi di dati, relazioni e distribuzioni rispetto ad altri algoritmi di alberi potenziati dal gradiente. È possibile utilizzarlo XGBoost per problemi di regressione, classificazione binaria, classificazione multiclasse e classificazione. Per ulteriori informazioni sull' XGBoostalgoritmo, consulta l'[XGBoostalgoritmo](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) nella Amazon SageMaker AI Developer Guide.
L'`CREATE MODEL`operazione Amazon Redshift ML con l'`AUTO OFF`opzione attualmente supporta XGBoost come. `MODEL_TYPE` È possibile fornire informazioni pertinenti come l'obiettivo e gli iperparametri come parte del comando `CREATE MODEL`, in base al caso d'uso specifico.
In questo tutorial utilizzerai [set di dati di autenticazione delle banconote](https://archive.ics.uci.edu/ml/datasets/banknote+authentication), che è un problema di classificazione binaria, per prevedere se una determinata banconota è autentica o contraffatta.
## Esempi di casi d'uso
Puoi risolvere altri problemi di classificazione binaria utilizzando Amazon Redshift ML, ad esempio prevedere se un paziente è sano o ha una malattia. Puoi anche prevedere se un'email è spam o meno.
**Attività**
+ Prerequisiti
+ Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
+ Passaggio 2: creazione del modello di machine learning
+ Passaggio 3: esecuzione di previsioni con il modello
## Prerequisiti
Per completare questo tutorial, è necessario completare la [configurazione amministrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) di Amazon Redshift ML.
## Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
Utilizza l'[editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) per eseguire le seguenti query.
La seguente query crea due tabelle, carica i dati da Amazon S3 e suddivide i dati in un set di addestramento e un set di test. Utilizzerai il set di addestramento per addestrare il modello e creare la funzione di previsione. Testerai quindi la funzione di previsione sul set di test.
```
--create training set table
CREATE TABLE banknoteauthentication_train(
variance FLOAT,
skewness FLOAT,
curtosis FLOAT,
entropy FLOAT,
class INT
);
--Load into training table
COPY banknoteauthentication_train
FROM
's3://redshiftbucket-ml-sagemaker/banknote_authentication/train_data/' IAM_ROLE default REGION 'us-west-2' IGNOREHEADER 1 CSV;
--create testing set table
CREATE TABLE banknoteauthentication_test(
variance FLOAT,
skewness FLOAT,
curtosis FLOAT,
entropy FLOAT,
class INT
);
--Load data into testing table
COPY banknoteauthentication_test
FROM
's3://redshiftbucket-ml-sagemaker/banknote_authentication/test_data/'
IAM_ROLE default
REGION 'us-west-2'
IGNOREHEADER 1
CSV;
```
## Passaggio 2: creazione del modello di machine learning
La seguente query crea il XGBoost modello in Amazon Redshift ML dal set di formazione creato nel passaggio precedente. Sostituisci `amzn-s3-demo-bucket` con `S3_BUCKET` per memorizzare i set di dati di input e altri artefatti Redshift ML.
```
CREATE MODEL model_banknoteauthentication_xgboost_binary
FROM
banknoteauthentication_train
TARGET class
FUNCTION func_model_banknoteauthentication_xgboost_binary
IAM_ROLE default
AUTO OFF
MODEL_TYPE xgboost
OBJECTIVE 'binary:logistic'
PREPROCESSORS 'none'
HYPERPARAMETERS DEFAULT
EXCEPT(NUM_ROUND '100')
SETTINGS(S3_BUCKET 'amzn-s3-demo-bucket');
```
### Visualizzazione dello stato dell'addestramento del modello (facoltativo)
È possibile utilizzare il comando SHOW MODEL per verificare quando il modello è pronto.
Utilizza la seguente query per monitorare lo stato di avanzamento dell'addestramento del modello.
```
SHOW MODEL model_banknoteauthentication_xgboost_binary;
```
Se il modello è `READY`, l'operazione SHOW MODEL fornisce anche il parametro `train:error`, come visualizzato nel seguente output di esempio. Il parametro `train:error` è un valore di precisione del modello contenente fino a sei cifre decimali. Un valore pari a 0 è il più preciso e un valore pari a 1 è il meno preciso.
```
+--------------------------+--------------------------------------------------+
| Model Name | model_banknoteauthentication_xgboost_binary |
+--------------------------+--------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 21.06.2022 19:07:35 |
| Model State | READY |
| train:error | 0.000000 |
| Estimated Cost | 0.006197 |
| | |
| TRAINING DATA: | |
| Query | SELECT * |
| | FROM "BANKNOTEAUTHENTICATION_TRAIN" |
| Target Column | CLASS |
| | |
| PARAMETERS: | |
| Model Type | xgboost |
| Training Job Name | redshiftml-20220621190735686935-xgboost |
| Function Name | func_model_banknoteauthentication_xgboost_binary |
| Function Parameters | variance skewness curtosis entropy |
| Function Parameter Types | float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 5400 |
| | |
| HYPERPARAMETERS: | |
| num_round | 100 |
| objective | binary:logistic |
+--------------------------+--------------------------------------------------+
```
## Passaggio 3: esecuzione di previsioni con il modello
### Verifica della precisione del modello
La seguente query di previsione utilizza la funzione di previsione creata nel passaggio precedente per verificare la precisione del modello. Esegui questa query sul set di test per assicurarti che il modello non sia eccessivamente uguale al set di addestramento. Questo tipo di corrispondenza è nota anche come overfitting; l'overfitting potrebbe far sì che il modello restituisca previsioni inaffidabili.
```
WITH predict_data AS (
SELECT
class AS label,
func_model_banknoteauthentication_xgboost_binary (variance, skewness, curtosis, entropy) AS predicted,
CASE
WHEN label IS NULL THEN 0
ELSE label
END AS actual,
CASE
WHEN actual = predicted THEN 1 :: INT
ELSE 0 :: INT
END AS correct
FROM
banknoteauthentication_test
),
aggr_data AS (
SELECT
SUM(correct) AS num_correct,
COUNT(*) AS total
FROM
predict_data
)
SELECT
(num_correct :: FLOAT / total :: FLOAT) AS accuracy
FROM
aggr_data;
```
### Previsione della quantità di banconote originali e contraffatte
La seguente query di previsione restituisce la quantità prevista di banconote originali e contraffatte nel set di test.
```
WITH predict_data AS (
SELECT
func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted
FROM
banknoteauthentication_test
)
SELECT
CASE
WHEN predicted = '0' THEN 'Original banknote'
WHEN predicted = '1' THEN 'Counterfeit banknote'
ELSE 'NA'
END AS banknote_authentication,
COUNT(1) AS count
FROM
predict_data
GROUP BY
1;
```
### Ricerca dell'osservazione media per una banconota originale e una contraffatta
La seguente query di previsione restituisce il valore medio di ciascuna caratteristica per le banconote che si prevede siano originali e contraffatte nel set di test.
```
WITH predict_data AS (
SELECT
func_model_banknoteauthentication_xgboost_binary(variance, skewness, curtosis, entropy) AS predicted,
variance,
skewness,
curtosis,
entropy
FROM
banknoteauthentication_test
)
SELECT
CASE
WHEN predicted = '0' THEN 'Original banknote'
WHEN predicted = '1' THEN 'Counterfeit banknote'
ELSE 'NA'
END AS banknote_authentication,
TRUNC(AVG(variance), 2) AS avg_variance,
TRUNC(AVG(skewness), 2) AS avg_skewness,
TRUNC(AVG(curtosis), 2) AS avg_curtosis,
TRUNC(AVG(entropy), 2) AS avg_entropy
FROM
predict_data
GROUP BY
1
ORDER BY
2;
```
## Argomenti correlati
Per ulteriori informazioni su Amazon Redshift ML, fare riferimento ai seguenti collegamenti:
+ [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operazione CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:
+ [Panoramica del machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning per principianti ed esperti](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Che cos'è l'equità e la spiegabilità dei modelli per le previsioni di Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Creazione di modelli di regressione
In questo tutorial, utilizzi Amazon Redshift ML per creare un modello di regressione basato sul machine learning ed eseguire query di previsione sul modello. I modelli di regressione consentono di prevedere risultati numerici, ad esempio il prezzo di un immobile o quante persone utilizzeranno il servizio di noleggio biciclette di una città. È possibile utilizzare il comando CREATE MODEL in Amazon Redshift con i dati di addestramento. Amazon Redshift ML compila quindi il modello, importa il modello addestrato in Redshift e prepara una funzione di previsione SQL. È possibile utilizzare la funzione di previsione nelle query SQL in Amazon Redshift.
In questo tutorial, utilizzerai Amazon Redshift ML per creare un modello di regressione che prevede il numero di persone che utilizzano il servizio di bike sharing della città di Toronto a qualsiasi ora del giorno. Gli input per il modello includono le festività e le condizioni meteorologiche. Si utilizzerà un modello di regressione, perché si desidera ottenere un risultato numerico per questo problema.
È possibile utilizzare il comando CREATE MODEL per esportare i dati di addestramento, addestrare un modello e rendere disponibile il modello in Amazon Redshift come funzione SQL. Usa l'istruzione CREATE MODEL per specificare i dati di addestramento come tabella o istruzione SELECT.
## Esempi di casi d'uso
Puoi risolvere altri problemi di regressione con Amazon Redshift ML, ad esempio la previsione del valore LTV (Lifetime Value) di un cliente. Puoi anche utilizzare Redshift ML per prevedere il prezzo più remunerativo e i ricavi risultanti di un prodotto.
**Attività**
+ Prerequisiti
+ Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
+ Passaggio 2: creazione del modello di machine learning
+ Passaggio 3: convalida del modello
## Prerequisiti
Per completare questo tutorial, è necessario completare la [configurazione amministrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) di Amazon Redshift ML.
## Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
Utilizza l'[editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) per eseguire le seguenti query.
1. È necessario creare tre tabelle per caricare i tre set di dati pubblici in Amazon Redshift. I set di dati sono [Toronto Bike Ridership Data](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/), [dati cronologici meteo](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html) e [dati cronologici delle festività](https://github.com/uWaterloo/Datasets/blob/master/Holidays/holidays.csv). Esegui la seguente query nell'editor di query Amazon Redshift per creare tabelle denominate `ridership`, `weather` e`holiday`.
```
CREATE TABLE IF NOT EXISTS ridership (
trip_id INT,
trip_duration_seconds INT,
trip_start_time timestamp,
trip_stop_time timestamp,
from_station_name VARCHAR(50),
to_station_name VARCHAR(50),
from_station_id SMALLINT,
to_station_id SMALLINT,
user_type VARCHAR(20)
);
CREATE TABLE IF NOT EXISTS weather (
longitude_x DECIMAL(5, 2),
latitude_y DECIMAL(5, 2),
station_name VARCHAR(20),
climate_id BIGINT,
datetime_utc TIMESTAMP,
weather_year SMALLINT,
weather_month SMALLINT,
weather_day SMALLINT,
time_utc VARCHAR(5),
temp_c DECIMAL(5, 2),
temp_flag VARCHAR(1),
dew_point_temp_c DECIMAL(5, 2),
dew_point_temp_flag VARCHAR(1),
rel_hum SMALLINT,
rel_hum_flag VARCHAR(1),
precip_amount_mm DECIMAL(5, 2),
precip_amount_flag VARCHAR(1),
wind_dir_10s_deg VARCHAR(10),
wind_dir_flag VARCHAR(1),
wind_spd_kmh VARCHAR(10),
wind_spd_flag VARCHAR(1),
visibility_km VARCHAR(10),
visibility_flag VARCHAR(1),
stn_press_kpa DECIMAL(5, 2),
stn_press_flag VARCHAR(1),
hmdx SMALLINT,
hmdx_flag VARCHAR(1),
wind_chill VARCHAR(10),
wind_chill_flag VARCHAR(1),
weather VARCHAR(10)
);
CREATE TABLE IF NOT EXISTS holiday (holiday_date DATE, description VARCHAR(100));
```
1. La seguente query consente di caricare i dati di esempio nelle tabelle create nella fase precedente.
```
COPY ridership
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/ridership/'
IAM_ROLE default
FORMAT CSV
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY weather
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/weather/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
COPY holiday
FROM
's3://redshift-ml-bikesharing-data/bike-sharing-data/holiday/'
IAM_ROLE default
FORMAT csv
IGNOREHEADER 1
DATEFORMAT 'auto'
TIMEFORMAT 'auto'
REGION 'us-west-2'
gzip;
```
1. La seguente query esegue trasformazioni sui set di dati `ridership` e `weather` per rimuovere distorsioni o anomalie. La rimozione di distorsioni e anomalie si traduce in una migliore precisione del modello. La query semplifica le tabelle creando due nuove viste denominate `ridership_view` e `weather_view`.
```
CREATE
OR REPLACE VIEW ridership_view AS
SELECT
trip_time,
trip_count,
TO_CHAR(trip_time, 'hh24') :: INT trip_hour,
TO_CHAR(trip_time, 'dd') :: INT trip_day,
TO_CHAR(trip_time, 'mm') :: INT trip_month,
TO_CHAR(trip_time, 'yy') :: INT trip_year,
TO_CHAR(trip_time, 'q') :: INT trip_quarter,
TO_CHAR(trip_time, 'w') :: INT trip_month_week,
TO_CHAR(trip_time, 'd') :: INT trip_week_day
FROM
(
SELECT
CASE
WHEN TRUNC(r.trip_start_time) < '2017-07-01' :: DATE THEN CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', r.trip_start_time)
)
ELSE DATE_TRUNC('hour', r.trip_start_time)
END trip_time,
COUNT(1) trip_count
FROM
ridership r
WHERE
r.trip_duration_seconds BETWEEN 60
AND 60 * 60 * 24
GROUP BY
1
);
CREATE
OR REPLACE VIEW weather_view AS
SELECT
CONVERT_TIMEZONE(
'US/Eastern',
DATE_TRUNC('hour', datetime_utc)
) daytime,
ROUND(AVG(temp_c)) temp_c,
ROUND(AVG(precip_amount_mm)) precip_amount_mm
FROM
weather
GROUP BY
1;
```
1. La seguente query crea una tabella che combina tutti gli attributi di input rilevanti da `ridership_view` e `weather_view` nella tabella `trip_data`.
```
CREATE TABLE trip_data AS
SELECT
r.trip_time,
r.trip_count,
r.trip_hour,
r.trip_day,
r.trip_month,
r.trip_year,
r.trip_quarter,
r.trip_month_week,
r.trip_week_day,
w.temp_c,
w.precip_amount_mm,CASE
WHEN h.holiday_date IS NOT NULL THEN 1
WHEN TO_CHAR(r.trip_time, 'D') :: INT IN (1, 7) THEN 1
ELSE 0
END is_holiday,
ROW_NUMBER() OVER (
ORDER BY
RANDOM()
) serial_number
FROM
ridership_view r
JOIN weather_view w ON (r.trip_time = w.daytime)
LEFT OUTER JOIN holiday h ON (TRUNC(r.trip_time) = h.holiday_date);
```
### Visualizzazione dei dati di esempio (facoltativo)
La seguente query mostra le voci della tabella. È possibile eseguire questa operazione per verificare che la tabella sia stata creata correttamente.
```
SELECT *
FROM trip_data
LIMIT 5;
```
Di seguito è riportato un esempio di output dell'operazione precedente.
```
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_time | trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 2017-03-21 22:00:00 | 47 | 22 | 21 | 3 | 17 | 1 | 3 | 3 | 1 | 0 | 0 | 1 |
| 2018-05-04 01:00:00 | 19 | 1 | 4 | 5 | 18 | 2 | 1 | 6 | 12 | 0 | 0 | 3 |
| 2018-01-11 10:00:00 | 93 | 10 | 11 | 1 | 18 | 1 | 2 | 5 | 9 | 0 | 0 | 5 |
| 2017-10-28 04:00:00 | 20 | 4 | 28 | 10 | 17 | 4 | 4 | 7 | 11 | 0 | 1 | 7 |
| 2017-12-31 21:00:00 | 11 | 21 | 31 | 12 | 17 | 4 | 5 | 1 | -15 | 0 | 1 | 9 |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
### Visualizzazione della correlazione tra gli attributi (facoltativo)
La determinazione della correlazione aiuta a misurare la forza dell'associazione tra gli attributi. Il livello di associazione può aiutarti a determinare cosa influisce sull'output di destinazione. In questo tutorial, l'output di destinazione è `trip_count`.
La query seguente crea o sostituisce la stored procedure `sp_correlation`. Si utilizza la stored procedure denominata `sp_correlation` per mostrare la correlazione tra un attributo e altri attributi in una tabella in Amazon Redshift.
```
CREATE OR REPLACE PROCEDURE sp_correlation(source_schema_name in varchar(255), source_table_name in varchar(255), target_column_name in varchar(255), output_temp_table_name inout varchar(255)) AS $$
DECLARE
v_sql varchar(max);
v_generated_sql varchar(max);
v_source_schema_name varchar(255)=lower(source_schema_name);
v_source_table_name varchar(255)=lower(source_table_name);
v_target_column_name varchar(255)=lower(target_column_name);
BEGIN
EXECUTE 'DROP TABLE IF EXISTS ' || output_temp_table_name;
v_sql = '
SELECT
''CREATE temp table '|| output_temp_table_name||' AS SELECT ''|| outer_calculation||
'' FROM (SELECT COUNT(1) number_of_items, SUM('||v_target_column_name||') sum_target, SUM(POW('||v_target_column_name||',2)) sum_square_target, POW(SUM('||v_target_column_name||'),2) square_sum_target,''||
inner_calculation||
'' FROM (SELECT ''||
column_name||
'' FROM '||v_source_table_name||'))''
FROM
(
SELECT
DISTINCT
LISTAGG(outer_calculation,'','') OVER () outer_calculation
,LISTAGG(inner_calculation,'','') OVER () inner_calculation
,LISTAGG(column_name,'','') OVER () column_name
FROM
(
SELECT
CASE WHEN atttypid=16 THEN ''DECODE(''||column_name||'',true,1,0)'' ELSE column_name END column_name
,atttypid
,''CAST(DECODE(number_of_items * sum_square_''||rn||'' - square_sum_''||rn||'',0,null,(number_of_items*sum_target_''||rn||'' - sum_target * sum_''||rn||
'')/SQRT((number_of_items * sum_square_target - square_sum_target) * (number_of_items * sum_square_''||rn||
'' - square_sum_''||rn||''))) AS numeric(5,2)) ''||column_name outer_calculation
,''sum(''||column_name||'') sum_''||rn||'',''||
''SUM(trip_count*''||column_name||'') sum_target_''||rn||'',''||
''SUM(POW(''||column_name||'',2)) sum_square_''||rn||'',''||
''POW(SUM(''||column_name||''),2) square_sum_''||rn inner_calculation
FROM
(
SELECT
row_number() OVER (order by a.attnum) rn
,a.attname::VARCHAR column_name
,a.atttypid
FROM pg_namespace AS n
INNER JOIN pg_class AS c ON n.oid = c.relnamespace
INNER JOIN pg_attribute AS a ON c.oid = a.attrelid
WHERE a.attnum > 0
AND n.nspname = '''||v_source_schema_name||'''
AND c.relname = '''||v_source_table_name||'''
AND a.atttypid IN (16,20,21,23,700,701,1700)
)
)
)';
EXECUTE v_sql INTO v_generated_sql;
EXECUTE v_generated_sql;
END;
$$ LANGUAGE plpgsql;
```
La seguente query mostra la correlazione tra la colonna di destinazione `trip_count` e altri attributi numerici nel set di dati.
```
call sp_correlation(
'public',
'trip_data',
'trip_count',
'tmp_corr_table'
);
SELECT
*
FROM
tmp_corr_table;
```
Di seguito è illustrato un esempio di output della precedente operazione `sp_correlation`.
```
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| trip_count | trip_hour | trip_day | trip_month | trip_year | trip_quarter | trip_month_week | trip_week_day | temp_c | precip_amount_mm | is_holiday | serial_number |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 1 | 0.32 | 0.01 | 0.18 | 0.12 | 0.18 | 0 | 0.02 | 0.53 | -0.07 | -0.13 | 0 |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
## Passaggio 2: creazione del modello di machine learning
1. La seguente query suddivide i dati in un set di addestramento e in un set di convalida assegnando l'80% del set di dati per l'addestramento e il 20% per la convalida. Il set di addestramento è l'input per il modello ML per identificare il miglior algoritmo possibile per il modello. Dopo aver creato il modello, utilizza il set di convalida per convalidare l'accuratezza del modello.
```
CREATE TABLE training_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
FROM
trip_data
WHERE
serial_number > (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
CREATE TABLE validation_data AS
SELECT
trip_count,
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday,
trip_time
FROM
trip_data
WHERE
serial_number <= (
SELECT
COUNT(1) * 0.2
FROM
trip_data
);
```
1. La seguente query crea un modello di regressione per prevedere il valore `trip_count` per qualsiasi data e ora di input. Nell’esempio seguente sostituisci amzn-s3-demo-bucket con il bucket S3.
```
CREATE MODEL predict_rental_count
FROM
training_data TARGET trip_count FUNCTION predict_rental_count
IAM_ROLE default
PROBLEM_TYPE regression
OBJECTIVE 'mse'
SETTINGS (
s3_bucket 'amzn-s3-demo-bucket',
s3_garbage_collect off,
max_runtime 5000
);
```
## Passaggio 3: convalida del modello
1. Utilizzare la seguente query per generare l'output relativo agli aspetti del modello e per trovare il parametro relativo all'errore quadratico medio nell'output. L'errore quadratico medio è un parametro di precisione standard per i problemi di regressione.
```
show model predict_rental_count;
```
1. Eseguire le seguenti query di previsione sui dati di convalida per confrontare il conteggio previsto con il conteggio effettivo dei viaggi.
```
SELECT
trip_time,
actual_count,
predicted_count,
(actual_count - predicted_count) difference
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
LIMIT
5;
```
1. La seguente query calcola l'errore quadratico medio e la relativa radice in base ai dati di convalida. Utilizzare l'errore quadratico medio e la relativa radice per misurare la distanza tra il target numerico previsto e la risposta numerica effettiva. Un modello ottimale è caratterizzato da un punteggio basso per entrambi i parametri. La seguente query restituisce il valore di entrambi i parametri.
```
SELECT
ROUND(
AVG(POWER((actual_count - predicted_count), 2)),
2
) mse,
ROUND(
SQRT(AVG(POWER((actual_count - predicted_count), 2))),
2
) rmse
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
);
```
1. La seguente query calcola l'errore percentuale nel conteggio dei viaggi per ogni durata del viaggio per la data 01/01/2017. La query ordina i tempi di viaggio dal momento con l'errore percentuale più basso a quello con la percentuale di errore più alta.
```
SELECT
trip_time,
CAST(ABS(((actual_count - predicted_count) / actual_count)) * 100 AS DECIMAL (7,2)) AS pct_error
FROM
(
SELECT
trip_time,
trip_count AS actual_count,
PREDICT_RENTAL_COUNT (
trip_hour,
trip_day,
trip_month,
trip_year,
trip_quarter,
trip_month_week,
trip_week_day,
temp_c,
precip_amount_mm,
is_holiday
) predicted_count
FROM
validation_data
)
WHERE
trip_time LIKE '2017-01-01 %%:%%:%%'
ORDER BY
2 ASC;
```
## Argomenti correlati
Per ulteriori informazioni su Amazon Redshift ML, fare riferimento ai seguenti collegamenti:
+ [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operazione CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:
+ [Panoramica del machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning per principianti ed esperti](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Che cos'è l'equità e la spiegabilità dei modelli per le previsioni di Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Creazione di modelli di regressione con Linear Learner
In questo tutorial, crei un modello basato sull'algoritmo Linear Learner con i dati di Amazon S3 ed esegui query di previsione con il modello utilizzando Amazon Redshift ML. L'algoritmo SageMaker AI linear learner risolve problemi di regressione o di classificazione multiclasse. Per ulteriori informazioni sulla regressione e sui problemi di classificazione multiclasse, consulta [Tipi di problemi per i paradigmi di apprendimento automatico nella](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) Amazon SageMaker AI Developer Guide. In questo tutorial, risolverai un problema di regressione. L'algoritmo Linear Learner addestra molti modelli in parallelo e determina automaticamente il modello più ottimizzato. Utilizzi l'operazione CREATE MODEL in Amazon Redshift, che crea il tuo modello lineare di apprendimento utilizzando l' SageMaker intelligenza artificiale e invia una funzione di previsione ad Amazon Redshift. Per ulteriori informazioni sull'algoritmo Linear Learner, consulta [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) nella Amazon SageMaker AI Developer Guide.
È possibile usare un comando CREATE MODEL per esportare i dati di addestramento, addestrare un modello, importare il modello e preparare una funzione di previsione Amazon Redshift. Usa l'istruzione CREATE MODEL per specificare i dati di addestramento come tabella o istruzione SELECT.
I modelli Linear Learner ottimizzano obiettivi continui o obiettivi discreti. Gli obiettivi continui vengono utilizzati per la regressione, mentre le variabili discrete vengono utilizzate per la classificazione. Alcuni metodi forniscono una soluzione solo per obiettivi continui, come il metodo di regressione. L'algoritmo Linear Learner garantisce un incremento della velocità con le tecniche di ottimizzazione di tipo Naive degli iperparametri, ad esempio la tecnica Naive Bayes. Una tecnica di ottimizzazione di tipo Naive presuppone che ogni variabile di input sia indipendente. Per utilizzare l'algoritmo Linear Learner, è necessario specificare colonne che rappresentano le dimensioni degli input e righe che rappresentano le osservazioni. Per ulteriori informazioni sull'algoritmo Linear Learner, consulta [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) nella Amazon SageMaker AI Developer Guide.
In questo tutorial, costruisci un modello Linear Learner che prevede l'età dell'abalone. Utilizzerai il comando CREATE MODEL con il [set di dati relativo agli abaloni](http://archive.ics.uci.edu/ml/datasets/Abalone) per determinare la relazione tra le misure fisiche dell'abalone. Userai quindi il modello per determinare l'età dell'abalone.
## Esempi di casi d'uso
Puoi risolvere altri problemi di regressione con la funzionalità Linear Learner e Amazon Redshift ML, come la previsione del prezzo di un immobile. Puoi anche utilizzare Redshift ML per prevedere il numero di persone che utilizzeranno il servizio di noleggio di biciclette di una città.
**Attività**
+ Prerequisiti
+ Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
+ Passaggio 2: creazione del modello di machine learning
+ Passaggio 3: convalida del modello
## Prerequisiti
Per completare questo tutorial, è necessario completare la [configurazione amministrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) di Amazon Redshift ML.
## Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
Utilizza l'[editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) per eseguire le seguenti query. Queste query caricano i dati di esempio in Redshift e li suddividono in un set di addestramento e un set di convalida.
1. La query seguente crea una tabella `abalone_dataset`.
```
CREATE TABLE abalone_dataset (
id INT IDENTITY(1, 1),
Sex CHAR(1),
Length float,
Diameter float,
Height float,
Whole float,
Shucked float,
Viscera float,
Shell float,
Rings integer
);
```
1. La seguente query copia i dati di esempio dal [set di dati relativo agli abaloni](http://archive.ics.uci.edu/ml/datasets/Abalone) in Amazon S3 nella tabella `abalone_dataset` creata in precedenza in Amazon Redshift.
```
COPY abalone_dataset
FROM
's3://redshift-ml-multiclass/abalone.csv' REGION 'us-east-1' IAM_ROLE default CSV IGNOREHEADER 1 NULL AS 'NULL';
```
1. Suddividendo manualmente i dati, sarai in grado di verificare l'accuratezza del modello assegnando un set di previsione aggiuntivo. La seguente query suddivide i dati in due set. La tabella `abalone_training` è destinata all'allenamento, mentre la tabella `abalone_validation` è destinata alla convalida.
```
CREATE TABLE abalone_training as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) < 8;
CREATE TABLE abalone_validation as
SELECT
*
FROM
abalone_dataset
WHERE
mod(id, 10) >= 8;
```
## Passaggio 2: creazione del modello di machine learning
In questo passaggio, si utilizza l'istruzione CREATE MODEL per creare il modello di machine learning con l'algoritmo Linear Learner.
La seguente query crea il modello Linear Learner con l'operazione CREATE MODEL utilizzando il bucket S3. Sostituisci amzn-s3-demo-bucket con il bucket S3.
```
CREATE MODEL model_abalone_ring_prediction
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS target_label
FROM
abalone_training
) TARGET target_label FUNCTION f_abalone_ring_prediction IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE REGRESSION OBJECTIVE 'MSE' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
MAX_RUNTIME 15000
);
```
### Visualizzazione dello stato dell'addestramento del modello (facoltativo)
È possibile utilizzare il comando SHOW MODEL per verificare quando il modello è pronto.
Utilizza la seguente query per monitorare lo stato di avanzamento dell'addestramento del modello.
```
SHOW MODEL model_abalone_ring_prediction;
```
Quando il modello è pronto, l'output dell'operazione precedente dovrebbe essere simile all'esempio seguente. Nota: l'output riporta il parametro `validation:mse`, che è l'errore quadratico medio. Userai un errore quadratico medio per convalidare la precisione del modello nella fase successiva.
```
+--------------------------+----------------------------------------------------------------------------------------------------+
| Model Name | model_abalone_ring_prediction |
+--------------------------+----------------------------------------------------------------------------------------------------+
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Thu, 30.06.2022 18:00:10 |
| Model State | READY |
| validation:mse | 4.168633 |
| Estimated Cost | 4.291608 |
| | |
| TRAINING DATA: | |
| Query | SELECT SEX , LENGTH , DIAMETER , HEIGHT , WHOLE , SHUCKED , VISCERA , SHELL, RINGS AS TARGET_LABEL |
| | FROM ABALONE_TRAINING |
| Target Column | TARGET_LABEL |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | Regression |
| Objective | MSE |
| AutoML Job Name | redshiftml-20220630180010947843 |
| Function Name | f_abalone_ring_prediction |
| Function Parameters | sex length diameter height whole shucked viscera shell |
| Function Parameter Types | bpchar float8 float8 float8 float8 float8 float8 float8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```
## Passaggio 3: convalida del modello
1. La seguente query di previsione convalida l'accuratezza del modello nel set di dati `abalone_validation` calcolando l'errore quadratico medio e la relativa radice.
```
SELECT
ROUND(AVG(POWER((tgt_label - predicted), 2)), 2) mse,
ROUND(SQRT(AVG(POWER((tgt_label - predicted), 2))), 2) rmse
FROM
(
SELECT
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell,
Rings AS tgt_label,
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
) AS predicted,
CASE
WHEN tgt_label = predicted then 1
ELSE 0
END AS match,
CASE
WHEN tgt_label <> predicted then 1
ELSE 0
END AS nonmatch
FROM
abalone_validation
) t1;
```
L'output della precedente query dovrebbe essere simile all'output di esempio seguente. Il valore del parametro relativo all'errore quadratico medio deve essere simile al parametro `validation:mse` visualizzato nell'output dell'operazione SHOW MODEL.
```
+-----+--------------------+
| mse | rmse |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+
```
1. Utilizzare la seguente query per eseguire l'operazione EXPLAIN\$1MODEL sulla funzione di previsione. L'operazione restituirà un report sulla spiegabilità del modello. Per ulteriori informazioni sull'operazione EXPLAIN\$1MODEL, consultare [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html) nella Guida per sviluppatori di database di Amazon Redshift.
```
SELECT
EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
Le informazioni seguenti sono un esempio del report sulla spiegabilità del modello generato dalla precedente operazione EXPLAIN\$1MODEL. I valori per ciascuno degli input sono valori di Shapley. I valori di Shapley rappresentano l'effetto che ogni input ha sulla previsione del modello, con input di valore più elevato che hanno un impatto maggiore sulla previsione. In questo esempio, gli input di valore più elevato hanno un impatto maggiore sulla previsione dell'età dell'abalone.
```
{
"explanations": {
"kernel_shap": {
"label0": {
"expected_value" :10.290688514709473,
"global_shap_values": {
"diameter" :0.6856910187882492,
"height" :0.4415323937124035,
"length" :0.21507476107609084,
"sex" :0.448611774505744,
"shell" :1.70426496893776,
"shucked" :2.1181392924386994,
"viscera" :0.342220754059912,
"whole" :0.6711906974084011
}
}
}
},
"version" :"1.0"
};
```
1. Utilizzare la seguente query per calcolare la percentuale di previsioni corrette che il modello genera sugli abaloni non ancora maturi. Gli abaloni immaturi hanno 10 anelli o meno; una previsione corretta è accurata con un anello di scarto rispetto al numero effettivo di anelli.
```
SELECT
TRUNC(
SUM(
CASE
WHEN ROUND(
f_abalone_ring_prediction(
Sex,
Length,
Diameter,
Height,
Whole,
Shucked,
Viscera,
Shell
),
0
) BETWEEN Rings - 1
AND Rings + 1 THEN 1
ELSE 0
END
) / CAST(COUNT(SHELL) AS FLOAT),
4
) AS prediction_pct
FROM
abalone_validation
WHERE
Rings <= 10;
```
## Argomenti correlati
Per ulteriori informazioni su Amazon Redshift ML, fare riferimento ai seguenti collegamenti:
+ [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operazione CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:
+ [Panoramica del machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning per principianti ed esperti](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Che cos'è l'equità e la spiegabilità dei modelli per le previsioni di Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)
# Tutorial: Creazione di modelli di classificazione multi-classe con Linear Learner
In questo tutorial, crei un modello Linear Learner con i dati di Amazon S3, quindi esegui query di previsione con il modello utilizzando Amazon Redshift ML. L'algoritmo SageMaker AI linear learner risolve problemi di regressione o classificazione. Per ulteriori informazioni sulla regressione e sui problemi di classificazione multiclasse, consulta [Tipi di problemi per i paradigmi di apprendimento automatico nella](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) Amazon SageMaker AI Developer Guide. In questo tutorial, risolverai un problema di classificazione multi-classe. L'algoritmo Linear Learner addestra molti modelli in parallelo e determina automaticamente il modello più ottimizzato. Utilizzi l'operazione CREATE MODEL in Amazon Redshift, che crea il tuo modello lineare di apprendimento utilizzando l' SageMaker intelligenza artificiale e invia la funzione di previsione ad Amazon Redshift. Per ulteriori informazioni sull'algoritmo Linear Learner, consulta [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) nella Amazon SageMaker AI Developer Guide.
È possibile usare un comando CREATE MODEL per esportare i dati di addestramento, addestrare un modello, importare il modello e preparare una funzione di previsione Amazon Redshift. Usa l'istruzione CREATE MODEL per specificare i dati di addestramento come tabella o istruzione SELECT.
I modelli Linear Learner ottimizzano obiettivi continui o obiettivi discreti. Gli obiettivi continui vengono utilizzati per la regressione, mentre le variabili discrete vengono utilizzate per la classificazione. Alcuni metodi forniscono una soluzione solo per obiettivi continui, ad esempio un metodo di regressione. L'algoritmo Linear Learner garantisce un incremento della velocità con le tecniche di ottimizzazione di tipo Naive degli iperparametri, ad esempio la tecnica Naive Bayes. Una tecnica di ottimizzazione di tipo Naive presuppone che ogni variabile di input sia indipendente. L'algoritmo Linear Learner addestra molti modelli in parallelo e seleziona il modello più ottimizzato. Un algoritmo simile è XGBoost quello che combina le stime di una serie di modelli più semplici e più deboli per fare previsioni. Per ulteriori informazioni XGBoost, consulta l'[XGBoost algoritmo](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) nella Amazon SageMaker AI Developer Guide.
Per utilizzare l'algoritmo Linear Learner, è necessario specificare colonne che rappresentano le dimensioni degli input e righe che rappresentano le osservazioni. Per ulteriori informazioni sull'algoritmo Linear Learner, consulta [Linear Learner Algorithm](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) nella Amazon SageMaker AI Developer Guide.
In questo tutorial, costruisci un modello Linear Learner che prevede i tipi di copertura per una determinata area. Userai il comando CREATE MODEL con il [set di dati relativo al tipo di copertura](https://archive.ics.uci.edu/ml/datasets/covertype) disponibile nella pagina UCI Machine Learning Repository. Utilizzerai quindi la funzione di previsione creata dal comando per determinare i tipi di copertura in un'area naturale. Un tipo di copertura forestale è generalmente un tipo di albero. Gli input che Redshift ML utilizzerà per creare il modello includono il tipo di suolo, la distanza dalle strade e la designazione delle aree naturali. Per ulteriori informazioni sul set di dati, consulta il [set di dati relativo al tipo di copertura](https://archive.ics.uci.edu/ml/datasets/covertype) disponibile nella pagina UCI Machine Learning Repository.
## Esempi di casi d'uso
Puoi risolvere altri problemi di classificazione multi-classe con il modello Linear Learner di Amazon Redshift ML, ad esempio la previsione della specie di una pianta in base a un'immagine. Puoi anche prevedere la quantità di un prodotto che un cliente acquisterà.
**Attività**
+ Prerequisiti
+ Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
+ Passaggio 2: creazione del modello di machine learning
+ Passaggio 3: convalida del modello
## Prerequisiti
Per completare questo tutorial, è necessario completare la [configurazione amministrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) di Amazon Redshift ML.
## Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift
Utilizza l'[editor di query v2 di Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) per eseguire le seguenti query. Queste query caricano i dati di esempio in Redshift e li suddividono in un set di addestramento e un set di convalida.
1. La query seguente crea una tabella `covertype_data`.
```
CREATE TABLE public.covertype_data (
elevation bigint ENCODE az64,
aspect bigint ENCODE az64,
slope bigint ENCODE az64,
horizontal_distance_to_hydrology bigint ENCODE az64,
vertical_distance_to_hydrology bigint ENCODE az64,
horizontal_distance_to_roadways bigint ENCODE az64,
hillshade_9am bigint ENCODE az64,
hillshade_noon bigint ENCODE az64,
hillshade_3pm bigint ENCODE az64,
horizontal_distance_to_fire_points bigint ENCODE az64,
wilderness_area1 bigint ENCODE az64,
wilderness_area2 bigint ENCODE az64,
wilderness_area3 bigint ENCODE az64,
wilderness_area4 bigint ENCODE az64,
soil_type1 bigint ENCODE az64,
soil_type2 bigint ENCODE az64,
soil_type3 bigint ENCODE az64,
soil_type4 bigint ENCODE az64,
soil_type5 bigint ENCODE az64,
soil_type6 bigint ENCODE az64,
soil_type7 bigint ENCODE az64,
soil_type8 bigint ENCODE az64,
soil_type9 bigint ENCODE az64,
soil_type10 bigint ENCODE az64,
soil_type11 bigint ENCODE az64,
soil_type12 bigint ENCODE az64,
soil_type13 bigint ENCODE az64,
soil_type14 bigint ENCODE az64,
soil_type15 bigint ENCODE az64,
soil_type16 bigint ENCODE az64,
soil_type17 bigint ENCODE az64,
soil_type18 bigint ENCODE az64,
soil_type19 bigint ENCODE az64,
soil_type20 bigint ENCODE az64,
soil_type21 bigint ENCODE az64,
soil_type22 bigint ENCODE az64,
soil_type23 bigint ENCODE az64,
soil_type24 bigint ENCODE az64,
soil_type25 bigint ENCODE az64,
soil_type26 bigint ENCODE az64,
soil_type27 bigint ENCODE az64,
soil_type28 bigint ENCODE az64,
soil_type29 bigint ENCODE az64,
soil_type30 bigint ENCODE az64,
soil_type31 bigint ENCODE az64,
soil_type32 bigint ENCODE az64,
soil_type33 bigint ENCODE az64,
soil_type34 bigint ENCODE az64,
soil_type35 bigint ENCODE az64,
soil_type36 bigint ENCODE az64,
soil_type37 bigint ENCODE az64,
soil_type38 bigint ENCODE az64,
soil_type39 bigint ENCODE az64,
soil_type40 bigint ENCODE az64,
cover_type bigint ENCODE az64
) DISTSTYLE AUTO;
```
1. La seguente query copia i dati di esempio dal [set di dati relativo al tipo di copertura](https://archive.ics.uci.edu/ml/datasets/covertype) in Amazon S3 nella tabella `covertype_data` creata in precedenza in Amazon Redshift.
```
COPY public.covertype_data
FROM
's3://redshift-ml-multiclass/covtype.data.gz' IAM_ROLE DEFAULT gzip DELIMITER ',' REGION 'us-east-1';
```
1. Dividendo manualmente i dati, sarai in grado di verificare l'accuratezza del modello assegnando un set di test aggiuntivo. La seguente query suddivide i dati in tre set. La tabella `covertype_training` è destinata all'addestramento, la tabella `covertype_validation` alla convalida e la tabella `covertype_test` al test del modello. Userai il set di addestramento per addestrare il modello e il set di convalida per convalidare lo sviluppo del modello. Userai quindi il set di test per testare le prestazioni del modello e verificare se si è verificato l'overfitting o l'underfitting del modello rispetto al set di dati.
```
CREATE TABLE public.covertype_data_prep AS
SELECT
a.*,
CAST (random() * 100 AS int) AS data_group_id
FROM
public.covertype_data a;
--training dataset
CREATE TABLE public.covertype_training as
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id < 80;
--validation dataset
CREATE TABLE public.covertype_validation AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id BETWEEN 80
AND 89;
--test dataset
CREATE TABLE public.covertype_test AS
SELECT
*
FROM
public.covertype_data_prep
WHERE
data_group_id > 89;
```
## Passaggio 2: creazione del modello di machine learning
In questo passaggio, si utilizza l'istruzione CREATE MODEL per creare il modello di machine learning con l'algoritmo Linear Learner.
La seguente query crea il modello Linear Learner con l'operazione CREATE MODEL utilizzando il bucket S3. Sostituisci amzn-s3-demo-bucket con il bucket S3.
```
CREATE MODEL forest_cover_type_model
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type
from
public.covertype_training
) TARGET cover_type FUNCTION predict_cover_type IAM_ROLE default MODEL_TYPE LINEAR_LEARNER PROBLEM_TYPE MULTICLASS_CLASSIFICATION OBJECTIVE 'Accuracy' SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
S3_GARBAGE_COLLECT OFF,
MAX_RUNTIME 15000
);
```
### Visualizzazione dello stato dell'addestramento del modello (facoltativo)
È possibile utilizzare il comando SHOW MODEL per verificare quando il modello è pronto.
Utilizza la seguente query per monitorare lo stato di avanzamento dell'addestramento del modello.
```
SHOW MODEL forest_cover_type_model;
```
Quando il modello è pronto, l'output dell'operazione precedente dovrebbe essere simile all'esempio seguente. Nota: l'output riporta il parametro `validation:multiclass_accuracy`, visibile sul lato destro del seguente esempio. La precisione multi-classe misura la percentuale di punti dati classificati correttamente dal modello. Utilizzerai la precisione multi-classe per convalidare l'accuratezza del modello nel passaggio successivo.
```
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Key | Value |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| Model Name | forest_cover_type_model |
| Schema Name | public |
| Owner | awsuser |
| Creation Time | Tue, 12.07.2022 20:24:32 |
| Model State | READY |
| validation:multiclass_accuracy | 0.724952 |
| Estimated Cost | 5.341750 |
| | |
| TRAINING DATA: | |
| Query | SELECT ELEVATION, ASPECT, SLOPE, HORIZONTAL_DISTANCE_TO_HYDROLOGY, VERTICAL_DISTANCE_TO_HYDROLOGY, HORIZONTAL_DISTANCE_TO_ROADWAYS, HILLSHADE_9AM, HILLSHADE_NOON, HILLSHADE_3PM , HORIZONTAL_DISTANCE_TO_FIRE_POINTS, WILDERNESS_AREA1, WILDERNESS_AREA2, WILDERNESS_AREA3, WILDERNESS_AREA4, SOIL_TYPE1, SOIL_TYPE2, SOIL_TYPE3, SOIL_TYPE4, SOIL_TYPE5, SOIL_TYPE6, SOIL_TYPE7, SOIL_TYPE8, SOIL_TYPE9, SOIL_TYPE10 , SOIL_TYPE11, SOIL_TYPE12 , SOIL_TYPE13 , SOIL_TYPE14, SOIL_TYPE15, SOIL_TYPE16, SOIL_TYPE17, SOIL_TYPE18, SOIL_TYPE19, SOIL_TYPE20, SOIL_TYPE21, SOIL_TYPE22, SOIL_TYPE23, SOIL_TYPE24, SOIL_TYPE25, SOIL_TYPE26, SOIL_TYPE27, SOIL_TYPE28, SOIL_TYPE29, SOIL_TYPE30, SOIL_TYPE31, SOIL_TYPE32, SOIL_TYPE33, SOIL_TYPE34, SOIL_TYPE36, SOIL_TYPE37, SOIL_TYPE38, SOIL_TYPE39, SOIL_TYPE40, COVER_TYPE |
| | FROM PUBLIC.COVERTYPE_TRAINING |
| Target Column | COVER_TYPE |
| | |
| PARAMETERS: | |
| Model Type | linear_learner |
| Problem Type | MulticlassClassification |
| Objective | Accuracy |
| AutoML Job Name | redshiftml-20220712202432187659 |
| Function Name | predict_cover_type |
| Function Parameters | elevation aspect slope horizontal_distance_to_hydrology vertical_distance_to_hydrology horizontal_distance_to_roadways hillshade_9am hillshade_noon hillshade_3pm horizontal_distance_to_fire_points wilderness_area1 wilderness_area2 wilderness_area3 wilderness_area4 soil_type1 soil_type2 soil_type3 soil_type4 soil_type5 soil_type6 soil_type7 soil_type8 soil_type9 soil_type10 soil_type11 soil_type12 soil_type13 soil_type14 soil_type15 soil_type16 soil_type17 soil_type18 soil_type19 soil_type20 soil_type21 soil_type22 soil_type23 soil_type24 soil_type25 soil_type26 soil_type27 soil_type28 soil_type29 soil_type30 soil_type31 soil_type32 soil_type33 soil_type34 soil_type36 soil_type37 soil_type38 soil_type39 soil_type40 |
| Function Parameter Types | int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 int8 |
| IAM Role | default-aws-iam-role |
| S3 Bucket | amzn-s3-demo-bucket |
| Max Runtime | 15000 |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
## Passaggio 3: convalida del modello
1. La seguente query di previsione convalida l'accuratezza del modello sul set di dati `covertype_validation` mediante il calcolo della precisione multi-classe. La precisione multi-classe è la percentuale delle previsioni del modello corrette.
```
SELECT
CAST(sum(t1.match) AS decimal(7, 2)) AS predicted_matches,
CAST(sum(t1.nonmatch) AS decimal(7, 2)) AS predicted_non_matches,
CAST(sum(t1.match + t1.nonmatch) AS decimal(7, 2)) AS total_predictions,
predicted_matches / total_predictions AS pct_accuracy
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
Cover_type AS actual_cover_type,
predict_cover_type(
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40
) AS predicted_cover_type,
CASE
WHEN actual_cover_type = predicted_cover_type THEN 1
ELSE 0
END AS match,
CASE
WHEN actual_cover_type <> predicted_cover_type THEN 1
ELSE 0
END AS nonmatch
FROM
public.covertype_validation
) t1;
```
L'output della precedente query dovrebbe essere simile all'output di esempio seguente. Il valore del parametro di precisione multi-classe deve essere simile al parametro `validation:multiclass_accuracy` visualizzato nell'output dell'operazione SHOW MODEL.
```
+-------------------+-----------------------+-------------------+--------------+
| predicted_matches | predicted_non_matches | total_predictions | pct_accuracy |
+-------------------+-----------------------+-------------------+--------------+
| 41211 | 16324 | 57535 | 0.71627704 |
+-------------------+-----------------------+-------------------+--------------+
```
1. La seguente query prevede il tipo di copertina più comune per `wilderness_area2`. Questo set di dati include quattro aree naturali e sette tipi di copertura. Un'area naturale può avere più tipi di copertura.
```
SELECT t1. predicted_cover_type, COUNT(*)
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type
FROM public.covertype_test
WHERE wilderness_area2 = 1)
t1
GROUP BY 1;
```
L'output del comando precedente dovrebbe essere simile all'esempio seguente. Questo risultato indica che il modello ha previsto che la maggior parte delle coperture è di tipo 1 e sono presenti coperture di tipo 2 e 7.
```
+----------------------+-------+
| predicted_cover_type | count |
+----------------------+-------+
| 2 | 564 |
| 7 | 97 |
| 1 | 2309 |
+----------------------+-------+
```
1. La seguente query mostra il tipo di copertura più comune in una singola area naturale. La query visualizza la quantità del tipo di copertura specifico e l'area naturale associata al tipo di copertura.
```
SELECT t1. predicted_cover_type, COUNT(*), wilderness_area
FROM
(
SELECT
Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10 ,
Soil_Type11,
Soil_Type12 ,
Soil_Type13 ,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40,
predict_cover_type( Elevation,
Aspect,
Slope,
Horizontal_distance_to_hydrology,
Vertical_distance_to_hydrology,
Horizontal_distance_to_roadways,
HIllshade_9am,
Hillshade_noon,
Hillshade_3pm ,
Horizontal_Distance_To_Fire_Points,
Wilderness_Area1,
Wilderness_Area2,
Wilderness_Area3,
Wilderness_Area4,
soil_type1,
Soil_Type2,
Soil_Type3,
Soil_Type4,
Soil_Type5,
Soil_Type6,
Soil_Type7,
Soil_Type8,
Soil_Type9,
Soil_Type10,
Soil_Type11,
Soil_Type12,
Soil_Type13,
Soil_Type14,
Soil_Type15,
Soil_Type16,
Soil_Type17,
Soil_Type18,
Soil_Type19,
Soil_Type20,
Soil_Type21,
Soil_Type22,
Soil_Type23,
Soil_Type24,
Soil_Type25,
Soil_Type26,
Soil_Type27,
Soil_Type28,
Soil_Type29,
Soil_Type30,
Soil_Type31,
Soil_Type32,
Soil_Type33,
Soil_Type34,
Soil_Type36,
Soil_Type37,
Soil_Type38,
Soil_Type39,
Soil_Type40) AS predicted_cover_type,
CASE WHEN Wilderness_Area1 = 1 THEN 1
WHEN Wilderness_Area2 = 1 THEN 2
WHEN Wilderness_Area3 = 1 THEN 3
WHEN Wilderness_Area4 = 1 THEN 4
ELSE 0
END AS wilderness_area
FROM public.covertype_test)
t1
GROUP BY 1, 3
ORDER BY 2 DESC
LIMIT 1;
```
L'output del comando precedente dovrebbe essere simile all'esempio seguente.
```
+----------------------+-------+-----------------+
| predicted_cover_type | count | wilderness_area |
+----------------------+-------+-----------------+
| 2 | 15738 | 1 |
+----------------------+-------+-----------------+
```
## Argomenti correlati
Per ulteriori informazioni su Amazon Redshift ML, fare riferimento ai seguenti collegamenti:
+ [Costi per l'utilizzo di Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operazione CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Funzione EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)
Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:
+ [Panoramica del machine learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine learning per principianti ed esperti](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [Che cos'è l'equità e la spiegabilità dei modelli per le previsioni di Machine Learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)