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/).
# Machine learning
O Amazon Redshift Machine Learning (Amazon Redshift ML) é um serviço robusto baseado em nuvem que ajuda analistas e cientistas de dados de todos os níveis de qualificação a usarem a tecnologia de Machine Learning. O Amazon Redshift ML usa um modelo para gerar resultados. É possível usar modelos das seguintes maneiras:
+ Você fornece os dados desejados para treinar um modelo e metadados associados a entradas de dados ao Amazon Redshift. Em seguida, o Amazon Redshift ML cria modelos no Amazon SageMaker AI que capturam padrões nos dados de entrada. Ao usar seus próprios dados para o modelo, você pode usar o Amazon Redshift ML para identificar tendências nos dados, como previsão de rotatividade, valor de permanência do cliente ou previsão de receita. Você pode usar esses modelos para gerar previsões para novos dados de entrada sem incorrer em custos adicionais.
+ É possível usar um dos modelos de base (FM) fornecidos pelo Amazon Bedrock, como Claude ou Amazon Titan. Usando o Amazon Bedrock, você pode combinar o poder dos grandes modelos de linguagem (LLMs) com data analytics no Amazon Redshift em apenas algumas etapas. Ao usar um grande modelo de linguagem (LLM) externo, você pode utilizar o Amazon Redshift para realizar processamento de linguagem natural (PLN) em seus dados. O PLN pode ser utilizado para aplicações como geração de texto, análise de sentimentos ou tradução. Para ter mais informações sobre como usar o Amazon Bedrock com o Amazon Redshift, consulte [Integração do Amazon Redshift ML com o Amazon Bedrock](machine-learning-br.md).
**nota**
**Optar por não usar seus dados para melhorar o serviço**
Se você estiver usando modelos do Amazon Bedrock, é recomendável ler as políticas da AWS sobre como o serviço Amazon Bedrock lida com seus dados. Você deve determinar se precisa usar uma política de cancelamento para evitar que o serviço use seus dados para melhorias no modelo ou no serviço, caso o Amazon Bedrock implemente essa funcionalidade no futuro. Para garantir que o serviço não use seus dados para essas finalidades, use a política geral de cancelamento da AWS.
Para saber mais, consulte:
[Políticas de recusa de serviços de IA](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_ai-opt-out.html)
[Perguntas frequentes sobre o Amazon Bedrock](https://aws.amazon.com/bedrock/faqs/)
**nota**
Os LLMs podem gerar informações imprecisas ou incompletas. Recomendamos verificar as informações que os LLMs produzem para garantir que sejam precisas e completas.
**Como o Amazon Redshift ML utiliza o Amazon SageMaker AI**
O Amazon Redshift utiliza o Amazon SageMaker AI Autopilot para obter automaticamente o melhor modelo e disponibilizar a função de previsão no Amazon Redshift.
O diagrama a seguir ilustra como o Amazon Redshift ML funciona.
![\[Fluxo de trabalho para integração do Amazon Redshift ML com o Amazon SageMaker AI Autopilot.\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/images/machine_learning_overview.png)
O fluxo de trabalho geral é o seguinte:
1. O Amazon Redshift exporta os dados de treinamento para o Amazon S3.
1. O Amazon SageMaker AI Autopilot pré-processa os dados de treinamento. O *pré-processamento* executa funções importantes, como a imputação de valores ausentes. Ele reconhece que certas colunas são categóricas (como o código postal), formata-as corretamente para treinamento e executa inúmeras outras tarefas. Escolher os melhores pré-processadores para aplicar no conjunto de dados de treinamento é um problema por si só, e o Amazon SageMaker AI Autopilot automatiza a respectiva solução.
1. O Amazon SageMaker AI Autopilot encontra o algoritmo e os hiperparâmetros do algoritmo que fornecem o modelo com as previsões mais precisas.
1. O Amazon Redshift registra a função de previsão como uma função SQL no cluster do Amazon Redshift.
1. Quando você executa instruções CREATE MODEL, o Amazon Redshift usa o Amazon SageMaker AI para treinamento. Portanto, há um custo associado para treinar seu modelo. Este é um item de linha separado para o Amazon SageMaker AI em seu faturamento da AWS. Você também paga pelo armazenamento usado no Amazon S3 para armazenar seus dados de treinamento. Não será cobrada a inferência que usa modelos criados com CREATE MODEL que podem ser compilados e executados no cluster do Amazon Redshift. Não há cobranças adicionais do Amazon Redshift para usar o Amazon Redshift ML.
**Topics**
+ [Visão geral do Machine Learning](machine_learning_overview.md)
+ [Machine Learning para iniciantes e especialistas](novice_expert.md)
+ [Custos para usar o Amazon Redshift ML](cost.md)
+ [Conceitos básicos do Amazon Redshift ML](getting-started-machine-learning.md)
+ [Tutoriais para o Amazon Redshift ML](tutorials_for_amazon_redshift_ml.md)
+ [Integração do Amazon Redshift ML com o Amazon Bedrock](machine-learning-br.md)
# Visão geral do Machine Learning
Com o Amazon Redshift, você pode aproveitar os recursos de machine learning para obter insights valiosos dos seus dados. Esta visão geral sobre machine learning (ML) mostra como explorar, visualizar e preparar seus dados para treinamento e implantação de um modelo de ML. As seções a seguir orientarão você pelo processo de utilização do Amazon Redshift ML para aproveitar o potencial de seus dados por meio de machine learning.
Usando o Amazon Redshift ML, é possível treinar modelos de Machine Learning usando instruções SQL e chamá-los em consultas SQL para previsão.
Para ajudá-lo a aprender a usar o Amazon Redshift ML, você pode assistir ao vídeo a seguir.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/pJF2kYGtO4A)
Para ter informações sobre os pré-requisitos para configurar clusters ou grupos de trabalho sem servidor, permissões e propriedade do Redshift para usar o Amazon Redshift ML, leia as seções a seguir. Essas seções também descrevem como o treinamento simples e as previsões funcionam no Amazon Redshift ML.
## Como o machine learning pode resolver seu problema
Um modelo de Machine Learning gera previsões encontrando padrões em seus dados de treinamento e aplicando esses padrões a novos dados. No Machine Learning, você treina esses modelos aprendendo os padrões que melhor explicam seus dados. Em seguida, você usa os modelos para fazer previsões (também chamadas inference) sobre novos dados. Machine Learning normalmente é um processo iterativo no qual você pode continuar a melhorar a precisão das previsões alterando os parâmetros e melhorando os dados de treinamento. Se os dados forem alterados, o novo treinamento de novos modelos com o novo conjunto de dados acontece.
Para atender a vários objetivos de negócios, existem diferentes abordagens fundamentais de Machine Learning.
### Aprendizado supervisionado no Amazon Redshift ML
O Amazon Redshift oferece suporte à aprendizagem supervisionada, que é a abordagem mais comum para análises empresariais avançadas. O aprendizado supervisionado é a abordagem preferida de Machine Learning quando você tem um conjunto estabelecido de dados e uma compreensão de como os dados de entrada específicos prevêem vários resultados de negócios. Esses resultados às vezes são chamados de rótulos. Em particular, seu conjunto de dados é uma tabela com atributos que compreendem feições (entradas) e destinos (saídas). Por exemplo, suponha que você tenha uma tabela que forneça a idade e o código postal para clientes passados e presentes. Suponha que você também tenha um campo “ativo” que seja true para clientes presentes e false para clientes que suspenderam sua associação. O objetivo do machine learning supervisionado é identificar os padrões de idade e código postal que levam à rotatividade de clientes, como representado por clientes cujos destinos são “False”. Você pode usar esse modelo para prever clientes com probabilidade de rotatividade, como suspender sua associação, e potencialmente oferecer incentivos de retenção.
O Amazon Redshift oferece suporte ao aprendizado supervisionado que inclui regressão, classificação binária e classificação multiclasse. Regressão refere-se ao problema da previsão de valores contínuos, como o gasto total dos clientes. Classificação binária refere-se ao problema de prever um de dois resultados, como prever se um cliente rotula ou não. Classificação multiclasse refere-se ao problema de prever um de muitos resultados, como prever o item que um cliente pode estar interessado. Analistas de dados e cientistas de dados podem usá-lo para executar o aprendizado supervisionado para lidar com problemas que vão desde previsão, personalização ou previsão de rotatividade de clientes. Também é possível usar o aprendizado supervisionado em problemas como previsão de quais vendas serão fechadas, previsão de receita, detecção de fraude e previsão de valor de vida do cliente.
### Aprendizado não supervisionado no Amazon Redshift ML
O aprendizado não supervisionado usa algoritmos de machine learning para analisar e agrupar dados de treinamento não rotulados. Os algoritmos detectam padrões ou agrupamentos ocultos. O objetivo é modelar a estrutura ou distribuição subjacente nos dados para saber mais sobre os dados.
O Amazon Redshift é compatível com o algoritmo de cluster K-Means para resolver um problema de aprendizado não supervisionado. Esse algoritmo resolve problemas de clusterização em que você deseja detectar agrupamentos nos dados. O algoritmo K-Means tenta encontrar agrupamentos discretos dentro dos dados. Os dados não classificados são agrupados e particionados de acordo com suas semelhanças e diferenças. Por meio do agrupamento, o algoritmo K-Means determina iterativamente os melhores centroides e atribui cada membro ao centroide mais próximo. Os membros mais próximos do mesmo centroide 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. Por exemplo, o algoritmo de clusterização K-Means pode ser usado para classificar cidades afetadas por uma pandemia ou classificar cidades de acordo com a popularidade dos produtos de consumo.
Ao usar o algoritmo K-Means, especifique uma entrada `k` que especifique o número de clusters a serem encontrados nos dados. A saída desse algoritmo é um conjunto de centroides k. Cada ponto de dados pertence a um dos clusters k mais próximos a ele. Cada cluster é descrito por seu centroide. Pode-se pensar no centroide como a média multidimensional do cluster. O algoritmo K-Means compara as distâncias para ver o quanto os clusters diferem uns dos outros. Uma distância maior geralmente indica uma diferença maior entre os clusters.
O pré-processamento dos dados é importante para o K-Means, pois garante que os recursos do modelo permaneçam na mesma escala e produzam resultados confiáveis. O Amazon Redshift é compatível com alguns pré-processadores K-Means para a instrução CREATE MODEL, como StandardScaler, MinMax e NumericPassThrough. Caso não queira aplicar nenhum pré-processamento para K-means, escolha NumericPassthrough explicitamente como um transformador. Para obter mais informações sobre como configurar parâmetros K-Means, consulte [CREATE MODEL com parâmetros K-MEANS](r_create_model_use_cases.md#r_k-means-create-model-parameters).
Para ajudá-lo a saber como realizar treinamento não supervisionado com o cluster K-Means, assista ao vídeo a seguir.
[](http://www.youtube.com/watch?v=https://www.youtube.com/embed/TFKgl5d0U_0)
## Termos e conceitos do Amazon Redshift ML
Os seguintes termos são usados para descrever alguns conceitos do Amazon Redshift ML:
+ *Machine Learning* no Amazon Redshift treina um modelo com um comando SQL. O Amazon Redshift ML e o Amazon SageMaker AI gerenciam todas as conversões de dados, permissões, uso de recursos e descoberta do modelo adequado.
+ *Treinamento* é a fase em que o Amazon Redshift cria um modelo de Machine Learning executando um subconjunto especificado de dados no modelo. O Amazon Redshift inicia automaticamente um trabalho de treinamento no Amazon SageMaker AI e gera um modelo.
+ A *previsão* (também chamada de *inferência*) é o uso do modelo em consultas SQL do Amazon Redshift para prever resultados. No momento da inferência, o Amazon Redshift usa uma função de previsão baseada em modelo como parte de uma consulta maior para produzir previsões. As previsões são calculadas no local, no cluster do Redshift, proporcionando assim alta taxa de transferência, baixa latência e nenhum custo adicional.
+ Com o *traga seu próprio modelo (BYOM)*, você pode usar um modelo treinado fora do Amazon Redshift com o Amazon SageMaker AI para inferência no banco de dados localmente no Amazon Redshift. O Amazon Redshift ML oferece suporte ao uso de BYOM para inferência local.
+ A *inferência local* é usada quando os modelos são pré-treinados no Amazon SageMaker AI, compilados pelo Amazon SageMaker AI Neo e localizados no Amazon Redshift ML. Para importar modelos compatíveis com inferência local para o Amazon Redshift, use o comando CREATE MODEL. O Amazon Redshift importa os modelos pré-treinados do SageMaker AI chamando o Amazon SageMaker AI Neo. Você compila o modelo lá e importa o modelo compilado para o Amazon Redshift. Use inferência local para uma velocidade mais rápida e custos mais baixos.
+ A *inferência remota* é usada quando o Amazon Redshift invoca um endpoint de modelo implantado no SageMaker AI. Ela oferece a flexibilidade de invocar todos os tipos de modelo personalizado e de modelo de aprendizado profundo, como modelos TensorFlow que você criou e implantou no Amazon SageMaker AI.
Os seguintes fatores também são importantes:
+ O *Amazon SageMaker* é um serviço de machine learning totalmente gerenciado. Com o Amazon SageMaker AI, cientistas de dados e desenvolvedores podem facilmente criar, treinar e implantar modelos diretamente em um ambiente hospedado pronto para produção. Para obter informações sobre o Amazon SageMaker, consulte [What is Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/whatis.html) no *Guia do desenvolvedor do Amazon SageMaker AI*.
+ O *Amazon SageMaker AI Autopilot* é um conjunto de recursos que treina e ajusta automaticamente os melhores modelos de machine learning para classificação ou regressão, com base em seus dados. Você mantém total controle e visibilidade. O Amazon SageMaker AI Autopilot aceita dados de entrada em formato tabular. O Amazon SageMaker AI Autopilot oferece limpeza e pré-processamento automáticos de dados, seleção automática de algoritmos para regressão linear, classificação binária e classificação multiclasse. Ele também comporta otimização automática de hiperparâmetros (HPO), treinamento distribuído, instância automática e seleção de tamanho de cluster. Para obter informações sobre o Amazon SageMaker AI Autopilot, consulte [Automate model development with Amazon SageMaker AI Autopilot](https://docs.aws.amazon.com/sagemaker/latest/dg/autopilot-automate-model-development.html) no *Guia do desenvolvedor do Amazon SageMaker AI*.
+ O *Amazon Bedrock* é um serviço totalmente gerenciado que oferece uma variedade de modelos de base (FMs) de alto desempenho das principais empresas de IA, como AI21 Labs, Anthropic, Cohere, Meta, Mistral AI, Stability AI e Amazon, por meio de uma única API, além de um amplo conjunto de recursos necessários para criar aplicações de IA generativa.
# Machine Learning para iniciantes e especialistas
Com o Amazon Redshift, você pode aproveitar os recursos de machine learning (ML) para extrair insights dos seus dados, seja você iniciante ou especialista em ML. Machine learning é um recurso do Amazon Redshift que permite criar, treinar e implantar modelos de ML usando comandos SQL, sem a necessidade de ampla expertise em ML ou engenharia de dados complexa.
As seções a seguir fornecem orientações sobre o processo de utilização de machine learning, possibilitando que você aproveite o potencial de seus dados com o Amazon Redshift.
O Amazon Redshift ML permite que você treine modelos com um único comando SQL CREATE MODEL. O comando CREATE MODEL cria um modelo que o Amazon Redshift usa para gerar previsões baseadas em modelos com construções SQL familiares.
O Amazon Redshift ML é especialmente útil quando você não tem experiência em Machine Learning, ferramentas, linguagens, algoritmos e APIs. Com o Amazon Redshift ML, você não precisa realizar o trabalho pesado que é necessário para integração com um serviço externo de Machine Learning. O Amazon Redshift poupa o tempo de formatar e mover dados, gerenciar controles de permissão ou criar integrações, fluxos de trabalho e scripts personalizados. Você pode usar facilmente algoritmos populares de Machine Learning e simplificar as necessidades de treinamento que exigem iteração frequente, desde o treinamento até a previsão. O Amazon Redshift descobre automaticamente o melhor algoritmo e ajusta o melhor modelo para o seu problema. Você pode fazer previsões dentro do cluster do Amazon Redshift sem precisar transferir os dados para fora do Amazon Redshift nem interagir e pagar por outro serviço.
O Amazon Redshift ML oferece suporte a analistas de dados e cientistas de dados no uso de machine learning. Também permite que especialistas em machine learning usem seus conhecimentos para orientar a instrução CREATE MODEL a usar apenas os aspectos especificados. Com isso, você pode acelerar o tempo necessário para que CREATE MODEL encontre o melhor candidato, melhore a precisão do modelo ou ambas as coisas.
A instrução CREATE MODEL oferece flexibilidade em como você pode especificar os parâmetros para o trabalho de treinamento. Essa flexibilidade permite que tanto iniciantes como especialistas de machine learning escolham os pré-processadores, algoritmos, tipos de problemas ou hiperparâmetros de sua preferência. Por exemplo, um usuário interessado na rotatividade de clientes pode especificar na instrução CREATE MODEL que o tipo de problema é uma classificação binária, o que funciona bem para rotatividade de clientes. Em seguida, a instrução CREATE MODEL restringe sua busca pelo melhor modelo em modelos de classificação binária. Mesmo com a escolha do usuário do tipo de problema, ainda há muitas opções com as quais a instrução CREATE MODEL pode trabalhar. Por exemplo, o CREATE MODEL descobre e aplica as melhores transformações de pré-processamento e descobre as melhores configurações de hiperparâmetro.
O Amazon Redshift ML facilita o treinamento ao encontrar automaticamente o melhor modelo usando o Amazon SageMaker AI Autopilot. Nos bastidores, o Amazon SageMaker AI Autopilot treina e ajusta automaticamente o melhor modelo de machine learning com base nos dados fornecidos. O Amazon SageMaker AI Neo compila o modelo de treinamento e o disponibiliza para previsão no cluster do Redshift. Quando você executa uma consulta de inferência de machine learning usando um modelo treinado, a consulta pode usar todos os recursos de processamento paralelo em massa do Amazon Redshift. Ao mesmo tempo, a consulta pode usar a previsão baseada em machine learning.
+ Como *iniciante em machine learning* com conhecimento geral de diferentes aspectos do machine learning, como pré-processadores, algoritmos e hiperparâmetros, use a instrução CREATE MODEL apenas para os aspectos especificados. Em seguida, você pode encurtar o tempo que CREATE MODEL precisa para encontrar o melhor candidato ou melhorar a precisão do modelo. Além disso, você pode aumentar o valor comercial das previsões introduzindo conhecimento de domínio adicional, como o tipo de problema ou o objetivo. Por exemplo, em um cenário de rotatividade de cliente, se o resultado “cliente não está ativo” for raro, o objetivo de F1 geralmente é preferido ao objetivo de Precisão. Como os modelos de alta precisão podem prever “o cliente está ativo” o tempo todo, isso resulta em alta precisão, mas pouco valor empresarial. Para obter informações sobre o objetivo F1, consulte [AutoMLJobObjective](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_AutoMLJobObjective.html) na *Referência de API do Amazon SageMaker AI*.
Para obter mais informações sobre as opções básicas para a instrução CREATE MODEL, consulte [CREATE MODEL simples](r_create_model_use_cases.md#r_simple_create_model).
+ Como um *Praticante avançado de Machine Learning*, você pode especificar o tipo de problema e os pré-processadores para certos recursos (mas não todos). Em seguida, a instrução CREATE MODEL segue suas sugestões sobre os aspectos especificados. Ao mesmo tempo, a instrução CREATE MODEL detecta automaticamente os melhores pré-processadores para os recursos restantes e os melhores hiperparâmetros. Para obter mais informações sobre como você pode restringir um ou mais aspectos do pipeline de treinamento, consulte [CREATE MODEL com orientação do usuário](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Como um *especialista em Machine Learning*, você pode assumir o controle total do treinamento e do ajuste de hiperparâmetros. Em seguida, a instrução CREATE MODEL não tenta detectar os pré-processadores, algoritmos e hiperparâmetros ideais porque você faz todas as escolhas. Para obter mais informações sobre como usar CREATE MODEL com AUTO OFF, consulte [Modelos CREATE XGBoost com AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Os *engenheiros de dados* podem trazer um modelo XGBoost pré-treinado para o Amazon SageMaker AI e importá-lo para o Amazon Redshift para inferência local. Com o traga seu próprio modelo (BYOM), você pode usar um modelo treinado fora do Amazon Redshift com o Amazon SageMaker AI para inferência no banco de dados localmente no Amazon Redshift. O Amazon Redshift ML oferece suporte ao uso de BYOM para inferência local ou remota.
Para obter mais informações sobre como usar a instrução CREATE MODEL para inferência local ou remota, consulte [Traga seu próprio modelo (BYOM): inferência local](r_create_model_use_cases.md#r_byom_create_model).
Como usuário do Amazon Redshift ML, você pode escolher qualquer uma das opções a seguir para treinar e implantar seu modelo:
+ Tipos de problema, consulte [CREATE MODEL com orientação do usuário](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Objetivos, consulte [CREATE MODEL com orientação do usuário](r_create_model_use_cases.md#r_user_guidance_create_model) ou [Modelos CREATE XGBoost com AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Tipos de modelo, consulte [Modelos CREATE XGBoost com AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Pré-processadores, consulte [CREATE MODEL com orientação do usuário](r_create_model_use_cases.md#r_user_guidance_create_model).
+ Hiperparâmetros, consulte [Modelos CREATE XGBoost com AUTO OFF](r_create_model_use_cases.md#r_auto_off_create_model).
+ Traga seu próprio modelo (BYOM), consulte [Traga seu próprio modelo (BYOM): inferência local](r_create_model_use_cases.md#r_byom_create_model).
# Custos para usar o Amazon Redshift ML
Com o Amazon Redshift, é possível aproveitar os recursos de machine learning para extrair insights de seus dados, sem a necessidade de uma ampla experiência em engenharia de dados ou machine learning. As seções a seguir descrevem os custos associados ao uso do Amazon Redshift ML e ajudam você a planejar e otimizar suas despesas, bem como a aproveitar essa avançada integração de machine learning.
## Custos para usar o Amazon Redshift ML com o SageMaker AI
O Amazon Redshift ML para SageMaker AI usa seus recursos de cluster existentes para previsão, de modo que você possa evitar cobranças adicionais do Amazon Redshift. Não há cobrança adicional do Amazon Redshift para criar ou usar um modelo. A previsão acontece no local, no cluster do Redshift, então não é necessário pagar mais, a menos que você precise redimensionar o cluster. O Amazon Redshift ML usa o Amazon SageMaker AI para treinar seu modelo, o que tem um custo adicional associado.
Não há cobrança adicional para funções de previsão executadas no seu cluster do Amazon Redshift. A instrução CREATE MODEL usa o Amazon SageMaker AI e incorre em um custo adicional. O custo aumenta com o número de células em seus dados de treinamento. O número de células é o produto do número de registros (nos horários de consulta de treinamento ou tabela) vezes o número de colunas. Por exemplo, quando uma consulta SELECT da instrução CREATE MODEL cria 10.000 registros e 5 colunas, o número de células que ela cria é 50.000.
Em alguns casos, os dados de treinamento produzidos pela consulta SELECT da instrução CREATE MODEL excedem o limite MAX\$1CELLS fornecido (ou o padrão 1 milhão, se você não forneceu um limite). Nesses casos, a instrução CREATE MODEL escolhe de modo aleatório aproximadamente MAX\$1CELLS (ou seja, os registros de “número de colunas” do conjunto de dados de treinamento). A instrução CREATE MODEL então executa o treinamento usando essas tuplas escolhidas aleatoriamente. A amostragem aleatória garante que o conjunto de dados de treinamento reduzido não tenha qualquer viés. Assim, definindo o MAX\$1CELLS, você pode controlar seus custos de treinamento.
Ao usar a instrução CREATE MODEL, você pode usar as opções MAX\$1CELLS e MAX\$1RUNTIVE para controlar os custos, o tempo e a precisão do modelo potencial.
MAX\$1RUNTIME especifica o tempo máximo que o treinamento pode levar no SageMaker AI quando a opção AUTO ON ou OFF é usada. Os trabalhos de treinamento geralmente concluem antes do MAX\$1RUNTIVE, dependendo do tamanho do conjunto de dados. Depois que um modelo é treinado, o Amazon Redshift faz um trabalho adicional em segundo plano para compilar e instalar seus modelos em seu cluster. Assim, CREATE MODEL pode demorar mais do que MAX\$1RUNTIVE. No entanto, MAX\$1RUNTIME limita a quantidade de computação e tempo usados no SageMaker AI para treinar seu modelo. Você pode verificar o status do seu modelo a qualquer momento usando SHOW MODEL.
Quando você executa CREATE MODEL com AUTO ON, o Amazon Redshift ML usa o SageMaker AI Autopilot para explorar de forma automática e inteligente diferentes modelos (ou candidatos) para encontrar o melhor. MAX\$1RUNTURE limita a quantidade de tempo e a computação gasta. Se MAX\$1RUNTIVE estiver definido muito baixo, talvez não haja tempo suficiente para explorar até mesmo um candidato. Se vir o erro “Candidato de piloto automático não tem modelos”, execute novamente o CREATE MODEL com um valor MAX\$1RUNTIVE maior. Para obter mais informações sobre esse parâmetro, consulte [MaxAutoMLJobRuntimeInSeconds](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AutoMLJobCompletionCriteria.html) na *Referência de API do Amazon SageMaker AI*.
Quando você executa CREATE MODEL com AUTO OFF, MAX\$1RUNTIME corresponde a um limite de tempo de execução do trabalho de treinamento no SageMaker AI. Os trabalhos de treinamento geralmente são concluídos mais cedo, dependendo do tamanho do conjunto de dados e de outros parâmetros usados, como num\$1rounds em MODEL\$1TYPE XGBOOST.
Você também pode controlar custos ou reduzir o tempo de treinamento especificando um valor MAX\$1CELLS menor ao executar CREATE MODEL. A *célula* é uma entrada no banco de dados. Cada linha corresponde a tantas células quanto existem colunas, que podem ser de largura fixa ou variável. MAX\$1CELLS limita o número de células e, portanto, o número de exemplos de treinamento usados para treinar seu modelo. Por padrão, MAX\$1CELLS é definido como 1 milhão de células. Reduzir MAX\$1CELLS diminui o número de linhas do resultado da consulta SELECT no CREATE MODEL que o Amazon Redshift exporta e envia ao SageMaker para treinar um modelo. Reduzindo MAX\$1CELLS, assim, reduz o tamanho do conjunto de dados usado para treinar modelos com AUTO ON e AUTO OFF. Essa abordagem ajuda a reduzir os custos e o tempo para treinar modelos. Para ver informações sobre treinamento e tempos de cobrança de um trabalho de treinamento específico, selecione **Trabalhos de treinamento** no Amazon SageMaker AI.
Aumentar MAX\$1RUNTIME e MAX\$1CELLS geralmente melhora a qualidade do modelo, permitindo que o SageMaker AI explore mais candidatos. Dessa forma, o SageMaker AI pode ter mais tempo para treinar cada candidato e usar mais dados para treinar modelos melhores. Se você quiser uma iteração ou exploração mais rápida do seu conjunto de dados, use MAX\$1RUNTIVE e MAX\$1CELLS inferiores. Se você quiser uma precisão aprimorada dos modelos, use MAX\$1RUNTIVE e MAX\$1CELLS superiores.
Para obter mais informações sobre os custos associados a vários números de celular e detalhes sobre o teste gratuito, consulte [Preços do Amazon Redshift](https://aws.amazon.com/redshift/pricing).
## Custos para usar o Amazon Redshift ML com o Amazon Bedrock
O uso do Amazon Redshift ML com o Amazon Bedrock gera custos adicionais. Para obter mais informações, consulte [Preço do Amazon Bedrock](https://aws.amazon.com/bedrock/pricing/).
# Conceitos básicos do Amazon Redshift ML
O Amazon Redshift ML facilita a criação, o treinamento e a implantação de modelos de Machine Learning usando comandos SQL familiares. Com o Amazon Redshift ML, você pode usar os dados no cluster do Redshift para treinar modelos com o Amazon SageMaker AI. Depois, os modelos são localizados e as previsões podem ser feitas em um banco de dados do Amazon Redshift. No momento, o Amazon Redshift ML é compatível com os seguintes algoritmos de machine learning: XGBoost (AUTO ON e OFF) e perceptron multicamada (AUTO ON), K-Means (AUTO OFF) e Linear Learner.
**Topics**
+ [Definir cluster e configuração para administração do Amazon Redshift ML](#admin-setup)
+ [Usar a explicabilidade do modelo com o Amazon Redshift ML](#clarify)
+ [Métricas de probabilidade do Amazon Redshift ML](#probability_metrics)
## Definir cluster e configuração para administração do Amazon Redshift ML
Antes de trabalhar com o Amazon Redshift ML, conclua a configuração do cluster e configure as permissões para usar o Amazon Redshift ML.
### Configuração de cluster para usar o Amazon Redshift ML
Antes de trabalhar com o Amazon Redshift ML, preencha os pré-requisitos a seguir.
Como administrador do Amazon Redshift, faça a configuração única a seguir para usar clusters provisionados pelo Amazon Redshift. Para usar o Amazon Redshift ML com o Amazon Redshift sem servidor, consulte [Getting started with Amazon Redshift Serverless](https://docs.aws.amazon.com/redshift/latest/gsg/new-user-serverless.html).
Para executar a configuração única do cluster para o Amazon Redshift ML
1. Crie um cluster do Amazon Redshift usando o Console de gerenciamento da AWS ou a AWS Command Line Interface (AWS CLI). Anexe a política do AWS Identity and Access Management (IAM) ao criar o cluster. Para ter mais informações sobre as permissões necessárias para usar o Amazon Redshift ML com o Amazon SageMaker, consulte [Permissões necessárias para usar o machine learning (ML) do Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#iam-permission-ml?).
1. Crie o perfil do IAM necessário para usar o Amazon Redshift ML realizando um dos seguintes procedimentos:
+ Para usar o SageMaker AI com o Amazon Redshift ML, crie um perfil do IAM com as políticas `AmazonS3FullAccess` e `AmazonSageMakerFullAccess`. Se você também planeja criar modelos do Forecast, anexe igualmente a política `AmazonForecastFullAccess` ao seu perfil.
+ Para usar o Amazon Bedrock com o Amazon Redshift ML, crie um perfil do IAM com as políticas `AmazonS3FullAccess` e `AmazonBedrockFullAccess`.
+ Recomendamos criar uma função do IAM por meio do console do Amazon Redshift que tenha a política `AmazonRedshiftAllCommandsFullAccess` com permissões para executar comandos SQL, como CREATE MODEL. O Amazon Redshift usa um mecanismo contínuo baseado em API para criar funções do IAM de maneira programática em sua Conta da AWS em seu nome. O Amazon Redshift anexa automaticamente políticas gerenciadas pela AWS existentes para a função do IAM. Essa metodologia significa que você pode permanecer no console do Amazon Redshift e não precisa alternar para o console do IAM para criar a função. Para obter mais informações, consulte [Criar uma função do IAM como padrão para o Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/default-iam-role.html).
Quando uma função do IAM for criada como padrão para o cluster, inclua `redshift` como parte do nome do recurso ou use uma etiqueta específica do RedShift para etiquetar esses recursos.
Para usar os modelos de base do Amazon Bedrock, adicione a seguinte seção:
```
// Required section if you use Bedrock models.
{
"Effect": "Allow",
"Action": "bedrock:InvokeModel",
"Resource": [
"arn:aws:bedrock:::foundation-model/*"
]
}
```
+ Se você deseja criar uma função do IAM com uma política mais restritiva, use a política a seguir. Você também pode modificar essa política para atender às suas necessidades.
O bucket do Amazon S3 `redshift-downloads/redshift-ml/` é o local onde os dados de amostra usados para outras etapas e exemplos são armazenados. Você pode removê-lo se não precisar carregar dados do Amazon S3. Ou substitua-o por outros buckets do Amazon S3 que você usa para carregar dados no Amazon Redshift.
Os valores *`your-account-id`*, *`your-role`* e `amzn-s3-demo-bucket` são os que você especifica como parte do comando CREATE MODEL.
(Opcional) Use as chaves AWS KMS da política de exemplo se você especificar uma chave AWS KMS ao usar o Amazon Redshift ML. O valor *`your-kms-key`* é a chave que você usa como parte do comando CREATE MODEL.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"cloudwatch:PutMetricData",
"ecr:BatchCheckLayerAvailability",
"ecr:BatchGetImage",
"ecr:GetAuthorizationToken",
"ecr:GetDownloadUrlForLayer",
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:DescribeLogStreams",
"logs:PutLogEvents",
"sagemaker:*Job*",
"sagemaker:AddTags",
"sagemaker:CreateModel",
"sagemaker:CreateEndpoint",
"sagemaker:CreateEndpointConfig",
"sagemaker:DeleteEndpoint",
"sagemaker:DeleteEndpointConfig",
"sagemaker:DeleteModel"
],
"Resource": "*"
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole",
"s3:AbortMultipartUpload",
"s3:GetObject",
"s3:DeleteObject",
"s3:PutObject"
],
"Resource": [
"arn:aws:iam::111122223333:role/",
"arn:aws:s3:::amzn-s3-demo-bucket/*",
"arn:aws:s3:::redshift-downloads/*"
]
},
{
"Effect": "Allow",
"Action": [
"s3:GetBucketLocation",
"s3:ListBucket"
],
"Resource": [
"arn:aws:s3:::amzn-s3-demo-bucket",
"arn:aws:s3:::redshift-downloads"
]
},
{
"Effect": "Allow",
"Action": [
"kms:CreateGrant",
"kms:Decrypt",
"kms:DescribeKey",
"kms:Encrypt",
"kms:GenerateDataKey*"
],
"Resource": [
"arn:aws:kms:us-east-1:111122223333:key/"
]
}
]
}
```
------
1. Para permitir que o Amazon Redshift e o SageMaker AI assumam a função de interagir com outros serviços, adicione a política de confiança a seguir ao perfil do IAM.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"redshift.amazonaws.com",
"sagemaker.amazonaws.com",
"forecast.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. (Opcional) Criar um bucket do Amazon S3 e uma chave AWS KMS. Eles são usados pelo Amazon Redshift para armazenar os dados de treinamento enviados ao Amazon SageMaker AI e receber o modelo treinado do Amazon SageMaker AI.
1. (Opcional) Crie diferentes combinações de funções do IAM e buckets do Amazon S3 para controlar o acesso a diferentes grupos de usuários.
1. Quando você ativa o roteamento de VPC aprimorado, o tráfego entre o Redshift ML e seu bucket do S3 passa pela sua VPC privada. Para obter mais informações sobre o roteamento da VPC, consulte [Roteamento aprimorado da VPC no Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
Para obter mais informações sobre as permissões necessárias para especificar uma VPC privada para seu trabalho de ajuste de hiperparâmetros, consulte [Permissions required to use Amazon Redshift ML with Amazon SageMaker AI](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html).
**nota**
As chamadas de inferência feitas para modelos remotos do SageMaker IA não passam pela VPC.
Para obter informações sobre como usar a instrução CREATE MODEL para começar a criar modelos para diferentes casos de uso, consulte [CREATE MODEL](r_CREATE_MODEL.md).
### Gerenciar permissões e propriedade
Assim como em outros objetos de banco de dados, como tabelas ou funções, o Amazon Redshift vincula a criação e o uso de modelos ML para acessar mecanismos de controle. Há permissões separadas para a criação de um modelo que executa as funções de previsão.
Os exemplos a seguir usam dois grupos de usuários: `retention_analyst_grp` (criador do modelo) e `marketing_analyst_grp` (usuário do modelo), para ilustrar como o Amazon Redshift gerencia o controle de acesso. O analista de retenção cria modelos de machine learning que outros conjuntos de usuários podem usar com as permissões obtidas.
Um superusuário pode conceder permissão USER ou GROUP para criar modelos de Machine Learning usando a instrução a seguir.
```
GRANT CREATE MODEL TO GROUP retention_analyst_grp;
```
Usuários ou grupos com essa permissão podem criar um modelo em qualquer esquema no cluster se um usuário tiver a permissão usual de CREATE no SCHEMA. O modelo de Machine Learning faz parte da hierarquia de esquemas de forma semelhante a tabelas, exibições, procedimentos e funções definidas pelo usuário.
Supondo que já exista um esquema `demo_ml`, conceda aos dois grupos de usuários a permissão no esquema da seguinte forma.
```
GRANT CREATE, USAGE ON SCHEMA demo_ml TO GROUP retention_analyst_grp;
```
```
GRANT USAGE ON SCHEMA demo_ml TO GROUP marketing_analyst_grp;
```
Para permitir que outros usuários usem a função de inferência de machine learning, conceda a permissão EXECUTE. O exemplo a seguir usa a permissão EXECUTE para conceder ao GRUPO marketing\$1analyst\$1grp a permissão de usar o modelo.
```
GRANT EXECUTE ON MODEL demo_ml.customer_churn_auto_model TO GROUP marketing_analyst_grp;
```
Use a instrução REVOKE com CREATE MODEL e EXECUTE para revogar essas permissões de usuários ou grupos. Para obter mais informações sobre comandos de controle de permissão, consulte [GRANT](r_GRANT.md) e [REVOKE](r_REVOKE.md).
## Usar a explicabilidade do modelo com o Amazon Redshift ML
Com a explicabilidade do modelo do Amazon Redshift ML, você usa valores relevantes de recursos para ajudar a entender como cada atributo dos dados de treinamento contribui para o resultado previsto.
A explicabilidade do modelo ajuda a melhorar os modelos de machine learning (ML) ao explicar as previsões feitas pelos modelos. A explicabilidade do modelo ajuda a explicar como esses modelos fazem previsões usando uma abordagem de atribuição de recursos.
O Amazon Redshift ML incorpora a explicabilidade do modelo para fornecer funcionalidade de explicação do modelo aos usuários do Amazon Redshift ML. Para obter mais informações sobre a explicabilidade do modelo, consulte [O que é imparcialidade e explicabilidade do modelo para predições de machine learning?](https://docs.aws.amazon.com/sagemaker/latest/dg/clarify-fairness-and-explainability.html) no *Guia do desenvolvedor do Amazon SageMaker AI*.
A explicabilidade do modelo também monitora as inferências que os modelos fazem na produção para oscilação de atribuição de recursos. Também fornece ferramentas para ajudar você a gerar relatórios de governança de modelos que podem ser usados para informar equipes de risco e conformidade e reguladores externos.
Quando você especifica a opção AUTO ON ou AUTO OFF ao usar a instrução CREATE MODEL, após a conclusão do trabalho de treinamento do modelo, o SageMaker AI cria a saída da explicação. É possível usar a função EXPLAIN\$1MODEL para consultar o relatório de explicabilidade em formato JSON. Para obter mais informações, consulte [Funções de machine learning](ml-function.md).
## Métricas de probabilidade do Amazon Redshift ML
Em problemas de aprendizado supervisionado, os rótulos de classes são resultados de previsões que usam os dados de entrada. Por exemplo, se você está usando um modelo para prever se um cliente se inscreveria novamente em um serviço de streaming, possíveis rótulos são “provável” e “pouco provável”. O Redshift ML oferece o recurso de métricas de probabilidade, que atribuem uma probabilidade a cada rótulo para indicar sua probabilidade. Isso ajuda você a tomar decisões mais informadas com base nos resultados previstos. No Amazon Redshift ML, as métricas de probabilidade estão disponíveis ao criar modelos AUTO ON com um tipo de problema de classificação binária ou classificação multiclasse. Se você omitir o parâmetro AUTO ON, o Redshift ML assumirá que o modelo deve ter AUTO ON.
### Criar o modelo
Ao criar um modelo, o Amazon Redshift detecta automaticamente o tipo de modelo e o tipo de problema. Se for um problema de classificação, o Redshift criará automaticamente uma segunda função de inferência que você poderá usar para gerar probabilidades relativas a cada rótulo. O nome dessa segunda função de inferência é o nome da função de inferência especificada seguido pela string `_probabilities`. Por exemplo, se você nomear sua função de inferência como `customer_churn_predict`, o nome da segunda função de inferência será `customer_churn_predict_probabilities`. Depois, você pode consultar essa função para obter as probabilidades de cada rótulo.
```
CREATE MODEL customer_churn_model
FROM customer_activity
PROBLEM_TYPE BINARY_CLASSIFICATION
TARGET churn
FUNCTION customer_churn_predict
IAM_ROLE {default}
AUTO ON
SETTINGS ( S3_BUCKET 'amzn-s3-demo-bucket'
```
### Obter probabilidades
Quando a função de probabilidade estiver pronta, a execução do comando retornará um [tipo SUPER](https://docs.aws.amazon.com/redshift/latest/dg/r_SUPER_type.html) com matrizes das probabilidades retornadas e seus rótulos associados. Por exemplo, o resultado `"probabilities" : [0.7, 0.3], "labels" : ["False.", "True."]` significa que o rótulo False tem uma probabilidade de 0,7 e o rótulo True tem uma probabilidade de 0,3.
```
SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins, Intl_calls,
Intl_charge, Cust_serv_calls)
FROM customer_activity;
customer_churn_predict_probabilities
--------------------
{"probabilities" : [0.7, 0.3], "labels" : ["False.", "True."]}
{"probabilities" : [0.8, 0.2], "labels" : ["False.", "True."]}
{"probabilities" : [0.75, 0.25], "labels" : ["True.", "False"]}
```
As matrizes de probabilidades e rótulos são sempre ordenadas em ordem decrescente de probabilidade. Você pode escrever uma consulta para retornar apenas o rótulo previsto com a maior probabilidade desaninhando os resultados retornados de SUPER da função de probabilidade.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM (SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins, Intl_calls,
Intl_charge, Cust_serv_calls) AS prediction
FROM customer_activity);
labels | probabilities
-----------+--------------
"False." | 0.7
"False." | 0.8
"True." | 0.75
```
Para simplificar as consultas, você pode armazenar os resultados da função de previsão em uma tabela.
```
CREATE TABLE churn_auto_predict_probabilities AS
(SELECT customer_churn_predict_probabilities(Account_length, Area_code,
VMail_message, Day_mins, Day_calls, Day_charge,Eve_mins, Eve_calls,
Eve_charge, Night_mins, Night_calls, Night_charge,Intl_mins,
Intl_calls, Intl_charge, Cust_serv_calls) AS prediction
FROM customer_activity);
```
Você pode consultar a tabela com os resultados para retornar somente previsões que tenham uma probabilidade maior que 0,7.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM churn_auto_predict_probabilities
WHERE prediction.probabilities[0] > 0.7;
labels | probabilities
-----------+--------------
"False." | 0.8
"True." | 0.75
```
Usando a notação de índices, você pode obter a probabilidade de um rótulo específico. O exemplo a seguir retorna as probabilidades de todos os rótulos `True.`
```
SELECT label, index, p.prediction.probabilities[index]
FROM churn_auto_predict_probabilities p, p.prediction.labels AS label AT index
WHERE label='True.';
label | index | probabilities
---------+-------+---------------
"True." | 0 | 0.3
"True." | 0 | 0.2
"True." | 0 | 0.75
```
O exemplo a seguir retorna todas as linhas que têm um rótulo `True` com uma probabilidade maior que 0,7, indicando que é provável que o cliente retorne.
```
SELECT prediction.labels[0], prediction.probabilities[0]
FROM churn_auto_predict_probabilities
WHERE prediction.probabilities[0] > 0.7 AND prediction.labels[0] = "True.";
labels | probabilities
-----------+--------------
"True." | 0.75
```
# 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)
# Integração do Amazon Redshift ML com o Amazon Bedrock
Esta seção descreve como usar a integração do Amazon Redshift ML com o Amazon Bedrock. Com esse recurso, você pode invocar um modelo do Amazon Bedrock usando SQL e utilizar seus dados de um data warehouse do Amazon Redshift para criar aplicações de IA generativa, como geração de texto, análise de sentimentos ou tradução.
**Topics**
+ [Criar ou atualizar um perfil do IAM para a integração do Amazon Redshift ML com o Amazon Bedrock](#machine-learning-br-iam)
+ [Criar ou atualizar um modelo externo para a integração do Amazon Redshift ML com o Amazon Bedrock](#machine-learning-br-create)
+ [Usar um modelo externo para a integração do Amazon Redshift ML com o Amazon Bedrock](#machine-learning-br-use)
+ [Engenharia de prompts para a integração do Amazon Redshift ML com o Amazon Bedrock](#machine-learning-br-prompt)
## Criar ou atualizar um perfil do IAM para a integração do Amazon Redshift ML com o Amazon Bedrock
Esta seção descreve como criar um perfil do IAM para usar a integração do Amazon Redshift ML com o Amazon Bedrock.
Adicione a seguinte política ao perfil do IAM que você usa com a integração do Amazon Redshift ML com o Amazon Bedrock:
+ `AmazonBedrockFullAccess`
Para permitir que o Amazon Redshift assuma um perfil para interagir com outros serviços, adicione a seguinte política de confiança aio perfil do IAM:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": [
"redshift.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Se o cluster ou namespace estiver em uma VPC, siga as instruções em [Definir cluster e configuração para administração do Amazon Redshift ML](getting-started-machine-learning.md#admin-setup).
Se precisar de uma política mais restritiva, você pode criar uma que inclua somente as permissões do Amazon Bedrock especificadas nas seguintes páginas:
+ [Definir cluster e configuração para administração do Amazon Redshift ML](getting-started-machine-learning.md#admin-setup)
+ [ Permissões necessárias para usar o machine learning (ML) do Amazon Redshift)](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-access-control-identity-based.html#iam-permission-ml?)
Para ter informações sobre como a criar um perfil do IAM, consulte [Criar um perfil do IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html) no *Guia do usuário do AWS Identity and Access Management*.
## Criar ou atualizar um modelo externo para a integração do Amazon Redshift ML com o Amazon Bedrock
Esta seção mostra como criar um modelo externo para usar como interface para o Amazon Bedrock no data warehouse do Amazon Redshift.
Para invocar um modelo do Amazon Bedrock por meio do Amazon Redshift, você deve primeiro executar o comando `CREATE EXTERNAL MODEL`. Esse comando cria um objeto de modelo externo no banco de dados e uma função de usuário associada que você usa para gerar conteúdo textual com o Amazon Bedrock.
O seguinte exemplo de código mostra um comando `CREATE EXTERNAL MODEL` básico:
```
CREATE EXTERNAL MODEL llm_claude
FUNCTION llm_claude_func
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2:1',
PROMPT 'Summarize the following text:');
```
O comando `CREATE EXTERNAL MODEL` tem uma interface unificada e consistente com o Amazon Bedrock para todos os modelos de base (FMs) que comportam mensagens. Essa é a opção padrão ao usar o comando `CREATE EXTERNAL MODEL` ou ao especificar explicitamente que o tipo de solicitação deve ser `UNIFIED`. Para ter mais informações, consulte a [documentação da API Converse](https://docs.aws.amazon.com/bedrock/latest/APIReference/API_runtime_Converse.html) na *documentação de API do Amazon Bedrock*.
Se um FM não comportar mensagens, você deverá definir a configuração `request_type` como `RAW`, como demonstra o exemplo a seguir. Ao definir `request_type` como `RAW`, você deve criar a solicitação enviada ao Amazon Bedrock ao usar a função de inferência com base no FM selecionado. Habilite o acesso ao modelo Titan Text G1 — Express no Amazon Bedrock antes de executar o exemplo a seguir.
```
CREATE EXTERNAL MODEL titan_raw
FUNCTION func_titan_raw
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'amazon.titan-text-express-v1',
REQUEST_TYPE RAW,
RESPONSE_TYPE SUPER);
```
Se precisar de mais informações sobre uma solicitação de entrada, como total de tokens, você poderá solicitar `RESPONSE_TYPE` para ser `super` ao criar o modelo.
```
CREATE EXTERNAL MODEL patient_recommendations_v2
FUNCTION patient_recommendations_func_v2
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2',
PROMPT 'Generate personalized diet plan for following patient:',
RESPONSE_TYPE SUPER);
```
O parâmetro `PROMPT` para o comando `CREATE EXTERNAL MODEL` é um prompt estático. Se você precisar de um prompt dinâmico para sua aplicação, deverá especificá-lo ao usar a função de inferência. Para obter mais detalhes, consulte [Engenharia de prompts para a integração do Amazon Redshift ML com o Amazon Bedrock](#machine-learning-br-prompt).
Para ter mais informações sobre a instrução `CREATE EXTERNAL MODEL` e os respectivos parâmetros e configurações, consulte [CREATE EXTERNAL MODEL](r_create_external_model.md).
## Usar um modelo externo para a integração do Amazon Redshift ML com o Amazon Bedrock
Esta seção mostra como invocar um modelo externo para gerar texto em resposta aos prompts fornecidos. Para invocar um modelo externo, use a função de inferência que você criou com `CREATE EXTERNAL MODEL`.
**Topics**
+ [Inferência com modelos do tipo de solicitação `UNIFIED`](#machine-learning-br-use-unified)
+ [Inferência com modelos do tipo de solicitação `RAW`](#machine-learning-br-use-raw)
+ [A inferência funciona como funções somente de líder](#machine-learning-br-use-leader)
+ [Observações sobre o uso de funções de inferência](#machine-learning-br-use-usage)
### Inferência com modelos do tipo de solicitação `UNIFIED`
A função de inferência para modelos com o tipo de solicitação `UNIFIED` tem os três seguintes parâmetros, que são passados sequencialmente para a função:
+ **Texto de entrada** (obrigatório): esse parâmetro especifica o texto de entrada que o Amazon Redshift passa para o Amazon Bedrock.
+ **Configuração de inferência** e **Campos adicionais de solicitação de modelo** (opcional): o Amazon Redshift passa esses parâmetros para os parâmetros correspondentes da API de modelo Converse.
O seguinte exemplo de código mostra como usar uma função de inferência do tipo `UNIFIED`:
```
SELECT llm_claude_func(input_text, object('temperature', 0.7, 'maxtokens', 500))
FROM some_data;
```
### Inferência com modelos do tipo de solicitação `RAW`
A função de inferência para modelos com o tipo de solicitação `RAW` tem apenas um parâmetro do tipo de dados `SUPER`. A sintaxe desse parâmetro depende do modelo do Amazon Bedrock que é usado.
O seguinte exemplo de código mostra como usar uma função de inferência do tipo `RAW`:
```
SELECT llm_titan_func(
object(
"inputText", "Summarize the following text: " | input_text,
"textGenerationConfig", object("temperature", 0.5, "maxTokenCount", 500)
)
)
FROM some_data;
```
### A inferência funciona como funções somente de líder
As funções de inferência para modelos do Amazon Bedrock podem ser executadas como funções somente de nós líderes quando a consulta que as utiliza não faz referência a nenhuma tabela. Isso pode ser útil se você quiser fazer uma pergunta rapidamente a um LLM.
O seguinte exemplo de código mostra como usar uma função de inferência somente de líder:
```
SELECT general_titan_llm_func('Summarize the benefits of LLM on data analytics in 100 words');
```
### Observações sobre o uso de funções de inferência
Observe o seguinte ao usar funções de inferência com a integração do Amazon Redshift ML com o Amazon Bedrock:
+ Os nomes dos parâmetros de todos os modelos do Amazon Bedrock diferenciam maiúsculas e minúsculas. Se seus parâmetros não corresponderem aos exigidos pelo modelo, o Amazon Bedrock poderá ignorá-los discretamente.
+ O throughput das consultas de inferência é limitado pelas cotas de tempo de execução dos diferentes modelos oferecidos pelo Amazon Bedrock em diferentes regiões. Para ter mais informações, consulte [Quotas for Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/quotas.html) no *Guia do usuário do Amazon Bedrock*.
+ Se você precisar de um throughput garantido e consistente, considere a possibilidade de obter throughput provisionado do Amazon Bedrock para o modelo de que você precisa. Para ter mais informações, consulte [Increase model invocation capacity with Provisioned Throughput in Amazon Bedrock](https://docs.aws.amazon.com/bedrock/latest/userguide/prov-throughput.html) no *Guia do usuário do Amazon Bedrock*.
+ Consultas de inferência com grandes quantidades de dados podem ter exceções de controle de utilização. Isso se deve às cotas limitadas de tempo de execução do Amazon Bedrock. O Amazon Redshift repete as solicitações várias vezes, mas as consultas ainda assim podem ter controle de utilização porque o throughput para modelos não provisionados pode ser variável.
+ Se você encontrar exceções de controle de utilização provenientes do Amazon Bedrock, como `Too many requests, please wait before trying again.`, mesmo com pequenas quantidades de dados, verifique as cotas em **Cotas de serviço** na sua conta do Amazon Bedrock. Verifique se a cota aplicada no nível da conta é pelo menos igual ao valor da cota padrão da AWS para as solicitações **InvokeModel** do modelo que você está usando.
## Engenharia de prompts para a integração do Amazon Redshift ML com o Amazon Bedrock
Esta seção mostra como usar prompts estáticos com um modelo externo.
Para usar prompts de prefixo e sufixo estáticos em seu modelo externo, forneça-os usando os parâmetros `SUFFIX` e `PROMPT` da instrução `CREATE EXTERNAL MODEL`. Esses prompts são adicionados a cada consulta usando o modelo externo.
O seguinte exemplo mostra como adicionar prompts de prefixo e sufixo a um modelo externo:
```
CREATE EXTERNAL MODEL llm_claude
FUNCTION llm_claude_func
IAM_ROLE ''
MODEL_TYPE BEDROCK
SETTINGS (
MODEL_ID 'anthropic.claude-v2:1',
PROMPT 'Summarize the following text:',
SUFFIX 'Respond in an analytic tone');
```
Para usar prompts dinâmicos, você pode fornecê-los ao usar a função de inferência concatenando-os na entrada da função. O seguinte exemplo mostra como usar prompts dinâmicos com uma função de inferência:
```
SELECT llm_claude_func('Summarize the following review:' | input_text | 'The review should have formal tone.')
FROM some_data
```