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