Casos de uso - Amazon Redshift
CREATE MODEL simples CREATE MODEL com orientação do usuárioModelos CREATE XGBoost com AUTO OFFTraga seu próprio modelo (BYOM): inferência localTraga seu próprio modelo (BYOM): inferência remotaCREATE MODEL com K-MEANSCREATE MODEL com o Forecast

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::<account-id>:role/<role-name>' }

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 usou para compartilhar dados de treinamento e artefatos entre o Amazon Redshift e o SageMaker. 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.

Para obter mais informações sobre os custos associados a vários números de celular e detalhes de avaliação gratuita, consulte Preços do Amazon Redshift.

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.

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 na Referência da API do Amazon SageMaker.

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 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 o objetivos, consulte AutoMLJobObjective na Referência da API do Amazon SageMaker.

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::<account-id>:role/<role-name>' }
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 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.

Nome do parâmetro Valor do parâmetro Valor padrão Observações

num_class

 Inteiro

Necessário para a classificação Multiclass.

 N/D

num_round

 Inteiro

100

 N/D

tree_method

 String Auto N/D

max_depth

 Inteiro 6 [0, 10]
min_child_weight Float 1 MinValue: 0, MaxValue: 120
subsample Float 1 MinValue: 0.5, MaxValue: 1
gamma Float 0 MinValue: 0, MaxValue: 5
alpha Float 0 MinValue: 0, MaxValue: 1000
eta Float 0.3 MinValue: 0.1, MaxValue: 0.5
colsample_byleve Float 1 MinValue: 0.1, MaxValue: 1
colsample_bynode Float 1 MinValue: 0.1, MaxValue: 1
colsample_bytree Float 1 MinValue: 0.5, MaxValue: 1
lambda Float 1 MinValue: 0, MaxValue: 1000
max_delta_step Inteiro 0 [0, 10]

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 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 Autopilot e modelos treinados diretamente no Amazon SageMaker 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 como entrada. O nome de trabalho pode ser um nome de trabalho de treinamento do Amazon SageMaker ou um nome de trabalho do Amazon SageMaker 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. 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::<account-id>:role/<role-name>'}

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.

CREATE MODEL para exemplo de inferências locais

O exemplo a seguir cria um modelo que foi treinado anteriormente no Amazon SageMaker, 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 trabalho de treinamento do SageMaker.

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::<account-id>:role/<role-name>' }
[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 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 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. Se o nome do endpoint apontar para um endpoint multimodelo, adicione o nome do modelo a ser usado. Os endpoints devem estar na mesma região da AWS que o cluster do Amazon Redshift. Para encontrar o endpoint, inicie o Amazon SageMaker. No menu suspenso Inference (Inferência), escolha Endpoints.

IAM_ROLE { default | 'arn:aws:iam::<account-id>:role/<role-name>'}

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 invocação do SageMaker. 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, o SageMaker 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.

  • Certifique-se de que o endpoint do Amazon SageMaker tenha recursos suficientes para acomodar chamadas de inferência do Amazon Redshift ou que o endpoint do Amazon SageMaker possa 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írgulas (CSV), o que corresponde a um tipo de conteúdo de text/CSV no SageMaker.

  • 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írgulas (CSV) por meio de um tipo de conteúdo de text/CSV no SageMaker. 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 um endpoint do SageMaker 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 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::<account-id>:role/<role-name>' }
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.

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 no Guia do desenvolvedor do Amazon SageMaker

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 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::<account-id>:role/<role-name>'} 
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.

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::<account-id>:role/<role-name>' }

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::<account-id>:role/<role-name>'
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