Esempi di casi d'uso 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 Argomenti correlati

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 di apprendimento SageMaker lineare 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 Amazon Developer Guide. SageMaker 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'CREATEMODELoperazione in Amazon Redshift, che crea il tuo modello di apprendimento lineare utilizzando SageMaker e invia una funzione di previsione ad Amazon Redshift. Per ulteriori informazioni sull'algoritmo Linear Learner, consulta Linear Learner Algorithm nella Amazon SageMaker Developer Guide.

Puoi usare un CREATE MODEL comando per esportare dati di addestramento, addestrare un modello, importare il modello e preparare una funzione di previsione di Amazon Redshift. Usa l'CREATEMODELoperazione per specificare i dati di addestramento come tabella o dichiarazioneSELECT.

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 il Linear Learner Algorithm nella Amazon SageMaker Developer Guide.

In questo tutorial, costruisci un modello Linear Learner che prevede l'età dell'abalone. Usa il CREATE MODEL comando sul set di dati Abalone per determinare la relazione tra le misurazioni 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 di Amazon Redshift ML.

Passaggio 1: caricamento dei dati da Amazon S3 ad Amazon Redshift

Utilizza l'editor di query v2 di Amazon Redshift 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.

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
);

La seguente query copia i dati di esempio dal set di dati relativo agli abaloni 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';
```
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'CREATEMODEListruzione per creare il modello di apprendimento automatico con l'algoritmo lineare di apprendimento.

La seguente query crea il modello lineare di apprendimento con l'CREATEMODELoperazione utilizzando il bucket S3. Sostituisci amzn-s3-demo-bucket con il tuo 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 per sapere quando il modello è pronto. SHOW MODEL

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

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 della metrica dell'errore quadratico medio dovrebbe essere simile alla validation:mse metrica mostrata dall'output dell'SHOWMODELoperazione.


+-----+--------------------+
| mse |        rmse        |
+-----+--------------------+
| 5.1 | 2.2600000000000002 |
+-----+--------------------+

Utilizzate la seguente query per eseguire l'MODELoperazione EXPLAIN _ sulla funzione di previsione. L'operazione restituirà un report sulla spiegabilità del modello. Per ulteriori informazioni sull'MODELoperazione EXPLAIN _, consulta la MODELfunzione EXPLAIN _ nella Amazon Redshift Database Developer Guide.
```
SELECT
    EXPLAIN_MODEL ('model_abalone_ring_prediction');
```
Le seguenti informazioni sono un esempio del report sulla spiegabilità del modello prodotto dalla precedente EXPLAIN operazione _. MODEL 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" 
};
```

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:

Per ulteriori informazioni sul machine learning, consulta la documentazione seguente:

Avvertimento JavaScript è disabilitato o non è disponibile nel tuo browser.

Per usare la documentazione AWS, JavaScript deve essere abilitato. Consulta le pagine della guida del browser per le istruzioni.

Convenzioni dei documenti

Tutorial: Creazione di modelli di regressione

Tutorial: Creazione di modelli di classificazione multi-classe con Linear Learner