Cas d’utilisation - Amazon Redshift
CREATE MODEL simple CREATE MODEL avec guide de l’utilisateurCommande CREATE pour des modèles XGBoost avec AUTO OFFModèle BYOM (Bring Your Own Model) : inférence localeModèle BYOM (Bring Your Own Model) : inférence distanteCREATE MODEL avec K-MEANSCREATE MODEL avec Forecast

Amazon Redshift ne prendra plus en charge la création de nouvelles fonctions Python définies par l’utilisateur à compter du 1er novembre 2025. Si vous souhaitez utiliser des fonctions Python définies par l’utilisateur, créez-les avant cette date. Les fonctions Python définies par l’utilisateur existantes continueront de fonctionner normalement. Pour plus d’informations, consultez le billet de blog .

Cas d’utilisation

Les cas d’utilisation suivants montrent comment utiliser la clause CREATE MODEL en fonction de vos besoins.

CREATE MODEL simple

Voici un résumé des options de base de la syntaxe CREATE MODEL.

Syntaxe CREATE MODEL simple

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 ]
)

Paramètres CREATE MODEL simples

model_name

Nom du modèle. Le nom du modèle d’un schéma doit être unique.

FROM { table_name | ( select_query ) }

Le table_name ou la requête qui spécifie les données d’entraînement. Il peut s’agir soit d’une table existante dans le système, soit d’une requête SELECT compatible avec Amazon RedShift entre parenthèses, c’est-à-dire (). Le résultat de la requête doit contenir au moins deux colonnes.

TARGET column_name

Nom de la colonne qui devient la cible de la prédiction. La colonne doit exister dans la clause FROM.

FUNCTION prediction_function_name

Valeur qui spécifie le nom de la fonction de machine learning Amazon Redshift à générer par le modèle CREATE MODEL et utilisée pour effectuer des prédictions à l’aide de ce modèle. La fonction est créée dans le même schéma que l’objet de modèle et peut être surchargée.

Le machine learning d’Amazon Redshift prend en charge les modèles tels que les modèles d’arbre Xtreme Gradient Boosted (XGBoost) pour la régression et la classification.

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

Utilisez le mot clé par défaut pour qu’Amazon Redshift utilise le rôle IAM défini comme rôle par défaut et associé au cluster lorsque la commande CREATE MODEL s’exécute. Vous pouvez également spécifier l’ARN d’un rôle IAM pour utiliser ce rôle.

S3_BUCKET ’amzn-s3-demo-bucket’

Nom du compartiment Amazon S3 que vous avez créé précédemment et qui est utilisé pour partager des données d’entraînement et des artefacts entre Amazon Redshift et SageMaker AI. Amazon Redshift crée un sous-dossier dans ce compartiment avant le déchargement des données d’entraînement. Lorsque l’entraînement est terminé, Amazon Redshift supprime le sous-dossier créé et son contenu.

MAX_CELLS integer

Nombre maximal de cellules à exporter à partir de la clause FROM. La valeur par défaut est 1 000 000.

Le nombre de cellules est le produit du nombre de lignes dans les données d’entraînement (produites par la table ou la requête de clause FROM) multiplié par le nombre de colonnes. Si le nombre de cellules dans les données d’entraînement est supérieur à celui spécifié par le paramètre max_cells, CREATE MODEL crée des sous-échantillons des données d’entraînement de la clause FROM pour réduire la taille du jeu de données d’entraînement en dessous de la valeur MAX_CELLS. Autoriser des jeux de données d’entraînement plus volumineux peut permettre de bénéficier d’une plus grande précision, mais peut également augmenter la durée et le coût d’entraînement du modèle.

Pour obtenir des informations sur les coûts d’utilisation d’Amazon Redshift, consultez Coûts d’utilisation d’Amazon Redshift ML.

Pour plus d’informations sur les coûts associés aux différents nombres de cellules et sur les détails de l’essai gratuit, consultez Tarification Amazon Redshift.

CREATE MODEL avec guide de l’utilisateur

Vous trouverez ci-dessous une description des options de CREATE MODEL en plus des options décrites dans CREATE MODEL simple.

