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.
# Le champ des fonctionnalités dans neptune\$1ml
Les valeurs des propriétés et les littéraux RDF se présentent sous différents formats et types de données. Pour obtenir de bonnes performances de machine learning, il est essentiel de convertir ces valeurs en encodages numériques appelés *fonctionnalités*.
Neptune ML effectue l'extraction et l'encodage des fonctionnalités dans le cadre des étapes d'exportation et de traitement des données, comme décrit dans [Encodage des fonctionnalités dans Neptune ML](machine-learning-feature-encoding.md).
Pour les jeux de données de graphe de propriétés, le processus d'exportation déduit automatiquement les fonctionnalités `auto` pour les propriétés de chaîne et pour les propriétés numériques qui contiennent des valeurs multiples. Pour les propriétés numériques contenant des valeurs uniques, il déduit des fonctionnalités `numerical`. Pour les propriétés de date, il déduit des fonctionnalités `datetime`.
Si vous souhaitez remplacer une spécification de fonction déduite automatiquement ou ajouter une spécification numérique de compartiment, TF-IDF ou SBERT pour une propriété FastText, vous pouvez contrôler le codage des entités à l'aide du champ Features.
**Note**
Vous pouvez uniquement utiliser le champ `features` pour contrôler les spécifications des fonctionnalités pour les données de graphe de propriétés, et non pour les données RDF.
Pour le texte de forme libre, Neptune ML peut utiliser plusieurs modèles différents pour convertir la séquence de jetons d'une valeur de propriété de chaîne en un vecteur de valeur réelle de taille fixe :
+ [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features) : utilise l'encodage [fastText](https://fasttext.cc/). Il s'agit de l'encodage recommandé pour les fonctionnalités qui utilisent une et une seule des cinq langues prises en charge par fastText.
+ [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-sbert-features) : utilise les modèles d'encodage [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Il s'agit de l'encodage recommandé pour le texte que `text_fasttext` ne prend pas en charge.
+ [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features) : utilise les algorithmes [Word2Vec](https://wikipedia.org/wiki/Word2vec) publiés à l'origine par [Google](https://code.google.com/archive/p/word2vec/) pour encoder du texte. Word2Vec prend en charge uniquement l'anglais.
+ [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features) : utilise un vectoriseur [de fréquence de terme et de fréquence de document inverse](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) pour l'encodage de texte. L'encodage TF-IDF prend en charge des fonctionnalités statistiques que les autres encodages ne prennent pas en charge.
Le champ `features` contient un tableau JSON des fonctionnalités des propriétés des nœuds. Les objets figurant dans le tableau peuvent contenir les champs suivants :
**Contents**
+ [nœud](#machine-learning-neptune_ml-features-node)
+ [périphérique](#machine-learning-neptune_ml-features-edge)
+ [property](#machine-learning-neptune_ml-features-property)
+ [type](#machine-learning-neptune_ml-feature-types)
+ [norm](#machine-learning-neptune_ml-features-norm)
+ [langage](#machine-learning-neptune_ml-features-language)
+ [max\$1length](#machine-learning-neptune_ml-features-max_length)
+ [separator](#machine-learning-neptune_ml-features-separator)
+ [range](#machine-learning-neptune_ml-features-range)
+ [bucket\$1cnt](#machine-learning-neptune_ml-features-bucket_cnt)
+ [slide\$1window\$1size](#machine-learning-neptune_ml-features-slide_window_size)
+ [imputer](#machine-learning-neptune_ml-features-imputer)
+ [max\$1features](#machine-learning-neptune_ml-features-max_features)
+ [min\$1df](#machine-learning-neptune_ml-features-min_df)
+ [ngram\$1range](#machine-learning-neptune_ml-features-ngram_range)
+ [datetime\$1parts](#machine-learning-neptune_ml-features-datetime_parts)
## Le champ de nœuds dans les fonctionnalités
Le champ `node` spécifie l'étiquette de graphe de propriétés d'un sommet de fonctionnalité. Par exemple :
```
"node": "Person"
```
Si un sommet possède plusieurs étiquettes, utilisez un tableau qui les contiendra. Par exemple :
```
"node": ["Admin", "Person"]
```
## Le champ périphérique dans les fonctionnalités
Le champ `edge` spécifie le type d'arête d'une arête de fonctionnalité. Un type d'arête consiste en un tableau contenant les étiquettes de graphe de propriétés du sommet source, l'étiquette de graphe de propriétés de l'arête et la ou les étiquettes de graphe de propriétés du sommet de destination. Vous devez fournir ces trois valeurs lorsque vous spécifiez une fonctionnalité d'arête. Par exemple :
```
"edge": ["User", "reviewed", "Movie"]
```
Si un sommet source ou de destination d'un type d'arête possède plusieurs étiquettes, utilisez un autre tableau qui les contiendra. Par exemple :
```
"edge": [["Admin", "Person"]. "edited", "Post"]
```
## Le champ de propriété dans les fonctionnalités
Utilisez le paramètre de propriété pour spécifier une propriété du sommet identifié par le paramètre `node`. Par exemple :
```
"property" : "age"
```
## Valeurs possibles du champ de type pour les entités
Le paramètre `type` indique le type de fonctionnalité en cours de définition. Par exemple :
```
"type": "bucket_numerical"
```
**Valeurs possibles du paramètre `type`**
+ **`"auto"`** : spécifie que Neptune ML doit détecter automatiquement le type de propriété et appliquer un encodage de fonctionnalité approprié. Une fonctionnalité `auto` peut également comporter un champ `separator` facultatif.
Consultez [Encodage automatique des fonctionnalités dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
+ **`"category"`** : cet encodage de fonctionnalité représente une valeur de propriété sous la forme d'une catégorie parmi un certain nombre de catégories. En d'autres termes, la fonctionnalité peut prendre une ou plusieurs valeurs discrètes. Une fonctionnalité `category` peut également comporter un champ `separator` facultatif.
Consultez [Fonctionnalités catégorielles dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-categorical-features).
+ **`"numerical"`** : cet encodage de fonctionnalité représente les valeurs de propriété numériques sous forme de nombres dans un intervalle continu où « supérieur à » et « inférieur à » ont une signification.
Une fonctionnalité `numerical` peut également comporter des champs `norm`, `imputer` et `separator` facultatifs.
Consultez [Fonctionnalités numériques dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
+ **`"bucket_numerical"`** : cet encodage de fonctionnalité divise les valeurs de propriété numériques en un ensemble de *compartiments* ou de catégories.
Par exemple, vous pouvez encoder l'âge des personnes dans 4 compartiments : les enfants (0 à 20), les jeunes adultes (20 à 40), les personnes d'âge moyen (40 à 60) et les personnes âgées (à partir de 60).
Une `bucket_numerical` fonctionnalité nécessite un `range` `bucket_cnt` champ et peut éventuellement inclure un `imputer` and/or `slide_window_size` champ.
Consultez [Fonctionnalités numériques de compartiment dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
+ **`"datetime"`** : cet encodage de fonctionnalité représente une valeur de propriété datetime sous la forme d'un tableau de ces fonctionnalités catégorielles : année, mois, jour de la semaine et heure.
Une ou plusieurs de ces quatre catégories peuvent être éliminées à l'aide du paramètre `datetime_parts`.
Consultez [Fonctionnalités datetime dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).
+ **`"text_fasttext"`** : cet encodage de fonctionnalité convertit les valeurs de propriété constituées de phrases ou de texte libre en vecteurs numériques à l'aide de modèles [fastText](https://fasttext.cc/). Il prend en charge cinq langues, à savoir l'anglais (`en`), le chinois (`zh`), l'hindi (`hi`), l'espagnol (`es`) et le français (`fr`). Pour les valeurs de propriété de texte dans l'une de ces cinq langues, `text_fasttext` est l'encodage recommandé. Toutefois, il ne peut pas traiter les cas où une même phrase contient des mots dans plusieurs langues.
Pour les langues autres que celles prises en charge par fastText, utilisez l'encodage `text_sbert`.
Si vous avez de nombreuses chaînes de texte de valeur de propriété de plus de 120 jetons, par exemple, utilisez le champ `max_length` pour limiter le nombre de jetons dans chaque chaîne encodée par `"text_fasttext"`.
Consultez [Encodage *fastText* des valeurs de propriété de texte dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-fasttext-features).
+ **`"text_sbert"`** : cet encodage convertit les valeurs de propriété de texte en vecteurs numériques à l'aide des modèles [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Neptune prend en charge deux méthodes SBERT, à savoir `text_sbert128`, qui est la méthode par défaut si vous spécifiez simplement `text_sbert`, et `text_sbert512`. La différence entre les deux est le nombre maximal de jetons qui sont encodés dans une propriété de texte. L'encodage `text_sbert128` encode uniquement les 128 premiers jetons, tandis que `text_sbert512` encode jusqu'à 512 jetons. Par conséquent, l'utilisation de `text_sbert512` peut nécessiter plus de temps de traitement que `text_sbert128`. Les deux méthodes sont plus lentes que `text_fasttext`.
Les méthodes `text_sbert*` prennent en charge de nombreuses langues et peuvent encoder une phrase contenant plusieurs langues.
Consultez [Encodage Sentence BERT (SBERT) des fonctionnalités de texte dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-sbert-features).
+ **`"text_word2vec"`** : cet encodage convertit les valeurs de propriété de texte en vecteurs numériques à l'aide des algorithmes [Word2Vec](https://wikipedia.org/wiki/Word2vec). Il prend en charge uniquement l'anglais.
Consultez [Encodage Word2Vec des fonctionnalités textuelles dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-word2vec-features).
+ **`"text_tfidf"`** : cet encodage convertit les valeurs de propriété de texte en vecteurs numériques à l'aide d'un vectoriseur [de fréquence de terme et de fréquence de document inverse](https://wikipedia.org/wiki/Tf-idf) (TF-IDF).
Vous définissez les paramètres d'un encodage de fonctionnalité `text_tfidf` à l'aide du champ `ngram_range`, du champ `min_df` et du champ `max_features`.
Consultez [Encodage TF-IDF des fonctionnalités de texte dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
+ **`"none"`** : l'utilisation du type `none` n'entraîne aucun encodage des fonctionnalités. Les valeurs de propriété brutes sont analysées et enregistrées à la place.
Utilisez `none` uniquement si vous envisagez d'effectuer votre propre encodage de fonctionnalités personnalisé dans le cadre de l'entraînement de modèle personnalisé.
## Le champ des normes
Ce champ est obligatoire pour les fonctionnalités numériques. Il spécifie une méthode de normalisation à utiliser sur les valeurs numériques :
```
"norm": "min-max"
```
Les méthodes de normalisation suivantes sont prises en charge :
+ **« min-max »** : normalisez chaque valeur en lui soustrayant la valeur minimale, puis en la divisant par la différence entre la valeur maximale et la valeur minimale.
+ **« standard »** : normalisez chaque valeur en la divisant par la somme de toutes les valeurs.
+ **« aucune »** : ne normalisez pas les valeurs numériques pendant l'encodage.
Consultez [Fonctionnalités numériques dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
## Le champ de langue
Le champ de langue indique la langue utilisée dans les valeurs des propriétés de texte. Son utilisation dépend de la méthode d'encodage de texte :
+ Pour l'encodage [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), ce champ est obligatoire et doit spécifier l'une des langues suivantes :
+ `en` (anglais)
+ `zh` (chinois)
+ `hi` (hindi)
+ `es` (espagnol)
+ `fr` (français)
+ Pour l'encodage [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), ce champ n'est pas utilisé, car l'encodage SBERT est multilingue.
+ Pour l'encodage [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features), ce champ est facultatif, car `text_word2vec` prend en charge uniquement l'anglais. Le cas échéant, il doit spécifier le nom du modèle de langue anglaise :
```
"language" : "en_core_web_lg"
```
+ Pour l'encodage [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features), ce champ n'est pas utilisé.
## Le champ max\$1length
Le champ `max_length` est facultatif pour les fonctionnalités `text_fasttext`, où il indique le nombre maximal de jetons qui seront encodés dans une fonctionnalité de texte en entrée. Entrez du texte d'une longueur supérieure à celle de `max_length` qui est tronquée. Par exemple, définir max\$1length sur 128 indique que tous les jetons situés après le 128e dans une séquence de texte seront ignorés :
```
"max_length": 128
```
## Le champ du séparateur
Ce champ est utilisé en option avec les fonctionnalités `category`, `numerical` et `auto`. Il spécifie un caractère qui peut être utilisé pour diviser une valeur de propriété en plusieurs valeurs catégorielles ou valeurs numériques :
```
"separator": ";"
```
Utilisez le champ `separator` seulement quand la propriété stocke plusieurs valeurs délimitées dans une seule chaîne, telle que `"Actor;Director"` ou `"0.1;0.2"`.
Consultez [Fonctionnalités catégorielles](machine-learning-feature-encoding.md#machine-learning-categorical-features), [Fonctionnalités numériques](machine-learning-feature-encoding.md#machine-learning-numerical-features) et [Encodage automatique](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
## Le champ de portée
Ce champ est obligatoire pour les fonctionnalités `bucket_numerical`. Il indique la plage de valeurs numériques qui doivent être divisées en compartiments, au format `[lower-bound, upper-bound]` :
```
"range" : [20, 100]
```
Si une valeur de propriété est inférieure à la limite inférieure, elle est affectée au premier compartiment, ou si elle est supérieure à la limite supérieure, elle est affectée au dernier compartiment.
Consultez [Fonctionnalités numériques de compartiment dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Le champ bucket\$1cnt
Ce champ est obligatoire pour les fonctionnalités `bucket_numerical`. Il spécifie le nombre de compartiments dans lesquels la plage numérique définie par le paramètre `range` doit être divisée :
```
"bucket_cnt": 10
```
Consultez [Fonctionnalités numériques de compartiment dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Le champ slide\$1window\$1size
Ce champ est utilisé en option avec les fonctionnalités `bucket_numerical` pour attribuer des valeurs à plusieurs compartiments :
```
"slide_window_size": 5
```
Le fonctionnement d'une fenêtre coulissante est le suivant : Neptune ML prend la taille de la fenêtre **`s`** et transforme chaque valeur numérique **`v`** d'une propriété en une plage allant de ` v - s/2 ` à ` v + s/2 `. La valeur est ensuite attribuée à chaque compartiment que la plage chevauche.
Consultez [Fonctionnalités numériques de compartiment dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Le champ de l'imputeur
Ce champ est utilisé en option avec les fonctionnalités `numerical` et `bucket_numerical` pour fournir une technique d'imputation permettant de renseigner les valeurs manquantes :
```
"imputer": "mean"
```
Les techniques d'imputation prises en charge sont les suivantes :
+ `"mean"`
+ `"median"`
+ `"most-frequent"`
Si vous n'incluez pas le paramètre imputer, le prétraitement des données s'arrête lorsqu'une valeur manquante est détectée.
Consultez [Fonctionnalités numériques dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features) et [Fonctionnalités numériques de compartiment dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## Le champ max\$1features
Ce champ est utilisé en option par les fonctionnalités `text_tfidf` pour spécifier le nombre maximal de termes à encoder :
```
"max_features": 100
```
Avec un paramètre de 100, le vectoriseur TF-IDF encode uniquement les 100 termes les plus courants. Si vous n'incluez pas `max_features`, la valeur par défaut est 5 000.
Consultez [Encodage TF-IDF des fonctionnalités de texte dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Le champ min\$1df
Ce champ est utilisé en option par les fonctionnalités `text_tfidf` pour spécifier la fréquence minimale des documents des termes à encoder :
```
"min_df": 5
```
Un paramètre de 5 indique qu'un terme doit apparaître dans au moins 5 valeurs de propriété différentes pour être encodé.
La valeur par défaut si vous n'incluez pas le paramètre `min_df` est `2`.
Consultez [Encodage TF-IDF des fonctionnalités de texte dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Le champ ngram\$1range
Ce champ est utilisé en option par les fonctionnalités `text_tfidf` pour spécifier la taille des séquences de mots ou de jetons à considérer comme des termes individuels potentiels à encoder :
```
"ngram_range": [2, 4]
```
La valeur `[2, 4]` indique que les séquences de 2, 3 et 4 mots doivent être considérées comme des termes individuels potentiels.
Si vous ne définissez pas explicitement `ngram_range`, la valeur par défaut est `[1, 1]`, ce qui signifie que seuls des mots ou des jetons uniques sont considérés comme des termes à encoder.
Consultez [Encodage TF-IDF des fonctionnalités de texte dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## Le champ datetime\$1parts
Ce champ est utilisé en option par les fonctionnalités `datetime` pour spécifier les parties de la valeur datetime à encoder de manière catégorielle :
```
"datetime_parts": ["weekday", "hour"]
```
Si vous n'incluez pas `datetime_parts`, Neptune ML encode par défaut les parties année, mois, jour de la semaine et heure de la valeur datetime. La valeur `["weekday", "hour"]` indique que seuls le jour de la semaine et l'heure des valeurs datetime doivent être encodés de manière catégorielle dans la fonctionnalité.
Si l'une des parties ne possède pas plus d'une valeur unique dans le jeu d'entraînement, elle n'est pas encodée.
Consultez [Fonctionnalités datetime dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).