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.

# Utilisation de l'outil neptune-export ou du service Neptune-Export pour exporter des données depuis Neptune pour Neptune ML
<a name="machine-learning-data-export"></a>

Neptune ML nécessite que vous fournissiez des données d'entraînement pour [Deep Graph Library (DGL)](https://www.dgl.ai/) afin de créer et d'évaluer des modèles.

Vous pouvez exporter des données depuis Neptune à l'aide du [service d'exportation Neptune](export-service.md) ou de l'[utilitaire `neptune-export`](export-utility.md). Le service et l'outil de ligne de commande publient les données dans Amazon Simple Storage Service (Amazon S3) dans un format CSV, chiffrées à l'aide du chiffrement côté serveur Amazon S3 (`SSE-S3`). Consultez [Fichiers exportés par Neptune-Export et `neptune-export`](exported-files.md).

En outre, lorsque vous configurez une exportation de données d'entraînement pour Neptune ML, la tâche d'exportation crée et publie un fichier de configuration d'entraînement de modèle chiffré avec les données exportées. Par défaut, ce fichier est nommé `training-data-configuration.json`.

# Exemples d'utilisation du service d'exportation Neptune pour exporter des données d'entraînement pour Neptune ML
<a name="machine-learning-export-examples"></a>

Cette demande exporte les données d'entraînement de graphe de propriétés pour une tâche de classification de nœud :

```
curl \
  (your NeptuneExportApiUri) \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
        "command": "export-pg",
        "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
        "params": {
          "endpoint": "(your Neptune endpoint DNS name)",
          "profile": "neptune_ml"
        },
        "additionalParams": {
          "neptune_ml": {
            "version": "v2.0",
            "targets": [
              {
                "node": "Movie",
                "property": "genre",
                "type": "classification"
              }
            ]
          }
        }
      }'
```

Cette demande exporte les données d'entraînement RDF pour une tâche de classification de nœud :

```
curl \
  (your NeptuneExportApiUri) \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{
        "command": "export-rdf",
        "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
        "params": {
          "endpoint": "(your Neptune endpoint DNS name)",
          "profile": "neptune_ml"
        },
        "additionalParams": {
          "neptune_ml": {
            "version": "v2.0",
            "targets": [
              {
                "node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
                "predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
                "type": "classification"
              }
            ]
          }
        }
      }'
```

# Champs à définir dans l'objet params lors de l'exportation des données d'entraînement
<a name="machine-learning-params"></a>

L'objet d'une demande d'exportation peut contenir différents champs, comme décrit dans la [documentation `params`](export-params-fields.md). Les champs suivants sont particulièrement pertinents pour l'exportation de données d'entraînement de machine learning :

****
+ **`endpoint`** : utilisez `endpoint` pour spécifier un point de terminaison d'une instance Neptune dans votre cluster de bases de données que le processus d'exportation peut interroger pour extraire des données.
+ **`profile`** : le champ `profile` de l'objet `params` doit être défini sur **`neptune-ml`**.

  Cela permet au processus d'exportation de formater les données exportées de manière appropriée pour l'entraînement de modèle Neptune ML, au format CSV pour des données de graphe de propriétés ou sous forme de N-Triples pour des données RDF. Cela entraîne également la création et l'écriture d'un fichier `training-data-configuration.json` dans le même emplacement Amazon S3 que les données d'entraînement exportées.
+ **`cloneCluster`** : s'il est défini sur `true`, le processus d'exportation clone votre cluster de bases de données, exporte depuis le clone, puis supprime le clone une fois terminé.
+ **`useIamAuth`** : si l'[authentification IAM](iam-auth-enable.md) est activée sur votre cluster de bases de données, vous devez inclure ce champ défini sur `true`.

Le processus d'exportation propose également plusieurs méthodes pour filtrer les données que vous exportez (voir [ces exemples](export-filtering-examples.md)).

# Utilisation de l'objet AdditionalParams pour régler l'exportation des informations d'entraînement des modèles
<a name="machine-learning-additionalParams"></a>

L'objet `additionalParams` contient des champs que vous pouvez utiliser pour spécifier des étiquettes de classe de machine learning et des fonctionnalités à des fins d'entraînement et pour guider la création d'un fichier de configuration de données d'entraînement.

Le processus d'exportation ne permet pas de déduire automatiquement quelles propriétés de nœud et d'arête doivent être les étiquettes de classe de machine learning qui doivent servir d'exemples à des fins d'entraînement. Il ne peut pas non plus déduire automatiquement le meilleur encodage des fonctionnalités pour les propriétés numériques, catégorielles et textuelles. Vous devez donc fournir des indications à l'aide des champs de l'objet `additionalParams` pour spécifier ces éléments ou pour remplacer l'encodage par défaut.

Pour des données de graphe de propriétés, la structure de haut niveau d'`additionalParams` dans une demande d'exportation peut ressembler à ceci :