Par défaut, CREATE MODEL recherche la meilleure combinaison de prétraitement et le meilleur modèle pour votre jeu de données spécifique. Il se peut que vous ayez besoin d’un contrôle plus poussé ou d’introduire des connaissances de domaine supplémentaires (comme le type de problème ou l’objectif) pour votre modèle. Dans un scénario de désabonnement client, si le résultat « client n’est pas actif » est rare, l’objectif F1 est souvent préféré à l’objectif Précision. Étant donné que les modèles à haute précision peuvent prédire « le client est actif » tout le temps, il en résulte une haute précision, mais peu de valeur opérationnelle. Pour obtenir des informations sur l’objectif F1, consultez AutoMLJobObjective dans la Référence API Amazon SageMaker AI.

Ensuite, le modèle CREATE suit vos suggestions sur les aspects spécifiés, tels que l’objectif. Dans le même temps, CREATE MODEL détecte automatiquement les meilleurs préprocesseurs et les meilleurs hyperparamètres.

CREATE MODEL avec syntaxe de guide de l’utilisateur

CREATE MODEL offre plus de flexibilité sur les aspects que vous pouvez spécifier et les aspects qu’Amazon Redshift détecte automatiquement.

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 avec paramètres de guide de l’utilisateur

MODEL_TYPE { XGBOOST | MLP | LINEAR_LEARNER }

(Facultatif) Spécifie le type de modèle. Vous pouvez spécifier si vous souhaitez entraîner un modèle d’un type spécifique, tel que XGBoost, perceptron multicouche (MLP) ou Linear Learner, qui sont tous des algorithmes pris en charge par Amazon SageMaker AI Autopilot. Si vous ne spécifiez pas le paramètre, tous les types de modèles pris en charge sont recherchés pendant l’entraînement pour trouver le meilleur modèle.

PROBLEM_TYPE ( REGRESSION | BINARY_CLASSIFICATION | MULTICLASS_CLASSIFICATION )

(Facultatif) Spécifie le type de problème. Si vous connaissez le type de problème, vous pouvez limiter la recherche Amazon Redshift au meilleur modèle de ce type en particulier. Si vous ne spécifiez pas ce paramètre, un type de problème est détecté pendant l’entraînement, en fonction de vos données.

OBJECTIVE ( ’MSE’ | ’Accuracy’ | ’F1’ | ’F1Macro’ | ’AUC’)

(Facultatif) Spécifie le nom de la métrique d’objectif utilisée pour mesurer la qualité prédictive d’un système de machine learning. Cette métrique est optimisée pendant l’entraînement afin de fournir la meilleure estimation des valeurs des paramètres du modèle à partir des données. Si vous ne spécifiez pas de métrique explicitement, le comportement par défaut consiste à utiliser automatiquement MSE : pour la régression, F1 : pour la classification binaire, Précision : pour la classification multiclasse. Pour plus d’informations sur les objectifs, consultez AutoMLJobObjective dans la Référence API Amazon SageMaker AI.

MAX_CELLS integer

(Facultatif) Spécifie le nombre de cellules dans les données d’entraînement. Cette valeur est le produit du nombre d’enregistrements (dans la requête d’entraînement ou dans la table) multiplié par le nombre de colonnes. La valeur par défaut est 1 000 000.

MAX_RUNTIME integer

(Facultatif) Spécifie la durée maximale d’entraînement. Les tâches d’entraînement se terminent souvent plus tôt en fonction de la taille du jeu de données. Ce nombre spécifie la durée maximale de l’entraînement. La valeur par défaut est 5 400 (90 minutes).

S3_GARBAGE_COLLECT { ON | OFF }{SUR | OFF}

(Facultatif) Spécifie si Amazon Redshift lance le récupérateur de mémoire sur les jeux de données obtenus utilisés pour entraîner les modèles et sur les modèles. Si la valeur est définie sur OFF, les jeux de données obtenus utilisés pour entraîner les modèles et les modèles eux-mêmes restent dans Amazon S3 et peuvent être utilisés à d’autres fins. Si la valeur est définie sur ON, Amazon Redshift supprime les artefacts dans Amazon S3 une fois l’entraînement terminé. La valeur par défaut est ON.

KMS_KEY_ID ’kms_key_id’

(Facultatif) Spécifie si Amazon Redshift utilise le chiffrement côté serveur avec une clé AWS KMS pour protéger les données au repos. Les données en transit sont protégées par le protocole SSL.

PREPROCESSORS ’string’

