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á. # Treinar um modelo usando o Neptune ML Depois de exportar os dados exportados do Neptune para treinamento de modelos, é possível iniciar um trabalho de processamento de modelos usando um comando `curl` (ou `awscurl`) como o seguinte: ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" }' ``` Os detalhes de como usar esse comando são explicados em [O comando modeltraining](machine-learning-api-modeltraining.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. Você também pode fornecer um `previousModelTrainingJobId` para usar informações de um trabalho de treinamento de modelos do Neptune ML concluído para acelerar a pesquisa de hiperparâmetros em um novo trabalho de treinamento. Isso é útil durante o [novo treinamento de modelos em novos dados de grafos](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-model-retraining), bem como no [treinamento incremental nos mesmos dados de grafos](machine-learning-overview-evolving-data-incremental.md#machine-learning-overview-incremental). Use um comando como este: ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "previousModelTrainingJobId" : "(the model-training job-id of a completed job)" }' ``` É possível treinar sua própria implementação de modelos na infraestrutura de treinamento do Neptune ML fornecendo um objeto `customModelTrainingParameters`, como este: ``` curl \ -X POST https://(your Neptune endpoint)/ml/modeltraining -H 'Content-Type: application/json' \ -d '{ "id" : "(a unique model-training job ID)", "dataProcessingJobId" : "(the data-processing job-id of a completed job)", "trainModelS3Location" : "s3://(your Amazon S3 bucket)/neptune-model-graph-autotrainer" "modelName": "custom", "customModelTrainingParameters" : { "sourceS3DirectoryPath": "s3://(your Amazon S3 bucket)/(path to your Python module)", "trainingEntryPointScript": "(your training script entry-point name in the Python module)", "transformEntryPointScript": "(your transform script entry-point name in the Python module)" } }' ``` Consulte [O comando modeltraining](machine-learning-api-modeltraining.md) para obter mais informações, por exemplo, sobre como obter o status de um trabalho em execução, como interrompê-lo e como listar todos os trabalhos em execução. Consulte [Modelos personalizados no Neptune ML](machine-learning-custom-models.md) para obter informações sobre como implementar e usar um modelo personalizado. **Topics** + [Modelos e treinamento de modelos no Amazon Neptune ML](machine-learning-models-and-training.md) + [Personalizar as configurações de hiperparâmetros do modelo no Neptune ML](machine-learning-customizing-hyperparams.md) + [Práticas recomendadas para treinamento de modelos](machine-learning-improve-model-performance.md) # Modelos e treinamento de modelos no Amazon Neptune ML O Neptune ML usa redes neurais para grafos (GNN) a fim de criar modelos para as várias tarefas de machine learning. Foi demonstrado que as redes neurais para grafos obtêm resultados de última geração para tarefas de machine learning para grafos e são excelentes para extrair padrões informativos de dados estruturados em grafos. ## Redes neurais para grafos (GNNs) no Neptune ML As redes neurais para grafos (GNNs) pertencem a uma família de redes neurais que calculam representações de nós levando em consideração a estrutura e os atributos dos nós próximos. As GNNs complementam outros métodos tradicionais de machine learning e rede neural que não são adequados para dados de grafos. As GNNs são usadas para resolver tarefas de machine learning, como classificação e regressão de nós (previsão de propriedades de nós) e classificação e regressão de bordas (previsão de propriedades de bordas) ou previsão de links (previsão se dois nós no grafo devem estar conectados ou não). Em geral, o uso de uma GNN para uma tarefa de machine learning envolve duas fases: + Uma fase de codificação, em que s GNN calcula um vetor d-dimensional para cada nó no grafo. Esses vetores também são denominados *representações* ou *incorporações*. + Uma fase de decodificação, que faz previsões com base nas representações codificadas. Para classificação e regressão de nós, as representações de nós são usadas diretamente para as tarefas de classificação e regressão. Para classificação e regressão de bordas, as representações dos nós incidentes em uma borda são usadas como entrada para a classificação ou a regressão. Para previsão de links, uma pontuação de probabilidade de borda é calculada usando um par de representações de nós e uma representação do tipo de borda. A [Deep Graph Library (DGL)](https://www.dgl.ai/) viabiliza a definição e o treinamento eficientes de GNNs para essas tarefas. Diferentes modelos de GNN são unificados sob a formulação da transmissão de mensagens. Nessa visualização, a representação de um nó em um grafo é calculada usando as representações dos vizinhos do nó (as mensagens), junto com a representação inicial do nó. No NeptuneML, a representação inicial de um nó é derivada dos atributos extraídos de suas propriedades do nó ou pode ser aprendida e depende da identidade do nó. O Neptune ML também oferece a opção de concatenar atributos de nós e representações de nós que podem ser aprendidos para servir como representação do nó original. Para as várias tarefas no Neptune ML envolvendo grafos com propriedades de nós, usamos a [Relational Graph Convolutional Network](https://arxiv.org/abs/1703.06103) (R-GCN) para realizar a fase de codificação. A R-GCN é uma arquitetura de GNN adequada para grafos com vários tipos de nós e bordas (conhecidos como grafos heterogêneos). A rede R-GCN consiste em um número fixo de camadas, empilhadas uma após a outra. Cada camada da R-GCN usa seus parâmetros de modelo que podem ser aprendidos para agregar informações da vizinhança imediata de 1 salto de um nó. Como as camadas subsequentes usam as representações de saída da camada anterior como entrada, o raio da vizinhança do grafo que influencia a incorporação final de um nó depende do número de camadas (`num-layer`) da rede R-GCN. Por exemplo, isso significa que uma rede de duas camadas usa informações de nós que estão a dois saltos de distância. Para saber mais sobre GNNs, consulte [A Comprehensive Survey on Graph Neural Networks](https://arxiv.org/abs/1901.00596). Para obter mais informações sobre a Deep Graph Library (DGL), visite a [página da web](https://www.dgl.ai/) da DGL. Para ver um tutorial prático sobre como usar a DGL com GNNs, consulte [Learning graph neural networks with Deep Graph Library](https://www.amazon.science/videos-webinars/learning-graph-neural-networks-with-deep-graph-library). ## Treinar redes neurais para grafos No machine learning, o processo de obter um modelo para aprender a fazer boas previsões para uma tarefa é chamado de treinamento de modelos. Em geral, isso é realizado especificando um objetivo específico a ser otimizado, bem como um algoritmo a ser usado para realizar essa otimização. Esse processo também é empregado no treinamento de uma GNN para aprender boas representações para a tarefa posterior. Criamos uma função objetiva para essa tarefa que é minimizada durante o treinamento de modelos. Por exemplo, para classificação de nós, usamos [CrossEntropyLoss](https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html) como o objetivo, o que penaliza erros de classificação, e para regressão de nós minimizamos o [MeanSquareError](https://pytorch.org/docs/stable/generated/torch.nn.MSELoss.html). O objetivo geralmente é uma função de perda que pega as previsões do modelo para um ponto de dados específico e as compara ao valor verdadeiro básico desse ponto de dados. Ela exibe o valor da perda, que mostra o quão distantes estão as previsões do modelo. O objetivo do processo de treinamento é minimizar a perda e garantir que as previsões do modelo estejam próximas da verdade. O algoritmo de otimização usado no machine learning para o processo de treinamento geralmente é uma variante do gradiente descendente. No Neptune ML, usamos [Adam](https://arxiv.org/pdf/1412.6980.pdf), que é um algoritmo para otimização baseada em gradiente de primeira ordem de funções objetivas estocásticas com base em estimativas adaptativas de momentos de ordem inferior. Embora o processo de treinamento de modelos tente garantir que os parâmetros do modelo aprendido estejam próximos dos mínimos da função objetiva, o desempenho geral de um modelo também depende dos *hiperparâmetros* do modelo, que são configurações do modelo que não são aprendidas pelo algoritmo de treinamento. Por exemplo, a dimensionalidade da representação do nó aprendido, `num-hidden`, é um hiperparâmetro que afeta o desempenho do modelo. Portanto, é comum no machine learning realizar a otimização de hiperparâmetros (HPO) para escolher os hiperparâmetros adequados. O Neptune ML usa uma tarefa de ajuste de hiperparâmetros do SageMaker AI para iniciar várias instâncias de treinamento de modelo com diferentes configurações de hiperparâmetros para tentar encontrar o melhor modelo para uma variedade de configurações de hiperparâmetros. Consulte [Personalizar as configurações de hiperparâmetros do modelo no Neptune ML](machine-learning-customizing-hyperparams.md). ## Modelos de incorporação de grafos de conhecimento no Neptune ML Grafos de conhecimento (KGs) são grafos que codificam informações sobre diferentes entidades (nós) e suas relações (bordas). No Neptune ML, os modelos de incorporação de grafos de conhecimento são aplicados por padrão para realizar a previsão de links quando o grafo não contém propriedades de nós, somente relações com outros nós. Embora os modelos de R-GCN com incorporações que podem ser aprendidas também possam ser usados para esses grafos especificando o tipo de modelo como `"rgcn"`, os modelos de incorporação de grafos de conhecimento são mais simples e foram projetados para ser eficazes para aprender representações de grafos de conhecimento em grande escala. Os modelos de incorporação de grafos de conhecimento são usados em uma tarefa de previsão de links para prever os nós ou relações que completam uma `(h, r, t)` tripla em que `h` é o nó de origem, `r` é o tipo de relação e `t` é o nó de destino. Os modelos de incorporação de grafos de conhecimento implementados no Neptune ML são `distmult`, `transE` e `rotatE`. Para saber mais sobre os modelos de incorporação de grafos de conhecimento, consulte [DGL-KE](https://github.com/awslabs/dgl-ke). ## Treinar modelos personalizados no Neptune ML O Neptune ML permite definir e implementar os próprios modelos personalizados, para cenários específicos. Consulte [Modelos personalizados no Neptune ML](machine-learning-custom-models.md) para obter informações sobre como implementar um modelo personalizado e como usar a infraestrutura do Neptune ML para treiná-lo. # Personalizar as configurações de hiperparâmetros do modelo no Neptune ML Quando você inicia um trabalho de treinamento de modelos do Neptune ML, o Neptune ML usa automaticamente as informações inferidas do trabalho de [processamento de dados](machine-learning-on-graphs-processing.md) anterior. Ele usa as informações para gerar intervalos de configuração de hiperparâmetros que são usados para criar um [trabalho de ajuste de hiperparâmetros de SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-how-it-works.html) para treinar vários modelos para sua tarefa. Dessa forma, você não precisa especificar uma longa lista de valores de hiperparâmetros com os quais os modelos serão treinados. Em vez disso, os intervalos e os padrões dos hiperparâmetros do modelo são selecionados com base no tipo de tarefa, no tipo de grafo e nas configurações do trabalho de ajuste. No entanto, você também pode substituir a configuração padrão de hiperparâmetros e fornecer hiperparâmetros personalizados modificando um arquivo de configuração JSON que o trabalho de processamento de dados gera. Usando a [API modelTraining](machine-learning-api-modeltraining.md) do Neptune ML, é possível controlar várias configurações de trabalhos de ajuste de hiperparâmetros gerais, como `maxHPONumberOfTrainingJobs`, `maxHPOParallelTrainingJobs` e `trainingInstanceType`. Para um controle mais refinado sobre os hiperparâmetros do modelo, você pode personalizar o arquivo `model-HPO-configuration.json` que o trabalho de processamento de dados gera. O arquivo é salvo no local do Amazon S3 que você especificou para a saída do trabalho de processamento. É possível baixar o arquivo, editá-lo para substituir as configurações padrão de hiperparâmetros e enviá-lo de volta para o mesmo local do Amazon S3. Não altere o nome do arquivo e siga estas instruções ao editar. Como baixar o arquivo do Amazon S3: ``` aws s3 cp \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json \ ./ ``` Quando terminar de editar, faça upload do arquivo de volta para onde estava: ``` aws s3 cp \ model-HPO-configuration.json \ s3://(bucket name)/(path to output folder)/model-HPO-configuration.json ``` ## Estrutura do arquivo `model-HPO-configuration.json` O arquivo `model-HPO-configuration.json` especifica o modelo a ser treinado, o `task_type` de machine learning e os hiperparâmetros que devem ser variados ou fixos para as várias execuções de treinamento do modelo. Os hiperparâmetros são categorizados como pertencentes a vários níveis, o que significa a precedência dada aos hiperparâmetros quando o trabalho de ajuste do hiperparâmetro é invocado: + Os hiperparâmetros de nível 1 têm a maior precedência. Se você definir `maxHPONumberOfTrainingJobs` como um valor menor que 10, somente os hiperparâmetros de nível 1 serão ajustados, e o restante assumirá seus valores padrão. + Os hiperparâmetros de nível 2 têm menor precedência; portanto, se você tiver mais de 10, mas menos de 50 trabalhos de treinamento no total para um trabalho de ajuste, os hiperparâmetros de nível 1 e nível 2 serão ajustados. + Os hiperparâmetros de nível 3 são ajustados junto com os níveis 1 e 2 somente se você tiver mais de 50 trabalhos de treinamento no total. + Por fim, os hiperparâmetros fixos não são ajustados e sempre assumem seus valores padrão. ### Exemplo de arquivo `model-HPO-configuration.json` Veja a seguir um exemplo de arquivo `model-HPO-configuration.json`: ``` { "models": [ { "model": "rgcn", "task_type": "node_class", "eval_metric": { "metric": "acc" }, "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, "1-tier-param": [ { "param": "num-hidden", "range": [16, 128], "type": "int", "inc_strategy": "power2" }, { "param": "num-epochs", "range": [3,30], "inc_strategy": "linear", "inc_val": 1, "type": "int", "node_strategy": "perM" }, { "param": "lr", "range": [0.001,0.01], "type": "float", "inc_strategy": "log" } ], "2-tier-param": [ { "param": "dropout", "range": [0.0,0.5], "inc_strategy": "linear", "type": "float", "default": 0.3 }, { "param": "layer-norm", "type": "bool", "default": true } ], "3-tier-param": [ { "param": "batch-size", "range": [128, 4096], "inc_strategy": "power2", "type": "int", "default": 1024 }, { "param": "fanout", "type": "int", "options": [[10, 30],[15, 30], [15, 30]], "default": [10, 15, 15] }, { "param": "num-layer", "range": [1, 3], "inc_strategy": "linear", "inc_val": 1, "type": "int", "default": 2 }, { "param": "num-bases", "range": [0, 8], "inc_strategy": "linear", "inc_val": 2, "type": "int", "default": 0 } ], "fixed-param": [ { "param": "concat-node-embed", "type": "bool", "default": true }, { "param": "use-self-loop", "type": "bool", "default": true }, { "param": "low-mem", "type": "bool", "default": true }, { "param": "l2norm", "type": "float", "default": 0 } ] } ] } ``` ### Elementos de um arquivo `model-HPO-configuration.json` O arquivo contém um objeto JSON com uma única matriz de nível superior chamada `models` que contém um único objeto de configuração de modelo. Ao personalizar o arquivo, assegure-se de que a matriz `models` tenha somente um objeto de configuração de modelo. Se seu arquivo contiver mais de um objeto de configuração de modelo, o trabalho de ajuste falhará com um aviso. O objeto de configuração do modelo contém os seguintes elementos gerais: + **`model`**: (*string*) O tipo de modelo a ser treinado (**não modifique**). Os valores válidos são: + `"rgcn"`: é o padrão para tarefas de classificação e regressão de nós e para tarefas de previsão de links heterogêneos. + `"transe"`: é o padrão para as tarefas de previsão de links do KGE. + `"distmult"`: é um tipo de modelo alternativo para tarefas de previsão de links do KGE. + `"rotate"`: é um tipo de modelo alternativo para tarefas de previsão de links do KGE. Como regra, não modifique diretamente o valor `model`, pois tipos de modelos diferentes geralmente têm hiperparâmetros aplicáveis substancialmente diferentes, o que pode gerar um erro de análise após o início do trabalho de treinamento. Para alterar o tipo de modelo, use o parâmetro `modelName` na [API modelTraining](machine-learning-api-modeltraining.md#machine-learning-api-modeltraining-create-job) em vez de alterá-lo no arquivo `model-HPO-configuration.json`. Uma forma de alterar o tipo de modelo e fazer alterações detalhadas nos hiperparâmetros é copiar o modelo padrão de configuração do modelo no modelo que você deseja usar e colá-lo no arquivo `model-HPO-configuration.json`. Haverá uma pasta denominada `hpo-configuration-templates` no mesmo local do Amazon S3 que o arquivo `model-HPO-configuration.json` se o tipo de tarefa inferido for compatível com vários modelos. Essa pasta contém todas as configurações padrão de hiperparâmetros para os outros modelos aplicáveis à tarefa. Por exemplo, se você quiser alterar as configurações de modelo e hiperparâmetros para uma tarefa de previsão de link `KGE` do modelo padrão `transe` para um modelo `distmult`, basta colar o conteúdo do arquivo `hpo-configuration-templates/distmult.json` no arquivo `model-HPO-configuration.json` e editar os hiperparâmetros conforme necessário. **nota** Se você definir o parâmetro `modelName` na API `modelTraining` e também alterar a especificação `model` e de hiperparâmetros no arquivo `model-HPO-configuration.json`, e elas forem diferentes, o valor `model` no arquivo `model-HPO-configuration.json` terá precedência, e o valor `modelName` será ignorado. + **`task_type`**: (*String*) O tipo de tarefa de machine learning inferido ou passado diretamente para o trabalho de processamento de dados (**não modifique**). Os valores válidos são: + `"node_class"` + `"node_regression"` + `"link_prediction"` O trabalho de processamento de dados infere o tipo de tarefa examinando o conjunto de dados exportado e o arquivo de configuração do trabalho de treinamento gerado para conferir as propriedades do conjunto de dados. Esse valor não deve ser alterado. Se você quiser treinar uma tarefa diferente, precisará [executar um novo trabalho de processamento de dados](machine-learning-on-graphs-processing.md). Se o valor `task_type` não for o esperado, confira as entradas do seu trabalho de processamento de dados para ter certeza de que estão corretas. Isso inclui parâmetros para a API `modelTraining`, bem como no arquivo de configuração do trabalho de treinamento gerado pelo processo de exportação de dados. + **`eval_metric`**: (*String*) a métrica de avaliação deve ser usada para avaliar o desempenho do modelo e selecionar o modelo com melhor desempenho em todas as execuções de HPO. Os valores válidos são: + `"acc"`: precisão de classificação padrão. É o padrão para tarefas de classificação de rótulo único, a menos que rótulos não equilibrados sejam encontrados durante o processamento de dados. Nesse caso, o padrão será `"F1"`. + `"acc_topk"`: o número de vezes que o rótulo correto está entre as principais previsões **`k`**. Também é possível definir o valor **`k`** transmitindo `topk` como uma chave extra. + `"F1"`: a [pontuação da F1](https://en.wikipedia.org/wiki/F-score). + `"mse"`: [métrica de erro quadrático médio](https://en.wikipedia.org/wiki/Mean_squared_error), para tarefas de regressão. + `"mrr"`: [métrica média de classificação recíproca](https://en.wikipedia.org/wiki/Mean_reciprocal_rank). + `"precision"`: a precisão do modelo, calculada como a razão entre os positivos verdadeiros e os positivos previstos: `= true-positives / (true-positives + false-positives)`. + `"recall"`: a chamada do modelo, calculada como a razão entre os positivos verdadeiros e os positivos reais: `= true-positives / (true-positives + false-negatives)`. + `"roc_auc"`: a área abaixo da [curva ROC](https://en.wikipedia.org/wiki/Receiver_operating_characteristic). Esse é o padrão para classificação com vários rótulos. Por exemplo, para alterar a métrica para `F1`, altere o valor `eval_metric` da seguinte forma: ``` " eval_metric": { "metric": "F1", }, ``` Ou para alterar a métrica para uma pontuação de precisão `topk`, você mudaria a `eval_metric` da seguinte forma: ``` "eval_metric": { "metric": "acc_topk", "topk": 2 }, ``` + **`eval_frequency`**: (*Objeto*) Especifica com que frequência durante o treinamento o desempenho do modelo no conjunto de validação deve ser conferido. Com base no desempenho da validação, a parada antecipada pode então ser iniciada e o melhor modelo pode ser salvo. O objeto `eval_frequency` contém dois elementos, a saber, `"type"` e `"value"`. Por exemplo: ``` "eval_frequency": { "type": "evaluate_every_pct", "value": 0.1 }, ``` Os valores `type` válidos são: + **`evaluate_every_pct`**: especifica a porcentagem de treinamento a ser concluído para cada avaliação. Para `evaluate_every_pct`, o campo `"value"` contém um número de ponto flutuante entre zero e um que expressa essa porcentagem. + **`evaluate_every_batch`**: especifica o número de treinamento a ser concluído para cada avaliação. Para `evaluate_every_batch`, o campo `"value"` contém um número inteiro que expressa essa contagem de lotes. + **`evaluate_every_epoch`**: especifica o número de épocas por avaliação, em que uma nova época começa à meia-noite. Para `evaluate_every_epoch`, o campo `"value"` contém um número inteiro que expressa essa contagem de épocas. A configuração padrão para `eval_frequency` é: ``` "eval_frequency": { "type": "evaluate_every_epoch", "value": 1 }, ``` + **`1-tier-param`**: (*Obrigatório*) Uma matriz de hiperparâmetros de nível 1. Se não quiser ajustar nenhum hiperparâmetro, você poderá definir isso como uma matriz vazia. Isso não afeta o número total de trabalhos de treinamento lançados pelo trabalho de ajuste de hiperparâmetros de SageMaker IA. Significa apenas que todos os trabalhos de treinamento, se houver mais de 1, mas menos de 10, serão executados com o mesmo conjunto de hiperparâmetros. Por outro lado, se você quiser tratar todos os seus hiperparâmetros ajustáveis com igual importância, poderá colocar todos os hiperparâmetros nessa matriz. + **`2-tier-param`**: (*obrigatório*) uma matriz de hiperparâmetros de nível 2. Esses parâmetros serão ajustados somente se `maxHPONumberOfTrainingJobs` tiver um valor maior que 10. Caso contrário, eles serão fixados nos valores padrão. Se você tiver um orçamento de treinamento de no máximo 10 trabalhos de treinamento ou não quiser hiperparâmetros de nível 2 por qualquer outro motivo, mas quiser ajustar todos os hiperparâmetros ajustáveis, defina isso como uma matriz vazia. + **`3-tier-param`**: (*obrigatório*) uma matriz de hiperparâmetros de nível 3. Esses parâmetros serão ajustados somente se `maxHPONumberOfTrainingJobs` tiver um valor maior que 50. Caso contrário, eles serão fixados nos valores padrão. Se não quiser ajustar nenhum hiperparâmetro de nível 3, você poderá definir isso como uma matriz vazia. + **`fixed-param`**: (*obrigatório*) uma matriz de hiperparâmetros fixos que usam apenas seus valores padrão e não variam em diferentes trabalhos de treinamento. Se quiser variar todos os hiperparâmetros, você poderá definir isso como uma matriz vazia e definir o valor como `maxHPONumberOfTrainingJobs` grande o suficiente para variar todos os níveis ou tornar todos os hiperparâmetros de nível 1. O objeto JSON que representa cada hiperparâmetro em `1-tier-param`, `2-tier-param`, `3-tier-param` e `fixed-param` contém os seguintes elementos: + **`param`**: (*string*) o nome do hiperparâmetro (**não altere**). Veja a [lista de nomes de hiperparâmetros válidos no Neptune ML](#machine-learning-hyperparams-list). + **`type`**: (*string*) o tipo de hiperparâmetro (**não altere**). Os tipos válidos são `bool`, `int` e `float`. + **`default`**: (*string*) o valor padrão para o hiperparâmetro. Você pode definir um novo valor padrão. Os hiperparâmetros ajustáveis também podem conter os seguintes elementos: + **`range`**: (*matriz*) o intervalo de um hiperparâmetro ajustável contínuo. Deve ser uma matriz com dois valores, ou seja, o mínimo e o máximo do intervalo (`[min, max]`). + **`options`**: (*matriz*) as opções para um hiperparâmetro categórico ajustável. Essa matriz deve conter todas as opções a serem consideradas: ``` "options" : [value1, value2, ... valuen] ``` + **`inc_strategy`**: (*string*) o tipo de alteração incremental para intervalos contínuos de hiperparâmetros ajustáveis (**não altere**). Os valores válidos são `log`, `linear` e `power2`. Aplica-se somente quando a chave de intervalo é definida. Modificar isso pode resultar no não uso de todo o intervalo de seu hiperparâmetro para ajuste. + **`inc_val`** (*float*) a quantidade pela qual os incrementos sucessivos diferem para hiperparâmetros ajustáveis contínuos (**não altere**). Aplica-se somente quando a chave de intervalo é definida. Modificar isso pode resultar no não uso de todo o intervalo de seu hiperparâmetro para ajuste. + **`node_strategy`**: (*string*) indica que o intervalo efetivo desse hiperparâmetro deve mudar com base no número de nós no grafo (**não altere**). Os valores válidos são `"perM"` (por milhão), `"per10M"` (por 10 milhões) e `"per100M"` (por 100 milhões). Em vez de alterar esse valor, altere `range`. + **`edge_strategy`**: (*string*) indica que o intervalo efetivo desse hiperparâmetro deve mudar com base no número de bordas no grafo (**não altere**). Os valores válidos são `"perM"` (por milhão), `"per10M"` (por 10 milhões) e `"per100M"` (por 100 milhões). Em vez de alterar esse valor, altere `range`. ### Lista de todos os hiperparâmetros no Neptune ML A lista a seguir contém todos os hiperparâmetros que podem ser definidos em qualquer lugar no Neptune ML, para qualquer tipo de modelo e tarefa. Como nem todos são aplicáveis a todos os tipos de modelo, é importante definir apenas hiperparâmetros no arquivo `model-HPO-configuration.json` que aparece para o modelo que você está usando. + **`batch-size`**: o tamanho do lote de nós-alvo usados em uma passagem direta. *Tipo*: `int`. Definir isso como um valor muito maior pode causar problemas de memória para treinamento em instâncias de GPU. + **`concat-node-embed`**: indica se é necessário obter a representação inicial de um nó concatenando seus atributos processados com incorporações de nós iniciais que podem ser aprendidos a fim de aumentar a expressividade do modelo. *Tipo*: `bool`. + **`dropout`**: a probabilidade de abandono aplicada às camadas de abandono. *Tipo*: `float`. + **`edge-num-hidden`**: o tamanho da camada oculta ou o número de unidades do módulo de atributos de borda. Usado somente quando `use-edge-features` for definido como `True`. *Tipo*: flutuante. + **`enable-early-stop`**: alterna se deve ou não usar o atributo de parada antecipada. *Tipo*: `bool`. *Padrão*: `true`. Use esse parâmetro booliano para desativar o atributo de parada antecipada. + **`fanout`**: o número de vizinhos para amostra para um nó-alvo durante a amostragem de vizinhos. *Tipo*: `int`. Esse valor está fortemente acoplado a `num-layers` e deve estar sempre no mesmo nível de hiperparâmetros. Isso ocorre porque você pode especificar um fanout para cada camada potencial do GNN. Como esse hiperparâmetro pode fazer com que o desempenho do modelo varie amplamente, ele deve ser corrigido ou definido como um hiperparâmetro de nível 2 ou nível 3. Definir isso como um valor grande pode causar problemas de memória para treinamento em instâncias de GPU. + **`gamma`**: o valor da margem na função de pontuação. *Tipo*: `float`. Isso se aplica somente aos modelos de previsão de links `KGE`. + **`l2norm`**: o valor de redução de peso usado no otimizador que impõe uma penalidade de normalização L2 nos pesos. *Tipo*: `bool`. + **`layer-norm`**: indica se a normalização de camadas deve ser usada para modelos `rgcn`. *Tipo*: `bool`. + **`low-mem`**: indica se deve ser usada uma implementação de baixa memória da função de transmissão de mensagens de relação em detrimento da velocidade. *Tipo*: `bool`. + **`lr`**: a taxa de aprendizado. *Tipo*: `float`. Isso deve ser definido como um hiperparâmetro de nível 1. + **`neg-share`**: na previsão de links, indica se as amostras de bordas positivas podem compartilhar amostras de bordas negativas. *Tipo*: `bool`. + **`num-bases`**: o número de bases para decomposição de bases em um modelo `rgcn`. Usar um valor de `num-bases` menor do que o número de tipos de borda no grafo atua como um regularizador para o modelo `rgcn`. *Tipo*: `int`. + **`num-epochs`**: o número de épocas de treinamento a serem executados. *Tipo*: `int`. Época é uma passagem de treinamento completa pelo grafo. + **`num-hidden`**: o tamanho da camada oculta ou o número de unidades. *Tipo*: `int`. Isso também define o tamanho inicial de incorporação para nós sem atributos. Definir isso para um valor muito maior sem reduzir `batch-size` pode causar out-of-memory problemas de treinamento na instância da GPU. + **`num-layer`**: o número de camadas de GNN no modelo. *Tipo*: `int`. Esse valor está fortemente acoplado ao parâmetro fanout e deve vir depois que o fanout é definido no mesmo nível de hiperparâmetros. Como isso ode fazer com que o desempenho do modelo varie amplamente, ele deve ser corrigido ou definido como um hiperparâmetro de nível 2 ou nível 3. + **`num-negs`**: na previsão de links, o número de amostras negativas por amostra positiva. *Tipo*: `int`. + **`per-feat-name-embed`**: indica se cada atributo deve ser incorporado transformando-o de forma independente antes de combinar os atributos. *Tipo*: `bool`. Quando definido como `true`, cada atributo por nó é transformado de forma independente em um tamanho de dimensão fixo antes que todos os atributos transformados do nó sejam concatenados e posteriormente transformados na dimensão `num_hidden`. Quando definido como `false`, os atributos são concatenados sem nenhuma transformação específica do atributo. + **`regularization-coef`**: na previsão de links, o coeficiente de perda de regularização. *Tipo*: `float`. + **`rel-part`**: indica se a partição de relação deve ser usada para previsão de links `KGE`. *Tipo*: `bool`. + **`sparse-lr`**: a taxa de aprendizado para incorporações de nós que podem ser aprendidos. *Tipo*: `float`. As incorporações de nós iniciais que podem ser aprendidos são usadas para nós sem atributos ou quando `concat-node-embed` está definido. Os parâmetros da camada de incorporação de nós esparsos que podem ser aprendidos são treinados usando um otimizador separado que pode ter uma taxa de aprendizado separada. + **`use-class-weight`**: indica se devem ser aplicados pesos de classe para tarefas de classificação não equilibradas. Se definido como `true`, as contagens de rótulos são usadas para definir um peso para cada rótulo de classe. *Tipo*: `bool`. + **`use-edge-features`**: indica se os atributos de borda devem ser usados durante a transmissão de mensagens. Se definido como `true`, um módulo de atributo de borda personalizado é adicionado à camada RGCN para tipos de borda que têm atributos. *Tipo*: `bool`. + **`use-self-loop`**: indica se deve incluir loops automáticos no treinamento de um modelo `rgcn`. *Tipo*: `bool`. + **`window-for-early-stop`**: controla a média do número das pontuações de validação mais recentes para decidir sobre uma parada antecipada. O padrão é 3. type=int. Consulte também [Interrupção antecipada do processo de treinamento de modelos no Neptune ML](machine-learning-improve-model-performance.md#machine-learning-model-training-early-stop). *Tipo*: `int`. *Padrão*: `3`. Consulte . ## Personalizar hiperparâmetros no Neptune ML Ao editar o arquivo `model-HPO-configuration.json`, os seguintes tipos de alteração a serem feitas são os mais comuns: + Edite os valores and/or máximos mínimos dos `range` hiperparâmetros. + Defina um hiperparâmetro como um valor fixo movendo-o para a seção `fixed-param` e definindo seu valor padrão para o valor fixo que você deseja que ele assuma. + Altere a prioridade de um hiperparâmetro colocando-o em um nível específico, editando seu intervalo e certificando-se de que seu valor padrão seja definido adequadamente. # Práticas recomendadas para treinamento de modelos Há procedimentos que você pode realizar para melhorar o desempenho dos modelos do Neptune ML. ## Escolher a propriedade correta do nó Pode ser que nem todas as propriedades no grafo sejam significativas ou relevantes para as tarefas de machine learning. Todas as propriedades irrelevantes devem ser excluídas durante a exportação de dados. Veja algumas práticas recomendadas: + Use especialistas no domínio para ajudar a avaliar a importância dos atributos e a viabilidade de usá-los para previsões. + Remova os atributos considerados redundantes ou irrelevantes para reduzir o ruído nos dados e as correlações sem importância. + Faça iterações à medida que constrói o modelo. Ajuste os atributos, as combinações de atributos e os objetivos de ajuste à medida que avança. O [processamento de atributos](https://docs.aws.amazon.com/machine-learning/latest/dg/feature-processing.html) no Guia do desenvolvedor do Amazon Machine Learning apresenta diretrizes adicionais para o processamento de atributos relevantes para o Neptune ML. ## Lidar com pontos de dados atípicos Valor atípico é um ponto de dados significativamente diferente dos dados restantes. Valores atípicos podem prejudicar ou induzir erros no processo de treinamento, ocasionando maior tempo de treinamento ou modelos menos precisos. A menos que sejam realmente importantes, você deve eliminar os valores atípicos antes de exportar os dados. ## Remover bordas e nós duplicados Os grafos armazenados no Neptune podem ter bordas ou nós duplicados. Esses elementos redundantes introduzirão ruído no treinamento de modelos de ML. Elimine bordas ou nós duplicados antes de exportar os dados. ## Ajustar a estrutura do grafo Quando o grafo é exportado, você pode alterar a forma como os atributos são processados e como o grafo é construído, para melhorar o desempenho do modelo. Veja algumas práticas recomendadas: + Quando uma propriedade de borda tem o significado de categorias de bordas, em alguns casos vale a pena transformá-la em tipos de borda. + A política de normalização padrão usada para uma propriedade numérica é `min-max`, mas em alguns casos outras políticas de normalização funcionam melhor. É possível pré-processar a propriedade e alterar a política de normalização conforme explicado em [Elementos de um arquivo `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements). + O processo de exportação gera automaticamente tipos de atributo com base nos tipos de propriedade. Por exemplo, ele trata as propriedades `String` como atributos categóricos e as propriedades `Float` e `Int` como atributos numéricos. Se necessário, você poderá modificar o tipo de atributo após a exportação (consulte [Elementos de um arquivo `model-HPO-configuration.json`](machine-learning-customizing-hyperparams.md#machine-learning-hyperparams-file-elements)). ## Ajustar os intervalos e padrões dos hiperparâmetros A operação de processamento de dados infere intervalos de configuração de hiperparâmetros a partir do grafo. Se os intervalos e os padrões de hiperparâmetros do modelo gerado não funcionarem bem para os dados dos grafos, você poderá editar o arquivo de configuração do HPO para criar sua própria estratégia de ajuste de hiperparâmetros. Veja algumas práticas recomendadas: + Quando o grafo fica grande, o tamanho padrão da dimensão oculta pode não ser grande o suficiente para conter todas as informações. É possível alterar o hiperparâmetro `num-hidden` para controlar o tamanho da dimensão oculta. + Para modelos de incorporação de grafos de conhecimento (KGE), convém alterar o modelo específico que está sendo usado de acordo com a estrutura do grafo e o orçamento. Os modelos `TrainsE` têm dificuldade de lidar com relações um-para-muitos (1-N), muitos-para-um (N-1) e muitos-para-muitos (N-N). Os modelos `DistMult` têm dificuldade de lidar com relações simétricas. `RotatE` é bom em modelar todos os tipos de relações, mas é mais caro do que `TrainsE` e `DistMult` durante o treinamento. + Em alguns casos, quando tanto a identificação do nó quanto as informações do atributo do nó são importantes, você deve usar ``concat-node-embed`` para instruir o modelo Neptune ML a obter a representação inicial de um nó concatenando os atributos com suas incorporações iniciais. + Ao obter um desempenho razoavelmente bom em alguns hiperparâmetros, é possível ajustar o espaço de pesquisa de hiperparâmetros de acordo com esses resultados. ## Interrupção antecipada do processo de treinamento de modelos no Neptune ML A interrupção antecipada pode reduzir significativamente o tempo de execução do treinamento de modelos e os custos associados sem degradar o desempenho do modelo. Também evita que o modelo se ajuste demais aos dados de treinamento. A interrupção antecipada depende de medições regulares do desempenho do conjunto de validação. Inicialmente, o desempenho melhora à medida que o treinamento prossegue, mas quando o modelo começa a se ajustar demais, ele começa a declinar novamente. O atributo de interrupção antecipada identifica o ponto em que o modelo começa a se ajustar demais e interrompe o treinamento do modelo nesse ponto. O Neptune ML monitora as chamadas da métrica de validação e compara a métrica de validação mais recente com a média das métricas de validação nas últimas **`n`** avaliações, em que **`n`** é um número definido usando o parâmetro `window-for-early-stop`. Assim que a métrica de validação for pior do que a média, o Neptune ML interromperá o treinamento do modelo e salvará o melhor modelo até o momento. É possível controlar a interrupção antecipada usando os seguintes parâmetros: + **`window-for-early-stop`**: o valor desse parâmetro é um número inteiro que especifica a média do número de pontuações de validação recentes ao decidir sobre uma interrupção antecipada. O valor padrão é `3`. + **`enable-early-stop`**: use esse parâmetro booliano para desativar o atributo de interrupção antecipada. Por padrão, o valor é `true`. ## Interrupção antecipada do processo HPO no Neptune ML O recurso de interrupção antecipada no Neptune ML também interrompe as tarefas de treinamento que não estão funcionando bem em comparação com outras tarefas de treinamento, usando o recurso de início a quente do HPO do SageMaker AI. Isso também pode reduzir custos e melhorar a qualidade do HPO. Consulte [Run a warm start hyperparameter tuning job](https://docs.aws.amazon.com/sagemaker/latest/dg/automatic-model-tuning-warm-start.html) para obter uma descrição de como isso funciona. O início a quente oferece a capacidade de transmitir informações aprendidas em trabalhos de treinamento anteriores para trabalhos de treinamento subsequentes e oferece dois benefícios distintos: + Primeiro, os resultados dos trabalhos de treinamento anteriores são usados para selecionar boas combinações de hiperparâmetros a serem pesquisados no novo trabalho de ajuste. + Segundo, permite a interrupção antecipada para acessar mais execuções do modelo, o que reduz o tempo de ajuste. Esse atributo é habilitado automaticamente no Neptune ML e permite que você encontre um equilíbrio entre o tempo de treinamento e o desempenho do modelo. Se você estiver satisfeito com o desempenho do modelo atual, poderá usar esse modelo. Caso contrário, execute mais HPOs que são iniciados a quente com os resultados das execuções anteriores para descobrir um modelo melhor. ## Obter serviços de suporte profissional A AWS oferece serviços de suporte profissional para ajudar você com problemas em machine learning em projetos do Neptune. Se tiver problemas, entre em contato com o [AWS Support](https://aws.amazon.com/premiumsupport/).