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: Creazione di modelli di regressione con Linear Learner
<a name="tutorial_linear_learner_regression"></a>

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
<a name="tutorial_linear_learner_regression_tasks"></a>

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
<a name="tutorial_linear_learner_regression_prereqs"></a>

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
<a name="tutorial_linear_learner_regression_step_load_data"></a>

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
<a name="tutorial_linear_learner_regression_step_create_model"></a>

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)
<a name="tutorial_linear_learner_regression_show_status"></a>

È 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
<a name="tutorial_linear_learner_regression_step_validate"></a>

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
<a name="tutorial_linear_learner_regression_related_topics"></a>

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)