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/).
# Casos de uso
Os casos de uso a seguir demonstram como usar CREATE MODEL para atender às suas necessidades.
## CREATE MODEL simples
A seguir o resumo das opções básicas da sintaxe CREATE MODEL.
### Sintaxe simples CREATE MODEL
```
CREATE MODEL model_name
FROM { table_name | ( select_query ) }
TARGET column_name
FUNCTION prediction_function_name
IAM_ROLE { default }
SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
[ MAX_CELLS integer ]
)
```
### Parâmetros simples CREATE MODEL
*model\_name*
O nome do modelo. O nome do modelo em um esquema deve ser exclusivo.
FROM { *table\_name* \| ( *select\_query* ) }
O table\_name ou a consulta que especifica os dados de treinamento. Eles podem ser uma tabela existente no sistema ou uma consulta SELECT compatível com o Amazon RedShift entre parênteses, ou seja, (). Deve haver pelo menos duas colunas no resultado da consulta.
TARGET *column\_name*
O nome da coluna que se torna o alvo da previsão. A coluna deve existir na cláusula FROM.
FUNCTION *prediction\_function\_name*
Um valor que especifica o nome da função de Machine Learning do Amazon Redshift a ser gerada pelo CREATE MODEL e usada para fazer previsões usando esse modelo. A função é criada no mesmo esquema que o objeto modelo e pode ser sobrecarregada.
O Machine Learning do Amazon Redshift oferece suporte a modelos, como modelos Xtreme Gradient Boosted tree (XGBoost) para regressão e classificação.
IAM\_ROLE { default \| 'arn:aws:iam:::role/'}
Use a palavra-chave padrão para que o Amazon Redshift use a função do IAM definida como padrão e associada ao cluster quando o comando CREAT MODEL for executado. Como alternativa, você pode especificar o ARN de um perfil do IAM para usar esse perfil.
*S3\_BUCKET *'amzn-s3-demo-bucket'**
O nome do bucket do Amazon S3 que você criou anteriormente era usado para compartilhar dados e artefatos de treinamento entre o Amazon Redshift e o SageMaker AI. O Amazon Redshift cria uma subpasta neste bucket antes do descarregamento dos dados de treinamento. Quando o treinamento for concluído, o Amazon Redshift exclui a subpasta criada e seu conteúdo.
Inteiro MAX\_CELLS
O número máximo de células a serem exportadas da cláusula FROM. O padrão é 1.000.000.
O número de células é o produto do número de linhas nos dados de treinamento (produzidos pela tabela ou consulta da cláusula FROM) vezes o número de colunas. Se o número de células nos dados de treinamento for maior do que o especificado pelo parâmetro max\_cells, CREATE MODEL baixará os dados de treinamento da cláusula FROM para reduzir o tamanho do conjunto de treinamento abaixo de MAX\_CELLS. Permitir conjuntos de dados de treinamento maiores pode produzir maior precisão, mas também pode significar que o modelo leva mais tempo para treinar e custa mais.
Para obter informações sobre os custos de uso do Amazon Redshift, consulte [Custos para usar o Amazon Redshift ML](cost.md).
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).
## CREATE MODEL com orientação do usuário
A seguir, você pode encontrar uma descrição das opções para CREATE MODEL, além das opções descritas em [CREATE MODEL simples](#r_simple_create_model).
Por padrão, CREATE MODEL procura a melhor combinação de pré-processamento e modelo para seu conjunto de dados específico. Você pode querer controle adicional ou introduzir conhecimento de domínio adicional (como tipo de problema ou objetivo) sobre seu modelo. Em um cenário de rotatividade do 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*.
Em seguida, o CREATE MODEL segue suas sugestões sobre os aspectos especificados, como o objetivo. Ao mesmo tempo, o CREATE MODEL descobre automaticamente os melhores pré-processadores e os melhores hiperparâmetros.
### CREATE MODEL com sintaxe de orientação do usuário
CREATE MODEL oferece mais flexibilidade nos aspectos que você pode especificar e nos aspectos que o Amazon Redshift detecta automaticamente.
```
CREATE MODEL model_name
FROM { table_name | ( select_statement ) }
TARGET column_name
FUNCTION function_name
IAM_ROLE { default }
[ MODEL_TYPE { XGBOOST | MLP | LINEAR_LEARNER} ]
[ PROBLEM_TYPE ( REGRESSION | BINARY_CLASSIFICATION | MULTICLASS_CLASSIFICATION ) ]
[ OBJECTIVE ( 'MSE' | 'Accuracy' | 'F1' | 'F1Macro' | 'AUC') ]
SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket', |
S3_GARBAGE_COLLECT { ON | OFF }, |
KMS_KEY_ID 'kms_key_id', |
MAX_CELLS integer, |
MAX_RUNTIME integer (, ...)
)
```
### CREATE MODEL com parâmetros de orientação do usuário
*MODEL\_TYPE { XGBOOST \| MLP \| LINEAR\_LEARNER }*
(Opcional) Especifica o tipo de modelo. Você pode especificar se deseja treinar um modelo de um tipo específico, como XGBoost, perceptron multicamada (MLP) ou Linear Learner, que são todos algoritmos compatíveis com o Amazon SageMaker AI Autopilot. Se você não especificar o parâmetro, todos os tipos de modelo aceitos serão pesquisados durante o treinamento para obter o melhor modelo.
*PROBLEM\_TYPE ( REGRESSION \| BINARY\_CLASSIFICATION \| MULTICLASS\_CLASSIFICATION )*
(Opcional) Especifica o tipo de problema. Se você souber o tipo de problema, pode restringir o Amazon Redshift a apenas pesquisar o melhor modelo desse tipo de modelo específico. Se você não especificar esse parâmetro, um tipo de problema será descoberto durante o treinamento com base em seus dados.
OBJECTIVE ( 'MSE' \| 'Accuracy' \| 'F1' \| 'F1Macro' \| 'AUC')
(Opcional) Especifica o nome da métrica objetiva usada para medir a qualidade preditiva de um sistema de Machine Learning. Essa métrica é otimizada durante o treinamento para fornecer a melhor estimativa dos valores dos parâmetros do modelo a partir dos dados. Se você não especificar uma métrica explicitamente, o comportamento padrão é usar automaticamente MSE: para regressão, F1: para classificação binária, Precisão: para classificação multiclass. Para obter informações sobre os objetivos, consulte [AutoMLJobObjective](https://docs.aws.amazon.com//sagemaker/latest/APIReference/API_AutoMLJobObjective.html) na *Referência de API do Amazon SageMaker AI*.
Inteiro MAX\_CELLS
(Opcional) Especifica o número de células nos dados de treinamento. Esse valor é o produto do número de registros (na consulta de treinamento ou tabela) vezes o número de colunas. O padrão é 1.000.000.
Inteiro MAX\_RUNTIME
(Opcional) Especifica a quantidade máxima de tempo para treinar. Os trabalhos de treinamento geralmente concluem mais cedo dependendo do tamanho do conjunto de dados. Isso especifica a quantidade máxima de tempo em que o treinamento deve levar. The default is 5.400 (90 minutos).
S3\_GARBAGE\_COLLECT { ON \| OFF }
(Opcional) Especifica se o Amazon Redshift executa a coleta de lixo nos conjuntos de dados resultantes usados nos modelos e para treiná-los. Se definido como OFF, os conjuntos de dados resultantes usados para treinar modelos e os modelos permanecem no Amazon S3 e podem ser usados para outros fins. Se definido como ON, o Amazon Redshift excluirá os artefatos no Amazon S3 após a conclusão do treinamento. O padrão é ON.
KMS\_KEY\_ID 'kms\_key\_id'
(Opcional) Especifica se o Amazon Redshift usa criptografia do lado do servidor com uma chave AWS KMS para proteger dados em repouso. Os dados em trânsito são protegidos com Secure Sockets Layer (SSL).
*PREPROCESSORS 'string' *
(Opcional) Especifica certas combinações de pré-processadores para determinados conjuntos de colunas. O formato é uma lista de columnSets e as transformações apropriadas a serem aplicadas a cada conjunto de colunas. O Amazon Redshift aplica todos os transformadores em uma lista de transformadores específica a todas as colunas no ColumnSet correspondente. Por exemplo, para aplicar OneHotEncoder com Imputer às colunas t1 e t2, use o comando de exemplo a seguir.
```
CREATE MODEL customer_churn
FROM customer_data
TARGET 'Churn'
FUNCTION predict_churn
IAM_ROLE { default | 'arn:aws:iam:::role/' }
PROBLEM_TYPE BINARY_CLASSIFICATION
OBJECTIVE 'F1'
PREPROCESSORS '[
...
{"ColumnSet": [
"t1",
"t2"
],
"Transformers": [
"OneHotEncoder",
"Imputer"
]
},
{"ColumnSet": [
"t3"
],
"Transformers": [
"OneHotEncoder"
]
},
{"ColumnSet": [
"temp"
],
"Transformers": [
"Imputer",
"NumericPassthrough"
]
}
]'
SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket'
)
```
O Amazon Redshift oferece suporte aos seguintes transformadores:
+ OneHotEncoder — Normalmente usado para codificar um valor discreto em um vetor binário com um valor diferente de zero. Este transformador é adequado para muitos modelos de machine learning.
+ OrdinalEncoder — Codifica valores discretos em um único inteiro. Esse transformador é adequado para determinados modelos de machine learning, como MLP e Linear Learner.
+ NumericPassThrough — Passa a entrada como está no modelo.
+ Imputer — Preenche valores ausentes e valores não numéricos (NaN).
+ ImputerWithIndicator — Preenche valores ausentes e valores NaN. Este transformador também cria um indicador de se algum valor estava faltando e preenchido.
+ Normalizer — Normaliza valores, o que pode melhorar a performance de muitos algoritmos de Machine Learning.
+ DateTimeVectorizer — Cria uma incorporação vetorial, representando uma coluna do tipo de dados datetime que pode ser usada em modelos de Machine Learning.
+ PCA — Projeta os dados em um espaço dimensional mais baixo para reduzir o número de recursos e, ao mesmo tempo, manter o máximo de informações possível.
+ StandardScaler: padroniza os recursos removendo a média e a escalabilidade para a variância da unidade.
+ minMax: transforma recursos escalando cada recurso para um determinado intervalo.
O Amazon Redshift ML armazena os transformadores treinados e os aplica automaticamente como parte da consulta de previsão. Você não precisa especificá-los ao gerar previsões do seu modelo.
## Modelos CREATE XGBoost com AUTO OFF
O AUTO OFF CREATE MODEL tem geralmente objetivos diferentes do padrão CREATE MODEL.
Como um usuário avançado que já conhece o tipo de modelo que você deseja e hiperparâmetros para usar ao treinar esses modelos, você pode usar CREATE MODEL com AUTO OFF para desativar a descoberta automática CREATE MODEL de pré-processadores e hiperparâmetros. Para fazer isso, especifique explicitamente o tipo de modelo. O XGBoost é atualmente o único tipo de modelo compatível quando AUTO é definido como OFF. Você pode especificar hiperparâmetros. O Amazon Redshift usa valores padrão para quaisquer hiperparâmetros especificados.
### Modelos CREATE XGBoost com sintaxe AUTO OFF
```
CREATE MODEL model_name
FROM { table_name | (select_statement ) }
TARGET column_name
FUNCTION function_name
IAM_ROLE { default }
AUTO OFF
MODEL_TYPE XGBOOST
OBJECTIVE { 'reg:squarederror' | 'reg:squaredlogerror' | 'reg:logistic' |
'reg:pseudohubererror' | 'reg:tweedie' | 'binary:logistic' | 'binary:hinge' |
'multi:softmax' | 'rank:pairwise' | 'rank:ndcg' }
HYPERPARAMETERS DEFAULT EXCEPT (
NUM_ROUND '10',
ETA '0.2',
NUM_CLASS '10',
(, ...)
)
PREPROCESSORS 'none'
SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket', |
S3_GARBAGE_COLLECT { ON | OFF }, |
KMS_KEY_ID 'kms_key_id', |
MAX_CELLS integer, |
MAX_RUNTIME integer (, ...)
)
```
### Modelos CREATE XGBoost com parâmetros AUTO OFF
*AUTO OFF*
Desativa a descoberta automática de pré-processador, algoritmo e seleção de hiper-parâmetros do CREATE MODEL.
MODEL\_TYPE XGBOOST
Especifica o uso do XGBOOST para treinar o modelo.
OBJECTIVE str
Especifica um objetivo reconhecido pelo algoritmo. O Amazon Redshift oferece suporte a reg:squarederror, reg:squaredlogerror, reg:logistic, reg:pseudohubererror, reg:tweedie, binary:logistic, binary:hinge e multi:softmax. Para obter mais informações sobre esses objetivos, consulte [Aprendizado de parâmetros de tarefa](https://xgboost.readthedocs.io/en/latest/parameter.html#learning-task-parameters) na documentação do XGBoost.
HYPERPARAMETERS { DEFAULT \| DEFAULT EXCEPT ( key ‘value’ (,..) ) }
Especifica se os parâmetros padrão do XGBoost são usados ou substituídos por valores especificados pelo usuário. Os valores devem ser colocados entre aspas simples. A seguir estão exemplos de parâmetros para XGBoost e seus padrões.
[See the AWS documentation website for more details](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_create_model_use_cases.html)
O exemplo a seguir prepara dados para XGBoost.
```
DROP TABLE IF EXISTS abalone_xgb;
CREATE TABLE abalone_xgb (
length_val float,
diameter float,
height float,
whole_weight float,
shucked_weight float,
viscera_weight float,
shell_weight float,
rings int,
record_number int);
COPY abalone_xgb
FROM 's3://redshift-downloads/redshift-ml/abalone_xg/'
REGION 'us-east-1'
IAM_ROLE default
IGNOREHEADER 1 CSV;
```
O exemplo a seguir cria um modelo XGBoost com opções avançadas especificadas, como MODEL\_TYPE, OBJETIVE e PREPROCESSORS.
```
DROP MODEL abalone_xgboost_multi_predict_age;
CREATE MODEL abalone_xgboost_multi_predict_age
FROM ( SELECT length_val,
diameter,
height,
whole_weight,
shucked_weight,
viscera_weight,
shell_weight,
rings
FROM abalone_xgb WHERE record_number < 2500 )
TARGET rings FUNCTION ml_fn_abalone_xgboost_multi_predict_age
IAM_ROLE default
AUTO OFF
MODEL_TYPE XGBOOST
OBJECTIVE 'multi:softmax'
PREPROCESSORS 'none'
HYPERPARAMETERS DEFAULT EXCEPT (NUM_ROUND '100', NUM_CLASS '30')
SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket');
```
O exemplo a seguir usa uma consulta de inferência para prever a idade do peixe com um número de registro maior que 2.500. Ele usa a função ml\_fn\_abalone\_xgboost\_multi\_predict\_age criada a partir do comando acima.
```
select ml_fn_abalone_xgboost_multi_predict_age(length_val,
diameter,
height,
whole_weight,
shucked_weight,
viscera_weight,
shell_weight)+1.5 as age
from abalone_xgb where record_number > 2500;
```
## Traga seu próprio modelo (BYOM): inferência local
O Amazon Redshift ML é compatível com o uso de BYOM (traga seu próprio modelo) para inferência local.
A seguir o resumo das opções básicas da sintaxe CREATE MODEL para 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.
### Sintaxe CREATE MODEL para inferência local
A seguir é descrito a sintaxe CREATE MODEL para inferência local.
```
CREATE MODEL model_name
FROM ('job_name' | 's3_path' )
FUNCTION function_name ( data_type [, ...] )
RETURNS data_type
IAM_ROLE { default }
[ SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket', | --required
KMS_KEY_ID 'kms_string') --optional
];
```
Atualmente, o Amazon Redshift comporta apenas modelos XGBoost, MLP e Linear Learner pré-treinados para BYOM. Você pode importar o SageMaker AI Autopilot e modelos treinados diretamente no Amazon SageMaker AI para inferência local usando esse caminho.
#### Parâmetros CREATE MODEL para inferência local
*model\_name*
O nome do modelo. O nome do modelo em um esquema deve ser exclusivo.
FROM (*'job\_name'* \| *'s3\_path'* )
O *job\_name* usa um nome de trabalho do Amazon SageMaker AI como entrada. O nome do trabalho pode ser um nome de trabalho de treinamento do Amazon SageMaker AI ou um nome de trabalho do Amazon SageMaker AI Autopilot. O trabalho deve ser criado na mesma conta da AWS que possui o cluster do Amazon Redshift. Para encontrar o nome do trabalho, inicie o Amazon SageMaker AI. No menu suspenso **Training** (Treinamento), escolha **Training jobs** (Trabalhos de treinamento).
O *'s3\_path'* especifica o local S3 do arquivo de artefatos de modelo .tar.gz que deve ser usado ao criar o modelo.
FUNCTION *function\_name* ( *data\_type* [, ...] )
O nome da função a ser criada e os tipos de dados dos argumentos de entrada. Você pode fornecer um nome de esquema.
RETURNS *tipo\_dados*
Tipo de dados do valor retornado pela função.
IAM\_ROLE { default \| 'arn:aws:iam:::role/'}
Use a palavra-chave padrão para que o Amazon Redshift use a função do IAM definida como padrão e associada ao cluster quando o comando CREATE MODEL for executado.
Use o nome do recurso da Amazon (ARN) de uma função do IAM que seu cluster usa para autenticação e autorização.
SETTINGS ( S3\_BUCKET *'amzn-s3-demo-bucket'*, \| KMS\_KEY\_ID *'kms\_string'*)
A cláusula S3\_BUCKET especifica o local do Amazon S3 usado para armazenar resultados intermediários.
(Opcional) A cláusula KMS\_KEY\_ID especifica se o Amazon Redshift usa criptografia do lado do servidor com uma chave do AWS KMS para proteger dados em repouso. Os dados em trânsito são protegidos com Secure Sockets Layer (SSL).
Para obter mais informações, consulte [CREATE MODEL com orientação do usuário](#r_user_guidance_create_model).
#### CREATE MODEL para exemplo de inferências locais
O exemplo a seguir cria um modelo que foi previamente treinado no Amazon SageMaker AI, fora do Amazon Redshift. Como o tipo de modelo é compatível com o Amazon Redshift ML para inferência local, o seguinte CREATE MODEL cria uma função que pode ser usada localmente no Amazon Redshift. Você pode fornecer um nome de tarefa de treinamento do SageMaker AI.
```
CREATE MODEL customer_churn
FROM 'training-job-customer-churn-v4'
FUNCTION customer_churn_predict (varchar, int, float, float)
RETURNS int
IAM_ROLE default
SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket');
```
Depois que o modelo é criado, você pode usar a função *customer\_churn\_predict* com os tipos de argumento especificados para fazer previsões.
## Traga seu próprio modelo (BYOM): inferência remota
O Amazon Redshift ML também é compatível com o uso de BYOM (traga seu próprio modelo) para inferência remota.
A seguir o resumo das opções básicas da sintaxe CREATE MODEL para BYOM.
### Sintaxe CREATE MODEL para inferência remota
A seguir é descrito a sintaxe CREATE MODEL para inferência remota.
```
CREATE MODEL model_name
FUNCTION function_name ( data_type [, ...] )
RETURNS data_type
SAGEMAKER 'endpoint_name'[:'model_name']
IAM_ROLE { default | 'arn:aws:iam:::role/' }
[SETTINGS (MAX_BATCH_ROWS integer)];
```
#### Parâmetros CREATE MODEL para inferência remota
*model\_name*
O nome do modelo. O nome do modelo em um esquema deve ser exclusivo.
FUNCTION *fn\_name* ( [*data\_type*] [, ...] )
O nome da função e os tipos de dados dos argumentos de entrada. Consulte [Tipos de dados](https://docs.aws.amazon.com/redshift/latest/dg/c_Supported_data_types.html) para obter todos os tipos de dados compatíveis. `Geography`,`geometry` e `hllsketch` não são compatíveis.
Você também pode fornecer um nome de função dentro de um esquema usando a notação em duas partes, como `myschema.myfunction`.
RETURNS *tipo\_dados*
Tipo de dados do valor retornado pela função. Consulte [Tipos de dados](https://docs.aws.amazon.com/redshift/latest/dg/c_Supported_data_types.html) para obter todos os tipos de dados compatíveis. `Geography`,`geometry` e `hllsketch` não são compatíveis.
SAGEMAKER *'endpoint\_name'*[:*'model\_name'*]
O nome do endpoint do Amazon SageMaker AI. Se o nome do endpoint apontar para um endpoint multimodelo, adicione o nome do modelo a ser usado. O endpoint deve ser hospedado na mesma região da AWS e Conta da AWS que o cluster do Amazon Redshift. Para encontrar o endpoint, inicie o Amazon SageMaker AI. No menu suspenso **Inference** (Inferência), escolha **Endpoints**.
IAM\_ROLE { default \| 'arn:aws:iam:::role/'}
Use a palavra-chave padrão para que o Amazon Redshift use a função do IAM definida como padrão e associada ao cluster quando o comando CREATE MODEL for executado. Como alternativa, você pode especificar o ARN de um perfil do IAM para usar esse perfil.
MAX\_BATCH\_ROWS *inteiro*
O número máximo de linhas que o Amazon Redshift envia em uma única solicitação em lote para uma única invocação do SageMaker AI. Ele é compatível somente com BYOM com inferência remota. O número real de linhas em um lote também depende do tamanho da entrada, mas é menor ou igual a esse valor. O valor mínimo desse parâmetro é 1. O valor máximo é `INT_MAX` ou 2.147.483.647. Esse parâmetro é necessário somente quando os tipos de dados de entrada e retornados são `SUPER`. O valor padrão é `INT_MAX`, ou 2.147.483.647.
Quando o modelo é implantado em um endpoint do SageMaker AI, o SageMaker AI cria as informações do modelo no Amazon Redshift. Em seguida, executa a inferência através da função externa. Você pode usar o comando SHOW MODEL para exibir as informações do modelo no cluster do Amazon Redshift.
#### CREATE MODEL para observações de uso da inferência remota
Antes de usar CREATE MODEL para inferência remota, considere o seguinte:
+ O endpoint deve ser hospedado na mesma conta da AWS que possui o cluster do Amazon Redshift.
+ Verifique se o endpoint do Amazon SageMaker AI tem recursos suficientes para atender a chamadas de inferência do Amazon Redshift ou se o endpoint do Amazon SageMaker AI pode ser escalado automaticamente.
+ Se você não estiver usando o tipo de dados `SUPER` como entrada, o modelo só aceitará entradas no formato de valores separados por vírgula (CSV), o que corresponde ao tipo de conteúdo de `text/CSV` no SageMaker AI.
+ Se você não estiver usando o tipo de dados `SUPER` como entrada, a saída dos modelos será um valor único do tipo especificado ao criar a função. A saída está no formato de valores separados por vírgula (CSV) por meio de um tipo de conteúdo de `text/CSV` no SageMaker AI. Os tipos de dados `VARCHAR` não podem estar entre aspas e não podem conter novas linhas, e cada saída precisa estar em uma nova linha.
+ Os modelos aceitam nulos como strings vazias.
+ Quando o tipo de dados de entrada é `SUPER`, somente um argumento de entrada é permitido.
+ Quando o tipo de dados de entrada é `SUPER`, o tipo de dados retornado também deve ser `SUPER`.
+ MAX\_BATCH\_ROWS é necessário quando os tipos de dados de entrada e retornados são SUPER.
+ Quando o tipo de dados de entrada é `SUPER` o tipo de conteúdo da invocação do endpoint é `application/json` quando MAX\_BATCH\_ROWS é `1` ou `application/jsonlines` em todos os outros casos.
+ Quando o tipo de dados retornados é `SUPER` o tipo de aceitação da invocação do endpoint é `application/json` quando MAX\_BATCH\_ROWS é `1` ou `application/jsonlines` em todos os outros casos.
##### CREATE MODEL para exemplo de inferências remotas
O exemplo a seguir cria um modelo que usa o endpoint do SageMaker AI para fazer previsões. Certifique-se de que o endpoint está em execução para fazer previsões e especifique seu nome no comando CREATE MODEL.
```
CREATE MODEL remote_customer_churn
FUNCTION remote_fn_customer_churn_predict (varchar, int, float, float)
RETURNS int
SAGEMAKER 'customer-churn-endpoint'
IAM_ROLE default;
```
O exemplo a seguir cria um BYOM com inferência remota com um grande modelo de linguagem (LLM). Os LLMs hospedados no Amazon SageMaker AI Jumpstart aceitam e retornam o tipo de conteúdo `application/json` e permitem um único JSON por invocação. Os tipos de dados de entrada e retornados devem ser `SUPER` e MAX\_BATCH\_ROWS deve ser definido como 1.
```
CREATE MODEL sample_super_data_model
FUNCTION sample_super_data_model_predict(super)
RETURNS super
SAGEMAKER 'sample_super_data_model_endpoint'
IAM_ROLE default
SETTINGS (MAX_BATCH_ROWS 1);
```
## CREATE MODEL com K-MEANS
O Amazon Redshift oferece suporte ao algoritmo K-Means que agrupa dados que não são rotulados. Esse algoritmo resolve problemas de clusterização em que você deseja detectar agrupamentos nos dados. Os dados não classificados são agrupados e particionados de acordo com suas semelhanças e diferenças.
### CREATE MODEL com sintaxe K-MEANS
```
CREATE MODEL model_name
FROM { table_name | ( select_statement ) }
FUNCTION function_name
IAM_ROLE { default | 'arn:aws:iam:::role/' }
AUTO OFF
MODEL_TYPE KMEANS
PREPROCESSORS 'string'
HYPERPARAMETERS DEFAULT EXCEPT ( K 'val' [, ...] )
SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
KMS_KEY_ID 'kms_string', |
-- optional
S3_GARBAGE_COLLECT on / off, |
-- optional
MAX_CELLS integer, |
-- optional
MAX_RUNTIME integer
-- optional);
```
### CREATE MODEL com parâmetros K-MEANS
*AUTO OFF*
Desativa a descoberta automática de pré-processador, algoritmo e seleção de hiper-parâmetros do CREATE MODEL.
MODEL\_TYPE KMEANS
Especifica o uso do KMEANS para treinar o modelo.
PREPROCESSORS 'string'
Especifica certas combinações de pré-processadores para determinados conjuntos de colunas. O formato é uma lista de columnSets e as transformações apropriadas a serem aplicadas a cada conjunto de colunas. O Amazon Redshift oferece suporte a três pré-processadores K-Means: 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 os transformadores compatíveis, consulte [CREATE MODEL com parâmetros de orientação do usuário](#r_user_guidance-create-model-parameters).
O algoritmo K-Means usa a distância euclidiana para calcular a semelhança. O pré-processamento dos dados garante que os recursos do modelo permaneçam na mesma escala e produzam resultados confiáveis.
HYPERPARAMETERS DEFAULT EXCEPT ( K 'val' [, ...] )
Especifica se os parâmetros K-Means são usados. É necessário especificar o parâmetro `K` ao usar o algoritmo K-Means. Para obter mais informações, consulte [Hiperparâmetros do k-means](https://docs.aws.amazon.com/sagemaker/latest/dg/k-means-api-config.html) no *Guia do desenvolvedor do Amazon SageMaker AI*
O exemplo a seguir prepara dados para K-Means.
```
CREATE MODEL customers_clusters
FROM customers
FUNCTION customers_cluster
IAM_ROLE default
AUTO OFF
MODEL_TYPE KMEANS
PREPROCESSORS '[
{
"ColumnSet": [ "*" ],
"Transformers": [ "NumericPassthrough" ]
}
]'
HYPERPARAMETERS DEFAULT EXCEPT ( K '5' )
SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket');
select customer_id, customers_cluster(...) from customers;
customer_id | customers_cluster
--------------------
12345 1
12346 2
12347 4
12348
```
## CREATE MODEL com o Forecast
Os modelos de previsão no Redshift ML usam o Amazon Forecast para criar previsões precisas de séries temporais. Isso permite que você use dados históricos de um período para fazer previsões sobre eventos futuros. Os casos de uso comuns do Amazon Forecast incluem o uso de dados de produtos de varejo para decidir como definir os preços dos itens, dados de quantidade de fabricação para prever quanto de um item pedir e dados de tráfego da web para prever quanto tráfego um servidor da web pode receber.
Os [limites de cota do Amazon Forecast](https://docs.aws.amazon.com/forecast/latest/dg/limits.html) são aplicados nos modelos de previsão do Amazon Redshift. Por exemplo, o número máximo de previsões é 100, mas esse valor é ajustável. A eliminação de um modelo de previsão não exclui automaticamente os recursos associados no Amazon Forecast. Se você excluir um cluster do Redshift, todos os modelos associados também serão descartados.
Observe que, no momento, os modelos do Forecast só estão disponíveis nas seguintes regiões:
+ Leste dos EUA (Ohio) (us-east-2)
+ Leste dos EUA (Norte da Virgínia) (us-east-1)
+ Oeste dos EUA (Oregon) (us-west-2)
+ Ásia-Pacífico (Mumbai) (ap-south-1)
+ Ásia-Pacífico (Seul) (ap-northeast-2)
+ Ásia-Pacífico (Singapura) (ap-southeast-1)
+ Ásia-Pacífico (Sydney) (ap-southeast-2)
+ Ásia Pacific (Tóquio) (ap-northeast-1)
+ Europa (Frankfurt) (eu-central-1)
+ Europa (Irlanda) (eu-west-1)
### Sintaxe de CREATE MODEL com o Forecast
```
CREATE [ OR REPLACE ] MODEL forecast_model_name
FROM { table_name | ( select_query ) }
TARGET column_name
IAM_ROLE { default | 'arn:aws:iam:::role/'}
AUTO ON
MODEL_TYPE FORECAST
SETTINGS (
S3_BUCKET 'amzn-s3-demo-bucket',
HORIZON integer,
FREQUENCY forecast_frequency
[PERCENTILES '0.1', '0.5', '0.9']
)
```
### Parâmetros de CREATE MODEL com o Forecast
*forecast\_model\_name*
O nome do modelo. O nome do modelo deve ser exclusivo.
FROM { table\_name \| ( select\_query ) }
O table\_name ou a consulta que especifica os dados de treinamento. Isso pode ser uma tabela existente no sistema ou uma consulta SELECT compatível com o Amazon Redshift entre parênteses. O resultado da tabela ou consulta deve ter pelo menos três colunas: (1) uma coluna varchar que especifica o nome da série temporal (cada conjunto de dados pode ter várias séries temporais); (2) uma coluna de data e hora; e (3) a coluna de destino das previsões. Essa coluna de destino deve ser do tipo int ou float. Se você fornecer um conjunto de dados com mais de três colunas, o Amazon Redshift vai assumir que todas as colunas adicionais fazem parte de uma série temporal relacionada. Observe que as séries temporais relacionadas devem ser do tipo int ou float. Para obter mais informações sobre séries temporais relacionadas, consulte [Usar conjuntos de dados de séries temporais relacionadas](https://docs.aws.amazon.com/forecast/latest/dg/related-time-series-datasets.html).
TARGET column\_name
O nome da coluna que se torna o alvo da previsão. A coluna deve existir na cláusula FROM.
IAM\_ROLE { default \| 'arn:aws:iam:::role/'}
Use a palavra-chave padrão para que o Amazon Redshift use a função do IAM definida como padrão e associada ao cluster quando o comando CREAT MODEL for executado. Como alternativa, você pode especificar o ARN de um perfil do IAM para usar esse perfil.
AUTO ON
Ativa a descoberta automática da seleção de hiperparâmetros e algoritmo de CREATE MODEL. Especificar “on” ao criar um modelo do Forecast indica o uso de um Forecast AutoPredictor, em que o Amazon Forecast aplica as combinações ideais de algoritmos a cada série temporal em seu conjunto de dados.
MODEL\_TYPE FORECAST
Especifica o uso de FORECAST para treinar o modelo.
S3\_BUCKET 'amzn-s3-demo-bucket'
O nome do bucket do Amazon Simple Storage Service que você criou anteriormente e que é usado para compartilhar artefatos e dados de treinamento entre o Amazon Redshift e o Amazon Forecast. O Amazon Redshift cria uma subpasta neste bucket antes de descarregar os dados de treinamento. Quando o treinamento for concluído, o Amazon Redshift exclui a subpasta criada e seu conteúdo.
HORIZON integer
O número máximo de previsões que o modelo pode retornar. Depois que o modelo é treinado, não é possível alterar esse número inteiro.
FREQUENCY forecast\_frequency
Especifica o nível de detalhamento que você deseja que as previsões tenham. As opções disponíveis são `Y | M | W | D | H | 30min | 15min | 10min | 5min | 1min`. Obrigatório se você for treinar um modelo de previsão.
PERCENTILES string
Uma string delimitada por vírgula que especifica os tipos de previsão usados para treinar um previsor. Os tipos de previsão podem ser quantis de 0,01 a 0,99, em incrementos de 0,01 ou mais. Você também pode especificar a previsão média com mean. É possível especificar até cinco tipos de previsão.
O exemplo a seguir demonstra como criar um modelo de previsão simples.
```
CREATE MODEL forecast_example
FROM forecast_electricity_
TARGET target
IAM_ROLE 'arn:aws:iam:::role/'
AUTO ON
MODEL_TYPE FORECAST
SETTINGS (S3_BUCKET 'amzn-s3-demo-bucket',
HORIZON 24,
FREQUENCY 'H',
PERCENTILES '0.25,0.50,0.75,mean',
S3_GARBAGE_COLLECT OFF);
```
Depois de criar o modelo de previsão, você pode criar uma tabela com os dados da previsão.
```
CREATE TABLE forecast_model_results as SELECT Forecast(forecast_example)
```
Em seguida, você pode consultar a nova tabela para obter previsões.
```
SELECT * FROM forecast_model_results
```