Dependências do modelo de log

Neste artigo, você aprenderá a registrar um modelo e suas dependências como artefatos de modelo, para que eles estejam disponíveis em seu ambiente para tarefas de produção, como serviço de modelo.

Registrar dependências de modelos de pacote Python

O MLflow tem suporte nativo para algumas bibliotecas Python de ML, em que o MLflow pode registrar dependências de forma confiável para modelos que usam essas bibliotecas. Confira as variantes de modelo internas.

Por exemplo, o MLflow dá suporte ao scikit-learn no módulo mlflow.sklearn e o comando mlflow.sklearn.log_model registra a versão do sklearn. O mesmo se aplica ao registro automático com essas bibliotecas de ML. Consulte o repositório github do MLflow para obter exemplos adicionais.

Para bibliotecas de ML que podem ser instaladas com pip install PACKAGE_NAME==VERSION, mas não têm variantes de modelo do MLflow internas, você pode registrar esses pacotes usando o método mlflow.pyfunc.log_model. Registre os requisitos com a versão exata da biblioteca, por exemplo, f"nltk=={nltk.__version__}" em vez de apenas nltk.

mlflow.pyfunc.log_model dá suporte ao registro em log para:

• Bibliotecas públicas e personalizadas empacotadas como arquivos egg ou wheel do Python.
• Pacotes públicos em PyPI e pacotes hospedados privadamente em seu próprio servidor PyPI.

Com mlflow.pyfunc.log_model, o MLflow tenta inferir as dependências automaticamente. O MLflow infere as dependências usando mlflow.models.infer_pip_requirements e registra-as em um arquivo requirements.txt como um artefato de modelo.

Em versões mais antigas, o MLflow às vezes não identifica automaticamente todas as dependências do Python, especialmente se a biblioteca não for um tipo de modelo nativo. Nesses casos, você pode especificar dependências adicionais com o parâmetro extra_pip_requirements no comando log_model. Veja um exemplo de como usar o parâmetro extra_pip_requirements.

Registro em log de modelo personalizado

Para cenários em que o registro em log de modelo mais personalizado é necessário, você pode:

• Escrever um modelo personalizado do Python. Fazer isso permite que você subclassifique mlflow.pyfunc.PythonModel para personalizar a inicialização e a previsão. Essa abordagem funciona bem para personalização de modelos somente Python.
  • Para obter um exemplo simples, consulte o exemplo do modelo adicionar N.
  • Para obter um exemplo mais complexo, consulte o exemplo de modelo XGBoost personalizado.
• Escrever uma variante personalizada. Nesse cenário, você pode personalizar o registro em log mais do que a variante genérica pyfunc, mas isso requer mais trabalho para implementar.

Código Python personalizado

Você pode ter dependências de código python que não podem ser instaladas usando o %pip install comando, como um ou mais .py arquivos.

Ao registrar um modelo em log, você pode informar ao MLflow que o modelo pode encontrar essas dependências em um caminho especificado usando o code_paths parâmetro (ou code_path no MLflow 2.x) em mlflow.pyfunc.log_model. O MLflow armazena todos os arquivos ou diretórios passados usando code_paths ou code_path como artefatos, juntamente com o modelo em um diretório de código. Ao carregar o modelo, o MLflow adiciona esses arquivos ou diretórios ao caminho do Python. Essa rota também funciona com arquivos wheel personalizados do Python, que podem ser incluídos no modelo usando code_paths ou code_path, assim como os arquivos .py.

MLflow 3

mlflow.pyfunc.log_model(
   name=name,
   code_paths=[filename.py],
   data_path=data_path,
   conda_env=conda_env,
)

MLflow 2.x

mlflow.pyfunc.log_model(
   artifact_path=artifact_path,
   code_path=[filename.py],
   data_path=data_path,
   conda_env=conda_env,
)

Registrar dependências diretas e transitivas de log

Com o MLflow 3, você pode optar por registrar dependências diretas e transitivas definindo a variável de MLFLOW_LOCK_MODEL_DEPENDENCIES ambiente.

import os
os.environ["MLFLOW_LOCK_MODEL_DEPENDENCIES"] = "true"

# Now when you log your model, MLflow captures
# both direct and transitive dependencies

mlflow.sklearn.log_model(
    model,
    "my_model",
)

Registrar dependências de modelo de pacote não Python

O MLflow não coleta automaticamente dependências não Python, como pacotes Java, pacotes R e pacotes nativos (como pacotes Linux). Para esses pacotes, você precisa registrar dados adicionais.

• Lista de dependências: o Databricks recomenda registrar um artefato com o modelo especificando essas dependências não Python. Pode ser um arquivo .txt simples ou um arquivo .json. mlflow.pyfunc.log_model permite especificar esse artefato adicional usando o argumento artifacts.
• Pacotes personalizados: assim como para dependências Python personalizadas acima, você precisa garantir que os pacotes estejam disponíveis em seu ambiente de implantação. Para pacotes em um local central, como o Maven Central ou seu próprio repositório, verifique se o local está disponível na hora de pontuação ou de serviço. Para pacotes privados não hospedados em outro lugar, você pode registrar pacotes junto com o modelo como artefatos.

