Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Algorithme d'apprentissage linéaire
Les *modèles linéaires* sont des algorithmes d'apprentissage supervisés, utilisés pour résoudre les problèmes de régression ou de classification. Comme entrée, vous fournissez les exemples étiquetés du modèle (*x*, *y*). *x* est un vecteur hautement dimensionnel et *y* une étiquette numérique. Pour les problèmes de classification binaire, l'étiquette doit être 0 ou 1. Pour les problèmes de classification multi-classes, les étiquettes doivent être comprises entre 0 et `num_classes` -1. Pour les problèmes de régression, *y* est un nombre réel. L'algorithme apprend une fonction linéaire ou, pour les problèmes de classification, une fonction de seuil linéaire, et mappe un vecteur *x* à une approximation de l'étiquette *y*.
L'algorithme d'apprentissage linéaire Amazon SageMaker AI fournit une solution aux problèmes de classification et de régression. Grâce à l'algorithme d' SageMaker IA, vous pouvez explorer simultanément différents objectifs d'entraînement et choisir la meilleure solution parmi un ensemble de validation. Vous pouvez également explorer un grand nombre de modèles et choisir le meilleur. Le meilleur modèle optimise l'une des actions suivantes :
+ Objectif continu, comme l'erreur quadratique moyenne, la perte d'entropie croisée, l'erreur absolue.
+ Objectifs indépendants adaptés à la classification, comme la mesure F1, la précision, le rappel ou l'exactitude.
Comparé aux méthodes qui fournissent une solution uniquement pour des objectifs continus, l'algorithme d'apprentissage linéaire SageMaker basé sur l'IA permet une augmentation significative de la vitesse par rapport aux techniques naïves d'optimisation des hyperparamètres. Il est également plus commode.
L'algorithme d'apprentissage linéaire requiert une matrice de données, avec les lignes correspondant aux observations et les colonnes aux dimensions des caractéristiques. Il nécessite également une colonne supplémentaire contenant les étiquettes qui correspondent aux points de données. Amazon SageMaker AI Linear Learner vous demande au minimum de spécifier les emplacements des données d'entrée et de sortie, ainsi que le type d'objectif (classification ou régression) comme arguments. La dimension de fonction est également requise. Pour de plus amples informations, veuillez consulter [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Vous pouvez spécifier des paramètres supplémentaires dans le mappage de la chaîne `HyperParameters` du corps de la demande. Ces paramètres contrôlent la procédure d'optimisation ou les spécificités de la fonction d'objective que vous entraînez. Par exemple, le nombre de périodes (epoch), la régularisation et le type de perte.
Si vous utilisez l'[entraînement Spot géré](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html), l'algorithme d'apprentissage linéaire prend en charge l'utilisation de [points de contrôle pour prendre un instantané du statut du modèle](https://docs.aws.amazon.com/sagemaker/latest/dg/model-checkpoints.html).
**Topics**
+ [Interface d'entrée/sortie pour l'algorithme d'apprentissage linéaire](#ll-input_output)
+ [Recommandations relatives aux instances EC2 pour l'algorithme d'apprentissage linéaire](#ll-instances)
+ [Exemples de blocs-notes d'apprentissage linéaire](#ll-sample-notebooks)
+ [Fonctionnement de l'apprentissage linéaire](ll_how-it-works.md)
+ [Hyperparamètres de l'apprentissage linéaire](ll_hyperparameters.md)
+ [Régler un modèle d'apprentissage linéaire](linear-learner-tuning.md)
+ [Formats de réponse d'apprentissage linéaire](LL-in-formats.md)
## Interface d'entrée/sortie pour l'algorithme d'apprentissage linéaire
L'algorithme d'apprentissage linéaire d'Amazon SageMaker AI prend en charge trois canaux de données : le train, la validation (facultatif) et le test (facultatif). Si vous fournissez des données de validation, `S3DataDistributionType` doit être `FullyReplicated`. L'algorithme enregistre la perte de validation à chaque époque et utilise un échantillon des données de validation pour calibrer le meilleur modèle et le sélectionner. Si vous ne fournissez pas de données de validation, l'algorithme utilise un échantillon des données d'entraînement pour calibrer le modèle et le sélectionner. Si vous fournissez les données de test, les journaux de l'algorithme contiennent le score de test du modèle final.
**Pour l'entraînement**, l'algorithme d'apprentissage linéaire prend en charge les formats `recordIO-wrapped protobuf` et `CSV`. Pour le type d'entrée `application/x-recordio-protobuf`, seuls les tenseurs Float32 sont pris en charge. Pour le type d'entrée `text/csv`, la première colonne est supposée être l'étiquette, laquelle est la variable cible de la prédiction. Vous pouvez utiliser le mode File ou le mode Pipe pour entraîner les modèles d'apprentissage linéaire sur les données obéissant au format `recordIO-wrapped-protobuf` ou au format `CSV`.
**Pour l'inférence**, l'algorithme d'apprentissage linéaire prend en charge les formats `application/json`, `application/x-recordio-protobuf` et `text/csv`. Lorsque vous effectuez des prédictions sur de nouvelles données, le format de la réponse dépend du type de modèle. **Pour la régression** (`predictor_type='regressor'`), l'élément `score` est la prédiction produite par le modèle. **Pour la classification** (`predictor_type='binary_classifier'` ou `predictor_type='multiclass_classifier'`), le modèle renvoie un `score` et un `predicted_label`. L'élément `predicted_label` est la classe prédite par le modèle et `score` mesure la puissance de prédiction.
+ **Pour la classification binaire**, `predicted_label` est `0` ou `1`, et `score` est un nombre à virgule flottante unique qui indique à quel point l'algorithme estime que l'étiquette doit être 1.
+ **Pour la classification multi-classes**, `predicted_class` est un nombre entier de `0` à `num_classes-1`, et `score` sera une liste comportant un nombre à virgule flottante par classe.
Pour interpréter `score` dans les problèmes de classification, vous devez envisager la fonction de perte utilisée. Si la valeur de l’hyperparamètre `loss` est `logistic` pour la classification binaire ou `softmax_loss` pour la classification multi-classes, `score` peut être interprété comme la probabilité de la classe correspondante. Ce sont les valeurs de perte utilisées par l'apprenant linéaire lorsque la valeur de `loss` est la valeur par défaut `auto`. Mais si la perte est défini sur `hinge_loss`, le score ne peut pas être interprété comme une probabilité. En effet, la perte correspond à un classificateur de vecteur de support, ce qui signifie qu'elle ne produit pas d'estimations de probabilité.
Pour plus d’informations sur les formats de fichiers d’entrée et de sortie, consultez [Formats de réponse d'apprentissage linéaire](LL-in-formats.md). Pour plus d’informations sur les formats d’inférence, consultez [Exemples de blocs-notes d'apprentissage linéaire](#ll-sample-notebooks).
## Recommandations relatives aux instances EC2 pour l'algorithme d'apprentissage linéaire
L'algorithme d'apprentissage linéaire prend en charge les instances de CPU et de GPU pour l'entraînement et l'inférence. Pour les GPU, l'algorithme d'apprentissage linéaire prend en charge les familles de GPU P2, P3, G4dn et G5.
Pendant les tests, nous n'avons pas trouvé de preuve substantielle que les instances à plusieurs GPU seraient plus rapides que les instances à un seul GPU. Les résultats peuvent varier, en fonction de votre cas d'utilisation spécifique.
## Exemples de blocs-notes d'apprentissage linéaire
Le tableau suivant présente une variété d'exemples de blocs-notes qui abordent différents cas d'utilisation de l'algorithme d'apprentissage linéaire Amazon SageMaker AI.
| **Titre du bloc-notes** | **Description** |
| --- | --- |
| [Introduction avec le jeu de données MNIST](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/linear_learner_mnist/linear_learner_mnist.html) | À l'aide du jeu de données MNIST, nous entraînons un classificateur binaire pour prédire un seul chiffre. |
| [Comment créer un classificateur multi-classes ?](https://sagemaker-examples.readthedocs.io/en/latest/scientific_details_of_algorithms/linear_learner_multiclass_classification/linear_learner_multiclass_classification.html) | À l’aide du jeu de données Covertype d’UCI, nous montrons comment entraîner un classificateur multi-classes. |
| [Comment créer un pipeline de Machine Learning (ML) pour inférence ?](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-python-sdk/scikit_learn_inference_pipeline/Inference%20Pipeline%20with%20Scikit-learn%20and%20Linear%20Learner.html) | À l'aide d'un conteneur Scikit-learn, nous montrons comment créer un end-to-end pipeline ML. |
Pour obtenir des instructions sur la façon de créer et d'accéder à des instances de bloc-notes Jupyter que vous pouvez utiliser pour exécuter l'exemple dans SageMaker AI, consultez. [Instances de SageMaker blocs-notes Amazon](nbi.md) Après avoir créé une instance de bloc-notes et l'avoir ouverte, choisissez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Les exemples de blocs-notes de modélisation de rubrique utilisant les algorithmes NTM se trouvent dans la section **Introduction to Amazon algorithms** (Présentation des algorithmes Amazon). Pour ouvrir un bloc-notes, choisissez son onglet **Use** (Utiliser), puis **Create copy** (Créer une copie).
# Fonctionnement de l'apprentissage linéaire
Il existe trois étapes associées à la mise en œuvre de l'algorithme d'apprentissage linéaire : prétraiter, entraîner et valider.
## Étape 1 : Prétraiter
La normalisation, ou dimensionnement de fonction, est une étape de prétraitement importante pour certaines fonctions de perte, qui garantit que le modèle entraîné sur un ensemble de données ne soit pas dominé par le poids d'une seule fonction. L'algorithme Amazon SageMaker AI Linear Learner dispose d'une option de normalisation pour faciliter cette étape de prétraitement. Si la normalisation est activée, l'algorithme traite d'abord un petit échantillon de données pour apprendre la valeur moyenne et l'écart type pour chaque fonction et pour l'étiquette. Chacune des fonctions de l'ensemble de données complet est ensuite déplacée pour avoir une moyenne égale à zéro et dimensionnée de sorte à avoir un écart type unitaire.
**Note**
Pour obtenir de meilleurs résultats, assurez-vous que vos données sont réorganisées aléatoirement avant l'entraînement. Un entraînement avec des données non réorganisée peut entraîner l'échec de l'entraînement.
Vous pouvez configurer si l'algorithme d'apprentissage linéaire normalise les données de fonction et les étiquettes à l'aide des hyperparamètres `normalize_data` et `normalize_label`, respectivement. La normalisation est activée par défaut pour les fonctions et les étiquettes pour la régression. Seules les fonctions peuvent être normalisées pour la classification binaire et il s'agit du comportement par défaut.
## Étape 2 : Entraîner
Avec l'algorithme d'apprentissage linéaire, vous entraînez à l'aide d'une implémentation de l'algorithme de gradient stochastique (SGD, Stochastic Gradient Descent). Vous pouvez contrôler le processus d'optimisation en choisissant l'algorithme d'optimisation. Par exemple, vous pouvez choisir d'utiliser Adam AdaGrad, la descente stochastique en gradient ou d'autres algorithmes d'optimisation. Vous spécifiez également leurs hyperparamètres, tels que la vitesse (momentum), le taux d'apprentissage (learning rate) et la planification du taux d'apprentissage (learning rate schedule). Si vous n'êtes pas sûr de l'algorithme ou de la valeur d'hyperparamètre à utiliser, choisissez une valeur par défaut qui fonctionne pour la majorité des ensembles de données.
Pendant l'entraînement, vous optimisez simultanément plusieurs modèles, chacun avec des objectifs légèrement différents. Par exemple, vous variez la régularisation L1 ou L2 et testez différents paramètres de l'optimiseur.
## Étape 3 : Validation et définition du seuil
Lors de l'entraînement de plusieurs modèles en parallèle, les modèles sont évalués par rapport à un ensemble de validation afin de sélectionner le modèle optimal une fois l'entraînement terminé. Pour la régression, le modèle optimal est celui qui permet d'obtenir la meilleure perte sur l'ensemble de validation. Pour la classification, un échantillon de l'ensemble de validation est utilisé pour calibrer le seuil de classification. Le modèle optimal sélectionné est celui qui atteint les meilleurs critères de sélection de classification binaire sur l'ensemble de validation. Parmi les exemples de ces critères, citons la mesure F1, l'exactitude et la perte d'entropie croisée.
**Note**
Si aucun ensemble de validation n'est fourni pour l'algorithme, il est impossible d'évaluer et de sélectionner le modèle optimal. Pour tirer parti de l'entraînement parallèle et de la sélection de modèle, veillez à fournir un ensemble de validation à l'algorithme.
# Hyperparamètres de l'apprentissage linéaire
Le tableau suivant contient les hyper-paramètres pour l'algorithme d'apprentissage linéaire. Il s'agit des paramètres qui sont définis par les utilisateurs pour faciliter l'estimation des paramètres modèles issus des données. Les hyperparamètres requis qui doivent être définies sont les premiers répertoriés, dans l'ordre alphabétique. Les hyperparamètres facultatifs qui peuvent être définis sont répertoriés ensuite, également dans l'ordre alphabétique. Lorsqu'un hyperparamètre est défini sur`auto`, Amazon SageMaker AI calcule et définit automatiquement la valeur de cet hyperparamètre.
| Nom du paramètre | Description |
| --- | --- |
| num\$1classes | Nombre de classes de la variable de réponse. L'algorithme suppose que les classes sont étiquetées `0`, ..., `num_classes - 1`. **Obligatoire** quand `predictor_type` est `multiclass_classifier`. Dans le cas contraire, l'algorithme l'ignore. Valeurs valides : entiers compris entre 3 et 1 000 000 |
| predictor\$1type | Spécifie le type de variable cible sous la forme de classification binaire, de classification multi-classes ou de régression. **Obligatoire** Valeurs valides : `binary_classifier`, `multiclass_classifier` ou `regressor` |
| accuracy\$1top\$1k | Lors du calcul de la métrique d’exactitude top-k pour la classification multi-classes, la valeur de *k*. Si le modèle attribue l'un des top-k scores à l'étiquette true, un exemple est marqué comme correct. **Facultatif** Valeurs valides : nombre entiers positifs Valeur par défaut : 3 |
| balance\$1multiclass\$1weights | Spécifie s'il faut utiliser les pondérations de classe, qui donnent à chaque classe une importance égale dans la fonction perte (loss). Utilisé uniquement si le `predictor_type` est `multiclass_classifier`. **Facultatif** Valeurs valides : `true`, `false` Valeur par défaut : `false` |
| beta\$11 | Taux exponentiel de dégradation pour les estimations du premier moment. S'applique uniquement lorsque la valeur de `optimizer` est `adam`. **Facultatif** Valeurs valides : `auto` ou valeur à virgule flottante comprise entre 0 et 1,0 Valeur par défaut : `auto` |
| beta\$12 | Taux exponentiel de déclin pour les estimations du second moment. S'applique uniquement lorsque la valeur de `optimizer` est `adam`. **Facultatif** Valeurs valides : `auto` ou entier à virgule flottante compris entre 0 et 1,0 Valeur par défaut : `auto` |
| bias\$1lr\$1mult | Autorise un autre taux d'apprentissage pour le terme biaisé. Le taux d'apprentissage réel pour le biais est `learning_rate` \$1 `bias_lr_mult`. **Facultatif** Valeurs valides : `auto` ou entier à virgule flottante positif Valeur par défaut : `auto` |
| bias\$1wd\$1mult | Autorise différentes régularisations pour le terme biaisé. La pondération réelle de la régularisation L2 pour le biais est `wd` \$1 `bias_wd_mult`. Par défaut, il n'y a pas de régularisation sur le terme biaisé. **Facultatif** Valeurs valides : `auto` ou entier à virgule flottante non négatif Valeur par défaut : `auto` |
| binary\$1classifier\$1model\$1selection\$1criteria | Lorsque `predictor_type` a la valeur `binary_classifier`, les critères d'évaluation du modèle pour le jeu de données de validation (ou le jeu de données d'entraînement si vous ne fournissez pas d'ensemble de données de validation). Les critères comprennent : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/ll_hyperparameters.html) **Facultatif** Valeurs valides : `accuracy`, `f_beta`, `precision_at_target_recall`, `recall_at_target_precision` ou `loss_function` Valeur par défaut : `accuracy` |
| early\$1stopping\$1patience | Si aucune amélioration n'est apportée à la métrique appropriée, le nombre de périodes (epoch) à attendre avant la fin de l'entraînement. Si vous avez fourni une valeur pour binary\$1classifier\$1model\$1selection\$1criteria, la métrique est cette valeur. Dans le cas contraire, la métrique est identique à la valeur indiquée pour l'hyperparamètre loss. La métrique est évaluée sur les données de validation. Si vous n'avez pas fourni de données de validation, la métrique est toujours identique à la valeur indiquée pour l'hyperparamètre `loss` et elle est évaluée sur les données d'entraînement. Pour désactiver l'arrêt anticipé, définissez `early_stopping_patience` avec une valeur supérieure à la valeur spécifiée pour `epochs`.**Facultatif**Valeurs valides : nombre entier positifValeur par défaut : 3 |
| early\$1stopping\$1tolerance | Tolérance relative pour mesurer une amélioration de la fonction perte (loss). Si le ratio d'amélioration de la fonction perte (loss) divisé par la meilleure perte précédente est inférieur à cette valeur, l'arrêt anticipé considère l'amélioration comme égale à zéro. **Facultatif** Valeurs valides : entier à virgule flottante positif Valeur par défaut : 0.001 |
| epochs | Nombre maximal de passages sur les données d'entraînement. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 15 |
| f\$1beta | La valeur bêta à utiliser lors du calcul des métriques de score F pour la classification binaire ou multiclasse. Également utilisé si la valeur spécifiée pour `binary_classifier_model_selection_criteria` est `f_beta`. **Facultatif** Valeurs valides : entiers à virgule flottante positifs Valeur par défaut : 1.0 |
| feature\$1dim | Nombre de caractéristiques des données d'entrée. **Facultatif** Valeurs valides : `auto` ou entier positif Valeurs par défaut : `auto` |
| huber\$1delta | Paramètre pour la fonction de perte Huber. Pendant l'entraînement et l'évaluation des métriques, calculez la perte L2 pour les erreurs plus petites que delta et la perte L1 pour les erreurs supérieures à delta. **Facultatif** Valeurs valides : entier à virgule flottante positif Valeur par défaut : 1.0 |
| init\$1bias | Pondération initiale pour le terme biaisé. **Facultatif** Valeurs valides : entier à virgule flottante Valeur par défaut : 0 |
| init\$1method | Définit la fonction de distribution initiale utilisée pour les pondérations de modèle. Les fonctions incluent : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/ll_hyperparameters.html) **Facultatif** Valeurs valides : `uniform` ou `normal` Valeur par défaut : `uniform` |
| init\$1scale | Dimensionne une distribution uniforme initiale pour les pondérations de modèle. S'applique uniquement quand l'hyperparamètre `init_method` a la valeur `uniform`. **Facultatif** Valeurs valides : entier à virgule flottante positif Valeur par défaut : 0.07 |
| init\$1sigma | Écart-type initial pour la distribution normale. S'applique uniquement quand l'hyperparamètre `init_method` a la valeur `normal`. **Facultatif** Valeurs valides : entier à virgule flottante positif Valeur par défaut : 0.01 |
| l1 | Paramètre de régularisation L1. Si vous ne voulez pas utiliser la régularisation L1, définissez la valeur sur 0. **Facultatif** Valeurs valides : `auto` ou flottante non négative Valeur par défaut : `auto` |
| learning\$1rate | Taille d'étape utilisée par l'optimiseur pour les mises à jour de paramètre. **Facultatif** Valeurs valides : `auto` ou entier à virgule flottante positif Valeur par défaut : `auto`, dont la valeur dépend de l'optimiseur choisi. |
| loss | Spécifie la fonction perte. Les fonctions perte disponibles et leurs valeurs par défaut dépendent de la valeur de `predictor_type` : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/ll_hyperparameters.html) Valeurs valides : `auto`, `logistic`, `squared_loss`, `absolute_loss`, `hinge_loss`, `eps_insensitive_squared_loss`, `eps_insensitive_absolute_loss`, `quantile_loss` ou `huber_loss` **Facultatif** Valeur par défaut : `auto` |
| loss\$1insensitivity | Paramètre pour le type de perte insensible epsilon. Pendant l'entraînement et l'évaluation des métriques, toute erreur inférieure à cette valeur est considérée comme égale à zéro. **Facultatif** Valeurs valides : entier à virgule flottante positif Valeur par défaut : 0.01 |
| lr\$1scheduler\$1factor | Pour chaque hyperparamètre `lr_scheduler_step`, le taux d'apprentissage est diminué de cette quantité. S'applique uniquement quand l'hyperparamètre `use_lr_scheduler` a la valeur `true`. **Facultatif** Valeurs valides : `auto` ou entier positif à virgule flottante compris entre 0 et 1 Valeur par défaut : `auto` |
| lr\$1scheduler\$1minimum\$1lr | Le taux d'apprentissage ne diminue jamais à une valeur inférieure à celle définie pour `lr_scheduler_minimum_lr`. S'applique uniquement quand l'hyperparamètre `use_lr_scheduler` a la valeur `true`. **Facultatif** Valeurs valides : `auto` ou entier à virgule flottante positif Valeurs par défaut : `auto` |
| lr\$1scheduler\$1step | Nombre d'étapes entre les diminutions du taux d'apprentissage. S'applique uniquement quand l'hyperparamètre `use_lr_scheduler` a la valeur `true`. **Facultatif** Valeurs valides : `auto` ou entier positif Valeur par défaut : `auto` |
| margin | Marge de la fonction `hinge_loss`. **Facultatif** Valeurs valides : entier à virgule flottante positif Valeur par défaut : 1.0 |
| mini\$1batch\$1size | Nombre d'observations par mini-lot pour l'itérateur de données. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1000 |
| momentum | Vitesse de l'optimiseur `sgd`. **Facultatif** Valeurs valides : `auto` ou entier à virgule flottante compris entre 0 et 1,0 Valeur par défaut : `auto` |
| normalize\$1data | Normalise les données de fonction avant l'entraînement. La normalisation déplace les données de chaque fonction pour avoir une moyenne égale à zéro et les dimensionne pour avoir un écart type unitaire. **Facultatif** Valeurs valides : `auto`, `true` ou `false` Valeur par défaut : `true` |
| normalize\$1label | Normalise l'étiquette. La normalisation d'étiquette déplace l'étiquette pour obtenir une moyenne égale à 0 et la dimensionne pour avoir un écart type unitaire. La valeur `auto` par défaut normalise l'étiquette pour les problèmes de régression, mais pas pour les problèmes de classification. Si vous définissez l'hyperparamètre `normalize_label` avec la valeur `true` pour les problèmes de classification, l'algorithme l'ignore. **Facultatif** Valeurs valides : `auto`, `true` ou `false` Valeur par défaut : `auto` |
| num\$1calibration\$1samples | Nombre d'observations de l'ensemble de données de validation à utiliser pour le calibrage du modèle (lors de la recherche du meilleur seuil). **Facultatif** Valeurs valides : `auto` ou entier positif Valeur par défaut : `auto` |
| num\$1models | Nombre de modèles à entraîner en parallèle. Pour la valeur par défaut, `auto`, l'algorithme décide du nombre de modèles parallèles à entraîner. Un modèle est entraîné selon le paramètre d'entraînement donné (régularisation, optimiseur, perte), et le reste par les paramètres proches. **Facultatif** Valeurs valides : `auto` ou entier positif Valeurs par défaut : `auto` |
| num\$1point\$1for\$1scaler | Nombre de points de données à utiliser pour calculer la normalisation ou annuler le biais des termes. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 10,000 |
| optimizer | Algorithme d'optimisation à utiliser. **Facultatif** Valeurs valides : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/ll_hyperparameters.html) Valeur par défaut : `auto`. Le paramètre par défaut pour `auto` est `adam`. |
| positive\$1example\$1weight\$1mult | Pondération attribuée aux exemples positifs lors de l'entraînement d'un classificateur binaire. La pondération d'exemples négatifs est fixée à 1. Si vous souhaitez que l'algorithme choisisse une pondération afin que les erreurs de classification des exemples négatifs *et* des exemples positifs aient le même impact sur la perte d'entraînement, spécifiez `balanced`. Si vous voulez que l'algorithme choisisse la pondération qui optimise les performances, spécifiez `auto`. **Facultatif** Valeurs valides : `balanced`, `auto` ou entier positif à virgule flottante Valeur par défaut : 1.0 |
| quantile | Quantile pour la perte de quantile. Pour le quantile q, le modèle tente de produire des prédictions telles que la valeur de `true_label` soit supérieure à la prédiction avec la probabilité q. **Facultatif** Valeurs valides : entier à virgule flottante compris entre 0 et 1 Valeur par défaut : 0.5 |
| target\$1precision | Précision de la cible. Si `binary_classifier_model_selection_criteria` a la valeur `recall_at_target_precision`, la précision est détenue à cette valeur tandis que le rappel est optimisé. **Facultatif** Valeurs valides : entier à virgule flottante compris entre 0 et 1.0 Valeur par défaut : 0.8 |
| target\$1recall | Rappel de la cible. Si `binary_classifier_model_selection_criteria` a la valeur `precision_at_target_recall`, le rappel est détenu à cette valeur tandis que la précision est optimisée. **Facultatif** Valeurs valides : entier à virgule flottante compris entre 0 et 1.0 Valeur par défaut : 0.8 |
| unbias\$1data | Annule le biais des caractéristiques avant l'entraînement si bien que la moyenne est 0. Par défaut, les données sont sans biais si l'hyperparamètre `use_bias` a la valeur `true`. **Facultatif** Valeurs valides : `auto`, `true` ou `false` Valeur par défaut : `auto` |
| unbias\$1label | Annule le biais des étiquettes avant l'entraînement si bien que la moyenne est 0. S'applique uniquement quand l'hyperparamètre `use_bias` a la valeur `true`. **Facultatif** Valeurs valides : `auto`, `true` ou `false` Valeur par défaut : `auto` |
| use\$1bias | Spécifie si le modèle doit inclure un terme biaisé, lequel est le terme d'interception de l'équation linéaire. **Facultatif** Valeurs valides : `true` ou `false` Valeur par défaut : `true` |
| use\$1lr\$1scheduler | Spécifie s'il faut utiliser un planificateur pour le taux d'apprentissage. Si vous souhaitez utiliser un planificateur, spécifiez `true`. **Facultatif** Valeurs valides : `true` ou `false` Valeur par défaut : `true` |
| wd | Paramètre weight decay, également connu sous le nom de paramètre de régularisation L2. Si vous ne voulez pas utiliser la régularisation L2, définissez la valeur sur 0. **Facultatif** Valeurs valides : `auto` ou entier à virgule flottante non négatif Valeur par défaut : `auto` |
# Régler un modèle d'apprentissage linéaire
Le *réglage de modèle automatique*, ou réglage d'hyperparamètre, détecte la meilleure version d'un modèle en exécutant plusieurs tâches qui testent une plage d'hyperparamètres sur votre jeu de données. Vous choisissez les hyperparamètres réglables, une plage de valeurs pour chacun d'eux et une métrique d'objectif. Vous choisissez la métrique d'objectif parmi les métriques que calcule l'algorithme. Le réglage de modèle automatique recherche parmi les hyperparamètres choisis la combinaison de valeurs qui produira un modèle permettant d'optimiser la métrique d'objectif.
L'algorithme d'apprentissage linéaire dispose également d'un mécanisme interne pour régler les hyperparamètres distincts du réglage automatique du modèle décrite ici. Par défaut, l'algorithme d'apprentissage linéaire règle les hyperparamètres via l'entraînement en parallèle de plusieurs modèles. Lorsque vous utilisez le réglage de modèle automatique, le mécanisme de réglage interne de l'apprentissage linéaire est désactivé automatiquement. Le nombre de modèles parallèles, `num_models`, a ainsi la valeur 1. L'algorithme ignore toute valeur que vous définissez pour `num_models`.
Pour plus d'informations sur le réglage de modèle, consultez [Réglage automatique du modèle grâce à l' SageMaker IA](automatic-model-tuning.md).
## Métriques calculées par l'algorithme d'apprentissage linéaire
L'algorithme d'apprentissage linéaire rapporte les métriques dans le tableau suivant ; elles sont calculées au cours de l'entraînement. Choisissez l'une d'entre elles comme métrique d'objectif. Pour éviter un sur-ajustement, nous vous recommandons de régler le modèle par rapport à une métrique de validation au lieu d'une métrique d'entraînement.
| Nom de la métrique | Description | Orientation de l'optimisation |
| --- | --- | --- |
| test:absolute\$1loss | Perte absolue du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la régression. | Réduire |
| test:binary\$1classification\$1accuracy | Exactitude du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| test:binary\$1f\$1beta | Score F-beta du modèle final sur le jeu de données de test. Par défaut, il s'agit du score F1, qui représente la moyenne harmonique de la précision et du rappel. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| test:dcg | Gain cumulé escompté du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| test:macro\$1f\$1beta | Score F-beta du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| test:macro\$1precision | Score de précision du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| test:macro\$1recall | Score de rappel du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| test:mse | Erreur quadratique moyenne du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la régression. | Réduire |
| test:multiclass\$1accuracy | Exactitude du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| test:multiclass\$1top\$1k\$1accuracy | Exactitude parmi les k premières étiquettes prédites sur le jeu de données de test. Si vous choisissez cette métrique comme objectif, nous vous recommandons de définir la valeur de k à l'aide de l'hyperparamètre `accuracy_top_k`. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| test:objective\$1loss | Valeur moyenne de la fonction perte (loss) de l'objectif sur le jeu de données de test après que le modèle a été entraîné. Par défaut, la perte est une perte logistique pour la classification binaire et une perte quadratique pour la régression. Pour définir la perte des autres types, utilisez l'hyperparamètre `loss`. | Réduire |
| test:precision | Précision du modèle final sur le jeu de données de test. Si vous choisissez cette métrique comme objectif, nous vous recommandons de définir un rappel de cible en définissant l'hyperparamètre `binary_classifier_model_selection` avec la valeur `precision_at_target_recall` et en définissant la valeur de l'hyperparamètre `target_recall`. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| test:recall | Rappel du modèle final sur le jeu de données de test. Si vous choisissez cette métrique comme objectif, nous vous recommandons de définir une précision de cible en définissant l'hyperparamètre `binary_classifier_model_selection` avec la valeur `recall_at_target_precision` et en définissant la valeur de l'hyperparamètre `target_precision`. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| test:roc\$1auc\$1score | Zone sous la courbe caractéristique de fonctionnement de réception (courbe ROC) du modèle final sur le jeu de données de test. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| validation:absolute\$1loss | Perte absolue du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la régression. | Réduire |
| validation:binary\$1classification\$1accuracy | Exactitude du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| validation:binary\$1f\$1beta | Score F-beta du modèle final sur le jeu de données de validation. Par défaut, le score F-beta est le score F1, qui représente la moyenne harmonique des métriques `validation:precision` et `validation:recall`. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| validation:dcg | Gain cumulé escompté du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| validation:macro\$1f\$1beta | Score F-beta du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| validation:macro\$1precision | Score de précision du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| validation:macro\$1recall | Score de rappel du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| validation:mse | Erreur quadratique moyenne du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la régression. | Réduire |
| validation:multiclass\$1accuracy | Exactitude du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| validation:multiclass\$1top\$1k\$1accuracy | Exactitude parmi les k premières étiquettes prédites sur le jeu de données de validation. Si vous choisissez cette métrique comme objectif, nous vous recommandons de définir la valeur de k à l'aide de l'hyperparamètre `accuracy_top_k`. Cette métrique d'objectif n'est valide que pour la classification multiclasse. | Agrandir |
| validation:objective\$1loss | Valeur moyenne de la fonction perte de l'objectif sur le jeu de données de validation pour chaque période (epoch). Par défaut, la perte est une perte logistique pour la classification binaire et une perte quadratique pour la régression. Pour définir la perte d'autres types, utilisez l'hyperparamètre `loss`. | Réduire |
| validation:precision | Précision du modèle final sur le jeu de données de validation. Si vous choisissez cette métrique comme objectif, nous vous recommandons de définir un rappel de cible en définissant l'hyperparamètre `binary_classifier_model_selection` avec la valeur `precision_at_target_recall` et en définissant la valeur de l'hyperparamètre `target_recall`. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| validation:recall | Rappel du modèle final sur le jeu de données de validation. Si vous choisissez cette métrique comme objectif, nous vous recommandons de définir une précision de cible en définissant l'hyperparamètre `binary_classifier_model_selection` avec la valeur `recall_at_target_precision` et en définissant la valeur de l'hyperparamètre `target_precision`. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
| validation:rmse | Erreur quadratique moyenne racine du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la régression. | Réduire |
| validation:roc\$1auc\$1score | Zone sous la courbe caractéristique de fonctionnement de réception (courbe ROC) du modèle final sur le jeu de données de validation. Cette métrique d'objectif n'est valide que pour la classification binaire. | Agrandir |
## Réglage des hyperparamètres de l'apprentissage linéaire
Vous pouvez régler un modèle d'apprentissage linéaire avec les hyperparamètres suivants.
| Nom du paramètre | Type de paramètre | Plages recommandées |
| --- | --- | --- |
| wd | `ContinuousParameterRanges` | `MinValue: ``1e-7`, `MaxValue`: `1` |
| l1 | `ContinuousParameterRanges` | `MinValue`: `1e-7`, `MaxValue`: `1` |
| learning\$1rate | `ContinuousParameterRanges` | `MinValue`: `1e-5`, `MaxValue`: `1` |
| mini\$1batch\$1size | `IntegerParameterRanges` | `MinValue`: `100`, `MaxValue`: `5000` |
| use\$1bias | `CategoricalParameterRanges` | `[True, False]` |
| positive\$1example\$1weight\$1mult | `ContinuousParameterRanges` | `MinValue` : 1e-5, `MaxValue` : `1e5` |
# Formats de réponse d'apprentissage linéaire
## Formats de réponse JSON
Tous les algorithmes intégrés d'Amazon SageMaker AI respectent le format d'inférence d'entrée commun décrit dans [Common Data Formats - Inference](https://docs.aws.amazon.com/sagemaker/latest/dg/cdf-inference.html). Les formats de sortie disponibles pour l'algorithme d'apprentissage linéaire SageMaker AI sont les suivants.
**Classification binaire**
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
**Classification multiclasse**
```
let response = {
"predictions": [
{
"score": [0.1, 0.2, 0.4, 0.3],
"predicted_label": 2
}
]
}
```
**Régression**
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## Formats de réponse JSONLINES
**Classification binaire**
```
{"score": 0.4, "predicted_label": 0}
```
**Classification multiclasse**
```
{"score": [0.1, 0.2, 0.4, 0.3], "predicted_label": 2}
```
**Régression**
```
{"score": 0.4}
```
## Formats de réponse RECORDIO
**Classification binaire**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
**Classification multiclasse**
```
[
Record = {
"features": [],
"label": {
"score": {
"values": [0.1, 0.2, 0.3, 0.4]
},
"predicted_label": {
"values": [3]
}
},
"uid": "abc123",
"metadata": "{created_at: '2017-06-03'}"
}
]
```
**Régression**
```
[
Record = {
features = {},
label = {
'score': {
keys: [],
values: [0.4] # float32
}
}
}
]
```