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/).
# Tutoriais para o Amazon Redshift ML
Você pode usar o Amazon Redshift ML para treinar modelos de machine learning usando instruções SQL e chamá-los em consultas SQL para previsão. Machine Learning no Amazon Redshift treina um modelo com um comando SQL. O Amazon Redshift inicia automaticamente um trabalho de treinamento no Amazon SageMaker AI e gera um modelo. Depois de criar um modelo, você pode realizar previsões no Amazon Redshift usando a função de previsão do modelo.
Siga as etapas desses tutoriais para saber mais sobre os recursos do Amazon Redshift ML:
+ [Tutorial: Como criar modelos de rotatividade de clientes](tutorial_customer_churn.md): neste tutorial, você usará o Amazon Redshift ML para criar um modelo de rotatividade de clientes com o comando CREATE MODEL e executar consultas de previsão para cenários de usuários. Em seguida, você implementa consultas usando a função SQL gerada pelo comando CREATE MODEL.
+ [Tutorial: Como construir modelos de clusterização K-means](tutorial_k-means_clustering.md): neste tutorial, você usará o Amazon Redshift ML para criar, treinar e implantar um modelo de machine learning com base no [algoritmo k-means](url-sm-dev;k-means.html).
+ [Tutorial: Como criar modelos de classificação multiclasse](tutorial_multi-class_classification.md): neste tutorial, você usará o Amazon Redshift ML para criar um modelo de machine learning que solucione problemas de classificação multiclasse. O algoritmo de classificação multiclasse enquadra os pontos de dados em uma das três ou mais classes. Em seguida, você implementa consultas usando a função SQL gerada pelo comando CREATE MODEL.
+ [Tutorial: Como construir modelos XGBoost](tutorial_xgboost.md): neste tutorial, você criará um modelo com dados do Amazon S3 e executará consultas de previsão com o modelo usando o Amazon Redshift ML. O algoritmo XGBoost é uma implementação otimizada do algoritmo baseado em árvores com aumento de gradiente.
+ [Tutorial: Como criar modelos de regressão](tutorial_regression.md): neste tutorial, você usará o Amazon Redshift ML para criar um modelo de regressão de machine learning e executar consultas de previsão no modelo. Os modelos de regressão permitem prever resultados numéricos, como o preço de uma casa ou quantas pessoas usarão o serviço de aluguel de bicicletas em uma cidade.
+ [Tutorial: Como construir modelos de regressão com o aprendizado linear](tutorial_linear_learner_regression.md): neste tutorial, você criará um modelo de aprendizado linear com dados do Amazon S3 e executará 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.
+ [Tutorial: Como criar modelos de classificação com aprendizado linear](tutorial_linear_learner_multi-class_classification.md): neste tutorial, você criará um modelo de aprendizado linear com dados do Amazon S3 e executará 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 classificação.
# Tutorial: Como criar modelos de rotatividade de clientes
Neste tutorial, você usará o Amazon Redshift ML para criar um modelo de rotatividade de clientes com o comando CREATE MODEL e executar consultas de previsão para cenários de usuários. Em seguida, você implementa consultas usando a função SQL gerada pelo comando CREATE MODEL.
Você pode usar um comando CREATE MODEL simples para exportar dados de treinamento, treinar um modelo, importar o modelo e preparar uma função de previsão do Amazon Redshift. Use a instrução CREATE MODEL para especificar dados de treinamento como uma tabela ou instrução SELECT.
Esse exemplo usa informações históricas para construir um modelo de machine learning de rotatividade de clientes de uma operadora de telefonia móvel. Primeiro, o SageMaker AI treina o modelo de machine learning e depois testa o modelo usando as informações de perfil de um cliente arbitrário. Após a validação do modelo, o Amazon SageMaker AI implanta o modelo e a função de previsão no Amazon Redshift. Você pode usar a função de previsão para prever se um cliente vai se desligar ou não.
## Exemplos de casos de uso
Você pode resolver outros problemas de classificação binária usando o Amazon Redshift ML, como prever se é possível ou não fechar um lead de vendas. Você também pode prever se uma transação financeira é fraudulenta ou não.
**Tarefas**
+ Pré-requisitos
+ Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
+ Etapa 2: Criar o modelo de machine learning
+ Etapa 3: Executar previsões com o modelo
## Pré-requisitos
Para concluir as etapas neste tutorial, você precisa atender aos seguintes pré-requisitos:
+ Você deve configurar um cluster do Amazon Redshift para o Amazon Redshift ML. Para isso, use a documentação [Definir cluster e configuração para administração do Amazon Redshift ML](https://docs.aws.amazon.com/redshift/latest/dg/admin-setup.html).
+ O cluster do Amazon Redshift que você usa para criar o modelo e o bucket do Amazon S3 usado para preparar os dados de treinamento e os artefatos do modelo devem estar na mesma região da AWS.
+ Para baixar os comandos SQL e o conjunto de dados de exemplo usados nessa documentação, siga um destes procedimentos:
+ Baixe os [Comandos SQL](https://s3.amazonaws.com/redshift-downloads/redshift-ml/tutorial-scripts/redshift-ml-tutorial.sql), o [Arquivo de atividade do cliente](https://s3.amazonaws.com/redshift-downloads/redshift-ml/customer_activity/customer_activity.csv) e o [Arquivo Abalone](https://s3.amazonaws.com/redshift-downloads/redshift-ml/abalone_xg/abalone.csv).
+ Usando a AWS CLI para Amazon S3, execute o comando a seguir. Você pode usar seu próprio caminho de destino.
```
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
```
## Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
Use o [editor de consultas v2 do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) para editar e executar consultas e visualizar resultados.
A execução das consultas a seguir cria um perfil chamado `customer_activity` e ingere o conjunto de dados de exemplo do 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;
```
## Etapa 2: Criar o modelo de machine learning
A rotatividade é nossa entrada de destino nesse modelo. Todas as outras entradas para o modelo são atributos que ajudam a criar uma função para prever a rotatividade.
O exemplo a seguir usa a operação CREATE MODEL para fornecer um modelo que prevê se um cliente estará ativo, usando entradas como idade, código postal, gastos e casos do cliente. No exemplo a seguir, substitua amzn-s3-demo-bucket por seu próprio bucket do 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'
);
```
A consulta SELECT no exemplo anterior cria os dados de treinamento. A cláusula TARGET especifica qual coluna é o “rótulo” de machine learning que CREATE MODEL usa para aprender a prever. A coluna de destino “rotatividade” indica se o cliente ainda tem uma associação ativa ou suspendeu a associação. O campo S3\$1BUCKET é o nome do bucket do Amazon S3 que você criou anteriormente. O bucket do Amazon S3 é usado para compartilhar dados e artefatos de treinamento entre o Amazon Redshift e o Amazon SageMaker AI. As colunas restantes são os recursos que são usados para a previsão.
Para obter um resumo da sintaxe e dos recursos de um caso de uso simples do comando CREATE MODEL, consulte [Simple CREATE MODEL](https://docs.aws.amazon.com/redshift/latest/dg/r_create_model_use_cases.html#r_simple_create_model) (CREATE MODEL simples).
### Adicionar permissões para criptografia do lado do servidor (opcional)
O Amazon Redshift usa por padrão o Amazon SageMaker AI Autopilot para treinamento. Observe, especificamente, que o Amazon Redshift exporta os dados de treinamento com segurança para o bucket do Amazon S3 especificado pelo cliente. Se você não especificar um `KMS_KEY_ID`, os dados serão criptografados usando a criptografia do lado do servidor SSE-S3 por padrão.
Se sua entrada for criptografada usando a criptografia do lado do servidor com uma chave gerenciada pelo AWS KMS (SSE-KMS), adicione as seguintes permissões:
```
{
"Effect": "Allow",
"Action": [
"kms:Encrypt"
"kms:Decrypt"
]
}
```
Para obter mais informações sobre os perfis do Amazon SageMaker AI, consulte [Como usar os perfis de execução do SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html) no *Guia do desenvolvedor do Amazon SageMaker AI*.
### Conferir o status do modelo de treinamento (opcional)
Você pode usar o comando SHOW MODEL para saber quando o modelo está pronto.
Use a operação a seguir para verificar o status do modelo.
```
SHOW MODEL customer_churn_auto_model;
```
Veja a seguir um exemplo de saída da operação anterior.
```
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
Ao concluir o treinamento do modelo, a variável `model_state` se tornará `Model is Ready` e a função de previsão se tornará disponível.
## Etapa 3: Executar previsões com o modelo
Você pode usar instruções SQL para exibir as previsões feitas pelo respectivo modelo. Neste exemplo, a função de previsão criada pela operação CREATE MODEL é denominada `ml_fn_customer_churn_auto`. Os argumentos de entrada para a função de previsão correspondem aos tipos de recurso, como varchar para `state` e integer para `account_length`. A saída da função de previsão é do mesmo tipo que a coluna TARGET da instrução CREATE MODEL.
1. Como você treinou o modelo em dados anteriores a 1/1/2020, agora você usa a função de previsão no conjunto de testes. A consulta a seguir exibe as previsões sobre se os clientes cadastrados após 1.º/1/2020 passarão por rotatividade ou não.
```
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. O exemplo a seguir usa a mesma função de previsão para um caso de uso diferente. Neste caso, o Amazon Redshift prevê a proporção de rotatividade e não rotatividade entre clientes de diferentes estados onde a data de registro é posterior a 1.º/1/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. O exemplo a seguir usa a função de previsão para o caso de uso de previsão da porcentagem de clientes que se desligam em um estado. Neste caso, o Amazon Redshift prevê a porcentagem de rotatividade quando a data de registro é posterior a 1/1/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;
```
## Tópicos relacionados
Para obter mais informações sobre o Amazon Redshift ML, consulte a seguinte documentação:
+ [Custos para usar o 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)
+ [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)
# Tutorial: Como construir modelos de clusterização K-means
Neste tutorial, você usará o Amazon Redshift ML para criar, treinar e implantar um modelo de machine learning com base no [algoritmo K-means](url-sm-dev;k-means.html). Esse algoritmo resolve problemas de clusterização em que você deseja detectar agrupamentos nos dados. O K-means ajuda a agrupar dados que ainda não foram rotulados. Para saber mais sobre o clustering do k-means, consulte [Como funciona o clustering do k-means](https://docs.aws.amazon.com/sagemaker/latest/dg/algo-kmeans-tech-notes.html) no Guia do desenvolvedor do Amazon SageMaker AI.
Você usará uma operação CREATE MODEL para criar um modelo K-means com base em um cluster do Amazon Redshift. 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.
Neste tutorial, você usa o K-means no conjunto de dados [Banco de dados global de eventos, linguagem e tom (GDELT)](https://aws.amazon.com/public-datasets/gdelt/), que monitora notícias mundiais em todo o planeta, e os dados são armazenados a cada segundo, diariamente. O K-means agrupará eventos que tenham tom, atores ou locais semelhantes. Os dados são armazenados como vários arquivos no Amazon Simple Storage Service, em duas pastas diferentes. As pastas são históricas, que cobrem os anos de 1979 a 2013, e atualizações diárias, que cobrem os anos de 2013 e posteriores. Para este exemplo, usamos o formato histórico e trazemos dados de 1979.
## Exemplos de casos de uso
Você pode resolver outros problemas de clusterização com o Amazon Redshift ML, como agrupar clientes com hábitos de visualização semelhantes em um serviço de streaming. Você também pode usar o Redshift ML para prever o número ideal de centros de expedição para um serviço de entrega.
**Tarefas**
+ Pré-requisitos
+ Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
+ Etapa 2: Criar o modelo de machine learning
+ Etapa 3: Executar previsões com o modelo
## Pré-requisitos
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
1. Use o [editor de consultas v2 do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/query-editor-v2-using.html) para executar a consulta a seguir. A consulta descarta a tabela `gdelt_data` no esquema público, caso ela exista, e cria uma tabela com o mesmo nome no esquema público.
```
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. A consulta a seguir carrega os dados de exemplo na tabela `gdelt_data`.
```
COPY gdelt_data
FROM 's3://gdelt-open-data/events/1979.csv'
REGION 'us-east-1'
IAM_ROLE default
CSV
DELIMITER '\t';
```
### Examinar os dados de treinamento (opcional)
Para ver em quais dados seu modelo será treinado, use a consulta a seguir.
```
SELECT
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
FROM
gdelt_data LIMIT 100;
```
## Etapa 2: Criar o modelo de machine learning
O exemplo a seguir usa o comando CREATE MODEL para criar um modelo que agrupa os dados em sete clusters. O valor K é o número de clusters nos quais os pontos de dados são divididos. O modelo classifica os pontos de dados em clusters nos quais os pontos de dados são mais semelhantes entre si. Ao agrupar os pontos de dados em vários grupos, o algoritmo K-means determina iterativamente o melhor centro de cluster. Em seguida, o algoritmo atribui cada ponto de dados ao centro de cluster mais próximo. Os membros mais próximos do mesmo centro de cluster pertencem ao mesmo grupo. Os membros de um grupo são o mais semelhantes possível a outros membros do mesmo grupo e o mais diferentes possível de membros de outros grupos. O valor de K é subjetivo e depende de métodos que medem as semelhanças entre os pontos de dados. Você pode alterar o valor de K para suavizar os tamanhos do cluster se os clusters estiverem distribuídos de modo desigual.
No exemplo a seguir, substitua amzn-s3-demo-bucket por seu próprio bucket do 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');
```
### Conferir o status do modelo de treinamento (opcional)
Você pode usar o comando SHOW MODEL para saber quando o modelo está pronto.
Para verificar o status do modelo, use a operação SHOW MODEL a seguir e verifique se `Model State` é `Ready`.
```
SHOW MODEL NEWS_DATA_CLUSTERS;
```
Quando o modelo estiver pronto, a saída da operação anterior deverá mostrar que o `Model State` é `Ready`. Veja a seguir um exemplo de saída da operação anterior 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 |
+--------------------------+------------------------------------------------------------------------------------------------------+
```
## Etapa 3: Executar previsões com o modelo
### Identificar os clusters
Você pode encontrar agrupamentos discretos identificados nos dados pelo seu modelo, também conhecidos como clusters. Cluster é o conjunto de pontos de dados que está mais próximo do respectivo centro de cluster do que de qualquer outro centro de cluster. Como o valor K representa o número de clusters no modelo, ele também representa o número de centros de cluster. A consulta a seguir identifica os clusters mostrando o cluster associado a cada `globaleventid`.
```
SELECT
globaleventid,
news_monitoring_cluster (
AvgTone,
EventCode,
NumArticles,
Actor1Geo_Lat,
Actor1Geo_Long,
Actor2Geo_Lat,
Actor2Geo_Long
) AS cluster
FROM
gdelt_data;
```
### Conferir a distribuição dos dados
Você pode verificar a distribuição de dados entre clusters para ver se o valor K escolhido possibilitou que os dados fossem distribuídos de maneira uniforme. Use a consulta a seguir para determinar se os dados são distribuídos uniformemente pelos clusters.
```
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;
```
Você pode alterar o valor de K para nivelar o tamanho dos agrupamentos se os clusters estiverem distribuídos de forma desigual.
### Determinar os centros de cluster
Um conjunto de pontos de dados que está mais próximo do respectivo centro de cluster do que de qualquer outro centro de cluster. Por isso, encontrar os centros de cluster ajuda a definir os clusters.
Execute a consulta a seguir para determinar os centros dos clusters com base no número de artigos por código de 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;
```
### Mostrar informações sobre os pontos de dados em um cluster
Use a consulta a seguir para retornar os dados dos pontos atribuídos ao quinto cluster. Os artigos selecionados devem ter dois atores.
```
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;
```
### Mostrar dados sobre eventos com representantes do mesmo código étnico
A consulta a seguir conta o número de artigos escritos sobre eventos com um tom positivo. A consulta também exige que os dois atores tenham o mesmo código étnico e retorna a qual cluster cada evento está atribuído.
```
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;
```
## Tópicos relacionados
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)
# Tutorial: Como criar modelos de classificação multiclasse
Neste tutorial, você usa o Amazon Redshift ML para criar um modelo de machine learning que solucione problemas de classificação multiclasse. O algoritmo de classificação multiclasse enquadra os pontos de dados em uma das três ou mais classes. Em seguida, você implementa consultas usando a função SQL gerada pelo comando CREATE MODEL.
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.
Para acompanhar o tutorial, você usa o conjunto de dados público [E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast) (Previsão de vendas de comércio eletrônico), que inclui dados de vendas de um varejista on-line do Reino Unido. O modelo que você gerar terá como alvo os clientes mais ativos para um programa especial de fidelidade do cliente. Com a classificação multiclasse, você pode usar o modelo para prever por quantos meses um cliente ficará ativo em um período de 13 meses. A função de previsão designa clientes que devem estar ativos por sete ou mais meses para admissão no programa.
## Exemplos de casos de uso
Você pode resolver outros problemas de classificação multiclasse com o Amazon Redshift ML, como prever o produto mais vendido de uma linha de produtos. Você também pode prever quais frutas uma imagem contém, como selecionar maçãs, peras ou laranjas.
**Tarefas**
+ Pré-requisitos
+ Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
+ Etapa 2: Criar o modelo de machine learning
+ Etapa 3: Executar previsões com o modelo
## Pré-requisitos
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
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. Estas consultas carregam os dados de exemplo no Amazon Redshift.
1. A consulta a seguir cria uma tabela chamada `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. A consulta a seguir copia os dados de exemplo do [conjunto de dados E-Commerce Sales Forecast](https://www.kaggle.com/allunia/e-commerce-sales-forecast) para a tabela `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;
```
### Dividir os dados
Quando você cria um modelo no Amazon Redshift ML, o SageMaker AI divide automaticamente os dados em conjuntos de treinamento e teste, para que o SageMaker AI possa determinar a precisão do modelo. Ao dividir manualmente os dados nesta etapa, você poderá verificar a precisão do modelo alocando um conjunto de previsões adicional.
Use a instrução SQL a seguir para dividir os dados em três conjuntos para treinamento, validação e previsão.
```
--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);
```
## Etapa 2: Criar o modelo de machine learning
Nesta etapa, você usa a instrução CREATE MODEL para criar seu modelo de machine learning usando a classificação multiclasse.
A consulta a seguir cria o modelo de classificação multiclasse com o conjunto de treinamento usando a operação CREATE MODEL. Substitua amzn-s3-demo-bucket por seu próprio bucket do 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
);
```
Nessa consulta, você especifica o tipo de problema como `Multiclass_Classification`. O destino que você prevê para o modelo é `nbr_months_active`. Quando o SageMaker AI termina de treinar o modelo, ele cria a função `predict_customer_activity`, que você usará para fazer previsões no Amazon Redshift.
### Mostrar o status do modelo de treinamento (opcional)
Você pode usar o comando SHOW MODEL para saber quando o modelo está pronto.
Use a consulta a seguir para retornar várias métricas do modelo, incluindo o estado e a precisão.
```
SHOW MODEL ecommerce_customer_activity;
```
Quando o modelo estiver pronto, a saída da operação anterior deverá mostrar que o `Model State` é `Ready`. Veja a seguir um exemplo de saída da operação anterior 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 |
+--------------------------+-----------------------------------------------------------------------------------------------+
```
## Etapa 3: Executar previsões com o modelo
A consulta a seguir mostra quais clientes se qualificam para seu programa de fidelidade do cliente. Se o modelo previr que o cliente ficará ativo por pelo menos sete meses, então ele selecionará o cliente para o programa de fidelidade.
```
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;
```
### Executar consultas de previsão nos dados de validação (opcional)
Execute as consultas de previsão a seguir nos dados de validação para ver o nível de precisão do modelo.
```
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;
```
### Prever quantos clientes perderam a entrada (opcional)
A consulta a seguir compara o número de clientes que, segundo a previsão, ficarão ativos por apenas cinco ou seis meses. O modelo prevê que esses clientes perderão a oportunidade de serem incluídos no programa de fidelidade. A consulta então compara o número de clientes que quase conseguiram entrar no programa com o número previsto dos que estarão qualificados para o programa de fidelidade. Essa consulta pode ser usada para fundamentar uma decisão sobre se o limite do programa de fidelidade deve ou não ser reduzido. Você também pode determinar se há uma quantidade significativa de clientes que quase vão conseguir entrar no programa. Você pode então incentivar esses clientes a aumentar suas atividades para obter uma associação ao programa de fidelidade.
```
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);
```
## Tópicos relacionados
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)
# Tutorial: Como construir modelos XGBoost
Neste tutorial, você cria um modelo com dados do Amazon S3 e executa consultas de previsão com o modelo usando o Amazon Redshift ML. O algoritmo XGBoost é uma implementação otimizada do algoritmo baseado em árvores com aumento de gradiente. O XGBoost lida com mais tipos de dados, relacionamentos e distribuições do que outros algoritmos de árvores com aumento de gradiente. Você pode usar o XGBoost para regressão, classificação binária, classificação multiclasse e problemas de classificação. Para obter mais informações sobre o algoritmo XGBoost, consulte [Algoritmo XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) no Guia do desenvolvedor do Amazon SageMaker AI.
A operação `CREATE MODEL` do Amazon Redshift ML com a opção `AUTO OFF` no momento aceita o XGBoost como `MODEL_TYPE`. Você pode fornecer informações relevantes, como o objetivo e os hiperparâmetros, como parte do `CREATE MODEL`, com base em seu caso de uso.
Neste tutorial, use o [conjunto de dados banknote authentication](https://archive.ics.uci.edu/ml/datasets/banknote+authentication) (autenticação de cédulas), que é um problema de classificação binária para prever se determinada cédula é genuína ou falsificada.
## Exemplos de casos de uso
Você pode resolver outros problemas de classificação binária usando o Amazon Redshift ML, como prever se um paciente está saudável ou tem alguma doença. Você também pode prever se um e-mail é ou não spam.
**Tarefas**
+ Pré-requisitos
+ Etapa 1: Carregar dados do Amazon S3 para o Amazon Redshift
+ Etapa 2: Criar o modelo de machine learning
+ Etapa 3: Executar previsões com o modelo
## Pré-requisitos
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
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.
A consulta a seguir cria duas tabelas, carrega os dados do Amazon S3 e divide os dados em um conjunto de treinamento e um conjunto de testes. Você usará o conjunto de treinamento para treinar seu modelo e criar a função de previsão. Em seguida, você testará a função de previsão no conjunto de testes.
```
--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;
```
## Etapa 2: Criar o modelo de machine learning
A consulta a seguir cria o modelo XGBoost no Amazon Redshift ML com base no conjunto de treinamento que você criou na etapa anterior. Substitua `amzn-s3-demo-bucket` por seu próprio `S3_BUCKET`, que armazenará os conjuntos de dados de entrada e outros artefatos do 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');
```
### Mostrar o status do modelo de treinamento (opcional)
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_banknoteauthentication_xgboost_binary;
```
Se o modelo for `READY`, a operação SHOW MODEL também fornecerá a métrica `train:error`, conforme mostrado no exemplo de saída a seguir. A métrica `train:error` é uma medida de precisão de seu modelo que mede até seis casas decimais. O valor 0 é o mais preciso e o 1 é o menos 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 |
+--------------------------+--------------------------------------------------+
```
## Etapa 3: Executar previsões com o modelo
### Conferir a precisão do modelo
A consulta de previsão a seguir usa a função de previsão criada na etapa anterior para verificar a precisão do modelo. Execute essa consulta no conjunto de testes para verificar se o modelo não tem uma correspondência muito próxima do conjunto de treinamento. Essa correspondência próxima também é conhecida como sobreajuste, que pode levar o modelo a fazer previsões não confiáveis.
```
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;
```
### Prever a quantidade de cédulas originais e falsas
A consulta de previsão a seguir retorna a quantidade prevista de cédulas originais e falsas no conjunto de teste.
```
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;
```
### Encontrar a observação média de uma cédula original e uma falsificada
A consulta de previsão a seguir retorna o valor médio de cada recurso para cédulas que são previstas como originais e falsificadas no conjunto de teste.
```
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;
```
## Tópicos relacionados
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)
# Tutorial: Como criar modelos de regressão
Neste tutorial, você usa o Amazon Redshift ML para criar um modelo de regressão de machine learning e executar consultas de previsão no modelo. Os modelos de regressão permitem prever resultados numéricos, como o preço de uma casa ou quantas pessoas usarão o serviço de aluguel de bicicletas em uma cidade. Você usa o comando CREATE MODEL no Amazon Redshift com os dados de treinamento. Em seguida, o Amazon Redshift ML compila o modelo, importa o modelo treinado para o Redshift e prepara uma função de previsão SQL. Você pode usar a função de previsão em consultas SQL no Amazon Redshift.
Neste tutorial, você usará o Amazon Redshift ML para criar um modelo de regressão que prevê o número de pessoas que usam o serviço de compartilhamento de bicicletas da cidade de Toronto a qualquer hora do dia. As entradas para o modelo incluem feriados e condições climáticas. Você usará um modelo de regressão porque deseja um resultado numérico para esse problema.
Você pode usar o comando CREATE MODEL para exportar dados de treinamento, treinar e importar o modelo e disponibilizá-lo no Amazon Redshift como uma função SQL. Use a operação CREATE MODEL para especificar dados de treinamento como uma tabela ou instrução SELECT.
## Exemplos de casos de uso
Você pode resolver outros problemas de regressão com o Amazon Redshift ML, como prever o valor da vida útil de um cliente. Você também pode usar o Redshift ML para prever o preço mais lucrativo e a receita resultante de um produto.
**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
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
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.
1. Você deve criar três tabelas para carregar os três conjuntos de dados públicos no Amazon Redshift. Os conjuntos de dados são [Toronto Bike Ridership Data](https://open.toronto.ca/dataset/bike-share-toronto-ridership-data/) (Dados sobre usuários de bicicleta em Toronto), [historical weather data](https://climate.weather.gc.ca/historical_data/search_historic_data_e.html) (dados climáticos históricos) e [historical holidays data](https://github.com/uWaterloo/Datasets/blob/master/Holidays/holidays.csv) (dados históricos de feriados). Execute a consulta a seguir no editor de consultas do Amazon Redshift para criar tabelas com os nomes `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. A consulta a seguir carrega os dados de exemplo nas tabelas que você criou na etapa anterior.
```
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. A consulta a seguir executa transformações nos conjuntos de dados `ridership` e `weather` para remover vieses ou anomalias. A remoção de vieses e anomalias resulta em melhor precisão do modelo. A consulta simplifica as tabelas criando duas novas visualizações chamadas `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. A consulta a seguir cria uma tabela que combina todos os atributos de entrada relevantes de `ridership_view` e de `weather_view` na tabela `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);
```
### Visualizar os dados de exemplo (opcional)
A consulta a seguir mostra as entradas da tabela. Você pode executar essa operação para garantir se a tabela foi feita corretamente.
```
SELECT *
FROM trip_data
LIMIT 5;
```
Veja a seguir um exemplo de saída da operação anterior.
```
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
| 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 |
+---------------------+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
### Mostrar a correlação entre atributos (opcional)
Determinar a correlação ajuda a medir a consistência da associação entre os atributos. O nível de associação pode ajudar você a determinar o que afeta o resultado pretendido. Neste tutorial, o resultado pretendido é `trip_count`.
A consulta a seguir cria ou substitui o procedimento `sp_correlation`. Use o procedimento armazenado, denominado `sp_correlation`, para mostrar a correlação entre um atributo e outros atributos em uma tabela no 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;
```
A consulta a seguir mostra a correlação entre a coluna de destino, `trip_count`, e outros atributos numéricos em nosso conjunto de dados.
```
call sp_correlation(
'public',
'trip_data',
'trip_count',
'tmp_corr_table'
);
SELECT
*
FROM
tmp_corr_table;
```
Veja a seguir um exemplo de saída da operação anterior `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 |
+------------+-----------+----------+------------+-----------+--------------+-----------------+---------------+--------+------------------+------------+---------------+
```
## Etapa 2: Criar o modelo de machine learning
1. A consulta a seguir divide os dados em um conjunto de treinamento e um conjunto de validação, designando 80% do conjunto de dados para treinamento e 20% para validação. O conjunto de treinamento é a entrada para o modelo de ML que visa identificar o melhor algoritmo possível para o modelo. Depois que o modelo é criado, o conjunto de validação é usado para validar a precisão do modelo.
```
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. A consulta a seguir cria um modelo de regressão para prever o valor `trip_count` referente a qualquer data e hora de entrada. No exemplo a seguir, substitua amzn-s3-demo-bucket por seu próprio bucket do 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
);
```
## Etapa 3: Validar o modelo
1. Use a consulta a seguir para gerar aspectos do modelo e encontrar a métrica de erro quadrático médio na saída. O erro quadrático médio é uma métrica de precisão típica para problemas de regressão.
```
show model predict_rental_count;
```
1. Execute as consultas de previsão a seguir em relação aos dados de validação para comparar a contagem prevista com a contagem real de viagens.
```
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. A consulta a seguir calcula o erro quadrático médio e o erro quadrático médio da raiz com base nos dados de validação. O erro quadrático médio e o erro quadrático médio da raiz são usados para medir a distância entre o destino numérico previsto e a resposta numérica real. Um bom modelo tem uma pontuação baixa em ambas as métricas. A consulta a seguir retorna o valor de ambas as métricas.
```
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. A consulta a seguir calcula o erro percentual na contagem de viagens para cada tempo de viagem em 1.º/1/2017. A consulta ordena os tempos de viagem desde o momento com o menor erro percentual até o tempo com o erro percentual mais alto.
```
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;
```
## Tópicos relacionados
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)
# Tutorial: Como construir modelos de regressão com o aprendizado linear
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
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
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
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
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)
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
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
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)
# Tutorial: Como criar modelos de classificação com aprendizado linear
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 classificação. 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 classificação multiclasse. 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 aprendizagem linear usando o SageMaker AI e envia a função de previsão para o 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. O algoritmo de aprendizado linear treina muitos modelos em paralelo e seleciona o modelo mais otimizado. Um algoritmo semelhante é o XGBoost, que combina estimativas de um conjunto de modelos mais simples e mais fracos para fazer previsões. Para saber mais sobre o XGBoost, consulte [Algoritmo XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) no Guia do desenvolvedor do Amazon SageMaker AI.
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ê cria um modelo de aprendizado linear que prevê os tipos de cobertura florestal de determinada área. Use o comando CREATE MODEL no [conjunto de dados Covertype](https://archive.ics.uci.edu/ml/datasets/covertype) do UCI Machine Learning Repository. Em seguida, você usa a função de previsão criada pelo comando para determinar os tipos de cobertura de uma área selvagem. Um tipo de cobertura florestal geralmente é um tipo de árvore. As entradas que o Redshift ML usará para criar o modelo incluem o tipo de solo, a distância das estradas e a designação da área selvagem. Para obter mais informações sobre o conjunto de dados, consulte [Covertype Dataset](https://archive.ics.uci.edu/ml/datasets/covertype) (Conjunto de dados sobre tipo de cobertura) no UCI Machine Learning Repository.
## Exemplos de casos de uso
Você pode resolver outros problemas de classificação multiclasse com aprendizado linear por meio do Amazon Redshift ML, como prever a espécie de uma planta com base em uma imagem. Você também pode prever a quantidade de um produto que um cliente comprará.
**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
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
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 `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. A consulta a seguir copia os dados de exemplo do [conjunto de dados Covertype](https://archive.ics.uci.edu/ml/datasets/covertype) (Tipo de cobertura) no Amazon S3 para a tabela `covertype_data` que você criou anteriormente no Amazon Redshift.
```
COPY public.covertype_data
FROM
's3://redshift-ml-multiclass/covtype.data.gz' IAM_ROLE DEFAULT gzip DELIMITER ',' REGION 'us-east-1';
```
1. Ao dividir manualmente os dados nesta etapa, você poderá verificar a precisão do modelo alocando um conjunto adicional de testes. A consulta a seguir divide os dados em três conjuntos. Você usará a tabela `covertype_training` para treinamento, a tabela `covertype_validation` para validação e a tabela `covertype_test` para testar o modelo. Você usará o conjunto de treinamento para treinar o modelo e o conjunto de validação para validar o desenvolvimento do modelo. Em seguida, você usará o conjunto de testes para testar a performance do modelo e ver se o modelo está superajustando ou subajustando o conjunto de dados.
```
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;
```
## Etapa 2: Criar o modelo de machine learning
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 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
);
```
### Mostrar o status do modelo de treinamento (opcional)
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 forest_cover_type_model;
```
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:multiclass_accuracy`, que você pode ver no lado direito do exemplo a seguir. A precisão multiclasse mede a porcentagem de pontos de dados que são classificados corretamente pelo modelo. Você usará a precisão multiclasse para validar a exatidão do modelo na próxima etapa.
```
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
| 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 |
+--------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+
```
## Etapa 3: Validar o modelo
1. A consulta de previsão a seguir valida a precisão do modelo no conjunto de dados `covertype_validation` calculando a precisão multiclasse. A precisão multiclasse é a porcentagem das previsões do modelo que estão corretas.
```
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;
```
A saída do comando será semelhante à do exemplo a seguir. O valor da métrica de precisão multiclasse deve ser semelhante ao da métrica `validation:multiclass_accuracy` mostrada pela saída da operação SHOW MODEL.
```
+-------------------+-----------------------+-------------------+--------------+
| predicted_matches | predicted_non_matches | total_predictions | pct_accuracy |
+-------------------+-----------------------+-------------------+--------------+
| 41211 | 16324 | 57535 | 0.71627704 |
+-------------------+-----------------------+-------------------+--------------+
```
1. A consulta a seguir prevê o tipo de cobertura mais comum para `wilderness_area2`. Esse conjunto de dados inclui quatro áreas selvagens e sete tipos de cobertura. Uma área selvagem pode ter vários tipos de cobertura.
```
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;
```
A saída da operação anterior será semelhante à saída do exemplo a seguir. Essa saída significa que o modelo previu que a maioria das coberturas é do tipo 1, e há alguns tipos de cobertura 2 e 7.
```
+----------------------+-------+
| predicted_cover_type | count |
+----------------------+-------+
| 2 | 564 |
| 7 | 97 |
| 1 | 2309 |
+----------------------+-------+
```
1. A consulta a seguir mostra o tipo de cobertura mais comum em uma única área selvagem. A consulta exibe a quantidade desse tipo de cobertura e a respectiva área selvagem.
```
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;
```
A saída da operação anterior será semelhante à saída do exemplo a seguir.
```
+----------------------+-------+-----------------+
| predicted_cover_type | count | wilderness_area |
+----------------------+-------+-----------------+
| 2 | 15738 | 1 |
+----------------------+-------+-----------------+
```
## Tópicos relacionados
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)