```
{
  "command": "export-pg",
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "profile": "neptune_ml"
  },
  "additionalParams": {
      "neptune_ml": {
        "version": "v2.0",
        "targets": [ (an array of node and edge class label targets) ],
        "features": [ (an array of node feature hints) ]
    }
  }
}
```

Pour des données RDF, leur structure de haut niveau peut ressembler à ceci :

```
{
  "command": "export-rdf",
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "profile": "neptune_ml"
  },
  "additionalParams": {
      "neptune_ml": {
        "version": "v2.0",
        "targets": [ (an array of node and edge class label targets) ]
    }
  }
}
```

Vous pouvez également fournir plusieurs configurations d'exportation à l'aide du champ `jobs` :

```
{
  "command": "export-pg",
  "outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
  "params": {
    "endpoint": "(your Neptune endpoint DNS name)",
    "profile": "neptune_ml"
  },
  "additionalParams" : {
    "neptune_ml" : {
      "version": "v2.0",
      "jobs": [
        {
          "name" : "(training data configuration name)",
          "targets": [ (an array of node and edge class label targets) ],
          "features": [ (an array of node feature hints) ]
        },
        {
          "name" : "(another training data configuration name)",
          "targets": [ (an array of node and edge class label targets) ],
          "features": [ (an array of node feature hints) ]
        }
      ]
    }
  }
}
```

# Éléments de haut niveau dans le champ neptune\$1ml dans AdditionalParams
<a name="machine-learning-neptune_ml-top-level"></a>

## L'élément de version dans neptune\$1ml
<a name="machine-learning-neptune_ml-version"></a>

Spécifie la version de configuration des données d'entraînement à générer.

(*Facultatif*), *Type* : string, *Valeur par défaut* : « v2.0 ».

Si vous incluez `version`, réglez-la sur `v2.0`.

## Le champ jobs dans neptune\$1ml
<a name="machine-learning-neptune_ml-jobs"></a>

Contient un tableau d'objets de configuration de données d'entraînement, chacun définissant une tâche de traitement de données et contenant :
+ **`name`** : nom de la configuration des données d'entraînement à créer.

   Par exemple, une configuration de données d'entraînement portant le nom « job-number-1 » donne lieu à un fichier de configuration de données d'entraînement nommé `job-number-1.json`.
+ **`targets`** : tableau JSON de cibles d'étiquettes de classes de nœuds et d'arêtes qui représentent les étiquettes des classes de machine learning à des fins d'entraînement. Consultez [Le champ targets dans un objet neptune\$1ml](machine-learning-neptune_ml-targets.md).
+ **`features`** : tableau JSON de fonctionnalités de propriété de nœud. Consultez [Le champ des fonctionnalités dans neptune\$1ml](machine-learning-neptune_ml-features.md).

# Le champ targets dans un objet neptune\$1ml
<a name="machine-learning-neptune_ml-targets"></a>

Le champ `targets` d'une configuration d'exportation de données d'entraînement JSON contient un tableau d'objets cibles qui spécifient une tâche d'entraînement, ainsi que les étiquettes des classes de machine learning pour l'entraînement de cette tâche. Le contenu des objets cibles varie selon que vous effectuez l'entraînement sur des données de graphe de propriétés ou sur des données RDF.

Pour les tâches de classification et de régression de nœud de graphe de propriétés, les objets cibles du tableau peuvent ressembler à ceci :

```
{
  "node": "(node property-graph label)",
  "property": "(property name)",
  "type" : "(used to specify classification or regression)",
  "split_rate": [0.8,0.2,0.0],
  "separator": ","
}
```

Pour les tâches de prédiction de lien, de régression ou de classification d'arête de graphe de propriétés, elles peuvent ressembler à ceci :

```
{
  "edge": "(edge property-graph label)",
  "property": "(property name)",
  "type" : "(used to specify classification, regression or link_prediction)",
  "split_rate": [0.8,0.2,0.0],
  "separator": ","
}
```

Pour les tâches de régression et de classification RDF, les objets cibles du tableau peuvent ressembler à ceci :

```
{
  "node": "(node type of an RDF node)",
  "predicate": "(predicate IRI)",
  "type" : "(used to specify classification or regression)",
  "split_rate": [0.8,0.2,0.0]
}
```

Pour les tâches de prédiction de lien RDF, les objets cibles du tableau peuvent ressembler à ceci :

```
{
  "subject": "(source node type of an edge)",
  "predicate": "(relation type of an edge)",
  "object": "(destination node type of an edge)",
  "type" : "link_prediction",
  "split_rate": [0.8,0.2,0.0]
}
```

Les objets cibles peuvent contenir les champs suivants :