(Facultatif) Spécifie certaines combinaisons de préprocesseurs à certains ensembles de colonnes. Le format est une liste de columnSets et les transformations appropriées à appliquer à chaque ensemble de colonnes. Amazon Redshift applique tous les transformateurs d’une liste de transformateurs spécifique à toutes les colonnes du ColumnSet correspondant. Par exemple, pour appliquer OneHotEncoder avec Imputer aux colonnes t1 et t2, utilisez l’exemple de commande ci-dessous.

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'
)

Amazon Redshift prend en charge les transformateurs suivants :

  • OneHotEncoder : généralement utilisé pour encoder une valeur discrète dans un vecteur binaire avec une valeur différente de zéro. Ce transformateur convient à de nombreux modèles de machine learning.

  • OrdinalEncoder : encode les valeurs discrètes en un seul nombre entier. Ce transformateur convient à certains modèles de machine learning, tels que MLP et Linear Learner.

  • NumericPassthrough : transmet l’entrée telle quelle dans le modèle.

  • Imputer : remplit les valeurs manquantes et les valeurs qui ne sont pas un nombre (NaN).

  • ImputerWithIndicator : remplit les valeurs manquantes et les valeurs NaN. Ce transformateur crée également un indicateur indiquant si des valeurs étaient manquantes et ont été emplies.

  • Normalizer : normalise les valeurs, ce qui peut améliorer les performances de nombreux algorithmes de machine learning.

  • DateTimeVectorizer : crée une intégration de vecteur, représentant une colonne de type de données datetime pouvant être utilisée dans les modèles de machine learning.

  • PCA : projette les données dans un espace dimensionnel inférieur afin de réduire le nombre de fonctions tout en conservant autant d’informations que possible.

  • StandardScaler – Normalise les fonctions en supprimant la moyenne et en la mise à l’échelle en fonction de la variance unitaire.

  • MinMax – Transforme les fonctions en mettant à l’échelle chaque fonction en une plage donnée.

Amazon Redshift ML stocke les transformateurs entraînés et les applique automatiquement dans le cadre de la requête de prédiction. Vous n’avez pas besoin de les spécifier lorsque vous générez des prédictions à partir de votre modèle.

Commande CREATE pour des modèles XGBoost avec AUTO OFF

En général, la commande AUTO OFF CREATE MODEL a des objectifs différents de ceux de la commande CREATE MODE par défaut.

Si vous êtes utilisateur avancé qui connaît déjà le type de modèle souhaité et les hyperparamètres à utiliser lors de l’entraînement de ces modèles, vous pouvez utiliser CREATE MODEL avec AUTO OFF pour désactiver la détection automatique CREATE MODEL des préprocesseurs et des hyperparamètres. Pour ce faire, vous spécifiez explicitement le type de modèle. XGBoost est actuellement le seul type de modèle pris en charge lorsque AUTO est défini sur OFF. Vous pouvez spécifier des hyperparamètres. Amazon Redshift utilise des valeurs par défaut pour tous les hyperparamètres que vous avez spécifiés.

Modèles CREATE XGBoost avec syntaxe 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 (, ...)
)

Commande CREATE pour des modèles XGBoost avec des paramètres AUTO OFF

AUTO OFF

Désactive la détection automatique CREATE MODEL du préprocesseur, de l’algorithme et de la sélection d’hyperparamètres.

MODEL_TYPE XGBOOST

Indiquer d’utiliser XGBOOST pour entraîner le modèle.

OBJECTIVE str

Spécifie un objectif reconnu par l’algorithme. Amazon Redshift prend en charge reg:squarederror, reg:squaredlogerror, reg:logistic, reg:pseudohubererror, reg:tweedie, binary:logistic, binary:hinge, multi:softmax. Pour plus d’informations sur ces objectifs, consultez Learning Task Parameters (Apprendre les paramètres des tâches) dans la documentation XGBoost.

HYPERPARAMETERS { DEFAULT | DEFAULT EXCEPT ( key ‘value’ (,..) ) }

Spécifie si les paramètres XGBoost par défaut sont utilisés ou remplacés par des valeurs spécifiées par l’utilisateur. Les valeurs doivent être entre guillemets simples. Voici des exemples de paramètres pour XGBoost et leurs valeurs par défaut.

Nom du paramètre Valeur de paramètre Valeur par défaut Remarques

num_class

 Entier

Requis pour la classification multiclasse.

 N/A

num_round

 Entier

100

 N/A

tree_method

 Chaîne Auto N/A

max_depth

 Entier 6 [0 , 10]
