As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Processar os dados de grafos exportados do Neptune para treinamento A etapa de processamento de dados usa os dados de grafos do Neptune criados pelo processo de exportação e cria as informações que são usadas pela [Deep Graph Library](https://www.dgl.ai/) (DGL) durante o treinamento. Isso inclui a realização de vários mapeamentos e transformações de dados: + Análise de nós e bordas para criar os arquivos de mapeamento de grafos e de ID exigidos pela DGL. + Conversão das propriedades do nó e da borda nos atributos do nó e da borda exigidos pela DGL. + Divisão dos dados em conjuntos de treinamento, validação e teste. ## Gerenciamento da etapa de processamento de dados do Neptune ML. Depois de exportar os dados do Neptune que você deseja usar para treinamento de modelos, é possível iniciar um trabalho de processamento de dados usando um comando `curl` (ou `awscurl`) como o seguinte: ``` 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" }' ``` Os detalhes de como usar esse comando são explicados em [O comando de processamento de dados](machine-learning-api-dataprocessing.md), junto com informações sobre como obter o status de um trabalho em execução, como interrompê-lo e como listar todos os trabalhos em execução. ## Processar dados de grafos atualizados para o Neptune ML Também é possível fornecer um `previousDataProcessingJobId` à API para garantir que o novo trabalho de processamento de dados use o mesmo método de processamento de um trabalho anterior. Esse procedimento é necessário quando você deseja obter previsões para dados de grafos atualizados no Neptune, seja treinando novamente o modelo antigo nos novos dados ou recalculando os artefatos do modelo nos novos dados. Faça isso usando um comando `curl` (ou `awscurl`) desta forma: ``` 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)"}' ``` Defina o valor do parâmetro `previousDataProcessingJobId` como o ID de trabalho do processamento de dados anterior correspondente ao modelo treinado. **nota** No momento, exclusões de nós no grafo atualizado não são aceitas. Se os nós tiverem sido removidos em um grafo atualizado, você precisará iniciar um trabalho de processamento de dados completamente novo em vez de usar `previousDataProcessingJobId`. # Codificação de atributos no Neptune ML Os valores das propriedades têm diferentes formatos e tipos de dados. Para obter um bom desempenho no machine learning, é essencial converter esses valores em codificações numéricas conhecidas como *atributos*. O Neptune ML realiza extração e codificação de atributos como parte das etapas de exportação e processamento de dados, usando técnicas de codificação de atributos descritas aqui. **nota** Se você planeja implementar a própria codificação de atributos em uma implementação de modelo personalizado, é possível desabilitar a codificação automática de atributos na fase de pré-processamento de dados selecionando `none` como o tipo de codificação de atributos. Nenhuma codificação de atributos ocorre nessa propriedade de nó ou borda e, em vez disso, os valores brutos da propriedade são analisados e salvos em um dicionário. O pré-processamento de dados ainda cria o grafo DGL a partir do conjunto de dados exportado, mas o grafo DGL criado não tem os atributos pré-processados para treinamento. Você deve usar essa opção se planeja realizar a própria codificação de atributos personalizados como parte do treinamento de modelos personalizados. Para obter detalhes, consulte [Modelos personalizados no Neptune ML](machine-learning-custom-models.md). ## Atributos categóricos no Neptune ML Uma propriedade que pode receber um ou mais valores distintos de uma lista fixa de valores possíveis é um atributo categórico. No Neptune ML, os atributos categóricos são codificados usando a [codificação one-hot](https://en.wikipedia.org/wiki/One-hot). O seguinte exemplo mostra como o nome da propriedade de diferentes alimentos é codificado como one-hot de acordo com a categoria: ``` Food Veg. Meat Fruit Encoding --------- ---- ---- ----- -------- Apple 0 0 1 001 Chicken 0 1 0 010 Broccoli 1 0 0 100 ``` **nota** O número máximo de categorias em qualquer atributo categórico é cem. Se uma propriedade tiver mais de cem categorias de valor, somente as 99 mais comuns serão colocadas em categorias distintas e as demais serão colocadas em uma categoria especial chamada `OTHER`. ## Atributos numéricos no Neptune ML Qualquer propriedade cujos valores sejam números reais pode ser codificada como um atributo numérico no Neptune ML. Os atributos numéricos são codificados usando números de ponto flutuante. É possível especificar um método de normalização de dados a ser usado ao codificar atributos numéricos, como este: `"norm": "normalization technique"` As seguintes técnicas de normalização são compatíveis: + **“nenhum”**: não normalize os valores numéricos durante a codificação. + **“mín-máx”**: normalize cada valor subtraindo o valor mínimo e dividindo-o pela diferença entre o valor máximo e o mínimo. + **“padrão”**: normalize cada valor dividindo-o pela soma de todos os valores. ## Atributos numéricos de bucket no Neptune ML Em vez de representar uma propriedade numérica usando números brutos, é possível condensar valores numéricos em categorias. Por exemplo, é possível dividir a idade das pessoas em categorias como crianças (0 a 20 anos), jovens adultos (20 a 40), pessoas de meia idade (40 a 60 anos) e idosos (de 60 anos em diante). Usando esses buckets numéricos, você transformaria uma propriedade numérica em um tipo de atributo categórico. No Neptune ML, é possível fazer com que uma propriedade numérica seja codificada como um atributo numérico de bucket. Você deve fornecer dois itens: + Um intervalo numérico no formato, ` "range": [a, b] `, em que `a` e `b` são números inteiros. + Uma contagem de buckets, no formato ` "bucket_cnt": c `, em que `c` é o número de buckets, também um número inteiro. Depois, o Neptune ML calcula o tamanho de cada bucket como ` ( b - a ) / c ` e codifica cada valor numérico como o número de qualquer bucket em que ele se enquadra. Qualquer valor menor que `a` é considerado pertencente ao primeiro bucket, e qualquer valor maior que `b` é considerado pertencente ao último bucket. Você também pode fazer com que os valores numéricos se enquadrem em mais de um bucket, especificando um tamanho de janela deslizante, como este :` "slide_window_size": s `, em que `s` é um número. Depois, o Neptune ML transforma cada valor numérico `v` da propriedade em um intervalo de ` v - s/2 ` a ` v + s/2 ` e atribui o valor `v` a cada bucket coberto pelo intervalo. Por fim, também é possível fornecer uma forma de preencher valores ausentes para atributos numéricos e atributos numéricos de bucket. Você faz isso usando ` "imputer": "imputation technique "`, em que a técnica de imputação é uma das seguintes: `"mean"`, `"median"` ou `"most-frequent"`. Se não for especificado um estimador, um valor ausente poderá fazer com que o processamento seja interrompido. ## Codificação de atributos de texto no Neptune ML Para texto de formato livre, o Neptune ML pode usar vários modelos diferentes para converter a sequência de tokens em uma string de valor de propriedade em um vetor de valor real de tamanho fixo: + [`text_fasttext`](#machine-learning-fasttext-features): usa a codificação [fastText](https://fasttext.cc/). É a codificação recomendada para atributos que usam um e somente um dos cinco idiomas aceitos pela codificação fastText. + [`text_sbert`](#machine-learning-sbert-features): usa os modelos de codificação [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). É a codificação recomendada para texto que não é compatível com `text_fasttext`. + [`text_word2vec`](#machine-learning-word2vec-features): usa os algoritmos [Word2Vec](https://wikipedia.org/wiki/Word2vec) originalmente publicados pelo [Google](https://code.google.com/archive/p/word2vec/) para codificar texto. O Word2Vec é compatível apenas com inglês. + [`text_tfidf`](#machine-learning-tfidf-features): usa um vetorizador de [frequência de termo – frequência inversa do documento](https://wikipedia.org/wiki/Tf-idf) (TF-IDF) para codificar texto. A codificação TF-IDF é compatível com atributos estatísticos não aceitos por outras codificações. ### Codificação *fastText* de valores de propriedades de texto no Neptune ML O Neptune ML pode usar os modelos de [fastText](https://fasttext.cc/) para converter valores de propriedades de texto em vetores de valor real de tamanho fixo. Esse é o método de codificação recomendado para valores de propriedades de texto em qualquer um dos cinco idiomas compatíveis com o fastText: + `en`   (inglês) + `zh`   (chinês) + `hi`   (hindi) + `es`   (espanhol) + `fr`   (francês) Observe que a codificação fastText não consegue lidar com palavras em mais de um idioma. O método `text_fasttext` pode usar o campo `max_length` que especifica o número máximo de tokens em um valor de propriedade de texto que será codificado, após o qual a string será truncada. Isso pode melhorar o desempenho quando os valores das propriedades de texto contêm strings longas, porque, se `max_length` não for especificado, a fastText codificará todos os tokens, independentemente do tamanho da string. Este exemplo especifica que os títulos de filmes franceses são codificados usando fastText: ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_fasttext"], "language": "fr", "max_length": 1024 } ] } ``` ### Codificação Sentence BERT (SBERT) de atributos de texto no Neptune ML O Neptune ML pode converter a sequência de tokens de um valor de propriedade de string em um vetor de valor real de tamanho fixo usando modelos de [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). O Neptune é compatível com dois métodos de SBERT, ou seja, `text_sbert128`, que será o padrão se você especificar apenas `text_sbert` e `text_sbert512`. A diferença entre os dois é o tamanho máximo de uma string de valor de propriedade de texto codificada. A codificação `text_sbert128` trunca strings de texto depois de codificar 128 tokens, enquanto `text_sbert512` trunca strings de texto depois de codificar 512 tokens. Como resultado, `text_sbert512` pode exigir mais tempo de processamento do que `text_sbert128`. Os dois métodos são mais lentos do que `text_fasttext`. A codificação SBERT é multilíngue, portanto, não há necessidade de especificar um idioma para o texto do valor da propriedade que você está codificando. O SBERT é compatível com vários idiomas e pode codificar uma frase que contenha mais de um idioma. Se você estiver codificando valores de propriedades que contenham texto em um idioma ou idiomas que o fastText não aceita, o SBERT será o método de codificação recomendado. O exemplo a seguir especifica que os títulos de filmes sejam codificados como SBERT até no máximo 128 tokens: ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_sbert128"] } ] } ``` ### Codificação Word2Vec de atributos de texto no Neptune ML O Neptune ML pode codificar valores de propriedades de string como um atributo do Word2Vec ([atributos Word2Vec](https://wikipedia.org/wiki/Word2vec) foram publicados originalmente pelo [Google)](https://code.google.com/archive/p/word2vec/). O método `text_word2vec` codifica os tokens em uma string como um vetor denso usando um dos [modelos treinados pelo spaCy](https://spacy.io/models). Isso é compatível apenas com o idioma inglês usando o [modelo en\$1core\$1web\$1lg](https://spacy.io/models/en#en_core_web_lg)). O seguinte exemplo especifica que os títulos dos filmes sejam codificados usando Word2Vec: ``` { "file_name" : "nodes/movie.csv", "separator" : ",", "node" : ["~id", "movie"], "features" : [ { "feature": ["title", "title", "text_word2vec"], "language": "en_core_web_lg" } ] } ``` Observe que o campo de idioma é opcional, pois o modelo `en_core_web_lg` em inglês é o único compatível com o Neptune. ### Codificação TF-IDF de atributos de texto no Neptune ML O Neptune ML pode codificar valores de propriedades de texto como atributos `text_tfidf`. Essa codificação converte a sequência de palavras no texto em um vetor numérico usando um vetorizador de [frequência de termo – frequência inversa de documento](https://wikipedia.org/wiki/Tf-idf) (TF-IDF), seguido por uma operação de redução de dimensionalidade. [TF-IDF](https://en.wikipedia.org/wiki/Tf%E2%80%93idf) (frequência de termo – frequência inversa de documento) é um valor numérico destinado a medir a importância de uma palavra em um conjunto de documentos. É calculado dividindo o número de vezes que uma palavra aparece em um valor de propriedade específico pelo número total desses valores de propriedade em que ela aparece. Por exemplo, se a palavra “kiss” aparecer duas vezes em um título de filme específico (digamos, “kiss kiss bang bang”) e “kiss” aparecer no título de quatro filmes ao todo, o valor TF-IDF de “kiss” no título “kiss kiss bang bang” será ` 2 / 4 `. O vetor criado inicialmente tem dimensões ***d***, em que ***d*** é o número de termos exclusivos em todos os valores de propriedade desse tipo. A operação de redução de dimensionalidade usa uma projeção esparsa aleatória para reduzir esse número a um máximo de cem. O vocabulário de um grafo é então gerado pela fusão de todos os atributos `text_tfidf` contidos nele. É possível controlar o vetorizador TF-IDF de várias maneiras: + **`max_features`**: usando o parâmetro `max_features`, é possível limitar o número de termos nos atributos `text_tfidf` aos mais comuns. Por exemplo, se você definir `max_features` como cem, somente os cem termos mais usados serão incluídos. O valor padrão para `max_features` se você não o definir explicitamente será 5 mil. + **`min_df`**: usando o parâmetro `min_df`, você poderá limitar o número de termos nos atributos `text_tfidf` àqueles que tenham pelo menos uma frequência de documento especificada. Por exemplo, se você definir `min_df` como cinco, somente os termos exibidos em pelo menos cinco valores de propriedade diferentes serão usados. O valor padrão para `min_df` se você não o definir explicitamente será dois. + **`ngram_range`**: o parâmetro `ngram_range` determina quais combinações de palavras são tratadas como termos. Por exemplo, se você definir `ngram_range` como `[2, 4]`, os seguintes seis termos serão encontrados no título “kiss kiss bang bang”: + *Termos de duas palavras*: “kiss kiss”, “kiss bang” e “bang bang”. + *Termos de três palavras*: “kiss kiss bang” e “kiss bang bang”. + *Termos de quatro palavras*: “kiss kiss bang bang”. A configuração padrão para `ngram_range` é `[1, 1]`. ## Atributos de data e hora no Neptune ML O Neptune ML pode converter partes de valores de propriedades `datetime` em atributos categóricos codificando-os como [matrizes one-hot](https://en.wikipedia.org/wiki/One-hot). Use o parâmetro `datetime_parts` para especificar uma ou mais das seguintes partes a serem codificadas: `["year", "month", "weekday", "hour"]`. Se você não definir `datetime_parts`, por padrão, todas as quatro partes serão codificadas. Por exemplo, se o intervalo de valores de data e hora abranger os anos de 2010 a 2012, as quatro partes da entrada de data e hora `2011-04-22 01:16:34` serão as seguintes: + **ano**: `[0, 1, 0]`. Como há apenas três anos no período (2010, 2011 e 2012), a matriz one-hot tem três entradas, uma para cada ano. + **mês**: `[0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0]`. Aqui, a matriz one-hot tem uma entrada para cada mês do ano. + **dia da semana**: `[0, 0, 0, 0, 1, 0, 0]`. O padrão ISO 8601 estabelece que segunda-feira é o primeiro dia da semana e, como 22 de abril de 2011 foi sexta-feira, a matriz de dia da semana one-hot correspondente está ativa na quinta posição. + **hora**: `[0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]`. A hora da 1h é definida em uma matriz one-hot de 24 membros. Dia do mês, minuto e segundo não são codificados categoricamente. Se o intervalo `datetime` total em questão incluir apenas datas de um único ano, nenhuma matriz `year` será codificada. É possível especificar uma estratégia de imputação para preencher os valores `datetime` ausentes, usando o parâmetro `imputer` e uma das estratégias disponíveis para atributos numéricos. ## Codificação de atributos automáticos no Neptune ML Em vez de especificar manualmente os métodos de codificação de atributos a serem usados para as propriedades em seu grafo, você pode definir `auto` como um método de codificação de atributos. Depois, o Neptune ML tenta inferir a melhor codificação de atributos para cada propriedade com base no tipo de dados subjacente. Veja algumas das heurísticas que o Neptune ML usa para selecionar as codificações de atributos apropriadas: + Se a propriedade tiver somente valores numéricos e puder ser convertida em tipos de dados numéricos, o Neptune ML geralmente a codificará como um valor numérico. No entanto, se o número de valores exclusivos da propriedade for menor que 10% do número total de valores e a cardinalidade desses valores exclusivos for menor que cem, o Neptune ML usará uma codificação categórica. + Se os valores das propriedades puderem ser convertidos em um tipo `datetime`, o Neptune ML os codificará como um atributo `datetime`. + Se os valores das propriedades puderem ser forçados a boolianos (1/0 ou verdadeiro/falso), o Neptune ML usará a codificação de categorias. + Se a propriedade for uma string com mais de 10% de seus valores exclusivos e o número médio de tokens por valor for maior ou igual a três, o Neptune ML vai inferir que o tipo de propriedade é texto e detectará automaticamente o idioma que está sendo usado. Se o idioma detectado for um dos aceitos pelo [fastText](#machine-learning-fasttext-features), ou seja, inglês, chinês, hindi, espanhol e francês, o Neptune ML usará `text_fasttext` para codificar o texto . Caso contrário, o Neptune ML usará [`text_sbert`](#machine-learning-sbert-features). + Se a propriedade for uma string não classificada como um atributo de texto, o Neptune ML presumirá que seja um atributo categórico e usará a codificação de categoria. + Se cada nó tiver o próprio valor exclusivo para uma propriedade inferida como um atributo de categoria, o Neptune ML vai retirar a propriedade do grafo de treinamento porque provavelmente é um ID que não seria informativo para aprendizado. + Se a propriedade contiver separadores válidos do Neptune, como ponto e vírgula (“;”), o Neptune ML só poderá tratar a propriedade como `MultiNumerical` ou `MultiCategorical`. + O Neptune ML primeiro tenta codificar os valores como atributos numéricos. Se isso for bem-sucedido, o Neptune ML usará codificação numérica para criar atributos de vetor numérico. + Caso contrário, o Neptune ML codificará os valores como multicategóricos. + Se o Neptune ML não puder inferir o tipo de dados dos valores de uma propriedade, o Neptune ML eliminará a propriedade do grafo de treinamento. # Editar um arquivo de configuração de dados de treinamento O processo de exportação do Neptune exporta dados do Neptune ML de um cluster de banco de dados do Neptune para um bucket do S3. Ele exporta nós e bordas separadamente para uma pasta `nodes/` e uma `edges/`. Ele também cria um arquivo de configuração de dados de treinamento JSON, denominado `training-data-configuration.json` por padrão. Esse arquivo contém informações sobre o esquema do grafo, os tipos de atributos, as operações de transformação e normalização de atributos e o atributo de destino para uma tarefa de classificação ou regressão. Pode haver casos em que você queira modificar o arquivo de configuração diretamente. Um desses casos é quando você deseja alterar a forma como os atributos são processados ou como o grafo é criado, sem precisar executar novamente a exportação toda vez que quiser modificar a especificação da tarefa de machine learning que você está resolvendo. **Como editar o arquivo de configuração de dados de treinamento** 1. **Baixe o arquivo na máquina local.** A menos que você tenha especificado um ou mais trabalhos nomeados no parâmetro `additionalParams/neptune_ml` transmitido para o processo de exportação, o arquivo terá o nome padrão, que é `training-data-configuration.json`. Você pode usar um comando AWS CLI como este para baixar o arquivo: ``` aws s3 cp \ s3://(your Amazon S3 bucket)/(path to your export folder)/training-data-configuration.json \ ./ ``` 1. **Edite o arquivo usando um editor de texto.** 1. **Faça upload do arquivo modificado.** Faça o upload do arquivo modificado de volta para o mesmo local no Amazon S3 do qual você o baixou, usando um 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 ``` # Exemplo de arquivo de configuração de dados de treinamento JSON Veja um exemplo de arquivo de configuração de dados de treinamento que descreve um grafo para uma tarefa de classificação de nós: ``` { "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" : [ ] ] } ``` # A estrutura dos arquivos de configuração de dados de treinamento JSON O arquivo de configuração de treinamento se refere aos arquivos CSV salvos pelo processo de exportação nas pastas `nodes/` e `edges/`. Cada arquivo em `nodes/` armazena informações sobre nós que têm o mesmo rótulo de nó do grafo de propriedades. Cada coluna em um arquivo de nó armazena o ID ou a propriedade do nó. A primeira linha do arquivo contém um cabeçalho que especifica o `~id` ou o nome da propriedade de cada coluna. Cada arquivo em `edges/` armazena informações sobre nós que têm o mesmo rótulo de borda do grafo de propriedades. Cada coluna em um arquivo de nó armazena o ID do nó de origem, o ID do nó de destino ou a propriedade da borda. A primeira linha do arquivo contém um cabeçalho que especifica `~from`, `~to` ou o nome da propriedade de cada coluna. O arquivo de configuração de dados de treinamento tem três elementos gerais: ``` { "version" : "v2.0", "query_engine" : "gremlin", "graph" : [ ... ] } ``` + `version`: (string) a versão do arquivo de configuração que está sendo usado. + `query_engine`: (string) a linguagem de consulta usada para exportar os dados do grafo. No momento, somente “gremlin” é válido. + `graph`: (matriz JSON) lista um ou mais objetos de configuração que contêm parâmetros de modelo para cada um dos nós e bordas que serão usados. Os objetos de configuração na matriz de grafos têm a estrutura descrita na próxima seção. ## Conteúdo de um objeto de configuração listado na matriz `graph` Um objeto de configuração na matriz `graph` pode conter três nós gerais: ``` { "edges" : [ ... ], "nodes" : [ ... ], "warnings" : [ ... ], } ``` + `edges`: (matriz de objetos JSON) cada objeto JSON especifica um conjunto de parâmetros para definir como uma borda no grafo será tratada durante o processamento e o treinamento de modelos. Isso só é usado com o mecanismo do Gremlin. + `nodes`: (matriz de objetos JSON) cada objeto JSON especifica um conjunto de parâmetros para definir como um nó no grafo será tratado durante o processamento e o treinamento de modelos. Isso só é usado com o mecanismo do Gremlin. + `warnings`: (matriz de objetos JSON) cada objeto contém um aviso gerado durante o processo de exportação de dados. ## Conteúdo de um objeto de configuração de borda listado na matriz `edges` Um objeto de configuração de borda listado em uma matriz `edges` pode conter os seguintes campos gerais: ``` { "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`**: uma string especificando o caminho para um arquivo CSV que armazena informações sobre bordas com o mesmo rótulo de grafo de propriedades. A primeira linha desse arquivo contém uma linha de cabeçalho de rótulos de coluna. Os dois primeiros rótulos de coluna são `~from` e `~to`. A primeira coluna (`~from`) armazena o ID do nó inicial da borda e a segunda (`~to`) armazena o ID do nó final da borda. Os rótulos das colunas restantes na linha do cabeçalho especificam, para cada coluna restante, o nome da propriedade da borda cujos valores foram exportados para essa coluna. + **`separator`**: uma string contendo o delimitador que separa as colunas nesse arquivo CSV. + **`source`**: uma matriz JSON contendo duas strings que especificam o nó inicial da borda. A primeira string contém o nome do cabeçalho da coluna na qual o ID do nó inicial está armazenado. A segunda string especifica o tipo de nó. + **`relation`**: uma matriz JSON contendo duas strings que especificam o tipo de relação da borda. A primeira string contém o nome do cabeçalho da coluna na qual o nome da relação (`relname`) está armazenado. A segunda string contém o prefixo para o nome da relação (`prefixname`). O tipo de relação completo consiste em duas strings combinadas, com um caractere de hífen entre elas, como: `prefixname-relname`. Se a primeira string estiver vazia, todas as bordas terão o mesmo tipo de relação, ou seja, a string `prefixname`. + **`dest`**: uma matriz JSON contendo duas strings que especificam o nó final da borda. A primeira string contém o nome do cabeçalho da coluna na qual o ID do nó está armazenado. A segunda string especifica o tipo de nó. + **`features`**: uma matriz JSON de objetos de atributos de valor de propriedade. Cada objeto de atributo de valor de propriedade contém os seguintes campos: + **atributo**: uma matriz JSON de três strings. A primeira string contém o nome do cabeçalho da coluna que contem o valor de propriedade. A segunda string contém o nome do atributo. A terceira string contém o tipo de atributo. + **norma**: (*opcional*) especifica um método de normalização a ser aplicado aos valores da propriedade. + **`labels`**: uma matriz JSON de objetos. Cada um dos objetos define um atributo de destino das bordas e especifica as proporções das bordas que as fases de treinamento e validação devem assumir. Cada objeto contém os seguintes campos: + **rótulo**: uma matriz JSON de duas strings. A primeira string contém o nome do cabeçalho da coluna que contem o valor de propriedade do atributo de destino. A segunda string especifica um dos seguintes tipos de tarefa de destino: + `"classification"`: uma tarefa de classificação de borda. Os valores das propriedades fornecidos na coluna identificada pela primeira string na matriz `label` são tratados como valores categóricos. Para uma tarefa de classificação de bordas, a primeira string na matriz `label` não pode estar vazia. + `"regression"`: uma tarefa de regressão de bordas. Os valores das propriedades fornecidos na coluna identificada pela primeira string na matriz `label` são tratados como valores numéricos. Para uma tarefa de regressão de bordas, a primeira string na matriz `label` não pode estar vazia. + `"link_prediction"`: uma tarefa de previsão de links. Nenhum valor de propriedade é obrigatório. Para uma tarefa de previsão de links, a primeira string na matriz `label` é ignorada. + **`split_rate`**: uma matriz JSON contendo três números entre zero e um que somam um e representam uma estimativa das proporções de nós que as fases de treinamento, validação e teste usarão, respectivamente. Esse campo ou `custom_split_filenames` podem ser definidos, mas não ambos. Veja [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate). + **`custom_split_filenames`**: um objeto JSON que especifica os nomes dos arquivos que definem as populações de treinamento, validação e teste. Esse campo ou `split_rate` podem ser definidos, mas não ambos. Consulte [train-validation-testProporções personalizadas](#machine-learning-custom-stages-splits) para obter mais informações. ## Conteúdo de um objeto de configuração de nó listado na matriz `nodes` Um objeto de configuração de nó listado em uma matriz `nodes` pode conter os seguintes 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`**: uma string especificando o caminho para um arquivo CSV que armazena informações sobre nó com o mesmo rótulo de grafo de propriedades. A primeira linha desse arquivo contém uma linha de cabeçalho de rótulos de coluna. O rótulo da primeira coluna é `~id`, e a primeira coluna (`~id`) armazena o ID do nó. Os rótulos das colunas restantes na linha do cabeçalho especificam, para cada coluna restante, o nome da propriedade do nó cujos valores foram exportados para essa coluna. + **`separator`**: uma string contendo o delimitador que separa as colunas nesse arquivo CSV. + **`node`**: uma matriz JSON contendo duas strings. A primeira string contém o nome do cabeçalho da coluna que armazena o nó IDs. A segunda string especifica o tipo de nó no grafo, que corresponde a um rótulo de grafo de propriedades do nó. + **`features`**: uma matriz JSON de objetos de atributos de nós. Consulte [Conteúdo de um objeto de atributo listado em uma matriz `features` para um nó ou uma borda](#machine-learning-graph-node-features-config). + **`labels`**: uma matriz JSON de objetos de rótulos de nós. Consulte [Conteúdo de um objeto de rótulo de nó listado em uma matriz `labels` de nós](#machine-learning-graph-node-labels-config). ## Conteúdo de um objeto de atributo listado em uma matriz `features` para um nó ou uma borda Um objeto de atributo de nó listado em uma matriz `features` de nó pode conter os seguintes campos gerais: + **`feature`**: uma matriz JSON de três strings. A primeira string contém o nome do cabeçalho da coluna que contem o valor de propriedade do atributo. A segunda string contém o nome do atributo. A terceira string contém o tipo de atributo. Os tipos de atributos válidos estão listados em [Valores possíveis do campo de tipo para recursos](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-feature-types). + **`norm`**: esse campo é obrigatório para atributos numéricos. Ele especifica um método de normalização a ser usado em valores numéricos. Os valores válidos são `"none"`, `"min-max"` e “padrão”. Para obter detalhes, consulte [O campo norma](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-norm). + **`language`**: o campo de idioma especifica o idioma usado nos valores das propriedades de texto. O uso depende do método de codificação de texto: + Para a codificação [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), esse campo é obrigatório e deve especificar um dos seguintes idiomas: + `en`   (inglês) + `zh`   (chinês) + `hi`   (hindi) + `es`   (espanhol) + `fr`   (francês) No entanto, `text_fasttext` não consegue lidar com mais de um idioma por vez. + Para a codificação [`text_sbert`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), esse campo não é usado, pois a codificação SBERT é multilíngue. + Para a codificação [`text_word2vec`](machine-learning-feature-encoding.md#machine-learning-word2vec-features), esse campo é opcional, pois `text_word2vec` só é compatível com inglês. Se presente, ele deve especificar o nome do modelo em inglês: ``` "language" : "en_core_web_lg" ``` + Para a codificação [`tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features), esse campo não é usado. + **`max_length`**: esse campo é opcional para atributos [`text_fasttext`](machine-learning-feature-encoding.md#machine-learning-fasttext-features), no qual ele especifica o número máximo de tokens em um atributo de texto de entrada que será codificado. O texto de entrada após `max_length` ser atingido é ignorado. Por exemplo, definir max\$1length como 128 indica que qualquer token após o 128º em uma sequência de texto será ignorado. + **`separator`**: esse campo é usado opcionalmente com os atributos `category`, `numerical` e `auto`. Ele especifica um caractere que pode ser usado para dividir o valor de uma propriedade em vários valores categóricos ou valores numéricos. Consulte [O campo separador](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-separator). + **`range`**: esse campo é obrigatório para atributos `bucket_numerical`. Ele especifica o intervalo de valores numéricos que devem ser divididos em buckets. Consulte [O campo intervalo](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-range). + **`bucket_cnt`**: esse campo é obrigatório para atributos `bucket_numerical`. Ele especifica o número de buckets nos quais o intervalo numérico definido pelo parâmetro `range` deve ser dividido: Consulte [Atributos numéricos de bucket no Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features). + **`slide_window_size`**: esse campo é usado opcionalmente com atributos `bucket_numerical` para atribuir valores a mais de um bucket: Consulte [O campo slide\$1window\$1size](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-slide_window_size). + **`imputer`**: esse campo é usado opcionalmente com atributos `numerical`, `bucket_numerical` e `datetime` para fornecer uma técnica de imputação a fim de preencher valores ausentes. As técnicas de imputação compatíveis são `"mean"`, `"median"` e `"most_frequent"`. Consulte [O campo estimador](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-imputer). + **`max_features`**: esse campo é usado opcionalmente pelos atributos `text_tfidf` para especificar o número máximo de termos a serem codificados. Consulte [O campo max\$1features](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-max_features). + **`min_df`**: esse campo é usado opcionalmente pelos atributos `text_tfidf` para especificar a frequência mínima de documentos de termos a serem codificados. Consulte [O campo min\$1df](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-min_df). + **`ngram_range`**: esse campo é usado opcionalmente pelos atributos `text_tfidf` para especificar um intervalo de números de palavras ou tokens a serem considerados como possíveis termos individuais a serem codificados. Consulte [O campo ngram\$1range](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-ngram_range). + **`datetime_parts`**: esse campo é usado opcionalmente pelos atributos `datetime` para especificar quais partes do valor de data e hora devem ser codificadas categoricamente: Consulte [O campo datetime\$1parts](machine-learning-neptune_ml-features.md#machine-learning-neptune_ml-features-datetime_parts). ## Conteúdo de um objeto de rótulo de nó listado em uma matriz `labels` de nós Um objeto de rótulo listado em uma matriz `labels` de nós define um atributo de destino de nó e especifica as proporções dos nós que as fases de treinamento, validação e teste usarão. Cada objeto pode conter os seguintes 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`**: uma matriz JSON contendo duas strings. A primeira string contém o nome do cabeçalho da coluna que armazena os valores de propriedade do atributo. A segunda string especifica o tipo de tarefa de destino, que pode ser: + `"classification"`: uma tarefa de classificação de nós. Os valores das propriedades na coluna especificada são usados para criar um atributo categórico. + `"regression"`: uma tarefa de regressão de nós. Os valores das propriedades na coluna especificada são usados para criar um atributo numérico. + **`split_rate`**: uma matriz JSON contendo três números entre zero e um que somam um e representam uma estimativa das proporções de nós que as fases de treinamento, validação e teste usarão, respectivamente. Consulte [split\$1rate](machine-learning-neptune_ml-targets.md#machine-learning-property-graph-neptune_ml-targets-split_rate). + **`custom_split_filenames`**: um objeto JSON que especifica os nomes dos arquivos que definem as populações de treinamento, validação e teste. Esse campo ou `split_rate` podem ser definidos, mas não ambos. Consulte [train-validation-testProporções personalizadas](#machine-learning-custom-stages-splits) para obter mais informações. + **`separator`**: uma string contendo o delimitador que separa os valores de atributos categóricos de uma tarefa de classificação. **nota** Se nenhum objeto de rótulo for fornecido para bordas e nós, a tarefa será automaticamente considerada como previsão de links, e as bordas serão divididas aleatoriamente em 90% para treinamento e 10% para validação. ## train-validation-testProporções personalizadas Por padrão, o parâmetro `split_rate` é usado pelo Neptune ML para dividir o grafo aleatoriamente em populações de treinamento, validação e teste usando as proporções definidas nesse parâmetro. Para ter um controle mais preciso sobre quais entidades são usadas nessas diferentes populações, podem ser criados arquivos que as definam explicitamente e, depois, o [arquivo de configuração de dados de treinamento pode ser editado](machine-learning-processing-training-config-file.md) para associar esses arquivos de indexação às populações. Esse mapeamento é especificado por um objeto JSON para a chave [`custom_split_filesnames`](#custom_split_filenames) no arquivo de configuração de treinamento. Se essa opção for usada, os nomes dos arquivos deverão ser fornecidos para as chaves `train` e `validation` e é opcional para a chave `test`. A formatação desses arquivos deve corresponder ao [formato de dados do Gremlin](bulk-load-tutorial-format-gremlin.md#bulk-load-tutorial-format-gremlin-systemheaders). Especificamente, para tarefas em nível de nó, cada arquivo deve conter uma coluna com o `~id` cabeçalho que lista o nó e IDs, para tarefas em nível de borda, os arquivos devem especificar `~from` e `~to` indicar os nós de origem e destino das bordas, respectivamente. Esses arquivos precisam ser colocados no mesmo local do Amazon S3 que os dados exportados que são usados para processamento de dados (consulte: [`outputS3Path`](export-parameters.md#export-parameters-outputS3Path)). Para tarefas de classificação ou regressão de propriedades, esses arquivos podem definir os rótulos para a tarefa de machine learning. Nesse caso, os arquivos precisam ter uma coluna de propriedades com o mesmo nome de cabeçalho [definido no arquivo de configuração de dados de treinamento](#machine-learning-graph-node-labels-config). Se os rótulos de propriedades forem definidos nos arquivos de nó e borda exportados e nos arquivos de divisão personalizada, a prioridade será fornecida aos arquivos de divisão personalizada.