Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Amazon Neptune ML para el machine learning en gráficos A menudo hay información valiosa en grandes conjuntos de datos conectados que puede resultar difícil de extraer mediante consultas basadas únicamente en la intuición humana. Las técnicas de machine learning (ML) pueden ayudar a encontrar correlaciones ocultas en gráficos con miles de millones de relaciones. Estas correlaciones pueden ser útiles para recomendar productos, predecir la solvencia crediticia, identificar el fraude y muchas otras cosas. La característica Neptune ML permite crear y entrenar modelos útiles de machine learning en gráficos de gran tamaño en cuestión de horas en lugar de semanas. [Para lograrlo, Neptune ML utiliza la tecnología de redes neuronales gráficas (GNN) impulsada por [Amazon SageMaker AI](https://aws.amazon.com/sagemaker/) y la [Deep Graph Library (DGL) (que es de código abierto)](https://www.dgl.ai/).](https://github.com/dmlc/dgl/) Las redes neuronales de gráficos son un campo emergente de la inteligencia artificial (consulte, por ejemplo, [A Comprehensive Survey on Graph Neural Networks](https://arxiv.org/abs/1901.00596) [Una encuesta exhaustiva sobre las redes neuronales de gráficos]). Para ver un tutorial práctico sobre su uso GNNs con la DGL, consulte [Aprender redes neuronales gráficas con Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library). **nota** Los vértices de los gráficos se identifican en los modelos de Neptune ML como “nodos”. Por ejemplo, la clasificación de vértices utiliza un modelo de machine learning de clasificación de nodos y la regresión de vértices utiliza un modelo de regresión de nodos. ## Qué puede hacer Neptune ML Neptune admite tanto la inferencia transductiva, que devuelve predicciones que se precalcularon en el momento del entrenamiento, en función de los datos del gráfico en ese momento, como la inferencia inductiva, que devuelve el procesamiento de datos aplicado y la evaluación del modelo en tiempo real, en función de los datos actuales. Consulte [La diferencia entre la inferencia inductiva y la transductiva](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference). Neptune ML puede entrenar modelos de machine learning para que admitan cinco categorías diferentes de inferencia: **Tipos de tareas de inferencia compatibles actualmente con Neptune ML** + **Clasificación de nodos**: predice la característica categórica de una propiedad de vértice. Por ejemplo, con la película *Cadena perpetua* Neptune ML puede predecir su propiedad `genre` como `story` a partir de un conjunto candidato de `[story, crime, action, fantasy, drama, family, ...]`. Existen dos tipos de tareas de clasificación de nodos: + **Clasificación de clase única**: en este tipo de tarea, cada nodo tiene solo una característica de destino. Por ejemplo, la propiedad `Place_of_birth` de `Alan Turing` tiene el valor `UK`. + **Clasificación de varias clases**: en este tipo de tarea, cada nodo puede tener más de una característica de destino. Por ejemplo, la propiedad `genre` de la película *El padrino* tiene los valores `crime` y `story`. + **Regresión de nodos**: predice una propiedad numérica de un vértice. Por ejemplo, con la película *Vengadores: Endgame*, Neptune ML puede predecir que su propiedad `popularity` tiene un valor de `5.0`. + **Clasificación de bordes**: predice la característica categórica de una propiedad de borde. Existen dos tipos de tareas de clasificación de bordes: + **Clasificación de clase única**: en este tipo de tarea, cada borde tiene solo una característica de destino. Por ejemplo, un borde de valoración entre un usuario y una película pueden tener la propiedad `liked` con un valor “Sí” o “No”. + **Clasificación de varias clases**: en este tipo de tarea, cada borde puede tener más de una característica de destino. Por ejemplo, las valoraciones entre un usuario y una película pueden tener varios valores en la etiqueta de propiedad, como, por ejemplo, “Divertido”, “Conmovedor”, “Escalofriante”, etc. + **Regresión de bordes**: predice una propiedad numérica de un borde. Por ejemplo, un borde de valoración entre un usuario y una película puede tener la propiedad numérica `score` para la que Neptune ML puede predecir un valor con un usuario y una película. + **Predicción de enlaces**: predice los nodos de destino más probables par un nodo de origen y un borde de salida en concreto, o los nodos de origen más probables para un nodo de destino y un borde de entrada en concreto. Por ejemplo, con un gráfico de conocimientos sobre enfermedades relacionadas con las drogas, con `Aspirin` como nodo de origen y `treats` como borde de salida, Neptune ML puede predecir los nodos de destino más relevantes como `heart disease`, `fever`, etc. O bien, con el gráfico de conocimientos de Wikimedia, con `President-of` como borde o relación y `United-States` como nodo de destino, Neptune ML puede predecir los dirigentes más relevantes como `George Washington`, `Abraham Lincoln`, `Franklin D. Roosevelt`, etc. **nota** La clasificación de nodos y la clasificación de bordes solo admiten valores de cadena. Esto significa que no se admiten valores de propiedades numéricas como `0` o `1`, aunque sí se admiten los equivalentes de cadena `"0"` y `"1"`. Del mismo modo, los valores de la propiedad Boolean `true` y `false` no funcionan, pero sí lo hacen `"true"` y `"false"`. Con Neptune ML, puede utilizar modelos de machine learning que se dividen en dos categorías generales: **Tipos de modelos de machine learning compatibles actualmente con Neptune ML** + **Modelos de redes neuronales gráficas (GNN)**: incluyen [redes convolucionales gráficas relacionales (R](https://arxiv.org/abs/1703.06103) -). GCNs Los modelos GNN funcionan para los tres tipos de tareas anteriores. + **Modelos de incrustación de gráficos de conocimientos (KGE)**: incluyen los modelos `TransE`, `DistMult` y `RotatE`. Solo funcionan para la predicción de enlaces. **Modelos definidos por el usuario**: Neptune ML también le permite proporcionar su propia implementación de modelo personalizado para todos los tipos de tareas indicados anteriormente. Puede usar el [kit de herramientas de Neptune ML](https://github.com/awslabs/neptuneml-toolkit) para desarrollar y probar la implementación de un modelo personalizado basado en Python antes de usar la API de entrenamiento de Neptune ML con su modelo. Consulte [Modelos personalizados de Neptune ML](machine-learning-custom-models.md) para obtener información sobre cómo estructurar y organizar su implementación para que sea compatible con la infraestructura de entrenamiento de Neptune ML. # Configuración de Neptune ML La forma más sencilla de empezar a utilizar Neptune ML es [utilizar la plantilla de inicio CloudFormation rápido](machine-learning-quick-start.md). Esta plantilla instala todos los componentes necesarios, incluido un nuevo clúster de base de datos de Neptune, todos los roles de IAM necesarios y un nuevo cuaderno de gráficos de Neptune para facilitar el trabajo con Neptune ML. También puede instalar manualmente Neptune ML, tal y como se explica en [Configuración de Neptune ML sin utilizar la plantilla de inicio rápido CloudFormation](machine-learning-manual-setup.md). # Uso de la plantilla de AWS CloudFormation de Neptune ML para empezar a usar rápidamente un nuevo clúster de base de datos La forma más sencilla de comenzar a usar Neptune ML es utilizar la plantilla de inicio rápido de CloudFormation. Esta plantilla instala todos los componentes necesarios, incluido un nuevo clúster de base de datos de Neptune, todos los roles de IAM necesarios y un nuevo cuaderno de gráficos de Neptune para facilitar el trabajo con Neptune ML. **Para crear la pila de inicio rápido de Neptune ML** 1. Para lanzar la pila de CloudFormation en la consola de CloudFormation, elija uno de los botones **Lanzar pila** de la tabla siguiente: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/machine-learning-quick-start.html) 1. En la página **Select Template**, elija **Next**. 1. En la página **Specify Details (Especificar detalles)**, elija **Next (Siguiente)**. 1. En la página **Opciones**, seleccione **Siguiente**. 1. En la página **Revisar**, hay dos casillas de verificación que debe marcar: + La primera reconoce que AWS CloudFormation podría crear recursos de IAM con nombres personalizados. + La segunda reconoce que AWS CloudFormation podría necesitar la capacidad de `CAPABILITY_AUTO_EXPAND` para la nueva pila. `CAPABILITY_AUTO_EXPAND` permite de forma explícita que CloudFormation amplíe las macros automáticamente al crear la pila, sin revisión previa. Los clientes suelen crear un conjunto de cambios a partir de una plantilla procesada para que los cambios realizados por las macros puedan revisarse antes de crear la pila. Para obtener más información, consulte la API [CreateStack](https://docs.aws.amazon.com/AWSCloudFormation/latest/APIReference/API_CreateStack.html) de CloudFormation. A continuación, seleccione **Crear**. La plantilla de inicio rápido crea y configura las siguientes opciones: + Un clúster de base de datos de Neptune. + Los roles de IAM necesarios (y los adjunta). + El grupo de seguridad de Amazon EC2 necesario. + Los puntos de conexión de VPC de SageMaker AI necesarios. + Un grupo de parámetros de clúster de base de datos para Neptune ML. + Los parámetros necesarios para este grupo. + Un cuaderno de SageMaker AI con ejemplos de cuadernos rellenados previamente para Neptune ML. Tenga en cuenta que no todos los tamaños de instancia están disponibles en todas las regiones, por lo que debe asegurarse de que el tamaño de instancia del cuaderno seleccionado sea compatible con su región. + El servicio Neptune-Export. Cuando la pila de inicio rápido esté lista, vaya al cuaderno de SageMaker AI que creó la plantilla y consulte los ejemplos rellenados previamente. Le ayudarán a descargar conjuntos de datos de ejemplo que se pueden utilizar para experimentar con las capacidades de Neptune ML. También pueden ahorrarle mucho tiempo al utilizar Neptune ML. Por ejemplo, consulte el comando mágico de línea [%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml) y el comando mágico de celda [%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml) que son compatibles con estos cuadernos. También puede usar el siguiente comando AWS CLI para ejecutar la plantilla de CloudFormation de inicio rápido: ``` 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) ``` # Configuración de Neptune ML sin utilizar la plantilla de inicio rápido CloudFormation Esta guía proporciona step-by-step instrucciones para configurar Amazon Neptune ML sin utilizar la plantilla de inicio AWS CloudFormation rápido. Se entiende que ya dispone de un clúster de base de datos de Neptune en funcionamiento y se describe la configuración necesaria, incluida la instalación del servicio Neptune-Export, la creación de roles de IAM personalizados y la configuración del clúster de base de datos para habilitar Neptune ML. La guía también explica cómo crear dos puntos finales de SageMaker IA en su VPC de Neptune para que el motor Neptune acceda a la gestión de IA necesaria. SageMaker APIs Si sigue estas instrucciones, puede configurar Neptune ML en su infraestructura de Neptuno existente sin tener que depender de la plantilla. CloudFormation ## Comenzar con un clúster de base de datos de Neptune que funcione Si no utiliza la plantilla de CloudFormation inicio rápido para configurar Neptune ML, necesitará un clúster de base de datos Neptune existente con el que trabajar. Si lo desea, puede usar uno que ya tenga, clonar uno que ya esté utilizando o crear uno nuevo (consulte [Creación de un clúster de Neptune](get-started-create-cluster.md)). ## Instalación del servicio Neptune-Export Si aún no lo ha hecho, instale el servicio Neptune-Export, tal y como se explica en [Uso del servicio Neptune-Export para exportar datos de Neptune](export-service.md). Añada una regla de entrada al grupo de seguridad de `NeptuneExportSecurityGroup` que cree la instalación, con la siguiente configuración: + *Tipo:* `Custom TCP` + *Protocolo*: `TCP` + *Intervalo de puertos*: `80 - 443` + *Origen*: *(Neptune DB cluster security group ID)* ## Cree un rol de IAM de S3 personalizado NeptuneLoadFrom Si aún no lo ha hecho, cree un rol de IAM de `NeptuneLoadFromS3` personalizado, tal como se explica en [Creación de un rol de IAM para acceder a Amazon S3](bulk-load-tutorial-IAM-CreateRole.md). ## Cree un rol personalizado NeptuneSageMaker IAMRole Utilice la [consola de IAM](https://console.aws.amazon.com/iam/) para crear un `NeptuneSageMakerIAMRole` personalizado mediante la siguiente política: ------ #### [ 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" } ] } ``` ------ Al crear este rol, edite la relación de confianza para que quede como se indica a continuación: ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": [ "ec2.amazonaws.com", "rds.amazonaws.com", "sagemaker.amazonaws.com" ] }, "Action": "sts:AssumeRole" } ] } ``` ------ Por último, copie el ARN asignado a este nuevo rol de `NeptuneSageMakerIAMRole`. **importante** Asegúrese de que los permisos de Amazon S3 del `NeptuneSageMakerIAMRole` coincidan con los anteriores. El ARN universal, `arn:aws:s3:::*`, se utiliza para el recurso de Amazon S3 en la política anterior. Si por algún motivo no se puede utilizar el ARN universal, se deben añadir a la sección de recursos `arn:aws:s3:::graphlytics*` y el ARN de cualquier otro recurso de Amazon S3 del cliente que utilicen los comandos de Neptune ML. ## Configuración de un clúster de base de datos para habilitar Neptune ML **Para configurar un clúster de base de datos para Neptune ML** 1. En la [consola de Neptune](https://console.aws.amazon.com/neptune), vaya a **Grupos de parámetros** y, a continuación, al grupo de parámetros del clúster de base de datos asociado al clúster de base de datos que utilizará. Establezca el parámetro `neptune_ml_iam_role` en el ARN asignado al rol de `NeptuneSageMakerIAMRole` que acaba de crear. 1. Vaya a Bases de datos y, a continuación, seleccione el clúster de base de datos que utilizará para Neptune ML. Seleccione **Acciones** y, a continuación, **Administrar roles de IAM**. 1. En la página **Administrar roles de IAM**, seleccione **Añadir rol** y añada `NeptuneSageMakerIAMRole`. A continuación, añada el rol de `NeptuneLoadFromS3`. 1. Reinicie la instancia de escritor del clúster de base de datos. ## Cree dos puntos finales de SageMaker IA en su VPC de Neptune Por último, para que el motor Neptune acceda a la gestión de SageMaker IA necesaria APIs, debe crear dos puntos finales de SageMaker IA en su VPC de Neptune, como se explica en. [Cree dos puntos de conexión para la SageMaker IA en su VPC de Neptune](machine-learning-cluster-setup.md#machine-learning-sm-endpoints) # Configuración manual de un cuaderno de Neptune para Neptune ML Los cuadernos Neptune SageMaker AI vienen precargados con una variedad de cuadernos de muestra para Neptune ML. [Puede obtener una vista previa de estos ejemplos en el repositorio de cuadernos gráficos de código abierto. GitHub ](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning) Puede utilizar uno de los cuadernos de Neptune existentes o, si lo desea, puede crear uno propio siguiendo las instrucciones que se indican en [Uso del entorno de trabajo de Neptune para alojar los cuadernos de Neptune](graph-notebooks.md#graph-notebooks-workbench). También puede configurar un cuaderno de Neptune predeterminado para usarlo con Neptune ML. Para ello, siga estos pasos: **Modificación de un cuaderno para Neptune ML** 1. Abre la consola Amazon SageMaker AI en [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. En el panel de navegación de la izquierda, seleccione **Cuaderno** y, a continuación, **Instancias de cuaderno**. Busque el nombre del cuaderno de Neptune que desee utilizar para Neptune ML y selecciónelo para ir a su página de detalles. 1. Si la instancia del cuaderno se está ejecutando, seleccione el botón **Detener**, situado en la parte superior derecha de la página de detalles del cuaderno. 1. En **Configuración de instancias de cuaderno**, en **Configuración del ciclo de vida**, seleccione el enlace para abrir la página del ciclo de vida del cuaderno. 1. Seleccione **Editar** en la parte superior derecha y, a continuación, **Continuar**. 1. En la pestaña **Iniciar cuaderno**, modifique el script para incluir comandos de exportación adicionales y para rellenar los campos del rol de IAM de Neptune ML y del URI del servicio de exportación, algo parecido a lo siguiente en función del intérprete de comandos: ``` 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. Seleccione **Update (Actualizar)**. 1. Vuelva a la página de instancias del cuaderno. En **Permisos y cifrado** hay un campo para el **ARN del rol de IAM**. Seleccione el enlace de este campo para ir al rol de IAM con el que se ejecuta esta instancia de cuaderno. 1. Cree una nueva política insertada como esta: ------ #### [ 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. Guarde esta nueva política y asóciela al rol de IAM del paso 8. 1. Seleccione **Iniciar** en la parte superior derecha de la página de detalles de la instancia de bloc de notas de SageMaker IA para iniciar la instancia de bloc de notas. # Uso de AWS CLI para configurar Neptune ML en un clúster de base de datos Además de la plantilla CloudFormation de inicio rápido y la Consola de administración de AWS, también puede configurar Neptune ML mediante. AWS CLI ## Creación de un grupo de parámetros de clúster de base de datos para el nuevo clúster de Neptune ML Los siguientes AWS CLI comandos crean un nuevo grupo de parámetros de clúster de base de datos y lo configuran para que funcione con Neptune ML: **Para crear y configurar un grupo de parámetros de clúster de base de datos de Neptune ML** 1. Cree un nuevo grupo de parámetros del clúster de base de datos: ``` 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. Cree un conjunto de parámetros de `neptune_ml_iam_role` clúster de base de datos con el ARN del clúster de base de datos `SageMakerExcecutionIAMRole` para que lo utilice al llamar a la SageMaker IA para crear trabajos y obtener predicciones a partir de modelos de aprendizaje automático alojados: ``` 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) ``` Al configurar este parámetro, Neptune puede acceder a la SageMaker IA sin que tengas que pasar el rol en cada llamada. Para obtener más información sobre cómo crear el `SageMakerExcecutionIAMRole`, consulte [Cree un rol personalizado NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role). 1. Por último, utilice `describe-db-cluster-parameters` para comprobar que todos los parámetros del nuevo grupo de parámetros del clúster de bases de datos estén configurados tal y como desee: ``` 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) ``` ## Adjuntar el nuevo grupo de parámetros de clúster de base de datos al clúster de base de datos que usará con Neptune ML Ahora puede adjuntar el nuevo grupo de parámetros del clúster de base de datos que acaba de crear a un clúster de base de datos existente mediante el siguiente comando: ``` 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) ``` Para que todos los parámetros entren en vigor, puede reiniciar el clúster de base de datos: ``` 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) ``` O bien, si va a crear un nuevo clúster de base de datos para usarlo con Neptune ML, puede usar el siguiente comando para crear el clúster con el nuevo grupo de parámetros adjunto y, a continuación, crear una nueva instancia principal (escritor): ``` 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) ``` ## Adjúntelo `NeptuneSageMakerIAMRole` a su clúster de base de datos para que pueda acceder a los recursos de SageMaker AI y Amazon S3 Por último, siga las instrucciones [Cree un rol personalizado NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role) para crear un rol de IAM que permita que su clúster de base de datos se comunique con SageMaker AI y Amazon S3. A continuación, utilice el siguiente comando para adjuntar el rol de `NeptuneSageMakerIAMRole` que creó al clúster de base de datos: ``` 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) ``` ## Cree dos puntos de conexión para la SageMaker IA en su VPC de Neptune Neptune ML necesita dos puntos finales de SageMaker IA en la VPC de su clúster de base de datos de Neptune: + `com.amazonaws.(AWS region, like us-east-1).sagemaker.runtime` + `com.amazonaws.(AWS region, like us-east-1).sagemaker.api` Si no ha utilizado la CloudFormation plantilla de inicio rápido, que las crea automáticamente, puede utilizar los siguientes comandos para crearlas: AWS CLI Este crea el punto de conexión de `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 ``` Este otro crea el punto de conexión de `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 ``` También puede usar la [consola de la VPC](https://console.aws.amazon.com/vpc/) para crear estos puntos de conexión. Consulte [Proteger las llamadas de predicción en Amazon SageMaker con AWS PrivateLink](https://aws.amazon.com/blogs/machine-learning/secure-prediction-calls-in-amazon-sagemaker-with-aws-privatelink/) y [Proteger todas las llamadas a la SageMaker API de Amazon con AWS PrivateLink](https://aws.amazon.com/blogs/machine-learning/securing-all-amazon-sagemaker-api-calls-with-aws-privatelink/). ## Cree un parámetro de punto final de inferencia de SageMaker IA en el grupo de parámetros de su clúster de base de datos Para evitar tener que especificar el punto final de inferencia de SageMaker IA del modelo que utiliza en cada consulta que le realice, cree un parámetro de clúster de base de datos denominado `neptune_ml_endpoint` en el grupo de parámetros del clúster de base de datos de Neptune ML. Establezca el parámetro en el `id` del punto de conexión de la instancia en cuestión. Para ello, puede utilizar el siguiente AWS CLI comando: ``` 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) ``` # Información general sobre cómo utilizar la característica Neptune ML La característica Neptune ML de Amazon Neptune proporciona un flujo de trabajo optimizado para aprovechar los modelos de machine learning dentro de una base de datos de gráficos. El proceso incluye varios pasos clave: exportar datos de Neptune a formato CSV, preprocesar los datos para prepararlos para el entrenamiento del modelo, entrenar el modelo de machine learning con Amazon SageMaker AI, crear un punto de conexión de inferencia para ofrecer predicciones y, a continuación, consultar el modelo directamente desde consultas de Gremlin. El entorno de trabajo de Neptune proporciona cómodos comandos mágicos de línea y celda para ayudar a administrar y automatizar estos pasos. Al integrar las capacidades de machine learning directamente en la base de datos de gráficos, Neptune ML permite a los usuarios obtener información valiosa y realizar predicciones a partir de la gran cantidad de datos relacionales almacenados en el gráfico de Neptune. ## Inicio del flujo de trabajo para usar Neptune ML Para empezar, el uso de la característica Neptune ML en Amazon Neptune suele implicar los cinco pasos siguientes: ![\[Diagrama de flujo de trabajo de Neptune ML\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/neptune-ML-workflow.png) 1. **Configuración y exportación de datos**: el paso de exportación de datos utiliza el servicio Neptune-Export o la herramienta de línea de comandos de `neptune-export` para exportar datos de Neptune a Amazon Simple Storage Service (Amazon S3) en formato CSV. Al mismo tiempo, se genera automáticamente un archivo de configuración denominado `training-data-configuration.json`, que especifica cómo se pueden cargar los datos exportados en un gráfico entrenable. 1. **Preprocesamiento de datos**: en este paso, el conjunto de datos exportado se procesa previamente mediante técnicas estándar para prepararlo para el entrenamiento de modelos. La normalización de características se puede realizar para datos numéricos, y las características de texto se pueden codificar mediante `word2vec`. Al final de este paso, se genera un gráfico DGL a partir del conjunto de datos exportado para utilizarlo en el paso de entrenamiento de modelos. Este paso se implementa mediante un trabajo de procesamiento de SageMaker AI en la cuenta, y los datos resultantes se almacenan en la ubicación de Amazon S3 que haya especificado. 1. **Entrenamiento de modelos**: el paso de entrenamiento de modelos entrena el modelo de machine learning que se utilizará para las predicciones. El entrenamiento de modelos se realiza en dos etapas: + La primera etapa utiliza un trabajo de procesamiento de SageMaker AI para generar un conjunto de configuraciones de estrategias de entrenamiento de modelos que especifica qué tipo de modelo y qué rangos de hiperparámetros del modelo se utilizarán para el entrenamiento. + La segunda etapa utiliza un trabajo de ajuste del modelo de SageMaker AI para probar diferentes configuraciones de hiperparámetros y seleccionar el trabajo de entrenamiento que produjo el modelo con el mejor rendimiento. El trabajo de ajuste ejecuta un número previamente especificado de pruebas de trabajo de entrenamiento de modelos con los datos procesados. Al final de esta etapa, se utilizan los parámetros del modelo entrenado del mejor trabajo de entrenamiento para generar artefactos del modelo para su inferencia. 1. **Creación de un punto de conexión de inferencia en Amazon SageMaker AI**: el punto de conexión de inferencia es una instancia de punto de conexión de SageMaker AI que se lanza con los artefactos del modelo producidos por el mejor trabajo de entrenamiento. Cada modelo está vinculado a un único punto de conexión. El punto de conexión puede aceptar las solicitudes entrantes de la base de datos de gráficos y devolver las predicciones de modelos para las entradas de las solicitudes. Una vez creado el punto de conexión, permanecerá activo hasta que lo elimine. 1. **Consulta del modelo de machine learning mediante Gremlin**: puede utilizar extensiones del lenguaje de consultas de Gremlin para consultar las predicciones desde el punto de conexión de inferencia. **nota** El [entorno de trabajo de Neptune](graph-notebooks.md#graph-notebooks-workbench) incluye un comando mágico de línea y un comando mágico de celda que pueden ahorrarle mucho tiempo en la administración de estos pasos, es decir: [%neptune\$1ml](notebooks-magics.md#notebooks-line-magics-neptune_ml) [%%neptune\$1ml](notebooks-magics.md#notebooks-cell-magics-neptune_ml) # Hacer predicciones basadas en los datos de los gráficos en constante evolución Con un gráfico que cambia continuamente, es posible que desee crear de forma periódica nuevas predicciones por lotes con datos nuevos. La consulta de predicciones calculadas previamente (inferencia transductiva) puede ser considerablemente más rápida que generar nuevas predicciones sobre la marcha a partir de los datos más recientes (inferencia inductiva). Ambos enfoques son válidos en función de la rapidez con la que cambien los datos y de los requisitos de rendimiento. ## La diferencia entre la inferencia inductiva y la transductiva Al realizar una inferencia transductiva, Neptune busca y devuelve las predicciones que se han calculado previamente en el momento del entrenamiento. Al realizar una inferencia inductiva, Neptune crea el subgráfico correspondiente y obtiene sus propiedades. A continuación, el modelo DGL GNN aplica el procesamiento de datos y la evaluación del modelo en tiempo real. Por lo tanto, la inferencia inductiva puede generar predicciones con nodos y bordes que no estaban presentes en el momento del entrenamiento y que reflejan el estado actual del gráfico. Sin embargo, esto se produce a costa de una mayor latencia. Si el gráfico es dinámico, es posible que desee utilizar la inferencia inductiva para asegurarse de tener en cuenta los datos más recientes, pero si el gráfico es estático, la inferencia transductiva es más rápida y eficaz. La inferencia inductiva está deshabilitada de forma predeterminada. Si desea habilitarla para una consulta, utilice de la siguiente manera el predicado [Neptune\$1ml.inductiveInference](machine-learning-gremlin-inference-query-predicates.md#machine-learning-gremlin-inference-neptune-ml-inductiveInference) de Gremlin en la consulta: ``` .with( "Neptune#ml.inductiveInference") ``` # Flujos de trabajo de inferencias transductivas incrementales Mientras actualiza los artefactos de modelos (para ello, vuelve a realizar los pasos del uno al tres [desde **Configuración y exportación de datos** hasta **Transformación de modelos**]), Neptune ML va admitiendo formas más sencillas de actualizar sus predicciones de ML por lotes con nuevos datos. Una opción es utilizar un [flujo de trabajo de modelos incrementales](#machine-learning-overview-incremental), y otra consiste en utilizar el [reentrenamiento de modelos con un inicio en caliente](#machine-learning-overview-model-retraining). ## Flujo de trabajo de modelos incrementales En este flujo de trabajo, se actualizan las predicciones de ML sin volver a entrenar el modelo de ML. **nota** Solo puede hacerlo cuando los datos del gráfico se hayan actualizado con nuevos nodos o bordes. Actualmente, no funcionará cuando se eliminen los nodos. 1. **Configuración y exportación de datos**: este paso es el mismo que en el flujo de trabajo principal. 1. **Preprocesamiento incremental de datos**: este paso es similar al paso de preprocesamiento de datos del flujo de trabajo principal, pero utiliza la misma configuración de procesamiento utilizada anteriormente, que corresponde a un determinado modelo entrenado. 1. **Transformación de modelos**: en lugar de un paso de entrenamiento del modelo, este paso de transformación del modelo extrae el modelo entrenado del flujo de trabajo principal y los resultados del paso de preprocesamiento incremental de datos, y genera nuevos artefactos de modelos para utilizarlos en la inferencia. El paso de transformación de modelos inicia un trabajo de procesamiento de SageMaker AI para realizar el cálculo que genera los artefactos de modelos actualizados. 1. **Actualización del punto de conexión de inferencia de Amazon SageMaker AI**: si lo prefiere, si cuenta con un punto de conexión de inferencia existente, este paso actualiza el punto de conexión con los nuevos artefactos de modelos generados por el paso de transformación de modelos. Además, puede crear un nuevo punto de conexión de inferencia con los nuevos artefactos de modelos. ## Reentrenamiento de modelos con un inicio en caliente Con este flujo de trabajo, puede entrenar e implementar un nuevo modelo de ML para hacer predicciones con los datos de los gráficos incrementales, pero basándose en un modelo existente generado mediante el flujo de trabajo principal: 1. **Configuración y exportación de datos**: este paso es el mismo que en el flujo de trabajo principal. 1. **Preprocesamiento incremental de datos**: este paso es el mismo que en el flujo de trabajo de inferencia del modelo incremental. Los nuevos datos del gráfico deben procesarse con el mismo método de procesamiento que se utilizó anteriormente para el entrenamiento del modelo. 1. **Entrenamiento de modelos con un inicio en caliente**: el entrenamiento de modelos es similar a lo que ocurre en el flujo de trabajo principal, pero puede acelerar la búsqueda de hiperparámetros del modelo con el fin de sacar partido de la información de la tarea anterior de entrenamiento con modelos. 1. **Actualización del punto de conexión de inferencia de Amazon SageMaker AI**: este paso es el mismo que en el flujo de trabajo de inferencia de modelos incrementales. # Flujos de trabajo de modelos personalizados en Neptune ML Neptune ML le permite implementar y entrenar sus propios modelos personalizados para cualquiera de las tareas compatibles con Neptune ML. El flujo de trabajo para desarrollar e implementar un modelo personalizado es básicamente el mismo que el de los modelos integrados, con algunas diferencias, tal y como se explica en [Flujo de trabajo de modelos personalizados](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow). # Selección de instancias para las etapas de Neptune ML Las diferentes etapas del procesamiento de Neptune ML utilizan distintas instancias de SageMaker AI. A continuación, explicaremos cómo elegir el tipo de instancia adecuado para cada etapa. Puede encontrar información sobre los tipos de instancia de SageMaker AI y sus precios en [Precios de Amazon SageMaker](https://aws.amazon.com/sagemaker/pricing/). ## Selección de una instancia para el procesamiento de datos El paso de [procesamiento de datos](machine-learning-on-graphs-processing.md) de SageMaker AI requiere una [instancia de procesamiento](https://docs.aws.amazon.com/sagemaker/latest/dg/processing-job.html) que tenga suficiente memoria y almacenamiento en disco para los datos de entrada, intermedios y de salida. La cantidad específica de memoria y almacenamiento en disco que se necesita depende de las características del gráfico de Neptune ML y sus características exportadas. De forma predeterminada, Neptune ML elige la instancia `ml.r5` de menor tamaño cuya memoria sea diez veces mayor que el tamaño de los datos de gráficos exportados en el disco. ## Selección de una instancia para el entrenamiento y la transformación de modelos La selección del tipo de instancia correcto para el [entrenamiento de modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-training.html) o la [transformación de modelos](https://docs.aws.amazon.com/sagemaker/latest/dg/how-it-works-batch.html) depende del tipo de tarea, el tamaño del gráfico y los requisitos de entrega. Las instancias de GPU proporcionan el mejor rendimiento. Por lo general, recomendamos las instancias de serie `p3` y `g4dn`. También puede usar instancias `p2` o `p4d`. De forma predeterminada, Neptune ML elige la instancia de GPU de menor tamaño y con más memoria que la que necesitan el entrenamiento y la transformación de modelos. Puede encontrar esta selección en el archivo `train_instance_recommendation.json`, en la ubicación de salida del procesamiento de datos de Amazon S3. A continuación, se muestra un ejemplo del contenido de un archivo `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)" } ``` ## Selección de una instancia para un punto de conexión de inferencia La selección del tipo de instancia correcto para un [punto de conexión de inferencia](machine-learning-on-graphs-inference-endpoint.md) depende del tipo de tarea, del tamaño del gráfico y del presupuesto. De forma predeterminada, Neptune ML elige la instancia `ml.m5d` de menor tamaño y con más memoria que la que necesita el punto de conexión de inferencia. **nota** Si se necesitan más de 384 GB de memoria, Neptune ML usa una instancia `ml.r5d.24xlarge`. Puede ver el tipo de instancia que recomienda Neptune ML en el archivo `infer_instance_recommendation.json`, que se encuentra en la ubicación de Amazon S3 que está utilizando para el entrenamiento de modelos. A continuación, se muestra un ejemplo del contenido de ese archivo: ``` { "instance" : "(the recommended instance type for an inference endpoint)", "disk_size" : "(the estimated disk space required)", "mem_size" : "(the estimated memory required)" } ``` # Uso de la herramienta neptune-export o el servicio Neptune-Export para exportar datos de Neptune para Neptune ML Neptune ML requiere que proporcione datos de entrenamiento para que la biblioteca [Deep Graph Library (DGL)](https://www.dgl.ai/) cree y evalúe modelos. Puede exportar datos de Neptune mediante el [servicio Neptune-Export](export-service.md) o la [utilidad `neptune-export`](export-utility.md). Tanto el servicio como la herramienta de línea de comandos publican datos en Amazon Simple Storage Service (Amazon S3) en formato CSV, que se cifran mediante cifrado del lado del servidor de Amazon S3 (`SSE-S3`). Consulte [Archivos exportados por Neptune-Export y `neptune-export`](exported-files.md). Además, al configurar una exportación de datos de entrenamiento para Neptune ML, el trabajo de exportación crea y publica un archivo de configuración de entrenamiento de modelos cifrado junto con los datos exportados. De forma predeterminada, este archivo recibe el nombre de `training-data-configuration.json`. # Ejemplos del uso del servicio Neptune-Export para exportar datos de entrenamiento para Neptune ML Esta solicitud exporta datos de entrenamiento de gráficos de propiedades para una tarea de clasificación de nodos: ``` 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" } ] } } }' ``` Esta solicitud exporta datos de entrenamiento de RDF para una tarea de clasificación de nodos: ``` 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" } ] } } }' ``` # Campos que hay que configurar en el objeto params al exportar los datos de entrenamiento El objeto `params` de una solicitud de exportación puede incluir varios campos, tal y como se describe en la [documentación de `params`](export-params-fields.md). Los siguientes son los más relevantes a la hora de exportar datos de entrenamiento de machine learning: **** + **`endpoint`**: utilice `endpoint` para especificar un punto de conexión de una instancia de Neptune en su clúster de base de datos que el proceso de exportación pueda consultar para extraer datos. + **`profile`**: el campo `profile` del objeto `params` debe establecerse en **`neptune-ml`**. Esto provoca que el proceso de exportación formatee los datos exportados de forma adecuada para el entrenamiento de modelos de Neptune ML, en formato CSV para datos de gráficos de propiedades o como N-Triples para datos de RDF. También origina que se cree y escriba un archivo `training-data-configuration.json` en la misma ubicación de Amazon S3 que los datos de entrenamiento exportados. + **`cloneCluster`**: si se establece en `true`, el proceso de exportación clona el clúster de base de datos, lo exporta desde el clon y, al finalizar, elimina el clon. + **`useIamAuth`**: si el clúster de base de datos tiene habilitada la [autenticación de IAM](iam-auth-enable.md), debe incluir este campo establecido en `true`. El proceso de exportación también proporciona varias formas de filtrar los datos que exporta (consulte [estos ejemplos](export-filtering-examples.md)). # Uso del objeto additionalParams para ajustar la exportación de la información de entrenamiento de modelos El objeto `additionalParams` incluye campos que puede utilizar para especificar las etiquetas y características de las clases de machine learning con fines de entrenamiento y para dar instrucciones en la creación de un archivo de configuración de datos de entrenamiento. El proceso de exportación no puede inferior automáticamente las propiedades de nodo y borde que deben ser las etiquetas de las clases de machine learning para que sirvan de ejemplo con fines de entrenamiento. Tampoco puede inferir automáticamente la mejor codificación de características para las propiedades numéricas, categóricas y de texto, por lo que es necesario proporcionar sugerencias mediante los campos del objeto `additionalParams` para especificar estas opciones o anular la codificación predeterminada. En el caso de los datos de gráficos de propiedades, la estructura de nivel superior de `additionalParams` de una solicitud de exportación podría tener el siguiente aspecto: ``` { "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) ] } } } ``` En el caso de los datos de RDF, su estructura de nivel superior podría tener este aspecto: ``` { "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) ] } } } ``` También puede establecer varias configuraciones de exportación mediante el campo `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) ] } ] } } } ``` # Elementos de nivel superior en el campo neptune\$1ml de additionalParams ## El elemento version de neptune\$1ml Especifica la versión de la configuración de datos de entrenamiento que se va a generar. (*Opcional*), *Tipo*: cadena. *Valor predeterminado*: “v2.0”. Si incluye `version`, establézcala en `v2.0`. ## El campo jobs de neptune\$1ml Incluye una matriz de objetos de configuración de datos de entrenamiento, cada uno de los cuales define un trabajo de procesamiento de datos e incluye: + **`name`**: el nombre de la configuración de datos de entrenamiento que se va a crear. Por ejemplo, una configuración de datos de entrenamiento con el nombre “job-number-1” da como resultado un archivo de configuración de datos de entrenamiento denominado `job-number-1.json`. + **`targets`**: una matriz de JSON de destinos de etiquetas de clases de nodos y bordes que representan las etiquetas de clases de machine learning con fines de entrenamiento. Consulte [El campo targets de un objeto neptune\$1ml](machine-learning-neptune_ml-targets.md). + **`features`**: una matriz de JSON de características de propiedades de nodos. Consulte [El campo features en neptune\$1ml](machine-learning-neptune_ml-features.md). # El campo targets de un objeto neptune\$1ml El campo `targets` de una configuración de exportación de datos de entrenamiento de JSON incluye una matriz de objetos de destino que especifica una tarea de entrenamiento y las etiquetas de las clases de machine learning para entrenar esta tarea. El contenido de los objetos de destino varía en función de si se está entrenando con datos de gráficos de propiedades o con datos RDF. En el caso de las tareas de regresión y clasificación de nodos de gráficos de propiedades, los objetos de destino de la matriz pueden tener el siguiente aspecto: ``` { "node": "(node property-graph label)", "property": "(property name)", "type" : "(used to specify classification or regression)", "split_rate": [0.8,0.2,0.0], "separator": "," } ``` En el caso de las tareas de predicción de enlaces, regresión o clasificación de bordes de gráficos de propiedades, pueden tener el siguiente aspecto: ``` { "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": "," } ``` En el caso de las tareas de regresión y clasificación de nodos de RDF, los objetos de destino de la matriz pueden tener el siguiente aspecto: ``` { "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] } ``` En el caso de las tareas de predicción de enlaces de RDF, los objetos de destino de la matriz pueden tener el siguiente aspecto: ``` { "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] } ``` Los objetos de destino pueden incluir los siguientes campos: **Contents** + [Campos de destino de gráfico de propiedades](#machine-learning-property-graph-neptune_ml-targets) + [nodo](#machine-learning-property-graph-neptune_ml-targets-node) + [límite](#machine-learning-property-graph-neptune_ml-targets-edge) + [propiedad](#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) + [Campos de destino de RDF](#machine-learning-RDF-neptune_ml-targets) + [nodo](#machine-learning-RDF-neptune_ml-targets-node) + [subject](#machine-learning-RDF-neptune_ml-targets-subject) + [predicate](#machine-learning-RDF-neptune_ml-targets-predicate) + [objeto](#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) ## Campos de un objeto de destino de gráfico de propiedades ### El campo node (vertex) de un objeto de destino La etiqueta de gráfico de propiedades de un nodo de destino (vértice). Un objeto de destino debe incluir un elemento `node` o un elemento `edge`, pero no ambos. Un `node` puede tomar un único valor, como este: ``` "node": "Movie" ``` O bien, en el caso de un vértice con varias etiquetas, puede tomar una matriz de valores, como, por ejemplo: ``` "node": ["Content", "Movie"] ``` ### El campo edge de un objeto de destino de gráfico de propiedades Especifica un bordes de destino mediante sus etiquetas de nodo inicial, su propia etiqueta y sus etiquetas de nodo final. Un objeto de destino debe incluir un elemento `edge` o un elemento `node`, pero no ambos. El valor de un campo `edge` es una matriz JSON de tres cadenas que representan las etiquetas del gráfico de propiedades del nodo inicial, la etiqueta del gráfico de propiedades del propio borde y las etiquetas del gráfico de propiedades del nodo final, de la siguiente manera: ``` "edge": ["Person_A", "knows", "Person_B"] ``` Si el nodo and/or final del nodo de inicio tiene varias etiquetas, enciérrelas en una matriz, de la siguiente manera: ``` "edge": [ ["Admin", Person_A"], "knows", ["Admin", "Person_B"] ] ``` ### El campo property de un objeto de destino de gráfico de propiedades Especifica una propiedad del vértice o borde de destino, como, por ejemplo: ``` "property" : "rating" ``` Este campo es obligatorio, excepto cuando la tarea de destino es la predicción de enlaces. ### El campo type de un objeto de destino de gráfico de propiedades Indica el tipo de tarea de destino que se va a realizar en el `node` o la `edge`, como, por ejemplo: ``` "type" : "regression" ``` Los tipos de tareas compatibles con los nodos son: + `classification` + `regression` Los tipos de tareas compatibles con los bordes son: + `classification` + `regression` + `link_prediction` Este campo es obligatorio. ### El campo split\$1rate de un objeto de destino de gráfico de propiedades (*Opcional*) Una estimación de las proporciones de los nodos o los bordes que utilizarán las etapas de entrenamiento, validación y prueba, respectivamente. Estas proporciones se representan mediante una matriz de JSON de tres números entre cero y uno que suman uno: ``` "split_rate": [0.7, 0.1, 0.2] ``` Si no proporciona el campo opcional `split_rate`, el valor estimado por defecto es `[0.9, 0.1, 0.0]` para las tareas de clasificación y regresión y `[0.9,0.05, 0.05]` para las tareas de predicción de enlaces. ### El campo separator de un objeto de destino de gráfico de propiedades (*Opcional*) Se utiliza con una tarea de clasificación. El campo `separator` especifica un carácter que se utiliza para dividir el valor de una propiedad de destino en varios valores categóricos cuando se utiliza para almacenar varios valores de categoría en una cadena. Por ejemplo: ``` "separator": "|" ``` La presencia de un campo `separator` indica que la tarea es una tarea de clasificación con varios destinos. ## Campos de un objeto de destino de RDF ### El campo node de un objeto de destino de RDF Define el tipo de nodo de los nodos de destino. Se utiliza con tareas de clasificación de nodos o tareas de regresión de nodos. El tipo de nodo de un nodo de RDF se define mediante: ``` node_id, , node_type ``` Un `node` de RDF puede tomar un único valor, como este: ``` "node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie" ``` ### El campo subject de un objeto de destino de RDF En el caso de las tareas de predicción de enlaces, `subject` define el tipo de nodo de origen de los bordes de destino. ``` "subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director" ``` **nota** En el caso de las tareas de predicción de enlaces, `subject` debe usarse junto con `predicate` y `object`. Si no se proporciona alguna de estas tres opciones, todos los bordes se consideran el destino de entrenamiento. ### El campo predicate de un objeto de destino de RDF En el caso de las tareas de regresión y clasificación de nodos, `predicate` define los datos literales que se utilizan como la característica del nodo de destino de un nodo de destino. ``` "predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre" ``` **nota** Si los nodos de destino solo tienen un predicado que define la característica del nodo de destino, se puede omitir el campo `predicate`. En el caso de las tareas de predicción de enlaces, `predicate` define el tipo de relación de los bordes de destino: ``` "predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/direct" ``` **nota** En el caso de las tareas de predicción de enlaces, `predicate` debe usarse junto con `subject` y `object`. Si no se proporciona alguna de estas tres opciones, todos los bordes se consideran el destino de entrenamiento. ### El campo object de un objeto de destino de RDF En el caso de las tareas de predicción de enlaces, `object` define el tipo de nodo de destino de los bordes de destino: ``` "object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie" ``` **nota** En el caso de las tareas de predicción de enlaces, `object` debe usarse junto con `subject` y `predicate`. Si no se proporciona alguna de estas tres opciones, todos los bordes se consideran el destino de entrenamiento. ### El campo type de un objeto de destino de RDF Indica el tipo de tarea de destino que se va a realizar, como, por ejemplo: ``` "type" : "regression" ``` Los tipos de tareas compatibles con los datos de RDF son: + `link_prediction` + `classification` + `regression` Este campo es obligatorio. ### El campo `split_rate` de un objeto de destino de gráfico de propiedades (*Opcional*) Una estimación de las proporciones de los nodos o los bordes que utilizarán las etapas de entrenamiento, validación y prueba, respectivamente. Estas proporciones se representan mediante una matriz de JSON de tres números entre cero y uno que suman uno: ``` "split_rate": [0.7, 0.1, 0.2] ``` Si no proporciona el campo opcional `split_rate`, el valor estimado predeterminado es `[0.9, 0.1, 0.0]`. # El campo features en neptune\$1ml Los valores de las propiedades y los literales de RDF están disponibles en diferentes formatos y tipos de datos. Para lograr un buen rendimiento en el machine learning, es fundamental convertir esos valores en codificaciones numéricas conocidas como *características.* Neptune ML realiza la extracción y codificación de características como parte de los pasos de exportación y procesamiento de datos, tal y como se describe en [Codificación de características en Neptune ML](machine-learning-feature-encoding.md). En el caso de los conjuntos de datos de gráficos de propiedades, el proceso de exportación infiere automáticamente las características `auto` de las propiedades de cadenas y de las propiedades numéricas que incluyen varios valores. En el caso de las propiedades numéricas que incluyen valores únicos, infiere las características `numerical`. En el caso de las propiedades de fecha, infiere las características `datetime`. Si desea anular una especificación de entidad inferida automáticamente o añadir una especificación numérica de segmento, TF-IDF o SBERT para una propiedad FastText, puede controlar la codificación de la entidad mediante el campo de características. **nota** Solo puede usar el campo `features` para controlar las especificaciones de las características de los datos del gráfico de propiedades, no de los datos de RDF. En el caso de textos de formato libre, Neptune ML puede utilizar varios modelos diferentes para convertir la secuencia de tokens de un valor de propiedad de cadena en un vector de valor real de tamaño fijo: + [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features): utiliza la codificación [fastText](https://fasttext.cc/). Esta es la codificación recomendada para las características que utilizan solo uno de los cinco idiomas que admite FastText. + [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-sbert-features): utiliza los modelos de codificación [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Esta es la codificación recomendada para el texto que no admite `text_fasttext`. + [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features): utiliza los algoritmos [Word2Vec](https://wikipedia.org/wiki/Word2vec) publicados originalmente por [Google](https://code.google.com/archive/p/word2vec/) para codificar texto. Word2Vec solo admite inglés. + [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features): utiliza un vectorizador de [frecuencia de términos - frecuencia inversa de documentos](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) para codificar texto. La codificación TF-IDF admite características estadísticas que las demás codificaciones no admiten. El campo `features` incluye una matriz de JSON de características de propiedades de nodos. Los objetos de la matriz pueden incluir los siguientes campos: **Contents** + [nodo](#machine-learning-neptune_ml-features-node) + [límite](#machine-learning-neptune_ml-features-edge) + [propiedad](#machine-learning-neptune_ml-features-property) + [type](#machine-learning-neptune_ml-feature-types) + [norm](#machine-learning-neptune_ml-features-norm) + [idioma](#machine-learning-neptune_ml-features-language) + [max\$1length](#machine-learning-neptune_ml-features-max_length) + [separator](#machine-learning-neptune_ml-features-separator) + [rango](#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) ## El campo node en las características El campo `node` especifica una etiqueta de gráfico de propiedades de un vértice de característica. Por ejemplo: ``` "node": "Person" ``` Si un vértice tiene varias etiquetas, utilice una matriz para incluir todas ellas. Por ejemplo: ``` "node": ["Admin", "Person"] ``` ## El campo edge en las características El campo `edge` especifica el tipo de borde del borde de una característica. Un tipo de borde consiste en una matriz que incluye las etiquetas del gráfico de propiedades del vértice de origen, la etiqueta del gráfico de propiedades del borde y las etiquetas del gráfico de propiedades del vértice de destino. Debe proporcionar los tres valores al especificar una característica de borde. Por ejemplo: ``` "edge": ["User", "reviewed", "Movie"] ``` Si un vértice de origen o destino de un tipo de borde tiene varias etiquetas, utilice otra matriz para incluir todas ellas. Por ejemplo: ``` "edge": [["Admin", "Person"]. "edited", "Post"] ``` ## El campo property en las características Utilice el parámetro de propiedad para especificar una propiedad del vértice identificado por el parámetro `node`. Por ejemplo: ``` "property" : "age" ``` ## Valores posibles del campo type para las características El parámetro `type` especifica el tipo de característica que se está definiendo. Por ejemplo: ``` "type": "bucket_numerical" ``` **Valores posibles del parámetro `type`** + **`"auto"`**: especifica que Neptune ML debe detectar automáticamente el tipo de propiedad y aplicar una codificación de característica adecuada. Una característica `auto` también puede tener un campo opcional `separator`. Consulte [Codificación automática de características en Neptune ML](machine-learning-feature-encoding.md#machine-learning-auto-encoding). + **`"category"`**: esta codificación de característica representa el valor de una propiedad como una de varias categorías. Dicho de otro modo, la característica puede tomar uno o varios valores discretos. Una característica `category` también puede tener un campo opcional `separator`. Consulte [Características categóricas de Neptune ML](machine-learning-feature-encoding.md#machine-learning-categorical-features). + **`"numerical"`**: esta codificación de característica representa los valores de propiedades numéricas como números en un intervalo continuo en el que los valores “mayor que” y “menor que” tienen relevancia. Una característica `numerical` también puede tener los campos opcionales `norm`, `imputer` y `separator`. Consulte [Características numéricas de Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features). + **`"bucket_numerical"`**: esta codificación de característica divide los valores de propiedades numéricas en un conjunto de *buckets* o categorías. Por ejemplo, podrías codificar las edades de las personas en cuatro grupos: niños (0-20), adultos jóvenes (20-40), personas de mediana edad (40-60) y personas mayores (más de 60 años). Una `bucket_numerical` función requiere un campo `range` y un `bucket_cnt` campo y, de forma opcional, también puede incluir un campo. `imputer` and/or `slide_window_size` Consulte [Características numéricas por bucket de Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). + **`"datetime"`**: esta codificación de característica representa el valor de una propiedad de fecha y hora como una matriz de estas características categóricas: año, mes, día de la semana y hora. Se pueden eliminar una o varias de estas cuatro categorías mediante el parámetro `datetime_parts`. Consulte [Características de fecha y hora de Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features). + **`"text_fasttext"`**: esta codificación de característica convierte los valores de propiedad que constan de frases o texto de formato libre en vectores numéricos mediante modelos [fastText](https://fasttext.cc/). Es compatible con cinco idiomas: inglés (`en`), chino (`zh`), hindi (`hi`), español (`es`) y francés (`fr`). En el caso de los valores de propiedades de texto en cualquiera de esos cinco idiomas, se recomienda la codificación `text_fasttext`. Sin embargo, no admite casos en los que la misma frase incluya palabras en más de un idioma. Para otros idiomas distintos de los que admite fastText, utilice la codificación `text_sbert`. Si tiene muchas cadenas de texto de valor de propiedad de más de, por ejemplo, 120 caracteres, utilice el campo `max_length` para limitar el número de tokens en cada cadena que `"text_fasttext"` codifique. Consulte [Codificación *fastText* de valores de propiedades de texto en Neptune ML](machine-learning-feature-encoding.md#machine-learning-fasttext-features). + **`"text_sbert"`**: esta codificación convierte los valores de las propiedades de texto en vectores numéricos mediante los modelos [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Neptune admite dos métodos SBERT, es decir `text_sbert128`, que es el predeterminado si solo se especifica `text_sbert` y. `text_sbert512`. La diferencia entre ellos es el número máximo de tokens de una propiedad de texto que se codifica. La codificación `text_sbert128` solo codifica los primeros 128 tokens, mientras que `text_sbert512` codifica hasta 512 tokens. Como resultado, el uso de `text_sbert512` puede requerir más tiempo de procesamiento que `text_sbert128`. Ambos métodos son más lentos que `text_fasttext`. Los métodos `text_sbert*` admiten muchos idiomas y pueden codificar una frase que incluya más de un idioma. Consulte [Codificación de frases BERT (SBERT) de características de texto en Neptune ML](machine-learning-feature-encoding.md#machine-learning-sbert-features). + **`"text_word2vec"`**: esta codificación convierte los valores de las propiedades de texto en vectores numéricos mediante los algoritmos [Word2Vec](https://wikipedia.org/wiki/Word2vec). Solo es compatible con el inglés. Consulte [Codificación Word2Vec de características de texto en Neptune ML](machine-learning-feature-encoding.md#machine-learning-word2vec-features). + **`"text_tfidf"`**: esta codificación convierte los valores de las propiedades de texto en vectores numéricos mediante un vectorizador de [frecuencia de términos - frecuencia inversa de documentos](https://wikipedia.org/wiki/Tf-idf) (TF-IDF). Los parámetros de un codificación de característica `text_tfidf` se definen mediante el campo `ngram_range`, el campo `min_df` y el campo `max_features`. Consulte [Codificación TF-IDF de características de texto en Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features). + **`"none"`**: el uso del tipo `none` provoca que no se produzca ninguna codificación de características. En cambio, los valores de las propiedades sin procesar se analizan y se guardan. Utilice `none` solo si tiene previsto realizar su propia codificación personalizada de características como parte del entrenamiento con modelos personalizados. ## El campo norm Este campo es obligatorio para las características numéricas. Especifica un método de normalización para usar en valores numéricos: ``` "norm": "min-max" ``` Se admiten los siguientes métodos de normalización: + **“min-max”**: normaliza cada valor restándole el valor mínimo y dividiéndolo por la diferencia entre el valor máximo y el mínimo. + **“standard”**: normaliza cada valor dividiéndolo entre la suma de todos los valores. + **“none”**: no normaliza los valores numéricos durante la codificación. Consulte [Características numéricas de Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features). ## El campo language El campo de idioma especifica el idioma utilizado en los valores de las propiedades de texto. Su uso depende del método de codificación del texto: + En el caso de la codificación [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), este campo es obligatorio y debe especificar uno de los siguientes idiomas: + `en` (inglés) + `zh` (chino) + `hi` (hindi) + `es` (español) + `fr` (francés) + En el caso de la codificación [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), este campo no se utiliza, ya que la codificación SBERT es multilingüe. + En el caso de la codificación [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features), este campo es opcional, ya que `text_word2vec` solo admite el inglés. Si está presente, debe especificar el nombre del modelo en inglés: ``` "language" : "en_core_web_lg" ``` + En el caso de la codificación [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features), este campo no se utiliza. ## El campo max\$1length El campo `max_length` es opcional para las características `text_fasttext`, ya que especifica el número máximo de tokens que se codificarán en una característica de texto de entrada. Se truncará el texto de entrada que supere `max_length`. Por ejemplo, si se establece max\$1length en 128, se ignorará cualquier token situado después del 128 en una secuencia de texto: ``` "max_length": 128 ``` ## El campo separator Este campo se usa de forma opcional con las características `category`, `numerical` y `auto`. Especifica un carácter que se puede utilizar para dividir el valor de una propiedad en varios valores categóricos o numéricos: ``` "separator": ";" ``` Utilice el campo `separator` únicamente cuando la propiedad almacene varios valores delimitados en una única cadena, como, por ejemplo, `"Actor;Director"` o `"0.1;0.2"`. Consulte [Características categóricas](machine-learning-feature-encoding.md#machine-learning-categorical-features), [Características numéricas](machine-learning-feature-encoding.md#machine-learning-numerical-features) y [Codificación automática](machine-learning-feature-encoding.md#machine-learning-auto-encoding). ## El campo range Este campo es obligatorio para las características `bucket_numerical`. Especifica el rango de valores numéricos que se van a dividir en buckets, en el formato`[lower-bound, upper-bound]`: ``` "range" : [20, 100] ``` Si el valor de una propiedad es menor que el límite inferior, se asigna al primer bucket, o si es mayor que el límite superior, se asigna al último bucket. Consulte [Características numéricas por bucket de Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). ## El campo bucket\$1cnt Este campo es obligatorio para las características `bucket_numerical`. Especifica el número de buckets en los que debe dividirse el rango numérico definido por el parámetro `range`: ``` "bucket_cnt": 10 ``` Consulte [Características numéricas por bucket de Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). ## El campo slide\$1window\$1size Este campo se usa de forma opcional con características `bucket_numerical` para asignar valores a más de un bucket: ``` "slide_window_size": 5 ``` El funcionamiento de una ventana deslizante consiste en que Neptune ML toma el tamaño de la ventana **`s`** y transforma cada valor numérico **`v`** de una propiedad en un rango de ` v - s/2 ` a ` v + s/2 `. A continuación, el valor se asigna a cada bucket en el que se superpone el rango. Consulte [Características numéricas por bucket de Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). ## El campo imputer Este campo se utiliza de forma opcional con las características `numerical` y `bucket_numerical` para proporcionar una técnica de imputación y rellenar los valores que faltan: ``` "imputer": "mean" ``` Las técnicas de imputación admitidas son: + `"mean"` + `"median"` + `"most-frequent"` Si no incluye el parámetro de imputación, el preprocesamiento de datos se detiene y finaliza cuando se encuentra con un valor que falta. Consulte [Características numéricas de Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features) y [Características numéricas por bucket de Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). ## El campo max\$1features Las características `text_tfidf` utilizan este campo de forma opcional para especificar el número máximo de términos que se van a codificar: ``` "max_features": 100 ``` Un valor de 100 hace que el vectorizador de TF-IDF codifique solo los 100 términos más comunes. El valor predeterminado, si no se incluye `max_features`, es 5000. Consulte [Codificación TF-IDF de características de texto en Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features). ## El campo min\$1df Las características `text_tfidf` utilizan este campo de forma opcional para especificar la frecuencia mínima de documentos de los términos que se van a codificar: ``` "min_df": 5 ``` Un valor de 5 indica que un término debe aparecer en al menos 5 valores de propiedad diferentes para codificarse. El valor predeterminado, si no se incluye el parámetro `min_df`, es `2`. Consulte [Codificación TF-IDF de características de texto en Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features). ## El campo ngram\$1range Las características `text_tfidf` utilizan este campo de forma opcional para especificar qué tamaño de las secuencias de palabras o tokens debe considerarse como posibles términos individuales para codificar: ``` "ngram_range": [2, 4] ``` El valor `[2, 4]` especifica que las secuencias de 2, 3 y 4 palabras deben considerarse posibles términos individuales. El valor predeterminado, si no establece de forma explícita `ngram_range`, es `[1, 1]`, lo que significa que solo las palabras o tokens únicos se consideran términos que se van a codificar. Consulte [Codificación TF-IDF de características de texto en Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features). ## El campo datetime\$1parts Las características `datetime` utilizan este campo de forma opcional para especificar qué partes del valor de fecha y hora deben codificarse categóricamente: ``` "datetime_parts": ["weekday", "hour"] ``` Si no incluye `datetime_parts`, Neptune ML codifica de forma predeterminada las partes de año, mes, día de la semana y hora del valor de fecha y hora. El valor `["weekday", "hour"]` indica que solo los valores de fecha y hora del día de la semana y hora deben codificarse categóricamente en la característica. Si una de las partes no tiene más de un valor único en el conjunto de entrenamiento, no se ha codificado. Consulte [Características de fecha y hora de Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features). # Ejemplos del uso de parámetros en additionalParams para ajustar la configuración del entrenamiento de modelos Los siguientes ejemplos muestran cómo utilizar la característica “additionalParams” en los modelos de datos de gráficos de propiedades y RDF para configurar varios aspectos del proceso de entrenamiento del modelo en una aplicación de Neptune ML. Los ejemplos cubren una amplia gama de funciones, incluida la especificación de tasas de división predeterminadas para training/validation/test los datos, la definición de tareas de clasificación de nodos, regresión y predicción de enlaces, así como la configuración de diferentes tipos de funciones, como cubos numéricos, incrustaciones de texto, fecha y hora y datos categóricos. Estas configuraciones detalladas le permiten adaptar el proceso de machine learning a los requisitos específicos de datos y modelado, lo que le permite aprovechar todo el potencial de las capacidades de Neptune ML. **Contents** + [Ejemplos de gráficos de propiedades que utilizan additionalParams](#machine-learning-property-graph-additionalParams-examples) + [Especificación de una tasa de división predeterminada para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-default-split-rate-example) + [Especificación de una tarea de clasificación de nodos para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-node-classification-example) + [Especificación de una tarea de clasificación de nodos de varias clases para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-multi-class-example) + [Especificación de una tarea de regresión de nodos para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-node-regression-example) + [Especificación de una tarea de clasificación de bordes para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-edge-classification-example) + [Especificación de una tarea de borde de varias clases para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-multi-edge-classification-example) + [Especificación de una regresión de bordes para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-edge-regression-example) + [Especificación de una tarea de predicción de enlaces para la configuración del entrenamiento de modelos](#machine-learning-property-graph-additionalParams-link-prediction-example) + [Especificación de una característica de bucket numérico](#machine-learning-property-graph-additionalParams-numeric-bucket-example) + [Especificación de una característica `Word2Vec`](#machine-learning-property-graph-additionalParams-word2vec-example) + [Especificación de una característica `FastText`](#machine-learning-property-graph-additionalParams-fasttext-example) + [Especificación de una característica `Sentence BERT`](#machine-learning-property-graph-additionalParams-sbert-example) + [Especificación de una característica `TF-IDF`](#machine-learning-property-graph-additionalParams-tf-idf-example) + [Especificación de una característica `datetime`](#machine-learning-property-graph-additionalParams-datetime-example) + [Especificación de una característica `category`](#machine-learning-property-graph-additionalParams-category-example) + [Especificación de una característica `numerical`](#machine-learning-property-graph-additionalParams-numerical-example) + [Especificación de una característica `auto`](#machine-learning-property-graph-additionalParams-auto-example) + [Ejemplos de RDF con `additionalParams`](#machine-learning-RDF-additionalParams-examples) + [Especificación de una tasa de división predeterminada para la configuración del entrenamiento de modelos](#machine-learning-RDF-additionalParams-default-split-rate-example) + [Especificación de una tarea de clasificación de nodos para la configuración del entrenamiento de modelos](#machine-learning-RDF-additionalParams-node-classification-example) + [Especificación de una tarea de regresión de nodos para la configuración del entrenamiento de modelos](#machine-learning-RDF-additionalParams-node-regression-example) + [Especificación de una tarea de predicción de enlaces para determinados bordes](#machine-learning-RDF-additionalParams-link-prediction-example) + [Especificación de una tarea de predicción de enlaces para todos los bordes](#machine-learning-RDF-additionalParams-link-prediction-example) ## Ejemplos de gráficos de propiedades que utilizan additionalParams ### Especificación de una tasa de división predeterminada para la configuración del entrenamiento de modelos En el siguiente ejemplo el parámetro `split_rate` establece la tasa de división predeterminada para el entrenamiento de modelos. Si no se especifica ninguna tasa de división predeterminada, el entrenamiento usa un valor de [0,9, 0,1, 0,0]. Para anular el valor predeterminado según el destino, especifique una `split_rate` para cada destino. En el siguiente ejemplo el campo `default split_rate` indica que se debe utilizar una tasa de división de `[0.7,0.1,0.2]`, a no ser que se anule según el destino: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "split_rate": [0.7,0.1,0.2], "targets": [ (...) ], "features": [ (...) ] } } ``` ### Especificación de una tarea de clasificación de nodos para la configuración del entrenamiento de modelos Para indicar la propiedad de nodo que incluye ejemplos etiquetados con fines de entrenamiento, añada un elemento de clasificación de nodos a la matriz de `targets` mediante `"type" : "classification"`. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. En el siguiente ejemplo el destino `node` indica que la propiedad `genre` de cada nodo `Movie` debe tratarse como una etiqueta de clase de nodo. El valor `split_rate` anula la tasa de división predeterminada: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "node": "Movie", "property": "genre", "type": "classification", "split_rate": [0.7,0.1,0.2] } ], "features": [ (...) ] } } ``` ### Especificación de una tarea de clasificación de nodos de varias clases para la configuración del entrenamiento de modelos Para indicar la propiedad de nodo que incluye varios ejemplos etiquetados con fines de entrenamiento, añada un elemento de clasificación de nodos a la matriz de destino mediante `"type" : "classification"` y `separator` para especificar un carácter que pueda usarse para dividir el valor de una propiedad de destino en varios valores categóricos. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. En el siguiente ejemplo el destino `node` indica que la propiedad `genre` de cada nodo `Movie` debe tratarse como una etiqueta de clase de nodo. El campo `separator` indica que cada propiedad de género incluye varios valores separados por punto y coma: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "node": "Movie", "property": "genre", "type": "classification", "separator": ";" } ], "features": [ (...) ] } } ``` ### Especificación de una tarea de regresión de nodos para la configuración del entrenamiento de modelos Para indicar la propiedad de nodo que incluye regresiones etiquetadas con fines de entrenamiento, añada un elemento de regresión de nodos a la matriz de destino mediante `"type" : "regression"`. Si desea anular la tasa de división predeterminada, añada el campo split\$1rate. El siguiente destino `node` indica que la propiedad `rating` de cada nodo `Movie` debe tratarse como una etiqueta de regresión de nodo. ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "node": "Movie", "property": "rating", "type" : "regression", "split_rate": [0.7,0.1,0.2] } ], "features": [ ... ] } } ``` ### Especificación de una tarea de clasificación de bordes para la configuración del entrenamiento de modelos Para indicar la propiedad de borde que incluye ejemplos etiquetados con fines de entrenamiento, añada un elemento de borde a la matriz de `targets` mediante `"type" : "regression"`. Si desea anular la tasa de división predeterminada, añada el campo split\$1rate. El siguiente destino `edge` indica que la propiedad `metAtLocation` de cada borde `knows` debe tratarse como una etiqueta de clase de borde: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "edge": ["Person", "knows", "Person"], "property": "metAtLocation", "type": "classification" } ], "features": [ (...) ] } } ``` ### Especificación de una tarea de borde de varias clases para la configuración del entrenamiento de modelos Para indicar la propiedad de borde que incluye varios ejemplos etiquetados con fines de entrenamiento, añada un elemento de borde a la matriz de `targets` mediante `"type" : "classification"` y un campo `separator` para especificar un carácter utilizado para dividir el valor de una propiedad de destino en varios valores categóricos. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. El siguiente destino `edge` indica que la propiedad `sentiment` de cada borde `repliedTo` debe tratarse como una etiqueta de clase de borde. El campo del separador indica que cada propiedad de opinión incluye varios valores separados por comas: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "edge": ["Person", "repliedTo", "Message"], "property": "sentiment", "type": "classification", "separator": "," } ], "features": [ (...) ] } } ``` ### Especificación de una regresión de bordes para la configuración del entrenamiento de modelos Para indicar la propiedad de borde que incluye ejemplos de regresión etiquetados con fines de entrenamiento, añada un elemento `edge` a la matriz de `targets` mediante `"type" : "regression"`. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. El siguiente destino `edge` indica que la propiedad `rating` de cada borde `reviewed` debe tratarse como una regresión de borde: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "edge": ["Person", "reviewed", "Movie"], "property": "rating", "type" : "regression" } ], "features": [ (...) ] } } ``` ### Especificación de una tarea de predicción de enlaces para la configuración del entrenamiento de modelos Para indicar los bordes que deben usarse con fines de entrenamiento de predicción de enlaces, añada un elemento de borde a la matriz de destino mediante `"type" : "link_prediction"`. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. El siguiente destino `edge` indica que los bordes `cites` deben usarse para la predicción de enlaces: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "edge": ["Article", "cites", "Article"], "type" : "link_prediction" } ], "features": [ (...) ] } } ``` ### Especificación de una característica de bucket numérico Para especificar una característica de datos numéricos para una propiedad de nodo, añada `"type": "bucket_numerical"` a la matriz de `features`. La siguiente característica `node` indica que la propiedad `age` de cada nodo `Person` debe tratarse como una característica de bucket numérico: ``` "additionalParams": { "neptune_ml": { "targets": [ ... ], "features": [ { "node": "Person", "property": "age", "type": "bucket_numerical", "range": [1, 100], "bucket_cnt": 5, "slide_window_size": 3, "imputer": "median" } ] } } ``` ### Especificación de una característica `Word2Vec` Para especificar una característica `Word2Vec` para una propiedad de nodo, añada `"type": "text_word2vec"` a la matriz de `features`. La siguiente característica `node` indica que la propiedad `description` de cada nodo `Movie` debe tratarse como una característica `Word2Vec`: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ ... ], "features": [ { "node": "Movie", "property": "description", "type": "text_word2vec", "language": "en_core_web_lg" } ] } } ``` ### Especificación de una característica `FastText` Para especificar una característica `FastText` para una propiedad de nodo, añada `"type": "text_fasttext"` a la matriz de `features`. El campo `language` es obligatorio y debe especificar uno de los siguientes códigos de idiomas: + `en` (inglés) + `zh` (chino) + `hi` (hindi) + `es` (español) + `fr` (francés) Tenga en cuenta que la codificación `text_fasttext` no puede admitir más de un idioma a la vez en una característica. La siguiente característica `node` indica que la propiedad `description` (francés) de cada nodo `Movie` debe tratarse como una característica `FastText`: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ ... ], "features": [ { "node": "Movie", "property": "description", "type": "text_fasttext", "language": "fr", "max_length": 1024 } ] } } ``` ### Especificación de una característica `Sentence BERT` Para especificar una característica `Sentence BERT` para una propiedad de nodo, añada `"type": "text_sbert"` a la matriz de `features`. No es necesario especificar el idioma, ya que el método codifica automáticamente las características de texto mediante un modelo de idioma multilingüe. La siguiente característica `node` indica que la propiedad `description` de cada nodo `Movie` debe tratarse como una característica `Sentence BERT`: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ ... ], "features": [ { "node": "Movie", "property": "description", "type": "text_sbert128", } ] } } ``` ### Especificación de una característica `TF-IDF` Para especificar una característica `TF-IDF` para una propiedad de nodo, añada `"type": "text_tfidf"` a la matriz de `features`. La siguiente característica `node` indica que la propiedad `bio` de cada nodo `Person` debe tratarse como una característica `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 } ] } } ``` ### Especificación de una característica `datetime` El proceso de exportación infiere automáticamente las características `datetime` de las propiedades de fecha. Sin embargo, si desea limitar las `datetime_parts` usadas para una característica `datetime` o anular una especificación de característica para que una propiedad que normalmente se trataría como una característica `auto` se trate de forma explícita como una característica `datetime`, añada una `"type": "datetime"` a la matriz de característica. La siguiente característica `node` indica que la propiedad `createdAt` de cada nodo `Post` debe tratarse como una característica `datetime`: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ ... ], "features": [ { "node": "Post", "property": "createdAt", "type": "datetime", "datetime_parts": ["month", "weekday", "hour"] } ] } } ``` ### Especificación de una característica `category` El proceso de exportación infiere automáticamente las características `auto` de las propiedades de cadenas y de las propiedades numéricas que incluyen varios valores. En el caso de las propiedades numéricas que incluyen valores únicos, infiere las características `numerical`. En el caso de las propiedades de fecha, infiere las características `datetime`. Si desea anular una especificación de característica para que una propiedad se trate como una característica categórica, añada `"type": "category"` a la matriz de característica. Si la propiedad incluye varios valores, incluya un campo `separator`. Por ejemplo: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ ... ], "features": [ { "node": "Post", "property": "tag", "type": "category", "separator": "|" } ] } } ``` ### Especificación de una característica `numerical` El proceso de exportación infiere automáticamente las características `auto` de las propiedades de cadenas y de las propiedades numéricas que incluyen varios valores. En el caso de las propiedades numéricas que incluyen valores únicos, infiere las características `numerical`. En el caso de las propiedades de fecha, infiere las características `datetime`. Si desea anular una especificación de característica para que una propiedad se trate como una característica `numerical`, añada `"type": "numerical"` a la matriz de característica. Si la propiedad incluye varios valores, incluya un campo `separator`. Por ejemplo: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ ... ], "features": [ { "node": "Recording", "property": "duration", "type": "numerical", "separator": "," } ] } } ``` ### Especificación de una característica `auto` El proceso de exportación infiere automáticamente las características `auto` de las propiedades de cadenas y de las propiedades numéricas que incluyen varios valores. En el caso de las propiedades numéricas que incluyen valores únicos, infiere las características `numerical`. En el caso de las propiedades de fecha, infiere las características `datetime`. Si desea anular una especificación de característica para que una propiedad se trate como una característica `auto`, añada `"type": "auto"` a la matriz de característica. Si la propiedad incluye varios valores, incluya un campo `separator`. Por ejemplo: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ ... ], "features": [ { "node": "User", "property": "role", "type": "auto", "separator": "," } ] } } ``` ## Ejemplos de RDF con `additionalParams` ### Especificación de una tasa de división predeterminada para la configuración del entrenamiento de modelos En el siguiente ejemplo el parámetro `split_rate` establece la tasa de división predeterminada para el entrenamiento de modelos. Si no se especifica ninguna tasa de división predeterminada, el entrenamiento usa un valor de [0,9, 0,1, 0,0]. Para anular el valor predeterminado según el destino, especifique una `split_rate` para cada destino. En el siguiente ejemplo el campo `default split_rate` indica que se debe utilizar una tasa de división de `[0.7,0.1,0.2]`, a no ser que se anule según el destino: ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "split_rate": [0.7,0.1,0.2], "targets": [ (...) ] } } ``` ### Especificación de una tarea de clasificación de nodos para la configuración del entrenamiento de modelos Para indicar la propiedad de nodo que incluye ejemplos etiquetados con fines de entrenamiento, añada un elemento de clasificación de nodos a la matriz de `targets` mediante `"type" : "classification"`. Añada un campo node para indicar el tipo de nodo de los nodos de destino. Añada un campo `predicate` para definir los datos literales que se utilizarán como la característica de nodo de destino del nodo de destino. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. En el siguiente ejemplo el destino `node` indica que la propiedad `genre` de cada nodo `Movie` debe tratarse como una etiqueta de clase de nodo. El valor `split_rate` anula la tasa de división predeterminada: ``` "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] } ] } } ``` ### Especificación de una tarea de regresión de nodos para la configuración del entrenamiento de modelos Para indicar la propiedad de nodo que incluye regresiones etiquetadas con fines de entrenamiento, añada un elemento de regresión de nodos a la matriz de destino mediante `"type" : "regression"`. Añada un campo `node` para indicar el tipo de nodo de los nodos de destino. Añada un campo `predicate` para definir los datos literales que se utilizarán como la característica de nodo de destino del nodo de destino. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. El siguiente destino `node` indica que la propiedad `rating` de cada nodo `Movie` debe tratarse como una etiqueta de regresión de nodo. ``` "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] } ] } } ``` ### Especificación de una tarea de predicción de enlaces para determinados bordes Para indicar los bordes que deben usarse con fines de entrenamiento de predicción de enlaces, añada un elemento de borde a la matriz de destino mediante `"type" : "link_prediction"`. Añada los campos `subject`, `predicate` y `object` para especificar el tipo de borde. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. El siguiente destino `edge` indica que los bordes `directed` que conectan `Directors` a `Movies` deben usarse para la predicción de enlaces: ``` "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" } ] } } ``` ### Especificación de una tarea de predicción de enlaces para todos los bordes Para indicar que todos los bordes que deben usarse con fines de entrenamiento de predicción de enlaces, añada un elemento `edge` a la matriz de destino mediante `"type" : "link_prediction"`. No añada los campos `subject`, `predicate` ni `object`. Si desea anular la tasa de división predeterminada, añada el campo `split_rate`. ``` "additionalParams": { "neptune_ml": { "version": "v2.0", "targets": [ { "type" : "link_prediction" } ] } } ``` # Procesamiento de los datos de gráficos exportados de Neptune para el entrenamiento El paso de procesamiento de datos toma los datos de gráficos de Neptune creados por el proceso de exportación y crea la información que utiliza la biblioteca [Deep Graph Library (DGL)](https://www.dgl.ai/) durante el entrenamiento. Esto incluye realizar varios mapeos y transformaciones de datos: + Analizar nodos y bordes para crear los archivos de mapeo de gráficos e identificador que requiere DGL. + Convertir las propiedades de nodos y bordes en las características de nodos y bordes que requiere DGL. + Dividir los datos en conjuntos de entrenamiento, validación y prueba. ## Administración del paso de procesamiento de datos para Neptune ML Una vez que haya exportado los datos de Neptune que desee utilizar para el entrenamiento de modelos, puede iniciar un trabajo de procesamiento de datos mediante un comando `curl` (o `awscurl`) como el siguiente: ``` 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" }' ``` Los detalles sobre cómo usar este comando se explican en [El comando de procesamiento de datos](machine-learning-api-dataprocessing.md), junto con información sobre cómo obtener el estado de un trabajo en ejecución, cómo detener un trabajo en ejecución y cómo enumerar todos los trabajos en ejecución. ## Procesamiento de datos de gráficos actualizados para Neptune ML También puede proporcionar un `previousDataProcessingJobId` a la API para garantizar que el nuevo trabajo de procesamiento de datos utilice el mismo método de procesamiento que el trabajo anterior. Esto es necesario si desea obtener predicciones para datos de gráficos actualizados en Neptune, ya sea reentrenando el modelo antiguo con los nuevos datos o volviendo a calcular los artefactos de modelos en los nuevos datos. Para ello, utilice un comando `curl` (o `awscurl`) como este: ``` 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)"}' ``` Establezca el valor del parámetro `previousDataProcessingJobId` en el ID de trabajo del trabajo de procesamiento de datos anterior que corresponda al modelo entrenado. **nota** Actualmente, no se admiten las eliminaciones de nodos en el gráfico actualizado. Si se han eliminado los nodos de un gráfico actualizado, debe iniciar un trabajo de procesamiento de datos completamente nuevo en lugar de usar `previousDataProcessingJobId`. # Codificación de características en Neptune ML Los valores de las propiedades están disponibles en diferentes formatos y tipos de datos. Para lograr un buen rendimiento en el machine learning, es fundamental convertir esos valores en codificaciones numéricas conocidas como *características*. Neptune ML realiza la extracción y codificación de características como parte de los pasos de procesamiento y exportación de datos mediante técnicas de codificación de características que se describen aquí. **nota** Si tiene previsto implementar su propia codificación de características en una implementación de modelo personalizado, puede deshabilitar la codificación automática de características en la etapa de preprocesamiento de datos. Para ello, seleccione `none` como tipo de codificación de características. No se produce ninguna codificación de características en esa propiedad de nodo o borde y, en su lugar, los valores sin procesar de las propiedades se analizan y guardan en un diccionario. El preprocesamiento de datos sigue creando el gráfico DGL a partir del conjunto de datos exportado, pero este gráfico creado no cuanta con las características preprocesadas para el entrenamiento. Debe utilizar esta opción únicamente si tiene previsto realizar su propia codificación personalizada de características como parte del entrenamiento con modelos personalizados. Para obtener más información, consulte [Modelos personalizados de Neptune ML](machine-learning-custom-models.md). ## Características categóricas de Neptune ML Una propiedad que puede tomar uno o varios valores distintos de una lista fija de valores posibles es una característica categórica. En Neptune ML, las características categóricas se codifican mediante la [codificación one-hot](https://en.wikipedia.org/wiki/One-hot). En el siguiente ejemplo se muestra cómo el nombre de propiedad de distintos alimentos se codifica mediante la codificación one-hot según su categoría: ``` Food Veg. Meat Fruit Encoding --------- ---- ---- ----- -------- Apple 0 0 1 001 Chicken 0 1 0 010 Broccoli 1 0 0 100 ``` **nota** El número máximo de categorías de cualquier característica categórica es de 100. Si una propiedad tiene más de 100 categorías de valor, solo las 99 más comunes se ubican en categorías distintas y el resto se coloca en una categoría especial denominada `OTHER`. ## Características numéricas de Neptune ML Cualquier propiedad cuyos valores sean números reales se puede codificar como una característica numérica en Neptune ML. Las características numéricas se codifican mediante números de coma flotante. Puede especificar un método de normalización de datos para usarlo al codificar características numéricas, como, por ejemplo: `"norm": "normalization technique"`. Se admiten las siguientes técnicas de normalización: + **“none”**: no normaliza los valores numéricos durante la codificación. + **“min-max”**: normaliza cada valor restándole el valor mínimo y dividiéndolo por la diferencia entre el valor máximo y el mínimo. + **“standard”**: normaliza cada valor dividiéndolo entre la suma de todos los valores. ## Características numéricas por bucket de Neptune ML En lugar de representar una propiedad numérica con números sin procesar, puede condensar los valores numéricos en categorías. Por ejemplo, puede dividir las edades de las personas en categorías, como niños (0-20), adultos jóvenes (20-40), personas de mediana edad (40-60) y personas mayores (a partir de los 60 años). Al usar estos buckets numéricos, estaría transformando una propiedad numérica en una especie de característica categórica. En Neptune ML, para que una propiedad numérica se codifique como una característica numérica por bucket, debe proporcionar dos cosas: + Un rango numérico con el formato ` "range": [a, b] `, donde `a` y `b` son números enteros. + Un recuento de buckets con el formato ` "bucket_cnt": c `, donde `c` es el número de buckets, también un número entero. Neptune ML calcula el tamaño de cada bucket como ` ( b - a ) / c ` y codifica cada valor numérico como el número del bucket en el que se encuentre. Cualquier valor inferior a `a` se considera que pertenece al primer bucket y cualquier valor superior a `b` se considera que pertenece al último bucket. Si lo desea, también puede hacer que los valores numéricos se clasifiquen en más de un bucket. Para ello, debe especificar un tamaño de ventana deslizante, como, por ejemplo: ` "slide_window_size": s `, donde `s` es un número. A continuación, Neptune ML transforma cada valor numérico `v` de la propiedad en un rango de ` v - s/2 ` a ` v + s/2 ` y asigna el valor `v` a cada bucket que cubre el rango. Por último, si lo desea, también puede proporcionar una forma de rellenar los valores que faltan para las características numéricas y las características numéricas por buckets. Para ello, utilice ` "imputer": "imputation technique "`, donde la técnica de imputación es una de las siguientes: `"mean"`, `"median"` o `"most-frequent"`. Si no se especifica un parámetro de imputación, esto puede provocar que el procesamiento se detenga. ## Codificación de características de texto en Neptune ML En el caso de textos de formato libre, Neptune ML puede utilizar varios modelos diferentes para convertir la secuencia de tokens de una cadena de valor de propiedad en un vector de valor real de tamaño fijo: + [`text_fasttext`](#machine-learning-fasttext-features): utiliza la codificación [fastText](https://fasttext.cc/). Esta es la codificación recomendada para las características que utilizan solo uno de los cinco idiomas que admite FastText. + [`text_sbert`](#machine-learning-sbert-features): utiliza los modelos de codificación [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Esta es la codificación recomendada para el texto que no admite `text_fasttext`. + [`text_word2vec`](#machine-learning-word2vec-features): utiliza los algoritmos [Word2Vec](https://wikipedia.org/wiki/Word2vec) publicados originalmente por [Google](https://code.google.com/archive/p/word2vec/) para codificar texto. Word2Vec solo admite inglés. + [`text_tfidf`](#machine-learning-tfidf-features): utiliza un vectorizador de [frecuencia de términos - frecuencia inversa de documentos](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) para codificar texto. La codificación TF-IDF admite características estadísticas que las demás codificaciones no admiten. ### Codificación *fastText* de valores de propiedades de texto en Neptune ML Neptune ML puede utilizar los modelos de [fastText](https://fasttext.cc/) para convertir valores de propiedades de texto en vectores de valores reales de tamaño fijo. Este es el método de codificación recomendado para los valores de propiedades de texto en cualquiera de los cinco idiomas que admite FastText: + `en` (inglés) + `zh` (chino) + `hi` (hindi) + `es` (español) + `fr` (francés) Tenga en cuenta que fastText no puede procesar frases que incluyan palabras en más de un idioma. Si lo desea, el método `text_fasttext` puede utilizar un campo `max_length` que especifique el número máximo de tokens del valor de una propiedad de texto que se codificará, tras el cual se truncará la cadena. Esto puede mejorar el rendimiento cuando los valores de las propiedades del texto incluyen cadenas largas, ya que si no se especifica `max_length`, fastText codifica todos los tokens independientemente de la longitud de la cadena. En este ejemplo se especifica que los títulos de películas en francés se codifican mediante fastText: ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_fasttext"], "language": "fr", "max_length": 1024 } ] } ``` ### Codificación de frases BERT (SBERT) de características de texto en Neptune ML Neptune ML puede convertir la secuencia de tokens de un valor de propiedad de cadena en un vector de valor real de tamaño fijo mediante los modelos [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). Neptune admite dos métodos SBERT: `text_sbert128`, que es el predeterminado si solo se especifica `text_sbert` y `text_sbert512`. La diferencia entre ambos es la longitud máxima de una cadena de valores de propiedad de texto que se codifica. La codificación `text_sbert128` trunca las cadenas de texto después de codificar 128 tokens, mientras que `text_sbert512` trunca las cadenas de texto después de codificar 512 tokens. Como resultado, `text_sbert512` requiere más tiempo de procesamiento que `text_sbert128`. Ambos métodos son más lentos que `text_fasttext`. La codificación SBERT es multilingüe, por lo que no es necesario especificar un idioma para el texto del valor de propiedad que se va a codificar. SBERT admite muchos idiomas y puede codificar una frase que incluya más de un idioma. Si va a codificar valores de propiedades que incluyan texto en uno o varios idiomas que fastText no admite, el método de codificación recomendado es SBERT. En el siguiente ejemplo se especifica que los títulos de las películas se codifican como SBERT hasta un máximo de 128 tokens: ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_sbert128"] } ] } ``` ### Codificación Word2Vec de características de texto en Neptune ML Neptune ML puede codificar valores de propiedades de cadenas como una característica de Word2Vec ([Google](https://code.google.com/archive/p/word2vec/) publicó originalmente los [algoritmos de Word2Vec](https://wikipedia.org/wiki/Word2vec)). El método `text_word2vec` codifica los tokens de una cadena como un vector denso mediante uno de los [modelos entrenados de spaCy](https://spacy.io/models). Esto solo es compatible con el idioma inglés (mediante el modelo [en\$1core\$1web\$1lg](https://spacy.io/models/en#en_core_web_lg)). En el siguiente ejemplo se especifica que los títulos de las películas se codifican con Word2Vec: ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_word2vec"], "language": "en_core_web_lg" } ] } ``` Tenga en cuenta que el campo de idioma es opcional, ya que el modelo `en_core_web_lg` en inglés es el único que admite Neptune. ### Codificación TF-IDF de características de texto en Neptune ML Neptune ML puede codificar valores de propiedades de texto como características `text_tfidf`. Esta codificación convierte la secuencia de palabras del texto en un vector numérico mediante un vectorizador de [frecuencia de términos - frecuencia inversa de documentos](https://wikipedia.org/wiki/Tf-idf) (TF-IDF), seguido de una operación de reducción de la dimensionalidad. [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) (frecuencia de términos - frecuencia inversa de documentos) es un valor numérico destinado a medir la importancia de una palabra en un conjunto de documentos. Se calcula dividiendo el número de veces que aparece una palabra en un determinado valor de propiedad entre el número total de dichos valores de propiedad en los que aparece. Por ejemplo, si la palabra “kiss” aparece dos veces en el título de una película (por ejemplo, “kiss kiss bang bang”) y “kiss” aparece en el título de cuatro películas en total, el valor TF-IDF de “kiss” en el título “kiss kiss bang bang” sería ` 2 / 4 `. El vector que se crea inicialmente tiene dimensiones ***d***, donde ***d*** es el número de términos únicos en todos los valores de propiedad de ese tipo. La operación de reducción de dimensionalidad utiliza una proyección dispersa aleatoria para reducir ese número a un máximo de 100. A continuación, se genera el vocabulario de un gráfico mediante la combinación de todas sus características `text_tfidf`. El vectorizador de TF-IDF se puede controlar de varias maneras: + **`max_features`**: con el parámetro `max_features`, puede limitar el número de términos de las características `text_tfidf` a los más comunes. Por ejemplo, si se establece `max_features` en 100, solo se incluyen los 100 términos más utilizados. El valor predeterminado de `max_features` si no se establece de forma explícita es 5000. + **`min_df`**: con el parámetro `min_df`, puede limitar el número de términos de las características `text_tfidf` a aquellos que tengan al menos una determinada frecuencia de documentos. Por ejemplo, si se establece `min_df` en 5, solo se utilizarán los términos que aparezcan en al menos 5 valores de propiedad diferentes. El valor predeterminado de `min_df` si no se establece de forma explícita es 2. + **`ngram_range`**: el parámetro `ngram_range` determina qué combinaciones de palabras se consideran términos. Por ejemplo, si `ngram_range` se establece en `[2, 4]`, los seis términos siguientes aparecerían en el título “kiss kiss bang bang”: + *Términos de dos palabras*: “kiss kiss”, “kiss bang” y “bang bang”. + *Términos de tres palabras*: “kiss kiss bang” y “kiss bang bang”. + *Términos de cuatro palabras*: “kiss kiss bang bang”. El ajuste predeterminado de `ngram_range` es `[1, 1]`. ## Características de fecha y hora de Neptune ML Neptune ML puede convertir partes de los valores de las propiedades `datetime` en características categóricas mediante la codificación de [matrices one-hot](https://en.wikipedia.org/wiki/One-hot). Utilice el parámetro `datetime_parts` para especificar una o varias de las siguientes partes para codificar: `["year", "month", "weekday", "hour"]`. Si no se configura `datetime_parts`, las cuatro partes se codificarán de forma predeterminada. Por ejemplo, si el rango de valores de fecha y hora abarca los años 2010 a 2012, las cuatro partes de la entrada de fecha y hora `2011-04-22 01:16:34` son las siguientes: + **year**: `[0, 1, 0]`. Como solo hay tres años en el intervalo (2010, 2011 y 2012), la matriz one-hot tiene tres entradas, una para cada año. + **month**: `[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]`. En este caso, la matriz one-hot tiene una entrada para cada mes del año. + **weekday**: `[0, 0, 0, 0, 1, 0, 0]`. La norma ISO 8601 establece que el lunes es el primer día de la semana y, dado que el 22 de abril de 2011 era viernes, la correspondiente matriz one-hot de día de la semana ocupa la quinta posición. + **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]`. La hora 1 de la madrugada se establece en una matriz one-hot de 24 miembros. El día del mes, el minuto y el segundo no están codificados de forma categórica. Si el rango total de `datetime` en cuestión solo incluye fechas de un año, no se codifica ninguna matriz de `year`. Puede especificar una estrategia de imputación para rellenar los valores de `datetime` que faltan, mediante el parámetro `imputer` y una de las estrategias disponibles para las características numéricas. ## Codificación automática de características en Neptune ML En lugar de especificar manualmente los métodos de codificación de características que se van a utilizar para las propiedades del gráfico, puede configurar `auto` como un método de codificación de características. A continuación, Neptune ML intenta inferir la mejor codificación de características para cada propiedad en función del tipo de datos subyacente. Estas son algunas de las heurísticas que Neptune ML utiliza para seleccionar las codificaciones de características adecuadas: + Si la propiedad solo tiene valores numéricos y se puede convertir en tipos de datos numéricos, Neptune ML suele codificarla como un valor numérico. Sin embargo, si el número de valores únicos de la propiedad es inferior al 10 % del número total de valores y la cardinalidad de esos valores únicos es inferior a 100, Neptune ML utiliza una codificación categórica. + Si los valores de las propiedades se pueden convertir en un tipo `datetime`, Neptune ML los codificará como una característica `datetime`. + Si los valores de las propiedades se pueden convertir en valores booleanos (1/0 o True/False), Neptune ML utilizará la codificación por categorías. + Si la propiedad es una cadena con más del 10 % de sus valores únicos y el número medio de tokens por valor es mayor o igual a 3, Neptune ML inferirá que el tipo de propiedad sea texto y detectará automáticamente el idioma que se está utilizando. Si el idioma detectado es uno de los que admite [fastText](#machine-learning-fasttext-features), es decir, inglés, chino, hindi, español y francés, Neptune ML utilizará `text_fasttext` para codificar el texto. De lo contrario, Neptune ML utilizará [`text_sbert`](#machine-learning-sbert-features). + Si la propiedad es una cadena no clasificada como característica de texto, Neptune ML presupone que se trata de una característica categórica y utiliza la codificación por categorías. + Si cada nodo tiene su propio valor único para una propiedad que se infiere que es una característica de categoría, Neptune ML eliminará la propiedad del gráfico de entrenamiento porque probablemente sea un ID que no sería informativo para el entrenamiento. + Si se sabe que la propiedad incluye separadores válidos de Neptune, como puntos y comas (“;”), Neptune ML solo puede tratar la propiedad como `MultiNumerical` o `MultiCategorical`. + Neptune ML primero intenta codificar los valores como características numéricas. Si esto se ejecuta correctamente, Neptune ML utilizará la codificación numérica para crear características vectoriales numéricas. + De lo contrario, Neptune ML codificará los valores como multicategóricos. + Si Neptune ML no puede inferir el tipo de datos de los valores de una propiedad, Neptune ML eliminará la propiedad del gráfico de entrenamiento. # Edición de un archivo de configuración de datos de entrenamiento El proceso de exportación de Neptune exporta los datos de Neptune ML de un clúster de base de datos de Neptune a un bucket de S3. Exporta los nodos y los bordes por separado a una carpeta `nodes/` y a una carpeta `edges/`. También crea un archivo de configuración de datos de entrenamiento JSON, con el nombre predeterminado `training-data-configuration.json`. Este archivo incluye información sobre el esquema del gráfico, los tipos de sus características, las operaciones de transformación y normalización de características y la característica de destino para una tarea de clasificación o regresión. Puede haber casos en los que desee modificar directamente el archivo de configuración. Uno de estos casos es cuando desea cambiar la forma en que se procesan las características o la forma en que se crea el gráfico, sin necesidad de volver a ejecutar la exportación cada vez que desee modificar la especificación de la tarea de machine learning que está resolviendo. **Para editar el archivo de configuración de datos de entrenamiento** 1. **Descargue el archivo en el equipo local.** A menos que haya especificado uno o más trabajos con nombre en el parámetro `additionalParams/neptune_ml` transferido al proceso de exportación, el archivo tendrá un nombre predeterminado, que es `training-data-configuration.json`. Puede usar un comando AWS CLI como este para descargar el archivo: ``` aws s3 cp \ s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json \ ./ ``` 1. **Edite el archivo con un editor de texto.** 1. **Cargue el archivo modificado.** Vuelva a cargar el archivo modificado en la misma ubicación de Amazon S3 desde la que lo descargó mediante un comando de AWS CLI como este: ``` aws s3 cp \ training-data-configuration.json \ s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json ``` # Ejemplo de un archivo de configuración de datos de entrenamiento de JSON Este es un ejemplo de un archivo de configuración de datos de entrenamiento que describe un gráfico para una tarea de clasificación de nodos: ``` { "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" : [ ] ] } ``` # La estructura de los archivos de configuración de datos de entrenamiento de JSON El archivo de configuración de entrenamiento hace referencia a los archivos CSV guardados durante el proceso de exportación en las carpetas `nodes/` y `edges/`. Cada archivo en `nodes/` almacena información sobre los nodos que tienen la misma etiqueta de nodo del gráfico de propiedades. Cada columna de un archivo de nodo almacena el ID o la propiedad del nodo. La primera línea del archivo incluye un encabezado que especifica el `~id` o el nombre de la propiedad de cada columna. Cada archivo en `edges/` almacena información sobre los nodos que tienen la misma etiqueta de borde del gráfico de propiedades. Cada columna de un archivo de nodo almacena el identificador del nodo de origen, el identificador del nodo de destino o la propiedad de borde. La primera línea del archivo incluye un encabezado que especifica `~from`, `~to` o el nombre de la propiedad de cada columna. El archivo de configuración de los datos de entrenamiento tiene tres elementos de nivel superior: ``` { "version" : "v2.0", "query_engine" : "gremlin", "graph" : [ ... ] } ``` + `version`: (Cadena) la versión del archivo de configuración que se está utilizando. + `query_engine`: (Cadena) el lenguaje de consulta utilizado para exportar los datos del gráfico. Actualmente, solo es válido “gremlin”. + `graph`: (Matriz de JSON) muestra uno o varios objetos de configuración que incluyen los parámetros del modelo para cada uno de los nodos y bordes que se utilizarán. Los objetos de configuración de la matriz de gráficos tienen la estructura que se describe en la siguiente sección. ## Contenido de un objeto de configuración que aparece en la matriz de `graph` Un objeto de configuración de la matriz de `graph` puede incluir tres nodos de nivel superior: ``` { "edges" : [ ... ], "nodes" : [ ... ], "warnings" : [ ... ], } ``` + `edges`: (matriz de objetos de JSON) cada objeto de JSON especifica un conjunto de parámetros para definir cómo se tratará un borde del gráfico durante el procesamiento y el entrenamiento del modelo. Esto solo se usa con el motor de Gremlin. + `nodes`: (matriz de objetos de JSON) cada objeto de JSON especifica un conjunto de parámetros para definir cómo se tratará un nodo del gráfico durante el procesamiento y el entrenamiento del modelo. Esto solo se usa con el motor de Gremlin. + `warnings`: (matriz de objetos de JSON) cada objeto incluye una advertencia generada durante el proceso de exportación de datos. ## Contenido de un objeto de configuración de borde que aparece en una matriz de `edges` Un objeto de configuración de borde incluido en una matriz de `edges` puede incluir los siguientes campos de nivel superior: ``` { "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`**: una cadena que especifica la ruta a un archivo CSV que almacena información sobre los bordes que tienen la misma etiqueta de gráfico de propiedades. La primera línea de ese archivo incluye una línea de encabezado de las etiquetas de las columnas. Las dos primeras etiquetas de columna son `~from` y `~to`. La primera columna (la columna `~from`) almacena el identificador del nodo inicial del borde y la segunda (la columna `~to`) almacena el identificador del nodo final del borde. Las etiquetas de columna restantes de la línea de encabezado especifican, para cada columna restante, el nombre de la propiedad de borde cuyos valores se han exportado a esa columna. + **`separator`**: una cadena que incluye el delimitador que separa las columnas de ese archivo CSV. + **`source`**: una matriz de JSON que incluye dos cadenas que especifican el nodo inicial de la periferia. La primera cadena incluye el nombre del encabezado de la columna en la que se almacena el ID del nodo inicial. La segunda cadena especifica el tipo de nodo. + **`relation`**: una matriz de JSON que incluye dos cadenas que especifican el tipo de relación del borde. La primera cadena incluye el nombre del encabezado de la columna en la que se almacena el nombre de la relación (`relname`). La segunda cadena incluye el prefijo del nombre de la relación (`prefixname`). El tipo de relación completa consta de las dos cadenas combinadas, con un guion entre ellas, como, por ejemplo: `prefixname-relname`. Si la primera cadena está vacía, todos los bordes tienen el mismo tipo de relación, es decir, la cadena `prefixname`. + **`dest`**: una matriz de JSON que incluye dos cadenas que especifican el nodo final del borde. La primera cadena incluye el nombre del encabezado de la columna en la que se almacena el ID del nodo. La segunda cadena especifica el tipo de nodo. + **`features`**: una matriz de JSON de objetos de características de valores de propiedad. Cada objeto de característica de valor de propiedad incluye los siguientes campos: + **feature**: una matriz de JSON de tres cadenas. La primera cadena incluye el nombre del encabezado de la columna que incluye el valor de propiedad. La segunda cadena incluye el nombre de la característica. La tercera cadena incluye el tipo de característica. + **norm**: (*opcional*) especifica un método de normalización para aplicarlo a los valores de las propiedades. + **`labels`**: una matriz de JSON de objetos. Cada uno de los objetos define una característica de destino de los bordes y especifica las proporciones de los bordes que deben tener las etapas de entrenamiento y validación. Cada objeto incluye los siguientes campos: + **label**: una matriz de JSON de dos cadenas. La primera cadena incluye el nombre del encabezado de la columna que incluye el valor de propiedad de característica de destino. La segunda cadena especifica uno de los siguientes tipos de tareas de destino: + `"classification"`: una tarea de clasificación de bordes. Los valores de propiedad proporcionados en la columna identificada por la primera cadena de la matriz de `label` se tratan como valores categóricos. Para una tarea de clasificación de bordes, la primera cadena de la matriz de `label` no puede estar vacía. + `"regression"`: una tarea de regresión de bordes. Los valores de propiedad proporcionados en la columna identificada por la primera cadena de la matriz de `label` se tratan como valores numéricos. Para una tarea de regresión de bordes, la primera cadena de la matriz de `label` no puede estar vacía. + `"link_prediction"`: una tarea de predicción de enlaces. No es necesario introducir ningún valor de propiedad. Para una tarea de predicción de enlaces, se ignora la primera cadena de la matriz de `label`. + **`split_rate`**: una matriz de JSON que incluye tres números entre cero y uno que suman uno y que representan una estimación de las proporciones de nodos que se utilizarán en las etapas de entrenamiento, validación y prueba, respectivamente. Se pueden definir este campo o la opción `custom_split_filenames`, pero no ambos. Consulte [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate). + **`custom_split_filenames`**: un objeto de JSON que especifica los nombres de los archivos que definen las poblaciones de entrenamiento, validación y prueba. Se pueden definir este campo o la opción `split_rate`, pero no ambos. Para obtener más información, consulte [train-validation-testProporciones personalizadas](#machine-learning-custom-stages-splits). ## Contenido de un objeto de configuración de nodo que aparece en una matriz de `nodes` Un objeto de configuración de nodo incluido en una matriz de `nodes` puede incluir los siguientes campos: ``` { "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`**: una cadena que especifica la ruta a un archivo CSV que almacena información sobre los nodos que tienen la misma etiqueta de gráfico de propiedades. La primera línea de ese archivo incluye una línea de encabezado de las etiquetas de las columnas. La etiqueta de la primera columna es `~id`, y la primera columna (la columna `~id`) almacena el ID del nodo. Las etiquetas de columna restantes de la línea de encabezado especifican, para cada columna restante, el nombre de la propiedad de nodo cuyos valores se han exportado a esa columna. + **`separator`**: una cadena que incluye el delimitador que separa las columnas de ese archivo CSV. + **`node`**: una matriz de JSON que incluye dos cadenas. La primera cadena contiene el nombre del encabezado de la columna que almacena el nodo IDs. La segunda cadena especifica el tipo de nodo del gráfico, que corresponde a una etiqueta de gráfico de propiedades del nodo. + **`features`**: una matriz de JSON de objetos de características de nodos. Consulte [Contenido de un objeto de característica incluido en una matriz de `features` para un nodo o un borde](#machine-learning-graph-node-features-config). + **`labels`**: una matriz de JSON de objetos de etiquetas de nodos. Consulte [Contenido de un objeto de etiqueta de nodo que aparece en una matriz de `labels` de nodo](#machine-learning-graph-node-labels-config). ## Contenido de un objeto de característica incluido en una matriz de `features` para un nodo o un borde Un objeto de característica de nodo incluido en una matriz de `features` de nodo puede incluir los siguientes campos de nivel superior: + **`feature`**: una matriz de JSON de tres cadenas. La primera cadena incluye el nombre del encabezado de la columna que incluye el valor de propiedad de la característica. La segunda cadena incluye el nombre de la característica. La tercera cadena incluye el tipo de característica. Los tipos de características válidos se muestran en [Valores posibles del campo type para las características](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-feature-types). + **`norm`**: este campo es obligatorio para las características numéricas. Especifica un método de normalización para usar en valores numéricos. Los valores válidos son `"none"`, `"min-max"`, y “estándar”. Para obtener más información, consulte [El campo norm](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-norm). + **`language`**: el campo de idioma especifica el idioma que se utiliza en los valores de las propiedades de texto. Su uso depende del método de codificación del texto: + En el caso de la codificación [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), este campo es obligatorio y debe especificar uno de los siguientes idiomas: + `en` (inglés) + `zh` (chino) + `hi` (hindi) + `es` (español) + `fr` (francés) Sin embargo, `text_fasttext` no puede admitir más de un idioma a la vez. + En el caso de la codificación [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), este campo no se utiliza, ya que la codificación SBERT es multilingüe. + En el caso de la codificación [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features), este campo es opcional, ya que `text_word2vec` solo admite el inglés. Si está presente, debe especificar el nombre del modelo en inglés: ``` "language" : "en_core_web_lg" ``` + En el caso de la codificación [`tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features), este campo no se utiliza. + **`max_length`**: este campo es opcional para las características [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), ya que especifica el número máximo de tokens que se codificarán en una característica de texto de entrada. Se ignorará el texto introducido una vez alcanzado `max_length`. Por ejemplo, si se establece max\$1length en 128, se ignorará cualquier token situado después del 128 en una secuencia de texto. + **`separator`**: este campo se usa de forma opcional con las características `category`, `numerical` y `auto`. Especifica un carácter que se puede utilizar para dividir el valor de una propiedad en varios valores categóricos o numéricos. Consulte [El campo separator](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-separator). + **`range`**: este campo es obligatorio para las características `bucket_numerical`. Especifica el rango de valores numéricos que se van a dividir en buckets. Consulte [El campo range](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-range). + **`bucket_cnt`**: este campo es obligatorio para las características `bucket_numerical`. Especifica el número de buckets en los que debe dividirse el rango numérico definido por el parámetro `range`. Consulte [Características numéricas por bucket de Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). + **`slide_window_size`**: este campo se usa de forma opcional con características `bucket_numerical` para asignar valores a más de un bucket. Consulte [El campo slide\$1window\$1size](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-slide_window_size). + **`imputer`**: este campo se utiliza de forma opcional con las características `numerical`, `bucket_numerical` y `datetime` para proporcionar una técnica de imputación y rellenar los valores que faltan. Las técnicas de imputación admitidas son `"mean"`, `"median"` y `"most_frequent"`. Consulte [El campo imputer](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-imputer). + **`max_features`**: las características `text_tfidf` utilizan este campo de forma opcional para especificar el número máximo de términos que se van a codificar. Consulte [El campo max\$1features](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-max_features). + **`min_df`**: las características `text_tfidf` utilizan este campo de forma opcional para especificar la frecuencia mínima de documentos de los términos que se van a codificar. Consulte [El campo min\$1df](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-min_df). + **`ngram_range`**: las características `text_tfidf` utilizan este campo de forma opcional para especificar el rango de números de palabras o tokens que deben considerarse como posibles términos individuales que se van codificar. Consulte [El campo ngram\$1range](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-ngram_range). + **`datetime_parts`**: las características `datetime` utilizan este campo de forma opcional para especificar qué partes del valor de fecha y hora deben codificarse categóricamente. Consulte [El campo datetime\$1parts](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-datetime_parts). ## Contenido de un objeto de etiqueta de nodo que aparece en una matriz de `labels` de nodo Un objeto de etiqueta incluido en una matriz de `labels` de nodo define una característica de destino del nodo y especifica las proporciones de los nodos que se utilizarán en las etapas de entrenamiento, validación y prueba. Cada objeto puede incluir los siguientes campos: ``` { "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`**: una matriz de JSON que incluye dos cadenas. La primera cadena incluye el nombre del encabezado de la columna que almacena el valor de propiedad de la característica. La segunda cadena especifica el tipo de tarea de destino, que puede ser: + `"classification"`: una tarea de clasificación de nodos. Los valores de las propiedades de la columna especificada se utilizan para crear una característica categórica. + `"regression"`: una tarea de regresión de nodos. Los valores de las propiedades de la columna especificada se utilizan para crear una característica numérica. + **`split_rate`**: una matriz de JSON que incluye tres números entre cero y uno que suman uno y que representan una estimación de las proporciones de nodos que se utilizarán en las etapas de entrenamiento, validación y prueba, respectivamente. Consulte [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate). + **`custom_split_filenames`**: un objeto de JSON que especifica los nombres de los archivos que definen las poblaciones de entrenamiento, validación y prueba. Se pueden definir este campo o la opción `split_rate`, pero no ambos. Para obtener más información, consulte [train-validation-testProporciones personalizadas](#machine-learning-custom-stages-splits). + **`separator`**: una cadena que incluye el delimitador que separa los valores de las características categóricas para una tarea de clasificación. **nota** Si no se proporciona ningún objeto de etiqueta tanto para los bordes como para los nodos, se asume automáticamente que la tarea consiste en una predicción de enlaces y los bordes se dividen de forma aleatoria en un 90 % para el entrenamiento y un 10 % para la validación. ## train-validation-testProporciones personalizadas De forma predeterminada, Neptune ML utiliza el parámetro `split_rate` para dividir el gráfico de forma aleatoria en poblaciones de entrenamiento, validación y prueba mediante las proporciones definidas en este parámetro. Para tener un control más preciso sobre qué entidades se utilizan en estas distintas poblaciones, se pueden crear archivos que las definan de forma explícita y, a continuación, [se puede editar el archivo de configuración de los datos de entrenamiento](machine-learning-processing-training-config-file.md) para asignar estos archivos de indexación a las poblaciones. Este mapeo se especifica mediante un objeto de JSON para la clave [`custom_split_filesnames`](#custom_split_filenames) del archivo de configuración de entrenamiento. Si se utiliza esta opción, se deben proporcionar los nombres de archivo para las claves `train` y `validation`, y es opcional para la clave `test`. El formato de estos archivos debe coincidir con el [formato de datos de Gremlin](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-systemheaders). Específicamente, para las tareas a nivel de nodo, cada archivo debe contener una columna con el `~id` encabezado que muestre el nodo IDs, y para las tareas `~to` a nivel de borde, los archivos deben especificar `~from` e indicar los nodos de origen y destino de los bordes, respectivamente. Estos archivos deben colocarse en la misma ubicación de Amazon S3 que los datos exportados que se utilizan para el procesamiento de datos (consulte: [`outputS3Path`](export-parameters.md#export-parameters-outputS3Path)). Para las tareas de clasificación o regresión de propiedades, estos archivos también pueden definir las etiquetas para la tarea de machine learning. En ese caso, los archivos deben tener una columna de propiedades con el mismo nombre de encabezado que el [definido en el archivo de configuración de los datos de entrenamiento](#machine-learning-graph-node-labels-config). Si las etiquetas de propiedades están definidas tanto en los archivos de nodos y de bordes exportados como en los archivos de división personalizada, se da prioridad a los archivos de división personalizada. # Entrenamiento de un modelo con Neptune ML Una vez que haya procesado los datos que ha exportado de Neptune para el entrenamiento de modelos, puede iniciar un trabajo de entrenamiento de modelos mediante un comando `curl` (o `awscurl`), tal y como se indica a continuación: ``` 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" }' ``` Los detalles sobre cómo usar este comando se explican en [El comando modeltraining](machine-learning-api-modeltraining.md), junto con información sobre cómo obtener el estado de un trabajo en ejecución, cómo detener un trabajo en ejecución y cómo enumerar todos los trabajos en ejecución. También puede proporcionar un `previousModelTrainingJobId` para utilizar la información de un trabajo de entrenamiento de modelos de Neptune ML que se haya completado para acelerar la búsqueda de hiperparámetros en un nuevo trabajo de entrenamiento. Esto es útil durante el [reentrenamiento de modelos con nuevos datos de gráficos](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-model-retraining), así como durante el [entrenamiento incremental de los mismos datos de gráficos](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental). Utilice un comando como este: ``` 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)" }' ``` Puede entrenar la implementación de su propio modelo en la infraestructura de entrenamiento de Neptune ML proporcionando un objeto `customModelTrainingParameters`, tal y como se indica a continuación: ``` 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)" } }' ``` Consulte [El comando modeltraining](machine-learning-api-modeltraining.md) para obtener más información, por ejemplo, sobre cómo obtener el estado de un trabajo en ejecución, cómo detener un trabajo en ejecución y cómo enumerar todos los trabajos en ejecución. Consulte [Modelos personalizados de Neptune ML](machine-learning-custom-models.md) para obtener información sobre cómo implementar y utilizar un modelo personalizado. **Topics** + [Modelos y entrenamiento de modelos en Amazon Neptune ML](machine-learning-models-and-training.md) + [Personalización de las configuraciones de hiperparámetros de modelos en Neptune ML](machine-learning-customizing-hyperparams.md) + [Prácticas recomendadas de entrenamiento de modelos](machine-learning-improve-model-performance.md) # Modelos y entrenamiento de modelos en Amazon Neptune ML Neptune ML utiliza redes neuronales de gráficos (GNN) para crear modelos para las distintas tareas de machine learning. Se ha demostrado que las redes neuronales de gráficos obtienen resultados de última generación para las tareas de machine learning de gráficos y son excelentes para extraer patrones informativos a partir de datos estructurados mediante gráficos. ## Redes neuronales de gráficos (GNN) en Neptune ML Las redes neuronales de gráficos (GNN) pertenecen a una familia de redes neuronales que calculan las representaciones de los nodos teniendo en cuenta la estructura y las características de los nodos cercanos. Las GNN complementan otros métodos tradicionales de machine learning y redes neuronales que no son adecuados para los datos de gráficos. Las GNN se utilizan para resolver tareas de machine learning, como la clasificación y regresión de nodos (predicción de propiedades de nodos) y la clasificación y regresión de bordes (predicción de propiedades de los bordes) o la predicción de enlaces (predicción de si dos nodos del gráfico deben estar conectados o no). En general, el uso de una GNN para una tarea de machine learning consta de dos etapas: + Una etapa de codificación, en la que la GNN calcula un vector de dimensión d para cada nodo del gráfico. Estos vectores también se denominan *representaciones* o *incrustaciones*. + Una etapa de decodificación, que hace predicciones basadas en las representaciones codificadas. Para la clasificación y regresión de nodos, las representaciones de los nodos se utilizan directamente para las tareas de clasificación y regresión. Para la clasificación y regresión de bordes, las representaciones de nodos de incidentes en un borde se utilizan como entrada para la clasificación o la regresión. Para la predicción de enlaces, se calcula una puntuación de probabilidad de borde mediante un par de representaciones de nodos y una representación de tipo de borde. La biblioteca [Deep Graph Library (DGL)](https://www.dgl.ai/) facilita la definición y el entrenamiento eficaces de las GNN para estas tareas. Los diferentes modelos de GNN se unifican bajo la formulación de transferencia de mensajes. En esta vista, la representación de un nodo en un gráfico se calcula mediante las representaciones de los vecinos del nodo (los mensajes), junto con la representación inicial del nodo. En Neptune ML, la representación inicial de un nodo se deriva de las características extraídas de sus propiedades, o se puede aprender y depende de la identidad del nodo. Neptune ML también ofrece la opción de concatenar características de nodos y representaciones de nodos que se pueden aprender para que sirvan como representación del nodo original. Para las diversas tareas de Neptune ML que implican gráficos con propiedades de nodos, utilizamos la [red convolucional de gráficos relacional](https://arxiv.org/abs/1703.06103) (R-GCN) para realizar la etapa de codificación. La R-GCN es una arquitectura de GNN adecuada para gráficos con varios tipos de nodos y bordes (estos se conocen como gráficos heterogéneos). La red R-GCN consta de un número fijo de capas, apiladas una tras otra. Cada capa de la R-GCN utiliza los parámetros de su modelo que se pueden aprender para agregar información de la vecindad inmediata de un salto de un nodo. Dado que las capas posteriores utilizan las representaciones de salida de la capa anterior como entrada, el radio de la vecindad del gráfico que influye en la incrustación final de un nodo depende del número de capas (`num-layer`) de la red R-GCN. Por ejemplo, esto significa que una red de dos capas usa información de nodos que están a dos saltos de distancia. Para obtener más información sobre las GNN, consulte [A Comprehensive Survey on Graph Neural Networks](https://arxiv.org/abs/1901.00596) (Una encuesta exhaustiva sobre las redes neuronales de gráficos). Para obtener más información sobre la biblioteca Deep Graph Library (DGL), visite la [página web](https://www.dgl.ai/) de la DGL. Para ver un tutorial práctico sobre el uso de la DGL con las GNN, consulte [Learning graph neural networks with Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library) (Obtener información sobre las redes neuronales de gráficos con Deep Graph Library). ## Entrenamiento de las redes neuronales de gráficos En el machine learning, el proceso de hacer que un modelo aprenda a hacer buenas predicciones para una tarea se denomina entrenamiento de modelos. Por lo general, esto se realiza especificando un determinado objetivo que se debe optimizar, así como un algoritmo que se debe utilizar para realizar esta optimización. Este proceso se emplea para entrenar a una GNN con el fin de que aprenda también buenas representaciones para la tarea posterior. Creamos una función objetivo para esa tarea que se minimiza durante el entrenamiento de modelos. Por ejemplo, para la clasificación de nodos, utilizamos [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html) como objetivo, lo que penaliza las clasificaciones erróneas, y para la regresión de nodos, minimizamos [MeanSquareError](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html). El objetivo suele ser una función de pérdida que toma las predicciones del modelo para un determinado punto de datos y las compara con el valor real de ese punto de datos. Devuelve el valor de pérdida, que muestra qué tan lejos están las predicciones del modelo. El objetivo del proceso de entrenamiento es minimizar la pérdida y garantizar que las predicciones del modelo se acerquen al valor real. El algoritmo de optimización utilizado en el aprendizaje profundo para el proceso de entrenamiento suele ser una variante del gradiente descendente. En Neptune ML, utilizamos [Adam](https://arxiv.org/pdf/1412.6980.pdf), que es un algoritmo para la optimización basada en gradientes de primer orden de funciones objetivo estocásticas basadas en estimaciones adaptativas de momentos de orden inferior. Si bien el proceso de entrenamiento del modelo intenta garantizar que los parámetros del modelo aprendidos estén cerca de los mínimos de la función objetivo, el rendimiento general de un modelo también depende de los *hiperparámetros* del modelo, que son ajustes del modelo que el algoritmo de entrenamiento no aprende. Por ejemplo, la dimensionalidad de la representación del nodo aprendida, `num-hidden`, es un hiperparámetro que afecta al rendimiento del modelo. Por lo tanto, en el machine learning es habitual realizar una optimización de hiperparámetros (HPO) para elegir los hiperparámetros adecuados. Neptune ML utiliza un trabajo de ajuste de hiperparámetros de SageMaker AI para lanzar varias instancias de entrenamiento de modelos con diferentes configuraciones de hiperparámetros con el fin de encontrar el mejor modelo para una serie de ajustes de hiperparámetros. Consulte [Personalización de las configuraciones de hiperparámetros de modelos en Neptune ML](machine-learning-customizing-hyperparams.md). ## Modelos de incrustación de gráficos de conocimientos de Neptune ML Los gráficos de conocimientos (KG) son gráficos que codifican información sobre diferentes entidades (nodos) y sus relaciones (bordes). En Neptune ML, los modelos de incrustación de gráficos de conocimientos se aplican de forma predeterminada para realizar la predicción de enlaces cuando el gráfico no incluye propiedades de nodo, solo relaciones con otros nodos. Aunque los modelos de R-GCN con incrustaciones que se pueden aprender también se pueden usar para estos gráficos (si indicamos `"rgcn"` como tipo de modelo), los modelos de incrustación de gráficos de conocimientos son más sencillos y se han diseñado para ser eficaces a la hora de aprender representaciones de gráficos de conocimiento a gran escala. Los modelos de incrustación de gráficos de conocimientos se utilizan en una tarea de predicción de enlaces para predecir los nodos o relaciones que completan un triple `(h, r, t)`, donde `h` es el nodo de origen, `r` es el tipo de relación y `t` es el nodo de destino. Los modelos de incrustación de gráficos de conocimientos implementados en Neptune ML son `distmult`, `transE` y `rotatE`. Para obtener más información sobre los modelos de incrustación de gráficos de conocimientos, consulte [DGL-KE.](https://github.com/awslabs/dgl-ke) ## Entrenamiento de modelos personalizados en Neptune ML Neptune ML le permite definir e implementar sus propios modelos personalizados para situaciones específicas. Consulte [Modelos personalizados de Neptune ML](machine-learning-custom-models.md) para obtener información sobre cómo implementar un modelo personalizado y cómo usar la infraestructura de Neptune ML para entrenarlo. # Personalización de las configuraciones de hiperparámetros de modelos en Neptune ML Al iniciar un trabajo de entrenamiento de modelos, Neptune ML utiliza automáticamente la información inferida del trabajo de [procesamiento de datos](machine-learning-on-graphs-processing.md) anterior. Utiliza la información para generar rangos de configuración de hiperparámetros que se utilizan para crear un [trabajo de ajuste de hiperparámetros de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html) para entrenar varios modelos para su tarea. De esta forma, no es necesario especificar una larga lista de valores de hiperparámetros para los modelos con los que se va a entrenar. En cambio, los rangos de hiperparámetros y los valores predeterminados del modelo se seleccionan en función del tipo de tarea, el tipo de gráfico y la configuración del trabajo de ajuste. Sin embargo, también puede anular la configuración predeterminada de los hiperparámetros y proporcionar hiperparámetros personalizados. Para ello, modifique un archivo de configuración de JSON que genera el trabajo de procesamiento de datos. Con la [API de modelTraining](machine-learning-api-modeltraining.md) de Neptune ML, puede controlar varias configuraciones de trabajos de ajuste de hiperparámetros de alto nivel, como, por ejemplo, `maxHPONumberOfTrainingJobs`, `maxHPOParallelTrainingJobs` y `trainingInstanceType`. Para un control más detallado de los hiperparámetros de los modelos, puede personalizar el archivo `model-HPO-configuration.json` que genera el trabajo de procesamiento de datos. El archivo se guarda en la ubicación de Amazon S3 que especificó para la salida del trabajo de procesamiento. Puede descargar el archivo, editarlo para anular las configuraciones de hiperparámetros predeterminadas y volver a cargarlo en la misma ubicación de Amazon S3. No cambie el nombre del archivo y asegúrese de seguir estas instrucciones al editarlo. Para descargar el archivo de Amazon S3: ``` aws s3 cp \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json \ ./ ``` Cuando haya terminado de editarlo, vuelva a cargar el archivo donde estaba: ``` aws s3 cp \ model-HPO-configuration.json \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json ``` ## Estructura del archivo `model-HPO-configuration.json` El archivo `model-HPO-configuration.json` especifica el modelo que se va a entrenar, la opción `task_type` del machine learning y los hiperparámetros que deben modificarse o fijarse para las distintas ejecuciones de entrenamiento del modelo. Los hiperparámetros se clasifican como pertenecientes a varios niveles, lo que indica la prioridad que se da a los hiperparámetros cuando se invoca el trabajo de ajuste de hiperparámetros: + Los hiperparámetros de nivel 1 tienen la prioridad más alta. Si se establece `maxHPONumberOfTrainingJobs` en un valor inferior a 10, solo se ajustan los hiperparámetros de nivel 1 y el resto toma sus valores predeterminados. + Los hiperparámetros de nivel 2 tienen una prioridad inferior, por lo que si tiene más de 10 pero menos de 50 trabajos de entrenamiento en total para un trabajo de ajuste, se ajustarán los hiperparámetros de nivel 1 y 2. + Los hiperparámetros de nivel 3 se ajustan junto con los de nivel 1 y 2 solo si tiene más de 50 trabajos de formación en total. + Por último, los hiperparámetros fijos no se ajustan en absoluto y siempre toman sus valores predeterminados. ### Ejemplo de un archivo `model-HPO-configuration.json` A continuación se muestra un archivo `model-HPO-configuration.json` de ejemplo: ``` { "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 } ] } ] } ``` ### Elementos de un archivo `model-HPO-configuration.json` El archivo incluye un objeto de JSON con una única matriz de nivel superior denominado `models` que incluye un único objeto de configuración de modelo. Al personalizar el archivo, asegúrese de que la matriz de `models` solo tenga un objeto de configuración de modelo. Si el archivo incluye más de un objeto de configuración de modelo, se producirá un error en el trabajo de ajuste y aparecerá una advertencia. El objeto de configuración de modelo incluye los siguientes elementos de nivel superior: + **`model`**: (*cadena*) el tipo de modelo que se va a entrenar (**no lo modifique**). Los valores válidos son: + `"rgcn"`: este es el valor predeterminado para las tareas de clasificación y regresión de nodos y para las tareas heterogéneas de predicción de enlaces. + `"transe"`: este es el valor predeterminado para las tareas de predicción de enlaces de KGE. + `"distmult"`: este es un tipo de modelo alternativo para las tareas de predicción de enlaces de KGE. + `"rotate"`: este es un tipo de modelo alternativo para las tareas de predicción de enlaces de KGE. Por regla general, no modifique directamente el valor de `model`, ya que los diferentes tipos de modelos suelen tener hiperparámetros aplicables bastante diferentes, lo que puede provocar un error de análisis una vez iniciado el trabajo de entrenamiento. Para cambiar el tipo de modelo, utilice el parámetro `modelName` de la [API de modelTraining](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) en lugar de cambiarlo en el archivo `model-HPO-configuration.json`. Una forma de cambiar el tipo de modelo y realizar cambios detallados en los hiperparámetros consiste en copiar la plantilla predeterminada de configuración del modelo para el modelo que desee usar y pegarla en el archivo `model-HPO-configuration.json`. Hay una carpeta con el nombre `hpo-configuration-templates` en la misma ubicación de Amazon S3 que el archivo `model-HPO-configuration.json` si el tipo de tarea inferido admite varios modelos. Esta carpeta incluye todas las configuraciones predeterminadas de hiperparámetros para los demás modelos que se aplican a la tarea. Por ejemplo, si desea cambiar las configuraciones del modelo y de los hiperparámetros de una tarea de predicción de enlaces de `KGE` del modelo predeterminado`transe` a un modelo `distmult`, simplemente pegue el contenido del archivo `hpo-configuration-templates/distmult.json` en el archivo `model-HPO-configuration.json` y, a continuación, edite los hiperparámetros según sea necesario. **nota** Si establece el parámetro `modelName` en la API de `modelTraining` y también cambia la opción `model` y la especificación del hiperparámetro en el archivo `model-HPO-configuration.json`, y estos son diferentes, el valor `model` del archivo `model-HPO-configuration.json` tendrá prioridad y se omitirá `modelName`. + **`task_type`**: (*cadena*) el tipo de tarea de machine learning inferido o transferido directamente al trabajo de procesamiento de datos (**no lo modifique**). Los valores válidos son: + `"node_class"` + `"node_regression"` + `"link_prediction"` El trabajo de procesamiento de datos infiere el tipo de tarea examinando las propiedades del conjunto de datos exportado y el archivo de configuración del trabajo de entrenamiento generado. Este valor no debe modificarse. Si desea entrenar otra tarea, debe [ejecutar un nuevo trabajo de procesamiento de datos](machine-learning-on-graphs-processing.md). Si el valor `task_type` no es el que esperaba, debe comprobar las entradas del trabajo de procesamiento de datos para asegurarse de que sean correctas. Esto incluye los parámetros de la API de `modelTraining` y del archivo de configuración del trabajo de entrenamiento generado por el proceso de exportación de datos. + **`eval_metric`**: (*cadena*) la métrica de evaluación debe usarse para evaluar el rendimiento del modelo y seleccionar el modelo con mejor rendimiento en todas las ejecuciones de HPO. Los valores válidos son: + `"acc"`: precisión de clasificación estándar. Este es el valor predeterminado para las tareas de clasificación de una sola etiqueta, a menos que se encuentren etiquetas desequilibradas durante el procesamiento de los datos, en cuyo caso el valor predeterminado es `"F1"`. + `"acc_topk"`: el número de veces que la etiqueta correcta figura entre las principales predicciones de **`k`**. Para establecer el valor **`k`**, también puede proporcionar el valor `topk` como clave adicional. + `"F1"`: el [valor F1](https://en.wikipedia.org/wiki/F-score). + `"mse"`: [métrica de error cuadrático medio](https://en.wikipedia.org/wiki/Mean_squared_error), para tareas de regresión. + `"mrr"`: [métrica de rango recíproco medio](https://en.wikipedia.org/wiki/Mean_reciprocal_rank). + `"precision"`: la precisión del modelo, calculada como la proporción entre los positivos verdaderos y los positivos pronosticados: `= true-positives / (true-positives + false-positives)`. + `"recall"`: la exhaustividad del modelo, calculada como la proporción entre los positivos verdaderos y los positivos pronosticados: `= true-positives / (true-positives + false-negatives)`. + `"roc_auc"`: el área debajo de la [curva ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic). Este es el valor predeterminado para la clasificación de varias etiquetas. Por ejemplo, para cambiar la métrica a `F1`, cambie el valor `eval_metric` de la siguiente manera: ``` " eval_metric": { "metric": "F1", }, ``` O bien, si desea cambiar la métrica a una puntuación de precisión `topk`, debería cambiar el valor `eval_metric` de la siguiente manera: ``` "eval_metric": { "metric": "acc_topk", "topk": 2 }, ``` + **`eval_frequency`**: (*objeto*) especifica con qué frecuencia se debe comprobar el rendimiento del modelo en el conjunto de validación durante el entrenamiento. En función del rendimiento de la validación, se puede iniciar una detención temprana y guardar el mejor modelo. El objeto `eval_frequency` incluye dos elementos: `"type"` y `"value"`. Por ejemplo: ``` "eval_frequency": { "type": "evaluate_every_pct", "value": 0.1 }, ``` Los valores válidos de `type` son: + **`evaluate_every_pct`**: especifica el porcentaje de entrenamiento que debe completarse en cada evaluación. En el caso de `evaluate_every_pct`, el campo `"value"` incluye un número de coma flotante entre cero y uno que expresa ese porcentaje. + **`evaluate_every_batch`**: especifica el número de lotes entrenamiento que debe completarse en cada evaluación. En el caso de `evaluate_every_batch`, el campo `"value"` incluye un número entero que expresa el recuento de lotes. + **`evaluate_every_epoch`**: especifica el número de épocas por evaluación, donde una nueva época comienza a medianoche. En el caso de `evaluate_every_epoch`, el campo `"value"` incluye un número entero que expresa el recuento de épocas. El ajuste predeterminado de `eval_frequency` es: ``` "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, ``` + **`1-tier-param`**: (*obligatorio*) una matriz de hiperparámetros de nivel 1. Si no desea ajustar ningún hiperparámetro, puede hacerlo en una matriz vacía. Esto no afecta al número total de trabajos de formación iniciados por el trabajo de ajuste de hiperparámetros de la SageMaker IA. Tan solo significa que todos los trabajos de entrenamiento, si hay más de 1 pero menos de 10, se ejecutarán con el mismo conjunto de hiperparámetros. Por otro lado, si desea tratar todos los hiperparámetros ajustables con la misma importancia, puede colocar todos los hiperparámetros en esta matriz. + **`2-tier-param`**: (*obligatorio*) una matriz de hiperparámetros de nivel 2. Estos parámetros solo se ajustan si la opción `maxHPONumberOfTrainingJobs` tiene un valor superior a 10. De lo contrario, se fijan a los valores predeterminados. Si tiene un presupuesto de entrenamiento de un máximo de 10 trabajos de entrenamiento o no quiere hiperparámetros de nivel 2 por algún otro motivo, pero desea ajustar todos los hiperparámetros ajustables, puede hacerlo en una matriz vacía. + **`3-tier-param`**: (*obligatorio*) una matriz de hiperparámetros de nivel 3. Estos parámetros solo se ajustan si la opción `maxHPONumberOfTrainingJobs` tiene un valor superior a 50. De lo contrario, se fijan a los valores predeterminados. Si no desea ajustar los hiperparámetros de nivel 3, puede hacerlo en una matriz vacía. + **`fixed-param`**: (*obligatorio*) una matriz de hiperparámetros fijos que solo toman sus valores predeterminados y no varían en los distintos trabajos de entrenamiento. Si desea modificar todos los hiperparámetros, puede hacerlo en una matriz vacía y establecer el valor para `maxHPONumberOfTrainingJobs` lo suficientemente grande como para modificar todos los niveles o hacer que todos los hiperparámetros sean de nivel 1. El objeto de JSON que representa cada hiperparámetro de `1-tier-param`, `2-tier-param`, `3-tier-param` y `fixed-param` incluye los siguientes elementos: + **`param`**: (*cadena*) el nombre del hiperparámetro (**no lo modifique**). Consulte la [lista de nombres de hiperparámetros válidos en Neptune ML](#machine-learning-hyperparams-list). + **`type`**: (*cadena*) el tipo del hiperparámetro (**no lo modifique**). Los tipos válidos son `bool`, `int` y`float`. + **`default`**: (*cadena*) El valor predeterminado del hiperparámetro. Puede establecer un nuevo valor predeterminado. Los hiperparámetros ajustables también pueden incluir los siguientes elementos: + **`range`**: (*matriz*) el rango de un hiperparámetro ajustable continuo. Debe ser una matriz con dos valores, es decir, el mínimo y el máximo del rango (`[min, max]`). + **`options`**: (*matriz*) las opciones de un hiperparámetro ajustable categórico. Esta matriz debe incluir todas las opciones que se deben tener en cuenta: ``` "options" : [value1, value2, ... valuen] ``` + **`inc_strategy`**: (*cadena*) el tipo de cambio incremental para rangos de hiperparámetros ajustables continuos (**no lo modifique**). Los valores válidos son `log`, `linear` y `power2`. Esto solo se aplica cuando se establece la clave de rango. Si se modifica, es posible que no se utilice todo el rango del hiperparámetro para el ajuste. + **`inc_val`**: (*flotante*) la diferencia entre los incrementos sucesivos de los hiperparámetros ajustables continuo (**no lo modifique**). Esto solo se aplica cuando se establece la clave de rango. Si se modifica, es posible que no se utilice todo el rango del hiperparámetro para el ajuste. + **`node_strategy`**: (*cadena*) indica que el rango efectivo de este hiperparámetro debe cambiar en función del número de nodos del gráfico (**no lo modifique**). Los valores válidos son `"perM"` (por millón), `"per10M"` (por 10 millones) y `"per100M"` (por 100 millones). En lugar de cambiar este valor, cambie la opción `range`. + **`edge_strategy`**: (*cadena*) indica que el rango efectivo de este hiperparámetro debe cambiar en función del número de bordes del gráfico (**no lo modifique**). Los valores válidos son `"perM"` (por millón), `"per10M"` (por 10 millones) y `"per100M"` (por 100 millones). En lugar de cambiar este valor, cambie la opción `range`. ### Lista de todos los hiperparámetros de Neptune ML En la siguiente lista se incluyen todos los hiperparámetros que se pueden configurar en cualquier lugar de Neptune ML, para cualquier tipo de modelo y tarea. Como no todos son aplicables a todos los tipos de modelo, es importante que solo establezca los hiperparámetros en el archivo `model-HPO-configuration.json` que aparece en la plantilla del modelo que esté utilizando. + **`batch-size`**: el tamaño del lote de nodos de destino que se utilizan en un pase hacia adelante. *Tipo*: `int`. Si se establece en un valor mucho mayor, se pueden producir problemas de memoria durante el entrenamiento en instancias de GPU. + **`concat-node-embed`**: indica si se debe obtener la representación inicial de un nodo concatenando sus características procesadas con incrustaciones de nodos iniciales que se puedan aprender con el fin de aumentar la expresividad del modelo. *Tipo*: `bool`. + **`dropout`**: la probabilidad de abandono aplicada a las capas de abandono. *Tipo*: `float`. + **`edge-num-hidden`**: el tamaño de la capa oculta o el número de unidades del módulo de características de borde. Solo se usa cuando el valor `use-edge-features` está establecido en `True`. *Tipo*: flotante. + **`enable-early-stop`**: cambia si se utiliza o no la característica de detención temprana. *Tipo*: `bool`. *Valor predeterminado*: `true`. Utilice este parámetro booleano para desactivar la característica de detención temprana. + **`fanout`**: el número de vecinos que se deben muestrear para un nodo de destino durante el muestreo de vecinos. *Tipo*: `int`. Este valor está estrechamente relacionado con el mismo nivel de hiperparámetros `num-layers` y siempre debe estar en el mismo. Esto se debe a que puede especificar una distribución ramificada para cada posible capa de GNN. Como este hiperparámetro puede hacer que el rendimiento del modelo varíe considerablemente, debe ser fijo o establecerse como un hiperparámetro de nivel 2 o 3. Si se establece en un valor grande se pueden producir problemas de memoria durante el entrenamiento en instancias de GPU. + **`gamma`**: el valor del margen de la función de puntuación. *Tipo*: `float`. Esto se aplica únicamente a los modelos de predicción de enlaces de `KGE`. + **`l2norm`**: el valor de decadencia de ponderación utilizado en el optimizador, que impone una penalización de normalización L2 a las ponderaciones. *Tipo*: `bool`. + **`layer-norm`**: indica si se debe utilizar la normalización de capas para los modelos `rgcn`. *Tipo*: `bool`. + **`low-mem`**: indica si se debe utilizar una implementación con poca memoria de la función de transferencias de mensajes de relación en detrimento de la velocidad. *Tipo*: `bool`. + **`lr`**: la tasa de aprendizaje. *Tipo*: `float`. Debe configurarse como un hiperparámetro de nivel 1. + **`neg-share`**: en la predicción de enlaces, indica si los bordes muestreados positivos pueden compartir ejemplos de bordes negativos. *Tipo*: `bool`. + **`num-bases`**: el número de bases para la descomposición de bases en un modelo `rgcn`. El uso de un valor de `num-bases` que sea inferior al número de tipos de bordes del gráfico actúa como regularizador del modelo `rgcn`. *Tipo*: `int`. + **`num-epochs`**: el número de épocas del entrenamiento que se va a ejecutar. *Tipo*: `int`. Una época es un recorrido completo de entrenamiento por el gráfico. + **`num-hidden`**: el tamaño de la capa oculta o el número de unidades. *Tipo*: `int`. Esto también establece el tamaño de incrustación inicial para los nodos sin características. Si se establece en un valor mucho mayor sin reducirlo, `batch-size` se pueden producir out-of-memory problemas al entrenar en una instancia de GPU. + **`num-layer`**: el número de capas GNN en el modelo. *Tipo*: `int`. Este valor está estrechamente relacionado con el parámetro de distribución ramificada y debe aparecer después de que la distribución ramificada se establezca en la misma capa de hiperparámetro. Dado que esto puede hacer que el rendimiento del modelo varíe considerablemente, debe ser fijo o establecerse como un hiperparámetro de nivel 2 o 3. + **`num-negs`**: en la predicción de enlaces, el número de muestras negativas por muestra positiva. *Tipo*: `int`. + **`per-feat-name-embed`**: indica si se debe incrustar cada característica transformándola de forma independiente antes de combinar características. *Tipo*: `bool`. Si se establece en `true`, cada característica por nodo se transforma de forma independiente en un tamaño de dimensión fijo antes de que todas las características transformadas del nodo se concatenen y se transformen posteriormente en la dimensión `num_hidden`. Cuando se establece en `false`, las características se concatenan sin ninguna transformación específica de la característica. + **`regularization-coef`**: en la predicción de enlaces, el coeficiente de pérdida de regularización. *Tipo*: `float`. + **`rel-part`**: indica si se debe utilizar la partición de relaciones para la predicción de enlaces de `KGE`. *Tipo*: `bool`. + **`sparse-lr`**: la tasa de aprendizaje de las incrustaciones de nodos que se pueden aprender. *Tipo*: `float`. Las incrustaciones de nodos iniciales que se pueden aprender se utilizan para los nodos sin características o cuando esté establecida la opción `concat-node-embed`. Los parámetros de la capa de incrustación de nodos dispersos que se pueden aprender se entrenan mediante un optimizador independiente que puede tener una tasa de aprendizaje diferente. + **`use-class-weight`**: indica si se deben aplicar ponderaciones de clase a las tareas de clasificación desequilibradas. Si se establece en `true`, los recuentos de etiquetas se utilizan para establecer una ponderación para cada etiqueta de clase. *Tipo*: `bool`. + **`use-edge-features`**: indica si se deben utilizar las características de borde al transferir los mensajes. Si se establece en `true`, se añade un módulo de características de borde personalizado a la capa RGCN para los tipos de bordes que tienen características. *Tipo*: `bool`. + **`use-self-loop`**: indica si se deben incluir bucles automáticos en el entrenamiento de un modelo `rgcn`. *Tipo*: `bool`. + **`window-for-early-stop`**: controla el número de puntuaciones de validación más recientes para obtener una media con el fin de decidir si se debe detener antes de tiempo. El valor predeterminado es 3. type=int. Véase también [Detención temprana del proceso de entrenamiento de modelos en Neptune ML](machine-learning-improve-model-performance.md#machine-learning-model-training-early-stop). *Tipo*: `int`. *Valor predeterminado*: `3`. Consulte . ## Personalización de hiperparámetros en Neptune ML Al editar el archivo `model-HPO-configuration.json`, los tipos de cambios más habituales que hay que realizar son los siguientes: + Edite los valores and/or máximos mínimos de los `range` hiperparámetros. + Para establecer un hiperparámetro en un valor fijo, muévalo a la sección `fixed-param` y establezca su valor predeterminado en el valor fijo que desee que adquiera. + Para cambiar la prioridad de un hiperparámetro, colóquelo en un determinado nivel, edite su rango y asegúrese de que su valor predeterminado esté establecido de forma adecuada. # Prácticas recomendadas de entrenamiento de modelos Hay cosas que puede hacer para mejorar el rendimiento de los modelos de Neptune ML. ## Selección de la propiedad de nodo correcta Es posible que no todas las propiedades del gráfico sean significativas o relevantes para las tareas de machine learning. Debe excluirse cualquier propiedad irrelevante durante la exportación de datos. A continuación le presentamos algunas prácticas recomendadas: + Recurra a expertos en la materia para que le ayuden a evaluar la importancia de las características y la viabilidad de utilizarlas para hacer predicciones. + Elimine las características que considere redundantes o irrelevantes para reducir el ruido en los datos y las correlaciones sin importancia. + Realice iteraciones a medida que crea el modelo. Ajuste las características, las combinaciones de características y ajuste los objetivos a medida que avanza. En la sección [Procesamiento de características](https://docs.aws.amazon.com/machine-learning/latest/dg/feature-processing.html) de la Guía para desarrolladores de Amazon Machine Learning se proporcionan directrices adicionales para el procesamiento de características que son relevantes para Neptune ML. ## Gestión de puntos de datos atípicos Un valor atípico es un punto de datos que difiere bastante del resto de datos. Los valores atípicos de los datos pueden confundir o engañar al proceso de entrenamiento, lo que se traduce en un tiempo de entrenamiento más prolongado o en modelos menos precisos. A menos que sean realmente importantes, debe eliminar los valores atípicos antes de exportar los datos. ## Eliminación de los nodos y bordes duplicados Los gráficos almacenados en Neptune pueden tener nodos o bordes duplicados. Estos elementos redundantes introducirán ruido durante el entrenamiento de modelos de ML. Elimine los nodos o bordes duplicados antes de exportar los datos. ## Ajuste de la estructura del gráfico Al exportar el gráfico, puede cambiar la forma en que se procesan las características y cómo se crea el gráfico para mejorar el rendimiento del modelo. A continuación le presentamos algunas prácticas recomendadas: + Cuando una propiedad de borde tiene el significado de categorías de bordes, en algunos casos, merece la pena convertirla en tipos de borde. + La política de normalización predeterminada que se utiliza para una propiedad numérica es `min-max`, pero, en algunos casos, otras políticas de normalización funcionan mejor. Puede preprocesar la propiedad y cambiar la política de normalización, tal y como se explica en [Elementos de un archivo `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements). + El proceso de exportación genera automáticamente tipos de características en función de los tipos de propiedad. Por ejemplo, trata las propiedades de `String` como características categóricas y las propiedades de `Float` y `Int` como características numéricas. Si fuera necesario, puede modificar el tipo de característica después de la exportación (consulte [Elementos de un archivo `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements)). ## Ajuste de los rangos y valores predeterminados de los hiperparámetros La operación de procesamiento de datos infiere los rangos de configuración de los hiperparámetros a partir del gráfico. Si los rangos de hiperparámetros y los valores predeterminados del modelo generados no funcionan bien con los datos del gráfico, puede editar el archivo de configuración de HPO para crear su propia estrategia de ajuste de hiperparámetros. A continuación le presentamos algunas prácticas recomendadas: + Al ampliar el gráfico, es posible que el tamaño predeterminado de la dimensión oculta no sea lo suficientemente grande como para incluir toda la información. Puede cambiar el hiperparámetro `num-hidden` para controlar el tamaño de la dimensión oculta. + En el caso de los modelos de incrustación de gráficos de conocimientos (KGE), es posible que desee cambiar el modelo específico que se utiliza en función del presupuesto y la estructura del gráfico. Los modelos de `TrainsE` tienen dificultades para tratar relaciones de uno a muchos (1-N), de muchos a uno (N-1) y de muchos a muchos (N-N). Los modelos de `DistMult` tienen dificultades para tratar las relaciones simétricas. `RotatE` es una buena opción para modelar todo tipo de relaciones, pero es más caro que `TrainsE` y `DistMult` durante el entrenamiento. + En algunos casos, cuando la identificación del nodo y la información de las características del nodo son importantes, debe utilizar ``concat-node-embed`` para indicar al modelo de Neptune ML que obtenga la representación inicial de un nodo mediante la concatenación de sus características con sus incrustaciones iniciales. + Si obtiene un rendimiento razonablemente bueno con algunos hiperparámetros, puede ajustar el espacio de búsqueda de hiperparámetros en función de estos resultados. ## Detención temprana del proceso de entrenamiento de modelos en Neptune ML La detención temprana puede reducir considerablemente el tiempo de ejecución del entrenamiento de modelos y los costos asociados sin degradar el rendimiento de los modelos. También evita que el modelo se sobreajuste a los datos de entrenamiento. La detención temprana depende de las mediciones periódicas del rendimiento del conjunto de validación. Inicialmente, el rendimiento mejora a medida que avanza el entrenamiento, pero cuando el modelo comienza a sobreajustarse, vuelve a disminuir. La característica de detención temprana identifica el punto en el que el modelo comienza a sobreajustarse y detiene el entrenamiento del modelo en ese momento. Neptune ML supervisa las llamadas a las métricas de validación y compara la métrica de validación más reciente con el promedio de las métricas de validación de las últimas evaluaciones de **`n`**, donde **`n`** es un número establecido mediante el parámetro `window-for-early-stop`. En cuanto la métrica de validación es inferior al promedio, Neptune ML detiene el entrenamiento del modelo y guarda el mejor modelo hasta el momento. Puede controlar la detención temprana mediante los siguientes parámetros: + **`window-for-early-stop`**: el valor de este parámetro es un número entero que especifica el número de puntuaciones de validación recientes que se van a promediar cuando se decide si realizar una detención temprana. El valor predeterminado es `3`. + **`enable-early-stop`**: utilice este parámetro booleano para desactivar la característica de detención temprana. De forma predeterminada su valor es `true`. ## Detención temprana del proceso de HPO en Neptune ML La característica de detención temprana de Neptune ML también detiene los trabajos de entrenamiento que no tienen un buen rendimiento en comparación con otros trabajos, mediante la característica de inicio en caliente de HPO de SageMaker AI. Esto también puede reducir los costos y mejorar la calidad de HPO. Consulte [Ejecución de un trabajo de ajuste de hiperparámetros de inicio en caliente](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html) para obtener una descripción de su funcionamiento. El inicio en caliente permite transferir la información aprendida en trabajos de entrenamiento anteriores a trabajos de entrenamiento posteriores y ofrece dos ventajas bien diferenciadas: + En primer lugar, los resultados de los trabajos de entrenamiento anteriores se utilizan para seleccionar combinaciones correctas de hiperparámetros para realizar búsquedas en el nuevo trabajo de ajuste. + En segundo lugar, permite una detención temprana para acceder a más ejecuciones del modelo, lo que reduce el tiempo de ajuste. Esta característica se habilita automáticamente en Neptune ML y le permite lograr un equilibrio entre el tiempo de entrenamiento del modelo y el rendimiento. Si está satisfecho con el rendimiento del modelo actual, puede utilizar ese modelo. De lo contrario, ejecute más HPO que se inicien en caliente con los resultados de ejecuciones anteriores para descubrir un modelo mejor. ## Obtener servicios de soporte profesional AWS ofrece servicios de soporte profesional para ayudarle con los problemas del machine learning en los proyectos de Neptune. Si se queda bloqueado, póngase en contacto con [AWS Support](https://aws.amazon.com/premiumsupport/). # Uso de un modelo entrenado para generar nuevos artefactos de modelo Con el comando de transformación de modelos de Neptune ML, puede calcular artefactos de modelos, como incrustaciones de nodos, en datos de gráficos procesados mediante parámetros de modelo previamente entrenados. ## Transformación de modelos para la inferencia incremental En el [flujo de trabajo de inferencia incremental de modelos](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental), una vez que haya procesado los datos de gráficos actualizados que ha exportado de Neptune, puede iniciar un trabajo de transformación de modelo mediante un comando curl (o awscurl), tal y como se indica a continuación: ``` 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/" }' ``` A continuación, puede transferir el ID de este trabajo a la llamada a la API de create-endpoints para crear un nuevo punto de conexión o actualizar uno existente con los nuevos artefactos del modelo generados por este trabajo. Esto permite que el punto de conexión nuevo o actualizado proporcione predicciones del modelo para los datos de gráficos actualizados. ## Transformación de modelos para cualquier trabajo de entrenamiento También puede proporcionar un parámetro `trainingJobName` para generar artefactos de modelos para cualquiera de los trabajos de entrenamiento de SageMaker AI lanzados durante el entrenamiento de modelos de Neptune ML. Dado que un trabajo de entrenamiento de modelos de Neptune ML puede lanzar muchos trabajos de entrenamiento de SageMaker AI, esto le ofrece la flexibilidad de crear un punto de conexión de inferencia basado en cualquiera de esos trabajos de entrenamiento de SageMaker AI. Por ejemplo: ``` 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 el trabajo de entrenamiento original era para un modelo personalizado proporcionado por el usuario, debe incluir un objeto `customModelTransformParameters` al invocar una transformación de modelo. Consulte [Modelos personalizados de Neptune ML](machine-learning-custom-models.md) para obtener información sobre cómo implementar y utilizar un modelo personalizado. **nota** El comando `modeltransform` siempre ejecuta la transformación del modelo en el mejor trabajo de entrenamiento de SageMaker AI para ese entrenamiento. Consulte [El comando modeltransform](machine-learning-api-modeltransform.md) para obtener más información sobre los trabajos de transformación de modelos. # Artefactos producidos por el entrenamiento de modelos en Neptune ML Tras el entrenamiento del modelo, Neptune ML utiliza los parámetros del modelo mejor entrenados para generar los artefactos del modelo que son necesarios para lanzar el punto de conexión de inferencia y proporcionar predicciones del modelo. Estos artefactos se empaquetan según el trabajo de entrenamiento y se almacenan en la ubicación de salida de Amazon S3 del mejor trabajo de entrenamiento de SageMaker AI. En las siguientes secciones se describe lo que se incluye en los artefactos de modelos para las distintas tareas y cómo el comando de transformación de modelos utiliza un modelo entrenado preexistente para generar artefactos, incluso a partir de datos de gráficos nuevos. ## Artefactos generados para diferentes tareas El contenido de los artefactos de modelos generados por el proceso de entrenamiento depende de la tarea de machine learning de destino: **** + **Clasificación y regresión de los nodos**: para la predicción de las propiedades de los nodos, los artefactos incluyen los parámetros del modelo, las incrustaciones de nodos del [codificador GNN](machine-learning-models-and-training.md#machine-learning-gnns), las predicciones del modelo para los nodos del gráfico de entrenamiento y algunos archivos de configuración para el punto de conexión de inferencia. En las tareas de clasificación y regresión de nodos, las predicciones del modelo se calculan previamente para los nodos presentes durante el entrenamiento con el fin de reducir la latencia de las consultas. + **Clasificación y regresión de bordes**: para la predicción de las propiedades de las bordes, los artefactos también incluyen los parámetros del modelo y las incrustaciones de nodos. Los parámetros del decodificador del modelo son especialmente importantes para la inferencia, ya que calculamos la clasificación de los bordes o las predicciones de regresión de los bordes aplicando el decodificador del modelo a las incrustaciones del vértice de origen y destino de un borde. + **Predicción de enlaces**: para la predicción de enlaces, además de los artefactos generados para la predicción de propiedades de borde, el gráfico DGL también se incluye como artefacto, ya que la predicción de enlaces requiere que el gráfico de entrenamiento realice las predicciones. El objetivo de la predicción de enlaces es predecir los vértices de destino que es probable que se combinen con un vértice de origen para formar un borde de un determinado tipo en el gráfico. Para ello, se combinan la incrustación de nodos del vértice de origen y una representación aprendida del tipo de borde con las incrustaciones de nodos de todos los vértices de destino posibles para obtener una puntuación de probabilidad de borde para cada uno de los vértices de destino. A continuación, las puntuaciones se ordenan para clasificar los posibles vértices de destino y devolver los mejores candidatos. Para cada uno de los tipos de tareas, las ponderaciones del modelo de red neuronal de gráficos se guardan en el artefacto del modelo. Esto permite a Neptune ML calcular salidas de modelos nuevos a medida que cambia el gráfico (inferencia *inductiva*), además de utilizar predicciones e incrustaciones precalculadas (inferencia *transductiva*) para reducir la latencia. ## Creación de nuevos artefactos de modelos Los artefactos de modelos generados después del entrenamiento del modelo en Neptune ML están directamente relacionados con el proceso de entrenamiento. Esto significa que las incrustaciones y predicciones precalculadas solo existen para las entidades que estaban en el gráfico de entrenamiento original. Aunque el modo de inferencia inductiva para los puntos de conexión de Neptune ML puede calcular predicciones para nuevas entidades en tiempo real, es posible que desee generar predicciones por lotes sobre nuevas entidades sin consultar un punto de conexión. Para obtener las predicciones de modelos por lotes para las nuevas entidades que se han añadido al gráfico, es necesario volver a calcular los artefactos de modelos nuevos para los nuevos datos de gráfico. Esto se logra mediante el comando `modeltransform`. Utilice el comando `modeltransform` cuando solo desee realizar predicciones por lotes sin configurar un punto de conexión, o cuando desee que se generen todas las predicciones de forma que pueda volver a escribirlas en el gráfico. Dado que el entrenamiento de modelos realiza de forma implícita una transformación del modelo al final del proceso de entrenamiento, los artefactos de modelos siempre se vuelven a calcular a partir de los datos del gráfico de entrenamiento mediante un trabajo de entrenamiento. Sin embargo, el comando `modeltransform` también puede calcular los artefactos de modelos en los datos del gráfico que no se usaron para entrenar un modelo. Para ello, los nuevos datos de gráficos deben procesarse con las mismas codificaciones de características que los datos de gráficos originales y deben seguir el mismo esquema de gráfico. Para ello, cree primero un nuevo trabajo de procesamiento de datos que sea un clon del trabajo de procesamiento de datos ejecutado con los datos del gráfico de entrenamiento original y ejecútelo con los nuevos datos del gráfico (consulte [Procesamiento de datos de gráficos actualizados para Neptune ML](machine-learning-on-graphs-processing.md#machine-learning-on-graphs-processing-updated)). A continuación, llame al comando `modeltransform` con el nuevo `dataProcessingJobId` y el antiguo `modelTrainingJobId` para volver a calcular los artefactos del modelo a partir de los datos del gráfico actualizados. Para la predicción de las propiedades de los nodos, las incrustaciones y predicciones de los nodos se vuelven a calcular a partir de los nuevos datos del gráfico, incluso también para los nodos que estaban presentes en el gráfico de entrenamiento original. Para la predicción de las propiedades de los bordes y los enlaces, las incrustaciones de los nodos también se vuelven a calcular y, de forma similar, anulan cualquier incrustación de nodos existente. Para volver a calcular las incrustaciones de nodos, Neptune ML aplica el codificador GNN aprendido del modelo entrenado anterior a los nodos de los nuevos datos de gráficos con sus nuevas características. En el caso de los nodos que no tengan características, se vuelven a utilizar las representaciones iniciales aprendidas del entrenamiento del modelo original. En el caso de los nodos nuevos que no tengan características y no estaban presentes en el gráfico de entrenamiento original, Neptune ML inicializa su representación como el promedio de las representaciones de nodos iniciales aprendidas de ese tipo de nodo presentes en el gráfico de entrenamiento original. Esto puede provocar una disminución en el rendimiento de las predicciones del modelo si hay muchos nodos nuevos que no tengan características, ya que todos se inicializarán con la incrustación inicial promedio de ese tipo de nodo. Si el modelo se entrena con el valor `concat-node-embed` establecido en true, las representaciones de los nodos iniciales se crean concatenando las características del nodo con la representación inicial que se puede aprender. Por lo tanto, para el gráfico actualizado, la representación del nodo inicial de los nodos nuevos también utiliza el promedio de incrustaciones de nodos iniciales, concatenadas con las nuevas características de los nodos. Además, actualmente no se admiten las eliminaciones de nodos. Si se han eliminado los nodos del gráfico actualizado, debe volver a entrenar el modelo a partir de los datos del gráfico actualizado. Al volver a calcular los artefactos del modelo, se vuelven a utilizar los parámetros del modelo aprendidos en un gráfico nuevo, y solo debe realizarse cuando el nuevo gráfico sea muy similar al antiguo. Si el nuevo gráfico no es lo suficientemente similar, es necesario volver a entrenar el modelo para obtener un rendimiento similar con los datos del nuevo gráfico. Lo que se considere suficientemente similar depende de la estructura de los datos del gráfico, pero como regla general, debe volver a entrenar el modelo si los nuevos datos difieren entre un 10 y un 20 % de los datos del gráfico de entrenamiento original. En el caso de los gráficos en los que todos los nodos tengan características, se aplica el extremo superior del umbral (un 20 % de diferencia), pero en el caso de los gráficos en los que muchos nodos no tengan características y los nuevos nodos añadidos al gráfico no tengan propiedades, el extremo inferior (un 10 % de diferencia) puede ser incluso demasiado alto. Consulte [El comando modeltransform](machine-learning-api-modeltransform.md) para obtener más información sobre los trabajos de transformación de modelos. # Modelos personalizados de Neptune ML **nota** La compatibilidad con el modelo personalizado de Neptune ML se basa en una versión anterior de Python 3. [Para crear y ejecutar modelos GNN personalizados con up-to-date dependencias, utilice on. GraphStorm SageMaker](https://graphstorm.readthedocs.io/en/v0.3.1/cli/model-training-inference/distributed/sagemaker.html) Por el momento, los modelos personalizados no admiten la [inferencia inductiva en tiempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference). Neptune ML le permite definir sus propias implementaciones de modelos personalizados mediante Python. Puede entrenar e implementar modelos personalizados con la infraestructura de Neptune ML de la misma manera que lo hace con los modelos integrados, y usarlos para obtener predicciones mediante consultas de gráficos. Para empezar a implementar su propio modelo personalizado en Python, siga los [ejemplos del kit de herramientas de Neptune ML](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/) y utilice los componentes del modelo que se proporcionan en el kit de herramientas de Neptune ML. En las siguientes secciones ofrecemos más información. **Contents** + [Información general sobre los modelos personalizados de Neptune ML](machine-learning-custom-model-overview.md) + [Cuándo usar un modelo personalizado en Neptune ML](machine-learning-custom-model-overview.md#machine-learning-custom-models-when-to-use) + [Flujo de trabajo para desarrollar y usar un modelo personalizado en Neptune ML](machine-learning-custom-model-overview.md#machine-learning-custom-model-workflow) + [Desarrollo de modelos personalizados en Neptune ML](machine-learning-custom-model-development.md) + [Desarrollo de scripts de entrenamiento de modelos personalizados en Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-training-script) + [Desarrollo de scripts de transformación de modelos personalizados en Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-transform-script) + [Archivo `model-hpo-configuration.json` personalizado de Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-hpo-configuration-file) + [Pruebas locales de la implementación de un modelo personalizado en Neptune ML](machine-learning-custom-model-development.md#machine-learning-custom-model-testing) # Información general sobre los modelos personalizados de Neptune ML ## Cuándo usar un modelo personalizado en Neptune ML Los modelos integrados de Neptune ML gestionan todas las tareas estándar compatibles con Neptune ML, pero puede haber casos en los que desee tener un control más detallado sobre el modelo para una tarea concreta o necesite personalizar el proceso de entrenamiento de modelos. Por ejemplo, un modelo personalizado es adecuado en las siguientes situaciones: + La codificación de características para las características de texto de los modelos de texto muy grandes deben ejecutarse en la GPU. + Desea utilizar su propio modelo de red neuronal gráfica (GNN) personalizado y desarrollado en la biblioteca Deep Graph Library (DGL). + Desea utilizar modelos tabulares o modelos de ensamblaje para la clasificación y regresión de nodos. ## Flujo de trabajo para desarrollar y usar un modelo personalizado en Neptune ML El soporte de modelos personalizados en Neptune ML se ha diseñado para integrarse sin problemas en los flujos de trabajo existentes de Neptune ML. Funciona mediante la ejecución de código personalizado en el módulo de origen de la infraestructura de Neptune ML para entrenar el modelo. Al igual que en el caso de un modo integrado, Neptune ML lanza automáticamente un trabajo de HyperParameter ajuste de SageMaker IA y selecciona el mejor modelo de acuerdo con la métrica de evaluación. A continuación, utiliza la implementación proporcionada en el módulo de origen para generar artefactos de modelos para su implementación. La exportación de datos, la configuración de entrenamientos y el preprocesamiento de datos son los mismos para un modelo personalizado que para uno integrado. Una vez realizado el preprocesamiento de los datos, puede desarrollar y probar de forma iterativa e interactiva la implementación de su modelo personalizado mediante Python. Cuando el modelo esté listo para la producción, puede cargar el módulo de Python resultante en Amazon S3 de la siguiente manera: ``` aws s3 cp --recursive (source path to module) s3://(bucket name)/(destination path for your module) ``` A continuación, puede usar el flujo de trabajo de datos normal [predeterminado](machine-learning-overview.md#machine-learning-overview-starting-workflow) o [incremental](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) para implementar el modelo en producción, con algunas diferencias. Para el entrenamiento de modelos con un modelo personalizado, debe proporcionar un objeto `customModelTrainingParameters` de JSON a la API de entrenamiento de modelos de Neptune ML para garantizar que se utilice el código personalizado. Los campos del objeto `customModelTrainingParameters` son los siguientes: + **`sourceS3DirectoryPath`**: (*obligatorio*) la ruta a la ubicación de Amazon S3 donde se encuentra el módulo de Python que implementa el modelo. Debe apuntar a una ubicación válida de Amazon S3 existente que incluya, como mínimo, un script de entrenamiento, un script de transformación y un archivo `model-hpo-configuration.json`. + **`trainingEntryPointScript`**: (*opcional*) el nombre del punto de entrada en el módulo de un script que realiza el entrenamiento de modelos y utiliza los hiperparámetros como argumentos de la línea de comandos, incluidos los hiperparámetros fijos. *Valor predeterminado*: `training.py`. + **`transformEntryPointScript`**: (*opcional*) el nombre del punto de entrada en el módulo de un script que debe ejecutarse después de identificar el mejor modelo de la búsqueda de hiperparámetros, con el fin de calcular los artefactos de modelos necesarios para su implementación. Debería poder ejecutarse sin argumentos de línea de comandos. *Valor predeterminado*: `transform.py`. Por ejemplo: ``` 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)" } }' ``` Del mismo modo, para habilitar una transformación de modelo personalizada, debe proporcionar un objeto `customModelTransformParameters` de JSON a la API de transformación de Neptune ML, con valores de campo que sean compatibles con los parámetros del modelo guardados del trabajo de entrenamiento. El objeto `customModelTransformParameters` incluye estos campos: + **`sourceS3DirectoryPath`**: (*obligatorio*) la ruta a la ubicación de Amazon S3 donde se encuentra el módulo de Python que implementa el modelo. Debe apuntar a una ubicación válida de Amazon S3 existente que incluya, como mínimo, un script de entrenamiento, un script de transformación y un archivo `model-hpo-configuration.json`. + **`transformEntryPointScript`**: (*opcional*) el nombre del punto de entrada en el módulo de un script que debe ejecutarse después de identificar el mejor modelo de la búsqueda de hiperparámetros, con el fin de calcular los artefactos de modelos necesarios para su implementación. Debería poder ejecutarse sin argumentos de línea de comandos. *Valor predeterminado*: `transform.py`. Por ejemplo: ``` 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)" } }' ``` # Desarrollo de modelos personalizados en Neptune ML Una buena forma de iniciar el desarrollo de modelos personalizados es seguir los [ejemplos del kit de herramientas de Neptune ML](https://github.com/awslabs/neptuneml-toolkit/tree/main/examples/custom-models/introduction) para estructurar y escribir el módulo de entrenamiento. El kit de herramientas de Neptune ML también implementa componentes de modelos de ML de gráficos modularizados en el [modelzoo](https://github.com/awslabs/neptuneml-toolkit/tree/main/src/neptuneml_toolkit/modelzoo) que puede apilar y usar para crear un modelo personalizado. Además, el kit de herramientas proporciona funciones de utilidad que le ayudan a generar los artefactos necesarios durante el entrenamiento y la transformación de modelos. Puede importar este paquete de Python en la implementación personalizada. Todas las funciones o módulos incluidos en el kit de herramientas también están disponibles en el entorno de entrenamiento de Neptune ML. Si su módulo de Python tiene dependencias externas adicionales, puede incluirlas creando un `requirements.txt` archivo en el directorio del módulo. Los paquetes que figuran en el archivo `requirements.txt` se instalarán antes de ejecutar el script de entrenamiento. Como mínimo, el módulo de Python que implementa el modelo personalizado debe incluir lo siguiente: + Un punto de entrada de script de entrenamiento + Un punto de entrada de script de transformación + Un archivo `model-hpo-configuration.json` ## Desarrollo de scripts de entrenamiento de modelos personalizados en Neptune ML El script de entrenamiento del modelo personalizado debe ser un script de Python ejecutable, como el ejemplo [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) del kit de herramientas de Neptune ML. Debe aceptar nombres y valores de hiperparámetros como argumentos de línea de comandos. Durante el entrenamiento de modelos, los nombres de los hiperparámetros se obtienen del archivo `model-hpo-configuration.json`. Los valores de los hiperparámetros se encuentran dentro del rango de hiperparámetros válido si el hiperparámetro se puede ajustar, o toman el valor de hiperparámetro predeterminado si no se puede ajustar. El script de entrenamiento se ejecuta en una instancia de entrenamiento de SageMaker AI con una sintaxis como la siguiente: ``` python3 (script entry point) --(1st parameter) (1st value) --(2nd parameter) (2nd value) (...) ``` Para todas las tareas, Neptune ML AutoTrainer envía varios parámetros necesarios al script de entrenamiento, además de los hiperparámetros que especifique, y el script debe ser capaz de gestionar estos parámetros adicionales para que funcione correctamente. Estos parámetros adicionales obligatorios varían un poco según la tarea: **Para la clasificación o la regresión de nodos** + **`task`**: el tipo de tarea utilizado internamente por Neptune ML. Para la clasificación de nodos, es `node_class`, y para la regresión de nodos, es `node_regression`. + **`model`**: el nombre del modelo utilizado internamente por Neptune ML, que es `custom` en este caso. + **`name`**: el nombre de la tarea utilizada internamente por Neptune ML, que es `node_class-custom` para la clasificación de nodos, y `node_regression-custom` para la regresión de nodos. + **`target_ntype`**: el nombre del tipo de nodo para la clasificación o la regresión. + **`property`**: el nombre de la propiedad de nodo para la clasificación o la regresión. **Para la predicción de enlaces** + **`task`**: el tipo de tarea utilizado internamente por Neptune ML. Para la predicción de enlaces, es `link_predict`. + **`model`**: el nombre del modelo utilizado internamente por Neptune ML, que es `custom` en este caso. + **`name`**: el nombre de la tarea utilizada internamente por Neptune ML, que es `link_predict-custom` en este caso. **Para la clasificación o la regresión de bordes** + **`task`**: el tipo de tarea utilizado internamente por Neptune ML. Para la clasificación de bordes, es `edge_class`, y para la regresión de bordes, es `edge_regression`. + **`model`**: el nombre del modelo utilizado internamente por Neptune ML, que es `custom` en este caso. + **`name`**: el nombre de la tarea utilizada internamente por Neptune ML, que es `edge_class-custom` para la clasificación de bordes, y `edge_regression-custom` para la regresión de bordes. + **`target_etype`**: el nombre del tipo de borde para la clasificación o la regresión. + **`property`**: el nombre de la propiedad de borde para la clasificación o la regresión. El script debe guardar los parámetros del modelo, así como cualquier otro artefacto que sea necesario al final del entrenamiento. Puede utilizar las funciones de utilidad del kit de herramientas de Neptune ML para determinar la ubicación de los datos de gráficos procesados, la ubicación en la que deben guardarse los parámetros del modelo y qué dispositivos de GPU están disponibles en la instancia de entrenamiento. Consulte el ejemplo de script de entrenamiento [train.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/train.py) para ver ejemplos de cómo utilizar estas funciones de utilidad. ## Desarrollo de scripts de transformación de modelos personalizados en Neptune ML Se necesita un script de transformación para sacar partido del [flujo de trabajo incremental](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental) de Neptune ML para la inferencia de modelos en gráficos en constante evolución sin volver a entrenar el modelo. Aunque el script de entrenamiento genere todos los artefactos necesarios para la implementación del modelo, tendrá que proporcionar un script de transformación si quiere generar modelos actualizados sin volver a entrenar el modelo. **nota** Por el momento, los modelos personalizados no admiten la [inferencia inductiva en tiempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference). El script de transformación del modelo personalizado debe ser un script de Python ejecutable, como el script de ejemplo [transform.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) del kit de herramientas de Neptune ML. Dado que este script se invoca durante el entrenamiento de modelos sin argumentos de línea de comandos, todos los argumentos de línea de comandos que el script acepte deben tener valores predeterminados. El script se ejecuta en una instancia de entrenamiento de SageMaker AI con una sintaxis como la siguiente: ``` python3 (your transform script entry point) ``` El script de transformación necesitará varios datos, como, por ejemplo: + La ubicación de los datos de gráficos procesados. + La ubicación en la que se guardan los parámetros del modelo y en la que se deben guardar los nuevos artefactos del modelo. + Los dispositivos disponibles en la instancia. + Los hiperparámetros que generaron el mejor modelo. Estas entradas se obtienen mediante las funciones de utilidad de Neptune ML a las que puede llamar el script. Consulte el ejemplo de script [transform.py](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/transform.py) del kit de herramientas para ver ejemplos de cómo hacerlo. El script debe guardar las incrustaciones de nodos, los mapeados de identificador de nodo y cualquier otro artefacto necesario para la implementación del modelo de cada tarea. Consulte la [documentación de artefactos de modelos](machine-learning-model-artifacts.md) para obtener más información sobre los artefactos de modelos necesarios para las diferentes tareas de Neptune ML. ## Archivo `model-hpo-configuration.json` personalizado de Neptune ML El archivo `model-hpo-configuration.json` define los hiperparámetros para el modelo personalizado. Tiene el mismo [formato](machine-learning-customizing-hyperparams.md) que el archivo `model-hpo-configuration.json` utilizado con los modelos integrados de Neptune ML y tiene prioridad con respecto a la versión que Neptune ML genera automáticamente y se carga en la ubicación de los datos procesados. Al añadir un hiperparámetro nuevo al modelo, también debe añadir una entrada para el hiperparámetro en este archivo para que el hiperparámetro se transfiera al script de entrenamiento. Debe proporcionar un rango para un hiperparámetro si desea que sea ajustable y configurarlo como un parámetro `tier-1`, `tier-2` o `tier-3`. El hiperparámetro se ajustará si el número total de trabajos de entrenamiento configurados permite ajustar los hiperparámetros de su nivel. En el caso de un parámetro que no se pueda ajustar, debe proporcionar un valor predeterminado y añadir el hiperparámetro a la sección `fixed-param` del archivo. Consulte el [archivo `model-hpo-configuration.json` de ejemplo](https://github.com/awslabs/neptuneml-toolkit/blob/main/examples/custom-models/introduction/movie-lens-rgcn/node-class/src/model-hpo-configuration.json) del kit de herramientas para ver un ejemplo de cómo hacerlo. También debe proporcionar la definición de métrica que utilizará el trabajo de optimización de hiperparámetros de SageMaker AI para evaluar los modelos candidatos entrenados. Para ello, añada un objeto `eval_metric` de JSON al archivo `model-hpo-configuration.json` de la siguiente manera: ``` "eval_metric": { "tuning_objective": { "MetricName": "(metric_name)", "Type": "Maximize" }, "metric_definitions": [ { "Name": "(metric_name)", "Regex": "(metric regular expression)" } ] }, ``` La matriz `metric_definitions` del objeto `eval_metric` muestra los objetos de definición de métrica para cada métrica que desee que SageMaker AI extraiga de la instancia de entrenamiento. Cada objeto de definición de métrica tiene una clave `Name` que le permite proporcionar un nombre a la métrica (por ejemplo, “precisión”, “f1”, etc.). La clave `Regex` le permite proporcionar una cadena de expresión regular que coincide con la forma en que se imprime esa métrica en concreto en los registros de entrenamiento. Consulte la [página Ajuste de hiperparámetros de SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-define-metrics.html) para obtener más información sobre cómo definir las métricas. A continuación, el objeto `tuning_objective` de `eval_metric` le permite especificar las métricas de `metric_definitions` que deben utilizarse como métrica de evaluación que sirva como métrica objetivo para la optimización de hiperparámetros. El valor de `MetricName` debe coincidir con el valor de un `Name` en una de las definiciones de `metric_definitions`. El valor de `Type` debe ser “Maximizar” o “Minimizar”, en función de si la métrica debe interpretarse como mayor es mejor (por ejemplo, “precisión”) o menor es mejor (como “error cuadrático medio”). Los errores que se produzcan en esta sección del archivo `model-hpo-configuration.json` pueden provocar errores en el trabajo de la API de entrenamiento del modelo de Neptune ML, ya que el trabajo de ajuste de hiperparámetros de SageMaker AI no podrá seleccionar el mejor modelo. ## Pruebas locales de la implementación de un modelo personalizado en Neptune ML Puede utilizar el entorno de Conda del kit de herramientas de Neptune ML para ejecutar el código localmente con el fin de probar y validar el modelo. Si está desarrollando en una instancia de cuaderno de Neptune, este entorno estará preinstalado en la instancia de cuaderno de Neptune. Si está desarrollando en otra instancia, debe seguir las [instrucciones de configuración local](https://github.com/awslabs/neptuneml-toolkit#local-installation) del kit de herramientas de Neptune ML. El entorno de Conda reproduce con precisión el entorno en el que se ejecutará el modelo cuando llame a la [API de entrenamiento de modelos](machine-learning-api-modeltraining.md). Todos los ejemplos de scripts de entrenamiento y de transformación permiten utilizar un indicador `--local` de línea de comandos para ejecutar los scripts en un entorno local y facilitar su depuración. Esta práctica se recomienda cuando tenga que desarrollar su propio modelo, ya que le permite probar la implementación del modelo de forma interactiva e iterativa. Durante el entrenamiento de modelos en el entorno de entrenamiento de producción de Neptune ML, se omite este parámetro. # Creación de un punto de conexión de inferencia para consultar Un punto de conexión de inferencia le permite consultar un modelo específico que se creó durante el proceso de entrenamiento del modelo. El punto de conexión se relaciona con el modelo de mejor rendimiento de un tipo determinado que el proceso de entrenamiento fue capaz de generar. A continuación, el punto de conexión puede aceptar las consultas de Gremlin de Neptune y devolver las predicciones de ese modelo para las entradas de las consultas. Una vez creado el punto de conexión de inferencia, permanecerá activo hasta que lo elimine. ## Administración de puntos de conexión de inferencia para Neptune ML Una vez que haya completado el entrenamiento del modelo con los datos que ha exportado desde Neptune, puede crear un punto de conexión de inferencia mediante un comando `curl` (o `awscurl`) como el siguiente: ``` 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)" }' ``` También puede crear un punto de conexión de inferencia a partir de un modelo creado por un trabajo de transformación de modelo completado, prácticamente de la misma manera: ``` 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)" }' ``` Las instrucciones sobre cómo utilizar estos comandos se explican en [El comando endpoints](machine-learning-api-endpoints.md), junto con información sobre cómo obtener el estado de un punto de conexión, cómo eliminar un punto de conexión y cómo enumerar todos los puntos de conexión de inferencia. # Consultas de inferencia en Neptune ML Puede utilizar Gremlin o SPARQL para consular un punto de conexión de inferencia de Neptune ML. Sin embargo, la [inferencia inductiva en tiempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference) solo se admite actualmente para consultas de Gremlin. # Consultas de inferencia de Gremlin en Neptune ML Tal y como se describe en [Capacidades de Neptune ML](machine-learning.md#machine-learning-capabilities), Neptune ML admite modelos de entrenamiento que pueden realizar los siguientes tipos de tareas de inferencia: + **Clasificación de nodos**: predice la característica categórica de una propiedad de vértice. + **Regresión de nodos**: predice una propiedad numérica de un vértice. + **Clasificación de bordes**: predice la característica categórica de una propiedad de borde. + **Regresión de bordes**: predice una propiedad numérica de un borde. + **Predicción de enlaces**: predice los nodos de destino con un nodo de origen y un borde de salida, o los nodos de origen con un nodo de destino y un borde de entrada. Podemos ilustrar estas diferentes tareas con ejemplos que utilizan el [conjunto de datos de MovieLens 100 000](https://grouplens.org/datasets/movielens/100k/) proporcionado por [GroupLens Research](https://grouplens.org/datasets/movielens/). Este conjunto de datos consta de películas, usuarios y clasificaciones de las películas por parte de los usuarios, a partir de las cales, hemos creado un gráfico de propiedades como el siguiente: ![\[Ejemplo de gráfico de propiedades de una película utilizando el conjunto de datos de MovieLens 100.000\]](http://docs.aws.amazon.com/es_es/neptune/latest/userguide/images/movie_property_graph_example.png) **Clasificación de nodos**: en el conjunto de datos anterior, `Genre` es un tipo de vértice que está conectado al tipo de vértice `Movie` mediante el borde `included_in`. Sin embargo, si retocamos el conjunto de datos para que `Genre` sea una característica [categórica](https://en.wikipedia.org/wiki/Categorical_variable) para el tipo de vértice `Movie`, el problema de inferir `Genre` para las nuevas películas que se añadan a nuestro gráfico de conocimientos se puede resolver mediante modelos de clasificación de nodos. **Regresión de nodos**: si tenemos en cuenta el tipo de vértice `Rating`, que tiene propiedades como `timestamp` y `score`, el problema de inferir el valor numérico `Score` para una `Rating` se puede resolver mediante modelos de regresión de nodos. **Clasificación de aristas**: Del mismo modo, en el caso de una `Rated` arista, si tenemos una propiedad `Scale` que puede tener uno de los valores,,,`Love`,,`Like`,`Dislike`,`Neutral`,,`Hate`,, entonces el problema de inferir `Scale` la `Rated` arista si es nueva se movies/ratings puede resolver mediante modelos de clasificación de aristas. **Regresión de bordes**: del mismo modo, para el mismo borde `Rated`, si tenemos una propiedad `Score` que incluye un valor numérico para la clasificación, esto se puede inferir de los modelos de regresión de bordes. **Predicción de enlaces**: problemas, como encontrar los diez principales usuarios que tienen más probabilidades de puntuar una determinada película o encontrar las diez principales películas que un determinado usuario tiene más probabilidades de valorar, se consideran parte de la predicción de enlaces. **nota** Para los casos de uso de Neptune ML, tenemos un conjunto muy completo de cuadernos diseñados para proporcionarle una comprensión práctica de cada caso de uso. Puede crear estos cuadernos junto con su clúster de Neptuno cuando utilice la plantilla [Neptune CloudFormation ML para crear un clúster de Neptune ML](machine-learning-quick-start.md). Estos cuadernos también están disponibles en [github](https://github.com/aws/graph-notebook/tree/main/src/graph_notebook/notebooks/04-Machine-Learning). **Topics** + [Predicados de Neptune ML utilizados en las consultas de inferencia de Gremlin](machine-learning-gremlin-inference-query-predicates.md) + [Consultas de clasificación de nodos de Gremlin en Neptune ML](machine-learning-gremlin-vertex-classification-queries.md) + [Consultas de regresión de nodos de Gremlin en Neptune ML](machine-learning-gremlin-vertex-regression-queries.md) + [Consultas de clasificación de bordes de Gremlin en Neptune ML](machine-learning-gremlin-edge-classification-queries.md) + [Consultas de regresión de bordes de Gremlin en Neptune ML](machine-learning-gremlin-edge-regression.md) + [Consultas de predicción de enlaces de Gremlin mediante modelos de predicción de enlaces en Neptune ML](machine-learning-gremlin-link-prediction-queries.md) + [Lista de excepciones para las consultas de inferencia de Gremlin en Neptune ML](machine-learning-gremlin-exceptions.md) # Predicados de Neptune ML utilizados en las consultas de inferencia de Gremlin ## `Neptune#ml.deterministic` Este predicado es una opción para las consultas de inferencia inductiva, es decir, para las consultas que incluyen el predicado [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference). Cuando se utiliza la inferencia inductiva, el motor de Neptune crea el subgráfico adecuado para evaluar el modelo GNN entrenado, y los requisitos de este subgráfico dependen de los parámetros del modelo final. En concreto, el parámetro `num-layer` determina el número de saltos de recorridos desde los nodos o bordes de destino, y el parámetro `fanouts` especifica el número de vecinos que hay que muestrear en cada salto (consulte [Parámetros de HPO](machine-learning-customizing-hyperparams.md)). De forma predeterminada, las consultas de inferencia inductiva se ejecutan en modo no determinista, en el que Neptune crea la vecindad de forma aleatoria. Al realizar predicciones, este muestreo normal de vecinos aleatorios a veces da como resultado predicciones diferentes. Cuando se incluye `Neptune#ml.deterministic` en una consulta de inferencia inductiva, el motor de Neptune intenta muestrear los vecinos de forma determinista para que las diversas invocaciones de la misma consulta devuelvan siempre los mismos resultados. Sin embargo, no se puede garantizar que los resultados sean completamente deterministas, ya que los cambios en el gráfico subyacente y los artefactos de los sistemas distribuidos aún pueden provocar fluctuaciones. El predicado `Neptune#ml.deterministic` se incluye en una consulta de la siguiente manera: ``` .with("Neptune#ml.deterministic") ``` Si el predicado `Neptune#ml.deterministic` se incluye en una consulta que no incluye también `Neptune#ml.inductiveInference`, simplemente se ignora. ## `Neptune#ml.disableInductiveInferenceMetadataCache` Este predicado es una opción para las consultas de inferencia inductiva, es decir, para las consultas que incluyen el predicado [`Neptune#ml.inductiveInference`](#machine-learning-gremlin-inference-neptune-ml-inductiveInference). Para las consultas de inferencia inductiva, Neptune utiliza un archivo de metadatos almacenado en Amazon S3 para decidir el número de saltos y la distribución ramificada al crear el vecindario. Neptune normalmente almacena en caché los metadatos de este modelo para evitar tener que recuperar una y otra vez el archivo de Amazon S3. El almacenamiento en caché se puede deshabilitar si se incluye el predicado `Neptune#ml.disableInductiveInferenceMetadataCache` en la consulta. Si bien Neptune puede tardar más en obtener los metadatos directamente de Amazon S3, resulta útil cuando el punto final de la SageMaker IA se ha actualizado tras volver a entrenarse o transformarse y la caché está obsoleta. El predicado `Neptune#ml.disableInductiveInferenceMetadataCache` se incluye en una consulta de la siguiente manera: ``` .with("Neptune#ml.disableInductiveInferenceMetadataCache") ``` A continuación, se muestra cómo podría ser una consulta en un cuaderno de 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` El predicado `Neptune#ml.endpoint` se utiliza en un paso `with()` para especificar el punto de conexión de inferencia, si es necesario: ``` .with("Neptune#ml.endpoint", "the model's SageMaker AI inference endpoint") ``` Puede identificar el punto de conexión tanto por su `id` o como por su URL. Por ejemplo: ``` .with( "Neptune#ml.endpoint", "node-classification-movie-lens-endpoint" ) ``` O bien: ``` .with( "Neptune#ml.endpoint", "https://runtime.sagemaker.us-east-1.amazonaws.com/endpoints/node-classification-movie-lens-endpoint/invocations" ) ``` **nota** Si [establece el parámetro `neptune_ml_endpoint`](machine-learning-cluster-setup.md#machine-learning-set-inference-endpoint-cluster-parameter) en el grupo de parámetros del clúster de base de datos de Neptune en el `id` o la URL del punto de conexión, no necesita incluir el predicado `Neptune#ml.endpoint` en cada consulta. ## `Neptune#ml.iamRoleArn` `Neptune#ml.iamRoleArn`se utiliza en un `with()` paso para especificar el ARN de la función de IAM de ejecución de SageMaker IA, si es necesario: ``` .with("Neptune#ml.iamRoleArn", "the ARN for the SageMaker AI execution IAM role") ``` Para obtener información sobre cómo crear la función de IAM de ejecución de SageMaker IA, consulte. [Cree un rol personalizado NeptuneSageMaker IAMRole](machine-learning-manual-setup.md#ml-manual-setup-sm-role) **nota** Si [establece el `neptune_ml_iam_role` parámetro en el](machine-learning-cluster-setup.md#machine-learning-enabling-create-param-group) grupo de parámetros del clúster de base de datos de Neptune en el ARN de su función de IAM de ejecución de SageMaker IA, no necesita incluir el `Neptune#ml.iamRoleArn` predicado en cada consulta. ## Neptune\$1ml.inductiveInference La inferencia transductiva está habilitada de forma predeterminada en Gremlin. Para realizar una consulta de [inferencia inductiva en tiempo real](machine-learning-overview-evolving-data.md#inductive-vs-transductive-inference), incluya el predicado `Neptune#ml.inductiveInference` de la siguiente manera: ``` .with("Neptune#ml.inductiveInference") ``` Si el gráfico es dinámico, la inferencia inductiva suele ser la mejor opción, pero si el gráfico es estático, la inferencia transductiva es más rápida y eficaz. ## `Neptune#ml.limit` El predicado `Neptune#ml.limit` es opcional y limita el número de resultados devueltos por la entidad: ``` .with( "Neptune#ml.limit", 2 ) ``` De forma predeterminada, el límite es 1 y el número máximo que se puede establecer es 100. ## `Neptune#ml.threshold` El predicado `Neptune#ml.threshold` establece de forma opcional un umbral límite para las puntuaciones de los resultados: ``` .with( "Neptune#ml.threshold", 0.5D ) ``` Esto le permite descartar todos los resultados con puntuaciones por debajo del umbral especificado. ## `Neptune#ml.classification` El `Neptune#ml.classification` predicado se adjunta al `properties()` paso para establecer que las propiedades deben obtenerse del punto final de SageMaker IA del modelo de clasificación de nodos: ``` .properties( "property key of the node classification model" ).with( "Neptune#ml.classification" ) ``` ## `Neptune#ml.regression` El `Neptune#ml.regression` predicado se adjunta al `properties()` paso para establecer que las propiedades deben obtenerse del punto final de la SageMaker IA del modelo de regresión de nodos: ``` .properties( "property key of the node regression model" ).with( "Neptune#ml.regression" ) ``` ## `Neptune#ml.prediction` El predicado `Neptune#ml.prediction` se adjunta a los pasos `in()` y `out()` pasos para establecer que se trata de una consulta de predicción de enlaces: ``` .in("edge label of the link prediction model").with("Neptune#ml.prediction").hasLabel("target node label") ``` ## `Neptune#ml.score` El predicado `Neptune#ml.score` se utiliza en las consultas de clasificación de nodos o bordes de Gremlin para obtener una puntuación de confianza en el machine learning. El predicado `Neptune#ml.score` debe pasarse junto con el predicado de la consulta en el paso `properties()` para obtener una puntuación de confianza en el ML para las consultas de clasificación de nodos o bordes. Puede encontrar un ejemplo de clasificación de nodos con [otros ejemplos de clasificación de nodos](machine-learning-gremlin-vertex-classification-queries.md#machine-learning-gremlin-node-class-other-queries) y un ejemplo de clasificación de bordes en la [sección Clasificación de bordes](machine-learning-gremlin-edge-classification-queries.md). # Consultas de clasificación de nodos de Gremlin en Neptune ML Para la clasificación de nodos de Gremlin en Neptune ML: + El modelo se entrena en una propiedad de los vértices. El conjunto de valores únicos de esta propiedad se denomina conjunto de clases de nodos o, simplemente, clases. + La clase de nodo o el valor de la propiedad categórica de la propiedad de un vértice se pueden inferir del modelo de clasificación de nodos. Esto es útil cuando esta propiedad aún no está asociada al vértice. + Para obtener una o varias clases de un modelo de clasificación de nodos, debe usar el paso `with()` con el predicado `Neptune#ml.classification` para configurar el paso `properties()`. El formato de salida es similar al que cabría esperar si se trataran de propiedades de vértices. **nota** La clasificación de nodos solo funciona con valores de propiedades de cadena. Esto significa que no se admiten valores de propiedades numéricas como `0` o `1`, aunque sí se admiten los equivalentes de cadena `"0"` y `"1"`. Del mismo modo, los valores de la propiedad Boolean `true` y `false` no funcionan, pero sí lo hacen `"true"` y `"false"`. Este es un ejemplo de una consulta de clasificación de nodos: ``` 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 salida de esta consulta sería similar a la siguiente: ``` ==>vp[genre->Action] ==>vp[genre->Crime] ==>vp[genre->Comedy] ``` En la consulta anterior, los pasos `V()` y `properties()` se utilizan de la siguiente manera: El paso `V()` incluye el conjunto de vértices para el que desea obtener las clases del modelo de clasificación de nodos: ``` .V( "movie_1", "movie_2", "movie_3" ) ``` El paso `properties()` incluye la clave en la que se entrenó el modelo, así como el valor `.with("Neptune#ml.classification")` para indicar que se trata de una consulta de inferencia de ML de clasificación de nodos. Por el momento, no se admiten varias claves de propiedad en un paso `properties().with("Neptune#ml.classification")`. Por ejemplo, la siguiente consulta da lugar a una excepción: ``` 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") ``` Para obtener información sobre el mensaje de error específico, consulte la [lista de excepciones de Neptune ML](machine-learning-gremlin-exceptions.md). Se puede usar un paso `properties().with("Neptune#ml.classification")` en combinación con cualquiera de los pasos siguientes: + `value()` + `value().is()` + `hasValue()` + `has(value,"")` + `key()` + `key().is()` + `hasKey()` + `has(key,"")` + `path()` ## Otras consultas de clasificación de nodos Si tanto el punto de conexión de inferencia como el correspondiente rol de IAM se han guardado en el grupo de parámetros del clúster de base de datos, una consulta de clasificación de nodos puede ser tan sencilla como esta: ``` g.V("movie_1", "movie_2", "movie_3").properties("genre").with("Neptune#ml.classification") ``` Puede combinar las propiedades y las clases de los vértices en una consulta mediante el paso `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") ) ``` También puede realizar una consulta ilimitada como la siguiente: ``` 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") ``` Puede recuperar las clases de nodos junto con los vértices mediante el paso `select()` junto con el paso `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") ``` También puede filtrar por clases de nodos, tal y como se muestra en estos ejemplos: ``` 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")) ``` Puede obtener una puntuación de confianza en la clasificación de nodos mediante el predicado `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 respuesta sería similar a: ``` ==>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] ``` ## Uso de la inferencia inductiva en una consulta de clasificación de nodos Supongamos que tuviera que añadir un nuevo nodo a un gráfico existente, en un cuaderno de Jupyter, de la siguiente manera: ``` %%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') ``` A continuación, podría usar una consulta de inferencia inductiva para obtener un género y una puntuación de confianza que reflejaran el nuevo nodo: ``` %%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") ``` Sin embargo, si ejecutara la consulta varias veces, es posible que obtuviera resultados algo diferentes: ``` # First time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.21365921] ``` Podría hacer que la misma consulta fuera determinista: ``` %%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") ``` En ese caso, los resultados serían aproximadamente los mismos cada vez: ``` # First time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[genre->Action] ==>vp[Neptune#ml.score->0.12345678] ``` # Consultas de regresión de nodos de Gremlin en Neptune ML La regresión de nodos es similar a la clasificación de nodos, excepto el valor inferido del modelo de regresión para cada nodo que es numérico. Puede utilizar las mismas consultas de Gremlin para la regresión de nodos que para la clasificación de nodos, excepto por las siguientes diferencias: + De nuevo, en Neptune ML, los nodos hacen referencia a vértices. + El paso `properties()` adopta el formato `properties().with("Neptune#ml.regression")` en lugar de `properties().with("Neptune#ml.classification")`. + Los predicados `"Neptune#ml.limit` y `"Neptune#ml.threshold"` no son aplicables. + Al filtrar el valor, debe especificar un valor numérico. Este es un ejemplo de una consulta de clasificación de vértices: ``` 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") ``` Puede filtrar el valor inferido mediante un modelo de regresión, tal y como se muestra en los siguientes ejemplos: ``` 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)) ``` ## Uso de la inferencia inductiva en una consulta de regresión de nodos Supongamos que tuviera que añadir un nuevo nodo a un gráfico existente, en un cuaderno de Jupyter, de la siguiente manera: ``` %%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') ``` A continuación, podría usar una consulta de inferencia inductiva para obtener una calificación que tuviera en cuenta el nuevo nodo: ``` %%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") ``` Dado que la consulta no es determinista, es posible que arrojara resultados algo diferentes si la ejecutara varias veces, en función de la vecindad: ``` # First time ==>vp[rating->9.1] # Second time ==>vp[rating->8.9] ``` Si necesitara resultados más coherentes, podría hacer que la consulta fuera determinista: ``` %%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") ``` Ahora los resultados serán aproximadamente los mismos cada vez: ``` # First time ==>vp[rating->9.1] # Second time ==>vp[rating->9.1] ``` # Consultas de clasificación de bordes de Gremlin en Neptune ML Para la clasificación de bordes de Gremlin en Neptune ML: + El modelo se entrena en una propiedad de los bordes. El conjunto de valores únicos de esta propiedad se denomina conjunto de clases. + El valor de clase o propiedad categórica de un borde se puede inferir del modelo de clasificación de bordes, lo que resulta útil cuando esta propiedad aún no está asociada al borde. + Para obtener una o varias clases de un modelo de clasificación de bordes, debe usar el paso `with()` con el predicado `"Neptune#ml.classification"` para configurar el paso `properties()`. El formato de salida es similar al que cabría esperar si se trataran de propiedades de bordes. **nota** La clasificación de bordes solo funciona con valores de propiedades de cadena. Esto significa que no se admiten valores de propiedades numéricas como `0` o `1`, aunque sí se admiten los equivalentes de cadena `"0"` y `"1"`. Del mismo modo, los valores de la propiedad Boolean `true` y `false` no funcionan, pero sí lo hacen `"true"` y `"false"`. A continuación, se muestra un ejemplo de una consulta de clasificación de bordes que solicita una puntuación de confianza mediante el predicado `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 respuesta sería similar a: ``` ==>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] ``` ## Sintaxis de una consulta de clasificación de bordes de Gremlin En el caso de un gráfico sencillo en el que `User` es el nodo principal y final y `Relationship` es el borde que los conecta: un ejemplo de consulta de clasificación de bordes es: ``` 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 salida de esta consulta sería similar a la siguiente: ``` ==>p[knows_by->"Family"] ==>p[knows_by->"Friends"] ==>p[knows_by->"Colleagues"] ``` En la consulta anterior, los pasos `E()` y `properties()` se utilizan de la siguiente manera: + El paso `E()` incluye el conjunto de bordes para el que desea obtener las clases del modelo de clasificación de bordes: ``` .E("relationship_1","relationship_2","relationship_3") ``` + El paso `properties()` incluye la clave en la que se entrenó el modelo, así como el valor `.with("Neptune#ml.classification")` para indicar que se trata de una consulta de inferencia de ML de clasificación de bordes. Por el momento, no se admiten varias claves de propiedad en un paso `properties().with("Neptune#ml.classification")`. Por ejemplo, la siguiente consulta da lugar a una excepción: ``` 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") ``` Para ver mensajes de error específicos, consulte [Lista de excepciones para las consultas de inferencia de Gremlin en Neptune ML](machine-learning-gremlin-exceptions.md). Se puede usar un paso `properties().with("Neptune#ml.classification")` en combinación con cualquiera de los pasos siguientes: + `value()` + `value().is()` + `hasValue()` + `has(value,"")` + `key()` + `key().is()` + `hasKey()` + `has(key,"")` + `path()` ## Uso de la inferencia inductiva en una consulta de clasificación de bordes Supongamos que tuviera que añadir un nuevo borde a un gráfico existente, en un cuaderno de Jupyter, de la siguiente manera: ``` %%gremlin g.V('1').as('fromV') .V('2').as('toV') .addE('eLabel1').from('fromV').to('toV').property(id, 'e101') ``` A continuación, podría usar una consulta de inferencia inductiva para obtener una escala que tuviera en cuenta el nuevo borde: ``` %%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") ``` Dado que la consulta no es determinista, los resultados variarían algo si se ejecutara varias veces, en función de la vecindad aleatoria: ``` # First time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.21365921] ``` Si necesitara resultados más coherentes, podría hacer que la consulta fuera determinista: ``` %%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") ``` Ahora los resultados serán más o menos los mismos cada vez que ejecute la consulta: ``` # First time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.12345678] # Second time ==>vp[scale->Like] ==>vp[Neptune#ml.score->0.12345678] ``` # Consultas de regresión de bordes de Gremlin en Neptune ML La regresión de bordes es similar a la clasificación de bordes, excepto el valor inferido del modelo de ML que es numérico. En el caso de la regresión de bordes, Neptune ML admite las mismas consultas que para la clasificación. Los puntos clave a tener en cuenta son: + Debe usar el predicado `"Neptune#ml.regression"` de ML para configurar el paso `properties()` para este caso de uso. + Los predicados `"Neptune#ml.limit"` y `"Neptune#ml.threshold"` no son aplicables en este caso de uso. + Para filtrar el valor, debe especificarlo como numérico. ## Sintaxis de una consulta de regresión de bordes de Gremlin En el caso de un gráfico sencillo en el que `User` es el nodo principal, `Movie` es el nodo final y `Rated` es el borde que los conecta: a continuación se muestra un ejemplo de consulta de regresión de bordes que encuentra el valor de clasificación numérica, denominado puntuación, para el borde `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") ``` También puede filtrar un valor inferido del modelo de regresión de ML. En el caso de los bordes `Rated` existentes (de `User` a `Movie`) identificadas por `"rating_1"`, `"rating_2"` y `"rating_3"`, donde la propiedad de borde `Score` esté presente para estas clasificaciones, puede utilizar una consulta como la siguiente para inferir `Score` para los bordes en los que es mayor o igual a 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)) ``` ## Uso de la inferencia inductiva en una consulta de regresión de bordes Supongamos que tuviera que añadir un nuevo borde a un gráfico existente, en un cuaderno de Jupyter, de la siguiente manera: ``` %%gremlin g.V('1').as('fromV') .V('2').as('toV') .addE('eLabel1').from('fromV').to('toV').property(id, 'e101') ``` A continuación, podría usar una consulta de inferencia inductiva para obtener una puntuación que tuviera en cuenta el nuevo borde: ``` %%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") ``` Dado que la consulta no es determinista, los resultados variarían algo si se ejecutara varias veces, en función de la vecindad aleatoria: ``` # First time ==>ep[score->96] # Second time ==>ep[score->91] ``` Si necesitara resultados más coherentes, podría hacer que la consulta fuera determinista: ``` %%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") ``` Ahora los resultados serán más o menos los mismos cada vez que ejecute la consulta: ``` # First time ==>ep[score->96] # Second time ==>ep[score->96] ``` # Consultas de predicción de enlaces de Gremlin mediante modelos de predicción de enlaces en Neptune ML Los modelos de predicción de enlaces pueden resolver problemas como los siguientes: + **Predicción del nodo principal**: con un vértice y un tipo de borde, ¿desde qué vértices es probable que se enlace este vértice? + **Predicción del nodo final**: con un vértice y un tipo de borde, ¿desde qué vértices es probable que se enlace este vértice? **nota** Aún no se admite la predicción de bordes en Neptune ML. Para los ejemplos siguientes, supongamos que tenemos un gráfico sencillo con los vértices `User` y `Movie` que estén vinculados por el borde `Rated`. Este es un ejemplo de consulta de predicción del nodo principal, que se utiliza para predecir cuáles son los cinco principales usuarios que tienen más probabilidades de valorar las películas `"movie_1"`, `"movie_2"` y `"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") ``` Esta es una similar para la predicción del nodo final, que se utiliza para predecir cuáles son las cinco principales películas que el usuario `"user_1"` tiene más probabilidades de valorar: ``` 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") ``` Se necesitan tanto la etiqueta de borde como la de vértice previsto. Si se omite alguna de ellas, se produce una excepción. Por ejemplo, la siguiente consulta sin una etiqueta de vértice previsto produce una excepción: ``` 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") ``` Del mismo modo, la siguiente consulta sin una etiqueta de borde genera una excepción: ``` 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") ``` Para obtener información sobre los mensajes de error específicos que generan estas excepciones, consulte la [lista de excepciones de Neptune ML](machine-learning-gremlin-exceptions.md). ## Otras consultas de predicción de enlaces Puede usar el paso `select()` con el paso `as(` para generar los vértices previstos junto con los vértices de entrada: ``` 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") ``` Puede realizar consultas ilimitadas, como, por ejemplo: ``` 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") ``` ## Uso de la inferencia inductiva en una consulta de predicción de enlaces Supongamos que tuviera que añadir un nuevo nodo a un gráfico existente, en un cuaderno de Jupyter, de la siguiente manera: ``` %%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') ``` A continuación, podría usar una consulta de inferencia inductiva para predecir el nodo principal, teniendo en cuenta el nuevo nodo: ``` %%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") ``` Resultado: ``` ==>V[2] ``` Asimismo, podría usar una consulta de inferencia inductiva para predecir el nodo final, teniendo en cuenta el nuevo nodo: ``` %%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") ``` Resultado: ``` ==>V[1] ``` # Lista de excepciones para las consultas de inferencia de Gremlin en Neptune ML Esta es una lista completa de las excepciones que pueden producirse al ejecutar consultas de inferencia de Gremlin en Neptune ML. Estas excepciones abarcan una serie de problemas, desde los relacionados con el rol de IAM o punto de conexión especificado hasta los pasos de Gremlin no compatibles y las limitaciones en el número de consultas de inferencia de ML por consulta. Cada entrada incluye un mensaje detallado que describe el problema. + **`BadRequestException`**: no se pueden cargar las credenciales del rol proporcionado. *Mensaje*: `Unable to load credentials for role: the specified IAM Role ARN.` + **`BadRequestException`**— La función de IAM especificada no está autorizada a invocar el punto final de la IA. SageMaker *Mensaje*: `User: the specified IAM Role ARN is not authorized to perform: sagemaker:InvokeEndpoint on resource: the specified endpoint.` + **`BadRequestException`**: el punto de conexión especificado no existe. *Mensaje*: `Endpoint the specified endpoint not found.` + **`InternalFailureException`**: no se pueden obtener los metadatos de inferencia inductiva en tiempo real de Neptune ML desde Amazon S3. *Mensaje*: `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 no puede encontrar el archivo de metadatos de inferencia inductiva en tiempo real en Amazon S3. *Mensaje*: `Neptune ML cannot find the metadata file for Real-Time Inductive Inference in S3.` + **`InvalidParameterException`**: el punto de conexión especificado no es válido desde el punto de vista sintáctico. *Mensaje*: `Invalid endpoint provided for external service query.` + **`InvalidParameterException`**— El ARN del rol de IAM de SageMaker ejecución especificado no es válido sintácticamente. *Mensaje*: `Invalid IAM role ARN provided for external service query.` + **`InvalidParameterException`**: se especifican varias claves de propiedad en el paso `properties()` de una consulta. *Mensaje*: `ML inference queries are currently supported for one property key.` + **`InvalidParameterException`**: se especifican varias etiquetas de borde en una consulta. *Mensaje*: `ML inference are currently supported only with one edge label.` + **`InvalidParameterException`**: se especifican varias restricciones de etiquetas de vértices en una consulta. *Mensaje*: `ML inference are currently supported only with one vertex label constraint.` + **`InvalidParameterException`**: los predicados `Neptune#ml.classification` y `Neptune#ml.regression` están presentes en la misma consulta. *Mensaje*: `Both regression and classification ML predicates cannot be specified in the query.` + **`InvalidParameterException`**: se ha especificado más de una etiqueta de borde en los pasos `in()` o `out()` de una consulta de predicción de enlaces. *Mensaje*: `ML inference are currently supported only with one edge label.` + **`InvalidParameterException`**: se ha especificado más de una clave de propiedad con Neptune\$1ml.score. *Mensaje*: `Neptune ML inference queries are currently supported for one property key and one Neptune#ml.score property key.` + **`MissingParameterException`**: no se ha especificado el punto de conexión en la consulta ni como parámetro de clúster de base de datos. *Mensaje*: `No endpoint provided for external service query.` + **``MissingParameterException**— La función de IAM de ejecución de SageMaker IA no se especificó en la consulta ni como parámetro del clúster de base de datos. *Mensaje*: `No IAM role ARN provided for external service query.` + **`MissingParameterException`**: falta la clave de propiedad en el paso `properties()` de una consulta. *Mensaje*: `Property key needs to be specified using properties() step for ML inference queries.` + **`MissingParameterException`**: no se ha especificado ninguna etiqueta de borde en los pasos `in()` o `out()` de una consulta de predicción de enlaces. *Mensaje*: `Edge label needs to be specified while using in() or out() step for ML inference queries.` + **`MissingParameterException`**: no se ha especificado ninguna clave de propiedad con Neptune\$1ml.score. *Mensaje*: `Property key needs to be specified along with Neptune#ml.score property key while using the properties() step for Neptune ML inference queries.` + **`UnsupportedOperationException`**: el paso `both()` se utiliza en una consulta de predicción de enlaces. *Mensaje*: `ML inference queries are currently not supported with both() step.` + **`UnsupportedOperationException`**: no se ha especificado ninguna etiqueta de vértice prevista en el paso `has()` con los pasos `in()` o `out()` en una consulta de predicción de enlaces. *Mensaje*: `Predicted vertex label needs to be specified using has() step for ML inference queries.` + **`UnsupportedOperationException`**: las consultas de inferencia inductiva de ML de Gremlin no son compatibles actualmente con pasos no optimizados. *Mensaje*: `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`**: las consultas de inferencia de Neptune ML no son compatibles actualmente en un paso `repeat`. *Mensaje*: `Neptune ML inference queries are currently not supported inside a repeat step.` + **`UnsupportedOperationException`**: no se admite más de una consulta de inferencia de Neptune ML por consulta de Gremlin. *Mensaje*: `Neptune ML inference queries are currently supported only with one ML inference query per gremlin query.` # Consultas de inferencia de SPARQL en Neptune ML Neptune ML mapea el gráfico de RDF en un gráfico de propiedades para modelar la tarea de ML. Por el momento, admite los siguientes casos de uso: + **Clasificación de objetos**: predice la característica categórica de un objeto. + **Regresión de objetos**: predice una propiedad numérica de un objeto. + **Predicción de objetos**: predice un objeto a partir de un sujeto y una relación. + **Predicción de sujetos**: predice un sujeto a partir de un objeto y una relación. **nota** Neptune ML no admite casos de uso de clasificación y regresión de sujetos con SPARQL. # Predicados de Neptune ML utilizados en las consultas de inferencia de SPARQL Los siguientes predicados se utilizan con la inferencia de SPARQL: ## Predicado `neptune-ml:timeout` Especifica el tiempo de espera de la conexión con el servidor remoto. No debe confundirse con el tiempo de espera de la solicitud de consulta, que es el tiempo máximo que el servidor puede tardar en satisfacer una solicitud. Tenga en cuenta que si el tiempo de espera de la consulta se produce antes de que se agote el tiempo de espera del servicio especificado por el predicado `neptune-ml:timeout`, la conexión del servicio también se cancelará. ## Predicado `neptune-ml:outputClass` El predicado `neptune-ml:outputClass` solo se usa para definir la clase del objeto previsto para la predicción del objeto o del sujeto previsto para la predicción del sujeto. ## Predicado `neptune-ml:outputScore` El predicado `neptune-ml:outputScore` es un número positivo que representa la probabilidad de que el resultado de un modelo de machine learning sea correcto. ## Predicado `neptune-ml:modelType` El predicado `neptune-ml:modelType` especifica el tipo de modelo de machine learning que se está entrenando: + `OBJECT_CLASSIFICATION` + `OBJECT_REGRESSION` + `OBJECT_PREDICTION` + `SUBJECT_PREDICTION` ## Predicado `neptune-ml:input` El predicado `neptune-ml:input` hace referencia a la lista de URI que se utilizan como entradas para Neptune ML. ## Predicado `neptune-ml:output` El predicado `neptune-ml:output` hace referencia a la lista de conjuntos de enlaces en los que Neptune ML devuelve resultados. ## Predicado `neptune-ml:predicate` El predicado `neptune-ml:predicate` se usa de manera diferente en función de la tarea que se esté realizando: + Para la **predicción de un objeto o un sujeto**: define el tipo de predicado (el tipo de borde o relación). + Para la **clasificación y regresión de objetos**: define el valor literal (propiedad) que queremos predecir. ## Predicado `neptune-ml:batchSize` `neptune-ml:batchSize` especifica el tamaño de entrada para la llamada de servicio remoto. # Ejemplos de clasificación de objetos de SPARQL Para la clasificación de objetos de SPARQL en Neptune ML, el modelo se entrena en uno de los valores de los predicados. Esto es útil cuando ese predicado aún no está presente en un determinado sujeto. Solo se pueden inferir valores de predicados categóricos con el modelo de clasificación de objetos. La siguiente consulta busca predecir el valor del predicado para todas las entradas del tipo `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 . } } ``` Esta consulta se puede personalizar de la siguiente manera: ``` 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 . } } ``` # Ejemplos de regresión de objetos de SPARQL La regresión de objetos es similar a la clasificación de nodos, excepto el valor de predicado numérico inferido del modelo de regresión de cada nodo. Puede utilizar las mismas consultas de SPARQL para la regresión de objetos que para la clasificación de objetos, con la excepción de que los predicados `the Neptune#ml.limit` y `Neptune#ml.threshold` no son aplicables. La siguiente consulta busca predecir el valor del predicado para todas las entradas del tipo `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 . } } ``` Esta consulta se puede personalizar de la siguiente manera: ``` 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 . } } ``` # Ejemplo de predicción de objetos de SPARQL La *predicción de objetos* predice el valor del objeto para un sujeto y un predicado determinados. La siguiente consulta de predicción de objetos busca predecir qué película le gustaría a la entrada del tipo `foaf:Person`: ``` ?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 consulta en sí misma se puede personalizar de la siguiente manera: ``` 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 . } } ``` # Ejemplo de predicción de sujetos de SPARQL La *predicción de sujetos* predice el valor del sujetos para un objeto y un predicado determinados. Por ejemplo, la siguiente consulta predice quién (del tipo `foaf:User`) verá una película determinada: ``` 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 ; } } ``` # Lista de excepciones para las consultas de inferencia de SPARQL en Neptune ML **** + **`BadRequestException`**: *Mensaje*: `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`**: *Mensaje*: `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`**: *Mensaje*: `Invalid predicate (predicate name) provided for external service http://aws.amazon.com/neptune/vocab/v01/services/ml#inference query.` + **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the predicate (predicate name) to be defined`. + **`BadRequestException`**: *Mensaje*: `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`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference expects the input (parameter name) to be a constant, found: (type)`. + **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference is expected to return only 1 value`. + **`BadRequestException`**: *Mensaje*: `"The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference only allows StatementPatternNodes`. + **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference does not allow the predicate (predicate name)`. + **`BadRequestException`**: *Mensaje*: `The SERVICE http://aws.amazon.com/neptune/vocab/v01/services/ml#inference predicates cannot be variables, found: (type)`. + **`BadRequestException`**: *Mensaje*: `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)`. # Referencia de la API de administración de Neptune ML **Contents** + [El comando de procesamiento de datos](machine-learning-api-dataprocessing.md) + [Creación de un trabajo de procesamiento de datos](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-create-job) + [Obtención del estado del trabajo](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-get-job-status) + [Detención de un trabajo](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-stop-job) + [Mostrar trabajos](machine-learning-api-dataprocessing.md#machine-learning-api-dataprocessing-list-jobs) + [El comando modeltraining](machine-learning-api-modeltraining.md) + [Creación de un trabajo de entrenamiento de modelos](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) + [Obtención del estado del trabajo](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-get-job-status) + [Detención de un trabajo](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-stop-job) + [Mostrar trabajos](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-list-jobs) + [El comando modeltransform](machine-learning-api-modeltransform.md) + [Creación de un trabajo de transformación de modelos](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-create-job) + [Obtención del estado del trabajo](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-get-job-status) + [Detención de un trabajo](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-stop-job) + [Mostrar trabajos](machine-learning-api-modeltransform.md#machine-learning-api-modeltransform-list-jobs) + [El comando endpoints](machine-learning-api-endpoints.md) + [Creación de un punto de conexión de inferencia](machine-learning-api-endpoints.md#machine-learning-api-endpoints-create-job) + [Obtención del estado de punto de conexión](machine-learning-api-endpoints.md#machine-learning-api-endpoints-get-endpoint-status) + [Eliminación de un punto de conexión](machine-learning-api-endpoints.md#machine-learning-api-endpoints-delete-endpoint) + [Enumeración de puntos de conexión de inferencia](machine-learning-api-endpoints.md#machine-learning-api-endpoints-list-endpoints) + [Excepciones](machine-learning-api-exceptions.md) # Procesamiento de datos mediante el comando `dataprocessing` El comando `dataprocessing` de Neptune ML se utiliza para crear un trabajo de procesamiento de datos, comprobar su estado, detenerlo o enumerar todos los trabajos de procesamiento de datos activos. ## Creación de un trabajo de procesamiento de datos mediante el comando `dataprocessing` de Neptune ML Un comando típico `dataprocessing` de Neptune ML para crear un nuevo trabajo tiene el siguiente aspecto: ``` 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)" }' ``` Un comando para iniciar el reprocesamiento incremental tiene el siguiente aspecto: ``` 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)" }' ``` **Parámetros para la creación de trabajos de `dataprocessing`** + **`id`**: (*opcional*) un identificador único para el trabajo nuevo. *Tipo*: cadena. *Valor predeterminado*: un UUID generado automáticamente. + **`previousDataProcessingJobId`**: (*opcional*) el ID de trabajo de un trabajo de procesamiento de datos completado que se ejecuta en una versión anterior de los datos. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. *Nota*: Úselo para el procesamiento incremental de datos, para actualizar el modelo cuando los datos del gráfico cambien (pero no cuando se eliminen los datos). + **`inputDataS3Location`**— (*Obligatorio*) El URI de la ubicación de Amazon S3 en la que desea que SageMaker AI descargue los datos necesarios para ejecutar el trabajo de procesamiento de datos. *Tipo*: cadena. + **`processedDataS3Location`**— (*Obligatorio*) El URI de la ubicación de Amazon S3 en la que desea que SageMaker AI guarde los resultados de un trabajo de procesamiento de datos. *Tipo*: cadena. + **`sagemakerIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM para SageMaker la ejecución de la IA. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`neptuneIamRoleArn`**— (*Opcional*) El nombre del recurso de Amazon (ARN) de una función de IAM que la SageMaker IA puede asumir para realizar tareas en su nombre. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`processingInstanceType`**: (*opcional*) el tipo de instancia de ML que se utiliza durante el procesamiento de datos. Su memoria debe ser lo suficientemente grande como para incluir el conjunto de datos procesado. *Tipo*: cadena. *Valor predeterminado*: el tipo `ml.r5` de menor tamaño cuya memoria es diez veces mayor que el tamaño de los datos de gráficos exportados en el disco. *Nota*: Neptune ML puede seleccionar el tipo de instancia automáticamente. Consulte [Selección de una instancia para el procesamiento de datos](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size). + **`processingInstanceVolumeSizeInGB`**: (*opcional*) el tamaño del volumen del disco de la instancia de procesamiento. Tanto los datos de entrada como los datos procesados se almacenan en el disco, por lo que el tamaño del volumen debe ser lo suficientemente grande como para incluir ambos conjuntos de datos. *Tipo*: número entero. *Valor predeterminado*: `0`. *Nota*: Si no se especifica o el valor es 0, Neptune ML elige el tamaño del volumen automáticamente en función del tamaño de los datos. + **`processingTimeOutInSeconds`**: (*opcional*) tiempo de espera en segundos para el trabajo de procesamiento de datos. *Tipo*: número entero. *Valor predeterminado*: `86,400` (un día). + **`modelType`**: (*opcional*) uno de los dos tipos de modelos que Neptune ML admite actualmente: modelos de subgráficos heterogéneos (`heterogeneous`) y gráficos de conocimientos (`kge`). *Tipo*: cadena. *Valor predeterminado*: *ninguno*. *Nota*: Si no se especifica, Neptune ML elige automáticamente el modelo en función de los datos. + **`configFileName`**: (*opcional*) un archivo de especificación de datos que describe cómo cargar los datos de gráficos exportados para el entrenamiento. El kit de herramientas de exportación de Neptune genera automáticamente el archivo. *Tipo*: cadena. *Valor predeterminado*: `training-data-configuration.json`. + **`subnets`**— (*Opcional*) La IDs de las subredes de la VPC de Neptune. *Tipo*: lista de cadenas. *Valor predeterminado*: *ninguno*. + **`securityGroupIds`**— (*Opcional*) El grupo de seguridad de VPC. IDs *Tipo*: lista de cadenas. *Valor predeterminado*: *ninguno*. + **`volumeEncryptionKMSKey`**— (*Opcional*) La clave AWS Key Management Service (AWS KMS) que utiliza la SageMaker IA para cifrar los datos del volumen de almacenamiento adjunto a las instancias informáticas de aprendizaje automático que ejecutan el trabajo de procesamiento. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. + **`enableInterContainerTrafficEncryption`**: (*opcional*) habilite o deshabilite el cifrado del tráfico entre contenedores en trabajos de entrenamiento o de ajuste de hiperparámetros. *Tipo*: booleano. *Valor predeterminado*: *true*. **nota** El parámetro `enableInterContainerTrafficEncryption` solo está disponible en la [versión 1.2.0.2.R3 del motor](engine-releases-1.2.0.2.R3.md). + **`s3OutputEncryptionKMSKey`**— (*Opcional*) La clave AWS Key Management Service (AWS KMS) que utiliza la SageMaker IA para cifrar el resultado del trabajo de formación. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. ## Obtención del estado de un trabajo de procesamiento de datos mediante el comando `dataprocessing` de Neptune ML Un ejemplo del comando `dataprocessing` de Neptune ML para el estado de un trabajo: ``` curl -s \ "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)" \ | python -m json.tool ``` **Parámetros para el estado del trabajo de `dataprocessing`** + **`id`**: (*obligatorio*) el identificador único del trabajo de procesamiento de datos. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. ## Detención de un trabajo de procesamiento de datos mediante el comando `dataprocessing` de Neptune ML Un ejemplo del comando `dataprocessing` de Neptune ML para detener un trabajo: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)" ``` Otro ejemplo: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/dataprocessing/(the job ID)?clean=true" ``` **Parámetros para el trabajo de detención de `dataprocessing`** + **`id`**: (*obligatorio*) el identificador único del trabajo de procesamiento de datos. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`clean`**: (*opcional*) este indicador especifica que todos los artefactos de Amazon S3 deben eliminarse cuando se detiene el trabajo. *Tipo*: booleano. *Valor predeterminado*: `FALSE`. ## Enumeración de trabajos de procesamiento de datos activos mediante el comando `dataprocessing` de Neptune ML Un ejemplo del comando `dataprocessing` de Neptune ML para enumerar los trabajos activos: ``` curl -s "https://(your Neptune endpoint)/ml/dataprocessing" ``` Otro ejemplo: ``` curl -s "https://(your Neptune endpoint)/ml/dataprocessing?maxItems=3" ``` **Parámetros para los trabajos de enumeración de `dataprocessing`** + **`maxItems`**: (*opcional*) el número máximo de elementos que devolver. *Tipo*: número entero. *Valor predeterminado*: `10`. *Valor máximo permitido*: `1024`. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. # Entrenamiento de modelos con el comando `modeltraining` El comando `modeltraining` de Neptune ML se utiliza para crear un trabajo de entrenamiento de modelos, comprobar su estado, detenerlo o enumerar todos los trabajos de entrenamiento de modelos activos. ## Creación de un trabajo de entrenamiento de modelos mediante el comando `modeltraining` de Neptune ML Un comando `modeltraining` de Neptune ML para crear un trabajo completamente nuevo tiene el siguiente aspecto: ``` 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" }' ``` Un comando `modeltraining` de Neptune ML para crear un trabajo de actualización para el entrenamiento incremental de modelos tiene el siguiente aspecto: ``` 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)", }' ``` Un comando `modeltraining` de Neptune ML para crear un nuevo trabajo con una implementación de modelo personalizada proporcionada por el usuario tiene el siguiente aspecto: ``` 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)" } }' ``` **Parámetros para la creación de trabajos de `modeltraining`** + **`id`**: (*opcional*) un identificador único para el trabajo nuevo. *Tipo*: cadena. *Valor predeterminado*: un UUID generado automáticamente. + **`dataProcessingJobId`**: (*obligatorio*) el ID del trabajo de procesamiento de datos completado que ha creado los datos con los que se trabajará en el entrenamiento. *Tipo*: cadena. + **`trainModelS3Location`**: (*obligatorio*) la ubicación en Amazon S3 donde se van a almacenar los artefactos del modelo. *Tipo*: cadena. + **`previousModelTrainingJobId`**: (*opcional*) el ID del trabajo de entrenamiento de modelos completado que desee actualizar de forma incremental en función de los datos actualizados. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. + **`sagemakerIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM para SageMaker la ejecución de la IA. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`modelName`**: (*opcional*) el tipo de modelo para el entrenamiento. De forma predeterminada, el modelo de ML se basa automáticamente en el `modelType` utilizado en el procesamiento de datos, pero aquí puede especificar otro tipo de modelo. *Tipo*: cadena. *Valor predeterminado*: `rgcn` para gráficos heterogéneos y `kge` para gráficos de conocimientos. *Valores válidos*: para gráficos heterogéneos: `rgcn`. Para gráficos de `kge`: `transe`, `distmult` o `rotate`. Para la implementación de modelos personalizados: `custom`. + **`baseProcessingInstanceType`**: (*opcional*) el tipo de instancia de ML que se utiliza para preparar y administrar el entrenamiento de modelos de ML. *Tipo*: cadena. *Nota*: Se trata de una instancia de CPU que se elige en función de los requisitos de memoria para procesar los datos y el modelo de entrenamiento. Consulte [Selección de una instancia para el entrenamiento y la transformación de modelos](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`trainingInstanceType`**: (*opcional*) el tipo de instancia de ML que se utiliza para el entrenamiento de modelos. Todos los modelos de Neptune ML admiten el entrenamiento con CPU, GPU y varias GPU. *Tipo*: cadena. *Valor predeterminado*: `ml.p3.2xlarge`. *Nota*: La elección del tipo de instancia adecuado para el entrenamiento depende del tipo de tarea, del tamaño del gráfico y del presupuesto. Consulte [Selección de una instancia para el entrenamiento y la transformación de modelos](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`trainingInstanceVolumeSizeInGB`**: (*opcional*) el tamaño del volumen del disco de la instancia de entrenamiento. Tanto los datos de entrada como los datos de salida se almacenan en el disco, por lo que el tamaño del volumen debe ser lo suficientemente grande como para incluir ambos conjuntos de datos. *Tipo*: número entero. *Valor predeterminado*: `0`. *Nota*: Si no se especifica o el valor es 0, Neptune ML selecciona un tamaño de volumen de disco en función de la recomendación generada en el paso de procesamiento de datos. Consulte [Selección de una instancia para el entrenamiento y la transformación de modelos](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`trainingTimeOutInSeconds`**: (*opcional*) tiempo de espera en segundos para el trabajo de entrenamiento. *Tipo*: número entero. *Valor predeterminado*: `86,400` (un día). + **`maxHPONumberOfTrainingJobs`**: número total máximo de trabajos de entrenamiento que se deben iniciar para el trabajo de ajuste de hiperparámetros. *Tipo*: número entero. *Valor predeterminado*: `2`. *Nota*: Neptune ML ajusta automáticamente los hiperparámetros del modelo de machine learning. Para obtener un modelo que funcione bien, utilice al menos 10 trabajos (dicho de otro modo, establezca `maxHPONumberOfTrainingJobs` en 10). Por lo general, cuantos más ajustes se realicen, mejores serán los resultados. + **`maxHPOParallelTrainingJobs`**: número máximo de trabajos de entrenamiento en paralelo que se deben iniciar para el trabajo de ajuste de hiperparámetros. *Tipo*: número entero. *Valor predeterminado*: `2`. *Nota*: El número de trabajos en paralelo que puede ejecutar está limitado por los recursos disponibles en la instancia de entrenamiento. + **`subnets`**— (*Opcional*) La IDs de las subredes de la VPC de Neptune. *Tipo*: lista de cadenas. *Valor predeterminado*: *ninguno*. + **`securityGroupIds`**— (*Opcional*) El grupo de seguridad de VPC. IDs *Tipo*: lista de cadenas. *Valor predeterminado*: *ninguno*. + **`volumeEncryptionKMSKey`**— (*Opcional*) La clave AWS Key Management Service (AWS KMS) que utiliza la SageMaker IA para cifrar los datos del volumen de almacenamiento adjunto a las instancias de procesamiento de aprendizaje automático que ejecutan el trabajo de formación. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. + **`s3OutputEncryptionKMSKey`**— (*Opcional*) La clave AWS Key Management Service (AWS KMS) que utiliza la SageMaker IA para cifrar el resultado del trabajo de procesamiento. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. + **`enableInterContainerTrafficEncryption`**: (*opcional*) habilite o deshabilite el cifrado del tráfico entre contenedores en trabajos de entrenamiento o de ajuste de hiperparámetros. *Tipo*: booleano. *Valor predeterminado*: *true*. **nota** El parámetro `enableInterContainerTrafficEncryption` solo está disponible en la [versión 1.2.0.2.R3 del motor](engine-releases-1.2.0.2.R3.md). + **`enableManagedSpotTraining`**: (*opcional*) optimiza el costo de entrenar modelos de machine learning mediante el uso de instancias de spot de Amazon Elastic Compute Cloud. Para obtener más información, consulta [Managed Spot Training en Amazon SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/model-managed-spot-training.html). *Tipo*: booleano. *Valor predeterminado*: *false*. + **`customModelTrainingParameters`**: (*opcional*) la configuración para el entrenamiento de modelos personalizados. Este campo es un objeto de JSON con los siguientes campos: + **`sourceS3DirectoryPath`**: (*obligatorio*) la ruta a la ubicación de Amazon S3 donde se encuentra el módulo de Python que implementa el modelo. Debe apuntar a una ubicación válida de Amazon S3 existente que incluya, como mínimo, un script de entrenamiento, un script de transformación y un archivo `model-hpo-configuration.json`. + **`trainingEntryPointScript`**: (*opcional*) el nombre del punto de entrada en el módulo de un script que realiza el entrenamiento de modelos y utiliza los hiperparámetros como argumentos de la línea de comandos, incluidos los hiperparámetros fijos. *Valor predeterminado*: `training.py`. + **`transformEntryPointScript`**: (*opcional*) el nombre del punto de entrada en el módulo de un script que debe ejecutarse después de identificar el mejor modelo de la búsqueda de hiperparámetros, con el fin de calcular los artefactos de modelos necesarios para su implementación. Debería poder ejecutarse sin argumentos de línea de comandos. *Valor predeterminado*: `transform.py`. + **`maxWaitTime`**: (*Opcional*) el tiempo máximo de espera, en segundos, al realizar el entrenamiento del modelo mediante instancias de spot. Debe ser superior a `trainingTimeOutInSeconds`. *Tipo*: número entero. ## Obtención del estado de un trabajo de entrenamiento de modelos mediante el comando `modeltraining` de Neptune ML Un ejemplo del comando `modeltraining` de Neptune ML para el estado de un trabajo: ``` curl -s \ "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)" \ | python -m json.tool ``` **Parámetros para el estado del trabajo de `modeltraining`** + **`id`**: (*obligatorio*) el identificador único del trabajo de entrenamiento de modelos. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. ## Detención de un trabajo de entrenamiento de modelos mediante el comando `modeltraining` de Neptune ML Un ejemplo del comando `modeltraining` de Neptune ML para detener un trabajo: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)" ``` Otro ejemplo: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltraining/(the job ID)?clean=true" ``` **Parámetros para el trabajo de detención de `modeltraining`** + **`id`**: (*obligatorio*) el identificador único del trabajo de entrenamiento de modelos. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`clean`**: (*opcional*) este indicador especifica que todos los artefactos de Amazon S3 deben eliminarse cuando se detiene el trabajo. *Tipo*: booleano. *Valor predeterminado*: `FALSE`. ## Enumeración de trabajos de entrenamiento de modelos activos mediante el comando `modeltraining` de Neptune ML Un ejemplo del comando `modeltraining` de Neptune ML para enumerar los trabajos activos: ``` curl -s "https://(your Neptune endpoint)/ml/modeltraining" | python -m json.tool ``` Otro ejemplo: ``` curl -s "https://(your Neptune endpoint)/ml/modeltraining?maxItems=3" | python -m json.tool ``` **Parámetros para los trabajos de enumeración de `modeltraining`** + **`maxItems`**: (*opcional*) el número máximo de elementos que devolver. *Tipo*: número entero. *Valor predeterminado*: `10`. *Valor máximo permitido*: `1024`. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. # Transformación de modelos mediante el comando `modeltransform` El comando `modeltransform` de Neptune ML se utiliza para crear un trabajo de transformación de modelos, comprobar su estado, detenerlo o enumerar todos los trabajos de transformación de modelos activos. ## Creación de un trabajo de transformación de modelos mediante el comando `modeltransform` de Neptune ML Un comando `modeltransform` de Neptune ML para crear un trabajo de transformación incremental, sin tener que volver a entrenar los modelos, tiene el siguiente aspecto: ``` 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" }' ``` Un `modeltransform` comando de Neptune ML para crear un trabajo a partir de un trabajo de formación de SageMaker IA completado tiene el siguiente aspecto: ``` 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" : "" }' ``` Un comando `modeltransform` de Neptune ML para crear un trabajo que utiliza una implementación de modelos personalizados tiene el siguiente aspecto: ``` 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)" } }' ``` **Parámetros para la creación de trabajos de `modeltransform`** + **`id`**: (*opcional*) un identificador único para el trabajo nuevo. *Tipo*: cadena. *Valor predeterminado*: un UUID generado automáticamente. + **`dataProcessingJobId`**: el ID del trabajo de un trabajo de procesamiento de datos completado. *Tipo*: cadena. *Nota*: Debe incluir los valores `dataProcessingJobId` y `mlModelTrainingJobId`, o `trainingJobName`. + **`mlModelTrainingJobId`**: el ID de trabajo de un trabajo de entrenamiento de modelos completado. *Tipo*: cadena. *Nota*: Debe incluir los valores `dataProcessingJobId` y `mlModelTrainingJobId`, o `trainingJobName`. + **`trainingJobName`**— El nombre de un trabajo de formación en SageMaker IA completado. *Tipo*: cadena. *Nota*: Debe incluir los parámetros `dataProcessingJobId` y `mlModelTrainingJobId`, o el parámetro `trainingJobName`. + **`sagemakerIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM para SageMaker la ejecución de la IA. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`customModelTransformParameters `**: (*opcional*) información de configuración para la transformación de un modelo mediante un modelo personalizado. El objeto `customModelTransformParameters` incluye los siguientes campos, que deben tener valores compatibles con los parámetros del modelo guardados del trabajo de entrenamiento: + **`sourceS3DirectoryPath`**: (*obligatorio*) la ruta a la ubicación de Amazon S3 donde se encuentra el módulo de Python que implementa el modelo. Debe apuntar a una ubicación válida de Amazon S3 existente que incluya, como mínimo, un script de entrenamiento, un script de transformación y un archivo `model-hpo-configuration.json`. + **`transformEntryPointScript`**: (*opcional*) el nombre del punto de entrada en el módulo de un script que debe ejecutarse después de identificar el mejor modelo de la búsqueda de hiperparámetros, con el fin de calcular los artefactos de modelos necesarios para su implementación. Debería poder ejecutarse sin argumentos de línea de comandos. *Valor predeterminado*: `transform.py`. + **`baseProcessingInstanceType`**: (*opcional*) el tipo de instancia de ML que se utiliza para preparar y administrar el entrenamiento de modelos de ML. *Tipo*: cadena. *Nota*: Se trata de una instancia de CPU que se elige en función de los requisitos de memoria para procesar los datos y el modelo de transformación. Consulte [Selección de una instancia para el entrenamiento y la transformación de modelos](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`baseProcessingInstanceVolumeSizeInGB`**: (*opcional*) el tamaño del volumen del disco de la instancia de entrenamiento. Tanto los datos de entrada como los datos de salida se almacenan en el disco, por lo que el tamaño del volumen debe ser lo suficientemente grande como para incluir ambos conjuntos de datos. *Tipo*: número entero. *Valor predeterminado*: `0`. *Nota*: Si no se especifica o el valor es 0, Neptune ML selecciona un tamaño de volumen de disco en función de la recomendación generada en el paso de procesamiento de datos. Consulte [Selección de una instancia para el entrenamiento y la transformación de modelos](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size). + **`subnets`**— (*Opcional*) La IDs de las subredes de la VPC de Neptune. *Tipo*: lista de cadenas. *Valor predeterminado*: *ninguno*. + **`securityGroupIds`**— (*Opcional*) El grupo de seguridad de VPC. IDs *Tipo*: lista de cadenas. *Valor predeterminado*: *ninguno*. + **`volumeEncryptionKMSKey`**— (*Opcional*) La clave AWS Key Management Service (AWS KMS) que utiliza la SageMaker IA para cifrar los datos del volumen de almacenamiento adjunto a las instancias de procesamiento de aprendizaje automático que ejecutan el trabajo de transformación. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. + **`enableInterContainerTrafficEncryption`**: (*opcional*) habilite o deshabilite el cifrado del tráfico entre contenedores en trabajos de entrenamiento o de ajuste de hiperparámetros. *Tipo*: booleano. *Valor predeterminado*: *true*. **nota** El parámetro `enableInterContainerTrafficEncryption` solo está disponible en la [versión 1.2.0.2.R3 del motor](engine-releases-1.2.0.2.R3.md). + **`s3OutputEncryptionKMSKey`**— (*Opcional*) La clave AWS Key Management Service (AWS KMS) que utiliza la SageMaker IA para cifrar el resultado del trabajo de procesamiento. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. ## Obtención del estado de un trabajo de transformación de modelos mediante el comando `modeltransform` de Neptune ML Un ejemplo del comando `modeltransform` de Neptune ML para el estado de un trabajo: ``` curl -s \ "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)" \ | python -m json.tool ``` **Parámetros para el estado del trabajo de `modeltransform`** + **`id`**: (*obligatorio*) el identificador único del trabajo de transformación de modelos. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. ## Detención de un trabajo de transformación de modelos mediante el comando `modeltransform` de Neptune ML Un ejemplo del comando `modeltransform` de Neptune ML para detener un trabajo: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)" ``` Otro ejemplo: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/modeltransform/(the job ID)?clean=true" ``` **Parámetros para el trabajo de detención de `modeltransform`** + **`id`**: (*obligatorio*) el identificador único del trabajo de transformación de modelos. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`clean`**: (*opcional*) este indicador especifica que todos los artefactos de Amazon S3 deben eliminarse cuando se detiene el trabajo. *Tipo*: booleano. *Valor predeterminado*: `FALSE`. ## Enumeración de trabajos de transformación de modelos activos mediante el comando `modeltransform` de Neptune ML Un ejemplo del comando `modeltransform` de Neptune ML para enumerar los trabajos activos: ``` curl -s "https://(your Neptune endpoint)/ml/modeltransform" | python -m json.tool ``` Otro ejemplo: ``` curl -s "https://(your Neptune endpoint)/ml/modeltransform?maxItems=3" | python -m json.tool ``` **Parámetros para los trabajos de enumeración de `modeltransform`** + **`maxItems`**: (*opcional*) el número máximo de elementos que devolver. *Tipo*: número entero. *Valor predeterminado*: `10`. *Valor máximo permitido*: `1024`. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. # Administración de los puntos de conexión de inferencia mediante el comando `endpoints` El comando `endpoints` de Neptune ML se utiliza para crear un punto de conexión de inferencia, comprobar su estado, eliminarlo o enumerar los puntos de conexión de inferencia existentes. ## Creación de un punto de conexión de inferencia mediante el comando `endpoints` de Neptune ML Un comando `endpoints` de Neptune ML para crear un punto de conexión de inferencia a partir de un modelo creado por un trabajo de entrenamiento tiene el siguiente aspecto: ``` 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)" }' ``` Un comando `endpoints` de Neptune ML para actualizar un punto de conexión de inferencia existente a partir de un modelo creado por un trabajo de entrenamiento tiene el siguiente aspecto: ``` 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)" }' ``` Un comando `endpoints` de Neptune ML para crear un punto de conexión de inferencia a partir de un trabajo de transformación de modelos tiene el siguiente aspecto: ``` 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)" }' ``` Un comando `endpoints` de Neptune ML para actualizar un punto de conexión de inferencia existente a partir de un trabajo de transformación de modelos tiene el siguiente aspecto: ``` 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)" }' ``` **Parámetros para la creación de puntos de conexión de inferencia `endpoints`** + **`id`**: (*opcional*) un identificador único para el nuevo punto de conexión de inferencia. *Tipo*: cadena. *Valor predeterminado*: un nombre con marca temporal generado automáticamente. + **`mlModelTrainingJobId`**: el ID del trabajo de entrenamiento de modelos completado que ha creado el modelo al que apuntará el punto de conexión de inferencia. *Tipo*: cadena. *Nota*: Debe proporcionar el valor `mlModelTrainingJobId` o el valor `mlModelTransformJobId`. + **`mlModelTransformJobId`**: el ID de trabajo de un trabajo de transformación de modelos completado. *Tipo*: cadena. *Nota*: Debe proporcionar el valor `mlModelTrainingJobId` o el valor `mlModelTransformJobId`. + **`update`**: (*opcional*) si está presente, este parámetro indica que se trata de una solicitud de actualización. *Tipo*: booleano. *Valor predeterminado*: `false` *Nota*: Debe proporcionar el valor `mlModelTrainingJobId` o el valor `mlModelTransformJobId`. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`modelName`**: (*opcional*) tipo de modelo para el entrenamiento. De forma predeterminada, el modelo de ML se basa automáticamente en el `modelType` utilizado en el procesamiento de datos, pero aquí puede especificar otro tipo de modelo. *Tipo*: cadena. *Valor predeterminado*: `rgcn` para gráficos heterogéneos y `kge` para gráficos de conocimientos. *Valores válidos*: para gráficos heterogéneos: `rgcn`. Para gráficos de conocimientos: `kge`, `transe`, `distmult` o `rotate`. + **`instanceType`**: (*opcional*) el tipo de instancia de ML que se utiliza para el mantenimiento en línea. *Tipo*: cadena. *Valor predeterminado*: `ml.m5.xlarge`. *Nota*: La selección de la instancia de ML para un punto de conexión de inferencia depende del tipo de tarea, del tamaño del gráfico y del presupuesto. Consulte [Selección de una instancia para un punto de conexión de inferencia](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size). + **`instanceCount`**: (*opcional*) el número mínimo de instancias de Amazon EC2 que se deben implementar en un punto de conexión para la predicción. *Tipo*: número entero. *Valor predeterminado*: `1`. + **`volumeEncryptionKMSKey`**— (*Opcional*) La clave AWS Key Management Service (AWS KMS) que utiliza la SageMaker IA para cifrar los datos del volumen de almacenamiento adjunto a las instancias informáticas de aprendizaje automático que ejecutan los puntos finales. *Tipo*: cadena. *Valor predeterminado*: *ninguno*. ## Obtención del estado de un punto de conexión de inferencia mediante el comando `endpoints` de Neptune ML Un ejemplo del comando `endpoints` de Neptune ML para el estado de un punto de conexión de instancia: ``` curl -s \ "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)" \ | python -m json.tool ``` **Parámetros para el estado del punto de conexión de instancia `endpoints`** + **`id`**: (*obligatorio*) el identificador único del punto de conexión de inferencia. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. ## Eliminación de un punto de conexión de instancia mediante el comando `endpoints` de Neptune ML Un ejemplo del comando `endpoints` de Neptune ML para eliminar un punto de conexión de instancia: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)" ``` Otro ejemplo: ``` curl -s \ -X DELETE "https://(your Neptune endpoint)/ml/endpoints/(the inference endpoint ID)?clean=true" ``` **Parámetros para la eliminación de puntos de conexión de inferencia `endpoints`** + **`id`**: (*obligatorio*) el identificador único del punto de conexión de inferencia. *Tipo*: cadena. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. + **`clean`**: (*opcional*) indica que también se deben eliminar todos los artefactos relacionados con este punto de conexión. *Tipo*: booleano. *Valor predeterminado*: `FALSE`. ## Enumeración de puntos de conexión de inferencia mediante el comando `endpoints` de Neptune ML Un comando `endpoints` de Neptune ML para enumerar los puntos de conexión de inferencia tiene el siguiente aspecto: ``` curl -s "https://(your Neptune endpoint)/ml/endpoints" \ | python -m json.tool ``` Otro ejemplo: ``` curl -s "https://(your Neptune endpoint)/ml/endpoints?maxItems=3" \ | python -m json.tool ``` **Parámetros para la enumeración de puntos de conexión de inferencia `dataprocessing`** + **`maxItems`**: (*opcional*) el número máximo de elementos que devolver. *Tipo*: número entero. *Valor predeterminado*: `10`. *Valor máximo permitido*: `1024`. + **`neptuneIamRoleArn`**— (*Opcional*) El ARN de un rol de IAM que proporciona a Neptune acceso a los recursos de IA y SageMaker Amazon S3. *Tipo*: cadena. *Nota*: Debe figurar en el grupo de parámetros del clúster de base de datos o se producirá un error. # Errores y excepciones de la API de administración de Neptune ML Todas las excepciones de la API de administración de Neptune ML devuelven un código HTTP 400. Tras recibir alguna de estas excepciones, no se debe volver a intentar el comando que generó la excepción. **** + **`MissingParameterException`**: Mensaje de error: `Required credentials are missing. Please add IAM role to the cluster or pass as a parameter to this request.` + **`InvalidParameterException`** Mensajes de error: + `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`** Mensajes de error: + `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.` # Límites de Neptune ML + Los tipos de inferencia admitidos actualmente son la clasificación de nodos, la regresión de nodos, la clasificación de bordes, la regresión de bordes y la predicción de enlaces (consulte [Capacidades de Neptune ML](machine-learning.md#machine-learning-capabilities)). + El tamaño máximo del gráfico que puede admitir Neptune ML depende de la cantidad de memoria y almacenamiento necesarios durante la [preparación de los datos](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-processing-instance-size), el [entrenamiento del modelo](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-training-transform-instance-size) y la [inferencia](machine-learning-on-graphs-instance-selection.md#machine-learning-on-graphs-inference-endpoint-instance-size). + El tamaño máximo de memoria de una instancia de procesamiento de datos de SageMaker AI es de 768 GB. Como resultado, se produce un error en la etapa de procesamiento de datos si se necesitan más de 768 GB de memoria. + El tamaño máximo de memoria de una instancia de entrenamiento de SageMaker AI es de 732 GB. Como resultado, se produce un error en la etapa de entrenamiento si se necesitan más de 732 GB de memoria. + El tamaño máximo de una carga útil de inferencia para un punto de conexión de SageMaker AI es de 6 MiB. Como resultado, se produce un error en la inferencia inductiva si la carga útil del subgráfico supera este tamaño. + Por el momento, Neptune ML solo está disponible en las regiones en las que se admiten Neptune y los demás servicios de los que depende (como AWS Lambda, Amazon API Gateway y Amazon SageMaker AI). Existen diferencias en China (Pekín) y China (Ningxia) relacionadas con el uso predeterminado de la autenticación de IAM, tal y como se [explica aquí](https://docs.amazonaws.cn/en_us/aws/latest/userguide/api-gateway.html#feature-diff) junto con otras diferencias. + Los puntos de conexión de inferencia de predicción de enlaces lanzados por Neptune ML actualmente solo pueden predecir posibles enlaces con nodos que estaban presentes en el gráfico durante el entrenamiento. Por ejemplo, supongamos que tenemos un gráfico con los vértices `User` y `Movie` y los bordes `Rated`. Con el modelo de recomendación de predicción de enlaces de Neptune ML correspondiente, puede añadir un nuevo usuario al gráfico y hacer que el modelo pronostique películas para él, pero el modelo solo puede recomendar películas que estuvieron presentes durante el entrenamiento del modelo. Aunque la incrustación de nodos `User` se calcula en tiempo real mediante su subgráfico local y el modelo GNN y, por lo tanto, puede cambiar con el tiempo a medida que los usuarios valoran las películas, se compara con las incrustaciones de películas estáticas y precalculadas para la recomendación final. + Los modelos KGE compatibles con Neptune ML solo funcionan para tareas de predicción de enlaces, y las representaciones son específicas de los tipos de bordes y vértices presentes en el gráfico durante el entrenamiento. Esto significa que todos los tipos de bordes y vértices a los que se hace referencia en una consulta de inferencia deben haber estado presentes en el gráfico durante el entrenamiento. No se pueden hacer predicciones para nuevos tipos de bordes o vértices sin volver a entrenar el modelo. ## Limitaciones de los recursos de SageMaker AI Según las actividades y el uso de recursos con el paso del tiempo, es posible que reciba mensajes de error que indiquen que [ha superado su cuota](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html) ([ResourceLimitExceeded](https://repost.aws/knowledge-center/sagemaker-resource-limit-exceeded-error)) y que necesita escalar verticalmente sus recursos de SageMaker AI. Siga los pasos del procedimiento [Solicitar un aumento de la cuota de servicio para los recursos de SageMaker](https://docs.aws.amazon.com/sagemaker/latest/dg/regions-quotas.html#service-limit-increase-request-procedure) de esta página para solicitar un aumento de la cuota a AWS Support. Los nombres de los recursos de SageMaker AI corresponden a las etapas de Neptune ML de la siguiente manera: + `ProcessingJob` de SageMaker AI lo utilizan los trabajos de procesamiento de datos, entrenamiento de modelos y transformación de modelos de Neptune. + `HyperParameterTuningJob` de SageMaker AI lo utilizan los trabajos de entrenamiento de modelos de Neptune. + `TrainingJob` de SageMaker AI lo utilizan los trabajos de entrenamiento de modelos de Neptune. + `Endpoint` de SageMaker AI lo utilizan los puntos de conexión de inferencia de Neptune.