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 des machines de factorisation
L'algorithme Factorization Machines est un algorithme d'apprentissage supervisé polyvalent que vous pouvez utiliser pour les tâches de régression et de classification. Il s'agit d'une extension d'un modèle linéaire, conçue pour capturer, de façon économique, les interactions entre les caractéristiques dans des ensembles de données fragmentés haute dimension. Par exemple, dans un système de prédiction de clics, le modèle Factorization Machines peut capturer des schémas de taux de clic observés lorsque des publicités d'une certaine catégorie sont placées sur des pages d'une certaine catégorie. Les machines de factorisation constituent un bon choix pour des tâches traitant des ensembles de données fragmentés haute dimension, telles que la prévision de clics et la recommandation d'éléments.
**Note**
L'implémentation de l'algorithme Factorization Machines par Amazon SageMaker AI ne prend en compte que les interactions par paires (2e ordre) entre les fonctionnalités.
**Topics**
+ [Interface d'entrée/de sortie pour l'algorithme des machines de factorisation](#fm-inputoutput)
+ [Recommandation pour l'instance EC2 relative à l'algorithme des machines de factorisation](#fm-instances)
+ [Exemples de blocs-notes de machines de factorisation](#fm-sample-notebooks)
+ [Fonctionnement des machines de factorisation](fact-machines-howitworks.md)
+ [Hyperparamètres de machines de factorisation](fact-machines-hyperparameters.md)
+ [Personnalisation d'un modèle de machines de factorisation](fm-tuning.md)
+ [Formats de réponse Factorization Machines](fm-in-formats.md)
## Interface d'entrée/de sortie pour l'algorithme des machines de factorisation
L'algorithme Factorization Machines peut être exécuté en mode classification binaire ou en mode régression. Dans chaque mode, un ensemble de données peut être fourni pour le canal de **test**en même temps que l'ensemble de données du canal de formation. La notation dépend du mode utilisé. En mode régression, l'ensemble de données de test est noté à l'aide de la racine carrée de l'erreur quadratique moyenne (RMSE, Root Mean Square Error). En mode classification binaire, l'ensemble de données de test est noté à l'aide de Binary Cross Entropy (Log Loss), Accuracy (au seuil = 0.5) et F1 Score (au seuil = 0.5).
Pour l'**entraînement**, l'algorithme Factorization Machines prend uniquement en charge le format `recordIO-protobuf` avec des tenseurs `Float32`. Son cas d'utilisation portant essentiellement sur les données fragmentées, `CSV` n'est pas un bon candidat. En modes File (Fichier) et Pipe (Tube), la formation est prise en charge pour le format recordIO-wrapped protobuf.
Pour les **inférences**, l'algorithme Factorization Machines prend en charge les formats `application/json` et `x-recordio-protobuf`.
+ Pour le problème de **classification binaire**, l'algorithme prévoit un score et une étiquette. L'étiquette est un nombre et peut être `0` ou `1`. Le score est un nombre qui indique à quel point l'algorithme estime que l'étiquette doit être `1`. L'algorithme calcule un score d'abord, puis déduit l'étiquette à partir de la valeur de score. Si le score est supérieur ou égal à 0,5, l'étiquette est `1`.
+ Pour le problème de **régression**, un score est renvoyé et il correspond à la valeur prévue. Par exemple, si les machines de factorisation sont utilisées pour prédire l'évaluation d'un film, le score correspond à la valeur d'évaluation prévue.
Consultez [Exemples de blocs-notes de machines de factorisation](#fm-sample-notebooks) pour plus de détails sur les formats de fichier de formation et d'inférence.
## Recommandation pour l'instance EC2 relative à l'algorithme des machines de factorisation
L'algorithme Amazon SageMaker AI Factorization Machines est hautement évolutif et peut s'entraîner sur des instances distribuées. Nous recommandons une formation et une inférence avec des instances à CPU pour les ensembles de données fragmentés et denses. Dans certaines circonstances, l'entraînement avec un ou plusieurs appareils GPUs sur des données denses peut présenter certains avantages. L'entraînement avec n' GPUs est disponible que sur des données denses. Utilisez des instances d'UC pour les données fragmentées. L'algorithme des machines de factorisation prend en charge les instances P2, P3, G4dn et G5 pour l'entraînement et l'inférence.
## Exemples de blocs-notes de machines de factorisation
Pour un exemple de bloc-notes qui utilise l'algorithme SageMaker AI Factorization Machines pour analyser les images de chiffres manuscrits compris entre zéro et neuf dans le jeu de données MNIST, voir [An Introduction to Factorization](https://sagemaker-examples.readthedocs.io/en/latest/introduction_to_amazon_algorithms/factorization_machines_mnist/factorization_machines_mnist.html) Machines with MNIST. Pour savoir comment créer et 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) Une fois que vous avez créé une instance de bloc-notes et que vous l'avez ouverte, sélectionnez l'onglet **Exemples d'SageMaker IA** pour voir la liste de tous les exemples d' SageMaker IA. Vous trouverez des exemples de blocs-notes qui utilisent l'algorithme Factorization Machines dans la section **relative à la présentation des algorithmes Amazon**. Pour ouvrir un bloc-notes, cliquez sur son onglet **Use (Utiliser)** et sélectionnez **Create copy (Créer une copie)**.
# Fonctionnement des machines de factorisation
La tâche de prédiction d'un modèle Factorization Machines consiste à estimer une fonction ŷ à partir d'un ensemble de fonctions xi vers un domaine cible. Ce domaine s'emploie à valeur réelle pour la régression et sous forme binaire pour la classification. Le modèle Factorization Machines est supervisé et possède par conséquent un jeu de données d'entraînement (xi,yj) disponible. Il présente l'avantage d'utiliser une paramétrisation factorisée pour capturer les interactions de caractéristiques par paire. Il peut être représenté mathématiquement comme suit :
![\[Image contenant l'équation du modèle Factorization Machines.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/FM1.jpg)
Les trois termes de cette équation correspondent respectivement aux trois composantes du modèle :
+ Le terme w0 représente le biais global.
+ Les termes linéaires wi modélisent la puissance de la variable ie.
+ Les termes de factorisation modélisent l'interaction par paire entre les variables ie et je.
Les termes de biais global et les termes linaires sont identiques à ceux d'un modèle linéaire. Les interactions de caractéristiques par paire sont modélisées dans le troisième terme comme le produit interne des facteurs correspondants formés pour chaque caractéristique. Les facteurs formés peuvent aussi être considérés comme des vecteurs d'intégration pour chaque fonction. Par exemple, dans une tâche de classification, si une paire de caractéristiques a tendance à se produire plus souvent dans des exemples étiquetés positivement, le produit interne de leurs facteurs sera élevé. En d'autres termes, leurs vecteurs d'intégration sont proches les uns des autres en similarité de cosinus. Pour plus d'informations sur le modèle Factorization Machines, consultez l'article relatif à [Factorization Machines](https://www.ismll.uni-hildesheim.de/pub/pdfs/Rendle2010FM.pdf).
Pour les tâches de régression, le modèle est entraîné en réduisant l'erreur mise au carré entre la prédiction du modèle ŷn et la valeur cible yn. C'est ce que l'on appelle la « perte quadratique » :
![\[Image contenant l'équation de la perte quadratique.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/FM2.jpg)
Pour une tâche de classification, le modèle est formé en réduisant la perte d'entropie croisée, ou perte logistique :
![\[Image contenant l'équation de la perte logistique.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/FM3.jpg)
où :
![\[Image contenant la fonction logistique des valeurs prévues.\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/images/FM4.jpg)
Pour plus d'informations sur les fonctions de perte relatives à la classification, consultez [Loss functions for classification](https://en.wikipedia.org/wiki/Loss_functions_for_classification).
# Hyperparamètres de machines de factorisation
Le tableau suivant contient les hyperparamètres pour l'algorithme Factorization Machines. 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.
| Nom du paramètre | Description |
| --- | --- |
| feature\$1dim | Dimension de l'espace de caractéristiques d'entrée. Cela peut être très élevé avec une entrée fragmentées. **Obligatoire** Valeurs valides : nombre entier positif. Plage de valeurs suggérée : [10000,10000000] |
| num\$1factors | Dimensionnalité de factorisation. **Obligatoire** Valeurs valides : nombre entier positif. Plage de valeurs suggérée : [2,1000], 64 génère généralement de bons résultats et constitue un bon point de départ. |
| predictor\$1type | Type de prédicteur. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Obligatoire** Valeurs valides : chaîne : `binary_classifier` ou `regressor` |
| bias\$1init\$1method | Méthode d'initialisation pour le terme de biais : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Facultatif** Valeurs valides : `uniform`, `normal` ou `constant` Valeur par défaut : `normal` |
| bias\$1init\$1scale | Plage pour l'initialisation du terme avec écart. Prend effet si `bias_init_method` est défini sur `uniform`. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : None (Aucune) |
| bias\$1init\$1sigma | Écart type pour l'initialisation du terme de biais. Prend effet si `bias_init_method` est défini sur `normal`. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.01 |
| bias\$1init\$1value | Valeur initiale du terme de biais. Prend effet si `bias_init_method` est défini sur `constant`. **Facultatif** Valeurs valides : float. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : None (Aucune) |
| bias\$1lr | Taux d'apprentissage pour le terme de biais. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.1 |
| bias\$1wd | Dégradation des pondérations pour le terme de biais. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.01 |
| clip\$1gradient | Paramètre d'optimiseur de bornement de la norme du gradient. Borne la norme du gradient par projection sur l'intervalle [-`clip_gradient`, \$1`clip_gradient`]. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : None (Aucune) |
| epochs | Nombre d'époques de formation à exécuter. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1 |
| eps | Paramètre epsilon permettant d'éviter une division par 0. **Facultatif** Valeurs valides : float. Valeur suggérée : petite. Valeur par défaut : None (Aucune) |
| factors\$1init\$1method | Méthode d'initialisation des termes de factorisation : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Facultatif** Valeurs valides : `uniform`, `normal` ou `constant`. Valeur par défaut : `normal` |
| factors\$1init\$1scale | Plage pour l'initialisation des termes de factorisation. Prend effet si `factors_init_method` est défini sur `uniform`. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : None (Aucune) |
| factors\$1init\$1sigma | Écart type pour l'initialisation des termes de factorisation. Prend effet si `factors_init_method` est défini sur `normal`. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.001 |
| factors\$1init\$1value | Valeur initiale des termes de factorisation. Prend effet si `factors_init_method` est défini sur `constant`. **Facultatif** Valeurs valides : float. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : None (Aucune) |
| factors\$1lr | Taux d'apprentissage pour les termes de factorisation. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.0001 |
| factors\$1wd | Dégradation des pondérations pour les termes de factorisation. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.00001 |
| linear\$1lr | Taux d'apprentissage pour les termes linéaires. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.001 |
| linear\$1init\$1method | Méthode d'initialisation des termes linéaires : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/sagemaker/latest/dg/fact-machines-hyperparameters.html) **Facultatif** Valeurs valides : `uniform`, `normal` ou `constant`. Valeur par défaut : `normal` |
| linear\$1init\$1scale | Plage pour l'initialisation de termes linéaires. Prend effet si `linear_init_method` est défini sur `uniform`. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : None (Aucune) |
| linear\$1init\$1sigma | Écart type pour l'initialisation des termes linéaires. Prend effet si `linear_init_method` est défini sur `normal`. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.01 |
| linear\$1init\$1value | Valeur initiale des termes linéaires. Prend effet si `linear_init_method` est défini sur *constant*. **Facultatif** Valeurs valides : float. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : None (Aucune) |
| linear\$1wd | Dégradation des pondérations pour les termes linéaires. **Facultatif** Valeurs valides : flottante non négative. Plage de valeurs suggérée : [1e-8, 512]. Valeur par défaut : 0.001 |
| mini\$1batch\$1size | Taille du mini-lot utilisé pour la formation. **Facultatif** Valeurs valides : nombre entier positif Valeur par défaut : 1000 |
| rescale\$1grad | Paramètre d'optimiseur de remise à l'échelle du gradient. Si cette option est définie, multiplie le dégradé avec `rescale_grad` avant la mise à jour. Choisissez souvent 1.0/`batch_size`. **Facultatif** Valeurs valides : valeur flottante Valeur par défaut : None (Aucune) |
# Personnalisation d'un modèle de machines de factorisation
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.
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 des machines de factorisation
L'algorithme Factorization Machines contient des prédicteurs du type classification binaire et régression. Le type de prédicteur détermine quelle métrique utiliser pour le réglage automatique du modèle. L'algorithme reporte une métrique de régression `test:rmse`, qui est calculée au cours de la formation. Lors du réglage du modèle pour les tâches de régression, choisissez cette métrique comme objectif.
| Nom de la métrique | Description | Orientation de l'optimisation |
| --- | --- | --- |
| test:rmse | Racine carrée de l'erreur quadratique moyenne (RMSE) | Réduire |
L'algorithme Factorization Machines signale trois métriques de classification binaire, qui sont calculées durant l'entraînement. Lors du réglage du modèle pour les tâches de classification binaire, choisissez l'une de ces métriques comme objectif.
| Nom de la métrique | Description | Orientation de l'optimisation |
| --- | --- | --- |
| test:binary\$1classification\$1accuracy | Précision | Agrandir |
| test:binary\$1classification\$1cross\$1entropy | Entropie croisée | Réduire |
| test:binary\$1f\$1beta | Bêta | Agrandir |
## Hyperparamètres de machines de factorisation réglables
Vous pouvez régler les hyperparamètres ci-dessous pour l'algorithme Factorization Machines. Les paramètres d'initialisation qui contiennent les termes de biais, linéaire et de factorisation dépendent de leur méthode d'initialisation. Il existe trois méthodes d'initialisation : `uniform`, `normal` et `constant`. Ces méthodes ne sont pas réglables. Les paramètres réglables dépendent de la méthode d'initialisation choisie. Par exemple, si la méthode d'initialisation est `uniform`, seuls les paramètres `scale` peuvent être réglés. Plus précisément, si `bias_init_method==uniform`, alors `bias_init_scale`, `linear_init_scale` et `factors_init_scale` peuvent être réglés. De même, si la méthode d'initialisation est `normal`, seuls les paramètres `sigma` peuvent être réglés. Si la méthode d'initialisation est `constant`, seuls les paramètres `value` peuvent être réglés. Ces dépendances sont répertoriées dans le tableau ci-dessous.
| Nom du paramètre | Type de paramètre | Plages recommandées | Dépendance |
| --- | --- | --- | --- |
| bias\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==uniform |
| bias\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==normal |
| bias\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==constant |
| bias\$1lr | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Aucune |
| bias\$1wd | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Aucune |
| epoch | IntegerParameterRange | MinValue: 1, MaxValue 1000 | Aucune |
| factors\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==uniform |
| factors\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==normal |
| factors\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==constant |
| factors\$1lr | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Aucune |
| factors\$1wd | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue] | Aucune |
| linear\$1init\$1scale | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==uniform |
| linear\$1init\$1sigma | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==normal |
| linear\$1init\$1value | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | bias\$1init\$1method==constant |
| linear\$1lr | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Aucune |
| linear\$1wd | ContinuousParameterRange | MinValue: 1e-8, 512 MaxValue | Aucune |
| mini\$1batch\$1size | IntegerParameterRange | MinValue: 100, MaxValue 100 | Aucune |
# Formats de réponse Factorization Machines
Amazon SageMaker AI fournit plusieurs formats de réponse pour obtenir des inférences à partir du modèle de machines de factorisation, tels que JSON, JSONLINES et RECORDIO, avec des structures spécifiques pour les tâches de classification et de régression binaires.
## Format de réponse JSON
Classification binaire
```
let response = {
"predictions": [
{
"score": 0.4,
"predicted_label": 0
}
]
}
```
Régression
```
let response = {
"predictions": [
{
"score": 0.4
}
]
}
```
## Format de réponse JSONLINES
Classification binaire
```
{"score": 0.4, "predicted_label": 0}
```
Régression
```
{"score": 0.4}
```
## Format de réponse RECORDIO
Classification binaire
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
},
'predicted_label': {
keys: [],
values: [0.0] # float32
}
}
}
]
```
Régression
```
[
Record = {
features = {},
label = {
'score’: {
keys: [],
values: [0.4] # float32
}
}
}
]
```