Implantar modelos com dependências

Ao implantar um modelo do Acompanhamento de Servidor ou do Registro de Modelo do MLflow, você precisa garantir que o ambiente de implantação tenha as dependências corretas instaladas. O caminho mais simples pode depender do modo de implantação: lote/fluxo de dados ou serviço online e nos tipos de dependências.

Para todos os modos de implantação, o Databricks recomenda executar a inferência na mesma versão de runtime que você usou durante o treinamento, já que o Databricks Runtime no qual você criou seu modelo tem várias bibliotecas já instaladas. O MLflow no Databricks salva automaticamente essa versão de runtime no arquivo de metadados MLmodel em um campo databricks_runtime, como databricks_runtime: 10.2.x-cpu-ml-scala2.12.

Serviço online: Serviço de Modelo do Mosaic AI

O Databricks oferece o Serviço de Modelo, onde seus modelos de machine learning do MLflow são expostos como pontos de extremidade escalonáveis da API REST.

Para dependências do Python no arquivo requirements.txt, o Databricks e o MLflow lidam com tudo para dependências PyPI públicas. Da mesma forma, se você especificou .py arquivos ou arquivos de roda python ao registrar o modelo usando code_paths (ou code_path no MLflow 2.x), o MLflow carregará essas dependências automaticamente para você.

Para esses cenários de serviço de modelo, consulte o seguinte:

• Usar bibliotecas do Python personalizadas com Serviço de Modelo
• Empacotar artefatos personalizados e arquivos para o Serviço de Modelo

Serviço online: sistemas de terceiros ou contêineres do Docker

Se o cenário exigir o serviço para soluções de serviço de terceiros ou sua própria solução baseada no Docker, você poderá exportar seu modelo como um contêiner do Docker.

O Databricks recomenda o seguinte para serviços de terceiros que lidam automaticamente com dependências do Python. No entanto, para dependências não Python, o contêiner precisa ser modificado para incluí-las.

• Integração do Docker do MLflow para solução de serviço baseada no Docker: MLflow models build-docker

• Integração do MLflow com o Azure Machine Learning:
  • Implantar na instância de contêiner do Azure (ACI)
  • Implantar no Serviço de Kubernetes do Azure (AKS)

Trabalhos em lote e de fluxo

A pontuação em lote e streaming deve ser executada como Trabalhos do Lakeflow. Um trabalho de notebook geralmente é suficiente e a maneira mais simples de preparar o código é usar o Registro de Modelo do Databricks para gerar um notebook de pontuação.

O processo e as etapas seguintes para garantir que as dependências sejam instaladas e aplicadas adequadamente são descritos abaixo:

1. Inicie o cluster de pontuação com a mesma versão do Databricks Runtime usada durante o treinamento. Faça a leitura do campo databricks_runtime do arquivo MLmodel de metadados e inicie um cluster com essa versão de runtime.

   • Isso pode ser feito manualmente na configuração do cluster ou automatizado com lógica personalizada. Para automação, o formato de versão de runtime que você lê do arquivo de metadados na API de Trabalhos e na API de Clusters.

2. Em seguida, instale as dependências não Python. Para garantir que suas dependências não Python estejam acessíveis ao seu ambiente de implantação, você pode:

   • Instalar manualmente as dependências não Python do modelo no cluster do Databricks como parte da configuração do cluster antes de executar a inferência.
   • Como alternativa, você pode escrever uma lógica personalizada em sua implantação de trabalho de pontuação para automatizar a instalação das dependências no cluster. Supondo que você salvou suas dependências não Python como artefatos, conforme descrito em Registrar dependências de modelo de pacote não Python, essa automação pode instalar bibliotecas usando a API de Bibliotecas. Ou então, você pode escrever um código específico para gerar um script de inicialização com escopo de cluster para instalar as dependências.

3. Seu trabalho de pontuação instala as dependências Python no ambiente de execução do trabalho. No Databricks, o Registro de Modelo permite que você gere um notebook para inferência, o qual faz isso para você.

   • Quando você usa o Registro de Modelo do Databricks para gerar um notebook de pontuação, o notebook contém código para instalar as dependências do Python no arquivo do requirements.txt modelo. Para o trabalho do notebook para pontuação em lote ou em streaming, esse código inicializa o ambiente do notebook para que as dependências do modelo sejam instaladas e prontas para o modelo.

4. O MLflow manipula qualquer código Python personalizado incluído no code_paths (ou code_path no MLflow 2.x) em log_model. Esse código é adicionado ao caminho do Python quando o método do predict() modelo é chamado. Você também pode fazer isso manualmente:

   • Chamando mlflow.pyfunc.spark_udf com o argumento env_manager=['virtualenv'/'conda'].
   • Extraindo os requisitos usando mlflow.pyfunc.get_model_dependencies e instalando-os usando a instalação %pip.

   Observação

   Se você especificou arquivos .py ou arquivos de wheel Python ao registrar o modelo usando code_paths ou code_path, o MLflow carrega essas dependências automaticamente para você.