**Contents**
+ [Champs cibles de graphe de propriétés](#machine-learning-property-graph-neptune_ml-targets)
  + [nœud](#machine-learning-property-graph-neptune_ml-targets-node)
  + [périphérique](#machine-learning-property-graph-neptune_ml-targets-edge)
  + [property](#machine-learning-property-graph-neptune_ml-targets-property)
  + [type](#machine-learning-property-graph-neptune_ml-targets-type)
  + [split\$1rate](#machine-learning-property-graph-neptune_ml-targets-split_rate)
  + [separator](#machine-learning-property-graph-neptune_ml-targets-separator)
+ [Champs cibles RDF](#machine-learning-RDF-neptune_ml-targets)
  + [nœud](#machine-learning-RDF-neptune_ml-targets-node)
  + [subject](#machine-learning-RDF-neptune_ml-targets-subject)
  + [predicate](#machine-learning-RDF-neptune_ml-targets-predicate)
  + [objet](#machine-learning-RDF-neptune_ml-targets-object)
  + [type](#machine-learning-RDF-neptune_ml-targets-type)
  + [split\$1rate](#machine-learning-RDF-neptune_ml-targets-split_rate)

## Champs figurant dans un objet cible de graphe de propriétés
<a name="machine-learning-property-graph-neptune_ml-targets"></a>

### Le champ de nœud (sommet) d'un objet cible
<a name="machine-learning-property-graph-neptune_ml-targets-node"></a>

Étiquette de graphe de propriétés d'un nœud cible (sommet). Un objet cible doit contenir un élément `node` ou un élément `edge`, mais pas les deux.

Un élément `node` peut prendre une valeur unique, comme ceci :

```
  "node": "Movie"
```

Ou, dans le cas d'un sommet à plusieurs étiquettes, il peut prendre un tableau de valeurs, comme ceci :

```
  "node": ["Content", "Movie"]
```

### Le champ de bord d'un objet cible comportant un graphe de propriétés
<a name="machine-learning-property-graph-neptune_ml-targets-edge"></a>

Spécifie une arête cible à l'aide de sa ou ses étiquettes de nœud de départ, de sa propre étiquette et de sa ou ses étiquettes de nœud de fin. Un objet cible doit contenir un élément `edge` ou un élément `node`, mais pas les deux.

La valeur d'un champ `edge` est un tableau JSON de trois chaînes qui représentent la ou les étiquettes de graphe de propriétés du nœud de départ, l'étiquette de graphe de propriétés de l'arête elle-même, ainsi que la ou les étiquettes de graphe de propriétés du nœud de fin, comme suit :

```
  "edge": ["Person_A", "knows", "Person_B"]
```

Si le nœud de départ (nœud de and/or fin) possède plusieurs étiquettes, placez-les dans un tableau, comme ceci :

```
  "edge": [ ["Admin", Person_A"], "knows", ["Admin", "Person_B"] ]
```

### Le champ de propriété d'un objet cible comportant un graphe de propriétés
<a name="machine-learning-property-graph-neptune_ml-targets-property"></a>

Spécifie une propriété du sommet ou de l'arête cible, comme suit :

```
  "property" : "rating"
```

Ce champ est obligatoire, sauf lorsque la tâche cible est une prédiction de lien.

### Le champ de type dans un objet cible comportant un graphe de propriétés
<a name="machine-learning-property-graph-neptune_ml-targets-type"></a>

Indique le type de tâche cible à exécuter sur l'élément `node` ou `edge`, comme ceci :

```
  "type" : "regression"
```

Les types de tâche pris en charge pour les nœuds sont les suivants :
+ `classification`
+ `regression`

Les types de tâche pris en charge pour les arêtes sont les suivants :
+ `classification`
+ `regression`
+ `link_prediction`

Ce champ est obligatoire.

### Le champ split\$1rate dans un objet cible Property-Graph
<a name="machine-learning-property-graph-neptune_ml-targets-split_rate"></a>

(*Facultatif*) Estimation des proportions de nœuds et d'arêtes que les phases d'entraînement, de validation et de test utiliseront, respectivement. Ces proportions sont représentées par un tableau JSON de trois nombres compris entre zéro et un dont la somme est égale à un :

```
"split_rate": [0.7, 0.1, 0.2]
```

Si vous ne fournissez pas le `split_rate` champ facultatif, la valeur estimée par défaut est `[0.9, 0.1, 0.0]` destinée aux tâches de classification et de régression, ainsi qu'`[0.9,0.05, 0.05]`aux tâches de prédiction de liens.

### Le champ de séparation dans un objet cible comportant un graphe de propriétés
<a name="machine-learning-property-graph-neptune_ml-targets-separator"></a>

(*Facultatif*) Utilisé avec une tâche de classification.

Le champ `separator` spécifie un caractère utilisé pour diviser la valeur d'une propriété cible en plusieurs valeurs catégorielles, lorsqu'il est utilisé pour stocker plusieurs valeurs de catégorie dans une chaîne. Par exemple :

```
"separator": "|"
```

La présence d'un champ `separator` indique que la tâche est une tâche de classification à plusieurs cibles.

## Champs figurant dans un objet cible RDF
<a name="machine-learning-RDF-neptune_ml-targets"></a>

### Le champ de nœud dans un objet cible RDF
<a name="machine-learning-RDF-neptune_ml-targets-node"></a>

Définit le type de nœud des nœuds cibles. Utilisé avec les tâches de classification de nœud ou les tâches de régression de nœud. Le type de nœud d'un nœud dans RDF est défini par :

```
  node_id, <http://www.w3.org/1999/02/22-rdf-syntax-ns#type>, node_type
```

Un élément `node` RDF peut seulement prendre une valeur unique, comme ceci :

```
  "node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```

### Le champ objet d'un objet cible RDF
<a name="machine-learning-RDF-neptune_ml-targets-subject"></a>

Pour les tâches de prédiction de lien, `subject` définit le type de nœud source des arêtes cibles.

```
  "subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director"
```

**Note**  
Pour les tâches de prédiction de lien, `subject` doit être utilisé conjointement avec `predicate` et `object`. Si aucune de ces trois options n'est fournie, toutes les arêtes sont traitées comme cible d'entraînement.

### Le champ de prédicat dans un objet cible RDF
<a name="machine-learning-RDF-neptune_ml-targets-predicate"></a>

Pour les tâches de classification de nœud et de régression de nœud, `predicate` définit les données littérales utilisées comme fonctionnalité de nœud cible d'un nœud cible.

```
  "predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre"
```

**Note**  
Si les nœuds cibles n'ont qu'un seul prédicat définissant la fonctionnalité de nœud cible, le champ `predicate` peut être omis.

Pour les tâches de prédiction de lien, `predicate` définit le type de relation des arêtes cibles :

```
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/direct"
```

**Note**  
Pour les tâches de prédiction de lien, `predicate` doit être utilisé conjointement avec `subject` et `object`. Si aucune de ces trois options n'est fournie, toutes les arêtes sont traitées comme cible d'entraînement.

### Le champ d'objet dans un objet cible RDF
<a name="machine-learning-RDF-neptune_ml-targets-object"></a>

Pour les tâches de prédiction de lien, `object` définit le type de nœud de destination des arêtes cibles :

```
  "object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```

**Note**  
Pour les tâches de prédiction de lien, `object` doit être utilisé conjointement avec `subject` et `predicate`. Si aucune de ces trois options n'est fournie, toutes les arêtes sont traitées comme cible d'entraînement.

### Le champ de type dans un objet cible RDF
<a name="machine-learning-RDF-neptune_ml-targets-type"></a>

Indique le type de tâche cible à effectuer, comme suit :

```
  "type" : "regression"
```

Les types de tâche pris en charge pour les données RDF sont les suivants :
+ `link_prediction`
+ `classification`
+ `regression`

Ce champ est obligatoire.

### Champ `split_rate` figurant dans un objet cible de graphe de propriétés
<a name="machine-learning-RDF-neptune_ml-targets-split_rate"></a>

(*Facultatif*) Estimation des proportions de nœuds et d'arêtes que les phases d'entraînement, de validation et de test utiliseront, respectivement. Ces proportions sont représentées par un tableau JSON de trois nombres compris entre zéro et un dont la somme est égale à un :

```
"split_rate": [0.7, 0.1, 0.2]
```

Si vous ne spécifiez pas le champ `split_rate` facultatif, la valeur estimée par défaut est `[0.9, 0.1, 0.0]`.

# Le champ des fonctionnalités dans neptune\$1ml
<a name="machine-learning-neptune_ml-features"></a>

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
<a name="machine-learning-neptune_ml-features-node"></a>

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
<a name="machine-learning-neptune_ml-features-edge"></a>

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
<a name="machine-learning-neptune_ml-features-property"></a>

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
<a name="machine-learning-neptune_ml-feature-types"></a>

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
<a name="machine-learning-neptune_ml-features-norm"></a>

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
<a name="machine-learning-neptune_ml-features-language"></a>

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
<a name="machine-learning-neptune_ml-features-max_length"></a>

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
<a name="machine-learning-neptune_ml-features-separator"></a>

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
<a name="machine-learning-neptune_ml-features-range"></a>

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
<a name="machine-learning-neptune_ml-features-bucket_cnt"></a>

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
<a name="machine-learning-neptune_ml-features-slide_window_size"></a>

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
<a name="machine-learning-neptune_ml-features-imputer"></a>

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
<a name="machine-learning-neptune_ml-features-max_features"></a>

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
<a name="machine-learning-neptune_ml-features-min_df"></a>

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
<a name="machine-learning-neptune_ml-features-ngram_range"></a>

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
<a name="machine-learning-neptune_ml-features-datetime_parts"></a>

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

# Exemples d'utilisation de paramètres dans AdditionalParams pour ajuster la configuration d'entraînement des modèles
<a name="machine-learning-data-export-additionalParams-examples"></a>

 Les exemples suivants montrent comment utiliser la fonctionnalité « AdditionalParams » dans les modèles de données Property-Graph et RDF pour configurer différents aspects du processus d'apprentissage des modèles pour une application Neptune ML. Les exemples couvrent un large éventail de fonctionnalités, notamment la spécification des taux de division par défaut pour les training/validation/test données, la définition de tâches de classification des nœuds, de régression et de prédiction de liens, ainsi que la configuration de différents types de fonctionnalités tels que les compartiments numériques, les intégrations de texte, la date et l'heure et les données catégorielles. Ces configurations détaillées vous permettent d'adapter le pipeline d'apprentissage automatique à vos exigences spécifiques en matière de données et de modélisation, libérant ainsi tout le potentiel des fonctionnalités de Neptune ML. 

**Contents**
+ [

## Exemples de graphes de propriétés utilisant AdditionalParams
](#machine-learning-property-graph-additionalParams-examples)
  + [

### Spécification d'un taux de division par défaut pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-default-split-rate-example)
  + [

### Spécification d'une tâche de classification de nœud pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-node-classification-example)
  + [

### Spécification d'une tâche de classification de nœud multiclasse pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-multi-class-example)
  + [

### Spécification d'une tâche de régression de nœud pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-node-regression-example)
  + [

### Spécification d'une tâche de classification d'arête pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-edge-classification-example)
  + [

### Spécification d'une tâche de classification d'arête multiclasse pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-multi-edge-classification-example)
  + [

### Spécification d'une régression d'arête pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-edge-regression-example)
  + [

### Spécification d'une tâche de prédiction de lien pour la configuration d'entraînement de modèle
](#machine-learning-property-graph-additionalParams-link-prediction-example)
  + [

### Spécification d'une fonctionnalité de compartiment numérique
](#machine-learning-property-graph-additionalParams-numeric-bucket-example)
  + [

### Spécification d'une fonctionnalité `Word2Vec`
](#machine-learning-property-graph-additionalParams-word2vec-example)
  + [

### Spécification d'une fonctionnalité `FastText`
](#machine-learning-property-graph-additionalParams-fasttext-example)
  + [

### Spécification d'une fonctionnalité `Sentence BERT`
](#machine-learning-property-graph-additionalParams-sbert-example)
  + [

### Spécification d'une fonctionnalité `TF-IDF`
](#machine-learning-property-graph-additionalParams-tf-idf-example)
  + [

### Spécification d'une fonctionnalité `datetime`
](#machine-learning-property-graph-additionalParams-datetime-example)
  + [

### Spécification d'une fonctionnalité `category`
](#machine-learning-property-graph-additionalParams-category-example)
  + [

### Spécification d'une fonctionnalité `numerical`
](#machine-learning-property-graph-additionalParams-numerical-example)
  + [

### Spécification d'une fonctionnalité `auto`
](#machine-learning-property-graph-additionalParams-auto-example)
+ [

## Exemples RDF utilisant `additionalParams`
](#machine-learning-RDF-additionalParams-examples)
  + [

### Spécification d'un taux de division par défaut pour la configuration d'entraînement de modèle
](#machine-learning-RDF-additionalParams-default-split-rate-example)
  + [

### Spécification d'une tâche de classification de nœud pour la configuration d'entraînement de modèle
](#machine-learning-RDF-additionalParams-node-classification-example)
  + [

### Spécification d'une tâche de régression de nœud pour la configuration d'entraînement de modèle
](#machine-learning-RDF-additionalParams-node-regression-example)
  + [

### Spécification d'une tâche de prédiction de lien pour des arêtes spécifiques
](#machine-learning-RDF-additionalParams-link-prediction-example)
  + [

### Spécification d'une tâche de prédiction de lien pour toutes les arêtes
](#machine-learning-RDF-additionalParams-link-prediction-example)

## Exemples de graphes de propriétés utilisant AdditionalParams
<a name="machine-learning-property-graph-additionalParams-examples"></a>

### Spécification d'un taux de division par défaut pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-default-split-rate-example"></a>

Dans l'exemple suivant, le paramètre `split_rate` définit le taux de division par défaut pour l'entraînement de modèle. Si aucun taux de division par défaut n'est spécifié, l'entraînement utilise une valeur de [0.9, 0.1, 0.0]. Vous pouvez remplacer la valeur par défaut pour chaque cible en spécifiant un `split_rate` pour chaque cible.

Dans l'exemple suivant, le champ `default split_rate` indique qu'un taux de division de `[0.7,0.1,0.2]` doit être utilisé, sauf s'il est remplacé cible par cible :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "split_rate": [0.7,0.1,0.2],
    "targets": [
      (...)
    ],
    "features": [
      (...)
    ]
  }
}
```

### Spécification d'une tâche de classification de nœud pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-node-classification-example"></a>

Pour indiquer quelle propriété de nœud contient des exemples étiquetés à des fins d'entraînement, ajoutez un élément de classification de nœud au tableau `targets` en utilisant `"type" : "classification"`. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

Dans l'exemple suivant, la cible `node` indique que la propriété `genre` de chaque nœud `Movie` doit être traitée comme une étiquette de classe de nœuds. La valeur `split_rate` remplace le taux de division par défaut :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "node": "Movie",
        "property": "genre",
        "type": "classification",
        "split_rate": [0.7,0.1,0.2]
      }
    ],
    "features": [
      (...)
    ]
  }
}
```

### Spécification d'une tâche de classification de nœud multiclasse pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-multi-class-example"></a>

Pour indiquer quelle propriété de nœud contient plusieurs exemples étiquetés à des fins d'entraînement, ajoutez un élément de classification de nœud au tableau de cibles, en utilisant `"type" : "classification"`, et `separator` pour spécifier un caractère qui peut être utilisé pour diviser la valeur d'une propriété cible en plusieurs valeurs catégorielles. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

Dans l'exemple suivant, la cible `node` indique que la propriété `genre` de chaque nœud `Movie` doit être traitée comme une étiquette de classe de nœuds. Le champ `separator` indique que chaque propriété de genre contient plusieurs valeurs séparées par des points-virgules :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "node": "Movie",
        "property": "genre",
        "type": "classification",
        "separator": ";"
      }
    ],
    "features": [
      (...)
    ]
  }
}
```

### Spécification d'une tâche de régression de nœud pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-node-regression-example"></a>

Pour indiquer quelle propriété de nœud contient des régressions étiquetées à des fins d'entraînement, ajoutez un élément de régression de nœud au tableau de cibles, en utilisant `"type" : "regression"`. Ajoutez un champ split\$1rate si vous souhaitez remplacer le taux de division par défaut.

La cible `node` suivante indique que la propriété `rating` de chaque nœud `Movie` doit être traitée comme une étiquette de régression de nœud :

```
    "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "node": "Movie",
        "property": "rating",
        "type" : "regression",
        "split_rate": [0.7,0.1,0.2]
      }
    ],
    "features": [
      ...
    ]
  }
}
```

### Spécification d'une tâche de classification d'arête pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-edge-classification-example"></a>

Pour indiquer quelle propriété d'arête contient des exemples étiquetés à des fins d'entraînement, ajoutez un élément d'arête au tableau `targets` en utilisant `"type" : "regression"`. Ajoutez un champ split\$1rate si vous souhaitez remplacer le taux de division par défaut.

La cible `edge` suivante indique que la propriété `metAtLocation` de chaque arête `knows` doit être traitée comme une étiquette de classe d'arêtes.

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "edge": ["Person", "knows", "Person"],
        "property": "metAtLocation",
        "type": "classification"
      }
    ],
    "features": [
      (...)
    ]
  }
}
```

### Spécification d'une tâche de classification d'arête multiclasse pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-multi-edge-classification-example"></a>

Pour indiquer quelle propriété d'arête contient plusieurs exemples étiquetés à des fins d'entraînement, ajoutez un élément d'arête au tableau `targets`, en utilisant `"type" : "classification"`, et un champ `separator` pour spécifier un caractère utilisé pour diviser une valeur de propriété cible en plusieurs valeurs catégorielles. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

La cible `edge` suivante indique que la propriété `sentiment` de chaque arête `repliedTo` doit être traitée comme une étiquette de classe d'arêtes : Le champ de séparation indique que chaque propriété de sentiment contient plusieurs valeurs séparées par des virgules :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "edge": ["Person", "repliedTo", "Message"],
        "property": "sentiment",
        "type": "classification",
        "separator": ","
      }
    ],
    "features": [
      (...)
    ]
  }
}
```

### Spécification d'une régression d'arête pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-edge-regression-example"></a>

Pour indiquer quelle propriété d'arête contient des exemples de régression étiquetés à des fins d'entraînement, ajoutez un élément `edge` au tableau `targets` en utilisant `"type" : "regression"`. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

La cible `edge` suivante indique que la propriété `rating` de chaque arête `reviewed` doit être traitée comme une régression d'arête :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "edge": ["Person", "reviewed", "Movie"],
        "property": "rating",
        "type" : "regression"
      }
    ],
    "features": [
      (...)
    ]
  }
}
```

### Spécification d'une tâche de prédiction de lien pour la configuration d'entraînement de modèle
<a name="machine-learning-property-graph-additionalParams-link-prediction-example"></a>

Pour indiquer quelles arêtes doivent être utilisées à des fins d'entraînement de prédiction de lien, ajoutez un élément d'arête au tableau de cibles en utilisant `"type" : "link_prediction"`. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

La cible `edge` suivante indique que les arêtes `cites` doivent être utilisées pour la prédiction de lien :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "edge": ["Article", "cites", "Article"],
        "type" : "link_prediction"
      }
    ],
    "features": [
      (...)
    ]
  }
}
```

### Spécification d'une fonctionnalité de compartiment numérique
<a name="machine-learning-property-graph-additionalParams-numeric-bucket-example"></a>

Vous pouvez spécifier une fonctionnalité de données numériques pour une propriété de nœud en ajoutant `"type": "bucket_numerical"` au tableau `features`.

La fonctionnalité `node` suivante indique que la propriété `age` de chaque nœud `Person` doit être traitée comme une fonctionnalité de compartiment numérique :

```
  "additionalParams": {
  "neptune_ml": {
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Person",
        "property": "age",
        "type": "bucket_numerical",
        "range": [1, 100],
        "bucket_cnt": 5,
        "slide_window_size": 3,
        "imputer": "median"
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `Word2Vec`
<a name="machine-learning-property-graph-additionalParams-word2vec-example"></a>

Vous pouvez spécifier une fonctionnalité `Word2Vec` pour une propriété de nœud en ajoutant `"type": "text_word2vec"` au tableau `features`.

La fonctionnalité `node` suivante indique que la propriété `description` de chaque nœud `Movie` doit être traitée comme une fonctionnalité `Word2Vec` :

```
"additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Movie",
        "property": "description",
        "type": "text_word2vec",
        "language": "en_core_web_lg"
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `FastText`
<a name="machine-learning-property-graph-additionalParams-fasttext-example"></a>

Vous pouvez spécifier une fonctionnalité `FastText` pour une propriété de nœud en ajoutant `"type": "text_fasttext"` au tableau `features`. Le champ `language` est obligatoire et doit spécifier l'un des codes de langue suivants :
+ `en`   (anglais)
+ `zh`   (chinois)
+ `hi`   (hindi)
+ `es`   (espagnol)
+ `fr`   (français)

Notez que l'encodage `text_fasttext` ne peut pas gérer plus d'une langue à la fois dans une fonctionnalité.

La fonctionnalité `node` suivante indique que la propriété `description` française de chaque nœud `Movie` doit être traitée comme une fonctionnalité `FastText` :

```
"additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Movie",
        "property": "description",
        "type": "text_fasttext",
        "language": "fr",
        "max_length": 1024
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `Sentence BERT`
<a name="machine-learning-property-graph-additionalParams-sbert-example"></a>

Vous pouvez spécifier une fonctionnalité `Sentence BERT` pour une propriété de nœud en ajoutant `"type": "text_sbert"` au tableau `features`. Il n'est pas nécessaire de spécifier la langue, car la méthode encode automatiquement les fonctionnalités de texte à l'aide d'un modèle de langue multilingue.

La fonctionnalité `node` suivante indique que la propriété `description` de chaque nœud `Movie` doit être traitée comme une fonctionnalité `Sentence BERT` :

```
"additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Movie",
        "property": "description",
        "type": "text_sbert128",
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `TF-IDF`
<a name="machine-learning-property-graph-additionalParams-tf-idf-example"></a>

Vous pouvez spécifier une fonctionnalité `TF-IDF` pour une propriété de nœud en ajoutant `"type": "text_tfidf"` au tableau `features`.

La fonctionnalité `node` suivante indique que la propriété `bio` de chaque nœud `Person` doit être traitée comme une fonctionnalité `TF-IDF` :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Movie",
        "property": "bio",
        "type": "text_tfidf",
        "ngram_range": [1, 2],
        "min_df": 5,
        "max_features": 1000
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `datetime`
<a name="machine-learning-property-graph-additionalParams-datetime-example"></a>

Le processus d'exportation déduit automatiquement des fonctionnalités `datetime` pour les propriétés de date. Toutefois, si vous souhaitez limiter l'élément `datetime_parts` utilisé pour une fonctionnalité `datetime` ou remplacer une spécification de fonctionnalité afin qu'une propriété qui serait normalement traitée comme une fonctionnalité `auto` soit explicitement traitée comme une fonctionnalité `datetime`, vous pouvez le faire en ajoutant un élément `"type": "datetime"` au tableau de fonctionnalités.

La fonctionnalité `node` suivante indique que la propriété `createdAt` de chaque nœud `Post` doit être traitée comme une fonctionnalité `datetime` :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Post",
        "property": "createdAt",
        "type": "datetime",
        "datetime_parts": ["month", "weekday", "hour"]
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `category`
<a name="machine-learning-property-graph-additionalParams-category-example"></a>

Le processus d'exportation déduit automatiquement des 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 fonctionnalité afin qu'une propriété soit traitée comme une fonctionnalité catégorielle, ajoutez un élément `"type": "category"` au tableau de fonctionnalités. Si la propriété contient plusieurs valeurs, incluez un champ `separator`. Par exemple :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Post",
        "property": "tag",
        "type": "category",
        "separator": "|"
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `numerical`
<a name="machine-learning-property-graph-additionalParams-numerical-example"></a>

Le processus d'exportation déduit automatiquement des 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 fonctionnalité afin qu'une propriété soit traitée comme une fonctionnalité `numerical`, ajoutez un élément `"type": "numerical"` au tableau de fonctionnalités. Si la propriété contient plusieurs valeurs, incluez un champ `separator`. Par exemple :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "Recording",
        "property": "duration",
        "type": "numerical",
        "separator": ","
      }
    ]
  }
}
```

### Spécification d'une fonctionnalité `auto`
<a name="machine-learning-property-graph-additionalParams-auto-example"></a>

Le processus d'exportation déduit automatiquement des 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 fonctionnalité afin qu'une propriété soit traitée comme une fonctionnalité `auto`, ajoutez un élément `"type": "auto"` au tableau de fonctionnalités. Si la propriété contient plusieurs valeurs, incluez un champ `separator`. Par exemple :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      ...
    ],
    "features": [
      {
        "node": "User",
        "property": "role",
        "type": "auto",
        "separator": ","
      }
    ]
  }
}
```

## Exemples RDF utilisant `additionalParams`
<a name="machine-learning-RDF-additionalParams-examples"></a>

### Spécification d'un taux de division par défaut pour la configuration d'entraînement de modèle
<a name="machine-learning-RDF-additionalParams-default-split-rate-example"></a>

Dans l'exemple suivant, le paramètre `split_rate` définit le taux de division par défaut pour l'entraînement de modèle. Si aucun taux de division par défaut n'est spécifié, l'entraînement utilise une valeur de [0.9, 0.1, 0.0]. Vous pouvez remplacer la valeur par défaut pour chaque cible en spécifiant un `split_rate` pour chaque cible.

Dans l'exemple suivant, le champ `default split_rate` indique qu'un taux de division de `[0.7,0.1,0.2]` doit être utilisé, sauf s'il est remplacé cible par cible :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "split_rate": [0.7,0.1,0.2],
    "targets": [
      (...)
    ]
  }
}
```

### Spécification d'une tâche de classification de nœud pour la configuration d'entraînement de modèle
<a name="machine-learning-RDF-additionalParams-node-classification-example"></a>

Pour indiquer quelle propriété de nœud contient des exemples étiquetés à des fins d'entraînement, ajoutez un élément de classification de nœud au tableau `targets` en utilisant `"type" : "classification"`. Ajoutez un champ de nœud pour indiquer le type de nœud des nœuds cibles. Ajoutez un champ `predicate` pour définir les données littérales utilisées comme fonctionnalité de nœud cible du nœud cible. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

Dans l'exemple suivant, la cible `node` indique que la propriété `genre` de chaque nœud `Movie` doit être traitée comme une étiquette de classe de nœuds. La valeur `split_rate` remplace le taux de division par défaut :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
        "predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
        "type": "classification",
        "split_rate": [0.7,0.1,0.2]
      }
    ]
  }
}
```

### Spécification d'une tâche de régression de nœud pour la configuration d'entraînement de modèle
<a name="machine-learning-RDF-additionalParams-node-regression-example"></a>

Pour indiquer quelle propriété de nœud contient des régressions étiquetées à des fins d'entraînement, ajoutez un élément de régression de nœud au tableau de cibles, en utilisant `"type" : "regression"`. Ajoutez un champ `node` pour indiquer le type de nœud des nœuds cibles. Ajoutez un champ `predicate` pour définir les données littérales utilisées comme fonctionnalité de nœud cible du nœud cible. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

La cible `node` suivante indique que la propriété `rating` de chaque nœud `Movie` doit être traitée comme une étiquette de régression de nœud :

```
    "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
        "predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/rating",
        "type": "regression",
        "split_rate": [0.7,0.1,0.2]
      }
    ]
  }
}
```

### Spécification d'une tâche de prédiction de lien pour des arêtes spécifiques
<a name="machine-learning-RDF-additionalParams-link-prediction-example"></a>

Pour indiquer quelles arêtes doivent être utilisées à des fins d'entraînement de prédiction de lien, ajoutez un élément d'arête au tableau de cibles en utilisant `"type" : "link_prediction"`. Ajoutez les champs `subject`, `predicate` et `object` pour spécifier le type d'arête. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

La cible `edge` suivante indique que les arêtes `directed` qui connectent `Directors` à `Movies` doivent être utilisées pour la prédiction de lien :

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director",
        "predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/directed",
        "object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
        "type" : "link_prediction"
      }
    ]
  }
}
```

### Spécification d'une tâche de prédiction de lien pour toutes les arêtes
<a name="machine-learning-RDF-additionalParams-link-prediction-example"></a>

Pour indiquer que toutes les arêtes doivent être utilisées à des fins d'entraînement de prédiction de lien, ajoutez un élément `edge` au tableau de cibles en utilisant `"type" : "link_prediction"`. N'ajoutez pas de champs `subject`, `predicate` ni `object`. Ajoutez un champ `split_rate` si vous souhaitez remplacer le taux de division par défaut.

```
  "additionalParams": {
  "neptune_ml": {
    "version": "v2.0",
    "targets": [
      {
        "type" : "link_prediction"
      }
    ]
  }
}
```