O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). 

# Tutorial: Como construir modelos de regressão com o aprendizado linear
<a name="tutorial_linear_learner_regression"></a>

Neste tutorial, você cria um modelo de aprendizado linear com dados do Amazon S3 e executa consultas de previsão com o modelo usando o Amazon Redshift ML. O algoritmo de aprendizagem linear do SageMaker AI resolve problemas de regressão ou de classificação multiclasse. Para saber mais sobre problemas de regressão e classificação multiclasse, consulte [Tipos de problemas para os paradigmas básicos de machine learning](https://docs.aws.amazon.com/sagemaker/latest/dg/algorithms-choose.html#basic-machine-learning-paradigms) no Guia do desenvolvedor do Amazon SageMaker AI. Neste tutorial, você resolve um problema de regressão. O algoritmo de aprendizado linear treina muitos modelos em paralelo e determina automaticamente o modelo mais otimizado. Use a operação CREATE MODEL no Amazon Redshift, que cria o modelo de aprendizado linear usando o SageMaker AI e envia uma função de previsão ao Amazon Redshift. Para obter mais informações sobre o algoritmo de aprendizagem linear, consulte [Algoritmo de Aprendizagem linear](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) no Guia do desenvolvedor do Amazon SageMaker AI.

Você pode usar um comando CREATE MODEL para exportar dados de treinamento, treinar um modelo, importar o modelo e preparar uma função de previsão do Amazon Redshift. Use a operação CREATE MODEL para especificar dados de treinamento como uma tabela ou instrução SELECT.

Os modelos de aprendizado linear otimizam objetivos contínuos ou objetivos discretos. Os objetivos contínuos são usados para regressão, enquanto as variáveis discretas são usadas para classificação. Alguns métodos fornecem uma solução apenas para objetivos contínuos, como o de regressão. O algoritmo de aprendizado linear possibilita um aumento de velocidade em relação às técnicas de otimização de hiperparâmetros nativas, como a técnica Naive Bayes. Uma técnica de otimização simples pressupõe que cada variável de entrada seja independente. Para usar o algoritmo de aprendizado linear, você deve fornecer colunas para representar as dimensões das entradas e linhas para representar as observações. Para obter mais informações sobre o algoritmo de aprendizagem linear, consulte [Algoritmo de Aprendizagem linear](https://docs.aws.amazon.com/sagemaker/latest/dg/linear-learner.html) no Guia do desenvolvedor do Amazon SageMaker AI. 

Neste tutorial, você constrói um modelo de aprendizado linear que prevê a idade de abalones. Você usa o comando CREATE MODEL no [conjunto de dados Abalone](http://archive.ics.uci.edu/ml/datasets/Abalone) para determinar a relação entre as medidas físicas do abalone. Em seguida, você usa o modelo para determinar a idade de abalones.

## Exemplos de casos de uso
<a name="tutorial_linear_learner_regression_tasks"></a>

Você pode resolver outros problemas de regressão com o aprendizado linear e o Amazon Redshift ML, como prever o preço de uma casa. Você também pode usar o Redshift ML para prever o número de pessoas que usarão o serviço de aluguel de bicicletas em uma cidade.

**Tarefas**
+ Pré-requisitos
+ Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
+ Etapa 2: Criar o modelo de machine learning
+ Etapa 3: Validar o modelo

## Pré-requisitos
<a name="tutorial_linear_learner_regression_prereqs"></a>

Para finalizar este tutorial, você deve concluir a [configuração administrativa](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html) do Amazon Redshift ML.

## Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
<a name="tutorial_linear_learner_regression_step_load_data"></a>

Use o [editor de consultas v2 do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) para executar as consultas a seguir. Essas consultas carregam os dados de exemplo no Redshift e os dividem em um conjunto de treinamento e um conjunto de validação.

1. A consulta a seguir cria a tabela `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. A consulta a seguir copia os dados de exemplo do [conjunto de dados Abalone](http://archive.ics.uci.edu/ml/datasets/Abalone) no Amazon S3 para a tabela `abalone_dataset` que você criou anteriormente no 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. Ao dividir manualmente os dados, você poderá verificar a precisão do modelo alocando um conjunto adicional de previsões. A consulta a seguir divide os dados em dois conjuntos. A tabela `abalone_training` destina-se ao treinamento e a tabela `abalone_validation`, à validação.

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

## Etapa 2: Criar o modelo de machine learning
<a name="tutorial_linear_learner_regression_step_create_model"></a>

Nesta etapa, você usa a instrução CREATE MODEL para criar o modelo de machine learning com o algoritmo de aprendizado linear. 

A consulta a seguir cria o modelo de aprendizado linear com a operação CREATE MODEL usando seu bucket do S3. Substitua amzn-s3-demo-bucket por seu próprio bucket do 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
    );
```

### Mostrar o status do modelo de treinamento (opcional)
<a name="tutorial_linear_learner_regression_show_status"></a>

Você pode usar o comando SHOW MODEL para saber quando o modelo está pronto.

Use a consulta a seguir para monitorar o andamento do treinamento do modelo.

```
SHOW MODEL model_abalone_ring_prediction;
```

Quando o modelo estiver pronto, a saída da operação anterior será semelhante à saída do exemplo a seguir. Observe que a saída fornece a métrica `validation:mse`, que é o erro quadrático médio. Você usará o erro quadrático médio para validar a precisão do modelo na próxima etapa.

```
+--------------------------+----------------------------------------------------------------------------------------------------+
|        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 |
+--------------------------+----------------------------------------------------------------------------------------------------+
```

## Etapa 3: Validar o modelo
<a name="tutorial_linear_learner_regression_step_validate"></a>

1. A consulta de previsão a seguir valida a precisão do modelo no conjunto de dados `abalone_validation` calculando o erro quadrático médio e o erro quadrático médio da raiz.

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

   A saída do comando será semelhante à do exemplo a seguir. O valor da métrica de erro quadrático médio deve ser semelhante ao da métrica `validation:mse` mostrada pela saída da operação SHOW MODEL.

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

1. Use a consulta a seguir para executar a operação EXPLAIN\$1MODEL na função de previsão. A operação retornará um relatório de explicabilidade do modelo. Para obter mais informações sobre a operação EXPLAIN\$1MODEL, consulte [Função EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html) no Guia do desenvolvedor de bancos de dados do Amazon Redshift.

   ```
   SELECT
       EXPLAIN_MODEL ('model_abalone_ring_prediction');
   ```

   As informações a seguir são um exemplo de relatório de explicabilidade do modelo produzido pela operação EXPLAIN\$1MODEL anterior. Os valores para cada uma das entradas são Shapley. Os valores Shapley representam o efeito que cada entrada tem na previsão do modelo. As entradas de valor mais alto têm mais impacto na previsão. Neste exemplo, as entradas de valor mais alto têm maior impacto na previsão de idade de abalones.

   ```
   { 
       "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. Use a consulta a seguir para calcular a porcentagem de previsões corretas realizadas pelo modelo sobre abalones que ainda não são adultos. Os abalones ainda prematuros têm dez anéis ou menos, e uma previsão correta do número real de anéis é um anel.

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

## Tópicos relacionados
<a name="tutorial_linear_learner_regression_related_topics"></a>

Para obter mais informações sobre o Amazon Redshift ML, consulte a seguinte documentação:
+ [Custos para usar o ML do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/dg/cost.html)
+ [Operação CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_CREATE_MODEL.html)
+ [Função EXPLAIN\$1MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_explain_model_function.html)

Para obter mais informações sobre machine learning, consulte a seguinte documentação:
+ [Visão geral do Machine Learning](https://docs.aws.amazon.com/redshift/latest/dg/machine_learning_overview.html)
+ [Machine Learning para iniciantes e especialistas](https://docs.aws.amazon.com/redshift/latest/dg/novice_expert.html)
+ [What Is Fairness and Model Explainability for Machine Learning Predictions? (O que é equidade e explicabilidade de modelo para previsões de machine learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html)