min_child_weight Float 1 Valeur min. : 0, valeur max. : 120
subsample Float 1 Valeur min. : 0,5, valeur max. : 1
gamma Float 0 Valeur min. : 0, valeur max. : 5
alpha Float 0 Valeur min. : 0, valeur max. : 1 000
eta Float 0.3 Valeur min. : 0,1, valeur max. : 0,5
colsample_byleve Float 1 Valeur min. : 0,1, valeur max. : 1
colsample_bynode Float 1 Valeur min. : 0,1, valeur max. : 1
colsample_bytree Float 1 Valeur min. : 0,5, valeur max. : 1
lambda Float 1 Valeur min. : 0, valeur max. : 1 000
max_delta_step Entier 0 [0, 10]

L’exemple suivant prépare des données pour 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;

L’exemple suivant crée un modèle XGBoost avec des options avancées spécifiées, telles que MODEL_TYPE, OBJECTIVE et 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');

L’exemple suivant utilise une requête d’inférence pour prédire l’âge du poisson dont le nombre d’enregistrements est supérieur à 2 500. Il utilise la fonction ml_fn_abalone_xgboost_multi_predict_age créée à partir de la commande ci-dessus. 

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;

Modèle BYOM (Bring Your Own Model) : inférence locale

Amazon Redshift ML prend en charge l’utilisation du modèle BYOM pour l’inférence locale.

Vous trouverez ci-dessous un résumé des options de syntaxe CREATE MODEL pour le modèle BYOM. Vous pouvez utiliser un modèle entraîné en dehors d’Amazon Redshift avec Amazon SageMaker AI pour l’inférence locale en base de données dans Amazon Redshift.

Syntaxe CREATE MODEL pour l’inférence locale

Voici une description de la syntaxe CREATE MODEL pour l’inférence locale.

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

Amazon Redshift ne prend actuellement en charge que les modèles préentraînés XGBoost, MLP et Linear Learner pour le modèle BYOM. Vous pouvez importer SageMaker AI Autopilot et les modèles directement entraînés dans Amazon SageMaker AI à des fins d’inférence locale à l’aide de ce chemin.

Paramètres CREATE MODEL pour l’inférence locale

model_name

Nom du modèle. Le nom du modèle d’un schéma doit être unique.

FROM (’job_name’ | ’s3_path’ )

job_name utilise un nom de tâche Amazon SageMaker AI comme entrée. Le nom de tâche peut être un nom de tâche d’entraînement Amazon SageMaker AI ou un nom de tâche Amazon SageMaker AI Autopilot. La tâche doit être créée dans le compte AWS propriétaire du cluster Amazon Redshift. Pour trouver le nom de la tâche, lancez Amazon SageMaker AI. Dans le menu déroulant Training (Entraînement), choisissez Training jobs (Tâches d’entraînement).

’s3_path’ spécifie l’emplacement S3 du fichier d’artefacts de modèle .tar.gz à utiliser lors de la création du modèle.

FUNCTION function_name ( data_type [, ...] )

Nom de la fonction à créer et types de données des arguments d’entrée. Vous pouvez spécifier un nom de schéma.

RETURNS type_données

Type de données de la valeur renvoyée par la fonction.

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

Utilisez le mot clé par défaut pour qu’Amazon Redshift utilise le rôle IAM défini comme rôle par défaut et associé au cluster lorsque la commande CREATE MODEL s’exécute.

Utilisez l’Amazon Resource Name (ARN) d’un rôle IAM que votre cluster utilise pour l’authentification et l’autorisation.

SETTINGS ( S3_BUCKET ’amzn-s3-demo-bucket’, | KMS_KEY_ID ’kms_string’)

La clause S3_BUCKET spécifie l’emplacement Amazon S3 utilisé pour stocker les résultats intermédiaires.

(Facultatif) La clause KMS_KEY_ID spécifie si Amazon Redshift utilise le chiffrement côté serveur avec une clé AWS KMS pour protéger les données au repos. Les données en transit sont protégées par le protocole SSL.

Pour plus d'informations, consultez CREATE MODEL avec guide de l’utilisateur.

Exemple CREATE MODEL pour l’inférence locale

L’exemple suivant crée un modèle qui a déjà été entraîné dans Amazon SageMaker AI, en dehors d’Amazon Redshift. Étant donné que le type de modèle est pris en charge par le ML d’Amazon Redshift pour l’inférence locale, la commande CREATE MODEL suivante crée une fonction qui peut être utilisée localement dans Amazon Redshift. Vous pouvez fournir un nom de tâche d’entraînement 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');

