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. # Amazon Neptune ML pour le machine learning sur les graphes Les grands jeux de données connectés contiennent souvent des informations précieuses qu'il peut être difficile d'extraire sur la seule base de l'intuition humaine. Les techniques de machine learning (ML) peuvent aider à trouver des corrélations cachées dans des graphes contenant des milliards de relations. Ces corrélations peuvent être utiles pour recommander des produits, prédire la solvabilité, identifier des fraudes et bien d'autres choses encore. La fonctionnalité Neptune ML permet de créer et d'entraîner des modèles de machine learning utiles sur de grands graphes en quelques heures au lieu de plusieurs semaines. [Pour ce faire, Neptune ML utilise la technologie GNN (Graph Neural Network) développée par [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/) et la [Deep Graph Library (DGL) (qui est open source)](https://www.dgl.ai/).](https://github.com/dmlc/dgl/) Les réseaux de neurones en graphes sont un domaine émergent de l'intelligence artificielle (consultez, par exemple, [A Comprehensive Survey on Graph Neural Networks](https://arxiv.org/abs/1901.00596)). Pour un didacticiel pratique sur l'utilisation GNNs de DGL, voir [Apprendre les réseaux neuronaux à graphes avec Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library). **Note** Les sommets d'un graphe sont identifiés dans les modèles Neptune ML en tant que « nœuds ». Par exemple, la classification de sommet utilise un modèle de machine learning de classification de nœud, tandis que la régression de sommet utilise un modèle de régression de nœud. ## Ce que Neptune ML peut faire Neptune prend en charge à la fois l'inférence transductive, qui renvoie des prédictions précalculées au moment de l'entraînement, en fonction de vos données de graphe à ce moment-là, et l'inférence inductive, qui renvoie et applique le traitement des données et l'évaluation du modèle en temps réel, sur la base des données actuelles. Consultez [Différence entre inférence inductive et inférence transductive](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference). Neptune ML peut entraîner des modèles de machine learning pour prendre en charge cinq catégories d'inférence différentes : **Types de tâche d'inférence actuellement pris en charge par Neptune ML** + **Classification de nœud** : prédiction de la fonctionnalité catégorielle d'une propriété de sommet. Par exemple, pour le film *Les Évadés*, Neptune ML peut prédire sa propriété `genre` en tant que `story` à partir d'un ensemble de candidats `[story, crime, action, fantasy, drama, family, ...]`. Il existe deux types de tâches de classification de nœud : + **Classification à classe unique** : dans ce type de tâche, chaque nœud possède une seule fonctionnalité cible. Par exemple, la propriété `Place_of_birth` de `Alan Turing` a la valeur `UK`. + **Classification multiclasse** : dans ce type de tâche, chaque nœud peut avoir plus d'une seule fonctionnalité cible. Par exemple, la propriété `genre` du film *Le Parrain* a les valeurs `crime` et `story`. + **Régression de nœud** : prédiction d'une propriété numérique d'un sommet. Par exemple, pour le film *Avengers, le dernier affrontement*, Neptune ML peut prédire que sa propriété `popularity` a une valeur de `5.0`. + **Classification d'arête** : prédiction de la fonctionnalité catégorielle d'une propriété d'arête. Il existe deux types de tâches de classification d'arête : + **Classification à classe unique** : dans ce type de tâche, chaque arête possède une seule fonctionnalité cible. Par exemple, une arête d'évaluation entre un utilisateur et un film peut avoir la propriété `liked`, avec la valeur « Oui » ou « Non ». + **Classification multiclasse** : dans ce type de tâche, chaque arête peut avoir plus d'une seule fonctionnalité cible. Par exemple, une évaluation entre un utilisateur et un film peut avoir plusieurs valeurs de balise de propriété, telles que « Drôle », « Réconfortant », « Reposant », etc. + **Régression d'arête** : prédiction d'une propriété numérique d'une arête. Par exemple, une arête d'évaluation entre un utilisateur et un film peut avoir la propriété numérique `score`, pour laquelle Neptune ML peut prédire une valeur à partir d'un utilisateur et d'un film. + **Prédiction de lien** : prédiction des nœuds de destination les plus probables pour un nœud source et une arête sortante particuliers, ou des nœuds sources les plus probables pour un nœud de destination et une arête entrante donnés. Par exemple, avec un graphe de connaissances médicament-maladie, avec `Aspirin` comme nœud source et `treats` comme arête sortante, Neptune ML peut prédire les nœuds de destination les plus pertinents `heart disease`, `fever`, etc. Ou, avec le graphe de connaissances de Wikimedia, avec `President-of` comme arête ou relation et `United-States` comme nœud de destination, Neptune ML peut prédire les têtes les plus pertinentes `George Washington`, `Abraham Lincoln`, `Franklin D. Roosevelt`, etc. **Note** La classification de nœud et la classification d'arête prennent en charge uniquement des valeurs de chaîne. Cela signifie que des valeurs de propriété numériques telles que `0` ou `1` ne sont pas prises en charge, alors que les valeurs équivalentes de type string `"0"` et `"1"` le sont. De même, les valeurs de propriété booléenne `true` et `false` ne fonctionnent pas, mais `"true"` et `"false"` fonctionnent. Avec Neptune ML, vous pouvez utiliser des modèles de machine learning séparés en deux catégories générales : **Types de modèles de machine learning actuellement pris en charge par Neptune ML** + **Modèles de réseaux neuronaux à graphes (GNN)** : ils incluent les [réseaux convolutionnels à graphes relationnels (R](https://arxiv.org/abs/1703.06103) -). GCNs Les modèles GNN fonctionnent pour les trois types de tâches ci-dessus. + **Modèles d'intégration de graphe de connaissances (KGE)** : ils incluent les modèles `TransE`, `DistMult` et `RotatE`. Ils fonctionnent uniquement pour la prédiction de lien. **Modèles définis par l'utilisateur** : Neptune ML vous permet également de fournir votre propre implémentation de modèle personnalisé pour tous les types de tâches répertoriés ci-dessus. Vous pouvez utiliser la [boîte à outils Neptune ML](https://github.com/awslabs/neptuneml-toolkit) pour développer et tester votre implémentation de modèle personnalisé basée sur Python avant d'utiliser l'API d'entraînement Neptune ML avec votre modèle. Consultez [Modèles personnalisés dans Neptune ML](machine-learning-custom-models.md) pour plus de détails sur la manière de structurer et d'organiser votre implémentation afin qu'elle soit compatible avec l'infrastructure d'entraînement de Neptune ML. # Configuration de Neptune ML Le moyen le plus simple de démarrer avec Neptune ML est d'[utiliser le modèle de démarrage CloudFormation rapide](machine-learning-quick-start.md). Ce modèle installe tous les composants nécessaires, y compris un nouveau cluster de bases de données Neptune, tous les rôles IAM nécessaires et un nouveau bloc-notes de graphe Neptune pour faciliter l'utilisation de Neptune ML. Vous pouvez également installer Neptune ML manuellement, comme expliqué dans [Configuration de Neptune ML sans utiliser le modèle de démarrage rapide CloudFormation](machine-learning-manual-setup.md). # Utilisation du AWS CloudFormation modèle Neptune ML pour démarrer rapidement dans un nouveau cluster de bases de données Le moyen le plus simple de démarrer avec Neptune ML est d'utiliser le modèle de démarrage CloudFormation rapide. Ce modèle installe tous les composants nécessaires, y compris un nouveau cluster de bases de données Neptune, tous les rôles IAM nécessaires et un nouveau bloc-notes de graphe Neptune pour faciliter l'utilisation de Neptune ML. **Pour créer la pile de démarrage rapide Neptune ML** 1. Pour lancer la CloudFormation pile sur la CloudFormation console, cliquez sur l'un des boutons **Launch Stack** dans le tableau suivant : [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/machine-learning-quick-start.html) 1. Sur la page **Select Template**, choisissez **Next**. 1. Sur la page **Specify Details (Spécifier les détails)**, choisissez **Next (Suivant)**. 1. Dans la page **Options**, choisissez **Suivant**. 1. Sur la page **Vérifier**, vous devez cocher deux cases : + Le premier reconnaît que cela AWS CloudFormation peut créer des ressources IAM avec des noms personnalisés. + La seconde reconnaît que cela AWS CloudFormation pourrait nécessiter la `CAPABILITY_AUTO_EXPAND` capacité de la nouvelle pile. `CAPABILITY_AUTO_EXPAND`permet explicitement d' CloudFormation étendre automatiquement les macros lors de la création de la pile, sans révision préalable. Les clients créent souvent un jeu de modifications à partir d'un modèle traité, de sorte que les modifications apportées par les macros puissent être révisées avant la création de la pile. Pour en savoir plus, consultez l'API CloudFormation [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html). Ensuite, choisissez **Créer**. Le modèle de démarrage rapide crée et configure les éléments suivants : + Un cluster de bases de données Neptune. + Les rôles IAM nécessaires (et les attache). + Le groupe de EC2 sécurité Amazon nécessaire. + Les points de SageMaker terminaison VPC AI nécessaires. + Un groupe de paramètres de cluster de bases de données pour Neptune ML. + Les paramètres nécessaires dans ce groupe de paramètres. + Un bloc-notes SageMaker basé sur l'IA avec des exemples de blocs-notes préremplis pour Neptune ML. Notez que toutes les tailles d'instance ne sont pas disponibles dans chaque région. Vous devez donc vous assurer que la taille d'instance de bloc-notes sélectionnée est prise en charge par votre région. + Le service d'exportation Neptune. Lorsque la pile de démarrage rapide est prête, accédez au bloc-notes SageMaker AI créé par le modèle et consultez les exemples préremplis. Ils vous aideront à télécharger des exemples de jeux de données à utiliser pour expérimenter les fonctionnalités de Neptune ML. Ils peuvent également vous faire gagner beaucoup de temps dans le cadre de l'utilisation de Neptune ML. Découvrez par exemple la commande magique linéaire [%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml) et la commande magique cellulaire [%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml) prises en charge par ces blocs-notes. Vous pouvez également utiliser la AWS CLI commande suivante pour exécuter le modèle de démarrage rapide CloudFormation  : ``` aws cloudformation create-stack \ --stack-name neptune-ml-fullstack-$(date '+%Y-%m-%d-%H-%M') \ --template-url https://aws-neptune-customer-samples.s3.amazonaws.com/v2/cloudformation-templates/neptune-ml-nested-stack.json \ --parameters ParameterKey=EnableIAMAuthOnExportAPI,ParameterValue=(true if you have IAM auth enabled, or false otherwise) \ ParameterKey=Env,ParameterValue=test$(date '+%H%M')\ --capabilities CAPABILITY_IAM \ --region (the AWS region, like us-east-1) \ --disable-rollback \ --profile (optionally, a named CLI profile of yours) ``` # Configuration de Neptune ML sans utiliser le modèle de démarrage rapide CloudFormation Ce guide fournit des step-by-step instructions pour configurer Amazon Neptune ML sans utiliser le modèle de démarrage AWS CloudFormation rapide. Il suppose que vous disposez déjà d'un cluster de base de données Neptune fonctionnel et couvre la configuration nécessaire, y compris l'installation du service Neptune-Export, la création de rôles IAM personnalisés et la configuration de votre cluster de base de données pour activer Neptune ML. Le guide explique également comment créer deux points de terminaison SageMaker IA dans votre VPC Neptune pour permettre au moteur Neptune d'accéder à la gestion de l'IA nécessaire. SageMaker APIs En suivant ces instructions, vous pouvez configurer Neptune ML sur votre infrastructure Neptune existante sans vous fier au modèle. CloudFormation ## Utilisation d'un cluster de bases de données Neptune fonctionnel Si vous n'utilisez pas le modèle de CloudFormation démarrage rapide pour configurer Neptune ML, vous aurez besoin d'un cluster de base de données Neptune existant pour fonctionner. Si vous le souhaitez, vous pouvez en utiliser un que vous possédez déjà, ou en cloner un que vous utilisez déjà, ou encore en créer un nouveau (voir [Créer un cluster Neptune](get-started-create-cluster.md)). ## Installation du service d'exportation Neptune Si vous ne l'avez pas encore fait, installez le service d'exportation Neptune, comme expliqué dans [Utilisation du service d'exportation Neptune pour exporter des données Neptune](export-service.md). Ajoutez une règle entrante au groupe de sécurité `NeptuneExportSecurityGroup` créé par l'installation, avec les paramètres suivants : + *Type :* `Custom TCP` + *Protocole* : `TCP` + *Plage de ports* : `80 - 443` + *Source :* *(Neptune DB cluster security group ID)* ## Création d'un rôle NeptuneLoadFrom S3 IAM personnalisé Si vous ne l'avez pas encore fait, créez un rôle IAM `NeptuneLoadFromS3` personnalisé, comme expliqué dans [Création d'une politique IAM pour accéder à Amazon S3](bulk-load-tutorial-IAM-CreateRole.md). ## Création d'un NeptuneSageMaker IAMRole rôle personnalisé Utilisez la [console IAM](https://console.aws.amazon.com/iam/) pour créer un `NeptuneSageMakerIAMRole` personnalisé, en utilisant la politique suivante : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "ec2:CreateNetworkInterface", "ec2:CreateNetworkInterfacePermission", "ec2:CreateVpcEndpoint", "ec2:DeleteNetworkInterface", "ec2:DeleteNetworkInterfacePermission", "ec2:DescribeDhcpOptions", "ec2:DescribeNetworkInterfaces", "ec2:DescribeRouteTables", "ec2:DescribeSecurityGroups", "ec2:DescribeSubnets", "ec2:DescribeVpcEndpoints", "ec2:DescribeVpcs" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "ecr:GetAuthorizationToken", "ecr:GetDownloadUrlForLayer", "ecr:BatchGetImage", "ecr:BatchCheckLayerAvailability" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "iam:PassRole" ], "Resource": [ "arn:aws:iam::*:role/*" ], "Condition": { "StringEquals": { "iam:PassedToService": [ "sagemaker.amazonaws.com" ] } }, "Effect": "Allow" }, { "Action": [ "kms:CreateGrant", "kms:Decrypt", "kms:GenerateDataKey*" ], "Resource": "arn:aws:kms:*:*:key/*", "Effect": "Allow" }, { "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents", "logs:DescribeLogGroups", "logs:DescribeLogStreams", "logs:GetLogEvents" ], "Resource": [ "arn:aws:logs:*:*:log-group:/aws/sagemaker/*" ], "Effect": "Allow" }, { "Action": [ "sagemaker:AddTags", "sagemaker:CreateEndpoint", "sagemaker:CreateEndpointConfig", "sagemaker:CreateHyperParameterTuningJob", "sagemaker:CreateModel", "sagemaker:CreateProcessingJob", "sagemaker:CreateTrainingJob", "sagemaker:CreateTransformJob", "sagemaker:DeleteEndpoint", "sagemaker:DeleteEndpointConfig", "sagemaker:DeleteModel", "sagemaker:DescribeEndpoint", "sagemaker:DescribeEndpointConfig", "sagemaker:DescribeHyperParameterTuningJob", "sagemaker:DescribeModel", "sagemaker:DescribeProcessingJob", "sagemaker:DescribeTrainingJob", "sagemaker:DescribeTransformJob", "sagemaker:InvokeEndpoint", "sagemaker:ListTags", "sagemaker:ListTrainingJobsForHyperParameterTuningJob", "sagemaker:StopHyperParameterTuningJob", "sagemaker:StopProcessingJob", "sagemaker:StopTrainingJob", "sagemaker:StopTransformJob", "sagemaker:UpdateEndpoint", "sagemaker:UpdateEndpointWeightsAndCapacities" ], "Resource": [ "arn:aws:sagemaker:*:*:*" ], "Effect": "Allow" }, { "Action": [ "sagemaker:ListEndpointConfigs", "sagemaker:ListEndpoints", "sagemaker:ListHyperParameterTuningJobs", "sagemaker:ListModels", "sagemaker:ListProcessingJobs", "sagemaker:ListTrainingJobs", "sagemaker:ListTransformJobs" ], "Resource": "*", "Effect": "Allow" }, { "Action": [ "s3:GetObject", "s3:PutObject", "s3:DeleteObject", "s3:AbortMultipartUpload", "s3:ListBucket" ], "Resource": [ "arn:aws:s3:::*" ], "Effect": "Allow" } ] } ``` ------ Lors de la création de ce rôle, modifiez la relation d'approbation afin qu'elle se présente comme suit : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "ec2.amazonaws.com", "rds.amazonaws.com", "sagemaker.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ Enfin, copiez l'ARN attribué à ce nouveau rôle `NeptuneSageMakerIAMRole`. **Important** Veillez à ce que les autorisations Amazon S3 figurant dans `NeptuneSageMakerIAMRole` correspondent aux autorisations ci-dessus. L'ARN universel `arn:aws:s3:::*` est utilisé pour la ressource Amazon S3 dans la politique ci-dessus. Si, pour une raison ou une autre, l'ARN universel ne peut pas être utilisé, `arn:aws:s3:::graphlytics*` et l'ARN de toute autre ressource Amazon S3 du client que les commandes NeptuneML utiliseront doivent être ajoutés à la section des ressources. ## Configuration de votre cluster de bases de données de façon à activer Neptune ML **Pour configurer votre cluster de bases de données pour Neptune ML** 1. Dans la [console Neptune](https://console.aws.amazon.com/neptune), accédez à **Groupes de paramètres**, puis au groupe de paramètres du cluster de bases de données associé au cluster de bases de données que vous allez utiliser. Définissez le paramètre `neptune_ml_iam_role` sur l'ARN attribué au rôle `NeptuneSageMakerIAMRole` que vous venez de créer. 1. Accédez à Bases de données, puis sélectionnez le cluster de bases de données que vous utiliserez pour Neptune ML. Sélectionnez **Actions**, puis **Gérer les rôles IAM**. 1. Sur la page **Gérer les rôles IAM**, sélectionnez **Ajouter un rôle** et ajoutez `NeptuneSageMakerIAMRole`. Ajoutez ensuite le rôle `NeptuneLoadFromS3`. 1. Redémarrez l'instance d'enregistreur de votre cluster de bases de données. ## Créez deux points de terminaison SageMaker IA dans votre VPC Neptune Enfin, pour donner au moteur Neptune l'accès à la gestion de l' SageMaker IA nécessaire APIs, vous devez créer deux points de terminaison d' SageMaker IA dans votre VPC Neptune, comme expliqué dans. [Créez deux points de terminaison pour l' SageMaker IA dans votre VPC Neptune](machine-learning-cluster-setup.md#machine-learning-sm-endpoints) # Configuration manuelle d'un bloc-notes Neptune pour Neptune ML Les blocs-notes Neptune SageMaker AI sont préchargés avec une variété d'exemples de blocs-notes pour Neptune ML. Vous pouvez prévisualiser ces exemples dans le référentiel [open source graph-notebook GitHub ](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning). Vous pouvez utiliser l'un des blocs-notes Neptune existants ou, si vous le souhaitez, créer le vôtre en suivant les instructions fournies dans [Utilisation du workbench Neptune pour héberger des blocs-notes Neptune](graph-notebooks.md#graph-notebooks-workbench). Vous pouvez également configurer un bloc-notes Neptune par défaut à utiliser avec Neptune ML en procédant comme suit : **Modification d'un bloc-notes pour Neptune ML** 1. Ouvrez la console Amazon SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. Dans le panneau de navigation de gauche, choisissez **Bloc-notes**, puis **Instances de blocs-notes**. Recherchez le nom du bloc-notes Neptune que vous souhaitez utiliser pour Neptune ML et sélectionnez-le pour accéder à sa page de détails. 1. Si l'instance de bloc-notes est en cours d'exécution, sélectionnez le bouton **Arrêter** en haut à droite de la page de détails du bloc-notes. 1. Dans **Paramètres d'instances de blocs-notes**, sous **Configuration du cycle de vie**, sélectionnez le lien pour ouvrir la page du cycle de vie du bloc-notes. 1. Sélectionnez **Modifier** en haut à droite, puis **Continuer**. 1. Dans l'onglet **Démarrer un bloc-notes**, modifiez le script pour inclure des commandes d'exportation supplémentaires et pour remplir les champs correspondant à votre rôle IAM Neptune ML et à l'URI du service d'exportation, similaires à ce qui suit selon votre shell : ``` echo "export NEPTUNE_ML_ROLE_ARN=(your Neptune ML IAM role ARN)" >> ~/.bashrc echo "export NEPTUNE_EXPORT_API_URI=(your export service URI)" >> ~/.bashrc ``` 1. Tâche de sélection **Update (Mise à jour)**. 1. Revenez à la page d'instance de bloc-notes. Sous **Autorisations et chiffrement**, il existe un champ pour l'**ARN du rôle IAM**. Sélectionnez le lien dans ce champ pour accéder au rôle IAM avec lequel cette instance de bloc-notes sera exécutée. 1. Créez une nouvelle politique en ligne comme celle-ci : ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Action": [ "cloudwatch:PutMetricData" ], "Resource": "arn:aws:cloudwatch:us-east-1:111122223333:*", "Sid": "AllowPutMetrics", "Effect": "Allow" }, { "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:DescribeLogStreams", "logs:PutLogEvents", "logs:GetLogEvents" ], "Resource": "arn:aws:logs:us-east-1:111122223333:*", "Sid": "AllowCreateLogs", "Effect": "Allow" }, { "Action": [ "s3:Put*", "s3:Get*", "s3:List*" ], "Resource": "arn:aws:s3:::*", "Sid": "AllowS3Actions", "Effect": "Allow" }, { "Action": "execute-api:Invoke", "Resource": "arn:aws:execute-api:us-east-1:111122223333:*/*", "Sid": "AllowExecute", "Effect": "Allow" }, { "Action": [ "sagemaker:CreateModel", "sagemaker:CreateEndpointConfig", "sagemaker:CreateEndpoint", "sagemaker:DescribeModel", "sagemaker:DescribeEndpointConfig", "sagemaker:DescribeEndpoint", "sagemaker:DeleteModel", "sagemaker:DeleteEndpointConfig", "sagemaker:DeleteEndpoint" ], "Resource": "arn:aws:sagemaker:us-east-1:111122223333:*/*", "Sid": "AllowApiActions", "Effect": "Allow" }, { "Action": [ "iam:PassRole" ], "Resource": "arn:aws:iam::111122223333:role/role-name", "Sid": "AllowPassRole", "Effect": "Allow" } ] } ``` ------ 1. Enregistrez cette nouvelle politique et attachez-la au rôle IAM à l'étape 8. 1. Sélectionnez **Démarrer** en haut à droite de la page de détails de l'instance de bloc-notes SageMaker AI pour démarrer l'instance de bloc-notes. # Utilisation du AWS CLI pour configurer Neptune ML sur un cluster de bases de données Outre le modèle de CloudFormation démarrage rapide et le AWS Management Console, vous pouvez également configurer Neptune ML à l'aide du. AWS CLI ## Création d'un groupe de paramètres de cluster de bases de données pour votre nouveau cluster Neptune ML Les AWS CLI commandes suivantes créent un nouveau groupe de paramètres de cluster de base de données et le configurent pour qu'il fonctionne avec Neptune ML : **Pour créer et configurer un groupe de paramètres de cluster de bases de données pour Neptune ML** 1. Créez un nouveau groupe de paramètres de cluster de bases de données : ``` aws neptune create-db-cluster-parameter-group \ --db-cluster-parameter-group-name (name of the new DB cluster parameter group) \ --db-parameter-group-family neptune1 --description "(description of your machine learning project)" \ --region (AWS region, such as us-east-1) ``` 1. Créez un paramètre de `neptune_ml_iam_role` cluster de base de données défini sur l'ARN du `SageMakerExcecutionIAMRole` cluster de base de données à utiliser lorsque vous appelez l' SageMaker IA pour créer des tâches et obtenir des prédictions à partir de modèles de machine learning hébergés : ``` aws neptune modify-db-cluster-parameter-group \ --db-cluster-parameter-group-name (name of the new DB cluster parameter group) \ --parameters "ParameterName=neptune_ml_iam_role, \ ParameterValue=ARN of the SageMakerExcecutionIAMRole, \ Description=NeptuneMLRole, \ ApplyMethod=pending-reboot" \ --region (AWS region, such as us-east-1) ``` La définition de ce paramètre permet à Neptune d'accéder à l' SageMaker IA sans que vous ayez à transmettre le rôle à chaque appel. Pour en savoir plus sur la façon de créer le `SageMakerExcecutionIAMRole`, consultez [Création d'un NeptuneSageMaker IAMRole rôle personnalisé](machine-learning-manual-setup.md#ml-manual-setup-sm-role). 1. Enfin, utilisez `describe-db-cluster-parameters` pour vérifier que tous les paramètres du nouveau groupe de paramètres du cluster de bases de données sont définis comme vous le souhaitez : ``` aws neptune describe-db-cluster-parameters \ --db-cluster-parameter-group-name (name of the new DB cluster parameter group) \ --region (AWS region, such as us-east-1) ``` ## Attachement du nouveau groupe de paramètres de cluster de bases de données au cluster de bases de données que vous utiliserez avec Neptune ML Vous pouvez maintenant attacher le nouveau groupe de paramètres de cluster de bases de données que vous venez de créer à un cluster de bases de données existant à l'aide de la commande suivante : ``` aws neptune modify-db-cluster \ --db-cluster-identifier (the name of your existing DB cluster) \ --apply-immediately --db-cluster-parameter-group-name (name of your new DB cluster parameter group) \ --region (AWS region, such as us-east-1) ``` Pour rendre effectifs tous les paramètres, vous pouvez redémarrer le cluster de bases de données : ``` aws neptune reboot-db-instance --db-instance-identifier (name of the primary instance of your DB cluster) \ --profile (name of your AWS profile to use) \ --region (AWS region, such as us-east-1) ``` Ou, si vous créez un nouveau cluster de bases de données à utiliser avec Neptune ML, vous pouvez utiliser la commande suivante pour créer le cluster avec le nouveau groupe de paramètres attaché, puis créer une nouvelle instance principale (d'enregistreur) : ``` cluster-name=(the name of the new DB cluster) aws neptune create-db-cluster --db-cluster-identifier ${cluster-name} --engine graphdb \ --engine-version 1.0.4.1 \ --db-cluster-parameter-group-name (name of your new DB cluster parameter group) \ --db-subnet-group-name (name of the subnet to use) \ --region (AWS region, such as us-east-1) aws neptune create-db-instance --db-cluster-identifier ${cluster-name} --db-instance-identifier ${cluster-name}-i \ --db-instance-class (the instance class to use, such as db.r5.xlarge) --engine graphdb \ --region (AWS region, such as us-east-1) ``` ## Attachez-le `NeptuneSageMakerIAMRole` à votre cluster de base de données afin qu'il puisse accéder aux ressources SageMaker AI et Amazon S3 Enfin, suivez les instructions [Création d'un NeptuneSageMaker IAMRole rôle personnalisé](machine-learning-manual-setup.md#ml-manual-setup-sm-role) pour créer un rôle IAM qui permettra à votre cluster de base de données de communiquer avec SageMaker AI et Amazon S3. Ensuite, utilisez la commande suivante pour attacher le rôle `NeptuneSageMakerIAMRole` que vous avez créé à votre cluster de bases de données : ``` aws neptune add-role-to-db-cluster --db-cluster-identifier ${cluster-name} --role-arn arn:aws:iam::(the ARN number of the role's ARN):role/NeptuneMLRole \ --region (AWS region, such as us-east-1) ``` ## Créez deux points de terminaison pour l' SageMaker IA dans votre VPC Neptune Neptune ML a besoin de deux points de terminaison SageMaker AI dans le VPC de votre cluster de base de données Neptune : + `com.amazonaws.(AWS region, like us-east-1).sagemaker.runtime` + `com.amazonaws.(AWS region, like us-east-1).sagemaker.api` Si vous n'avez pas utilisé le CloudFormation modèle de démarrage rapide, qui les crée automatiquement pour vous, vous pouvez utiliser les AWS CLI commandes suivantes pour les créer : Celle-ci crée le point de terminaison `sagemaker.runtime` : ``` aws ec2 create-vpc-endpoint --vpc-id (the ID of your Neptune DB cluster's VPC) --vpc-endpoint-type Interface --service-name com.amazonaws.(AWS region, like us-east-1).sagemaker.runtime --subnet-ids (the subnet ID or IDs that you want to use) --security-group-ids (the security group for the endpoint network interface, or omit to use the default) --private-dns-enabled ``` Et celle-ci crée le point de terminaison `sagemaker.api` : ``` aws ec2 create-vpc-endpoint --vpc-id (the ID of your Neptune DB cluster's VPC) --vpc-endpoint-type Interface --service-name com.amazonaws.(AWS region, like us-east-1).sagemaker.api --subnet-ids (the subnet ID or IDs that you want to use) --security-group-ids (the security group for the endpoint network interface, or omit to use the default) --private-dns-enabled ``` Vous pouvez également utiliser la [console VPC](https://console.aws.amazon.com/vpc/) pour créer ces points de terminaison. Consultez [Sécuriser les appels de prédiction dans Amazon SageMaker avec AWS PrivateLink](https://aws.amazon.com/blogs/machine-learning/secure-prediction-calls-in-amazon-sagemaker-with-aws-privatelink/) et [Sécuriser tous les appels SageMaker d'API Amazon avec AWS PrivateLink](https://aws.amazon.com/blogs/machine-learning/securing-all-amazon-sagemaker-api-calls-with-aws-privatelink/). ## Créez un paramètre de point de terminaison d'inférence SageMaker AI dans le groupe de paramètres de votre cluster de base de données Pour éviter d'avoir à spécifier le point de terminaison d'inférence SageMaker AI du modèle que vous utilisez dans chaque requête que vous lui envoyez, créez un paramètre de cluster de base de données nommé `neptune_ml_endpoint` dans le groupe de paramètres de cluster de base de données pour Neptune ML. Définissez le paramètre sur l'`id` du point de terminaison de l'instance en question. Pour ce faire, vous pouvez utiliser la AWS CLI commande suivante : ``` aws neptune modify-db-cluster-parameter-group \ --db-cluster-parameter-group-name neptune-ml-demo \ --parameters "ParameterName=neptune_ml_endpoint, \ ParameterValue=(the name of the SageMaker AI inference endpoint you want to query), \ Description=NeptuneMLEndpoint, \ ApplyMethod=pending-reboot" \ --region (AWS region, such as us-east-1) ``` # Vue d'ensemble de la façon d'utiliser la fonctionnalité Neptune ML La fonctionnalité Neptune ML d'Amazon Neptune fournit un flux de travail rationalisé pour tirer parti des modèles d'apprentissage automatique au sein d'une base de données de graphes. Le processus comprend plusieurs étapes clés : exporter les données de Neptune au format CSV, prétraiter les données pour les préparer à l'entraînement du modèle, entraîner le modèle d'apprentissage automatique à l'aide d'Amazon SageMaker AI, créer un point de terminaison d'inférence pour fournir des prédictions, puis interroger le modèle directement à partir des requêtes Gremlin. Le plan de travail Neptune fournit des commandes magiques pratiques en ligne et en cellule pour faciliter la gestion et l'automatisation de ces étapes. En intégrant des fonctionnalités d'apprentissage automatique directement dans la base de données de graphes, Neptune ML permet aux utilisateurs d'obtenir des informations précieuses et de faire des prédictions à l'aide des riches données relationnelles stockées dans le graphe Neptune. ## Flux de travail initial pour l'utilisation de Neptune ML L'utilisation de la fonctionnalité Neptune ML dans Amazon Neptune implique généralement les cinq étapes suivantes de départ : ![\[Schéma du flux de travail Neptune ML\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/neptune-ML-workflow.png) 1. **Exportation et configuration des données** : l'étape d'exportation des données utilise le service d'exportation Neptune ou l'outil de ligne de commande `neptune-export` pour exporter les données de Neptune vers Amazon Simple Storage Service (Amazon S3) au format CSV. Un fichier de configuration nommé `training-data-configuration.json` est automatiquement généré au même moment et il indique comment les données exportées peuvent être chargées dans un graphe pouvant être entraîné. 1. **Prétraitement des données** : dans cette étape, le jeu de données exporté est prétraité à l'aide de techniques standard visant à le préparer pour l'entraînement de modèle. Une normalisation des fonctionnalités peut être effectuée pour les données numériques, et les fonctionnalités de texte peuvent être encodées à l'aide de `word2vec`. À la fin de cette étape, un graphe DGL (bibliothèque Deep Graph) est généré à partir du jeu de données exporté pour l'étape d'entraînement de modèle à utiliser. Cette étape est mise en œuvre à l'aide d'une tâche de traitement par SageMaker IA dans votre compte, et les données qui en résultent sont stockées dans un emplacement Amazon S3 que vous avez spécifié. 1. **Entraînement de modèle** : l'étape d'entraînement de modèle entraîne le modèle de machine learning qui sera utilisé pour les prédictions. L'entraînement de modèle se déroule en deux phases : + La première étape utilise une tâche de traitement par SageMaker IA pour générer un ensemble de configuration de stratégie d'entraînement du modèle qui spécifie le type de modèle et les plages d'hyperparamètres du modèle qui seront utilisés pour l'apprentissage du modèle. + La deuxième étape utilise ensuite une tâche de réglage du modèle SageMaker AI pour tester différentes configurations d'hyperparamètres et sélectionner la tâche de formation qui a produit le modèle le plus performant. La tâche de réglage exécute un nombre prédéfini d'essais de tâches d'entraînement de modèle sur les données traitées. À la fin de cette phase, les paramètres de modèle entraîné de la meilleure tâche d'entraînement sont utilisés pour générer des artefacts de modèle à des fins d'inférence. 1. **Création d'un point de terminaison d'inférence dans Amazon SageMaker AI** — Le point de terminaison d'inférence est une instance de point de terminaison d' SageMaker IA lancée avec les artefacts du modèle produits par le meilleur travail de formation. Chaque modèle est lié à un seul point de terminaison. Ce point de terminaison est capable d'accepter les demandes entrantes provenant de la base de données orientée graphe et de renvoyer les prédictions de modèle pour les entrées dans les demandes. Une fois que vous avez créé le point de terminaison, celui-ci reste actif jusqu'à ce que vous le supprimiez. 1. **Interrogation du modèle de machine learning à l'aide de Gremlin** : vous pouvez utiliser des extensions du langage de requête Gremlin pour effectuer des requêtes de prédictions à partir du point de terminaison d'inférence. **Note** Le [workbench Neptune](graph-notebooks.md#graph-notebooks-workbench) contient une magie linéaire et une magie cellulaire qui peuvent vous faire gagner beaucoup de temps lors de la gestion de ces étapes, à savoir : [%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml) [%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml) # Réalisation de prédictions basées sur l'évolution des données de graphe Dans le cas d'un graphe en constante évolution, vous souhaiterez peut-être créer régulièrement de nouvelles prédictions par lots à l'aide de données actualisées. L'interrogation de prédictions précalculées (inférence transductive) peut être nettement plus rapide que la génération de nouvelles prédictions à la volée basées sur les données les plus récentes (inférence inductive). Les deux approches ont leur place, en fonction de la rapidité avec laquelle vos données évoluent et de vos exigences en matière de performances. ## Différence entre inférence inductive et inférence transductive Dans le cadre de l'inférence transductive, Neptune recherche et renvoie des prédictions qui ont été précalculées au moment de l'entraînement. Dans le cadre de l'inférence inductive, Neptune construit le sous-graphe correspondant et extrait ses propriétés. Le modèle DGL GNN applique ensuite le traitement de données et l'évaluation de modèle en temps réel. L'inférence inductive peut donc générer des prédictions impliquant des nœuds et des arêtes qui n'étaient pas présents au moment de l'entraînement et qui reflètent l'état actuel du graphe. Cela se fait toutefois au prix d'une latence plus élevée. Si votre graphe est dynamique, vous pouvez utiliser l'inférence inductive pour être sûr de prendre en compte les données les plus récentes, mais si votre graphe est statique, l'inférence transductive est plus rapide et plus efficace. L'inférence inductive est désactivée par défaut. Vous pouvez l'activer pour une requête en utilisant le prédicat Gremlin [Neptune\$1ml.inductiveInference](machine-learning-gremlin-inference-query-predicates.md#machine-learning-gremlin-inference-neptune-ml-inductiveInference) dans la requête, comme suit : ``` .with( "Neptune#ml.inductiveInference") ``` # Flux de travail transductifs incrémentiels Lorsque vous mettez à jour les artefacts de modèle en réexécutant simplement les étapes 1 à 3 (de l'**exportation et de la configuration des données** à la **transformation de modèle**), Neptune ML propose des méthodes plus simples pour mettre à jour vos prédictions ML par lots à l'aide de nouvelles données. L'une consiste à utiliser un [flux de travail basé sur un modèle incrémentiel](#machine-learning-overview-incremental) et une autre consiste à utiliser le [réentraînement de modèle avec démarrage à chaud](#machine-learning-overview-model-retraining). ## Flux de travail basé sur un modèle incrémentiel Dans ce flux de travail, vous mettez à jour les prédictions ML sans réentraîner le modèle ML. **Note** Vous pouvez le faire uniquement quand les données de graphe ont été mises à jour avec de nouveaux nœuds et/ou arêtes. Cela ne fonctionne pas actuellement quand des nœuds sont supprimés. 1. **Exportation et configuration des données** : cette étape est identique à celle du flux de travail principal. 1. **Prétraitement des données incrémentielles** : cette étape est similaire à l'étape de prétraitement des données du flux de travail principal, mais utilise la même configuration de traitement que celle utilisée précédemment, qui correspond à un modèle entraîné spécifique. 1. **Transformation de modèle** : à la place d'une étape d'entraînement de modèle, cette étape de transformation de modèle prend le modèle entraîné du flux de travail principal et les résultats de l'étape de prétraitement des données incrémentielles, et génère de nouveaux artefacts de modèle à utiliser pour l'inférence. L'étape de transformation du modèle lance une tâche de traitement par SageMaker IA pour effectuer le calcul qui génère les artefacts du modèle mis à jour. 1. **Mettre à jour le point de terminaison d'inférence Amazon SageMaker AI** — Facultativement, si vous avez un point de terminaison d'inférence existant, cette étape met à jour le point de terminaison avec les nouveaux artefacts du modèle générés par l'étape de transformation du modèle. Vous pouvez également créer un nouveau point de terminaison d'inférence avec les nouveaux artefacts de modèle. ## Réentraînement de modèle avec démarrrage à chaud À l'aide de ce flux de travail, vous pouvez entraîner et déployer un nouveau modèle ML pour effectuer des prédictions à l'aide des données de graphe incrémentielles, mais démarrer à partir d'un modèle existant généré à l'aide du flux de travail principal : 1. **Exportation et configuration des données** : cette étape est identique à celle du flux de travail principal. 1. **Prétraitement des données incrémentielles** : cette étape est identique à celle figurant dans le flux de travail d'inférence du modèle incrémentiel. Les nouvelles données de graphe doivent être traitées avec la même méthode de traitement que celle utilisée précédemment pour l'entraînement de modèle. 1. **Entraînement de modèle avec démarrage à chaud** : l'entraînement de modèle est similaire à ce qui se passe dans le flux de travail principal, mais vous pouvez accélérer la recherche d'hyperparamètres de modèle en exploitant les informations issues de la tâche d'entraînement de modèle précédente. 1. **Mettre à jour le point de terminaison d'inférence Amazon SageMaker AI** : cette étape est identique à celle du flux de travail d'inférence de modèles incrémentiel. # Flux de travail pour les modèles personnalisés dans Neptune ML Neptune ML vous permet d'implémenter, d'entraîner et de déployer vos propres modèles personnalisés pour toutes les tâches prises en charge par Neptune ML. Le flux de travail pour le développement et le déploiement d'un modèle personnalisé est essentiellement le même que pour les modèles intégrés, à quelques différences près, comme expliqué dans [Flux de travail de modèle personnalisé](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow). # Sélection d'instances pour les phases Neptune ML Les différentes étapes du traitement de Neptune ML utilisent différentes instances d' SageMaker IA. Ici, nous expliquons comment choisir le type d'instance approprié pour chaque phase. Vous trouverez des informations sur les types d'instances d' SageMaker IA et leurs tarifs sur [Amazon SageMaker Pricing](https://aws.amazon.com/sagemaker/pricing/). ## Sélection d'une instance pour le traitement des données L'étape de [traitement des données](machine-learning-on-graphs-processing.md) par SageMaker IA nécessite une [instance de traitement](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) disposant de suffisamment de mémoire et de stockage sur disque pour les données d'entrée, intermédiaires et de sortie. La quantité spécifique de mémoire et de stockage sur disque requise dépend des caractéristiques du graphe Neptune ML et de ses fonctionnalités exportées. Par défaut, Neptune ML choisit la plus petite instance `ml.r5` dont la mémoire est dix fois supérieure à la taille des données de graphe exportées sur le disque. ## Sélection d'une instance pour l'entraînement de modèle et la transformation de modèle La sélection du type d'instance approprié pour l'[entraînement de modèle](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) ou la [transformation de modèle](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-batch.html) dépend du type de tâche, de la taille de graphe et de vos exigences en matière de délai d'exécution. Les instances GPU fournissent les meilleures performances. Nous recommandons généralement les instances en série `p3` et `g4dn`. Vous pouvez également utiliser les instances `p2` ou `p4d`. Par défaut, Neptune ML choisit la plus petite instance GPU avec plus de mémoire que ce que nécessitent l'entraînement de modèle et la transformation de modèle. Vous pouvez rechercher cette sélection dans le fichier `train_instance_recommendation.json`, dans l'emplacement de sortie du traitement des données Amazon S3. Voici un exemple du contenu d'un fichier `train_instance_recommendation.json` : ``` { "instance": "(the recommended instance type for model training and transform)", "cpu_instance": "(the recommended instance type for base processing instance)", "disk_size": "(the estimated disk space required)", "mem_size": "(the estimated memory required)" } ``` ## Sélection d'une instance pour un point de terminaison d'inférence La sélection du type d'instance approprié pour un [point de terminaison d'inférence](machine-learning-on-graphs-inference-endpoint.md) dépend du type de tâche, de la taille de graphe et de votre budget. Par défaut, Neptune ML choisit la plus petite instance `ml.m5d` avec plus de mémoire que celle requise par le point de terminaison d'inférence. **Note** Si plus de 384 Go de mémoire sont nécessaires, Neptune ML utilise une instance `ml.r5d.24xlarge`. Vous pouvez voir quel type d'instance Neptune ML recommande dans le fichier `infer_instance_recommendation.json` situé dans l'emplacement Amazon S3 que vous utilisez pour l'entraînement de modèle. Voici un exemple de contenu de ce fichier : ``` { "instance" : "(the recommended instance type for an inference endpoint)", "disk_size" : "(the estimated disk space required)", "mem_size" : "(the estimated memory required)" } ``` # Utilisation de l'outil neptune-export ou du service Neptune-Export pour exporter des données depuis Neptune pour Neptune ML 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 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 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 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 ## L'élément de version dans neptune\$1ml 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 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 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 ### Le champ de nœud (sommet) d'un objet cible É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 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 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 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 (*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 (*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 ### Le champ de nœud dans un objet cible RDF 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, , 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 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 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 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 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 (*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 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). # Exemples d'utilisation de paramètres dans AdditionalParams pour ajuster la configuration d'entraînement des modèles 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 ### Spécification d'un taux de division par défaut pour la configuration d'entraînement de modèle 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 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 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 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 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 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 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 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 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` 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` 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` 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` 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` 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` 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` 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` 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` ### Spécification d'un taux de division par défaut pour la configuration d'entraînement de modèle 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 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 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 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 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" } ] } } ``` # Traitement des données de graphe exportées depuis Neptune pour l'entraînement L'étape de traitement des données prend les données de graphe Neptune créées par le processus d'exportation et crée les informations utilisées par la bibliothèque [Deep Graph Library (DGL)](https://www.dgl.ai/) pendant l'entraînement. Cela inclut la réalisation de divers mappages et transformations de données : + Analyse des nœuds et des arêtes pour créer les fichiers de mappage de graphes et d'identifiants requis par la bibliothèque DGL. + Conversion des propriétés de nœud et d'arête en fonctionnalités de nœud et d'arête requises par la bibliothèque DGL. + Division des données en jeux de données d'entraînement, de validation et de test. ## Gestion de l'étape de traitement des données pour Neptune ML Après avoir exporté les données de Neptune que vous souhaitez utiliser pour l'entraînement de modèle, vous pouvez démarrer une tâche de traitement de données à l'aide d'une commande `curl` (ou `awscurl`) comme la suivante : ``` curl \ -X POST https://(your Neptune endpoint)/ml/dataprocessing \ -H 'Content-Type: application/json' \ -d '{ "inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)", "id" : "(a job ID for the new job)", "processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)", "configFileName" : "training-job-configuration.json" }' ``` Les détails de l'utilisation de cette commande sont expliqués dans [Commande dataprocessing](machine-learning-api-dataprocessing.md), avec d'autres informations sur la façon d'obtenir le statut d'une tâche en cours d'exécution, d'arrêter une tâche en cours d'exécution et de répertorier toutes les tâches en cours d'exécution. ## Traitement de données de graphe mises à jour pour Neptune ML Vous pouvez également fournir un `previousDataProcessingJobId` à l'API pour vous assurer que la nouvelle tâche de traitement de données utilise la même méthode de traitement qu'une tâche précédente. Cela est nécessaire lorsque vous souhaitez obtenir des prédictions pour des données de graphe mises à jour dans Neptune, soit en réentraînant l'ancien modèle sur les nouvelles données, soit en recalculant les artefacts de modèle sur les nouvelles données. Pour ce faire, utilisez une commande `curl` (ou `awscurl`) comme celle-ci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/dataprocessing \ -H 'Content-Type: application/json' \ -d '{ "inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)", "id" : "(a job ID for the new job)", "processedDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your output folder)", "previousDataProcessingJobId", "(the job ID of the previous data-processing job)"}' ``` Définissez la valeur du paramètre `previousDataProcessingJobId` sur l'ID de tâche de la tâche de traitement de données précédente qui correspond au modèle entraîné. **Note** La suppression de nœud dans le graphe mis à jour n'est actuellement pas prise en charge. Si des nœuds ont été supprimés dans un graphe mis à jour, vous devez démarrer une toute nouvelle tâche de traitement de données plutôt qu'utiliser `previousDataProcessingJobId`. # Encodage des fonctionnalités dans Neptune ML Les valeurs des propriétés 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, en utilisant les techniques d'encodage des fonctionnalités décrites ici. **Note** Si vous envisagez d'implémenter votre propre encodage de fonctionnalités dans une implémentation de modèle personnalisé, vous pouvez désactiver l'encodage automatique des fonctionnalités au cours de la phase de prétraitement des données en sélectionnant `none` comme type d'encodage des fonctionnalités. Aucun encodage des fonctionnalités n'est alors effectué sur ce nœud ou cette propriété d'arête, et les valeurs de propriété brutes sont analysées et enregistrées dans un dictionnaire. Le prétraitement des données crée toujours le graphe DGL à partir du jeu de données exporté, mais le graphe DGL construit ne possède pas les fonctionnalités prétraitées nécessaires à l'entraînement. Vous ne devez utiliser cette option que si vous envisagez d'effectuer l'encodage des fonctionnalités personnalisées dans le cadre de l'entraînement de modèle personnalisé. Consultez [Modèles personnalisés dans Neptune ML](machine-learning-custom-models.md) pour plus de détails. ## Fonctionnalités catégorielles dans Neptune ML Une propriété qui peut prendre une ou plusieurs valeurs distinctes à partir d'une liste fixe de valeurs possibles est une fonctionnalité catégorielle. Dans Neptune ML, les fonctionnalités catégorielles sont encodées à l'aide d'un [encodage 1 parmi n](https://en.wikipedia.org/wiki/One-hot). L'exemple suivant montre comment le nom de propriété de différents aliments est encodé par encodage 1 parmi n en fonction de sa catégorie : ``` Food Veg. Meat Fruit Encoding --------- ---- ---- ----- -------- Apple 0 0 1 001 Chicken 0 1 0 010 Broccoli 1 0 0 100 ``` **Note** Le nombre maximal de catégories par fonctionnalité catégorielle est de 100. Si une propriété comporte plus de 100 catégories de valeur, seules les 99 catégories les plus courantes sont placées dans des catégories distinctes, les autres étant placées dans une catégorie spéciale nommée `OTHER`. ## Fonctionnalités numériques dans Neptune ML Toute propriété dont les valeurs sont des nombres réels peut être encodée en tant que fonctionnalité numérique dans Neptune ML. Les fonctionnalités numériques sont encodées à l'aide de nombres à virgule flottante. Vous pouvez spécifier une méthode de normalisation des données à utiliser lors de l'encodage de fonctionnalités numériques, comme ceci : `"norm": "normalization technique"`. Les techniques de normalisation suivantes sont prises en charge : + **« aucune »** : ne normalisez pas les valeurs numériques pendant l'encodage. + **« 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. ## Fonctionnalités numériques de compartiment dans Neptune ML Plutôt que de représenter une propriété numérique à l'aide de nombres bruts, vous pouvez condenser les valeurs numériques en catégories. Par exemple, vous pouvez diviser l'âge des personnes en catégories telles que les enfants (0 à 20), les jeunes adultes (20 à 40), les personnes d'âge moyen (40 à 60) et les personnes âgées (à partir de 60). En utilisant ces compartiments numériques, vous transformeriez une propriété numérique en une sorte de fonctionnalité catégorielle. Dans Neptune ML, vous pouvez faire en sorte qu'une propriété numérique soit encodée sous la forme d'une fonctionnalité numérique de compartiment. Pour cela, vous devez fournir deux éléments : + Une plage numérique sous la forme ` "range": [a, b] `, où `a` et `b` sont des entiers. + Nombre de compartiments, sous la forme ` "bucket_cnt": c `, où `c` est le nombre de compartiments, également un entier. Neptune ML calcule alors la taille de chaque compartiment sous la forme ` ( b - a ) / c `, et encode chaque valeur numérique en tant que numéro du compartiment dans lequel il se trouve. Toute valeur inférieure à `a` est considérée comme appartenant au premier compartiment, et toute valeur supérieure à `b` est considérée comme appartenant au dernier compartiment. En option, vous pouvez également placer les valeurs numériques dans plusieurs compartiments, en spécifiant une taille de fenêtre coulissante, comme ceci : ` "slide_window_size": s `, où `s` est un nombre. Neptune ML transforme ensuite chaque valeur numérique `v` de la propriété en une plage allant de ` v - s/2 ` à ` v + s/2 `, et affecte la valeur `v` à chaque compartiment couvert par la plage. Enfin, vous pouvez également éventuellement fournir un moyen de renseigner les valeurs manquantes pour les fonctionnalités numériques et les fonctionnalités numériques de compartiment. Pour ce faire, utilisez ` "imputer": "imputation technique "`, où la technique d'imputation est l'une des suivantes : `"mean"`, `"median"` ou `"most-frequent"`. Si vous ne spécifiez aucun paramètre imputer, une valeur manquante peut entraîner l'arrêt du traitement. ## Encodage des fonctionnalités de texte dans Neptune ML Pour le texte de forme libre, Neptune ML peut utiliser plusieurs modèles différents pour convertir la séquence de jetons d'une chaîne de valeur de propriété en un vecteur de valeur réelle de taille fixe : + [`text_fasttext`](#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-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-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-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. ### Encodage *fastText* des valeurs de propriété de texte dans Neptune ML Neptune ML peut utiliser les modèles [fastText](https://fasttext.cc/) pour convertir les valeurs de propriété de texte en vecteurs de valeurs réelles de taille fixe. Il s'agit de la méthode d'encodage recommandée pour les valeurs de propriété de texte dans l'une des cinq langues prises en charge par fastText : + `en`   (anglais) + `zh`   (chinois) + `hi`   (hindi) + `es`   (espagnol) + `fr`   (français) Notez que fastText ne peut pas traiter les phrases contenant des mots dans plusieurs langues. La méthode `text_fasttext` peut éventuellement utiliser le champ `max_length` qui spécifie le nombre maximal de jetons dans une valeur de propriété de texte qui seront encodés, après quoi la chaîne est tronquée. Cela peut améliorer les performances lorsque les valeurs de propriété de texte contiennent de longues chaînes, car si `max_length` n'est pas spécifié, fastText encode tous les jetons, quelle que soit la longueur de la chaîne. Cet exemple indique que les titres de films en français sont encodés à l'aide de fastText : ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_fasttext"], "language": "fr", "max_length": 1024 } ] } ``` ### Encodage Sentence BERT (SBERT) des fonctionnalités de texte dans Neptune ML Neptune ML peut 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 à 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 : `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 réside dans la longueur maximale d'une chaîne de valeur de propriété de texte qui est encodée. L'encodage `text_sbert128` tronque les chaînes de texte après l'encodage de 128 jetons, tandis que `text_sbert512` tronque les chaînes de texte après l'encodage de 512 jetons. Par conséquent, `text_sbert512` nécessite plus de temps de traitement que `text_sbert128`. Les deux méthodes sont plus lentes que `text_fasttext`. L'encodage SBERT étant multilingue, il n'est pas nécessaire de spécifier une langue pour le texte de la valeur de propriété que vous encodez. SBERT prend en charge de nombreuses langues et peut encoder une phrase contenant plusieurs langues. Si vous encodez des valeurs de propriété contenant du texte dans une ou plusieurs langues que fastText ne prend pas en charge, SBERT est la méthode d'encodage recommandée. L'exemple suivant indique que les titres de films sont encodés au format SBERT jusqu'à un maximum de 128 jetons : ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_sbert128"] } ] } ``` ### Encodage Word2Vec des fonctionnalités textuelles dans Neptune ML Neptune ML peut encoder les valeurs de propriété de chaîne en tant que fonctionnalité Word2Vec (les [algorithmes Word2Vec](https://wikipedia.org/wiki/Word2vec) ont été initialement publiés par [Google](https://code.google.com/archive/p/word2vec/)). La méthode `text_word2vec` encode les jetons d'une chaîne sous forme de vecteur dense à l'aide d'un des [modèles entraînés par spaCy](https://spacy.io/models). Elle prend en charge uniquement la langue anglaise à l'aide du modèle [en\$1core\$1web\$1lg](https://spacy.io/models/en#en_core_web_lg). L'exemple suivant indique que les titres des films sont encodés à l'aide de Word2Vec : ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_word2vec"], "language": "en_core_web_lg" } ] } ``` Notez que le champ de langue est facultatif, car le modèle `en_core_web_lg` anglais est le seul pris en charge par Neptune. ### Encodage TF-IDF des fonctionnalités de texte dans Neptune ML Neptune ML peut encoder les valeurs de propriété de texte sous forme de fonctionnalités `text_tfidf`. Cet encodage convertit la séquence de mots du texte en un vecteur numérique à 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), suivi d'une opération de réduction de dimensionnalité. La [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) (de fréquence de terme et de fréquence de document inverse) est une valeur numérique destinée à mesurer l'importance d'un mot dans un ensemble de documents. Elle est calculée en divisant le nombre de fois qu'un mot apparaît dans une valeur de propriété donnée par le nombre total de valeurs de propriété dans lesquelles il apparaît. Par exemple, si le mot « kiss » apparaît deux fois dans un titre de film donné (par exemple, « kiss kiss bang bang ») et que « kiss » apparaît dans les titres de 4 films en tout, alors la valeur TF-IDF de « kiss » dans le titre « kiss kiss bang bang » est de ` 2 / 4 `. Le vecteur initialement créé possède ***d*** dimensions, où ***d*** est le nombre de termes uniques dans toutes les valeurs de propriété de ce type. L'opération de réduction de dimensionnalité utilise une projection fragmentée aléatoire pour réduire ce nombre à un maximum de 100. Le vocabulaire d'un graphe est ensuite généré en fusionnant toutes les fonctionnalités `text_tfidf` qu'il contient. Vous pouvez contrôler le vectoriseur TF-IDF de plusieurs manières : + **`max_features`** : le paramètre `max_features` vous permet de limiter le nombre de termes figurant dans les fonctionnalités `text_tfidf` aux termes les plus courants. Par exemple, si vous définissez `max_features` sur 100, seuls les 100 termes les plus couramment utilisés sont inclus. Si vous ne la définissez pas explicitement, la valeur par défaut de `max_features` est 5 000. + **`min_df`** : le paramètre `min_df` vous permet de limiter le nombre de termes figurant dans les fonctionnalités `text_tfidf` à ceux ayant au moins une fréquence de document spécifiée. Par exemple, si vous définissez `min_df` sur 5, seuls les termes qui apparaissent dans au moins 5 valeurs de propriété différentes sont utilisés. Si vous ne la définissez pas explicitement, la valeur par défaut de `min_df` est 2. + **`ngram_range`** : le paramètre `ngram_range` détermine quelles combinaisons de mots sont traitées comme des termes. Par exemple, si vous définissez `ngram_range` sur `[2, 4]`, les 6 termes suivants sont trouvés dans le titre « kiss kiss bang bang » : + *Termes de 2 mots* : « kiss kiss », « kiss bang » et « bang bang ». + *Termes de 3 mots* : « kiss kiss bang » et « kiss bang bang ». + *Termes de 4 mots* : « kiss kiss bang bang ». Le paramètre par défaut pour `ngram_range` est `[1, 1]`. ## Fonctionnalités datetime dans Neptune ML Neptune ML peut convertir des parties de valeurs de propriété `datetime` en fonctionnalités catégorielles en les encodant sous forme de [tableaux d'encodage 1 parmi n](https://en.wikipedia.org/wiki/One-hot). Utilisez le paramètre `datetime_parts` pour spécifier une ou plusieurs des parties suivantes à encoder : `["year", "month", "weekday", "hour"]`. Si vous ne définissez pas `datetime_parts`, les quatre parties sont encodées par défaut. Par exemple, si la plage de valeurs datetime couvre les années 2010 à 2012, les quatre parties de l'entrée datetime `2011-04-22 01:16:34` sont les suivantes : + **year** : `[0, 1, 0]`. Comme seulement 3 années sont couvertes (2010, 2011 et 2012), le tableau d'encodage 1 parmi n comporte trois entrées, une pour chaque année. + **month** : `[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]`. Ici, le tableau d'encodage 1 parmi n comporte une entrée pour chaque mois de l'année. + **weekday** : `[0, 0, 0, 0, 1, 0, 0]`. La norme ISO 8601 stipule que le lundi est le premier jour de la semaine, et comme le 22 avril 2011 était un vendredi, le tableau d'encodage 1 parmi n des jours de la semaine comporte un 1 en cinquième position. + **hour** : `[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]`. L'heure 1 h du matin est définie dans un tableau d'encodage 1 parmi n à 24 membres. Le jour du mois, la minute et la seconde ne sont pas encodés de manière catégorielle. Si la plage `datetime` totale en question inclut uniquement des dates d'une même année, aucun tableau `year` n'est encodé. Vous pouvez définir une stratégie d'imputation pour compléter les valeurs `datetime` manquantes, à l'aide du paramètre `imputer` et de l'une des stratégies disponibles pour les fonctionnalités numériques. ## Encodage automatique des fonctionnalités dans Neptune ML Au lieu de spécifier manuellement les méthodes d'encodage de fonctionnalité à utiliser pour les propriétés figurant dans votre graphe, vous pouvez définir `auto` en tant que méthode d'encodage de fonctionnalité. Neptune ML tente alors de déduire le meilleur encodage de fonctionnalité pour chaque propriété en fonction de son type de données sous-jacent. Voici quelques-unes des heuristiques utilisées par Neptune ML pour sélectionner les encodages de fonctionnalité appropriés : + Si la propriété comporte uniquement des valeurs numériques et peut être convertie en types de données numériques, Neptune ML l'encode généralement sous forme de valeur numérique. Toutefois, si le nombre de valeurs uniques pour la propriété est inférieur à 10 % du nombre total de valeurs et que la cardinalité de ces valeurs uniques est inférieure à 100, Neptune ML utilise un encodage catégoriel. + Si les valeurs de propriété peuvent être converties en un type `datetime`, Neptune ML les encode en tant que fonctionnalité `datetime`. + Si les valeurs de propriété peuvent être converties de manière forcée en booléens (1/0 ou True/False), Neptune ML utilise un encodage de catégorie. + Si la propriété est une chaîne dont plus de 10 % de ses valeurs sont uniques et que le nombre moyen de jetons par valeur est supérieur ou égal à 3, Neptune ML en déduit que le type de propriété est texte et détecte automatiquement la langue utilisée. Si la langue détectée est l'une de celles prises en charge par [fastText](#machine-learning-fasttext-features), à savoir l'anglais, le chinois, l'hindi, l'espagnol ou le français, Neptune ML utilise `text_fasttext` pour encoder le texte. Dans le cas contraire, Neptune ML utilise [`text_sbert`](#machine-learning-sbert-features). + Si la propriété est une chaîne non classée en tant que fonctionnalité de texte, Neptune ML suppose qu'il s'agit d'une fonctionnalité catégorielle et utilise un encodage de catégorie. + Si chaque nœud possède sa propre valeur unique pour une propriété qui est déduite comme étant une fonctionnalité de catégorie, Neptune ML supprime la propriété du graphe d'entraînement car il s'agit probablement d'un identifiant sans valeur informative pour l'apprentissage. + Si la propriété est connue pour contenir des séparateurs Neptune valides tels que des points-virgules (« ; »), Neptune ML peut uniquement traiter la propriété en tant que `MultiNumerical` ou `MultiCategorical`. + Neptune ML essaie d'abord d'encoder les valeurs sous forme de fonctionnalités numériques. En cas de succès, Neptune ML utilise l'encodage numérique pour créer des fonctionnalités vectorielles numériques. + Dans le cas contraire, Neptune ML les encode en tant que valeurs multi-catégorielles. + Si Neptune ML ne peut pas déduire le type de données des valeurs d'une propriété, Neptune est la propriété à partir MLdrops du graphe d'apprentissage. # Modification d'un fichier de configuration de données d'entraînement Le processus d'exportation Neptune exporte les données Neptune ML à partir d'un cluster de bases de données Neptune vers un compartiment S3. Il exporte les nœuds et les arêtes séparément dans un dossier `nodes/` et un dossier `edges/`. Il crée également un fichier de configuration de données d'entraînement JSON, nommé `training-data-configuration.json` par défaut. Ce fichier contient des informations sur le schéma du graphe, les types de ses fonctionnalités, les opérations de transformation et de normalisation de fonctionnalités, ainsi que la fonctionnalité cible pour une tâche de classification ou de régression. Il peut arriver que vous souhaitiez modifier directement le fichier de configuration. C'est notamment le cas lorsque vous souhaitez modifier la façon dont les fonctionnalités sont traitées ou la façon dont le graphe est construit, sans avoir à réexécuter l'exportation chaque fois que vous souhaitez modifier la spécification de la tâche de machine learning que vous êtes en train de résoudre. **Pour modifier le fichier de configuration de données d'entraînement** 1. **Téléchargez le fichier sur votre ordinateur local.** À moins que vous n'ayez spécifié une ou plusieurs tâches nommées dans le paramètre `additionalParams/neptune_ml` transmis au processus d'exportation, le fichier portera le nom par défaut, qui est `training-data-configuration.json`. Vous pouvez utiliser une commande AWS CLI comme celle-ci pour télécharger le fichier : ``` aws s3 cp \ s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json \ ./ ``` 1. **Modifiez le fichier à l'aide d'un éditeur de texte.** 1. **Chargez le fichier modifié.** Chargez le fichier modifié au même emplacement dans Amazon S3 à partir duquel vous l'avez téléchargé, à l'aide d'une commande AWS CLI comme celle-ci : ``` aws s3 cp \ training-data-configuration.json \ s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json ``` # Exemple de fichier de configuration de données d'entraînement JSON Voici un exemple de fichier de configuration des données d'entraînement qui décrit un graphe pour une tâche de classification de nœud : ``` { "version" : "v2.0", "query_engine" : "gremlin", "graph" : [ { "edges" : [ { "file_name" : "edges/(movie)-included_in-(genre).csv", "separator" : ",", "source" : ["~from", "movie"], "relation" : ["", "included_in"], "dest" : [ "~to", "genre" ] }, { "file_name" : "edges/(user)-rated-(movie).csv", "separator" : ",", "source" : ["~from", "movie"], "relation" : ["rating", "prefixname"], # [prefixname#value] "dest" : ["~to", "genre"], "features" : [ { "feature" : ["rating", "rating", "numerical"], "norm" : "min-max" } ] } ], "nodes" : [ { "file_name" : "nodes/genre.csv", "separator" : ",", "node" : ["~id", "genre"], "features" : [ { "feature": ["name", "genre", "category"], "separator": ";" } ] }, { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "word2vec"], "language": ["en_core_web_lg"] } ] }, { "file_name" : "nodes/user.csv", "separator" : ",", "node" : ["~id", "user"], "features" : [ { "feature": ["age", "age", "numerical"], "norm" : "min-max", "imputation": "median", }, { "feature": ["occupation", "occupation", "category"], } ], "labels" : [ { "label": ["gender", "classification"], "split_rate" : [0.8, 0.2, 0.0] } ] } ] }, "warnings" : [ ] ] } ``` # Structure des fichiers de configuration des données d'entraînement JSON Le fichier de configuration d'entraînement fait référence aux fichiers CSV enregistrés par le processus d'exportation dans les dossiers `nodes/` et `edges/`. Chaque fichier situé sous `nodes/` stocke des informations sur les nœuds qui ont la même étiquette de nœud de graphe de propriétés. Chaque colonne d'un fichier de nœud stocke soit l'ID de nœud, soit la propriété de nœud. La première ligne du fichier contient un en-tête qui spécifie l'élément `~id` ou le nom de propriété pour chaque colonne. Chaque fichier situé sous `edges/` stocke des informations sur les nœuds dotés de la même étiquette d'arête de graphe de propriétés. Chaque colonne d'un fichier de nœud stocke l'ID de nœud source, l'ID de nœud de destination ou la propriété d'arête. La première ligne du fichier contient un en-tête qui spécifie l'élément `~from`, l'élément `~to` ou le nom de propriété pour chaque colonne. Le fichier de configuration de données d'entraînement comporte trois éléments de niveau supérieur : ``` { "version" : "v2.0", "query_engine" : "gremlin", "graph" : [ ... ] } ``` + `version` : (string) version utilisée du fichier de configuration. + `query_engine`  (string) langage de requête utilisé pour l'exportation des données de graphe. Pour le moment, seul « gremlin » est valide. + `graph` : (tableau JSON) répertorie un ou plusieurs objets de configuration contenant les paramètres de modèle pour chacun des nœuds et des arêtes qui seront utilisés. Les objets de configuration du tableau de graphe ont la structure décrite dans la section suivante. ## Contenu d'un objet de configuration répertorié dans le tableau `graph` Un objet de configuration figurant dans le tableau `graph` peut contenir trois nœuds de niveau supérieur : ``` { "edges" : [ ... ], "nodes" : [ ... ], "warnings" : [ ... ], } ``` + `edges` : (tableau d'objets JSON) chaque objet JSON spécifie un ensemble de paramètres pour définir la manière dont une arête du graphe sera traitée pendant le traitement et l'entraînement de modèle. Ceci n'est utilisé qu'avec le moteur Gremlin. + `nodes` : (tableau d'objets JSON) chaque objet JSON spécifie un ensemble de paramètres pour définir la manière dont un nœud du graphe sera traité pendant le traitement et l'entraînement de modèle. Ceci n'est utilisé qu'avec le moteur Gremlin. + `warnings` : (tableau d'objets JSON) chaque objet contient un avertissement généré pendant le processus d'exportation de données. ## Contenu d'un objet de configuration d'arête répertorié dans un tableau `edges` Un objet de configuration d'arête répertorié dans un tableau `edges` peut contenir les champs de niveau supérieur suivants : ``` { "file_name" : "(path to a CSV file)", "separator" : "(separator character)", "source" : ["(column label for starting node ID)", "(starting node type)"], "relation" : ["(column label for the relationship name)", "(the prefix name for the relationship name)"], "dest" : ["(column label for ending node ID)", "(ending node type)"], "features" : [(array of feature objects)], "labels" : [(array of label objects)] } ``` + **`file_name`** : chaîne spécifiant le chemin d'un fichier CSV qui stocke des informations sur les arêtes ayant la même étiquette de graphe de propriétés. La première ligne de ce fichier contient une ligne d'en-tête d'étiquettes de colonne. Les deux premières étiquettes de colonne sont `~from` et `~to`. La première colonne (la colonne `~from`) stocke l'ID du nœud de départ de l'arête, et la seconde (la colonne `~to`) stocke l'ID du nœud de fin de l'arête. Les étiquettes de colonne restantes dans la ligne d'en-tête spécifient, pour chaque colonne restante, le nom de la propriété d'arête dont les valeurs ont été exportées dans cette colonne. + **`separator`** : chaîne contenant le délimiteur qui sépare les colonnes dans ce fichier CSV. + **`source`** : tableau JSON contenant deux chaînes qui spécifient le nœud de départ de l'arête. La première chaîne contient le nom d'en-tête de la colonne dans laquelle l'ID de nœud de départ est stocké. La deuxième chaîne spécifie le type de nœud. + **`relation`** : tableau JSON contenant deux chaînes qui spécifient le type de relation de l'arête. La première chaîne contient le nom d'en-tête de la colonne dans laquelle le nom de relation (`relname`) est stocké. La deuxième chaîne contient le préfixe du nom de relation (`prefixname`). Le type de relation complet se compose des deux chaînes combinées, avec un trait d'union entre elles, comme ceci : `prefixname-relname`. Si la première chaîne est vide, toutes les arêtes ont le même type de relation, à savoir la chaîne `prefixname`. + **`dest`** : tableau JSON contenant deux chaînes qui spécifient le nœud de fin de l'arête. La première chaîne contient le nom d'en-tête de la colonne dans laquelle l'ID de nœud est stocké. La deuxième chaîne spécifie le type de nœud. + **`features`** : tableau JSON d'objets de fonctionnalité à valeur de propriété. Chaque objet de fonctionnalité à valeur de propriété contient les champs suivants : + **feature** : tableau JSON de trois chaînes. La première chaîne contient le nom d'en-tête de la colonne qui contient la valeur de propriété. La deuxième chaîne contient le nom de la fonctionnalité. La troisième chaîne contient le type de fonctionnalité. + **norm** : (*facultatif*) spécifie une méthode de normalisation à appliquer aux valeurs de propriété. + **`labels`** : tableau JSON d'objets. Chacun des objets définit une fonctionnalité cible des arêtes et spécifie les proportions des arêtes que doivent prendre les phases d'entraînement et de validation. Chaque objet contient les champs suivants : + **label** : tableau JSON de deux chaînes. La première chaîne contient le nom d'en-tête de la colonne qui contient la valeur de propriété de la fonctionnalité cible. La deuxième chaîne spécifie l'un des types de tâches cibles suivants : + `"classification"` : tâche de classification d'arête. Les valeurs de propriété fournies dans la colonne identifiée par la première chaîne du tableau `label` sont traitées comme des valeurs catégorielles. Pour une tâche de classification d'arête, la première chaîne du tableau `label` ne peut pas être vide. + `"regression"` : tâche de régression d'arête. Les valeurs de propriété fournies dans la colonne identifiée par la première chaîne du tableau `label` sont traitées comme des valeurs numériques. Pour une tâche de régression d'arête, la première chaîne du tableau `label` ne peut pas être vide. + `"link_prediction"` : tâche de prédiction de lien. Aucune valeur de propriété n'est requise. Pour une tâche de prédiction de lien, la première chaîne du tableau `label` est ignorée. + **`split_rate`** : tableau JSON contenant trois nombres compris entre zéro et un dont la somme est égale à un et qui représentent une estimation des proportions de nœuds que les phases d'entraînement, de validation et de test utiliseront, respectivement. Ce champ ou l'élément `custom_split_filenames` peut être défini, mais pas les deux. Consultez [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate). + **`custom_split_filenames`** : objet JSON qui spécifie les noms des fichiers qui définissent les populations d'entraînement, de validation et de test. Ce champ ou l'élément `split_rate` peut être défini, mais pas les deux. Pour plus d’informations, consultez [train-validation-testProportions personnalisées](#machine-learning-custom-stages-splits). ## Contenu d'un objet de configuration de nœud répertorié dans un tableau `nodes` Un objet de configuration de nœud répertorié dans un tableau `nodes` peut contenir les champs suivants : ``` { "file_name" : "(path to a CSV file)", "separator" : "(separator character)", "node" : ["(column label for the node ID)", "(node type)"], "features" : [(feature array)], "labels" : [(label array)], } ``` + **`file_name`** : chaîne spécifiant le chemin d'un fichier CSV qui stocke des informations sur les nœuds ayant la même étiquette de graphe de propriétés. La première ligne de ce fichier contient une ligne d'en-tête d'étiquettes de colonne. La première étiquette de colonne est `~id` et la première colonne (la colonne `~id`) stocke l'ID de nœud. Les étiquettes de colonne restantes dans la ligne d'en-tête spécifient, pour chaque colonne restante, le nom de la propriété de nœud dont les valeurs ont été exportées dans cette colonne. + **`separator`** : chaîne contenant le délimiteur qui sépare les colonnes dans ce fichier CSV. + **`node`** : tableau JSON contenant deux chaînes. La première chaîne contient le nom d'en-tête de la colonne qui stocke le nœud IDs. La deuxième chaîne spécifie le type de nœud dans le graphe, qui correspond à une étiquette de graphe de propriétés du nœud. + **`features`** : tableau JSON d'objets de fonctionnalité de nœud. Consultez [Contenu d'un objet de fonctionnalité répertorié dans un tableau `features` pour un nœud ou une arête](#machine-learning-graph-node-features-config). + **`labels`** : tableau JSON d'objets d'étiquette de nœud. Consultez [Contenu d'un objet d'étiquette de nœud répertorié dans un tableau `labels` de nœud](#machine-learning-graph-node-labels-config). ## Contenu d'un objet de fonctionnalité répertorié dans un tableau `features` pour un nœud ou une arête Un objet de fonctionnalité de nœud répertorié dans un tableau `features` de nœud peut contenir les champs supérieurs suivants : + **`feature`** : tableau JSON de trois chaînes. La première chaîne contient le nom d'en-tête de la colonne qui contient la valeur de propriété de la fonctionnalité. La deuxième chaîne contient le nom de la fonctionnalité. La troisième chaîne contient le type de fonctionnalité. Les types de fonctionnalité valides sont répertoriés dans [Valeurs possibles du champ de type pour les entités](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-feature-types). + **`norm`** : ce champ est obligatoire pour les fonctionnalités numériques. Il spécifie une méthode de normalisation à utiliser sur les valeurs numériques. Les valeurs valides sont `"none"`, `"min-max"` et « standard ». Consultez [Le champ des normes](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-norm) pour plus de détails. + **`language`** : 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) Toutefois, `text_fasttext` ne peut pas gérer plus d'une langue à la fois. + 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 [`tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features), ce champ n'est pas utilisé. + **`max_length`** : ce champ est facultatif pour les fonctionnalités [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), où il indique le nombre maximal de jetons d'une fonctionnalité de teste d'entrée qui seront encodés. Le texte d'entrée une fois la longueur `max_length` atteinte est ignoré. 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 sont ignorés. + **`separator`** : 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. Consultez [Le champ du séparateur](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-separator). + **`range`** : ce champ est obligatoire pour les fonctionnalités `bucket_numerical`. Il indique la plage de valeurs numériques qui doit être divisée en compartiments. Consultez [Le champ de portée](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-range). + **`bucket_cnt`** : 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. Consultez [Fonctionnalités numériques de compartiment dans Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). + **`slide_window_size`** : ce champ est utilisé en option avec les fonctionnalités `bucket_numerical` pour attribuer des valeurs à plusieurs compartiments. Consultez [Le champ slide\$1window\$1size](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-slide_window_size). + **`imputer`** : ce champ est utilisé en option avec les fonctionnalités `numerical`, `bucket_numerical` et `datetime` pour fournir une technique d'imputation permettant de renseigner les valeurs manquantes. Les techniques d'imputation prises en charge sont `"mean"`, `"median"` et `"most_frequent"`. Consultez [Le champ de l'imputeur](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-imputer). + **`max_features`** : ce champ est utilisé en option par les fonctionnalités `text_tfidf` pour spécifier le nombre maximal de termes à encoder. Consultez [Le champ max\$1features](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-max_features). + **`min_df`** : ce champ est utilisé en option par les fonctionnalités `text_tfidf` pour spécifier la fréquence minimale de document des termes à encoder. Consultez [Le champ min\$1df](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-min_df). + **`ngram_range`** : ce champ est utilisé en option par les fonctionnalités `text_tfidf` pour spécifier une plage de nombres de mots ou de jetons à considérer comme des termes individuels potentiels à encoder. Consultez [Le champ ngram\$1range](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-ngram_range). + **`datetime_parts`** : 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. Consultez [Le champ datetime\$1parts](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-datetime_parts). ## Contenu d'un objet d'étiquette de nœud répertorié dans un tableau `labels` de nœud Un objet d'étiquette répertorié dans un tableau `labels` de nœud définit une fonctionnalité cible de nœud et spécifie les proportions de nœuds que les phases d'entraînement, de validation et de test utiliseront. Chaque objet peut contenir les champs suivants : ``` { "label" : ["(column label for the target feature property value)", "(task type)"], "split_rate" : [(training proportion), (validation proportion), (test proportion)], "custom_split_filenames" : {"train": "(training file name)", "valid": "(validation file name)", "test": "(test file name)"}, "separator" : "(separator character for node-classification category values)", } ``` + **`label`** : tableau JSON contenant deux chaînes. La première chaîne contient le nom d'en-tête de la colonne qui stocke les valeurs de propriété de la fonctionnalité. La deuxième chaîne indique le type de tâche cible, qui peut être : + `"classification"` : une tâche de classification de nœud. Les valeurs de propriété de la colonne spécifiée sont utilisées pour créer une fonctionnalité catégorielle. + `"regression"` : une tâche de régression de nœud. Les valeurs de propriété de la colonne spécifiée sont utilisées pour créer une fonctionnalité numérique. + **`split_rate`** : tableau JSON contenant trois nombres compris entre zéro et un dont la somme est égale à un et qui représentent une estimation des proportions de nœuds que les phases d'entraînement, de validation et de test utiliseront, respectivement. Consultez [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate). + **`custom_split_filenames`** : objet JSON qui spécifie les noms des fichiers qui définissent les populations d'entraînement, de validation et de test. Ce champ ou l'élément `split_rate` peut être défini, mais pas les deux. Pour plus d’informations, consultez [train-validation-testProportions personnalisées](#machine-learning-custom-stages-splits). + **`separator`** : chaîne contenant le délimiteur qui sépare les valeurs des fonctionnalités catégorielles pour une tâche de classification. **Note** Si aucun objet d'étiquette n'est fourni à la fois pour les arêtes et les nœuds, il est automatiquement supposé que la tâche est une prédiction de lien et les arêtes sont réparties de façon aléatoire à 90 % pour l'entraînement et à 10 % pour la validation. ## train-validation-testProportions personnalisées Par défaut, le paramètre `split_rate` est utilisé par Neptune ML pour diviser le graphe de manière aléatoire en populations d'entraînement, de validation et de test en utilisant les proportions définies dans ce paramètre. Pour avoir un contrôle plus précis sur les entités utilisées dans ces différentes populations, il est possible de créer des fichiers qui les définissent explicitement, puis de [modifier le fichier de configuration des données d'entraînement](machine-learning-processing-training-config-file.md) pour mapper ces fichiers d'indexation aux populations. Ce mappage est spécifié par un objet JSON pour la clé [`custom_split_filesnames`](#custom_split_filenames) dans le fichier de configuration d'entraînement. Si cette option est utilisée, les noms de fichiers doivent être fournis pour les clés `train` et `validation`, et sont facultatifs pour la clé `test`. Le formatage de ces fichiers doit correspondre au [format de données Gremlin](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-systemheaders). Plus précisément, pour les tâches au niveau du nœud, chaque fichier doit contenir une colonne avec l'`~id`en-tête répertoriant le nœud IDs, et pour les tâches au niveau de la périphérie, les fichiers doivent spécifier `~from` et `~to` indiquer les nœuds source et de destination des bords, respectivement. Ces fichiers doivent être placés dans le même emplacement Amazon S3 que les données exportées utilisées pour le traitement des données (voir : [`outputS3Path`](export-parameters.md#export-parameters-outputS3Path)). Pour les tâches de classification ou de régression de propriété, ces fichiers peuvent éventuellement définir les étiquettes de la tâche de machine learning. Dans ce cas, les fichiers doivent comporter une colonne de propriété portant le même nom d'en-tête que celui [défini dans le fichier de configuration des données d'entraînement](#machine-learning-graph-node-labels-config). Si des étiquettes de propriété sont définies à la fois dans les fichiers de nœud et d'arête exportés et dans les fichiers de division personnalisée, la priorité est donnée aux fichiers de division personnalisée. # Entraînement d'un modèle à l'aide de Neptune ML Après avoir traité les données que vous avez exportées de Neptune pour l'entraînement de modèle, vous pouvez démarrer une tâche d'entraînement de modèle à l'aide d'une commande `curl` (ou `awscurl`) comme la suivante : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" }' ``` Les détails de l'utilisation de cette commande sont expliqués dans [Commande modeltraining](machine-learning-api-modeltraining.md), avec d'autres informations sur la façon d'obtenir le statut d'une tâche en cours d'exécution, d'arrêter une tâche en cours d'exécution et de répertorier toutes les tâches en cours d'exécution. Vous pouvez également fournir un identifiant `previousModelTrainingJobId` pour utiliser les informations issues d'une tâche d'entraînement de modèle Neptune ML terminée, afin d'accélérer la recherche d'hyperparamètres dans une nouvelle tâche d'entraînement. Cela est utile lors du [réentraînement de modèle sur de nouvelles données de graphe](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-model-retraining), ainsi que lors de l'[entraînement incrémentiel sur les mêmes données de graphe](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental). Utilisez une commande comme celle-ci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "previousModelTrainingJobId" : "(the model-training job-id of a completed job)" }' ``` Vous pouvez entraîner votre propre implémentation de modèle sur l'infrastructure d'entraînement Neptune ML en fournissant un objet `customModelTrainingParameters` tel que celui-ci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "modelName": "custom", "customModelTrainingParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "trainingEntryPointScript": "(your training script entry-point name in the Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` Consultez [Commande modeltraining](machine-learning-api-modeltraining.md) pour plus d'informations, notamment sur la façon d'obtenir le statut d'une tâche en cours d'exécution, la façon d'arrêter une tâche en cours d'exécution et la façon de répertorier toutes les tâches en cours d'exécution. Consultez [Modèles personnalisés dans Neptune ML](machine-learning-custom-models.md) pour en savoir plus sur la façon d'implémenter et d'utiliser un modèle personnalisé. **Topics** + [Modèles et entraînement de modèle dans Amazon Neptune ML](machine-learning-models-and-training.md) + [Personnalisation des configurations d'hyperparamètres de modèle dans Neptune ML](machine-learning-customizing-hyperparams.md) + [Bonnes pratiques d'entraînement de modèle](machine-learning-improve-model-performance.md) # Modèles et entraînement de modèle dans Amazon Neptune ML Neptune ML utilise les réseaux de neurones en graphes (GNN) pour créer des modèles pour les différentes tâches de machine learning. Il a été démontré que les réseaux neuronaux graphiques obtiennent des state-of-the-art résultats pour les tâches d'apprentissage automatique des graphes et sont excellents pour extraire des modèles informatifs à partir de données structurées par des graphes. ## Réseaux neuronaux graphiques (GNNs) dans Neptune ML Les réseaux neuronaux à graphes (GNNs) appartiennent à une famille de réseaux neuronaux qui calculent les représentations des nœuds en tenant compte de la structure et des caractéristiques des nœuds voisins. GNNs complètent d'autres méthodes traditionnelles d'apprentissage automatique et de réseaux neuronaux qui ne sont pas bien adaptées aux données graphiques. GNNs sont utilisés pour résoudre des tâches d'apprentissage automatique telles que la classification et la régression des nœuds (prédiction des propriétés des nœuds), la classification et la régression des arêtes (prédiction des propriétés des arêtes) ou la prédiction des liens (prédiction si deux nœuds du graphe doivent être connectés ou non). En général, l'utilisation d'un réseau GNN pour une tâche de machine learning comporte deux phases : + Une phase d'encodage, au cours de laquelle le réseau GNN calcule un vecteur à d dimensions pour chaque nœud du graphe. Ces vecteurs sont également appelés *représentations* ou *intégrations*. + Une phase de décodage, qui effectue des prédictions basées sur les représentations encodées. Pour la classification et la régression de nœud, les représentations des nœuds sont utilisées directement pour les tâches de classification et de régression. Pour la classification et la régression d'arête, les représentations de nœud des nœuds incidents sur une arête sont utilisées comme entrée pour la classification ou la régression. Pour la prédiction de lien, un score de probabilité d'arête est calculé à l'aide d'une paire de représentations de nœud et d'une représentation de type d'arête. La [Deep Graph Library (DGL)](https://www.dgl.ai/) facilite la définition et la formation efficaces GNNs de ces tâches. Différents modèles GNN sont unifiés dans le cadre de la formulation de la transmission de messages. Dans cette vue, la représentation d'un nœud dans un graphe est calculée à l'aide des représentations des voisins du nœud (les messages), ainsi que de la représentation initiale du nœud. Dans NeptuneML, la représentation initiale d'un nœud est dérivée des fonctionnalités extraites de ses propriétés de nœud, ou elle peut être apprise et dépend de l'identité du nœud. Neptune ML offre également la possibilité de concaténer les fonctionnalités de nœud et les représentations de nœud pouvant être apprises pour servir de représentation de nœud d'origine. Pour les diverses tâches dans Neptune ML impliquant des graphes dotés de propriétés de nœud, nous utilisons le [réseau convolutif graphique relationnel](https://arxiv.org/abs/1703.06103) (R-GCN) pour effectuer la phase d'encodage. R-GCN est une architecture GNN parfaitement adaptée aux graphes comportant plusieurs types de nœud et d'arête (ils sont appelés graphes hétérogènes). Le réseau R-GCN est constitué d'un nombre fixe de couches empilées les unes après les autres. Chaque couche du R-GCN utilise ses paramètres de modèle pouvant être appris pour agréger les informations provenant du voisinage à un saut, immédiat d'un nœud. Comme les couches suivantes utilisent les représentations en sortie de la couche précédente comme entrée, le rayon du voisinage de graphe qui influence l'intégration finale d'un nœud dépend du nombre de couches (`num-layer`) du réseau R-GCN. Par exemple, cela signifie qu'un réseau à deux couches utilise les informations provenant de nœuds situés à deux sauts de distance. Pour en savoir plus GNNs, consultez [A Comprehensive Survey on Graph Neural Networks](https://arxiv.org/abs/1901.00596). Pour plus d'informations sur la bibliothèqe Deep Graph Library (DGL), visitez la [page Web](https://www.dgl.ai/) de la DGL. Pour un didacticiel pratique sur l'utilisation de DGL avec GNNs, voir [Apprendre les réseaux neuronaux à graphes avec Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library). ## Réseaux de neurones en graphes d'entraînement Dans le machine learning, le processus qui consiste à amener un modèle à apprendre à effectuer de bonnes prédictions pour une tâche s'appelle « entraînement de modèle ». Il est généralement réalisé en spécifiant un objectif particulier à optimiser, ainsi qu'un algorithme à utiliser pour effectuer cette optimisation. Ce processus est utilisé pour entraîner un réseau GNN à apprendre de bonnes représentations également pour la tâche en aval. Nous créons une fonction objectif pour cette tâche qui est minimisée lors de l'entraînement du modèle. Par exemple, pour la classification des nœuds, nous utilisons [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html)comme objectif, ce qui pénalise les erreurs de classification, et pour la régression des nœuds, nous minimisons. [MeanSquareError](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html) L'objectif est généralement une fonction de perte qui prend les prédictions du modèle pour un point de données particulier et les compare à la valeur réelle pour ce point de données. Il renvoie la valeur de perte, qui indique à quel point les prédictions du modèle sont éloignées. L'objectif du processus d'entraînement est de minimiser les pertes et de s'assurer que les prédictions du modèle sont proches de la réalité. L'algorithme d'optimisation utilisé en deep learning pour le processus d'entraînement est généralement une variante de la descente de gradient. Dans Neptune ML, nous utilisons [Adam](https://arxiv.org/pdf/1412.6980.pdf), un algorithme d'optimisation des fonctions objectives stochastiques basé sur un gradient de premier ordre, sur la base d'estimations adaptatives de moments d'ordre inférieur. Alors que le processus d'entraînement de modèle essaie de s'assurer que les paramètres de modèle appris sont proches des minima de la fonction objectif, les performances globales d'un modèle dépendent également des *hyperparamètres* du modèle, qui sont des paramètres de modèle qui ne sont pas appris par l'algorithme d'entraînement. Par exemple, la dimensionnalité de la représentation de nœud appris, `num-hidden`, est un hyperparamètre qui affecte les performances du modèle. Par conséquent, il est courant en machine learning d'effectuer une optimisation des hyperparamètres (HPO) pour choisir les hyperparamètres appropriés. Neptune ML utilise une tâche de réglage des hyperparamètres basée sur l' SageMaker IA pour lancer plusieurs instances d'apprentissage de modèles avec différentes configurations d'hyperparamètres afin de trouver le meilleur modèle pour une gamme de paramètres d'hyperparamètres. Consultez [Personnalisation des configurations d'hyperparamètres de modèle dans Neptune ML](machine-learning-customizing-hyperparams.md). ## Modèles d'intégration de graphe de connaissances dans Neptune ML Les graphes de connaissances (KGs) sont des graphes qui encodent des informations sur les différentes entités (nœuds) et leurs relations (arêtes). Dans Neptune ML, les modèles d'intégration de graphe de connaissances sont appliqués par défaut pour effectuer une prédiction de lien lorsque le graphe ne contient pas de propriétés de nœud, mais uniquement des relations avec d'autres nœuds. Des modèles R-GCN avec intégrations pouvant être apprises peuvent également être utilisés pour ces graphes en spécifiant le type de modèle `"rgcn"`, mais les modèles d'intégration de graphe de connaissances sont plus simples et sont conçus pour être efficaces pour l'apprentissage de représentations pour des graphes de connaissances à grande échelle. Les modèles d'intégration de graphe de connaissances sont utilisés dans une tâche de prédiction de lien pour prédire les nœuds ou les relations qui complètent un triple `(h, r, t)` où `h` est le nœud source, `r` le type de relation et `t` le nœud de destination. Les modèles d'intégration de graphe de connaissances implémentés dans Neptune ML sont `distmult`, `transE` et `rotatE`. Pour en savoir plus sur les modèles d'intégration de graphe de connaissances, consultez [DGL-KE](https://github.com/awslabs/dgl-ke). ## Entraînement de modèles personnalisés dans Neptune ML Neptune ML vous permet de définir et d'implémenter vos propres modèles personnalisés, pour des scénarios particuliers. Consultez [Modèles personnalisés dans Neptune ML](machine-learning-custom-models.md) pour en savoir plus sur la manière d'implémenter un modèle personnalisé et sur la manière d'utiliser l'infrastructure Neptune ML pour l'entraîner. # Personnalisation des configurations d'hyperparamètres de modèle dans Neptune ML Lorsque vous démarrez une tâche d'entraînement de modèle Neptune ML, Neptune ML utilise automatiquement les informations déduites de la tâche de [traitement de données](machine-learning-on-graphs-processing.md) précédente. Il utilise les informations pour générer des plages de configuration d'hyperparamètres qui sont utilisées pour créer une tâche de [réglage d'hyperparamètres basée sur l'SageMaker IA afin d'entraîner plusieurs modèles pour votre tâche](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html). Ainsi, il n'est pas nécessaire de spécifier une longue liste de valeurs d'hyperparamètres à utiliser pour entraîner les modèles. Au lieu de cela, les valeurs par défaut et les plages d'hyperparamètres de modèle sont sélectionnées en fonction du type de tâche, du type de graphe et des paramètres de la tâche de réglage. Toutefois, vous pouvez également remplacer la configuration des hyperparamètres par défaut et fournir des hyperparamètres personnalisés en modifiant un fichier de configuration JSON généré par la tâche de traitement des données. À l'aide de l'[API modelTraining](machine-learning-api-modeltraining.md) de Neptune ML, vous pouvez contrôler plusieurs paramètres de tâche de réglage d'hyperparamètres de haut niveau, tels que `maxHPONumberOfTrainingJobs`, `maxHPOParallelTrainingJobs` et `trainingInstanceType`. Pour un contrôle plus précis des hyperparamètres du modèle, vous pouvez personnaliser le fichier `model-HPO-configuration.json` généré par la tâche de traitement de données. Le fichier est enregistré à l'emplacement Amazon S3 que vous avez spécifié pour la sortie de la tâche de traitement. Vous pouvez télécharger le fichier, le modifier pour remplacer les configurations d'hyperparamètres par défaut, puis le charger à nouveau dans le même emplacement Amazon S3. Ne modifiez pas le nom du fichier et veillez à suivre ces instructions lorsque vous le modifiez. Pour télécharger le fichier à partir d'Amazon S3 : ``` aws s3 cp \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json \ ./ ``` Lorsque vous avez terminé la modification, rechargez le fichier là où il se trouvait : ``` aws s3 cp \ model-HPO-configuration.json \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json ``` ## Structure du fichier `model-HPO-configuration.json` Le fichier `model-HPO-configuration.json` spécifie le modèle à entraîner, l'élément `task_type` de machine learning et les hyperparamètres qui doivent être modulés ou fixés pour les diverses exécutions d'entraînement de modèle. Les hyperparamètres sont classés comme appartenant à différents niveaux qui indiquent la priorité accordée aux hyperparamètres lorsque la tâche de réglage des hyperparamètres est invoquée : + Les hyperparamètres de niveau 1 ont la priorité la plus élevée. Si vous définissez `maxHPONumberOfTrainingJobs` sur une valeur inférieure à 10, seuls les hyperparamètres de niveau 1 sont réglés et les autres adoptent leurs valeurs par défaut. + Les hyperparamètres de niveau 2 ont une priorité inférieure. Ainsi, si vous avez plus de 10 mais moins de 50 tâches d'entraînement au total pour une tâche de réglage, les hyperparamètres des niveaux 1 et 2 sont réglés. + Les hyperparamètres de niveau 3 sont réglés avec les niveaux 1 et 2 uniquement si vous avez un total de plus de 50 tâches d'entraînement. + Enfin, les hyperparamètres fixés ne sont pas du tout réglés et adoptent toujours leurs valeurs par défaut. ### Exemple de fichier `model-HPO-configuration.json` Voici un exemple de fichier `model-HPO-configuration.json` : ``` { "models": [ { "model": "rgcn", "task_type": "node_class", "eval_metric": { "metric": "acc" }, "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, "1-tier-param": [ { "param": "num-hidden", "range": [16, 128], "type": "int", "inc_strategy": "power2" }, { "param": "num-epochs", "range": [3,30], "inc_strategy": "linear", "inc_val": 1, "type": "int", "node_strategy": "perM" }, { "param": "lr", "range": [0.001,0.01], "type": "float", "inc_strategy": "log" } ], "2-tier-param": [ { "param": "dropout", "range": [0.0,0.5], "inc_strategy": "linear", "type": "float", "default": 0.3 }, { "param": "layer-norm", "type": "bool", "default": true } ], "3-tier-param": [ { "param": "batch-size", "range": [128, 4096], "inc_strategy": "power2", "type": "int", "default": 1024 }, { "param": "fanout", "type": "int", "options": [[10, 30],[15, 30], [15, 30]], "default": [10, 15, 15] }, { "param": "num-layer", "range": [1, 3], "inc_strategy": "linear", "inc_val": 1, "type": "int", "default": 2 }, { "param": "num-bases", "range": [0, 8], "inc_strategy": "linear", "inc_val": 2, "type": "int", "default": 0 } ], "fixed-param": [ { "param": "concat-node-embed", "type": "bool", "default": true }, { "param": "use-self-loop", "type": "bool", "default": true }, { "param": "low-mem", "type": "bool", "default": true }, { "param": "l2norm", "type": "float", "default": 0 } ] } ] } ``` ### Éléments d'un fichier `model-HPO-configuration.json` Le fichier contient un objet JSON avec un seul tableau de niveau supérieur nommé `models` contenant un seul objet de configuration de modèle. Lorsque vous personnalisez le fichier, assurez-vous que le tableau `models` ne contient qu'un seul objet de configuration de modèle. Si votre fichier contient plusieurs objets de configuration de modèle, la tâche de réglage échouera avec un avertissement. L'objet de configuration de modèle contient les éléments de haut niveau suivants : + **`model`** : (*string*) type de modèle à entraîner (**ne pas modifier**). Les valeurs valides sont : + `"rgcn"` : il s'agit de la valeur par défaut pour les tâches de classification et de régression de nœud, ainsi que pour les tâches de prédiction de lien hétérogènes. + `"transe"` : il s'agit de la valeur par défaut pour les tâches de prédiction de lien KGE. + `"distmult"` : il s'agit d'un type de modèle alternatif pour les tâches de prédiction de lien KGE. + `"rotate"` : il s'agit d'un type de modèle alternatif pour les tâches de prédiction de lien KGE. En règle générale, ne modifiez pas directement la valeur `model`, car les différents types de modèles ont souvent des hyperparamètres applicables sensiblement différents, ce qui peut entraîner une erreur d'analyse après le début de la tâche d'entraînement. Pour modifier le type de modèle, utilisez le paramètre `modelName` de l'[API modelTraining](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) au lieu de le modifier dans le fichier `model-HPO-configuration.json`. Une manière de modifier le type de modèle et d'apporter des modifications fines aux hyperparamètres consiste à copier le modèle de configuration de modèle par défaut pour le modèle que vous souhaitez utiliser et à le coller dans le fichier `model-HPO-configuration.json`. Il existe un dossier nommé `hpo-configuration-templates` au même emplacement Amazon S3 que le fichier `model-HPO-configuration.json` si le type de tâche déduit prend en charge plusieurs modèles. Ce dossier contient toutes les configurations d'hyperparamètres par défaut pour les autres modèles applicables à la tâche. Par exemple, si vous souhaitez modifier les configurations de modèle et d'hyperparamètres d'une tâche de prédiction de lien `KGE` en passant du modèle `transe` par défaut à un modèle `distmult`, il vous suffit de coller le contenu du fichier `hpo-configuration-templates/distmult.json` dans le fichier `model-HPO-configuration.json`, puis d'apporter les modifications nécessaires aux hyperparamètres. **Note** Si vous définissez le paramètre `modelName` dans l'API `modelTraining` et modifiez également la spécification des hyperparamètres et de `model` dans le fichier `model-HPO-configuration.json`, et que ceux-ci sont différents, la valeur `model` du fichier `model-HPO-configuration.json` est prioritaire et la valeur `modelName` est ignorée. + **`task_type`** : (*string*) type de tâche de machine learning déduit par la tâche de traitement des données ou transmis directement à cette tâche (**ne pas modifier**). Les valeurs valides sont : + `"node_class"` + `"node_regression"` + `"link_prediction"` La tâche de traitement des données déduit le type de tâche en examinant les propriétés du jeu de données exporté et du fichier généré de configuration de tâche d'entraînement. Cette valeur ne doit pas être modifiée. Si vous souhaitez entraîner une autre tâche, vous devez [exécuter une nouvelle tâche de traitement de données](machine-learning-on-graphs-processing.md). Si la valeur `task_type` n'est pas celle que vous attendiez, vous devez vérifier les entrées de votre tâche de traitement de données pour vous assurer qu'elles sont correctes. Cela inclut les paramètres de l'API `modelTraining`, ainsi que ceux du fichier de configuration de tâche d'entraînement généré par le processus d'exportation de données. + **`eval_metric`** : (*string*) la métrique d'évaluation doit être utilisée pour évaluer les performances de modèle et pour sélectionner le modèle le plus performant lors des exécutions HPO. Les valeurs valides sont : + `"acc"` : précision de classification standard. Il s'agit de la valeur par défaut pour les tâches de classification à étiquette unique, sauf si des étiquettes déséquilibrées sont détectées lors du traitement des données, auquel cas la valeur par défaut est `"F1"`. + `"acc_topk"` : nombre de fois où l'étiquette correcte figure parmi les meilleures prédictions **`k`**. Vous pouvez également définir la valeur **`k`** en transmettant `topk` comme clé supplémentaire. + `"F1"` : le [score F1](https://en.wikipedia.org/wiki/F-score). + `"mse"` : [métrique d'erreur quadratique moyenne](https://en.wikipedia.org/wiki/Mean_squared_error) pour les tâches de régression. + `"mrr"` : [métrique de rang réciproque moyen](https://en.wikipedia.org/wiki/Mean_reciprocal_rank). + `"precision"` : la précision du modèle, calculée comme le rapport entre les vrais positifs et les positifs prédits : `= true-positives / (true-positives + false-positives)`. + `"recall"` : le rappel du modèle, calculé comme le rapport entre les vrais positifs et les positifs réels : `= true-positives / (true-positives + false-negatives)`. + `"roc_auc"` : l'aire située sous la [courbe ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic). Il s'agit de la valeur par défaut pour la classification à plusieurs étiquettes. Par exemple, pour remplacer la métrique par `F1`, modifiez la valeur `eval_metric` comme suit : ``` " eval_metric": { "metric": "F1", }, ``` Ou, pour remplacer la métrique par un score de précision `topk`, vous devez modifier `eval_metric` comme suit : ``` "eval_metric": { "metric": "acc_topk", "topk": 2 }, ``` + **`eval_frequency`** : (*objet*) spécifie à quelle fréquence il convient de vérifier les performances du modèle sur le jeu de validation pendant l'entraînement. Sur la base des performances de validation, il est alors possible d'initier un arrêt anticipé et d'enregistrer le meilleur modèle. L'objet `eval_frequency` contient deux éléments, à savoir `"type"` et `"value"`. Par exemple : ``` "eval_frequency": { "type": "evaluate_every_pct", "value": 0.1 }, ``` Les valeurs `type` valides sont : + **`evaluate_every_pct`** : spécifie le pourcentage d'entraînement à suivre pour chaque évaluation. Pour `evaluate_every_pct`, le champ `"value"` contient un nombre à virgule flottante compris entre zéro et un, qui exprime ce pourcentage. + **`evaluate_every_batch`** : spécifie le nombre de lots d'entraînement à traiter pour chaque évaluation. Pour `evaluate_every_batch`, le champ `"value"` contient un entier qui exprime ce nombre de lots. + **`evaluate_every_epoch`** : spécifie le nombre d'époques par évaluation, une nouvelle époque commençant à minuit. Pour `evaluate_every_epoch`, le champ `"value"` contient un entier qui exprime ce nombre d'époques. Le paramètre par défaut pour `eval_frequency` est : ``` "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, ``` + **`1-tier-param`** : (*obligatoire*) tableau d'hyperparamètres de niveau 1. Si vous ne souhaitez régler aucun hyperparamètre, vous pouvez définir cet élément sur un tableau vide. Cela n'affecte pas le nombre total de tâches de formation lancées par la tâche de réglage des hyperparamètres de l' SageMaker IA. Cela signifie simplement que toutes les tâches d'entraînement, s'il y en a plus de 1 mais moins de 10, seront exécutées avec le même ensemble d'hyperparamètres. D'un autre côté, si vous souhaitez traiter tous vos hyperparamètres réglables avec une importance égale, vous pouvez placer tous les hyperparamètres dans ce tableau. + **`2-tier-param`** : (*obligatoire*) tableau d'hyperparamètres de niveau 2. Ces paramètres sont réglés uniquement si `maxHPONumberOfTrainingJobs` a une valeur supérieure à 10. Dans le cas contraire, ils sont fixés aux valeurs par défaut. Si vous avez un budget d'entraînement de 10 tâches d'entraînement au maximum ou ne souhaitez pas d'hyperparamètres de niveau 2 pour une raison quelconque, mais que vous souhaitez régler tous les hyperparamètres réglables, vous pouvez définir cet élément sur un tableau vide. + **`3-tier-param`** : (*obligatoire*) tableau d'hyperparamètres de niveau 3. Ces paramètres sont réglés uniquement si `maxHPONumberOfTrainingJobs` a une valeur supérieure à 50. Dans le cas contraire, ils sont fixés aux valeurs par défaut. Si vous ne souhaitez pas d'hyperparamètres de niveau 3, vous pouvez définir cet élément sur un tableau vide. + **`fixed-param`** : (*obligatoire*) un tableau d'hyperparamètres fixes qui ne prennent que leurs valeurs par défaut et ne varient pas dans les différentes tâches d'entraînement. Si vous souhaitez moduler tous les hyperparamètres, vous pouvez définir cet élément sur un tableau vide et définir une valeur de `maxHPONumberOfTrainingJobs` suffisamment grande pour faire varier tous les niveaux ou définir tous les hyperparamètres au niveau 1. L'objet JSON qui représente chaque hyperparamètre dans `1-tier-param`, `2-tier-param`, `3-tier-param` et `fixed-param` contient les éléments suivants : + **`param`** : (*string*) nom de l'hyperparamètre (**ne pas modifier**). Consultez la [liste des noms d'hyperparamètre valides dans Neptune ML](#machine-learning-hyperparams-list). + **`type`** : (*string*) type d'hyperparamètre (**ne pas modifier**). Les types valides sont : `bool`, `int` et `float`. + **`default`** : (*string*) valeur par défaut de l'hyperparamètre. Vous pouvez définir une nouvelle valeur par défaut. Les hyperparamètres réglables peuvent également contenir les éléments suivants : + **`range`** : (*array*) plage d'un hyperparamètre réglable continu. Il doit s'agir d'un tableau à deux valeurs, à savoir le minimum et le maximum de la plage (`[min, max]`). + **`options`** : (*array*) options pour un hyperparamètre réglable catégoriel. Ce tableau doit contenir toutes les options à prendre en compte : ``` "options" : [value1, value2, ... valuen] ``` + **`inc_strategy`** : (*string*) type de modification incrémentielle pour les plages d'hyperparamètres réglables continus (**ne pas modifier**). Les valeurs valides sont `log`, `linear` et `power2`. Cela s'applique uniquement lorsque la clé de plage est définie. Si vous modifiez cet élément, vous risquez de ne pas utiliser toute la plage de votre hyperparamètre pour le réglage. + **`inc_val`** : (*float*) différence entre les incréments successifs pour les hyperparamètres réglables continus (**ne pas modifier**). Cela s'applique uniquement lorsque la clé de plage est définie. Si vous modifiez cet élément, vous risquez de ne pas utiliser toute la plage de votre hyperparamètre pour le réglage. + **`node_strategy`** : (*string*) indique que la plage effective de cet hyperparamètre doit changer en fonction du nombre de nœuds du graphe (**ne pas modifier**). Les valeurs valides sont `"perM"` (par million), `"per10M"` (pour 10 millions) et `"per100M"` (pour 100 millions). Plutôt que de modifier cette valeur, modifiez `range`. + **`edge_strategy`** : (*string*) indique que la plage effective de cet hyperparamètre doit changer en fonction du nombre d'arêtes dans le graphe (**ne pas modifier**). Les valeurs valides sont `"perM"` (par million), `"per10M"` (pour 10 millions) et `"per100M"` (pour 100 millions). Plutôt que de modifier cette valeur, modifiez `range`. ### Liste de tous les hyperparamètres dans Neptune ML La liste suivante contient tous les hyperparamètres qui peuvent être définis n'importe où dans Neptune ML, pour tout type de modèle et toute tâche. Comme ils ne sont pas tous applicables à tout type de modèle, il est important de définir dans le fichier `model-HPO-configuration.json` seulement les hyperparamètres qui apparaissent dans le modèle relatif au modèle que vous utilisez. + **`batch-size`** : taille du lot de nœuds cibles utilisé en un seul transfert. *Type* : `int`. La définition d'une valeur beaucoup plus élevée peut entraîner des problèmes de mémoire lors de l'entraînement sur des instances GPU. + **`concat-node-embed`** : indique s'il faut obtenir la représentation initiale d'un nœud en concaténant ses fonctionnalités traitées avec des intégrations initiales de nœuds pouvant être apprises afin d'augmenter l'expressivité du modèle. *Type* : `bool`. + **`dropout`** : probabilité d'abandon appliquée aux couches d'abandon. *Type* : `float`. + **`edge-num-hidden`** : taille de la couche masquée ou nombre d'unités pour le module de fonctionnalités d'arête. Utilisé uniquement quand `use-edge-features` a pour valeur `True`. *Type* : float. + **`enable-early-stop`** : permet d'utiliser ou non la fonctionnalité d'arrêt anticipé. *Type* : `bool`. *Par défaut* : `true`. Utilisez ce paramètre booléen pour désactiver la fonctionnalité d'arrêt anticipé. + **`fanout`** : nombre de voisins à échantillonner pour un nœud cible lors de l'échantillonnage des voisins. *Type* : `int`. Cette valeur est étroitement liée à `num-layers` et devrait toujours figurer au même niveau d'hyperparamètres. Cela est dû au fait que vous pouvez spécifier une diffusion en éventail pour chaque couche GNN potentielle. Étant donné que cet hyperparamètre peut entraîner des variations importantes des performances de modèle, il devrait être fixé ou défini en tant qu'hyperparamètre de niveau 2 ou 3. Lui affecter une valeur élevée peut entraîner des problèmes de mémoire lors de l'entraînement sur des instances GPU. + **`gamma`** : valeur de marge dans la fonction de score. *Type* : `float`. Elle s'applique uniquement aux modèles de prédiction de lien `KGE`. + **`l2norm`** : valeur de dégradation de poids utilisée dans l'optimiseur, qui impose une pénalité de normalisation L2 aux poids. *Type* : `bool`. + **`layer-norm`** : indique s'il convient d'utiliser la normalisation des couches pour les modèles `rgcn`. *Type* : `bool`. + **`low-mem`** : indique s'il convient d'utiliser une implémentation à faible mémoire de la fonction de transmission des messages relationnels au détriment de la vitesse. *Type* : `bool`. + **`lr`** : taux d'apprentissage. *Type* : `float`. Il doit être défini en tant qu'hyperparamètre de niveau 1. + **`neg-share`** : dans le cadre de la prédiction de lien, indique si les arêtes échantillonnées positives peuvent partager des échantillons d'arête négatifs. *Type* : `bool`. + **`num-bases`** : nombre de bases pour la décomposition des bases dans un modèle `rgcn`. L'utilisation d'une valeur `num-bases` inférieure au nombre de types d'arête dans le graphe agit comme un régularisateur pour le modèle `rgcn`. *Type* : `int`. + **`num-epochs`** : nombre d'époques d'entraînement à exécuter. *Type* : `int`. Une époque est un parcours d'entraînement complet à travers le graphe. + **`num-hidden`** : taille de la couche masquée ou nombre d'unités. *Type* : `int`. Cela définit également la taille d'intégration initiale pour les nœuds sans fonctionnalités. La définir sur une valeur beaucoup plus élevée sans la réduire `batch-size` peut entraîner des out-of-memory problèmes d'entraînement sur une instance GPU. + **`num-layer`** : nombre de couches GNN dans le modèle. *Type* : `int`. Cette valeur est étroitement liée au paramètre de diffusion en éventail et devrait être définie après la diffusion en éventail au même niveau d'hyperparamètres. Étant donné qu'elle peut entraîner des variations importantes des performances de modèle, elle devrait être fixée ou définie en tant qu'hyperparamètre de niveau 2 ou 3. + **`num-negs`** : dans le cadre de la prédiction de lien, nombre d'échantillons négatifs par échantillon positif. *Type* : `int`. + **`per-feat-name-embed`** : indique s'il faut intégrer chaque fonctionnalité en la transformant indépendamment avant de combiner les fonctionnalités. *Type* : `bool`. Lorsque cette valeur est définie sur `true`, chaque fonctionnalité par nœud est transformée indépendamment en une taille de dimension fixe avant que toutes les fonctionnalités transformées pour le nœud soient concaténées puis transformées dans la dimension `num_hidden`. Lorsque la valeur `false` est définie, les fonctionnalités sont concaténées sans aucune transformation spécifique aux fonctionnalités. + **`regularization-coef`** : dans le cadre de la prédiction de lien, coefficient de perte de régularisation. *Type* : `float`. + **`rel-part`** : indique s'il convient d'utiliser une partition de relation pour la prédiction de lien `KGE`. *Type* : `bool`. + **`sparse-lr`** : taux d'apprentissage pour les intégrations de nœuds pouvant être appris. *Type* : `float`. Les intégrations initiales de nœuds pouvant être appris sont utilisées pour les nœuds sans fonctionnalités ou quand `concat-node-embed` est défini. Les paramètres de la couche d'intégration fragmentée de nœuds pouvant être appris sont entraînés à l'aide d'un optimiseur distinct qui peut avoir un taux d'apprentissage distinct. + **`use-class-weight`** : indique s'il convient d'appliquer des pondérations de classe pour les tâches de classification déséquilibrée. Si la valeur `true` est définie, les nombres d'étiquettes sont utilisés pour définir un poids pour chaque étiquette de classe. *Type* : `bool`. + **`use-edge-features`** : indique s'il convient d'utiliser les fonctionnalités d'arête lors de la transmission de messages. Si la valeur `true` est définie, un module de fonctionnalités d'arête personnalisé est ajouté à la couche RGCN pour les types d'arête comportant des fonctionnalités. *Type* : `bool`. + **`use-self-loop`** : indique s'il convient d'inclure les boucles automatiques dans l'entraînement d'un modèle `rgcn`. *Type* : `bool`. + **`window-for-early-stop`** : contrôle le nombre des derniers scores de validation à la moyenne pour décider ou non d'un arrêt anticipé. La valeur par défaut est 3. type=int. Consultez également [Arrêt anticipé du processus d'entraînement de modèle dans Neptune ML](machine-learning-improve-model-performance.md#machine-learning-model-training-early-stop). *Type* : `int`. *Par défaut* : `3`. Consultez . ## Personnalisation des hyperparamètres dans Neptune ML Lorsque vous modifiez le fichier `model-HPO-configuration.json`, les types de modifications les plus courants sont les suivants : + Modifiez les valeurs and/or maximales minimales des `range` hyperparamètres. + Affectez une valeur fixe à un hyperparamètre en le déplaçant vers la section `fixed-param` et en définissant sa valeur par défaut sur la valeur fixe que vous souhaitez qu'il prenne. + Modifiez la priorité d'un hyperparamètre en le plaçant dans un niveau spécifique, en modifiant sa plage et en vous assurant que sa valeur par défaut est définie de manière appropriée. # Bonnes pratiques d'entraînement de modèle Il y a des choses que vous pouvez faire pour améliorer les performances des modèles Neptune ML. ## Choisir la propriété de nœud appropriée Toutes les propriétés de votre graphe ne sont pas significatives ou pertinentes pour vos tâches de machine learning. Toute propriété non pertinente doit être exclue lors de l'exportation des données. Voici quelques bonnes pratiques : + Faites appel à des experts du domaine pour vous aider à évaluer l'importance des fonctionnalités et la faisabilité de leur utilisation pour les prédictions. + Supprimez les fonctionnalités que vous considérez redondantes ou non pertinentes afin de réduire le bruit dans les données et les corrélations superflues. + Effectuez une itération au fur et à mesure que vous créez votre modèle. Ajustez les fonctionnalités, les combinaisons de fonctionnalités et les objectifs de réglage au fur et à mesure. La rubrique [Fonctionnalisation](https://docs.aws.amazon.com/machine-learning/latest/dg/feature-processing.html) du Guide du développeur d'Amazon Machine Learning fournit des instructions supplémentaires relatives à la fonctionnalisation, qui sont pertinentes pour Neptune ML. ## Gérer les points de données aberrants Une aberration est un point de données très différent des autres données. Les données aberrantes peuvent gâcher ou induire en erreur le processus d'entraînement, ce qui peut conduire à un allongement du temps d'entraînement ou à des modèles moins précis. À moins qu'elles soient vraiment importantes, vous devez éliminer les aberrations avant d'exporter les données. ## Supprimer les nœuds et les arêtes dupliqués Les graphes stockés dans Neptune peuvent comporter des doublons de nœuds ou d'arêtes. Ces éléments redondants introduiront du bruit lors de l'entraînement de modèle ML. Éliminez les doublons de nœuds ou d'arêtes avant d'exporter les données. ## Régler la structure du graphe Lorsque le graphe est exporté, vous pouvez modifier la façon dont les fonctionnalités sont traitées et la façon dont le graphe est construit, afin d'améliorer les performances du modèle. Voici quelques bonnes pratiques : + Lorsqu'une propriété d'arête a la signification de catégories d'arête, il est parfois utile de la transformer en types d'arête. + La politique de normalisation par défaut utilisée pour une propriété numérique est `min-max`, mais dans certains cas, d'autres politiques de normalisation fonctionnent mieux. Vous pouvez prétraiter la propriété et modifier la politique de normalisation comme expliqué dans [Éléments d'un fichier `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements). + Le processus d'exportation génère automatiquement des types de fonctionnalité en fonction des types de propriété. Par exemple, il traite les propriétés `String` comme des fonctionnalités catégorielles et les propriétés `Float` et `Int` comme des fonctionnalités numériques. Si nécessaire, vous pouvez modifier le type de fonctionnalité après l'exportation (voir [Éléments d'un fichier `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements)). ## Régler les plages d'hyperparamètres et les valeurs par défaut L'opération de traitement de données déduit des plages de configuration des hyperparamètres à partir du graphe. Si les plages d'hyperparamètres et les valeurs par défaut du modèle généré ne fonctionnent pas correctement pour vos données de graphe, vous pouvez modifier le fichier de configuration HPO afin de créer votre propre stratégie de réglage des hyperparamètres. Voici quelques bonnes pratiques : + Lorsque le graphe devient grand, la taille de la dimension masquée par défaut peut ne pas être suffisante pour contenir toutes les informations. Vous pouvez modifier l'hyperparamètre `num-hidden` pour contrôler la taille de la dimension masquée. + Pour les modèles d'intégration de graphe de connaissances (KGE), vous souhaiterez peut-être modifier le modèle spécifique utilisé en fonction de votre structure de graphe et de votre budget. `TrainsE`les modèles ont du mal à gérer les relations one-to-many (1-N), many-to-one (N-1) et many-to-many (N-N). `DistMult`les modèles ont du mal à gérer les relations symétriques. `RotatE`est bon pour modéliser toutes sortes de relations, mais il est plus coûteux que `TrainsE` et `DistMult` pendant la formation. + Dans certains cas, quand l'identification du nœud et les informations sur les fonctionnalités du nœud sont importantes, vous devez utiliser ``concat-node-embed`` pour indiquer au modèle Neptune ML d'obtenir la représentation initiale d'un nœud en concaténant ses fonctionnalités avec ses intégrations initiales. + Lorsque vous obtenez des performances relativement bonnes sur certains hyperparamètres, vous pouvez ajuster l'espace de recherche des hyperparamètres en fonction de ces résultats. ## Arrêt anticipé du processus d'entraînement de modèle dans Neptune ML L'arrêt anticipé peut réduire de manière significative le temps d'entraînement de modèle et les coûts associés sans dégrader les performances de modèle. Il empêche également le surajustement du modèle aux données d'entraînement. L'arrêt anticipé dépend de mesures régulières des performances du jeu de validation. Initialement, les performances s'améliorent au fur et à mesure de l'entraînement, mais lorsque le modèle commence à être surajusté, elles commencent à décliner à nouveau. La fonctionnalité d'arrêt anticipé identifie le point où le modèle commence à être surajusté et interrompt l'entraînement de modèle à ce stade. Neptune ML surveille les appels des métriques de validation et compare la métrique de validation la plus récente à la moyenne des métriques de validation des **`n`** dernières évaluations, où **`n`** est un nombre défini à l'aide du paramètre `window-for-early-stop`. Dès que la métrique de validation est inférieure à cette moyenne, Neptune ML arrête l'entraînement du modèle et enregistre le meilleur modèle à ce stade. Vous pouvez contrôler l'arrêt anticipé à l'aide des paramètres suivants : + **`window-for-early-stop`** : la valeur de ce paramètre est un entier qui spécifie le nombre de scores de validation récents à moyenner pour décider d'un arrêt anticipé. La valeur par défaut est `3`. + **`enable-early-stop`** : utilisez ce paramètre booléen pour désactiver la fonctionnalité d'arrêt anticipé. Par défaut, cette valeur est `true`. ## Arrêt anticipé du processus HPO dans Neptune ML La fonction d'arrêt anticipé de Neptune ML arrête également les tâches d'entraînement qui ne fonctionnent pas bien par rapport aux autres tâches de formation, à l'aide de la fonction de démarrage à chaud SageMaker AI HPO. Cela peut également réduire les coûts et améliorer la qualité de l'optimisation des hyperparamètres (HPO). Consultez [Exécution d'une tâche de réglage des hyperparamètres avec démarrage à chaud](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html) pour obtenir une description de son fonctionnement. Le démarrage à chaud permet de transmettre les informations apprises à partir des tâches d'entraînement précédentes aux tâches d'entraînement suivantes et offre deux avantages distincts : + Tout d'abord, les résultats des tâches d'entraînement précédentes sont utilisés pour sélectionner de bonnes combinaisons d'hyperparamètres à examiner dans la nouvelle tâche de réglage. + Ensuite, il permet un arrêt anticipé pour accéder à un plus grand nombre d'exécutions de modèle, ce qui réduit le temps de réglage. Cette fonctionnalité est activée automatiquement dans Neptune ML et vous permet de trouver un équilibre entre le temps d'entraînement de modèle et ses performances. Si vous êtes satisfait des performances du modèle actuel, vous pouvez utiliser ce modèle. Sinon, vous en exécutez d'autres HPOs qui démarrent à chaud avec les résultats des essais précédents afin de découvrir un meilleur modèle. ## Bénéficier de services d'assistance professionnels AWS propose des services de support professionnels pour vous aider à résoudre les problèmes liés à vos projets d'apprentissage automatique sur Neptune. Si vous êtes bloqué, contactez [AWS Support](https://aws.amazon.com/premiumsupport/). # Utilisation d'un modèle entraîné pour générer de nouveaux artefacts de modèle À l'aide de la commande de transformation de modèle Neptune ML, vous pouvez calculer des artefacts de modèle tels que les intégrations de nœuds sur des données de graphe traitées à l'aide de paramètres de modèle préentraînés. ## Transformation de modèle pour une inférence incrémentielle Dans le [flux de travail d'inférence de modèle incrémentielle](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental), après avoir traité les données de graphe mises à jour que vous avez exportées depuis Neptune, vous pouvez démarrer une tâche de transformation de modèle à l'aide d'une commande curl (ou awscurl) comme suit : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltransform -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "mlModelTrainingJobId": "(the ML model training job-id)", "modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/" }' ``` Vous pouvez ensuite transmettre l'ID de cette tâche à l'appel d'API de création de points de terminaison pour créer un nouveau point de terminaison ou mettre à jour un point de terminaison existant avec les nouveaux artefacts de modèle générés par cette tâche. Cela permet au point de terminaison nouveau ou mis à jour de fournir des prédictions de modèle pour les données de graphe mises à jour. ## Transformation de modèle pour n'importe quelle tâche d'entraînement Vous pouvez également fournir un `trainingJobName` paramètre pour générer des artefacts de modèle pour toutes les tâches de formation à l' SageMaker IA lancées pendant l'entraînement du modèle Neptune ML. Étant donné qu'une tâche de formation sur le modèle Neptune ML peut potentiellement lancer de nombreuses tâches de formation à l' SageMaker IA, cela vous donne la flexibilité de créer un point de terminaison d'inférence basé sur l'une de ces tâches de formation à l' SageMaker IA. Par exemple : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltransform -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "trainingJobName" : "(name a completed SageMaker AI training job)", "modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/" }' ``` Si la tâche d'entraînement d'origine portait sur un modèle personnalisé fourni par l'utilisateur, vous devez inclure un objet `customModelTransformParameters` lorsque vous invoquez une transformation de modèle. Consultez [Modèles personnalisés dans Neptune ML](machine-learning-custom-models.md) pour en savoir plus sur la façon d'implémenter et d'utiliser un modèle personnalisé. **Note** La `modeltransform` commande exécute toujours la transformation du modèle sur la tâche de formation à l' SageMaker IA la mieux adaptée à cette formation. Consultez [Commande modeltransform](machine-learning-api-modeltransform.md) pour plus d'informations sur les tâches de transformation de modèle. # Artefacts produits par l'entraînement de modèle dans Neptune ML Après l'entraînement de modèle, Neptune ML utilise les paramètres de modèle les mieux entraînés pour générer les artefacts de modèle qui sont nécessaires pour le lancement du point de terminaison d'inférence et la fourniture de prédictions de modèle. Ces artefacts sont regroupés par la tâche de formation et stockés dans l'emplacement de sortie Amazon S3 de la meilleure tâche de formation en SageMaker IA. Les sections suivantes décrivent ce qui est inclus dans les artefacts de modèle pour les différentes tâches et comment la commande de transformation de modèle utilise un modèle entraîné préexistant pour générer des artefacts même sur de nouvelles données de graphe. ## Artefacts générés pour différentes tâches Le contenu des artefacts de modèle générés par le processus d'entraînement dépend de la tâche de machine learning cible : **** + **Classification et régression de nœud** : pour la prédiction d'une propriété d'un nœud, les artefacts incluent les paramètres de modèle, les intégrations de nœud provenant de l'[encodeur GNN](machine-learning-models-and-training.md#machine-learning-gnns), les prédictions de modèle pour les nœuds figurant dans le graphe d'entraînement et certains fichiers de configuration du point de terminaison d'inférence. Dans les tâches de classification et de régression de nœud, les prédictions de modèle sont précalculées pour les nœuds présents pendant l'entraînement afin de réduire la latence des requêtes. + **Classification et régression d'arête** : pour la prédiction d'une propriété d'une arête, les artefacts incluent également les paramètres de modèle et les intégrations de nœud. Les paramètres du décodeur de modèle sont particulièrement importants pour l'inférence, car nous calculons les prédictions de classification ou de régression d'arête en appliquant le décodeur de modèle aux intégrations des sommets source et de destination d'une arête. + **Prédiction de lien** : pour la prédiction de lien, outre les artefacts générés pour la prédiction d'une propriété d'une arête, le graphe DGL est également inclus en tant qu'artefact, car la prédiction de lien nécessite le graphe d'entraînement pour effectuer des prédictions. L'objectif de la prédiction de lien est de prédire les sommets de destination susceptibles de se combiner avec un sommet source pour former une arête d'un type particulier dans le graphe. Pour ce faire, l'intégration de nœud du sommet source et une représentation apprise pour le type d'arête sont combinées avec les intégrations de nœuds de tous les sommets de destination possibles, afin de produire un score de probabilité d'arête pour chacun des sommets de destination. Les scores sont ensuite triés pour classer les sommets de destination potentiels et renvoyer les meilleurs candidats. Pour chacun des types de tâche, les poids du modèle de réseau de neurones en graphes issu de la bibliothèque DGL sont enregistrés dans l'artefact du modèle. Cela permet à Neptune ML de calculer de nouvelles sorties du modèle à mesure que le graphe change (inférence *inductive*), en plus d'utiliser des prédictions et des intégrations précalculées (inférence *transductive*) pour réduire la latence. ## Génération de nouveaux artefacts de modèle Les artefacts de modèle générés après l'entraînement de modèle dans Neptune ML sont directement liés au processus d'entraînement. Cela signifie que les intégrations et les prédictions précalculées n'existent que pour les entités qui figuraient dans le graphe d'entraînement d'origine. Bien que le mode d'inférence inductive pour les points de terminaison Neptune ML puisse calculer des prédictions pour de nouvelles entités en temps réel, vous souhaiterez peut-être générer des prédictions par lots sur de nouvelles entités sans interroger un point de terminaison. Afin d'obtenir des prédictions de modèle par lots pour de nouvelles entités ajoutées au graphe, les nouveaux artefacts de modèle doivent être recalculés pour les nouvelles données de graphe. Cela se fait à l'aide de la commande `modeltransform`. Vous utilisez la commande `modeltransform` lorsque vous souhaitez uniquement des prédictions par lots sans configurer de point de terminaison, ou lorsque vous souhaitez générer toutes les prédictions afin de pouvoir les réécrire dans le graphe. Étant donné que l'entraînement de modèle effectue implicitement une transformation de modèle à la fin du processus d'entraînement, les artefacts de modèle sont toujours recalculés sur les données de graphe d'entraînement par une tâche d'entraînement. Toutefois, la commande `modeltransform` peut également calculer des artefacts de modèle sur des données de graphe qui n'ont pas été utilisées pour l'entraînement d'un modèle. Pour ce faire, les nouvelles données de graphe doivent être traitées à l'aide des mêmes encodages de fonctionnalité que les données de graphe d'origine et doivent adhérer au même schéma de graphe. Vous pouvez effectuer cela en commençant par créer une nouvelle tâche de traitement de données qui constitue un clone de la tâche de traitement de données exécutée sur les données de graphe d'entraînement d'origine, puis en l'exécutant sur les nouvelles données de graphe (voir [Traitement de données de graphe mises à jour pour Neptune ML](machine-learning-on-graphs-processing.md#machine-learning-on-graphs-processing-updated)). Ensuite, appelez la commande `modeltransform` avec le nouvel identifiant `dataProcessingJobId` et l'ancien identifiant `modelTrainingJobId` pour recalculer les artefacts de modèle sur les données de graphe mises à jour. Pour la prédiction d'une propriété d'un nœud, les intégrations et les prédictions de nœud sont recalculées sur les nouvelles données de graphe, même pour les nœuds présents dans le graphe d'entraînement d'origine. Pour la prédiction d'une propriété d'arête et la prédiction de lien, les intégrations de nœud sont également recalculées et remplacent de la même manière toutes les intégrations de nœud existantes. Pour recalculer les intégrations de nœud, Neptune ML applique l'encodeur GNN appris à partir du modèle entraîné précédent aux nœuds des nouvelles données de graphe avec leurs nouvelles fonctionnalités. Pour les nœuds dépourvus de fonctionnalités, les représentations initiales apprises à partir de l'entraînement de modèle d'origine sont réutilisées. Pour les nouveaux nœuds dépourvus de fonctionnalités et qui n'étaient pas présents dans le graphe d'entraînement d'origine, Neptune ML initialise leur représentation comme la moyenne des représentations de nœud initiales apprises de ce type de nœud présentes dans le graphe d'entraînement d'origine. Cela peut entraîner une baisse des performances dans les prédictions de modèle si de nombreux nouveaux nœuds n'ont pas de fonctionnalités, car ils seront tous initialisés selon l'intégration initiale moyenne pour ce type de nœud. Si votre modèle est entraîné avec `concat-node-embed` défini sur true, les représentations de nœud initiales sont créées en concaténant les fonctionnalités de nœud avec la représentation initiale pouvant être apprise. Ainsi, pour le graphe mis à jour, la représentation de nœud initiale des nouveaux nœuds utilise également les intégrations de nœud initiales moyennes, concaténées avec les nouvelles fonctionnalités de nœud. En outre, les suppressions de nœuds ne sont actuellement pas prises en charge. Si des nœuds ont été supprimés dans le graphe mis à jour, vous devez réentraîner le modèle sur les données de graphe mises à jour. Le recalcul des artefacts de modèle réutilise les paramètres de modèle appris sur un nouveau graphe et doit être effectué uniquement lorsque le nouveau graphe est très similaire à l'ancien. Si votre nouveau graphe n'est pas suffisamment similaire, vous devez réentraîner le modèle pour obtenir des performances de modèle similaires sur les nouvelles données de graphe. Ce qui constitue une similitude suffisante dépend de la structure de vos données de graphe, mais en règle générale, vous devez réentraîner votre modèle si vos nouvelles données diffèrent de plus de 10 à 20 % des données de graphe d'entraînement d'origine. Pour les graphes où tous les nœuds ont des fonctionnalités, le seuil supérieur (20 % de différence) s'applique, mais pour les graphes où de nombreux nœuds n'ont pas de fonctionnalités et où les nouveaux nœuds ajoutés au graphe n'ont pas de propriétés, le seuil inférieur (10 % de différence) peut même s'avérer trop élevé. Consultez [Commande modeltransform](machine-learning-api-modeltransform.md) pour plus d'informations sur les tâches de transformation de modèle. # Modèles personnalisés dans Neptune ML **Note** La prise en charge des modèles personnalisés de Neptune ML repose sur une ancienne version de Python 3. Pour créer et exécuter des modèles GNN personnalisés avec des up-to-date dépendances, utilisez [GraphStorm on SageMaker](https://graphstorm.readthedocs.io/en/v0.3.1/cli/model-training-inference/distributed/sagemaker.html). L'[inférence inductive en temps réel](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) n'est actuellement pas prise en charge pour les modèles personnalisés. Neptune ML vous permet de définir vos propres implémentations de modèle personnalisé à l'aide de Python. Vous pouvez entraîner et déployer des modèles personnalisés à l'aide de l'infrastructure Neptune ML d'une manière très similaire à celle employée pour les modèles intégrés, et vous pouvez les utiliser pour obtenir des prédictions par le biais de requêtes de graphe. Vous pouvez commencer à implémenter votre propre modèle personnalisé en Python en suivant les [exemples de la boîte à outils Neptune ML](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/) et en utilisant les composants de modèle fournis dans la boîte à outils Neptune ML. Les sections suivantes fournissent davantage de détails. **Contents** + [Vue d'ensemble des modèles personnalisés dans Neptune ML](machine-learning-custom-model-overview.md) + [Quand utiliser un modèle personnalisé dans Neptune ML](machine-learning-custom-model-overview.md#machine-learning-custom-models-when-to-use) + [Flux de travail pour le développement et l'utilisation d'un modèle personnalisé dans Neptune ML](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow) + [Développement de modèle personnalisé dans Neptune ML](machine-learning-custom-model-development.md) + [Développement d'un script d'entraînement de modèle personnalisé dans Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-training-script) + [Développement d'un script de transformation de modèle personnalisé dans Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-transform-script) + [Fichier `model-hpo-configuration.json` personnalisé dans Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-hpo-configuration-file) + [Test local de l'implémentation de votre modèle personnalisé dans Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-testing) # Vue d'ensemble des modèles personnalisés dans Neptune ML ## Quand utiliser un modèle personnalisé dans Neptune ML Les modèles intégrés de Neptune ML traitent toutes les tâches standard prises en charge par Neptune ML. Toutefois, dans certains cas, vous pouvez souhaiter disposer d'un contrôle plus précis sur le modèle pour une tâche particulière ou avoir besoin de personnaliser le processus d'entraînement de modèle. Un modèle personnalisé est par exemple approprié dans les cas suivants : + L'encodage des fonctionnalités pour les fonctionnalités de texte de très grands modèles de texte doit être exécuté sur le GPU. + Vous souhaitez utiliser votre propre modèle de réseau de neurones en graphes (GNN) personnalisé, développé dans la bibliothèque Deep Graph Library (DGL). + Vous souhaitez utiliser des modèles tabulaires ou des modèles d'ensemble pour la classification et la régression de nœud. ## Flux de travail pour le développement et l'utilisation d'un modèle personnalisé dans Neptune ML La prise en charge des modèles personnalisés dans Neptune ML est conçue pour s'intégrer parfaitement aux flux de travail Neptune ML existants. Elle fonctionne en exécutant du code personnalisé dans votre module source sur l'infrastructure de Neptune ML pour entraîner le modèle. Comme c'est le cas pour un mode intégré, Neptune ML lance automatiquement une tâche de HyperParameter réglage par SageMaker IA et sélectionne le meilleur modèle en fonction de la métrique d'évaluation. Il utilise ensuite l'implémentation fournie dans votre module source pour générer des artefacts de modèle à déployer. L'exportation des données, la configuration de l'entraînement et le prétraitement des données sont les mêmes pour un modèle personnalisé que pour un modèle intégré. Après le prétraitement des données, vous pouvez développer et tester de manière itérative et interactive l'implémentation de votre modèle personnalisé à l'aide de Python. Lorsque votre modèle est prêt pour la production, vous pouvez charger le module Python obtenu sur Amazon S3 comme suit : ``` aws s3 cp --recursive (source path to module) s3://(bucket name)/(destination path for your module) ``` Vous pouvez ensuite utiliser le flux de travail de données normal [par défaut](machine-learning-overview.md#machine-learning-overview-starting-workflow) ou [incrémentiel](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) pour déployer le modèle en production, à quelques différences près. Pour l'entraînement de modèle à l'aide d'un modèle personnalisé, vous devez fournir un objet JSON `customModelTrainingParameters` à l'API d'entraînement de modèle de Neptune ML afin de garantir que votre code personnalisé est utilisé. Les champs présents dans l'objet `customModelTrainingParameters` sont les suivants : + **`sourceS3DirectoryPath`** : (*obligatoire*) chemin de l'emplacement Amazon S3 où se trouve le module Python implémentant votre modèle. Il doit pointer vers un emplacement Amazon S3 existant valide contenant, au minimum, un script d'entraînement, un script de transformation et un fichier `model-hpo-configuration.json`. + **`trainingEntryPointScript`** : (*facultatif*) nom du point d'entrée dans votre module d'un script qui effectue l'entraînement de modèle et utilise les hyperparamètres comme arguments de ligne de commande, y compris les hyperparamètres fixes. *Par défaut* : `training.py`. + **`transformEntryPointScript`** : (*facultatif*) nom du point d'entrée dans le module d'un script qui doit être exécuté une fois que le modèle le plus approprié issu de la recherche par hyperparamètres a été identifié, afin de calculer les artefacts de modèle nécessaires au déploiement du modèle. Il devrait pouvoir s'exécuter sans arguments de ligne de commande. *Par défaut* : `transform.py`. Par exemple : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "modelName": "custom", "customModelTrainingParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "trainingEntryPointScript": "(your training script entry-point name in the Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` De même, pour activer une transformation de modèle personnalisée, vous devez fournir un objet JSON `customModelTransformParameters` à l'API de transformation de modèle de Neptune ML, avec des valeurs de champs compatibles avec les paramètres de modèle enregistrés à partir de la tâche d'entraînement. L'objet `customModelTransformParameters` contient les champs suivants : + **`sourceS3DirectoryPath`** : (*obligatoire*) chemin de l'emplacement Amazon S3 où se trouve le module Python implémentant votre modèle. Il doit pointer vers un emplacement Amazon S3 existant valide contenant, au minimum, un script d'entraînement, un script de transformation et un fichier `model-hpo-configuration.json`. + **`transformEntryPointScript`** : (*facultatif*) nom du point d'entrée dans le module d'un script qui doit être exécuté une fois que le modèle le plus approprié issu de la recherche par hyperparamètres a été identifié, afin de calculer les artefacts de modèle nécessaires au déploiement du modèle. Il devrait pouvoir s'exécuter sans arguments de ligne de commande. *Par défaut* : `transform.py`. Par exemple : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltransform -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "trainingJobName" : "(name of a completed SageMaker AI training job)", "modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/" "customModelTransformParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` # Développement de modèle personnalisé dans Neptune ML Une bonne manière de démarrer le développement de modèle personnalisé consiste à suivre les [exemples de la boîte à outils Neptune ML](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/introduction) pour structurer et écrire votre module d'entraînement. La boîte à outils Neptune ML implémente également des composants de modèle ML de graphe modulaire dans l'élément [modelzoo](https://github.com/awslabs/neptuneml-toolkit/tree/main/src/neptuneml_toolkit/modelzoo) que vous pouvez empiler et utiliser pour créer votre modèle personnalisé. En outre, la boîte à outils fournit des fonctions utilitaires qui vous aident à générer les artefacts nécessaires pendant l'entraînement de modèle et la transformation de modèle. Vous pouvez importer ce package Python dans votre implémentation personnalisée. Toutes les fonctions ou tous les modules fournis dans la boîte à outils sont également disponibles dans l'environnement d'entraînement Neptune ML. Si votre module Python possède des dépendances externes supplémentaires, vous pouvez les inclure en créant un fichier `requirements.txt` dans le répertoire de votre module. Les packages répertoriés dans le fichier `requirements.txt` seront ensuite installés avant l'exécution de votre script d'entraînement. Au minimum, le module Python qui implémente votre modèle personnalisé doit contenir les éléments suivants : + Un point d'entrée de script d'entraînement + Un point d'entrée de script de transformation + Un fichier `model-hpo-configuration.json` ## Développement d'un script d'entraînement de modèle personnalisé dans Neptune ML Votre script d'entraînement de modèle personnalisé doit être un script Python exécutable, comme l'exemple [https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py) de la boîte à outils Neptune ML. Il doit accepter les noms et les valeurs des hyperparamètres en tant qu'arguments de ligne de commande. Pendant l'entraînement de modèle, les noms des hyperparamètres sont obtenus à partir du fichier `model-hpo-configuration.json`. Les valeurs des hyperparamètres se situent dans la plage des hyperparamètres valides si l'hyperparamètre est réglable, ou prennent la valeur d'hyperparamètre par défaut s'il n'est pas réglable. Votre script d'entraînement est exécuté sur une instance d'entraînement SageMaker AI en utilisant une syntaxe comme celle-ci : ``` python3 (script entry point) --(1st parameter) (1st value) --(2nd parameter) (2nd value) (...) ``` Pour toutes les tâches, Neptune ML AutoTrainer envoie plusieurs paramètres requis à votre script d'entraînement en plus des hyperparamètres que vous spécifiez, et votre script doit être capable de gérer ces paramètres supplémentaires pour fonctionner correctement. Ces paramètres obligatoires supplémentaires varient quelque peu en fonction de la tâche : **Pour la classification de nœud ou la régression de nœud** + **`task`** : type de tâche utilisé en interne par Neptune ML. Pour la classification de nœud, il s'agit de `node_class` et, pour la régression de nœud, il s'agit de `node_regression`. + **`model`** : nom du modèle utilisé en interne par Neptune ML, à savoir `custom` dans ce cas. + **`name`** : nom de la tâche utilisée en interne par Neptune ML, à savoir `node_class-custom` pour la classification de nœud dans ce cas, et `node_regression-custom` pour la régression de nœud. + **`target_ntype`** : nom du type de nœud pour la classification ou la régression. + **`property`** : nom de la propriété de nœud pour la classification ou la régression. **Pour la prédiction de lien** + **`task`** : type de tâche utilisé en interne par Neptune ML. Pour la prédiction de lien, il s'agit de `link_predict`. + **`model`** : nom du modèle utilisé en interne par Neptune ML, à savoir `custom` dans ce cas. + **`name`** : nom de la tâche utilisée en interne par Neptune ML, à savoir `link_predict-custom` dans ce cas. **Pour la classification d'arête ou la régression d'arête** + **`task`** : type de tâche utilisé en interne par Neptune ML. Pour la classification d'arête, il s'agit de `edge_class` et, pour la régression d'arête, il s'agit de `edge_regression`. + **`model`** : nom du modèle utilisé en interne par Neptune ML, à savoir `custom` dans ce cas. + **`name`** : nom de la tâche utilisée en interne par Neptune ML, à savoir `edge_class-custom` pour la classification d'arête dans ce cas, et `edge_regression-custom` pour la régression d'arête. + **`target_etype`** : nom du type d'arête pour la classification ou la régression. + **`property`** : nom de la propriété d'arête pour la classification ou la régression. Votre script doit enregistrer les paramètres du modèle, ainsi que tous les autres artefacts qui seront nécessaires à la fin de l'entraînement. Vous pouvez utiliser les fonctions utilitaires de la boîte à outils Neptune ML pour déterminer l'emplacement des données de graphe traitées, l'emplacement où les paramètres de modèle doivent être enregistrés et les périphériques GPU disponibles sur l'instance d'entraînement. Consultez l'exemple de script d'entraînement [train.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py) pour des exemples d'utilisation de ces fonctions utilitaires. ## Développement d'un script de transformation de modèle personnalisé dans Neptune ML Un script de transformation est nécessaire pour tirer parti du [flux de travail incrémentiel](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) Neptune ML pour l'inférence de modèle sur des graphes évolutifs sans avoir à réentraîner le modèle. Même si tous les artefacts nécessaires au déploiement de modèle sont générés par le script d'entraînement, vous devez tout de même fournir un script de transformation si vous souhaitez générer des modèles mis à jour sans réentraîner le modèle. **Note** L'[inférence inductive en temps réel](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) n'est actuellement pas prise en charge pour les modèles personnalisés. Votre script de transformation de modèle personnalisé doit être un script Python exécutable, comme l'exemple de script [transform.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) de la boîte à outils Neptune ML. Comme ce script est invoqué pendant l'entraînement de modèle sans arguments de ligne de commande, tous les arguments de ligne de commande acceptés par le script doivent avoir les valeurs par défaut. Le script s'exécute sur une instance d'entraînement SageMaker AI avec une syntaxe comme celle-ci : ``` python3 (your transform script entry point) ``` Votre script de transformation aura besoin de diverses informations, telles que : + L'emplacement des données du graphe traité. + L'emplacement où les paramètres du modèle sont enregistrés et où les nouveaux artefacts de modèle doivent être enregistrés. + Les appareils disponibles sur l'instance. + Les hyperparamètres qui ont généré le meilleur modèle. Ces entrées sont obtenues à l'aide des fonctions utilitaires Neptune ML que votre script peut appeler. Consultez l'exemple de script [transform.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) de la boîte à outils pour obtenir des exemples de la manière de procéder. Le script doit enregistrer les intégrations de nœuds, les mappages d'ID de nœud et tous les autres artefacts nécessaires au déploiement du modèle pour chaque tâche. Consultez la [documentation sur les artefacts de modèle](machine-learning-model-artifacts.md) pour plus d'informations sur les artefacts de modèle requis pour les différentes tâches Neptune ML. ## Fichier `model-hpo-configuration.json` personnalisé dans Neptune ML Le fichier `model-hpo-configuration.json` définit les hyperparamètres de votre modèle personnalisé. Il est au même [format](machine-learning-customizing-hyperparams.md) que le fichier `model-hpo-configuration.json` utilisé avec les modèles intégrés de Neptune ML et il a priorité sur la version générée automatiquement par Neptune ML et chargée à l'emplacement de vos données traitées. Lorsque vous ajoutez un nouvel hyperparamètre à votre modèle, vous devez également ajouter une entrée pour l'hyperparamètre dans ce fichier afin que l'hyperparamètre soit transmis à votre script d'entraînement. Vous devez fournir une plage pour un hyperparamètre si vous souhaitez qu'il soit réglable et le définir en tant que paramètre `tier-1`, `tier-2` ou `tier-3`. L'hyperparamètre sera réglé si le nombre total de tâches d'entraînement configurées permet de régler les hyperparamètres de son niveau. Pour un paramètre non réglable, vous devez fournir une valeur par défaut et ajouter l'hyperparamètre dans la section `fixed-param` du fichier. Consultez le [fichier d'exemple `model-hpo-configuration.json`](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/model-hpo-configuration.json) de la boîte à outils pour obtenir un exemple de la procédure à suivre. Vous devez également fournir la définition de métrique que la tâche HyperParameter d'optimisation de l' SageMaker IA utilisera pour évaluer les modèles candidats entraînés. Pour ce faire, vous devez ajouter un objet JSON `eval_metric` dans le fichier `model-hpo-configuration.json` comme suit : ``` "eval_metric": { "tuning_objective": { "MetricName": "(metric_name)", "Type": "Maximize" }, "metric_definitions": [ { "Name": "(metric_name)", "Regex": "(metric regular expression)" } ] }, ``` Le `metric_definitions` tableau de l'`eval_metric`objet répertorie les objets de définition des métriques pour chaque métrique que vous souhaitez que l' SageMaker IA extrait de l'instance d'apprentissage. Chaque objet de définition de métrique possède une clé `Name` qui vous permet de donner un nom à la métrique (par exemple « précision », « f1 », etc.). La clé `Regex` vous permet de fournir une chaîne d'expression régulière correspondant à la manière dont cette métrique particulière est imprimée dans les journaux d'entraînement. Consultez la [page SageMaker AI HyperParameter Tuning](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-metrics.html) pour plus de détails sur la définition des métriques. L'objet `tuning_objective` dans `eval_metric` vous permet ensuite de spécifier quelle métrique de `metric_definitions` doit être utilisée comme métrique d'évaluation servant de métrique d'objectif pour l'optimisation des hyperparamètres. La valeur de `MetricName` doit correspondre à la valeur d'un élément `Name` dans l'une des définitions de `metric_definitions`. La valeur de `Type` doit être « Maximiser » ou « Minimiser » selon que la métrique doit être interprétée comme greater-is-better (comme « précision ») ou less-is-better (comme « mean-squared-error »). Des erreurs dans cette section du `model-hpo-configuration.json` fichier peuvent entraîner l'échec de la tâche d'API d'entraînement du modèle Neptune ML, car la tâche SageMaker AI HyperParameter Tuning ne sera pas en mesure de sélectionner le meilleur modèle. ## Test local de l'implémentation de votre modèle personnalisé dans Neptune ML Vous pouvez utiliser l'environnement Conda de la boîte à outils Neptune ML pour exécuter votre code localement afin de tester et de valider votre modèle. Si vous effectuez le développement sur une instance de bloc-notes Neptune, cet environnement Conda sera préinstallé sur l'instance de bloc-notes Neptune. Si vous effectuez le développement sur une autre instance, vous devez suivre les [instructions de configuration locale](https://github.com/awslabs/neptuneml-toolkit#local-installation) (langue française non garantie) de la boîte d'outils Neptune ML. L'environnement Conda reproduit avec précision l'environnement dans lequel votre modèle sera exécuté lorsque vous appellerez l'[API d'entraînement de modèle](machine-learning-api-modeltraining.md). Tous les exemples de scripts d'entraînement et de transformation vous permettent de transmettre un indicateur `--local` de ligne de commande pour exécuter les scripts dans un environnement local afin de faciliter le débogage. Il s'agit d'une bonne pratique lors du développement de votre propre modèle, car cela vous permet de tester l'implémentation de votre modèle de manière interactive et itérative. Lors de l'entraînement de modèle dans l'environnement d'entraînement de production Neptune ML, ce paramètre est omis. # Création d'un point de terminaison d'inférence à interroger Un point de terminaison d'inférence vous permet d'interroger un modèle spécifique construit par le processus d'entraînement de modèle. Le point de terminaison se rattache au modèle le plus performant d'un type donné que le processus d'entraînement a pu générer. Le point de terminaison est alors en mesure d'accepter les requêtes Gremlin de Neptune et de renvoyer les prédictions de ce modèle pour les entrées dans les requêtes. Une fois que vous avez créé un point de terminaison d'inférence, celui-ci reste actif jusqu'à ce que vous le supprimiez. ## Gestion des points de terminaison d'inférence pour Neptune ML Une fois que vous avez terminé l'entraînement de modèle sur les données que vous avez exportées depuis Neptune, vous pouvez créer un point de terminaison d'inférence à l'aide d'une commande `curl` (ou `awscurl`), telle que la suivante : ``` curl \ -X POST https://(your Neptune endpoint)/ml/endpoints -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique ID for the new endpoint)", "mlModelTrainingJobId": "(the model-training job-id of a completed job)" }' ``` Vous pouvez également créer un point de terminaison d'inférence à partir d'un modèle créé par une tâche de transformation de modèle terminée, à peu près de la même manière : ``` curl \ -X POST https://(your Neptune endpoint)/ml/endpoints -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique ID for the new endpoint)", "mlModelTransformJobId": "(the model-transform job-id of a completed job)" }' ``` Les détails de l'utilisation de ces commandes sont fournis dans [Commande endpoints](machine-learning-api-endpoints.md), ainsi que des informations sur la façon d'obtenir le statut d'un point de terminaison, la façon de supprimer un point de terminaison et de répertorier tous les points de terminaison d'inférence. # Requêtes d'inférence dans Neptune ML Vous pouvez utiliser Gremlin ou SPARQL pour interroger un point de terminaison d'inférence Neptune ML. Toutefois, l'[inférence inductive en temps réel](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) n'est actuellement prise en charge que pour les requêtes Gremlin. # Requêtes d'inférence Gremlin dans Neptune ML Comme décrit dans [Fonctionnalités de Neptune ML](machine-learning.md#machine-learning-capabilities), Neptune ML prend en charge les modèles d'entraînement qui peuvent effectuer les types de tâches d'inférence suivants : + **Classification de nœud** : prédit la fonctionnalité catégorielle d'une propriété de sommet. + **Régression de nœud** : prédit une propriété numérique d'un sommet. + **Classification d'arête** : prédit la fonctionnalité catégorielle d'une propriété d'arête. + **Régression d'arête** : prédit une propriété numérique d'une arête. + **Prédiction des liens** : prédit les nœuds de destination à partir d'un nœud source et d'une arête sortante, ou les nœuds sources à partir d'un nœud de destination et d'une arête entrante. Nous pouvons illustrer ces différentes tâches à l'aide d'exemples utilisant le jeu de [données de MovieLens 100 000 unités](https://grouplens.org/datasets/movielens/100k/) fourni par [GroupLens Research](https://grouplens.org/datasets/movielens/). Ce jeu de données comprend des films, des utilisateurs et des évaluations de ces films par les utilisateurs, à partir desquels nous avons créé un graphe de propriétés comme celui-ci : ![\[Exemple de graphique des propriétés d'un film à l'aide du jeu de MovieLens données de 100 000\]](http://docs.aws.amazon.com/fr_fr/neptune/latest/userguide/images/movie_property_graph_example.png) **Classification de nœud** : dans le jeu de données ci-dessus, `Genre` est un type de sommet connecté au type de sommet `Movie` par l'arête `included_in`. Toutefois, si nous modifions le jeu de données pour faire de `Genre` une fonctionnalité [catégorielle](https://en.wikipedia.org/wiki/Categorical_variable) du type de sommet `Movie`, le problème de la déduction de `Genre` pour les nouveaux films ajoutés au graphe de connaissances peut être résolu à l'aide de modèles de classification de nœud. **Régression de nœud** : si nous considérons le type de sommet `Rating`, qui possède des propriétés telles que `timestamp` et `score`, le problème de l'inférence de la valeur numérique `Score` pour un élément `Rating` peut être résolu à l'aide de modèles de régression de nœud. **Classification des arêtes** : De même, pour une `Rated` arête, si nous avons une propriété `Scale` qui peut avoir l'une des valeurs,,,,,`Love`,,`Like`,`Dislike`,, `Neutral``Hate`, alors le problème de la déduction de l'`Rated`arête `Scale` pour une nouvelle movies/ratings peut être résolu à l'aide de modèles de classification des arêtes. **Régression d'arête** : de façon similaire, pour la même arête `Rated`, si une propriété `Score` contient une valeur numérique pour l'évaluation, celle-ci peut être déduite à partir des modèles de régression d'arête. **Prédiction des liens** : des problèmes tels que la recherche des dix utilisateurs susceptibles d'évaluer le mieux un film donné ou la recherche des dix films qu'un utilisateur donné a le plus de chance d'évaluer relèvent de la prédiction des liens. **Note** Pour les cas d'utilisation de Neptune ML, nous disposons d'un ensemble très complet de blocs-notes conçus pour favoriser la compréhension pratique de chaque cas d'utilisation. Vous pouvez créer ces blocs-notes avec votre cluster Neptune en utilisant le modèle [Neptune CloudFormation ML pour créer un cluster Neptune ML](machine-learning-quick-start.md). Ces blocs-notes sont également disponibles sur [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning). **Topics** + [Prédicats Neptune ML utilisés dans les requêtes d'inférence Gremlin](machine-learning-gremlin-inference-query-predicates.md) + [Requêtes de classification de nœud Gremlin dans Neptune ML](machine-learning-gremlin-vertex-classification-queries.md) + [Requêtes de régression de nœud Gremlin dans Neptune ML](machine-learning-gremlin-vertex-regression-queries.md) + [Requêtes de classification d'arête Gremlin dans Neptune ML](machine-learning-gremlin-edge-classification-queries.md) + [Requêtes de régression d'arête Gremlin dans Neptune ML](machine-learning-gremlin-edge-regression.md) + [Requêtes de prédiction de lien Gremlin utilisant des modèles de prédiction de lien dans Neptune ML](machine-learning-gremlin-link-prediction-queries.md) + [Liste des exceptions pour les requêtes d'inférence Gremlin de Neptune ML](machine-learning-gremlin-exceptions.md) # Prédicats Neptune ML utilisés dans les requêtes d'inférence Gremlin ## `Neptune#ml.deterministic` Ce prédicat est une option pour les requêtes d'inférence inductive, c'est-à-dire pour les requêtes qui incluent le prédicat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference). Lors de l'utilisation de l'inférence inductive, le moteur Neptune crée le sous-graphe approprié pour évaluer le modèle GNN entraîné, et les exigences de ce sous-graphe dépendent des paramètres du modèle final. Plus précisément, le paramètre `num-layer` détermine le nombre de sauts de traversée depuis les arêtes ou les nœuds cibles, et le paramètre `fanouts` spécifie le nombre de voisins à échantillonner à chaque saut (voir [Paramètres HPO](machine-learning-customizing-hyperparams.md)). Par défaut, les requêtes d'inférence inductive s'exécutent en mode non déterministe, dans lequel Neptune construit le voisinage de manière aléatoire. Lors de la réalisation de prédictions, cet échantillonnage normal de voisins aléatoires fournit parfois des prédictions différentes. Lorsque vous incluez `Neptune#ml.deterministic` dans une requête d'inférence inductive, le moteur Neptune tente d'échantillonner les voisins de manière déterministe afin que plusieurs invocations de la même requête renvoient les mêmes résultats à chaque fois. Il n'est toutefois pas possible de garantir des résultats totalement déterministes, car les modifications apportées au graphe sous-jacent et les artefacts des systèmes distribués peuvent toujours introduire des fluctuations. Vous incluez le prédicat `Neptune#ml.deterministic` dans une requête comme suit : ``` .with("Neptune#ml.deterministic") ``` Si le prédicat `Neptune#ml.deterministic` est inclus dans une requête qui n'inclut pas également `Neptune#ml.inductiveInference`, il est tout simplement ignoré. ## `Neptune#ml.disableInductiveInferenceMetadataCache` Ce prédicat est une option pour les requêtes d'inférence inductive, c'est-à-dire pour les requêtes qui incluent le prédicat [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference). Pour les requêtes d'inférence inductive, Neptune utilise un fichier de métadonnées stocké dans Amazon S3 pour décider du nombre de sauts et de la diffusion en éventail lors de la construction du voisinage. Neptune met normalement en cache les métadonnées de ce modèle pour éviter de récupérer le fichier à plusieurs reprises depuis Amazon S3. La mise en cache peut être désactivée en incluant le prédicat `Neptune#ml.disableInductiveInferenceMetadataCache` dans la requête. Bien que Neptune puisse être plus lent à récupérer les métadonnées directement depuis Amazon S3, cela est utile lorsque le point de terminaison SageMaker AI a été mis à jour après un réentraînement ou une transformation et que le cache est périmé. Vous incluez le prédicat `Neptune#ml.disableInductiveInferenceMetadataCache` dans une requête comme suit : ``` .with("Neptune#ml.disableInductiveInferenceMetadataCache") ``` Voici à quoi peut ressembler un exemple de requête dans un bloc-notes Jupyter : ``` %%gremlin g.with("Neptune#ml.endpoint", "ep1") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .with("Neptune#ml.disableInductiveInferenceMetadataCache") .V('101').properties("rating") .with("Neptune#ml.regression") .with("Neptune#ml.inductiveInference") ``` ## `Neptune#ml.endpoint` Le prédicat `Neptune#ml.endpoint` est utilisé dans une étape `with()` pour spécifier le point de terminaison d'inférence, si nécessaire : ``` .with("Neptune#ml.endpoint", "the model's SageMaker AI inference endpoint") ``` Vous pouvez identifier le point de terminaison par son `id` ou son URL. Par exemple : ``` .with( "Neptune#ml.endpoint", "node-classification-movie-lens-endpoint" ) ``` Ou: ``` .with( "Neptune#ml.endpoint", "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/node-classification-movie-lens-endpoint/invocations" ) ``` **Note** Si vous [définissez le paramètre `neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) dans votre groupe de paramètres de cluster de bases de données Neptune sur l'`id` ou l'URL du point de terminaison, vous n'avez pas besoin d'inclure le prédicat `Neptune#ml.endpoint` dans chaque requête. ## `Neptune#ml.iamRoleArn` `Neptune#ml.iamRoleArn`est utilisé dans une `with()` étape pour spécifier l'ARN du rôle IAM d'exécution de l' SageMaker IA, si nécessaire : ``` .with("Neptune#ml.iamRoleArn", "the ARN for the SageMaker AI execution IAM role") ``` Pour plus d'informations sur la création du rôle IAM d'exécution de l' SageMaker IA, consultez[Création d'un NeptuneSageMaker IAMRole rôle personnalisé](machine-learning-manual-setup.md#ml-manual-setup-sm-role). **Note** Si vous [définissez le `neptune_ml_iam_role` paramètre](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) dans le groupe de paramètres de votre cluster de base de données Neptune sur l'ARN de votre rôle IAM d'exécution SageMaker AI, vous n'avez pas besoin d'inclure le `Neptune#ml.iamRoleArn` prédicat dans chaque requête. ## Neptune\$1ml.inductiveInference L'inférence transductive est activée par défaut dans Gremlin. Pour effectuer une requête d'[inférence inductive en temps réel](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), incluez le prédicat `Neptune#ml.inductiveInference` comme suit : ``` .with("Neptune#ml.inductiveInference") ``` Si votre graphe est dynamique, l'inférence inductive est souvent le meilleur choix, mais si votre graphe est statique, l'inférence transductive est plus rapide et plus efficace. ## `Neptune#ml.limit` Le prédicat `Neptune#ml.limit` limite éventuellement le nombre de résultats renvoyés par entité : ``` .with( "Neptune#ml.limit", 2 ) ``` Par défaut, la limite est de 1 et le nombre maximal pouvant être défini est de 100. ## `Neptune#ml.threshold` Le prédicat `Neptune#ml.threshold` établit éventuellement un seuil limite pour les scores de résultat : ``` .with( "Neptune#ml.threshold", 0.5D ) ``` Cela vous permet de rejeter tous les résultats dont les scores sont inférieurs au seuil spécifié. ## `Neptune#ml.classification` Le `Neptune#ml.classification` prédicat est attaché à l'`properties()`étape visant à établir que les propriétés doivent être extraites du point de terminaison SageMaker AI du modèle de classification des nœuds : ``` .properties( "property key of the node classification model" ).with( "Neptune#ml.classification" ) ``` ## `Neptune#ml.regression` Le `Neptune#ml.regression` prédicat est attaché à l'`properties()`étape visant à établir que les propriétés doivent être extraites du point de terminaison SageMaker AI du modèle de régression des nœuds : ``` .properties( "property key of the node regression model" ).with( "Neptune#ml.regression" ) ``` ## `Neptune#ml.prediction` Le prédicat `Neptune#ml.prediction` est attaché aux étapes `in()` et `out()` pour établir qu'il s'agit d'une requête de prédiction de lien : ``` .in("edge label of the link prediction model").with("Neptune#ml.prediction").hasLabel("target node label") ``` ## `Neptune#ml.score` Le prédicat `Neptune#ml.score` est utilisé dans les requêtes de classification de nœud ou d'arête de Gremlin pour extraire un score de confiance de machine learning. Le prédicat `Neptune#ml.score` doit être transmis avec le prédicat de requête à l'étape `properties()` afin d'obtenir un score de confiance ML pour les requêtes de classification de nœud ou d'arête. Vous pouvez trouver un exemple de classification de nœud avec [d'autres exemples de classification de nœud](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries), et un exemple de classification d'arête dans la section [Classification d'arête](machine-learning-gremlin-edge-classification-queries.md). # Requêtes de classification de nœud Gremlin dans Neptune ML Pour la classification de nœud Gremlin dans Neptune ML : + Le modèle est entraîné sur une seule propriété des sommets. L'ensemble des valeurs uniques de cette propriété est appelé « ensemble de classes de nœuds », ou simplement « classes ». + La classe de nœuds ou la valeur de propriété catégorielle de la propriété d'un sommet peut être déduite du modèle de classification de nœud. Ceci est utile lorsque cette propriété n'est pas déjà attachée au sommet. + Pour extraire une ou plusieurs classes d'un modèle de classification de nœud, vous devez utiliser l'étape `with()` avec le prédicat `Neptune#ml.classification` pour configurer l'étape `properties()`. Le format de sortie est similaire à ce à quoi vous vous attendriez s'il s'agissait de propriétés de sommet. **Note** La classification de nœud ne fonctionne qu'avec les valeurs de propriété de type string. Cela signifie que des valeurs de propriété numériques telles que `0` ou `1` ne sont pas prises en charge, alors que les valeurs équivalentes de type string `"0"` et `"1"` le sont. De même, les valeurs de propriété booléenne `true` et `false` ne fonctionnent pas, mais `"true"` et `"false"` fonctionnent. Voici un exemple de requête de classification de nœud : ``` g.with( "Neptune#ml.endpoint","node-classification-movie-lens-endpoint" ) .with( "Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role" ) .with( "Neptune#ml.limit", 2 ) .with( "Neptune#ml.threshold", 0.5D ) .V( "movie_1", "movie_2", "movie_3" ) .properties("genre").with("Neptune#ml.classification") ``` La sortie de cette requête ressemble à ce qui suit : ``` ==>vp[genre->Action] ==>vp[genre->Crime] ==>vp[genre->Comedy] ``` Dans la requête ci-dessus, les étapes `V()` et `properties()` sont utilisées comme suit : L'étape `V()` contient l'ensemble de sommets pour lequel vous souhaitez extraire les classes du modèle de classification de nœud : ``` .V( "movie_1", "movie_2", "movie_3" ) ``` L'étape `properties()` contient la clé sur laquelle le modèle a été entraîné et contient `.with("Neptune#ml.classification")` pour indiquer qu'il s'agit d'une requête d'inférence ML de classification de nœud. Les clés de propriété multiples ne sont actuellement pas prises en charge dans une étape `properties().with("Neptune#ml.classification")`. Par exemple, la requête suivante lève une exception : ``` g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V( "movie_1", "movie_2", "movie_3" ) .properties("genre", "other_label").with("Neptune#ml.classification") ``` Pour le message d'erreur spécifique, consultez la [liste des exceptions de Neptune ML](machine-learning-gremlin-exceptions.md). Une étape `properties().with("Neptune#ml.classification")` peut être utilisée en combinaison avec l'une quelconque des étapes suivantes : + `value()` + `value().is()` + `hasValue()` + `has(value,"")` + `key()` + `key().is()` + `hasKey()` + `has(key,"")` + `path()` ## Autres requêtes de classification de nœud Si le point de terminaison d'inférence et le rôle IAM correspondant ont tous les deux été enregistrés dans le groupe de paramètres de votre cluster de bases de données, une requête de classification de nœud peut être aussi simple que ceci : ``` g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification") ``` Vous pouvez mélanger des propriétés et des classes de sommets dans une requête en utilisant l'étape `union()` : ``` g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V( "movie_1", "movie_2", "movie_3" ) .union( properties("genre").with("Neptune#ml.classification"), properties("genre") ) ``` Vous pouvez également effectuer une requête illimitée telle que celle-ci : ``` g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V() .properties("genre").with("Neptune#ml.classification") ``` Vous pouvez récupérer les classes de nœuds ainsi que les sommets en utilisant l'étape `select()` associée à l'étape `as()` : ``` g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V( "movie_1", "movie_2", "movie_3" ).as("vertex") .properties("genre").with("Neptune#ml.classification").as("properties") .select("vertex","properties") ``` Vous pouvez également filtrer les classes de nœuds, comme illustré dans ces exemples : ``` g.with("Neptune#ml.endpoint", "node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V( "movie_1", "movie_2", "movie_3" ) .properties("genre").with("Neptune#ml.classification") .has(value, "Horror") g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V( "movie_1", "movie_2", "movie_3" ) .properties("genre").with("Neptune#ml.classification") .has(value, P.eq("Action")) g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V( "movie_1", "movie_2", "movie_3" ) .properties("genre").with("Neptune#ml.classification") .has(value, P.within("Action", "Horror")) ``` Vous pouvez obtenir un score de confiance pour la classification de nœud en utilisant le prédicat `Neptune#ml.score` : ``` g.with("Neptune#ml.endpoint","node-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V( "movie_1", "movie_2", "movie_3" ) .properties("genre", "Neptune#ml.score").with("Neptune#ml.classification") ``` La réponse ressemble alors à ceci : ``` ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.01234567] ==>vp[genre->Crime] ==>vp[Neptune#ml.score->0.543210] ==>vp[genre->Comedy] ==>vp[Neptune#ml.score->0.10101] ``` ## Utilisation de l'inférence inductive dans une requête de classification de nœud Supposons que vous ajoutiez un nouveau nœud à un graphe existant, dans un bloc-notes Jupyter, comme suit : ``` %%gremlin g.addV('label1').property(id,'101').as('newV') .V('1').as('oldV1') .V('2').as('oldV2') .addE('eLabel1').from('newV').to('oldV1') .addE('eLabel2').from('oldV2').to('newV') ``` Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir un genre et un score de confiance reflétant le nouveau nœud : ``` %%gremlin g.with("Neptune#ml.endpoint", "nc-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .V('101').properties("genre", "Neptune#ml.score") .with("Neptune#ml.classification") .with("Neptune#ml.inductiveInference") ``` Toutefois, si vous exécutez la requête plusieurs fois, vous pouvez obtenir des résultats quelque peu différents : ``` # First time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.21365921] ``` Vous pouvez rendre la même requête déterministe : ``` %%gremlin g.with("Neptune#ml.endpoint", "nc-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .V('101').properties("genre", "Neptune#ml.score") .with("Neptune#ml.classification") .with("Neptune#ml.inductiveInference") .with("Neptune#ml.deterministic") ``` Dans ce cas, les résultats sont à peu près les mêmes à chaque fois : ``` # First time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.12345678] ``` # Requêtes de régression de nœud Gremlin dans Neptune ML La régression de nœud est similaire à la classification de nœud, si ce n'est que la valeur déduite du modèle de régression pour chaque nœud est numérique. Vous pouvez utiliser les mêmes requêtes Gremlin pour la régression de nœud que pour la classification de nœud, à l'exception des différences suivantes : + Encore une fois, dans Neptune ML, les nœuds font référence à des sommets. + L'étape `properties()` prend la forme `properties().with("Neptune#ml.regression")` à la place de `properties().with("Neptune#ml.classification")`. + Les prédicats `"Neptune#ml.limit`" et `"Neptune#ml.threshold"` ne sont pas applicables. + Quand vous filtrez sur la valeur, vous devez spécifier une valeur numérique. Voici un exemple de requête de classification de sommet : ``` g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::0123456789:role/sagemaker-role") .V("movie_1","movie_2","movie_3") .properties("revenue").with("Neptune#ml.regression") ``` Vous pouvez filtrer sur la valeur déduite à l'aide d'un modèle de régression, comme illustré dans les exemples suivants : ``` g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("movie_1","movie_2","movie_3") .properties("revenue").with("Neptune#ml.regression") .value().is(P.gte(1600000)) g.with("Neptune#ml.endpoint","node-regression-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("movie_1","movie_2","movie_3") .properties("revenue").with("Neptune#ml.regression") .hasValue(P.lte(1600000D)) ``` ## Utilisation de l'inférence inductive dans une requête de régression de nœud Supposons que vous ajoutiez un nouveau nœud à un graphe existant, dans un bloc-notes Jupyter, comme suit : ``` %%gremlin g.addV('label1').property(id,'101').as('newV') .V('1').as('oldV1') .V('2').as('oldV2') .addE('eLabel1').from('newV').to('oldV1') .addE('eLabel2').from('oldV2').to('newV') ``` Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir une évaluation prenant en compte le nouveau nœud : ``` %%gremlin g.with("Neptune#ml.endpoint", "nr-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .V('101').properties("rating") .with("Neptune#ml.regression") .with("Neptune#ml.inductiveInference") ``` La requête n'étant pas déterministe, elle peut renvoyer des résultats légèrement différents si vous l'exécutez plusieurs fois, en fonction du voisinage : ``` # First time ==>vp[rating->9.1] # Second time ==>vp[rating->8.9] ``` Si vous avez besoin de résultats plus cohérents, vous pouvez rendre la requête déterministe : ``` %%gremlin g.with("Neptune#ml.endpoint", "nc-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .V('101').properties("rating") .with("Neptune#ml.regression") .with("Neptune#ml.inductiveInference") .with("Neptune#ml.deterministic") ``` Désormais, les résultats sont quasiment les mêmes à chaque fois : ``` # First time ==>vp[rating->9.1] # Second time ==>vp[rating->9.1] ``` # Requêtes de classification d'arête Gremlin dans Neptune ML Pour la classification d'arête Gremlin dans Neptune ML : + Le modèle est entraîné sur une seule propriété des arêtes. L'ensemble des valeurs uniques de cette propriété est appelé « ensemble de classes ». + La classe ou la valeur de propriété catégorielle d'une arête peut être déduite du modèle de classification d'arête, ce qui est utile quand cette propriété n'est pas encore attachée à l'arête. + Pour extraire une ou plusieurs classes d'un modèle de classification d'arête, vous devez utiliser l'étape `with()` avec le prédicat `"Neptune#ml.classification"` pour configurer l'étape `properties()`. Le format de sortie est similaire à celui auquel vous vous attendriez s'il s'agissait de propriétés d'arête. **Note** La classification d'arête ne fonctionne qu'avec les valeurs de propriété de type string. Cela signifie que des valeurs de propriété numériques telles que `0` ou `1` ne sont pas prises en charge, alors que les valeurs équivalentes de type string `"0"` et `"1"` le sont. De même, les valeurs de propriété booléenne `true` et `false` ne fonctionnent pas, mais `"true"` et `"false"` fonctionnent. Voici un exemple de requête de classification d'arête qui demande un score de confiance en utilisant le prédicat `Neptune#ml.score` : ``` g.with("Neptune#ml.endpoint","edge-classification-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .E("relationship_1","relationship_2","relationship_3") .properties("knows_by", "Neptune#ml.score").with("Neptune#ml.classification") ``` La réponse ressemble alors à ceci : ``` ==>p[knows_by->"Family"] ==>p[Neptune#ml.score->0.01234567] ==>p[knows_by->"Friends"] ==>p[Neptune#ml.score->0.543210] ==>p[knows_by->"Colleagues"] ==>p[Neptune#ml.score->0.10101] ``` ## Syntaxe d'une requête de classification d'arête Gremlin Pour un graphe simple où `User` représente le nœud de tête et le nœud de queue, et où `Relationship` est l'arête qui les relie, voici un exemple de requête de classification d'arête : ``` g.with("Neptune#ml.endpoint","edge-classification-social-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .E("relationship_1","relationship_2","relationship_3") .properties("knows_by").with("Neptune#ml.classification") ``` La sortie de cette requête ressemble à ce qui suit : ``` ==>p[knows_by->"Family"] ==>p[knows_by->"Friends"] ==>p[knows_by->"Colleagues"] ``` Dans la requête ci-dessus, les étapes `E()` et `properties()` sont utilisées comme suit : + L'étape `E()` contient l'ensemble des arêtes pour lesquelles vous souhaitez extraire les classes du modèle de classification d'arête : ``` .E("relationship_1","relationship_2","relationship_3") ``` + L'étape `properties()` contient la clé sur laquelle le modèle a été entraîné et contient `.with("Neptune#ml.classification")` pour indiquer qu'il s'agit d'une requête d'inférence ML de classification d'arête. Les clés de propriété multiples ne sont actuellement pas prises en charge dans une étape `properties().with("Neptune#ml.classification")`. Par exemple, la requête suivante lève une exception : ``` g.with("Neptune#ml.endpoint","edge-classification-social-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .E("relationship_1","relationship_2","relationship_3") .properties("knows_by", "other_label").with("Neptune#ml.classification") ``` Pour des messages d'erreur spécifiques, consultez [Liste des exceptions pour les requêtes d'inférence Gremlin de Neptune ML](machine-learning-gremlin-exceptions.md). Une étape `properties().with("Neptune#ml.classification")` peut être utilisée en combinaison avec l'une quelconque des étapes suivantes : + `value()` + `value().is()` + `hasValue()` + `has(value,"")` + `key()` + `key().is()` + `hasKey()` + `has(key,"")` + `path()` ## Utilisation de l'inférence inductive dans une requête de classification d'arête Supposons que vous ajoutiez une nouvelle arête à un graphe existant, dans un bloc-notes Jupyter, comme suit : ``` %%gremlin g.V('1').as('fromV') .V('2').as('toV') .addE('eLabel1').from('fromV').to('toV').property(id, 'e101') ``` Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir une échelle prenant en compte la nouvelle arête : ``` %%gremlin g.with("Neptune#ml.endpoint", "ec-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .E('e101').properties("scale", "Neptune#ml.score") .with("Neptune#ml.classification") .with("Neptune#ml.inductiveInference") ``` La requête n'étant pas déterministe, elle peut renvoyer des résultats légèrement différents si vous l'exécutez plusieurs fois, en fonction du voisinage aléatoire : ``` # First time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.21365921] ``` Si vous avez besoin de résultats plus cohérents, vous pouvez rendre la requête déterministe : ``` %%gremlin g.with("Neptune#ml.endpoint", "ec-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .E('e101').properties("scale", "Neptune#ml.score") .with("Neptune#ml.classification") .with("Neptune#ml.inductiveInference") .with("Neptune#ml.deterministic") ``` Désormais, les résultats sont plus ou moins les mêmes chaque fois que vous exécutez la requête : ``` # First time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.12345678] ``` # Requêtes de régression d'arête Gremlin dans Neptune ML La régression d'arête est similaire à la classification d'arête, si ce n'est que la valeur déduite du modèle ML est numérique. Pour la régression d'arête, Neptune ML prend en charge les mêmes requêtes que pour la classification. Les principaux points à noter sont les suivants : + Vous devez utiliser le prédicat ML `"Neptune#ml.regression"` pour configurer l'étape `properties()` correspondant à ce cas d'utilisation. + Les prédicats `"Neptune#ml.limit"` et `"Neptune#ml.threshold"` ne sont pas applicables dans ce cas d'utilisation. + Pour filtrer sur la valeur, vous devez spécifier la valeur sous forme numérique. ## Syntaxe d'une requête de régression d'arête Gremlin Pour un graphe simple où `User` est le nœud de tête, `Movie` le nœud de queue et `Rated` l'arête qui les relie, voici un exemple de requête de régression d'arête qui recherche la valeur d'évaluation numérique, appelée score ici, pour l'arête `Rated` : ``` g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .E("rating_1","rating_2","rating_3") .properties("score").with("Neptune#ml.regression") ``` Vous pouvez également filtrer sur une valeur déduite du modèle de régression ML. Pour les arêtes `Rated` existantes (de `User` à `Movie`) identifiées par `"rating_1"`, `"rating_2"` et `"rating_3"`, pour lesquelles la propriété d'arête `Score` n'est pas présente pour ces notations, vous pouvez utiliser une requête comme la suivante pour déduire `Score` pour les arêtes où elle est supérieure ou égale à 9 : ``` g.with("Neptune#ml.endpoint","edge-regression-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .E("rating_1","rating_2","rating_3") .properties("score").with("Neptune#ml.regression") .value().is(P.gte(9)) ``` ## Utilisation de l'inférence inductive dans une requête de régression d'arête Supposons que vous ajoutiez une nouvelle arête à un graphe existant, dans un bloc-notes Jupyter, comme suit : ``` %%gremlin g.V('1').as('fromV') .V('2').as('toV') .addE('eLabel1').from('fromV').to('toV').property(id, 'e101') ``` Vous pouvez ensuite utiliser une requête d'inférence inductive pour obtenir un score prenant en compte la nouvelle arête : ``` %%gremlin g.with("Neptune#ml.endpoint", "er-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .E('e101').properties("score") .with("Neptune#ml.regression") .with("Neptune#ml.inductiveInference") ``` La requête n'étant pas déterministe, elle peut renvoyer des résultats légèrement différents si vous l'exécutez plusieurs fois, en fonction du voisinage aléatoire : ``` # First time ==>ep[score->96] # Second time ==>ep[score->91] ``` Si vous avez besoin de résultats plus cohérents, vous pouvez rendre la requête déterministe : ``` %%gremlin g.with("Neptune#ml.endpoint", "er-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .E('e101').properties("score") .with("Neptune#ml.regression") .with("Neptune#ml.inductiveInference") .with("Neptune#ml.deterministic") ``` Désormais, les résultats sont plus ou moins les mêmes chaque fois que vous exécutez la requête : ``` # First time ==>ep[score->96] # Second time ==>ep[score->96] ``` # Requêtes de prédiction de lien Gremlin utilisant des modèles de prédiction de lien dans Neptune ML Les modèles de prédiction de lien peuvent résoudre des problèmes tels que les suivants : + **Prédiction de nœud de tête** : étant donné un sommet et un type d'arête, à partir de quels sommets est-il probable que ce sommet soit lié ? + **Prédiction de nœud de queue** : étant donné un sommet et une étiquette d'arête, à quels sommets est-il probable que ce sommet soit lié ? **Note** La prédiction d'arête n'est pas encore prise en charge dans Neptune ML. Pour les exemples ci-dessous, considérez un graphe simple avec les sommets `User` et `Movie` liés par l'arête `Rated`. Voici un exemple de requête de prédiction de nœud de tête, utilisé pour prédire les cinq utilisateurs qui ont le plus de chance d'évaluer les films `"movie_1"`, `"movie_2"` et `"movie_3"` : ``` g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .with("Neptune#ml.limit", 5) .V("movie_1", "movie_2", "movie_3") .in("rated").with("Neptune#ml.prediction").hasLabel("user") ``` Voici un exemple similaire pour la prédiction de nœud de queue, utilisé pour prédire les cinq films qu'il est le plus probable que l'utilisateur `"user_1"` évalue : ``` g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("user_1") .out("rated").with("Neptune#ml.prediction").hasLabel("movie") ``` L'étiquette d'arête et l'étiquette de sommet prédit sont toutes deux obligatoires. Si l'une d'elles est omise, une exception est levée. Par exemple, la requête suivante sans étiquette de sommet prédit lève une exception : ``` g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("user_1") .out("rated").with("Neptune#ml.prediction") ``` De façon similaire, la requête suivante sans étiquette d'arête lève une exception : ``` g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("user_1") .out().with("Neptune#ml.prediction").hasLabel("movie") ``` Pour connaître les messages d'erreur spécifiques renvoyés par ces exceptions, consultez la [liste des exceptions de Neptune ML](machine-learning-gremlin-exceptions.md). ## Autres requêtes de prédiction de lien Vous pouvez utiliser l'étape `select()` avec l'étape `as(`) pour générer les sommets prédits avec les sommets en entrée : ``` g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("movie_1").as("source") .in("rated").with("Neptune#ml.prediction").hasLabel("user").as("target") .select("source","target") g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("user_1").as("source") .out("rated").with("Neptune#ml.prediction").hasLabel("movie").as("target") .select("source","target") ``` Vous pouvez effectuer des requêtes illimitées, comme celles-ci : ``` g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("user_1") .out("rated").with("Neptune#ml.prediction").hasLabel("movie") g.with("Neptune#ml.endpoint","node-prediction-movie-lens-endpoint") .with("Neptune#ml.iamRoleArn","arn:aws:iam::0123456789:role/sagemaker-role") .V("movie_1") .in("rated").with("Neptune#ml.prediction").hasLabel("user") ``` ## Utilisation de l'inférence inductive dans une requête de prédiction de lien Supposons que vous ajoutiez un nouveau nœud à un graphe existant, dans un bloc-notes Jupyter, comme suit : ``` %%gremlin g.addV('label1').property(id,'101').as('newV1') .addV('label2').property(id,'102').as('newV2') .V('1').as('oldV1') .V('2').as('oldV2') .addE('eLabel1').from('newV1').to('oldV1') .addE('eLabel2').from('oldV2').to('newV2') ``` Vous pouvez alors utiliser une requête d'inférence inductive pour prédire le nœud de tête, en tenant compte du nouveau nœud : ``` %%gremlin g.with("Neptune#ml.endpoint", "lp-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .V('101').out("eLabel1") .with("Neptune#ml.prediction") .with("Neptune#ml.inductiveInference") .hasLabel("label2") ``` Résultat : ``` ==>V[2] ``` De façon similaire, vous pouvez utiliser une requête d'inférence inductive pour prédire le nœud de queue, en tenant compte du nouveau nœud : ``` %%gremlin g.with("Neptune#ml.endpoint", "lp-ep") .with("Neptune#ml.iamRoleArn", "arn:aws:iam::123456789012:role/NeptuneMLRole") .V('102').in("eLabel2") .with("Neptune#ml.prediction") .with("Neptune#ml.inductiveInference") .hasLabel("label1") ``` Résultat : ``` ==>V[1] ``` # Liste des exceptions pour les requêtes d'inférence Gremlin de Neptune ML Il s'agit d'une liste complète des exceptions qui peuvent se produire lors de l'exécution de requêtes d'inférence Neptune ML Gremlin. Ces exceptions couvrent toute une série de problèmes, tels que les problèmes liés au rôle ou au point de terminaison IAM spécifié, aux étapes Gremlin non prises en charge et aux limitations du nombre de requêtes d'inférence ML par requête. Chaque entrée inclut un message détaillé décrivant le problème. + **`BadRequestException`** : les informations d'identification pour le rôle fourni ne peuvent pas être chargées. *Message* : `Unable to load credentials for role: the specified IAM Role ARN.` + **`BadRequestException`**— Le rôle IAM spécifié n'est pas autorisé à invoquer le point de terminaison SageMaker AI. *Message* : `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.` + **`BadRequestException`** : le point de terminaison spécifié n'existe pas. *Message* : `Endpoint the specified endpoint not found.` + **`InternalFailureException`** : impossible d'extraire les métadonnées d'inférence inductive en temps réel de Neptune ML depuis Amazon S3. *Message* : `Unable to fetch Neptune ML - Real-Time Inductive Inference metadata from S3. Check the permissions of the S3 bucket or if the Neptune instance can connect to S3.` + **`InternalFailureException`** : Neptune ML ne trouve pas le fichier de métadonnées pour l'inférence inductive en temps réel dans Amazon S3. *Message* : `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.` + **`InvalidParameterException`** : le point de terminaison spécifié n'est pas valide syntaxiquement. *Message* : `Invalid endpoint provided for external service query.` + **`InvalidParameterException`**— L'ARN du rôle IAM SageMaker d'exécution spécifié n'est pas syntaxiquement valide. *Message* : `Invalid IAM role ARN provided for external service query.` + **`InvalidParameterException`** : plusieurs clés de propriété sont spécifiées à l'étape `properties()` d'une requête. *Message* : `ML inference queries are currently supported for one property key.` + **`InvalidParameterException`** : plusieurs étiquettes d'arête sont spécifiées dans une requête. *Message* : `ML inference are currently supported only with one edge label.` + **`InvalidParameterException`** : plusieurs contraintes d'étiquette de sommet sont spécifiées dans une requête. *Message* : `ML inference are currently supported only with one vertex label constraint.` + **`InvalidParameterException`** : les deux prédicats `Neptune#ml.classification` et `Neptune#ml.regression` sont présents dans la même requête. *Message* : `Both regression and classification ML predicates cannot be specified in the query.` + **`InvalidParameterException`** : plusieurs étiquettes d'arête ont été spécifiées à l'étape `in()` ou `out()` dans une requête de prédiction de lien. *Message* : `ML inference are currently supported only with one edge label.` + **`InvalidParameterException`** : plusieurs clés de propriété ont été spécifiées avec Neptune\$1ml.score. *Message* : `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.` + **`MissingParameterException`** : le point de terminaison n'a pas été spécifié dans la requête ou en tant que paramètre de cluster de bases de données. *Message* : `No endpoint provided for external service query.` + **``MissingParameterException**— Le rôle IAM d'exécution de l' SageMaker IA n'a pas été spécifié dans la requête ni en tant que paramètre de cluster de base de données. *Message* : `No IAM role ARN provided for external service query.` + **`MissingParameterException`** : la clé de propriété est absente de l'étape `properties()` d'une requête. *Message* : `Property key needs to be specified using properties() step for ML inference queries.` + **`MissingParameterException`** : aucune étiquette d'arête n'a été spécifiée à l'étape `in()` ou `out()` d'une requête de prédiction de lien. *Message* : `Edge label needs to be specified while using in() or out() step for ML inference queries.` + **`MissingParameterException`** : aucune clé de propriété n'a été spécifiée avec Neptune\$1ml.score. *Message* : `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.` + **`UnsupportedOperationException`** : l'étape `both()` est utilisée dans une requête de prédiction de lien. *Message* : `ML inference queries are currently not supported with both() step.` + **`UnsupportedOperationException`** : aucune étiquette de sommet prédit n'a été spécifiée à l'étape `has()` avec l'étape `in()` ou `out()` dans une requête de prédiction de lien. *Message* : `Predicted vertex label needs to be specified using has() step for ML inference queries.` + **`UnsupportedOperationException`** : les requêtes d'inférence inductive ML Gremlin ne sont actuellement pas prises en charge avec des étapes non optimisées. *Message* : `Neptune ML - Real-Time Inductive Inference queries are currently not supported with Gremlin steps which are not optimized for Neptune. Check the Neptune User Guide for a list of Neptune-optimized steps.` + **`UnsupportedOperationException`** : les requêtes d'inférence Neptune ML ne sont actuellement pas prises en charge dans une étape `repeat`. *Message* : `Neptune ML inference queries are currently not supported inside a repeat step.` + **`UnsupportedOperationException`** : pas plus d'une seule requête d'inférence Neptune ML n'est actuellement prise en charge par requête Gremlin. *Message* : `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.` # Requêtes d'inférence SPARQL dans Neptune ML Neptune ML mappe le graphe RDF dans un graphe de propriétés pour modéliser la tâche ML. Actuellement, il prend en charge les cas d'utilisation suivants : + **Classification d'objet** : prédit la fonctionnalité catégorielle d'un objet. + **Régression d'objet** : prédit une propriété numérique d'un objet. + **Prédiction d'objet** : prédit un objet en fonction d'un sujet et d'une relation. + **Prédiction de sujet** : prédit un sujet en fonction d'un objet et d'une relation. **Note** Neptune ML ne prend pas en charge les cas d'utilisation de régression et de classification de sujet avec SPARQL. # Prédicats Neptune ML utilisés dans les requêtes d'inférence SPARQL Les prédicats suivants sont utilisés avec l'inférence SPARQL : ## Prédicat `neptune-ml:timeout` Spécifie le délai d'expiration de la connexion avec le serveur distant. À ne pas confondre avec le délai d'expiration de la demande de requête, qui est le temps maximal que le serveur peut mettre pour satisfaire une demande. Notez que si le délai d'expiration de requête survient avant le délai d'expiration du service spécifié par le prédicat `neptune-ml:timeout`, la connexion au service est également annulée. ## Prédicat `neptune-ml:outputClass` Le prédicat `neptune-ml:outputClass` est uniquement utilisé pour définir la classe de l'objet prédit pour la prédiction d'objet ou du sujet prédit pour la prédiction de sujet. ## Prédicat `neptune-ml:outputScore` Le prédicat `neptune-ml:outputScore` est un nombre positif qui représente la probabilité que la sortie d'un modèle de machine learning soit correcte. ## Prédicat `neptune-ml:modelType` Le prédicat `neptune-ml:modelType` indique le type de modèle de machine learning en cours d'entraînement : + `OBJECT_CLASSIFICATION` + `OBJECT_REGRESSION` + `OBJECT_PREDICTION` + `SUBJECT_PREDICTION` ## Prédicat `neptune-ml:input` Le `neptune-ml:input` prédicat fait référence à la liste des entrées URIs utilisées pour Neptune ML. ## Prédicat `neptune-ml:output` Le prédicat `neptune-ml:output` fait référence à la liste des ensembles de liaisons où Neptune ML renvoie les résultats. ## Prédicat `neptune-ml:predicate` Le prédicat `neptune-ml:predicate` est utilisé différemment en fonction de la tâche exécutée : + Pour une **prédiction d'objet ou de sujet** : définit le type de prédicat (type d'arête ou de relation). + Pour une **classification et régression d'objet** : définit le littéral (propriété) que nous voulons prédire. ## Prédicat `neptune-ml:batchSize` `neptune-ml:batchSize` spécifie la taille d'entrée pour l'appel de service à distance. # Exemples de classification d'objet SPARQL Pour une classification d'objet SPARQL dans Neptune ML, le modèle est entraîné sur l'une des valeurs de prédicat. Ceci est utile lorsque ce prédicat n'est pas déjà présent avec un sujet donné. Seules les valeurs de prédicat catégorielles peuvent être déduites à l'aide du modèle de classification d'objet. La requête suivante cherche à prédire la valeur de prédicat pour toutes les entrées de type `foaf:Person` : ``` SELECT * WHERE { ?input a foaf:Person . SERVICE neptune-ml:inference { neptune-ml:config neptune-ml:modelType 'OBJECT_CLASSIFICATION' ; neptune-ml:input ?input ; neptune-ml:predicate ; neptune-ml:output ?output . } } ``` Cette requête peut être personnalisée comme suit : ``` SELECT * WHERE { ?input a foaf:Person . SERVICE neptune-ml:inference { neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ; neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ; neptune-ml:batchSize "40"^^xsd:integer ; neptune-ml:timeout "1000"^^xsd:integer ; neptune-ml:modelType 'OBJECT_CLASSIFICATION' ; neptune-ml:input ?input ; neptune-ml:predicate ; neptune-ml:output ?output . } } ``` # Exemples de régression d'objet SPARQL La régression d'objet est similaire à la classification d'objet, si ce n'est qu'une valeur de prédicat numérique est déduite du modèle de régression pour chaque nœud. Vous pouvez utiliser les mêmes requêtes SPARQL pour la régression d'objet que pour la classification d'objet, à l'exception du fait que les prédicats `the Neptune#ml.limit` et `Neptune#ml.threshold` ne sont pas applicables. La requête suivante cherche à prédire la valeur de prédicat pour toutes les entrées de type `foaf:Person` : ``` SELECT * WHERE { ?input a foaf:Person . SERVICE neptune-ml:inference { neptune-ml:config neptune-ml:modelType 'OBJECT_REGRESSION' ; neptune-ml:input ?input ; neptune-ml:predicate ; neptune-ml:output ?output . } } ``` Cette requête peut être personnalisée comme suit : ``` SELECT * WHERE { ?input a foaf:Person . SERVICE neptune-ml:inference { neptune-ml:config neptune-ml:endpoint 'node-prediction-account-balance-endpoint' ; neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ; neptune-ml:batchSize "40"^^xsd:integer ; neptune-ml:timeout "1000"^^xsd:integer ; neptune-ml:modelType 'OBJECT_REGRESSION' ; neptune-ml:input ?input ; neptune-ml:predicate ; neptune-ml:output ?output . } } ``` # Exemple de prédiction d'objet SPARQL La *prédiction d'objet* prédit la valeur de l'objet pour un sujet et un prédicat donnés. La requête de prédiction d'objet suivante cherche à prédire quel film l'entrée de type `foaf:Person` aimerait : ``` ?x a foaf:Person . ?x ?m . ?m a . ## Query SELECT * WHERE { ?input a foaf:Person . SERVICE neptune-ml:inference { neptune-ml:config neptune-ml:modelType 'OBJECT_PREDICTION' ; neptune-ml:input ?input ; neptune-ml:predicate ; neptune-ml:output ?output ; neptune-ml:outputClass . } } ``` La requête elle-même peut être personnalisée comme suit : ``` SELECT * WHERE { ?input a foaf:Person . SERVICE neptune-ml:inference { neptune-ml:config neptune-ml:endpoint 'node-prediction-user-movie-prediction-endpoint' ; neptune-ml:iamRoleArn 'arn:aws:iam::0123456789:role/sagemaker-role' ; neptune-ml:limit "5"^^xsd:integer ; neptune-ml:batchSize "40"^^xsd:integer ; neptune-ml:threshold "0.1"^^xsd:double ; neptune-ml:timeout "1000"^^xsd:integer ; neptune-ml:outputScore ?score ; neptune-ml:modelType 'OBJECT_PREDICTION' ; neptune-ml:input ?input ; neptune-ml:predicate ; neptune-ml:output ?output ; neptune-ml:outputClass . } } ``` # Exemple de prédiction de sujet SPARQL La *prédiction de sujet* prédit le sujet pour un prédicat et un objet donnés. Par exemple, la requête suivante prédit qui (de type `foaf:User`) regardera un film donné : ``` SELECT * WHERE { ?input (a foaf:Movie) . SERVICE neptune-ml:inference { neptune-ml:config neptune-ml:modelType 'SUBJECT_PREDICTION' ; neptune-ml:input ?input ; neptune-ml:predicate ; neptune-ml:output ?output ; neptune-ml:outputClass ; } } ``` # Liste des exceptions pour les requêtes d'inférence SPARQL de Neptune ML **** + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at least 1 value for the parameter (parameter name), found zero.` + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects at most 1 value for the parameter (parameter name), found (a number) values.` + **`BadRequestException`**   –   *Message* : `Invalid predicate (predicate name) provided for external service http://aws.amazon.com/neptune/vocab/v01/services/ml#inference query.` + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the predicate (predicate name) to be defined`. + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the value of (parameter) (parameter name) to be a variable, found: (type)"` + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the input (parameter name) to be a constant, found: (type)`. + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference is expected to return only 1 value`. + **`BadRequestException`**   –   *Message* : `"The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference only allows StatementPatternNodes`. + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference does not allow the predicate (predicate name)`. + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates cannot be variables, found: (type)`. + **`BadRequestException`**   –   *Message* : `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates are expected to be part of the namespace (namespace name), found: (namespace name)`. # Référence de l'API de gestion Neptune ML **Contents** + [Commande dataprocessing](machine-learning-api-dataprocessing.md) + [Créer une tâche de traitement de données](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-create-job) + [Obtenir le statut d'une tâche](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-get-job-status) + [Arrêter une tâche](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-stop-job) + [Liste des tâches](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-list-jobs) + [Commande modeltraining](machine-learning-api-modeltraining.md) + [Créer une tâche d’entraînement de modèle](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) + [Obtenir le statut d'une tâche](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-get-job-status) + [Arrêter une tâche](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-stop-job) + [Liste des tâches](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-list-jobs) + [Commande modeltransform](machine-learning-api-modeltransform.md) + [Créer une tâche de transformation de modèle](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-create-job) + [Obtenir le statut d'une tâche](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-get-job-status) + [Arrêter une tâche](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-stop-job) + [Liste des tâches](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-list-jobs) + [Commande endpoints](machine-learning-api-endpoints.md) + [Créer un point de terminaison d'inférence](machine-learning-api-endpoints.md#machine-learning-api-endpoints-create-job) + [Obtenir le statut d'un point de terminaison](machine-learning-api-endpoints.md#machine-learning-api-endpoints-get-endpoint-status) + [Supprimer un point de terminaison](machine-learning-api-endpoints.md#machine-learning-api-endpoints-delete-endpoint) + [Répertorier les points de terminaison d'inférence](machine-learning-api-endpoints.md#machine-learning-api-endpoints-list-endpoints) + [Exceptions](machine-learning-api-exceptions.md) # Traitement des données à l'aide de la commande `dataprocessing` Vous utilisez la commande Neptune ML `dataprocessing` pour créer une tâche de traitement de données, vérifier son statut, l'arrêter ou répertorier toutes les tâches de traitement de données actives. ## Création d'une tâche de traitement de données à l'aide de la commande Neptune ML `dataprocessing` Une commande Neptune ML `dataprocessing` typique pour créer une nouvelle tâche ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/dataprocessing \ -H 'Content-Type: application/json' \ -d '{ "inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)", "id" : "(a job ID for the new job)", "processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)" }' ``` Une commande pour lancer un retraitement incrémentiel ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/dataprocessing \ -H 'Content-Type: application/json' \ -d '{ "inputDataS3Location" : "s3://(Amazon S3 bucket name)/(path to your input folder)", "id" : "(a job ID for this job)", "processedDataS3Location" : "s3://(S3 bucket name)/(path to your output folder)" "previousDataProcessingJobId" : "(the job ID of a previously completed job to update)" }' ``` **Paramètres de création d'une tâche `dataprocessing`** + **`id`** : (*facultatif*) identifiant unique de la nouvelle tâche. *Type* : string. *Valeur par défaut* : un UUID généré automatiquement. + **`previousDataProcessingJobId`** : (*facultatif*) ID de tâche d'une tâche de traitement de données terminée, exécutée sur une version antérieure des données. *Type* : string. *Valeur par défaut* : *aucune*. *Remarque* : Utilisez-le pour le traitement incrémentiel des données, afin de mettre à jour le modèle quand les données du graphe ont changé (mais pas quand les données ont été supprimées). + **`inputDataS3Location`**— (*Obligatoire*) L'URI de l'emplacement Amazon S3 où vous souhaitez qu' SageMaker AI télécharge les données nécessaires à l'exécution de la tâche de traitement des données. *Type* : string. + **`processedDataS3Location`**— (*Obligatoire*) L'URI de l'emplacement Amazon S3 où vous souhaitez qu' SageMaker AI enregistre les résultats d'une tâche de traitement de données. *Type* : string. + **`sagemakerIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM pour l'exécution de l' SageMaker IA. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`neptuneIamRoleArn`**— (*Facultatif*) Le nom de ressource Amazon (ARN) d'un rôle IAM que l' SageMaker IA peut assumer pour effectuer des tâches en votre nom. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`processingInstanceType`** : (*facultatif*) type d'instance ML utilisé lors du traitement des données. Sa mémoire doit être suffisamment grande pour contenir le jeu de données traité. *Type* : string. *Valeur par défaut* : le plus petit type d'instance `ml.r5` dont la mémoire est dix fois supérieure à la taille des données de graphe exportées sur le disque. *Remarque* : Neptune ML peut sélectionner le type d'instance automatiquement. Consultez [Sélection d'une instance pour le traitement des données](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size). + **`processingInstanceVolumeSizeInGB`** : (*facultatif*) taille du volume de disque de l'instance de traitement. Les données d'entrée et les données traitées étant toutes stockées sur disque, la taille du volume doit être suffisante pour contenir les deux jeux de données. *Type* : entier. *Par défaut* : `0`. *Remarque* : Si ce paramètre n'est pas spécifié ou s'il est égal à 0, Neptune ML choisit automatiquement la taille du volume en fonction de la taille des données. + **`processingTimeOutInSeconds`** : (*facultatif*) délai d'expiration en secondes pour la tâche de traitement des données. *Type* : entier. *Valeur par défaut* : `86,400` (1 jour). + **`modelType`** : (*facultatif*) l'un des deux types de modèles actuellement pris en charge par Neptune ML : modèles de graphes hétérogènes (`heterogeneous`) et graphe de connaissances (`kge`). *Type* : string. *Valeur par défaut* : *aucune*. *Remarque* : Si ce paramètre n'est pas spécifié, Neptune ML choisit automatiquement le type de modèle en fonction des données. + **`configFileName`** : (*facultatif*) fichier de spécification de données qui décrit comment charger les données de graphe exportées à des fins d'entraînement. Ce fichier est automatiquement généré par la boîte à outils d'exportation Neptune. *Type* : string. *Par défaut* : `training-data-configuration.json`. + **`subnets`**— (*Facultatif*) Les IDs sous-réseaux du VPC Neptune. *Type* : liste de chaînes. *Valeur par défaut* : *aucune*. + **`securityGroupIds`**— (*Facultatif*) Le groupe de sécurité VPC. IDs *Type* : liste de chaînes. *Valeur par défaut* : *aucune*. + **`volumeEncryptionKMSKey`**— (*Facultatif*) La clé AWS Key Management Service (AWS KMS) utilisée par SageMaker AI pour chiffrer les données sur le volume de stockage attaché aux instances de calcul ML qui exécutent la tâche de traitement. *Type* : string. *Valeur par défaut* : *aucune*. + **`enableInterContainerTrafficEncryption`** : (*facultatif*) activez ou désactivez le chiffrement du trafic entre conteneurs dans les tâches d'entraînement ou de réglage des hyperparamètres. *Type* : booléen. *Valeur par défaut* : *True*. **Note** Le paramètre `enableInterContainerTrafficEncryption` est disponible uniquement dans la [version 1.2.0.2.R3 du moteur](engine-releases-1.2.0.2.R3.md). + **`s3OutputEncryptionKMSKey`**— (*Facultatif*) La clé AWS Key Management Service (AWS KMS) utilisée par l' SageMaker IA pour chiffrer le résultat du travail de formation. *Type* : string. *Valeur par défaut* : *aucune*. ## Obtention du statut d'une tâche de traitement de données à l'aide de la commande Neptune ML `dataprocessing` Voici un exemple de commande Neptune ML `dataprocessing` pour obtenir le statut d'une tâche : ``` curl -s \ "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)" \ | python -m json.tool ``` **Paramètres d'obtention du statut de la tâche `dataprocessing`** + **`id`** : (*obligatoire*) identifiant unique de la tâche de traitement de données. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. ## Arrêt d'une tâche de traitement de données à l'aide de la commande Neptune ML `dataprocessing` Voici un exemple de commande Neptune ML `dataprocessing` permettant d'arrêter une tâche : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)" ``` Ou encore : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)?clean=true" ``` **Paramètres d'arrêt de la tâche `dataprocessing`** + **`id`** : (*obligatoire*) identifiant unique de la tâche de traitement de données. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`clean`** : (*facultatif*) cet indicateur spécifie que tous les artefacts Amazon S3 doivent être supprimés lorsque la tâche est arrêtée. *Type* : booléen. *Par défaut* : `FALSE`. ## Répertorier les tâches de traitement de données actives à l'aide de la commande Neptune ML `dataprocessing` Voici un exemple de commande Neptune ML `dataprocessing` permettant de répertorier les tâches actives : ``` curl -s "https://(your Neptune endpoint)/ml/dataprocessing" ``` Ou encore : ``` curl -s "https://(your Neptune endpoint)/ml/dataprocessing?maxItems=3" ``` **Paramètres pour répertorier les tâches `dataprocessing`** + **`maxItems`** : (*facultatif*) nombre maximal d'éléments à renvoyer. *Type* : entier. *Par défaut* : `10`. *Valeur maximale autorisée* : `1024`. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. # Entraînement de modèle à l'aide de la commande `modeltraining` Vous utilisez la commande Neptune ML `modeltraining` pour créer une tâche d'entraînement de modèle, vérifier son statut, l'arrêter ou répertorier toutes les tâches d'entraînement de modèle actives. ## Création d'une tâche d'entraînement de modèle à l'aide de la commande Neptune ML `modeltraining` Une commande Neptune ML `modeltraining` permettant de créer une toute nouvelle tâche ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" }' ``` Une commande Neptune ML `modeltraining` permettant de créer une tâche de mise à jour pour un entraînement de modèle incrémentiel ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "previousModelTrainingJobId" : "(the job ID of a completed model-training job to update)", }' ``` Une commande Neptune ML `modeltraining` permettant de créer une nouvelle tâche avec l'implémentation d'un modèle personnalisé fourni par l'utilisateur ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "modelName": "custom", "customModelTrainingParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "trainingEntryPointScript": "(your training script entry-point name in the Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` **Paramètres de création d'une tâche `modeltraining`** + **`id`** : (*facultatif*) identifiant unique de la nouvelle tâche. *Type* : string. *Valeur par défaut* : un UUID généré automatiquement. + **`dataProcessingJobId`** : (*obligatoire*) ID de la tâche de traitement de données terminée qui a créé les données qui seront utilisées par l'entraînement. *Type* : string. + **`trainModelS3Location`** : (*obligatoire*) emplacement dans Amazon S3 où les artefacts de modèle doivent être stockés. *Type* : string. + **`previousModelTrainingJobId`** : (*facultatif*) ID de tâche d'une tâche d'entraînement de modèle terminée que vous souhaitez actualiser progressivement en fonction des données mises à jour. *Type* : string. *Valeur par défaut* : *aucune*. + **`sagemakerIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM pour l'exécution de l' SageMaker IA. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`modelName`** : (*facultatif*) type de modèle pour l'entraînement. Par défaut, le modèle ML est automatiquement basé sur le `modelType` utilisé dans le cadre du traitement de données, mais vous pouvez spécifier ici un autre type de modèle. *Type* : string. *Valeur par défaut* : `rgcn` pour les graphes hétérogènes et `kge` pour les graphes de connaissances. *Valeurs valides* : pour les graphes hétérogènes : `rgcn`. Pour les graphes `kge` : `transe`, `distmult` ou `rotate`. Pour l'implémentation d'un modèle personnalisé : `custom`. + **`baseProcessingInstanceType`** : (*facultatif*) type d'instance ML utilisé pour préparer et gérer l'entraînement de modèles ML. *Type* : string. *Remarque* : Il s'agit d'une instance de CPU choisie en fonction des besoins en mémoire pour le traitement des données et du modèle d'entraînement. Consultez [Sélection d'une instance pour l'entraînement de modèle et la transformation de modèle](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`trainingInstanceType`** : (*facultatif*) type d'instance ML utilisé pour l'entraînement de modèle. Tous les modèles Neptune ML prennent en charge l'entraînement de CPU, de GPU et de multiGPU. *Type* : string. *Par défaut* : `ml.p3.2xlarge`. *Remarque* : Le choix du type d'instance approprié pour l'entraînement dépend du type de tâche, de la taille de graphe et de votre budget. Consultez [Sélection d'une instance pour l'entraînement de modèle et la transformation de modèle](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`trainingInstanceVolumeSizeInGB`** : (*facultatif*) taille du volume de disque de l'instance d'entraînement. Les données d'entrée et le modèle de sortie étant toutes stockées sur disque, la taille du volume doit être suffisante pour contenir les deux jeux de données. *Type* : entier. *Par défaut* : `0`. *Remarque* : Si elle n'est pas spécifiée ou si elle est égale à 0, Neptune ML sélectionne une taille de volume de disque en fonction de la recommandation générée lors de l'étape de traitement de données. Consultez [Sélection d'une instance pour l'entraînement de modèle et la transformation de modèle](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`trainingTimeOutInSeconds`** : (*facultatif*) délai d'attente en secondes de la tâche d'entraînement. *Type* : entier. *Valeur par défaut* : `86,400` (1 jour). + **`maxHPONumberOfTrainingJobs`**   –   Nombre total maximal de tâches d'entraînement à démarrer pour la tâche de réglage des hyperparamètres. *Type* : entier. *Par défaut* : `2`. *Remarque* : Neptune ML règle automatiquement les hyperparamètres du modèle de machine learning. Pour obtenir un modèle performant, utilisez au moins 10 tâches (en d'autres termes, définissez `maxHPONumberOfTrainingJobs` sur 10). En général, plus le réglage est long, meilleurs sont les résultats. + **`maxHPOParallelTrainingJobs`**   –   Nombre maximal de tâches d'entraînement parallèles à démarrer pour la tâche de réglage des hyperparamètres. *Type* : entier. *Par défaut* : `2`. *Remarque* : Le nombre de tâches parallèles que vous pouvez exécuter est limité par les ressources disponibles sur votre instance d'entraînement. + **`subnets`**— (*Facultatif*) Les IDs sous-réseaux du VPC Neptune. *Type* : liste de chaînes. *Valeur par défaut* : *aucune*. + **`securityGroupIds`**— (*Facultatif*) Le groupe de sécurité VPC. IDs *Type* : liste de chaînes. *Valeur par défaut* : *aucune*. + **`volumeEncryptionKMSKey`**— (*Facultatif*) La clé AWS Key Management Service (AWS KMS) utilisée par l' SageMaker IA pour chiffrer les données du volume de stockage attaché aux instances de calcul ML qui exécutent la tâche de formation. *Type* : string. *Valeur par défaut* : *aucune*. + **`s3OutputEncryptionKMSKey`**— (*Facultatif*) La clé AWS Key Management Service (AWS KMS) utilisée par l' SageMaker IA pour chiffrer le résultat de la tâche de traitement. *Type* : string. *Valeur par défaut* : *aucune*. + **`enableInterContainerTrafficEncryption`** : (*facultatif*) activez ou désactivez le chiffrement du trafic entre conteneurs dans les tâches d'entraînement ou de réglage des hyperparamètres. *Type* : booléen. *Valeur par défaut* : *True*. **Note** Le paramètre `enableInterContainerTrafficEncryption` est disponible uniquement dans la [version 1.2.0.2.R3 du moteur](engine-releases-1.2.0.2.R3.md). + **`enableManagedSpotTraining`** : (*facultatif*) optimise le coût d'entraînement de modèles de machine learning à l'aide d'instances Spot Amazon Elastic Compute Cloud.. Pour plus d'informations, consultez [Managed Spot Training sur Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html). *Type* : booléen. *Valeur par défaut* : *False*. + **`customModelTrainingParameters`** : (*facultatif*) configuration pour un entraînement de modèle personnalisé. Ceci est un objet JSON avec les champs suivants : + **`sourceS3DirectoryPath`** : (*obligatoire*) chemin de l'emplacement Amazon S3 où se trouve le module Python implémentant votre modèle. Il doit pointer vers un emplacement Amazon S3 existant valide contenant, au minimum, un script d'entraînement, un script de transformation et un fichier `model-hpo-configuration.json`. + **`trainingEntryPointScript`** : (*facultatif*) nom du point d'entrée dans votre module d'un script qui effectue l'entraînement de modèle et utilise les hyperparamètres comme arguments de ligne de commande, y compris les hyperparamètres fixes. *Par défaut* : `training.py`. + **`transformEntryPointScript`** : (*facultatif*) nom du point d'entrée dans le module d'un script qui doit être exécuté une fois que le modèle le plus approprié issu de la recherche par hyperparamètres a été identifié, afin de calculer les artefacts de modèle nécessaires au déploiement du modèle. Il devrait pouvoir s'exécuter sans arguments de ligne de commande. *Par défaut* : `transform.py`. + **`maxWaitTime`** : (*facultatif*) temps d'attente maximal, en secondes, lors de l'entraînement de modèle à l'aide d'instances Spot. Devrait être supérieur à `trainingTimeOutInSeconds`. *Type* : entier. ## Obtention du statut d'une tâche d'entraînement de modèle à l'aide de la commande Neptune ML `modeltraining` Voici un exemple de commande Neptune ML `modeltraining` pour obtenir le statut d'une tâche : ``` curl -s \ "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)" \ | python -m json.tool ``` **Paramètres d'obtention du statut de la tâche `modeltraining`** + **`id`** : (*obligatoire*) identifiant unique de la tâche d'entraînement de modèle. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. ## Arrêt d'une tâche d'entraînement de modèle à l'aide de la commande Neptune ML `modeltraining` Voici un exemple de commande Neptune ML `modeltraining` permettant d'arrêter une tâche : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)" ``` Ou encore : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)?clean=true" ``` **Paramètres d'arrêt de la tâche `modeltraining`** + **`id`** : (*obligatoire*) identifiant unique de la tâche d'entraînement de modèle. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`clean`** : (*facultatif*) cet indicateur spécifie que tous les artefacts Amazon S3 doivent être supprimés lorsque la tâche est arrêtée. *Type* : booléen. *Par défaut* : `FALSE`. ## Répertorier les tâches d'entraînement de modèle actives à l'aide de la commande Neptune ML `modeltraining` Voici un exemple de commande Neptune ML `modeltraining` permettant de répertorier les tâches actives : ``` curl -s "https://(your Neptune endpoint)/ml/modeltraining" | python -m json.tool ``` Ou encore : ``` curl -s "https://(your Neptune endpoint)/ml/modeltraining?maxItems=3" | python -m json.tool ``` **Paramètres pour répertorier les tâches `modeltraining`** + **`maxItems`** : (*facultatif*) nombre maximal d'éléments à renvoyer. *Type* : entier. *Par défaut* : `10`. *Valeur maximale autorisée* : `1024`. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. # Transformation de modèle à l'aide de la commande `modeltransform` Vous utilisez la commande Neptune ML `modeltransform` pour créer une tâche de transformation de modèle, vérifier son statut, l'arrêter ou répertorier toutes les tâches de transformation de modèle actives. ## Création d'une tâche de transformation de modèle à l'aide de la commande Neptune ML `modeltransform` Une commande Neptune ML `modeltransform` permettant de créer une tâche de transformation incrémentielle, sans réentraînement de modèle, ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltransform -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-transform job ID)", "dataProcessingJobId" : "(the job-id of a completed data-processing job)", "mlModelTrainingJobId" : "(the job-id of a completed model-training job)", "modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform" }' ``` Voici une `modeltransform` commande Neptune ML permettant de créer une tâche à partir d'une tâche de formation à l' SageMaker IA terminée : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltransform -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-transform job ID)", "trainingJobName" : "(name of a completed SageMaker AI training job)", "modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform", "baseProcessingInstanceType" : "" }' ``` Une commande Neptune ML `modeltransform` permettant de créer une tâche qui utilise une implémentation de modèle personnalisée ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltransform -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "trainingJobName" : "(name of a completed SageMaker AI training job)", "modelTransformOutputS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-transform/" "customModelTransformParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` **Paramètres de création d'une tâche `modeltransform`** + **`id`** : (*facultatif*) identifiant unique de la nouvelle tâche. *Type* : string. *Valeur par défaut* : un UUID généré automatiquement. + **`dataProcessingJobId`**   –   ID de tâche d'une tâche de traitement de données terminée. *Type* : string. *Remarque* : Vous devez inclure `dataProcessingJobId` et `mlModelTrainingJobId`, ou `trainingJobName`. + **`mlModelTrainingJobId`**   –   ID de tâche d'une tâche d'entraînement de modèle terminée. *Type* : string. *Remarque* : Vous devez inclure `dataProcessingJobId` et `mlModelTrainingJobId`, ou `trainingJobName`. + **`trainingJobName`**— Le nom d'un poste de formation en SageMaker IA terminé. *Type* : string. *Remarque* : Vous devez inclure à la fois les paramètres `dataProcessingJobId` et `mlModelTrainingJobId`, ou le paramètre `trainingJobName`. + **`sagemakerIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM pour l'exécution de l' SageMaker IA. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`customModelTransformParameters `** : (*facultatif*) informations de configuration d'une transformation de modèle à l'aide d'un modèle personnalisé. L'objet `customModelTransformParameters` contient les champs suivants, dont les valeurs doivent être compatibles avec les paramètres de modèle enregistrés lors de la tâche d'entraînement : + **`sourceS3DirectoryPath`** : (*obligatoire*) chemin de l'emplacement Amazon S3 où se trouve le module Python implémentant votre modèle. Il doit pointer vers un emplacement Amazon S3 existant valide contenant, au minimum, un script d'entraînement, un script de transformation et un fichier `model-hpo-configuration.json`. + **`transformEntryPointScript`** : (*facultatif*) nom du point d'entrée dans le module d'un script qui doit être exécuté une fois que le modèle le plus approprié issu de la recherche par hyperparamètres a été identifié, afin de calculer les artefacts de modèle nécessaires au déploiement du modèle. Il devrait pouvoir s'exécuter sans arguments de ligne de commande. *Par défaut* : `transform.py`. + **`baseProcessingInstanceType`** : (*facultatif*) type d'instance ML utilisé pour préparer et gérer l'entraînement de modèles ML. *Type* : string. *Remarque* : Il s'agit d'une instance de CPU choisie en fonction des besoins en mémoire pour le traitement des données et du modèle de transformation. Consultez [Sélection d'une instance pour l'entraînement de modèle et la transformation de modèle](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`baseProcessingInstanceVolumeSizeInGB`** : (*facultatif*) taille du volume de disque de l'instance d'entraînement. Les données d'entrée et le modèle de sortie étant toutes stockées sur disque, la taille du volume doit être suffisante pour contenir les deux jeux de données. *Type* : entier. *Par défaut* : `0`. *Remarque* : Si elle n'est pas spécifiée ou si elle est égale à 0, Neptune ML sélectionne une taille de volume de disque en fonction de la recommandation générée lors de l'étape de traitement de données. Consultez [Sélection d'une instance pour l'entraînement de modèle et la transformation de modèle](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`subnets`**— (*Facultatif*) Les IDs sous-réseaux du VPC Neptune. *Type* : liste de chaînes. *Valeur par défaut* : *aucune*. + **`securityGroupIds`**— (*Facultatif*) Le groupe de sécurité VPC. IDs *Type* : liste de chaînes. *Valeur par défaut* : *aucune*. + **`volumeEncryptionKMSKey`**— (*Facultatif*) La clé AWS Key Management Service (AWS KMS) utilisée par l' SageMaker IA pour chiffrer les données sur le volume de stockage attaché aux instances de calcul ML qui exécutent la tâche de transformation. *Type* : string. *Valeur par défaut* : *aucune*. + **`enableInterContainerTrafficEncryption`** : (*facultatif*) activez ou désactivez le chiffrement du trafic entre conteneurs dans les tâches d'entraînement ou de réglage des hyperparamètres. *Type* : booléen. *Valeur par défaut* : *True*. **Note** Le paramètre `enableInterContainerTrafficEncryption` est disponible uniquement dans la [version 1.2.0.2.R3 du moteur](engine-releases-1.2.0.2.R3.md). + **`s3OutputEncryptionKMSKey`**— (*Facultatif*) La clé AWS Key Management Service (AWS KMS) utilisée par l' SageMaker IA pour chiffrer le résultat de la tâche de traitement. *Type* : string. *Valeur par défaut* : *aucune*. ## Obtention du statut d'une tâche de transformation de modèle à l'aide de la commande Neptune ML `modeltransform` Voici un exemple de commande Neptune ML `modeltransform` pour obtenir le statut d'une tâche : ``` curl -s \ "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)" \ | python -m json.tool ``` **Paramètres d'obtention du statut de la tâche `modeltransform`** + **`id`** : (*obligatoire*) identifiant unique de la tâche de transformation de modèle. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. ## Arrêt d'une tâche de transformation de modèle à l'aide de la commande Neptune ML `modeltransform` Voici un exemple de commande Neptune ML `modeltransform` permettant d'arrêter une tâche : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)" ``` Ou encore : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)?clean=true" ``` **Paramètres d'arrêt de la tâche `modeltransform`** + **`id`** : (*obligatoire*) identifiant unique de la tâche de transformation de modèle. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. + **`clean`** : (*facultatif*) cet indicateur spécifie que tous les artefacts Amazon S3 doivent être supprimés lorsque la tâche est arrêtée. *Type* : booléen. *Par défaut* : `FALSE`. ## Répertorier les tâches de transformation de modèle actives à l'aide de la commande Neptune ML `modeltransform` Voici un exemple de commande Neptune ML `modeltransform` permettant de répertorier les tâches actives : ``` curl -s "https://(your Neptune endpoint)/ml/modeltransform" | python -m json.tool ``` Ou encore : ``` curl -s "https://(your Neptune endpoint)/ml/modeltransform?maxItems=3" | python -m json.tool ``` **Paramètres pour répertorier les tâches `modeltransform`** + **`maxItems`** : (*facultatif*) nombre maximal d'éléments à renvoyer. *Type* : entier. *Par défaut* : `10`. *Valeur maximale autorisée* : `1024`. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM qui permet à Neptune d'accéder SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres de votre cluster de bases de données, sinon une erreur se produira. # Gestion des points de terminaison d'inférence à l'aide de la commande `endpoints` Vous utilisez la commande Neptune ML `endpoints` pour créer un point de terminaison d'inférence, vérifier son statut, le supprimer ou répertorier les points de terminaison d'inférence existants. ## Création d'un point de terminaison d'inférence à l'aide de la commande Neptune ML `endpoints` Une commande Neptune ML `endpoints` permettant de créer un point de terminaison d'inférence à partir d'un modèle créé par une tâche d'entraînement ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/endpoints -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique ID for the new endpoint)", "mlModelTrainingJobId": "(the model-training job-id of a completed job)" }' ``` Une commande Neptune ML `endpoints` permettant de mettre à jour un point de terminaison d'inférence existant à partir d'un modèle créé par une tâche d'entraînement ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/endpoints -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique ID for the new endpoint)", "update" : "true", "mlModelTrainingJobId": "(the model-training job-id of a completed job)" }' ``` Une commande Neptune ML `endpoints` permettant de créer un point de terminaison d'inférence à partir d'un modèle créé par une tâche de transformation de modèle ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/endpoints -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique ID for the new endpoint)", "mlModelTransformJobId": "(the model-training job-id of a completed job)" }' ``` Une commande Neptune ML `endpoints` permettant de mettre à jour un point de terminaison d'inférence existant à partir d'un modèle créé par une tâche de transformation de modèle ressemble à ceci : ``` curl \ -X POST https://(your Neptune endpoint)/ml/endpoints -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique ID for the new endpoint)", "update" : "true", "mlModelTransformJobId": "(the model-training job-id of a completed job)" }' ``` **Paramètres de création d'un point de terminaison d'inférence `endpoints`** + **`id`** : (*facultatif*) identifiant unique du nouveau point de terminaison d'inférence. *Type* : string. *Valeur par défaut* : nom horodaté généré automatiquement. + **`mlModelTrainingJobId`**   –   ID de tâche de la tâche d'entraînement de modèle terminée qui a créé le modèle vers lequel le point de terminaison d'inférence pointera. *Type* : string. *Remarque* : Vous devez fournir `mlModelTrainingJobId` ou `mlModelTransformJobId`. + **`mlModelTransformJobId`**   –   ID de tâche de la tâche de transformation de modèle terminée. *Type* : string. *Remarque* : Vous devez fournir `mlModelTrainingJobId` ou `mlModelTransformJobId`. + **`update`** : (*facultatif*) s'il est présent, ce paramètre indique qu'il s'agit d'une demande de mise à jour. *Type* : booléen. *Par défaut* : `false` *Remarque* : Vous devez fournir `mlModelTrainingJobId` ou `mlModelTransformJobId`. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM fournissant à Neptune l'accès SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres du cluster de bases de données, sans quoi une erreur sera générée. + **`modelName`** : (*facultatif*) type de modèle pour l'entraînement. Par défaut, le modèle ML est automatiquement basé sur le `modelType` utilisé dans le cadre du traitement de données, mais vous pouvez spécifier ici un autre type de modèle. *Type* : string. *Valeur par défaut* : `rgcn` pour les graphes hétérogènes et `kge` pour les graphes de connaissances. *Valeurs valides* : pour les graphes hétérogènes : `rgcn`. Pour les graphes de connaissances : `kge`, `transe`, `distmult` ou `rotate`. + **`instanceType`** : (*facultatif*) type d'instance ML utilisé pour la maintenance en ligne. *Type* : string. *Par défaut* : `ml.m5.xlarge`. *Remarque* : Le choix de l'instance ML pour un point de terminaison d'inférence dépend du type de tâche, de la taille de graphe et de votre budget. Consultez [Sélection d'une instance pour un point de terminaison d'inférence](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size). + **`instanceCount`** : (*facultatif*) nombre minimal d'instances Amazon EC2 à déployer sur un point de terminaison à des fins de prédiction. *Type* : entier. *Par défaut* : `1`. + **`volumeEncryptionKMSKey`**— (*Facultatif*) La clé AWS Key Management Service (AWS KMS) utilisée par SageMaker AI pour chiffrer les données sur le volume de stockage attaché aux instances de calcul ML qui exécutent les points de terminaison. *Type* : string. *Valeur par défaut* : *aucune*. ## Obtention du statut d'un point de terminaison d'inférence à l'aide de la commande Neptune ML `endpoints` Voici un exemple de commande Neptune ML `endpoints` pour obtenir le statut d'un point de terminaison d'instance : ``` curl -s \ "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)" \ | python -m json.tool ``` **Paramètres d'obtention du statut d'un point de terminaison de l'instance `endpoints`** + **`id`** : (*obligatoire*) identifiant unique du point de terminaison d'inférence. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM fournissant à Neptune l'accès SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres du cluster de bases de données, sans quoi une erreur sera générée. ## Suppression d'un point de terminaison d'instance à l'aide de la commande Neptune ML `endpoints` Voici un exemple de commande Neptune ML `endpoints` permettant de supprimer un point de terminaison d'instance : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)" ``` Ou encore : ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)?clean=true" ``` **Paramètres de suppression d'un point de terminaison d'inférence `endpoints`** + **`id`** : (*obligatoire*) identifiant unique du point de terminaison d'inférence. *Type* : string. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM fournissant à Neptune l'accès SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres du cluster de bases de données, sans quoi une erreur sera générée. + **`clean`** : (*facultatif*) indique que tous les artefacts liés à ce point de terminaison doivent également être supprimés. *Type* : booléen. *Par défaut* : `FALSE`. ## Répertorier les points de terminaison d'inférence à l'aide de la commande Neptune ML `endpoints` Une commande Neptune ML `endpoints` pour répertorier les points de terminaison d'inférence ressemble à ceci : ``` curl -s "https://(your Neptune endpoint)/ml/endpoints" \ | python -m json.tool ``` Ou encore : ``` curl -s "https://(your Neptune endpoint)/ml/endpoints?maxItems=3" \ | python -m json.tool ``` **Paramètres pour répertorier les points de terminaison d'inférence `dataprocessing`** + **`maxItems`** : (*facultatif*) nombre maximal d'éléments à renvoyer. *Type* : entier. *Par défaut* : `10`. *Valeur maximale autorisée* : `1024`. + **`neptuneIamRoleArn`**— (*Facultatif*) L'ARN d'un rôle IAM fournissant à Neptune l'accès SageMaker aux ressources AI et Amazon S3. *Type* : string. *Remarque* : Il doit être répertorié dans le groupe de paramètres du cluster de bases de données, sans quoi une erreur sera générée. # Erreurs et exceptions de l'API de gestion Neptune ML Toutes les exceptions de l'API de gestion Neptune ML renvoient un code HTTP 400. Après avoir reçu l'une de ces exceptions, la commande qui a généré l'exception ne doit pas être réessayée. **** + **`MissingParameterException`**   –   Message d'erreur : `Required credentials are missing. Please add IAM role to the cluster or pass as a parameter to this request.` + **`InvalidParameterException`**   –   Messages d'erreur : + `Invalid ML instance type.` + `Invalid ID provided. ID can be 1-48 alphanumeric characters.` + `Invalid ID provided. Must contain only letters, digits, or hyphens.` + `Invalid ID provided. Please check whether a resource with the given ID exists.` + `Another resource with same ID already exists. Please use a new ID.` + `Failed to stop the job because it has already completed or failed.` + **`BadRequestException`**   –   Messages d'erreur : + `Invalid S3 URL or incorrect S3 permissions. Please check your S3 configuration.` + `Provided ModelTraining job has not completed.` + `Provided SageMaker AI Training job has not completed.` + `Provided MLDataProcessing job is not completed.` + `Provided MLModelTraining job doesn't exist.` + `Provided ModelTransformJob doesn't exist.` + `Unable to find SageMaker AI resource. Please check your input.` # Limites de Neptune ML + Les types d'inférence actuellement pris en charge sont la classification de nœud, la régression de nœud, la classification d'arête, la régression d'arête et la prédiction de lien (voir [Fonctionnalités de Neptune ML](machine-learning.md#machine-learning-capabilities)). + La taille de graphe maximale que Neptune ML peut prendre en charge dépend de la quantité de mémoire et de stockage requise lors de la [préparation des données](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size), de l'[entraînement de modèle](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size) et de l'[inférence](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size). + La taille maximale de la mémoire d'une instance de traitement de données SageMaker AI est de 768 Go. Par conséquent, la phase de traitement de données échoue si elle nécessite plus de 768 Go de mémoire. + La taille maximale de la mémoire d'une instance de formation SageMaker AI est de 732 Go. Par conséquent, la phase d'entraînement échoue si elle nécessite plus de 732 Go de mémoire. + La taille maximale d'une charge utile d'inférence pour un point de terminaison SageMaker AI est de 6 MiB. Par conséquent, l'inférence inductive échoue si la charge utile du sous-graphe dépasse cette taille. + Neptune ML n'est actuellement disponible que dans les régions où Neptune et les autres services dont il dépend (tels qu'Amazon API AWS Lambda Gateway et Amazon SageMaker AI) sont tous pris en charge. Il existe des différences dans les régions Chine (Pékin) et Chine (Ningxia) liées à l'utilisation par défaut de l'authentification IAM, comme [expliqué ici](https://docs.amazonaws.cn/en_us/aws/latest/userguide/api-gateway.html#feature-diff), entre autres différences. + Les points de terminaison d'inférence de prédiction de lien lancés par Neptune ML ne peuvent actuellement prédire que les liens possibles avec les nœuds présents dans le graphe au cours de l'entraînement. Prenons l'exemple d'un graphe avec les sommets `User` et `Movie`, et les arêtes `Rated`. En utilisant un modèle de recommandation de prédiction de lien Neptune ML correspondant, vous pouvez ajouter un nouvel utilisateur au graphe et demander au modèle de prédire des films pour lui, mais le modèle peut recommander uniquement les films qui étaient présents lors de l'entraînement du modèle. Bien que l'intégration du nœud `User` soit calculée en temps réel à l'aide de son sous-graphe local et du modèle GNN, et qu'elle puisse donc changer au fil du temps, au fur et à mesure que les utilisateurs évaluent les films, elle est comparée aux intégrations de film précalculées statiques pour la recommandation finale. + Les modèles KGE pris en charge par Neptune ML fonctionnent uniquement pour les tâches de prédiction de lien, et les représentations sont spécifiques aux sommets et aux types d'arête présents dans le graphe pendant l'entraînement. Cela signifie que tous les sommets et types d'arête auxquels il est fait référence dans une requête d'inférence doivent avoir été présents dans le graphe pendant l'entraînement. Il est impossible d'effectuer des prédictions pour de nouveaux types d'arête ou de nouveaux sommets sans réentraîner le modèle. ## SageMaker Limitations des ressources de l'IA En fonction de vos activités et de l'utilisation des ressources au fil du temps, [vous pouvez rencontrer des messages d'erreur indiquant que vous avez dépassé votre quota](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html) ([ResourceLimitExceeded](https://repost.aws/knowledge-center/sagemaker-resource-limit-exceeded-error)). Et pour augmenter vos ressources d' SageMaker IA, suivez les étapes de la procédure [Demander une augmentation du quota de service pour les SageMaker ressources](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure) de cette page pour demander une augmentation de quota au AWS Support. SageMaker Les noms des ressources AI correspondent aux étapes de Neptune ML comme suit : + L' SageMaker IA `ProcessingJob` est utilisée par Neptune pour le traitement des données, la formation des modèles et les tâches de transformation de modèles. + L' SageMaker IA `HyperParameterTuningJob` est utilisée par Neptune Model Training Jobs. + L' SageMaker IA `TrainingJob` est utilisée par Neptune Model Training Jobs. + L' SageMaker IA `Endpoint` est utilisée par les points de terminaison d'inférence de Neptune.