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á.
# Usar a ferramenta neptune-export ou o serviço Neptune-Export para exportar dados do Neptune para o Neptune ML
O Neptune ML exige que você forneça dados de treinamento para a [Deep Graph Library (DGL](https://www.dgl.ai/)) criar e avaliar modelos.
É possível exportar dados do Neptune usando o [serviço Neptune-Export](export-service.md) ou o [utilitário `neptune-export`](export-utility.md). Tanto o serviço quanto a ferramenta de linha de comando publicam dados no Amazon Simple Storage Service (Amazon S3) em um formato CSV, criptografados usando criptografia no lado do servidor Amazon S3 (`SSE-S3`). Consulte [Arquivos exportados pelo Neptune-Export e `neptune-export`](exported-files.md).
Além disso, quando você configura uma exportação de dados de treinamento para o Neptune ML, o trabalho de exportação cria e publica um arquivo de configuração de treinamento de modelo criptografado junto com os dados exportados. Por padrão, esse arquivo é denominado `training-data-configuration.json`.
# Exemplos de uso do serviço Neptune-Export para exportar dados de treinamento do Neptune ML
Essa solicitação exporta dados de treinamento do grafo de propriedades para uma tarefa de classificação de nós:
```
curl \
(your NeptuneExportApiUri) \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification"
}
]
}
}
}'
```
Essa solicitação exporta dados de treinamento do RDF para uma tarefa de classificação de nós:
```
curl \
(your NeptuneExportApiUri) \
-X POST \
-H 'Content-Type: application/json' \
-d '{
"command": "export-rdf",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
"type": "classification"
}
]
}
}
}'
```
# Campos a serem definidos no objeto de parâmetro ao exportar dados de treinamento
O objeto `params` em uma solicitação de exportação pode conter vários campos, conforme descrito na [documentação de `params`](export-params-fields.md). Veja os mais relevantes para exportar dados de treinamento de machine learning:
****
+ **`endpoint`**: use `endpoint` para especificar um endpoint de uma instância do Neptune no cluster de banco de dados que o processo de exportação pode consultar para extrair dados.
+ **`profile`**: o campo `profile` no objeto `params` deve ser definido como **`neptune-ml`**.
Isso faz com que o processo de exportação formate os dados exportados adequadamente para o treinamento de modelos do Neptune ML, em formato CSV para dados de grafos de propriedades ou como N-Triples para dados do RDF. Isso também faz com que um arquivo `training-data-configuration.json` seja criado e gravado no mesmo local do Amazon S3 que os dados de treinamento exportados.
+ **`cloneCluster`**: se definido como `true`, o processo de exportação clona o cluster de banco de dados, exporta do clone e, depois, exclui o clone ao terminar.
+ **`useIamAuth`**: se o cluster de banco de dados tiver a [autenticação do IAM](iam-auth-enable.md) habilitada, você deverá incluir esse campo definido como `true`.
O processo de exportação também fornece várias maneiras de filtrar os dados exportados (consulte [estes exemplos](export-filtering-examples.md)).
# Usar o objeto additionalParams para ajustar a exportação de informações de treinamento de modelos
O objeto `additionalParams` contém campos que você pode usar para especificar rótulos e atributos de classe de machine learning para fins de treinamento e orientar a criação de um arquivo de configuração de dados de treinamento.
O processo de exportação não pode inferir automaticamente quais propriedades do nó e da borda devem ser os rótulos das classes de machine learning para servir como exemplos para fins de treinamento. Ele também não pode inferir automaticamente a melhor codificação de atributos para propriedades numéricas, categóricas e de texto, portanto, você precisa fornecer dicas usando campos no objeto `additionalParams` para especificar esses itens ou substituir a codificação padrão.
Para dados de grafos de propriedades, a estrutura geral de `additionalParams` em uma solicitação de exportação pode ter a seguinte aparência:
```
{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
}
}
}
```
Para dados do RDF, a estrutura geral pode ter a seguinte aparência:
```
{
"command": "export-rdf",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [ (an array of node and edge class label targets) ]
}
}
}
```
Também é possível fornecer várias configurações de exportação usando o campo `jobs`:
```
{
"command": "export-pg",
"outputS3Path": "s3://(your Amazon S3 bucket)/neptune-export",
"params": {
"endpoint": "(your Neptune endpoint DNS name)",
"profile": "neptune_ml"
},
"additionalParams" : {
"neptune_ml" : {
"version": "v2.0",
"jobs": [
{
"name" : "(training data configuration name)",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
},
{
"name" : "(another training data configuration name)",
"targets": [ (an array of node and edge class label targets) ],
"features": [ (an array of node feature hints) ]
}
]
}
}
}
```
# Elementos de nível superior no campo neptune\$1ml em additionalParams
## O elemento versão em neptune\$1ml
Especifica a versão da configuração dos dados de treinamento a ser gerada.
(*Opcional*), *Tipo*: string, *Padrão*: “v2.0”.
Se você incluir `version`, defina-o como `v2.0`.
## O campo tarefas em neptune\$1ml
Contém uma matriz de objetos de configuração de dados de treinamento, cada um definindo um trabalho de processamento de dados e contendo:
+ **`name`**: o nome da configuração dos dados de treinamento a ser criada.
Por exemplo, uma configuração de dados de treinamento com o nome “job-number-1" gera um arquivo de configuração de dados de treinamento chamado `job-number-1.json`.
+ **`targets`**: uma matriz JSON de destinos de rótulos de classes de nós e bordas que representam os rótulos de classes de machine learning para fins de treinamento. Consulte [O campo de destinos em um objeto neptune\$1ml](machine-learning-neptune_ml-targets.md).
+ **`features`**: uma matriz JSON de atributos de propriedades de nós. Consulte [O campo de recursos no neptune\$1ml](machine-learning-neptune_ml-features.md).
# O campo de destinos em um objeto neptune\$1ml
O campo `targets` em uma configuração de exportação de dados de treinamento JSON contém uma matriz de objetos de destino que especificam uma tarefa de treinamento e os rótulos das classes de machine learning para treinar essa tarefa. O conteúdo dos objetos de destino varia dependendo se você está treinando com dados de grafos de propriedades ou dados do RDF.
Para tarefas de classificação e regressão de nós do grafo de propriedades, os objetos de destino na matriz podem ter a seguinte aparência:
```
{
"node": "(node property-graph label)",
"property": "(property name)",
"type" : "(used to specify classification or regression)",
"split_rate": [0.8,0.2,0.0],
"separator": ","
}
```
Para tarefas de classificação de bordas, regressão ou previsão de links de grafos de propriedades, elas podem ter a seguinte aparência:
```
{
"edge": "(edge property-graph label)",
"property": "(property name)",
"type" : "(used to specify classification, regression or link_prediction)",
"split_rate": [0.8,0.2,0.0],
"separator": ","
}
```
Para tarefas de classificação e regressão do RDF, os objetos de destino na matriz podem ter a seguinte aparência:
```
{
"node": "(node type of an RDF node)",
"predicate": "(predicate IRI)",
"type" : "(used to specify classification or regression)",
"split_rate": [0.8,0.2,0.0]
}
```
Para tarefas de previsão de links do RDF, os objetos de destino na matriz podem ter a seguinte aparência:
```
{
"subject": "(source node type of an edge)",
"predicate": "(relation type of an edge)",
"object": "(destination node type of an edge)",
"type" : "link_prediction",
"split_rate": [0.8,0.2,0.0]
}
```
Os objetos de destino podem conter os seguintes campos:
**Contents**
+ [Campos de destino do grafo de propriedades](#machine-learning-property-graph-neptune_ml-targets)
+ [nó](#machine-learning-property-graph-neptune_ml-targets-node)
+ [borda](#machine-learning-property-graph-neptune_ml-targets-edge)
+ [property](#machine-learning-property-graph-neptune_ml-targets-property)
+ [type](#machine-learning-property-graph-neptune_ml-targets-type)
+ [split\$1rate](#machine-learning-property-graph-neptune_ml-targets-split_rate)
+ [separador](#machine-learning-property-graph-neptune_ml-targets-separator)
+ [Campos de destino do RDF](#machine-learning-RDF-neptune_ml-targets)
+ [nó](#machine-learning-RDF-neptune_ml-targets-node)
+ [subject](#machine-learning-RDF-neptune_ml-targets-subject)
+ [predicado](#machine-learning-RDF-neptune_ml-targets-predicate)
+ [objeto](#machine-learning-RDF-neptune_ml-targets-object)
+ [type](#machine-learning-RDF-neptune_ml-targets-type)
+ [split\$1rate](#machine-learning-RDF-neptune_ml-targets-split_rate)
## Campos em um objeto de destino do grafo de propriedades
### O campo nó (vértice) em um objeto de destino
O rótulo do grafo de propriedades de um nó de destino (vértice). Um objeto de destino deve conter um elemento `node` ou `edge`, mas não ambos.
O `node` pode assumir um único valor, como este:
```
"node": "Movie"
```
Ou, no caso de um vértice com vários rótulos, ele pode usar uma série de valores, como esta:
```
"node": ["Content", "Movie"]
```
### O campo borda em um objeto de destino do grafo de propriedades
Especifica uma borda de destino pelos rótulos de nó inicial, o próprio rótulo e os rótulos de nó final. Um objeto de destino deve conter um elemento `edge` ou `node`, mas não ambos.
O valor de um campo `edge` é uma matriz JSON de três strings que representam os rótulos do grafo de propriedades do nó inicial, o rótulo do grafo de propriedades da própria borda e os rótulos do grafo de propriedades do nó final, desta forma:
```
"edge": ["Person_A", "knows", "Person_B"]
```
Se o nó and/or final do nó inicial tiver vários rótulos, coloque-os em uma matriz, como esta:
```
"edge": [ ["Admin", Person_A"], "knows", ["Admin", "Person_B"] ]
```
### O campo propriedade em um objeto de destino do grafo de propriedades
Especifica uma propriedade do vértice ou da borda de destino, desta forma:
```
"property" : "rating"
```
Esse campo é obrigatório, exceto quando a tarefa de destino é a previsão de links.
### O campo tipo em um objeto de destino do grafo de propriedades
Indica o tipo de tarefa de destino a ser realizada no `node` ou na `edge`, desta forma:
```
"type" : "regression"
```
Os tipos de tarefa compatíveis com nós são:
+ `classification`
+ `regression`
Os tipos de tarefa compatíveis com bordas são:
+ `classification`
+ `regression`
+ `link_prediction`
Este campo é obrigatório.
### O campo split\$1rate em um objeto de destino do grafo de propriedades
(*Opcional*) Uma estimativa das proporções de nós ou bordas que as fases de treinamento, validação e teste usarão, respectivamente. Essas proporções são representadas por uma matriz JSON de três números entre zero e um que somam um:
```
"split_rate": [0.7, 0.1, 0.2]
```
Se você não fornecer o campo opcional `split_rate`, o valor estimado padrão será `[0.9, 0.1, 0.0]` para tarefas de classificação e regressão e `[0.9,0.05, 0.05]` para tarefas de previsão de links.
### O campo separador em um objeto de destino do grafo de propriedades
(*Opcional*) Usado com uma tarefa de classificação.
O campo `separator` especifica um caractere usado para dividir um valor de propriedade de destino em vários valores categóricos quando é usado para armazenar vários valores de categoria em uma string. Por exemplo:
```
"separator": "|"
```
A presença de um campo `separator` indica que a tarefa é de classificação com vários destinos.
## Campos em um objeto de destino do RDF
### O campo nó em um objeto de destino do RDF
Define o tipo dos nós de destino. Usado com tarefas de classificação ou regressão de nós. O tipo de um nó no RDF é definido por:
```
node_id, , node_type
```
Um `node` do RDF pode assumir um único valor, como este:
```
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```
### O campo assunto em um objeto de destino do RDF
Para tarefas de previsão de links, `subject` define o tipo de nó de origem das bordas de destino.
```
"subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director"
```
**nota**
Para tarefas de previsão de links, `subject` deve ser usado junto com `predicate` e `object`. Se algum desses três não for fornecido, todas as bordas serão tratadas como o destino do treinamento.
### O campo predicado em um objeto de destino do RDF
Para tarefas de classificação e regressão de nós, `predicate` define quais dados literais são usados como o atributo de um nó de destino.
```
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre"
```
**nota**
Se os nós de destino tiverem apenas um predicado que defina o atributo do nó de destino, o campo `predicate` poderá ser omitido.
Para tarefas de previsão de links, `predicate` define o tipo de relação das bordas de destino.
```
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/direct"
```
**nota**
Para tarefas de previsão de links, `predicate` deve ser usado junto com `subject` e `object`. Se algum desses três não for fornecido, todas as bordas serão tratadas como o destino do treinamento.
### O campo objeto em um objeto de destino do RDF
Para tarefas de previsão de links, `object` define o tipo de nó de destino das bordas de destino:
```
"object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie"
```
**nota**
Para tarefas de previsão de links, `object` deve ser usado junto com `subject` e `predicate`. Se algum desses três não for fornecido, todas as bordas serão tratadas como o destino do treinamento.
### O campo tipo em um objeto de destino do RDF
Indica o tipo de tarefa de destino a ser realizada, desta forma:
```
"type" : "regression"
```
Os tipos de tarefa compatíveis com dados do RDF são:
+ `link_prediction`
+ `classification`
+ `regression`
Este campo é obrigatório.
### O campo `split_rate` em um objeto de destino do grafo de propriedades
(*Opcional*) Uma estimativa das proporções de nós ou bordas que as fases de treinamento, validação e teste usarão, respectivamente. Essas proporções são representadas por uma matriz JSON de três números entre zero e um que somam um:
```
"split_rate": [0.7, 0.1, 0.2]
```
Se você não fornecer o campo `split_rate` opcional, o valor estimado padrão será `[0.9, 0.1, 0.0]`.
# O campo de recursos no neptune\$1ml
Os valores das propriedades e os literais do RDF 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, conforme descrito em [Codificação de atributos no Neptune ML](machine-learning-feature-encoding.md).
Para conjuntos de dados de grafos de propriedades, o processo de exportação infere automaticamente atributos `auto` para propriedades de string e propriedades numéricas que contêm vários valores. Para propriedades numéricas que contenham valores únicos, ele infere atributos `numerical`. Para propriedades de data, ele infere atributos `datetime`.
Se você quiser substituir uma especificação de recurso inferida automaticamente ou adicionar uma especificação numérica de bucket, TF-IDF ou SBERT para uma propriedade FastText, você pode controlar a codificação do recurso usando o campo features.
**nota**
É possível usar o campo `features` somente para controlar as especificações do atributo para dados de grafos de propriedades, não para dados do RDF.
Para texto de formato livre, o Neptune ML pode usar vários modelos diferentes para converter a sequência de tokens em um valor de propriedade de string em um vetor de valor real de tamanho fixo:
+ [`text_fasttext`](machine-learning-feature-encoding.md#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-feature-encoding.md#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-feature-encoding.md#machine-learning-word2vec-features): usa 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-feature-encoding.md#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.
O campo `features` contém uma matriz JSON de atributos de propriedade do nó. Os objetos na matriz podem conter os seguintes campos:
**Contents**
+ [nó](#machine-learning-neptune_ml-features-node)
+ [borda](#machine-learning-neptune_ml-features-edge)
+ [property](#machine-learning-neptune_ml-features-property)
+ [type](#machine-learning-neptune_ml-feature-types)
+ [norma](#machine-learning-neptune_ml-features-norm)
+ [idioma](#machine-learning-neptune_ml-features-language)
+ [max\$1length](#machine-learning-neptune_ml-features-max_length)
+ [separador](#machine-learning-neptune_ml-features-separator)
+ [intervalo](#machine-learning-neptune_ml-features-range)
+ [bucket\$1cnt](#machine-learning-neptune_ml-features-bucket_cnt)
+ [slide\$1window\$1size](#machine-learning-neptune_ml-features-slide_window_size)
+ [estimador](#machine-learning-neptune_ml-features-imputer)
+ [max\$1features](#machine-learning-neptune_ml-features-max_features)
+ [min\$1df](#machine-learning-neptune_ml-features-min_df)
+ [ngram\$1range](#machine-learning-neptune_ml-features-ngram_range)
+ [datetime\$1parts](#machine-learning-neptune_ml-features-datetime_parts)
## O campo nó em recursos
O campo `node` especifica um rótulo de grafo de propriedades de um vértice de atributo. Por exemplo:
```
"node": "Person"
```
Se um vértice tiver vários rótulos, use uma matriz para contê-los. Por exemplo:
```
"node": ["Admin", "Person"]
```
## O campo borda em recursos
O campo `edge` especifica o tipo de uma borda de atributo. Um tipo de borda consiste em uma matriz que contém os rótulos do grafo de propriedades do vértice de origem, o rótulo do grafo de propriedades da borda e os rótulos do grafo de propriedades do vértice de destino. É necessário fornecer todos os três valores ao especificar um atributo de borda. Por exemplo:
```
"edge": ["User", "reviewed", "Movie"]
```
Se um vértice de origem ou destino de um tipo de borda tiver vários rótulos, use outra matriz para contê-los. Por exemplo:
```
"edge": [["Admin", "Person"]. "edited", "Post"]
```
## O campo propriedade em recursos
Use o parâmetro propriedade para especificar uma propriedade do vértice identificado pelo parâmetro `node`. Por exemplo:
```
"property" : "age"
```
## Valores possíveis do campo de tipo para recursos
O parâmetro `type` especifica o tipo de atributo que está sendo definido. Por exemplo:
```
"type": "bucket_numerical"
```
**Valores possíveis do parâmetro `type`**
+ **`"auto"`**: especifica que o Neptune ML deve detectar automaticamente o tipo de propriedade e aplicar uma codificação de atributo adequada. Um atributo `auto` também pode ter um campo `separator` opcional.
Consulte [Codificação de atributos automáticos no Neptune ML](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
+ **`"category"`**: essa codificação de atributo representa um valor de propriedade como uma das várias categorias. Em outras palavras, o atributo pode assumir um ou mais valores distintos. Um atributo `category` também pode ter um campo `separator` opcional.
Consulte [Atributos categóricos no Neptune ML](machine-learning-feature-encoding.md#machine-learning-categorical-features).
+ **`"numerical"`**: essa codificação de atributo representa valores de propriedade numérica como números em um intervalo contínuo em que “maior que” e “menor que” têm significado.
Um atributo `numerical` também pode ter campos `norm`, `imputer` e `separator` opcionais.
Consulte [Atributos numéricos no Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
+ **`"bucket_numerical"`**: essa codificação de atributos divide os valores de propriedade numérica em um conjunto de *buckets* ou categorias.
Por exemplo, é possível codificar a idade das pessoas em quatro buckets: crianças (de 0 a 20 anos), jovens adultos (de 20 a 40 anos), meia idade (de 40 a 60 anos) e idosos (de 60 anos em diante).
Um `bucket_numerical` recurso requer um `bucket_cnt` campo `range` e um e, opcionalmente, também pode incluir um `imputer` and/or `slide_window_size` campo.
Consulte [Atributos numéricos de bucket no Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
+ **`"datetime"`**: essa codificação de atributos representa um valor de propriedade de data e hora como uma matriz desses atributos categóricos: ano, mês, dia da semana e hora.
Uma ou mais dessas quatro categorias podem ser eliminadas usando o parâmetro `datetime_parts`.
Consulte [Atributos de data e hora no Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).
+ **`"text_fasttext"`**: essa codificação de atributos converte valores de propriedade que consistem em frases ou texto de formato livre em vetores numéricos usando modelos [fastText](https://fasttext.cc/). Ela é compatível com cinco idiomas, a saber, inglês (`en`), chinês (`zh`), hindi (`hi`), espanhol (`es`) e francês (`fr`). Para valores de propriedade de texto em qualquer um desses cinco idiomas, `text_fasttext` é a codificação recomendada. No entanto, ela não consegue lidar com casos em que a mesma frase contenha palavras em mais de um idioma.
Para outros idiomas além dos compatíveis com a fastText, use a codificação `text_sbert`.
Se você tiver muitas strings de texto de valor de propriedade maiores que, digamos, 120 tokens, use o campo `max_length` para limitar o número de tokens em cada string codificada por `"text_fasttext"`.
Consulte [Codificação *fastText* de valores de propriedades de texto no Neptune ML](machine-learning-feature-encoding.md#machine-learning-fasttext-features).
+ **`"text_sbert"`**: essa codificação converte valores de propriedade de texto em vetores numéricos usando modelos [Sentence BERT](https://www.sbert.net/docs/pretrained_models.html#sentence-embedding-models) (SBERT). O Neptune é compatível com dois métodos SBERT, ou seja, `text_sbert128`, que será o padrão se você apenas especificar `text_sbert` e `text_sbert512`. A diferença entre eles é o número máximo de tokens em uma propriedade de texto codificada. A codificação `text_sbert128` codifica apenas os primeiros 128 tokens, enquanto `text_sbert512` codifica até 512 tokens. Como resultado, o uso de `text_sbert512` pode exigir mais tempo de processamento do que `text_sbert128`. Os dois métodos são mais lentos do que `text_fasttext`.
Os métodos `text_sbert*` são compatíveis com vários idiomas e podem codificar uma frase que contenha mais de um idioma.
Consulte [Codificação Sentence BERT (SBERT) de atributos de texto no Neptune ML](machine-learning-feature-encoding.md#machine-learning-sbert-features).
+ **`"text_word2vec"`**: essa codificação converte valores de propriedade de texto em vetores numéricos usando algoritmos [Word2Vec](https://wikipedia.org/wiki/Word2vec). Ela aceita apenas inglês.
Consulte [Codificação Word2Vec de atributos de texto no Neptune ML](machine-learning-feature-encoding.md#machine-learning-word2vec-features).
+ **`"text_tfidf"`**: essa codificação converte valores de propriedade de texto em vetores numéricos usando um vetorizador de [frequência de termo – frequência inversa de documento](https://wikipedia.org/wiki/Tf-idf) (TF-IDF).
Você define os parâmetros de uma codificação de atributos `text_tfidf` usando os campos `ngram_range`, `min_df` e `max_features`.
Consulte [Codificação TF-IDF de atributos de texto no Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
+ **`"none"`**: usar o tipo `none` faz com que nenhuma codificação de atributos ocorra. Em vez disso, os valores brutos das propriedades são analisados e salvos.
Use `none` somente se você planeja realizar a própria codificação de atributos personalizados como parte do treinamento de modelos personalizados.
## O campo norma
Esse campo é obrigatório para atributos numéricos. Ele especifica um método de normalização a ser usado em valores numéricos:
```
"norm": "min-max"
```
Os seguintes métodos de normalização são compatíveis:
+ **“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.
+ **“nenhum”**: não normalize os valores numéricos durante a codificação.
Consulte [Atributos numéricos no Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features).
## O campo idioma
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)
+ 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 [`text_tfidf`](machine-learning-feature-encoding.md#machine-learning-tfidf-features), esse campo não é usado.
## O campo max\$1length
O campo `max_length` é opcional para atributos `text_fasttext`, no qual ele especifica o número máximo de tokens em um atributo de texto de entrada que será codificado. Texto de entrada maior do que `max_length` é truncado. Por exemplo, definir max\$1length como 128 indica que qualquer token após o 128º em uma sequência de texto será ignorado:
```
"max_length": 128
```
## O campo separador
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:
```
"separator": ";"
```
Use o campo `separator` somente quando a propriedade armazena vários valores delimitados em uma única string, como `"Actor;Director"` ou `"0.1;0.2"`.
Consulte [Atributos categóricos](machine-learning-feature-encoding.md#machine-learning-categorical-features), [Atributos numéricos](machine-learning-feature-encoding.md#machine-learning-numerical-features) e [Codificação automática](machine-learning-feature-encoding.md#machine-learning-auto-encoding).
## O campo intervalo
Esse campo é obrigatório para atributos `bucket_numerical`. Ele especifica o intervalo de valores numéricos que devem ser divididos em buckets, no formato `[lower-bound, upper-bound]`:
```
"range" : [20, 100]
```
Se o valor de uma propriedade for menor que o limite inferior, ele será atribuído ao primeiro bucket ou, se for maior que o limite superior, será atribuído ao último bucket.
Consulte [Atributos numéricos de bucket no Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## O campo bucket\$1cnt
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:
```
"bucket_cnt": 10
```
Consulte [Atributos numéricos de bucket no Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## O campo slide\$1window\$1size
Esse campo é usado opcionalmente com atributos `bucket_numerical` para atribuir valores a mais de um bucket:
```
"slide_window_size": 5
```
Uma janela de controle deslizante funciona da seguinte forma: o Neptune ML considera o tamanho da janela **`s`** e transforma cada valor numérico **`v`** de uma propriedade em um intervalo de ` v - s/2 ` a ` v + s/2 `. O valor é então atribuído a cada bucket ao qual o intervalo se sobrepõe.
Consulte [Atributos numéricos de bucket no Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## O campo estimador
Esse campo é usado opcionalmente com atributos `numerical` e `bucket_numerical` para fornecer uma técnica de imputação a fim de preencher valores ausentes:
```
"imputer": "mean"
```
As técnicas de imputação compatíveis são:
+ `"mean"`
+ `"median"`
+ `"most-frequent"`
Se você não incluir o parâmetro estimador, o pré-processamento de dados será interrompido e encerrado quando um valor ausente for encontrado.
Consulte [Atributos numéricos no Neptune ML](machine-learning-feature-encoding.md#machine-learning-numerical-features) e [Atributos numéricos de bucket no Neptune ML](machine-learning-feature-encoding.md#machine-learning-bucket_numerical-features).
## O campo max\$1features
Esse campo é usado opcionalmente pelos atributos `text_tfidf` para especificar o número máximo de termos a serem codificados:
```
"max_features": 100
```
Uma configuração de cem faz com que o vetorizador TF-IDF codifique somente os cem termos mais comuns. O valor padrão, se você não incluir `max_features` será cinco mil.
Consulte [Codificação TF-IDF de atributos de texto no Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## O campo min\$1df
Esse campo é usado opcionalmente pelos atributos `text_tfidf` para especificar a frequência mínima de documentos de termos a serem codificados:
```
"min_df": 5
```
Uma configuração de cinco indica que um termo deve aparecer em pelo menos cinco valores de propriedade diferentes para ser codificado.
O valor padrão se você não incluir o parâmetro `min_df` será `2`.
Consulte [Codificação TF-IDF de atributos de texto no Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## O campo ngram\$1range
Esse campo é usado opcionalmente pelos atributos `text_tfidf` para especificar quais sequências de tamanho de palavras ou tokens devem ser consideradas como possíveis termos individuais a serem codificados:
```
"ngram_range": [2, 4]
```
O valor `[2, 4]` especifica que sequências de dois, três e quatro palavras devem ser consideradas como possíveis termos individuais.
O padrão, se você não definir explicitamente `ngram_range` será `[1, 1]`, o que significa que somente palavras ou tokens individuais são considerados termos a serem codificados.
Consulte [Codificação TF-IDF de atributos de texto no Neptune ML](machine-learning-feature-encoding.md#machine-learning-tfidf-features).
## O campo datetime\$1parts
Esse campo é usado opcionalmente pelos atributos `datetime` para especificar quais partes do valor de data e hora devem ser codificadas categoricamente:
```
"datetime_parts": ["weekday", "hour"]
```
Se você não incluir `datetime_parts`, por padrão, o Neptune ML codificará as partes de ano, mês, dia da semana e hora do valor de data e hora. O valor `["weekday", "hour"]` indica que somente os valores do dia da semana e da hora da data e hora devem ser codificados categoricamente no atributo.
Se uma das partes não tiver mais de um valor exclusivo no conjunto de treinamento, ela não será codificada.
Consulte [Atributos de data e hora no Neptune ML](machine-learning-feature-encoding.md#machine-learning-datetime-features).
# Exemplos de uso de parâmetros em additionalParams para ajustar a configuração de treinamento de modelo
Os exemplos a seguir demonstram como utilizar o recurso “additionalParams” em grafos de propriedades e modelos de dados RDF para configurar vários aspectos do processo de treinamento de modelos para uma aplicação do Neptune ML. Os exemplos abrangem uma ampla variedade de funcionalidades, incluindo a especificação de taxas de divisão padrão para training/validation/test dados, a definição de tarefas de classificação de nós, regressão e previsão de links, bem como a configuração de diferentes tipos de recursos, como compartimentos numéricos, incorporações de texto, data e hora e dados categóricos. Essas configurações detalhadas permitem que você adapte o pipeline de machine learning aos seus requisitos específicos de dados e modelagem, liberando todo o potencial dos recursos do Neptune ML.
**Contents**
+ [
## Exemplos de grafo de propriedades usando additionalParams
](#machine-learning-property-graph-additionalParams-examples)
+ [
### Especificar uma taxa de divisão padrão para a configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-default-split-rate-example)
+ [
### Especificar uma tarefa de classificação de nós para configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-node-classification-example)
+ [
### Especificar uma tarefa de classificação de nós de várias classes para configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-multi-class-example)
+ [
### Especificar uma tarefa de regressão de nós para configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-node-regression-example)
+ [
### Especificar uma tarefa de classificação de bordas para configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-edge-classification-example)
+ [
### Especificar uma tarefa de classificação de bordas de várias classes para configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-multi-edge-classification-example)
+ [
### Especificar uma regressão de bordas para configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-edge-regression-example)
+ [
### Especificar uma tarefa de previsão de links para configuração de treinamento de modelos
](#machine-learning-property-graph-additionalParams-link-prediction-example)
+ [
### Especificar um atributo de bucket numérico
](#machine-learning-property-graph-additionalParams-numeric-bucket-example)
+ [
### Especificar um atributo `Word2Vec`
](#machine-learning-property-graph-additionalParams-word2vec-example)
+ [
### Especificar um atributo `FastText`
](#machine-learning-property-graph-additionalParams-fasttext-example)
+ [
### Especificar um atributo `Sentence BERT`
](#machine-learning-property-graph-additionalParams-sbert-example)
+ [
### Especificar um atributo `TF-IDF`
](#machine-learning-property-graph-additionalParams-tf-idf-example)
+ [
### Especificar um atributo `datetime`
](#machine-learning-property-graph-additionalParams-datetime-example)
+ [
### Especificar um atributo `category`
](#machine-learning-property-graph-additionalParams-category-example)
+ [
### Especificar um atributo `numerical`
](#machine-learning-property-graph-additionalParams-numerical-example)
+ [
### Especificar um atributo `auto`
](#machine-learning-property-graph-additionalParams-auto-example)
+ [
## Exemplos do RDF usando `additionalParams`
](#machine-learning-RDF-additionalParams-examples)
+ [
### Especificar uma taxa de divisão padrão para a configuração de treinamento de modelos
](#machine-learning-RDF-additionalParams-default-split-rate-example)
+ [
### Especificar uma tarefa de classificação de nós para configuração de treinamento de modelos
](#machine-learning-RDF-additionalParams-node-classification-example)
+ [
### Especificar uma tarefa de regressão de nós para configuração de treinamento de modelos
](#machine-learning-RDF-additionalParams-node-regression-example)
+ [
### Especificar uma tarefa de previsão de links para bordas específicas
](#machine-learning-RDF-additionalParams-link-prediction-example)
+ [
### Especificar uma tarefa de previsão de links para todas as bordas
](#machine-learning-RDF-additionalParams-link-prediction-example)
## Exemplos de grafo de propriedades usando additionalParams
### Especificar uma taxa de divisão padrão para a configuração de treinamento de modelos
No exemplo a seguir, o parâmetro `split_rate` define a taxa de divisão padrão para o treinamento de modelos. Se nenhuma taxa de divisão padrão for especificada, o treinamento usará um valor de [0,9, 0,1, 0,0]. É possível substituir o valor padrão por destino especificando uma `split_rate` para cada destino.
No seguinte exemplo, o campo `default split_rate` indica que uma taxa de divisão de `[0.7,0.1,0.2]` deve ser usada, a menos que seja substituída por destino:”
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"split_rate": [0.7,0.1,0.2],
"targets": [
(...)
],
"features": [
(...)
]
}
}
```
### Especificar uma tarefa de classificação de nós para configuração de treinamento de modelos
Para indicar qual propriedade de nó contém exemplos rotulados para fins de treinamento, adicione um elemento de classificação de nós à matriz `targets`, usando `"type" : "classification"`. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
No exemplo a seguir, o destino `node` indica que a propriedade `genre` de cada nó `Movie` deve ser tratada como um rótulo de classe de nó. O valor `split_rate` substitui a taxa de divisão padrão:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification",
"split_rate": [0.7,0.1,0.2]
}
],
"features": [
(...)
]
}
}
```
### Especificar uma tarefa de classificação de nós de várias classes para configuração de treinamento de modelos
Para indicar qual propriedade de nó contém vários exemplos rotulados para fins de treinamento, adicione um elemento de classificação de nós à matriz de destinos, usando `"type" : "classification"` e `separator` para especificar um caractere que pode ser usado para dividir o valor de uma propriedade de destino em vários valores categóricos. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
No exemplo a seguir, o destino `node` indica que a propriedade `genre` de cada nó `Movie` deve ser tratada como um rótulo de classe de nó. O campo `separator` indica que cada propriedade de gênero contém vários valores separados por ponto e vírgula:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "genre",
"type": "classification",
"separator": ";"
}
],
"features": [
(...)
]
}
}
```
### Especificar uma tarefa de regressão de nós para configuração de treinamento de modelos
Para indicar qual propriedade de nó contém regressões rotuladas para fins de treinamento, adicione um elemento de regressão de nós à matriz de destinos, usando `"type" : "regression"`. Adicione um campo split\$1rate se quiser substituir a taxa de divisão padrão.
O seguinte destino `node` indica que a propriedade `rating` de cada nó `Movie` deve ser tratada como um rótulo de regressão de nós:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "Movie",
"property": "rating",
"type" : "regression",
"split_rate": [0.7,0.1,0.2]
}
],
"features": [
...
]
}
}
```
### Especificar uma tarefa de classificação de bordas para configuração de treinamento de modelos
Para indicar qual propriedade de borda contém exemplos rotulados para fins de treinamento, adicione um elemento de borda à matriz `targets`, usando `"type" : "regression"`. Adicione um campo split\$1rate se quiser substituir a taxa de divisão padrão.
O seguinte destino `edge` indica que a propriedade `metAtLocation` de cada borda `knows` deve ser tratada como um rótulo de classe de borda:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "knows", "Person"],
"property": "metAtLocation",
"type": "classification"
}
],
"features": [
(...)
]
}
}
```
### Especificar uma tarefa de classificação de bordas de várias classes para configuração de treinamento de modelos
Para indicar qual propriedade de nó contém vários exemplos rotulados para fins de treinamento, adicione um elemento de borda à matriz `targets` usando um campo `"type" : "classification"` e um `separator` para especificar um caractere usado para dividir o valor de uma propriedade de destino em vários valores categóricos. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
O destino `edge` a seguir indica que a propriedade `sentiment` de cada borda `repliedTo` deve ser tratada como um rótulo de classe de borda. O campo separador indica que cada propriedade de sentimento contém vários valores separados por vírgula:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "repliedTo", "Message"],
"property": "sentiment",
"type": "classification",
"separator": ","
}
],
"features": [
(...)
]
}
}
```
### Especificar uma regressão de bordas para configuração de treinamento de modelos
Para indicar qual propriedade de borda contém exemplos de regressão rotulados para fins de treinamento, adicione um elemento `edge` à matriz `targets`, usando `"type" : "regression"`. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
O seguinte destino `edge` indica que a propriedade `rating` de cada borda `reviewed` deve ser tratada como uma regressão de bordas:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Person", "reviewed", "Movie"],
"property": "rating",
"type" : "regression"
}
],
"features": [
(...)
]
}
}
```
### Especificar uma tarefa de previsão de links para configuração de treinamento de modelos
Para indicar quais bordas devem ser usadas para fins de treinamento de previsão de links, adicione um elemento de borda à matriz de destinos usando `"type" : "link_prediction"`. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
O seguinte destino `edge` indica que as bordas `cites` devem ser usadas para previsão de links:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"edge": ["Article", "cites", "Article"],
"type" : "link_prediction"
}
],
"features": [
(...)
]
}
}
```
### Especificar um atributo de bucket numérico
É possível especificar um atributo de dados numéricos para uma propriedade de nó adicionando `"type": "bucket_numerical"` à matriz `features`.
O seguinte atributo `node` indica que a propriedade `age` de cada nó `Person` deve ser tratada como um atributo de bucket numérico:
```
"additionalParams": {
"neptune_ml": {
"targets": [
...
],
"features": [
{
"node": "Person",
"property": "age",
"type": "bucket_numerical",
"range": [1, 100],
"bucket_cnt": 5,
"slide_window_size": 3,
"imputer": "median"
}
]
}
}
```
### Especificar um atributo `Word2Vec`
É possível especificar um atributo `Word2Vec` para uma propriedade de nó adicionando `"type": "text_word2vec"` à matriz `features`.
O seguinte atributo `node` indica que a propriedade `description` de cada nó `Movie` deve ser tratada como um atributo `Word2Vec`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_word2vec",
"language": "en_core_web_lg"
}
]
}
}
```
### Especificar um atributo `FastText`
É possível especificar um atributo `FastText` para uma propriedade de nó adicionando `"type": "text_fasttext"` à matriz `features`. O campo `language` é obrigatório e deve especificar um dos seguintes códigos de idioma:
+ `en` (inglês)
+ `zh` (chinês)
+ `hi` (hindi)
+ `es` (espanhol)
+ `fr` (francês)
Observe que a codificação `text_fasttext` não pode lidar com mais de um idioma por vez em um atributo.
O seguinte atributo `node` indica que a propriedade `description` de francês de cada nó `Movie` deve ser tratada como um atributo `FastText`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_fasttext",
"language": "fr",
"max_length": 1024
}
]
}
}
```
### Especificar um atributo `Sentence BERT`
É possível especificar um atributo `Sentence BERT` para uma propriedade de nó adicionando `"type": "text_sbert"` à matriz `features`. Não é necessário especificar o idioma, pois o método codifica automaticamente os atributos de texto usando um modelo de idioma multilíngue.
O seguinte atributo `node` indica que a propriedade `description` de cada nó `Movie` deve ser tratada como um atributo `Sentence BERT`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "description",
"type": "text_sbert128",
}
]
}
}
```
### Especificar um atributo `TF-IDF`
É possível especificar um atributo `TF-IDF` para uma propriedade de nó adicionando `"type": "text_tfidf"` à matriz `features`.
O seguinte atributo `node` indica que a propriedade `bio` de cada nó `Person` deve ser tratada como um atributo `TF-IDF`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Movie",
"property": "bio",
"type": "text_tfidf",
"ngram_range": [1, 2],
"min_df": 5,
"max_features": 1000
}
]
}
}
```
### Especificar um atributo `datetime`
O processo de exportação infere automaticamente atributos `datetime` para propriedades de data. No entanto, se você quiser limitar `datetime_parts` usado de um atributo `datetime` ou substituir uma especificação de atributo para que uma propriedade que normalmente seria tratada como um atributo `auto` seja explicitamente tratada como um atributo `datetime`, você pode fazer isso adicionando `"type": "datetime"` a à matriz de atributos.
O seguinte atributo `node` indica que a propriedade `createdAt` de cada nó `Post` deve ser tratada como um atributo `datetime`:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Post",
"property": "createdAt",
"type": "datetime",
"datetime_parts": ["month", "weekday", "hour"]
}
]
}
}
```
### Especificar um atributo `category`
O processo de exportação infere automaticamente atributos `auto` para propriedades de string e propriedades numéricas que contenham vários valores. Para propriedades numéricas que contenham valores únicos, ele infere atributos `numerical`. Para propriedades de data, ele infere atributos `datetime`.
Se você quiser substituir uma especificação de atributo para que uma propriedade seja tratada como um atributo categórico, adicione `"type": "category"` à matriz de atributos. Se a propriedade contiver vários valores, inclua um campo `separator`. Por exemplo:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Post",
"property": "tag",
"type": "category",
"separator": "|"
}
]
}
}
```
### Especificar um atributo `numerical`
O processo de exportação infere automaticamente atributos `auto` para propriedades de string e propriedades numéricas que contenham vários valores. Para propriedades numéricas que contenham valores únicos, ele infere atributos `numerical`. Para propriedades de data, ele infere atributos `datetime`.
Se você quiser substituir uma especificação de atributo para que uma propriedade seja tratada como um atributo `numerical`, adicione `"type": "numerical"` à matriz de atributos. Se a propriedade contiver vários valores, inclua um campo `separator`. Por exemplo:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "Recording",
"property": "duration",
"type": "numerical",
"separator": ","
}
]
}
}
```
### Especificar um atributo `auto`
O processo de exportação infere automaticamente atributos `auto` para propriedades de string e propriedades numéricas que contenham vários valores. Para propriedades numéricas que contenham valores únicos, ele infere atributos `numerical`. Para propriedades de data, ele infere atributos `datetime`.
Se você quiser substituir uma especificação de atributo para que uma propriedade seja tratada como um atributo `auto`, adicione `"type": "auto"` à matriz de atributos. Se a propriedade contiver vários valores, inclua um campo `separator`. Por exemplo:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
...
],
"features": [
{
"node": "User",
"property": "role",
"type": "auto",
"separator": ","
}
]
}
}
```
## Exemplos do RDF usando `additionalParams`
### Especificar uma taxa de divisão padrão para a configuração de treinamento de modelos
No exemplo a seguir, o parâmetro `split_rate` define a taxa de divisão padrão para o treinamento de modelos. Se nenhuma taxa de divisão padrão for especificada, o treinamento usará um valor de [0,9, 0,1, 0,0]. É possível substituir o valor padrão por destino especificando uma `split_rate` para cada destino.
No seguinte exemplo, o campo `default split_rate` indica que uma taxa de divisão de `[0.7,0.1,0.2]` deve ser usada, a menos que seja substituída por destino:”
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"split_rate": [0.7,0.1,0.2],
"targets": [
(...)
]
}
}
```
### Especificar uma tarefa de classificação de nós para configuração de treinamento de modelos
Para indicar qual propriedade de nó contém exemplos rotulados para fins de treinamento, adicione um elemento de classificação de nós à matriz `targets`, usando `"type" : "classification"`. Adicione um campo de nó para indicar o tipo dos nós de destino. Adicione um campo `predicate` para definir quais dados literais são usados como o atributo do nó de destino. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
No exemplo a seguir, o destino `node` indica que a propriedade `genre` de cada nó `Movie` deve ser tratada como um rótulo de classe de nó. O valor `split_rate` substitui a taxa de divisão padrão:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/genre",
"type": "classification",
"split_rate": [0.7,0.1,0.2]
}
]
}
}
```
### Especificar uma tarefa de regressão de nós para configuração de treinamento de modelos
Para indicar qual propriedade de nó contém regressões rotuladas para fins de treinamento, adicione um elemento de regressão de nós à matriz de destinos, usando `"type" : "regression"`. Adicione um campo `node` para indicar o tipo dos nós de destino. Adicione um campo `predicate` para definir quais dados literais são usados como o atributo do nó de destino. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
O seguinte destino `node` indica que a propriedade `rating` de cada nó `Movie` deve ser tratada como um rótulo de regressão de nós:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"node": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/rating",
"type": "regression",
"split_rate": [0.7,0.1,0.2]
}
]
}
}
```
### Especificar uma tarefa de previsão de links para bordas específicas
Para indicar quais bordas devem ser usadas para fins de treinamento de previsão de links, adicione um elemento de borda à matriz de destinos usando `"type" : "link_prediction"`. Adicione os campos `subject`, `predicate` e `object` para especificar o tipo de borda. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
O seguinte destino `edge` indica que as bordas `directed` que conectam `Directors` a `Movies` devem ser usadas para previsão de links:
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"subject": "http://aws.amazon.com/neptune/csv2rdf/class/Director",
"predicate": "http://aws.amazon.com/neptune/csv2rdf/datatypeProperty/directed",
"object": "http://aws.amazon.com/neptune/csv2rdf/class/Movie",
"type" : "link_prediction"
}
]
}
}
```
### Especificar uma tarefa de previsão de links para todas as bordas
Para indicar que todas as bordas devem ser usadas para fins de treinamento de previsão de links, adicione um elemento `edge` à matriz de destinos usando `"type" : "link_prediction"`. Não adicione campos `subject`, `predicate` nem `object`. Adicione um campo `split_rate` se quiser substituir a taxa de divisão padrão.
```
"additionalParams": {
"neptune_ml": {
"version": "v2.0",
"targets": [
{
"type" : "link_prediction"
}
]
}
}
```