Une fois le modèle créé, vous pouvez utiliser la fonction customer_churn_predict avec les types d’arguments spécifiés pour effectuer des prédictions.

Modèle BYOM (Bring Your Own Model) : inférence distante

Amazon Redshift ML prend également en charge l’utilisation du modèle BYOM pour l’inférence distante.

Vous trouverez ci-dessous un résumé des options de syntaxe CREATE MODEL pour le modèle BYOM.

Syntaxe CREATE MODEL pour l’inférence distante

Voici une description de la syntaxe CREATE MODEL pour l’inférence distante.

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)];

Paramètres CREATE MODEL pour l’inférence distante

model_name

Nom du modèle. Le nom du modèle d’un schéma doit être unique.

FUNCTION fn_name ( [data_type] [, ...] )

Nom de la fonction et types de données des arguments d’entrée. Consultez Types de données pour connaître tous les types de données pris en charge. Geography, geometry et hllsketch ne sont pas pris en charge.

Vous pouvez également fournir un nom de fonction dans un schéma en utilisant une notation en deux parties, telle que myschema.myfunction.

RETURNS type_données

Type de données de la valeur renvoyée par la fonction. Consultez Types de données pour connaître tous les types de données pris en charge. Geography, geometry et hllsketch ne sont pas pris en charge.

SAGEMAKER ’endpoint_name’[:’model_name’]

Nom du point de terminaison Amazon SageMaker AI. Si le nom du point de terminaison pointe vers un point de terminaison multimodèle, ajoutez le nom du modèle à utiliser. Le point de terminaison doit être hébergé dans la même région AWS et le même Compte AWS que le cluster Amazon Redshift. Pour trouver votre point de terminaison, lancez Amazon SageMaker AI. Dans le menu déroulant Inference (Inférence), choisissez Endpoints (Points de terminaison).

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

Utilisez le mot clé par défaut pour qu’Amazon Redshift utilise le rôle IAM défini comme rôle par défaut et associé au cluster lorsque la commande CREATE MODEL s’exécute. Vous pouvez également spécifier l’ARN d’un rôle IAM pour utiliser ce rôle.

MAX_BATCH_ROWS entier

Nombre maximum de lignes qu’Amazon Redshift envoie dans une seule demande par lot pour une seule invocation SageMaker AI. Uniquement prise en charge pour BYOM avec inférence à distance. Le nombre réel de lignes dans un lot dépend également de la taille d’entrée, mais il est inférieur ou égal à cette valeur. La valeur minimale pour ce paramètre est 1. La valeur maximale est INT_MAX ou 2 147 483 647. Ce paramètre n’est obligatoire que lorsque les types de données en entrée et en sortie sont de type SUPER. La valeur maximale est INT_MAX ou 2 147 483 647.

Lorsque le modèle est déployé sur un point de terminaison SageMaker AI, SageMaker AI crée les informations du modèle dans Amazon Redshift. Il effectue ensuite une inférence à travers la fonction externe. Vous pouvez utiliser la commande SHOW MODEL pour afficher les informations de modèle sur votre cluster Amazon Redshift.

CREATE MODEL pour les notes d’utilisation d’inférence distante

Avant d’utiliser CREATE MODLE pour l’inférence distante, tenez compte des éléments suivants :

  • Le point de terminaison doit être hébergé par le compte AWS propriétaire du cluster Amazon Redshift.

  • Assurez-vous que le point de terminaison Amazon SageMaker AI dispose de suffisamment de ressources pour accueillir les appels d’inférence provenant d’Amazon Redshift ou que le point de terminaison Amazon SageMaker AI peut être automatiquement mis à l’échelle.

  • Si vous n’utilisez pas le type de données SUPER en entrée, le modèle accepte uniquement les entrées au format CSV (valeurs séparées par des virgules) qui correspondent à un type de contenu text/CSV dans SageMaker AI.

  • Si vous n’utilisez pas le type de données SUPER en entrée, la sortie des modèles est une valeur unique du type spécifié lors de la création de la fonction. La sortie est au format CSV (valeurs séparées par des virgules) via un type de contenu text/CSV dans SageMaker AI. Les types de données VARCHAR ne peuvent pas être placés entre guillemets et ne peuvent pas contenir de nouvelles lignes. Chaque sortie doit figurer sur une nouvelle ligne.

  • Les modèles acceptent les valeurs NULL comme chaînes vides.

  • Lorsque les données d’entrée sont de type SUPER, un seul argument d’entrée est pris en charge.

  • Lorsque les données d’entrée sont de type SUPER, le type de données renvoyé doit également être SUPER.

  • MAX_BATCH_ROWS est requis lorsque les données en entrée et en sortie sont de type SUPER.

  • Lorsque les données d’entrée sont de type SUPER, le type de contenu du point de terminaison est soit application/json lorsque MAX_BATCH_ROWS est 1, soit application/jsonlines dans tous les autres cas.

  • Lorsque les données de sortie sont de type SUPER, le type d’acceptation du point de terminaison est soit application/json lorsque MAX_BATCH_ROWS est 1, soit application/jsonlines dans tous les autres cas.

