Desenvolvimento de modelos personalizados no Neptune ML

Uma boa maneira de começar o desenvolvimento de modelos personalizados é seguir os exemplos do kit de ferramentas do Neptune ML para estruturar e escrever o módulo de treinamento. O kit de ferramentas do Neptune ML também implementa componentes do modelo de ML de grafo modularizado no modelzoo que você pode empilhar e usar para criar o modelo personalizado.

Além disso, o kit de ferramentas fornece funções de utilitário que ajudam a gerar os artefatos necessários durante o treinamento e a transformação de modelos. É possível importar esse pacote Python na implementação personalizada. Todas as funções ou os módulos fornecidos no kit de ferramentas também estão disponíveis no ambiente de treinamento do Neptune ML.

Se o módulo Python tiver dependências externas adicionais, você poderá incluir essas dependências adicionais criando um arquivo requirements.txt no diretório do módulo. Os pacotes listados no arquivo requirements.txt serão então instalados antes da execução do script de treinamento.

No mínimo, o módulo Python que implementa o modelo personalizado precisa conter o seguinte:

• Um ponto de entrada do script de treinamento

• Um ponto de entrada do script de transformação

• Um arquivo model-hpo-configuration.json

Desenvolvimento de scripts de treinamento de modelos personalizados no Neptune ML

O script de treinamento de modelos personalizados deve ser um script Python executável, como o exemplo train.py do kit de ferramentas do Neptune ML. Ele deve aceitar nomes e valores de hiperparâmetros como argumentos de linha de comando. Durante o treinamento de modelos, os nomes dos hiperparâmetros são obtidos do arquivo model-hpo-configuration.json. Os valores dos hiperparâmetros estarão dentro do intervalo de hiperparâmetros válido se o hiperparâmetro for ajustável ou assumirão o valor padrão do hiperparâmetro se não for ajustável.

O script de treinamento é executado em uma instância de treinamento do SageMaker usando uma sintaxe como esta:

python3 (script entry point) --(1st parameter) (1st value) --(2nd parameter) (2nd value) (...)

Para todas as tarefas, o Neptune ML AutoTrainer envia vários parâmetros necessários ao script de treinamento, além dos hiperparâmetros especificados, e o script deve ser capaz de lidar com esses parâmetros adicionais para funcionar adequadamente.

Esses parâmetros adicionais necessários variam um pouco de acordo com a tarefa:

Para classificação ou regressão de nós

• task: o tipo de tarefa usado internamente pelo Neptune ML. Para classificação de nós, é node_class, e para regressão de nós, é node_regression.

• model: o nome do modelo usado internamente pelo Neptune ML, que é custom neste caso.

• name: o nome da tarefa usada internamente pelo Neptune ML, que é node_class-custom para classificação de nós nesse caso, e node_regression-custom para regressão de nós.

• target_ntype: o nome do tipo de nó para classificação ou regressão.

• property: o nome da propriedade de nó para classificação ou regressão.

Para previsão de links

• task: o tipo de tarefa usado internamente pelo Neptune ML. Para previsão de links, é link_predict.

• model: o nome do modelo usado internamente pelo Neptune ML, que é custom neste caso.

• name: o nome de tarefa usado internamente pelo Neptune ML, que é link_predict-custom nesse caso.

Para classificação ou regressão de bordas

• task: o tipo de tarefa usado internamente pelo Neptune ML. Para classificação de bordas, é edge_class, e para regressão de bordas, é edge_regression.

• model: o nome do modelo usado internamente pelo Neptune ML, que é custom neste caso.

• name: o nome da tarefa usada internamente pelo Neptune ML, que é edge_class-custom para classificação de bordas nesse caso, e edge_regression-custom para regressão de bordas.

• target_etype: o nome do tipo de borda para classificação ou regressão.

• property: o nome da propriedade de borda para classificação ou regressão.

O script deve salvar os parâmetros do modelo, bem como quaisquer outros artefatos necessários ao final do treinamento.

É possível usar as funções do utilitário do kit de ferramentas do Neptune ML para determinar a localização dos dados de grafos processados, o local em que os parâmetros do modelo devem ser salvos e quais dispositivos de GPU estão disponíveis na instância de treinamento. Consulte o exemplo de script de treinamento train.py para ver exemplos de como usar essas funções de utilitário.

Desenvolvimento de scripts de transformação de modelos personalizados no Neptune ML

É necessário um script de transformação para aproveitar o fluxo de trabalho incremental do Neptune ML para inferência de modelos em grafos em evolução sem treinar novamente o modelo. Mesmo que todos os artefatos necessários para a implantação do modelo sejam gerados pelo script de treinamento, você ainda precisará fornecer um script de transformação se quiser gerar modelos atualizados sem treinar novamente o modelo.

nota

No momento, a inferência indutiva em tempo real não é compatível com modelos personalizados.

O script de transformação de modelos personalizados deve ser um script Python executável, como o exemplo de script transform.py do kit de ferramentas do Neptune ML. Como esse script é invocado durante o treinamento de modelos sem argumentos de linha de comando, todos os argumentos de linha de comando aceitos pelo script devem ter padrões.

