Como configurar uma máquina de desenvolvimento com MLFlow e MinIO

Sobre o MLflow

MLflow é uma plataforma de código aberto projetada para gerenciar o ciclo de vida completo do aprendizado de máquina. A Databricks o criou como um projeto interno para enfrentar os desafios enfrentados em seus próprios processos de desenvolvimento e implantação de aprendizado de máquina. O MLflow foi lançado posteriormente como um projeto de código aberto em junho de 2018.

Como ferramenta para gerenciar o ciclo de vida completo, o MLflow contém os seguintes componentes.

• Rastreamento de MLflow - Um engenheiro usará mais esse recurso. Ele permite que experimentos sejam registrados e consultados. Ele também acompanha o código, os dados, a configuração e os resultados de cada experimento.
• Projetos MLflow - Permite que experimentos sejam reproduzidos empacotando o código em um formato independente de plataforma.
• Modelos MLflow – implanta modelos de aprendizado de máquina em um ambiente onde eles podem ser atendidos.
• Repositórios MLflow - Permite o armazenamento, anotação, descoberta e gerenciamento de modelos em um repositório central.

É possível instalar todos esses recursos em uma máquina de desenvolvimento para que os engenheiros possam experimentar o quanto quiserem, sem se preocupar em bagunçar uma instalação de produção.

Todos os arquivos usados para instalar e configurar o MLflow podem ser encontrados em nosso repositório Github .

Opções de instalação

A documentação do MLFlow lista nada menos que 6 opções para instalar o MLFlow. Isso pode parecer um exagero, mas essas opções acomodam preferências diferentes para um banco de dados e níveis variados de complexidade da rede.

A opção mais adequada para uma organização que tem várias equipes usando grandes conjuntos de dados e construindo modelos que podem se tornar bastante grandes é mostrada abaixo. Esta opção requer a configuração de três servidores - um servidor de rastreamento, um banco de dados PostgreSQL e um armazenamento de objetos S3 - nossa implementação usará MinIO.

O Tracking Server é um ponto de entrada único da máquina de desenvolvimento de um engenheiro para acessar a funcionalidade do MLflow. (Não se deixe enganar pelo nome - ele contém todos os componentes listados acima - Rastreamento, Modelo, Projetos e Repositórios.) O servidor de Rastreamento usa PostgreSQL para armazenar entidades. As entidades são execuções, parâmetros, métricas, tags, notas e metadados. (Mais sobre execuções posteriormente.) O servidor Tracking em nossa implementação acessa MinIO para armazenar artefatos. Exemplos de artefatos são modelos, conjuntos de dados e arquivos de configuração.

O que é interessante nas ferramentas modernas disponíveis para os engenheiros atualmente é que você pode emular um ambiente de produção - incluindo opções de ferramentas e conectividade de rede - usando contêineres. É isso que vou mostrar neste post. Mostrarei como usar o Docker Compose para instalar os servidores descritos acima como serviços executados em um contêiner. Além disso, a configuração do MLflow é definida de forma que você possa usar uma instância existente do MinIO, se desejar. Neste post, mostrarei como implantar uma nova instância do MinIO, mas os arquivos em nosso repositório Github possuem um arquivo `docker-compose` que mostra como conectar-se a uma instância existente do MinIO.

O que iremos instalar

Abaixo está uma lista de tudo que precisa ser instalado. Esta lista inclui servidores que se tornarão serviços em contêineres (MinIO, Postgres e MLFlow), bem como os SDKs necessários (MinIO e MLflow).

1. Área de Trabalho Docker

2. Servidor de rastreamento MLFlow via Docker Compose

3. Servidor MinIO via Docker Compose

4. PostgreSQL via Docker Compose

5. SDK MLFlow via instalação pip

6. MinIO SDK via instalação pip

   
   

Vamos começar com o Docker Desktop, que servirá como host para nossos serviços Docker Compose.

Área de Trabalho Docker

Você pode encontrar a instalação apropriada para o seu sistema operacional no site do Docker. Se estiver instalando o Docker Desktop em um Mac, você precisará saber qual chip seu Mac está usando – Apple ou Intel. Você pode determinar isso clicando no ícone da Apple no canto superior esquerdo do seu Mac e clicando na opção de menu “Sobre este Mac”.

Agora estamos prontos para instalar nossos serviços.

Servidor MLFlow, Postgres e MinIO