Exemple de CREATE MODEL pour l’inférence distante

L’exemple suivant crée un modèle qui utilise un point de terminaison SageMaker AI pour effectuer des prédictions. Assurez-vous que le point de terminaison est en cours d’exécution pour effectuer des prédictions et spécifiez son nom dans la commande 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;

L’exemple suivant crée un BYOM avec inférence à distance avec un grand modèle de langage (LLM). Les grands modèles de langage hébergés sur Amazon SageMaker AI Jumpstart acceptent et renvoient le type de contenu application/json et prennent en charge un seul JSON par appel. Les données d’entrée et de sortie doivent être de type SUPER et MAX_BATCH_ROWS doit être défini sur 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 avec K-MEANS

Amazon Redshift prend en charge l’algorithme K-Means qui regroupe des données non étiquetées. Cet algorithme résout les problèmes de mise en cluster lorsque vous souhaitez découvrir des regroupements dans les données. Les données non classifiées sont regroupées et partitionnées en fonction de leurs similitudes et de leurs différences.

CREATE MODEL avec la syntaxe 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 avec les paramètres K-MEANS

AUTO OFF

Désactive la détection automatique CREATE MODEL du préprocesseur, de l’algorithme et de la sélection d’hyperparamètres.

MODEL_TYPE KMEANS

Permet de spécifier l’utilisation de KMEANS pour entraîner le modèle.

PREPROCESSORS ’string’

Spécifie certaines combinaisons de préprocesseurs à certains ensembles de colonnes. Le format est une liste de columnSets et les transformations appropriées à appliquer à chaque ensemble de colonnes. Amazon Redshift prend en charge trois préprocesseurs K-Means, à savoir StandardScaler, MinMax et NumericPassthrough. Si vous ne souhaitez pas appliquer de prétraitement pour K-Means, choisissez NumericPassthrough explicitement en tant que transformateur. Pour plus d’informations sur les transformateurs pris en charge, consultez CREATE MODEL avec paramètres de guide de l’utilisateur.

L’algorithme K-Means utilise la distance euclidienne pour calculer la similarité. Le prétraitement des données garantit que les fonctions du modèle restent à la même échelle et produisent des résultats fiables.

HYPERPARAMETERS DEFAULT EXCEPT ( K ’val’ [, ...] )

Spécifie si les paramètres K-Means sont utilisés. Vous devez spécifier le paramètre K lors de l’utilisation de l’algorithme K-Means. Pour plus d’informations, consultez Hyperparamètres pour k-moyennes (K-Means) dans le Guide du développeur Amazon SageMaker AI

L’exemple suivant prépare des données pour 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 avec Forecast

Les modèles de prévisions de Redshift ML utilisent Amazon Forecast pour créer des prévisions chronologiques précises. Cela vous permet d’utiliser des données historiques sur une période donnée pour faire des prédictions sur des événements futurs. Les cas d’utilisation courants d’Amazon Forecast incluent l’utilisation des données sur les produits vendus au détail pour déterminer le prix des stocks, les données de quantité de fabrication pour prédire la quantité à commander d’un article et les données de trafic Web pour prévoir le volume de trafic qu’un serveur Web est susceptible de recevoir.

Les limites de quota d’Amazon Forecast sont appliquées dans les modèles de prévisions Amazon Redshift. Par exemple, le nombre maximum de prévisions est de 100, mais il est ajustable. La suppression d’un modèle de prévision ne supprime pas automatiquement les ressources associées dans Amazon Forecast. Si vous supprimez un cluster Redshift, tous les modèles associés sont également supprimés.

