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