O MLFLow Tracking Server, PostgresSQL e MinIO serão instalados como serviços usando o arquivo Docker Compose mostrado abaixo.

 version: "3.3" services: db: restart: always image: postgres container_name: mlflow_db expose: - "${PG_PORT}" networks: - backend environment: - POSTGRES_USER=${PG_USER} - POSTGRES_PASSWORD=${PG_PASSWORD} - POSTGRES_DATABASE=${PG_DATABASE} volumes: - ./db_data:/var/lib/postgresql/data/ healthcheck: test: ["CMD", "pg_isready", "-p", "${PG_PORT}", "-U", "${PG_USER}"] interval: 5s timeout: 5s retries: 3 s3: restart: always image: minio/minio container_name: mlflow_minio volumes: - ./minio_data:/data ports: - "${MINIO_PORT}:9000" - "${MINIO_CONSOLE_PORT}:9001" networks: - frontend - backend environment: - MINIO_ROOT_USER=${MINIO_ROOT_USER} - MINIO_ROOT_PASSWORD=${MINIO_ROOT_PASSWORD} - MINIO_ADDRESS=${MINIO_ADDRESS} - MINIO_PORT=${MINIO_PORT} - MINIO_STORAGE_USE_HTTPS=${MINIO_STORAGE_USE_HTTPS} - MINIO_CONSOLE_ADDRESS=${MINIO_CONSOLE_ADDRESS} command: server /data healthcheck: test: ["CMD", "curl", "-f", "http://localhost:9000/minio/health/live"] interval: 30s timeout: 20s retries: 3 tracking_server: restart: always build: ./mlflow image: mlflow_server container_name: mlflow_server depends_on: - db ports: - "${MLFLOW_PORT}:5000" networks: - frontend - backend environment: - AWS_ACCESS_KEY_ID=${MINIO_ACCESS_KEY} - AWS_SECRET_ACCESS_KEY=${MINIO_SECRET_ACCESS_KEY} - MLFLOW_S3_ENDPOINT_URL=http://s3:${MINIO_PORT} - MLFLOW_S3_IGNORE_TLS=true command: > mlflow server --backend-store-uri postgresql://${PG_USER}:${PG_PASSWORD}@db:${PG_PORT}/${PG_DATABASE} --host 0.0.0.0 --serve-artifacts --artifacts-destination s3://${MLFLOW_BUCKET_NAME} healthcheck: test: ["CMD", "curl", "-f", "http://localhost:${MLFLOW_PORT}/"] interval: 30s timeout: 10s retries: 3 volumes: db_data: minio_data: networks: frontend: driver: bridge backend: driver: bridge

Há algumas coisas dignas de nota que o ajudarão a solucionar problemas caso algo dê errado. Primeiro, tanto o MinIO quanto o PostgreSQL usam o sistema de arquivos local para armazenar dados. Para PostgreSQL, esta é a pasta `db_data` e para MinIO, é a pasta `minio_data`. Se você quiser recomeçar com uma instalação limpa, exclua essas pastas.

Em seguida, este arquivo Docker Compose é orientado pela configuração. Por exemplo, em vez de codificar o nome do banco de dados PostgreSQL para `mlflow`, o nome vem do arquivo `config.env` mostrado abaixo usando a seguinte sintaxe no arquivo Docker Compose - `${PG_DATABASE}`.

 # Postgres configuration PG_USER=mlflow PG_PASSWORD=mlflow PG_DATABASE=mlflow PG_PORT=5432 # MLflow configuration MLFLOW_PORT=5000 MLFLOW_BUCKET_NAME=mlflow # MinIO access keys - these are needed by MLflow MINIO_ACCESS_KEY=XeAMQQjZY2pTcXWfxh4H MINIO_SECRET_ACCESS_KEY=wyJ30G38aC2UcyaFjVj2dmXs1bITYkJBcx0FtljZ # MinIO configuration MINIO_ROOT_USER: 'minio_user' MINIO_ROOT_PASSWORD: 'minio_pwd' MINIO_ADDRESS: ':9000' MINIO_STORAGE_USE_HTTPS: False MINIO_CONSOLE_ADDRESS: ':9001' MINIO_PORT=9000 MINIO_CONSOLE_PORT=9001

Todas as variáveis de ambiente necessárias para esses serviços são configuradas neste arquivo. Este arquivo de configuração também contém informações necessárias para que esses serviços se comuniquem entre si. Observe que é o uso de variáveis de ambiente que informa ao servidor MLFlow Tracking como acessar o MinIO. Em outras palavras, a URL (incluindo o número da porta), a chave de acesso, a chave de acesso secreta e o bucket. Isso me leva ao meu ponto final e mais importante sobre o uso do Docker Compose - na primeira vez que você abrir esses serviços, os serviços de rastreamento do MLflow não funcionarão porque você precisará primeiro entrar na UI do MinIO, obter suas chaves e criar o bucket que o serviço de rastreamento usará para armazenar artefatos.

