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.

# Desarrollo de modelos personalizados en Neptune ML
<a name="machine-learning-custom-model-development"></a>

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
<a name="machine-learning-custom-model-training-script"></a>

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
<a name="machine-learning-custom-model-transform-script"></a>

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
<a name="machine-learning-custom-model-hpo-configuration-file"></a>

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
<a name="machine-learning-custom-model-testing"></a>

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.