O script é executado em uma instância de treinamento do SageMaker com uma sintaxe como esta:

python3 (your transform script entry point)

O script de transformação precisará de várias informações, como:

• A localização dos dados de grafos processados.

• O local onde os parâmetros do modelo são salvos e onde os novos artefatos do modelo devem ser salvos.

• Os dispositivos disponíveis na instância.

• Os hiperparâmetros que geraram o melhor modelo.

Essas entradas são obtidas usando as funções de utilitário do Neptune ML que o script pode chamar. Veja o exemplo do script transform.py do kit de ferramentas para ver exemplos de como fazer isso.

O script deve salvar as incorporações do nó, os mapeamentos de ID de nó e quaisquer outros artefatos necessários para a implantação do modelo em cada tarefa. Consulte a documentação dos artefatos do modelo para obter mais informações sobre os artefatos do modelo necessários para diferentes tarefas do Neptune ML.

Arquivo model-hpo-configuration.json personalizado no Neptune ML

O arquivo model-hpo-configuration.json define hiperparâmetros para o modelo personalizado. Ele está no mesmo formato que o arquivo model-hpo-configuration.json usado com os modelos integrados do Neptune ML e tem precedência sobre a versão gerada automaticamente pelo Neptune ML e carregada no local dos dados processados.

Ao adicionar um novo hiperparâmetro ao modelo, você também deve adicionar uma entrada para o hiperparâmetro nesse arquivo para que o hiperparâmetro seja transmitido ao script de treinamento.

Será necessário fornecer um intervalo para um hiperparâmetro se quiser que ele seja ajustável e defini-lo como parâmetro tier-1, tier-2 ou tier-3. O hiperparâmetro será ajustado se o número total de trabalhos de treinamento configurados permitir o ajuste de hiperparâmetros em seu nível. Para um parâmetro não ajustável, é necessário fornecer um valor padrão e adicionar o hiperparâmetro à seção fixed-param do arquivo. Veja o exemplo de arquivo model-hpo-configuration.json do kit de ferramentas para ver um exemplo de como fazer isso.

Você também deve fornecer a definição de métrica que a tarefa de otimização de hiperparâmetros do SageMaker usará para avaliar os modelos candidatos treinados. Para fazer isso, adicione um objeto JSON eval_metric ao arquivo model-hpo-configuration.json da seguinte forma:

"eval_metric": {
  "tuning_objective": {
      "MetricName": "(metric_name)",
      "Type": "Maximize"
  },
  "metric_definitions": [
    {
      "Name": "(metric_name)",
      "Regex": "(metric regular expression)"
    }
  ]
},

A matriz metric_definitions no objeto eval_metric lista objetos de definição de cada métrica que você deseja que o SageMaker extraia da instância de treinamento. Cada objeto de definição de métrica tem uma chave Name que permite fornecer um nome para a métrica (como “precisão”, “f1”, etc.). A chave Regex permite fornecer uma string de expressão regular que corresponda à forma como essa métrica específica é impressa nos logs de treinamento. Consulte a página SageMaker HyperParameter Tuning para obter mais detalhes sobre como definir métricas.

O objeto tuning_objective em eval_metric então permite especificar quais métricas em metric_definitions devem ser usadas como a métrica de avaliação que serve como métrica objetiva para otimização de hiperparâmetros. O valor para o MetricName deve corresponder ao valor de um Name em uma das definições em metric_definitions. O valor de Type deve ser “Maximizar” ou “Minimizar”, dependendo se a métrica deve ser interpretada como maior é melhor (como “precisão”) ou menos é melhor (como “erro quadrático médio”).

Erros nessa seção do arquivo model-hpo-configuration.json podem gerar falhas no trabalho da API de treinamento de modelos do Neptune ML, porque o trabalho de ajuste de hiperparâmetros do SageMaker não poderá selecionar o melhor modelo.

Teste local da implementação do modelo personalizado no Neptune ML

É possível usar o ambiente Conda do kit de ferramentas do Neptune ML para executar o código localmente a fim de testar e validar o modelo. Se você estiver desenvolvendo em uma instância do Neptune Notebook, esse ambiente Conda será pré-instalado na instância de bloco de anotações do Neptune. Se você estiver desenvolvendo em uma instância diferente, precisará seguir as instruções de configuração local no kit de ferramentas do Neptune ML.

O ambiente Conda reproduz com precisão o ambiente em que o modelo será executado quando você chamar a API de treinamento de modelos. Todos os exemplos de script de treinamento e scripts de transformação permitem transmitir um sinalizador --local de linha de comando para executar os scripts em um ambiente local a fim de facilitar a depuração. Essa é uma prática recomendada ao desenvolver o próprio modelo, pois permite testar de forma interativa e iterativa a implementação do modelo. Durante o treinamento de modelos no ambiente de treinamento de produção do Neptune ML, esse parâmetro é omitido.