Notez que les modèles de prévisions ne sont actuellement disponibles que dans les régions suivantes :

  • USA Est (Ohio) (us-east-2)

  • USA Est (Virginie du Nord) (us-east-1)

  • USA Ouest (Oregon) (us-west-2)

  • Asie-Pacifique (Mumbai) (ap-south-1)

  • Asie-Pacifique (Séoul) (ap-northeast-2)

  • Asie-Pacifique (Singapour) (ap-southeast-1)

  • Asie-Pacifique (Sydney) (ap-southeast-2)

  • Asie-Pacifique (Tokyo) (ap-northeast-1)

  • Europe (Francfort) (eu-central-1)

  • Europe (Irlande) (eu-west-1)

CREATE MODEL avec une syntaxe 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']
  )

CREATE MODEL avec des paramètres Forecast

forecast_model_name

Nom du modèle. Le nom du modèle doit être unique.

FROM { table_name | ( select_query ) }

Le table_name ou la requête qui spécifie les données d’entraînement. Il peut s’agir d’une table existante dans le système ou d’une requête SELECT compatible avec Amazon RedShift, placée entre parenthèses. Le résultat de la table ou de la requête doit comporter au moins trois colonnes : (1) une colonne varchar qui indique le nom de la série chronologique. Chaque jeu de données peut comporter plusieurs séries chronologiques ; (2) une colonne date/heure ; et (3) la colonne cible pour les prévisions. Cette colonne cible doit être un nombre entier ou à virgule flottante. Si vous fournissez un jeu de données comportant plus de trois colonnes, Amazon Redshift part du principe que toutes les colonnes supplémentaires font partie d’une série chronologique associée. Notez que les séries chronologiques associées doivent être de type nombre entier ou à virgule flottante. Pour plus d’informations sur les séries chronologiques associées, consultez Utilisation de jeux de données de séries chronologiques associés.

TARGET column_name

Nom de la colonne qui devient la cible de la prédiction. La colonne doit exister dans la clause FROM.

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

Utilisez le mot clé par défaut pour qu’Amazon Redshift utilise le rôle IAM défini comme rôle par défaut et associé au cluster lorsque la commande CREATE MODEL s’exécute. Vous pouvez également spécifier l’ARN d’un rôle IAM pour utiliser ce rôle.

AUTO ON

Active la détection automatique CREATE MODEL de l’algorithme et de la sélection d’hyperparamètres. L’activation de cette option lors de la création d’un modèle de prévision indique l’utilisation d’un prédicteur automatique de prévision, dans lequel Amazon Forecast applique les combinaisons optimales d’algorithmes à chaque série chronologique de votre jeu de données.

MODEL_TYPE FORECAST

Permet de spécifier l’utilisation de FORECAST pour entraîner le modèle.

S3_BUCKET ’amzn-s3-demo-bucket’

Nom du compartiment Amazon Simple Storage Service que vous avez créé précédemment et qui est utilisé pour partager des données d’entraînement et des artefacts entre Amazon Redshift et Amazon Forecast. Amazon Redshift crée un sous-dossier dans ce compartiment avant de décharger les données d’entraînement. Lorsque l’entraînement est terminé, Amazon Redshift supprime le sous-dossier créé et son contenu.

Entier HORIZON

Le nombre maximum de prédictions que le modèle de prévision peut renvoyer. Une fois le modèle entraîné, vous ne pouvez pas modifier cet entier.

FREQUENCY forecast_frequency

Indique le degré de granularité que vous souhaitez pour les prévisions. Les options disponibles sont Y | M | W | D | H | 30min | 15min | 10min | 5min | 1min. Obligatoire si vous entraînez un modèle de prévision.

Chaîne PERCENTILES

Une chaîne délimitée par des virgules qui spécifie les types de prévisions utilisés pour entraîner un prédicteur. Les types de prévisions peuvent être des quantiles compris entre 0,01 et 0,99, par incréments de 0,01 ou plus. Vous pouvez également spécifier la prévision moyenne à l’aide de la moyenne. Vous pouvez spécifier un maximum de cinq types de prévisions.

L’exemple suivant montre comment créer un modèle de prévision simple.

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

Après avoir créé le modèle de prévision, vous pouvez créer une nouvelle table contenant les données de prédiction.

CREATE TABLE forecast_model_results as SELECT Forecast(forecast_example)

Vous pouvez ensuite interroger la nouvelle table pour obtenir des prédictions.

SELECT * FROM forecast_model_results