Vamos fazer isso agora. Inicie os serviços pela primeira vez usando o comando abaixo.

 docker-compose --env-file config.env up -d --build

Certifique-se de executar este comando no mesmo diretório onde o arquivo Docker Compose está localizado.

Agora podemos obter nossas chaves e criar nosso bucket usando a UI do MinIO.

O console MinIO

No seu navegador, vá para `localhost:9001`. Se você especificou uma porta diferente para o endereço do console MinIO no arquivo `docker-compose`, use essa porta. Faça login usando o usuário root e a senha especificados no arquivo `config.env`.

Depois de fazer login, navegue até a guia Chaves de acesso e clique no botão Criar chave de acesso.

Isso o levará para a página Criar chave de acesso.

Sua chave de acesso e chave secreta não serão salvas até você clicar no botão Criar. Não saia desta página até que isso seja feito. Não se preocupe em copiar as chaves desta tela. Depois de clicar no botão Criar, você terá a opção de baixar as chaves para o seu sistema de arquivos (em um arquivo JSON). Se você quiser usar o MinIO SDK para gerenciar dados brutos, crie outra chave de acesso e chave secreta enquanto estiver nesta página.

Em seguida, crie um bucket chamado `mlflow`. Isso é simples, vá até a guia Buckets e clique no botão `Criar Bucket`.

Depois de ter suas chaves e criar seu bucket, você pode terminar de configurar os serviços parando os contêineres, atualizando o `config.env` e reiniciando os contêineres. O comando abaixo irá parar e remover seus contêineres.

 docker-compose down

Reiniciar:

 docker-compose --env-file config.env up -d --build

Em seguida, vamos iniciar a IU do MLflow e verificar se tudo está funcionando.

Iniciando a IU do MLflow

Navegue até `localhost:5000`. Você deverá ver a IU do MLflow.

Reserve algum tempo para explorar todas as guias. Se você é novo no MLflow, familiarize-se com o conceito de execuções e experimentos.

• Uma execução é uma passagem pelo seu código que geralmente resulta em um modelo treinado.
• Os experimentos são uma forma de marcar execuções relacionadas para que você possa vê-las agrupadas na interface do usuário do MLflow. Por exemplo, você pode ter treinado vários modelos usando parâmetros diferentes na tentativa de obter a melhor precisão (ou desempenho). Marcar essas execuções com o mesmo nome de experimento irá agrupá-las na guia Experimentos.

Instale o pacote MLflow Python.

O pacote MLflow Python é uma instalação simples `pip`. Eu recomendo instalá-lo em um ambiente virtual Python.

 pip install mlflow

Verifique a instalação listando a biblioteca MLflow.

 pip list | grep mlflow

Você deverá ver a biblioteca abaixo.

 mlflow 2.5.0

Instale o pacote MinIO Python

Você não precisa acessar o MinIO diretamente para aproveitar as vantagens dos recursos do MLflow - o SDK do MLflow fará interface com a instância do MinIO que configuramos acima. No entanto, você pode querer interagir diretamente com esta instância do MinIO para gerenciar os dados antes que eles sejam fornecidos ao MLflow. MinIO é uma ótima maneira de armazenar todos os tipos de dados não estruturados. O MinIO faz uso total do hardware subjacente, para que você possa salvar todos os dados brutos necessários sem se preocupar com escala ou desempenho . MinIO inclui recursos de replicação de bucket para manter os dados em vários locais sincronizados. Além disso, algum dia a IA será regulamentada; quando esse dia chegar, você precisará dos recursos corporativos do MinIO ( bloqueio de objetos , controle de versão , criptografia e bloqueios legais ) para proteger seus dados em repouso e para garantir que você não exclua acidentalmente algo que uma agência reguladora possa solicitar.

Se você instalou o pacote MLflow Python em um ambiente virtual, instale o MinIO no mesmo ambiente.

 pip install minio

Verifique novamente a instalação.

 pip list | grep minio

Isso confirmará se a biblioteca Minio foi instalada e exibirá a versão que você está usando.

 minio 7.1.15

Resumo

Esta postagem forneceu uma receita fácil de seguir para configurar MLflow e MinIO em uma máquina de desenvolvimento. O objetivo era economizar tempo e esforço de pesquisa dos servidores MLflow e da configuração do docker-compose.

Todos os esforços foram feitos para manter esta receita precisa. Se você tiver algum problema, informe-nos enviando uma mensagem para [email protected] ou participando da discussão em nosso canal geral do Slack .

Você está pronto para começar a codificar e treinar modelos com MLflow e MinIO.