MLFlow: gerenciamento de experimentos e integração com IA generativa

Conhecendo o MLFlow - Apresentação

Introdução ao Curso de MLFlow

Olá! Seja bem-vindo a mais um curso da Alura. Neste curso, vamos explorar diversos aspectos interessantes sobre o MLFlow.

Apresentação do Instrutor Leonardo Pena

Antes de começarmos, vamos nos apresentar. Meu nome é Leonardo Pena e serei o instrutor deste curso. Sou formado em Estatística e possuo uma vasta experiência na área.

Audiodescrição: Leonardo é um homem branco, com cabelo curto castanho e olhos castanhos. Ele veste uma camisa azul e está em um ambiente de estúdio com uma parede clara ao fundo.

Objetivo do Curso

Nosso objetivo é proporcionar um entendimento aprofundado sobre o MLFlow, abordando suas funcionalidades e aplicações práticas. Vamos juntos nessa jornada de aprendizado!

Conhecendo o MLFlow - Conhecendo O Mlflow

Apresentando o curso de MLFlow

Seja bem-vindo à nossa primeira aula do curso de MLFlow, focado na avaliação de modelos de IA. Nesta aula, vamos apresentar uma introdução básica ao MLFlow, abordando conceitos e definições fundamentais, as motivações para seu uso e as principais definições para nos prepararmos para as próximas aulas, onde colocaremos em prática o que aprendemos.

Vamos dar uma visão geral do curso, que será composto por várias aulas nas quais evoluiremos tanto em teoria quanto em prática. Aplicaremos na prática os conceitos que formos aprendendo. Nesta primeira aula, focaremos na introdução básica ao MLFlow, apresentando os principais conceitos. Em seguida, abordaremos o Tracking Avançado e o Model Registry, que é uma ferramenta essencial no MLFlow. Também discutiremos a versão 3.0 do MLFlow, que trouxe a capacidade de avaliação de modelos de IA generativa. Além disso, falaremos sobre o MLFlow para LLMs e a integração com a biblioteca LangChain. Por fim, teremos uma aula sobre o papel incompleto de GNI e de avaliação, que será nossa Aula 5.

Destacando a importância da prática

Em todas as aulas, passaremos brevemente pela teoria e, em seguida, iremos direto para a prática, pois é com a prática que realmente aprendemos sobre a teoria. O objetivo desta aula é claro e prático: compreender os principais conceitos e fundamentos do MLFlow, tanto na teoria quanto na prática. Realizaremos juntos o primeiro experimento, onde aprenderemos a fazer o tracking de métricas, parâmetros e artefatos. Isso é crucial por três motivos principais: as métricas nos indicam o desempenho do modelo, os parâmetros permitem a reprodução dos experimentos e os artefatos preservam nossos resultados e modelos.

Para começar a prática, precisamos instalar o MLFlow. Isso é feito com o seguinte comando:

pip install mlflow

Após a instalação, podemos configurar o ambiente para o MLFlow. Vamos definir a URI de rastreamento para um banco de dados SQLite, que armazenará nossos dados de experimentos:

export MLFLOW_TRACKING_URI=sqlite:///mlflow.db

E no código Python, configuramos o MLFlow para usar essa URI:

mlflow.set_tracking_uri("sqlite:///mlflow.db")

Realizando o primeiro experimento com MLFlow

Agora que temos o ambiente configurado, vamos realizar nosso primeiro experimento. Utilizaremos o MLFlow para registrar parâmetros, métricas e artefatos. Aqui está um exemplo básico de como isso é feito:

import mlflow

with mlflow.start_run():
    mlflow.log_param("learning_rate", 0.01)
    mlflow.log_metric("accuracy", 0.95)
    mlflow.log_artifact("model.pkl")

Neste exemplo, iniciamos uma nova execução com mlflow.start_run(). Registramos um parâmetro chamado "learning_rate" com o valor 0.01, uma métrica de "accuracy" com o valor 0.95, e um artefato chamado "model.pkl", que poderia ser o arquivo do modelo treinado.

Ao final da aula, teremos não apenas o conhecimento teórico, mas também uma experiência prática de uso do MLFlow em um projeto real, permitindo aplicar esses conceitos em futuros projetos. Antes de começar, vamos entender o que é o MLFlow. Ele é uma plataforma open source (código aberto), o que significa que temos acesso completo ao código e podemos customizá-lo conforme nossas necessidades, sem ficarmos presos a um fornecedor específico. Isso é um grande benefício no mundo do software.

Explorando os benefícios do MLFlow

O MLFlow se diferencia por gerenciar o ciclo de vida completo do machine learning, desde a experimentação inicial até o modelo em produção. Ele unifica quatro aspectos críticos: experimentação, reprodutibilidade, deployment (implantação) e registro central dos modelos. Sem o MLFlow, precisaríamos de várias ferramentas diferentes para cada etapa, mas ele integra e automatiza tudo isso.

Vamos entender os problemas específicos que o MLFlow resolve. O primeiro é a rastreabilidade, que é a dificuldade de reproduzir experimentos. Muitas vezes, temos um modelo que funciona bem, mas, após algumas semanas, não conseguimos mais reproduzir os resultados devido à perda de controle dos parâmetros exatos, da versão de dados ou do código utilizado. O segundo problema é organizacional, onde o código está espalhado em vários notebooks, os parâmetros anotados em comentários ou na memória da pessoa desenvolvedora, sem uma estrutura clara de conexão.

Por exemplo, se desenvolvemos um modelo de classificação que alcançou 95% de acurácia, e três meses depois um gerente solicita uma versão melhorada, sem o MLFlow, teríamos dificuldades em reproduzir e melhorar o modelo devido à falta de organização e rastreabilidade.

Compreendendo os componentes do MLFlow

Nós não conseguimos reproduzir nem mesmo os 95% originais do que foi feito, pois não lembramos se foi utilizado o standard scale (escala padrão) ou o min-max scaler (escalador min-max), qual foi o random state (estado aleatório) ou qual foi a versão do dataset (conjunto de dados) utilizada. Isso pode gerar alguns problemas. No entanto, esses problemas são resolvidos com o uso do MLFlow. Outros desafios que enfrentamos incluem o deployment (implantação), a complexidade para colocar o modelo em produção, a colaboração e o compartilhamento de resultados entre equipes, além dos componentes do MLFlow.

É crucial entendermos os quatro componentes do MLFlow: tracking (rastreamento), projects (projetos), models (modelos) e MLFlow registry (registro do MLFlow). Vamos abordar cada um deles para que fique claro, e depois aplicaremos na prática. Compreender esses termos é essencial para entender o MLFlow. O MLFlow resolve os problemas mencionados por meio desses quatro componentes principais, cada um com uma função específica, mas integrados entre si.

Detalhando o MLFlow tracking

O primeiro componente é o MLFlow tracking, que é o coração da plataforma. Ele registra e permite consultar os experimentos, incluindo códigos, dados, configurações e resultados. É aqui que resolvemos os problemas de rastreabilidade e reprodutibilidade.

Em seguida, temos o MLFlow projects, que fornece um formato padronizado para empacotar o código de machine learning de forma reprodutível. É como ter um contêiner para os experimentos que pode ser executado em qualquer ambiente.

O MLFlow models é uma convenção para empacotar os modelos de machine learning em múltiplos formatos. Podemos treinar um modelo em Python e depois fazer o deploy em Java, ou treinar um modelo em TensorFlow e servir em uma REST API, por exemplo.

Por fim, o MLFlow registry é um armazém central para gerenciar o ciclo de vida completo dos modelos. Podemos controlar a versão, as aprovações e a transição entre ambientes de desenvolvimento, teste e produção. Vamos explorar isso com mais calma em breve. Podemos pensar no MLFlow como um sistema de controle de versão, semelhante ao Git, mas específico para machine learning. Ele vai além do código e inclui dados, modelos, métricas e metadados.

Integrando os componentes do MLFlow

Visualizando como esses componentes se integram, temos um diagrama que mostra os quatro componentes do MLFlow trabalhando juntos de forma integrada. Eles não são ferramentas isoladas, mas formam um ecossistema complexo. O fluxo típico começa com o MLFlow tracking, registrando experimentos. Quando temos um experimento promissor, podemos empacotá-lo como um MLFlow project para garantir a reprodutibilidade. O modelo resultante é salvo no formato do MLFlow models, permitindo um deployment mais flexível. Finalmente, modelos aprovados são promovidos através do MLFlow registry, que é a última etapa.

Por exemplo, ao desenvolver um chatbot, podemos testar diferentes arquiteturas, fazer o tracking, empacotar e melhorar a abordagem no project, salvar o modelo treinado no models e, quando aprovado pela equipe, promovê-lo para a produção com o registry. Um ponto importante é que cada componente pode ser usado independentemente, mas o verdadeiro poder vem da integração de todos eles. Podemos começar apenas com o tracking e, gradualmente, incorporar os outros componentes conforme necessário.

Explorando os conceitos fundamentais do tracking

Vamos falar um pouco sobre cada um deles. O tracking é o primeiro componente e possui cinco conceitos fundamentais que precisamos dominar. Primeiro, os experimentos, que agrupam as runs (execuções) relacionadas. Por exemplo, podemos ter um experimento chamado "classificação de sentimento", que contém todas as tentativas de resolver esse problema específico.

As runs são execuções individuais do código de machine learning. Dentro do experimento de classificação de sentimentos, podemos ter runs testando diferentes algoritmos, como SVM, Random Forest, BERT, entre outros. Os parâmetros são definidos antes do treinamento, como learning rate (taxa de aprendizado), número de épocas e tamanho de batch. Eles são imutáveis durante uma run específica.

As métricas são valores numéricos que podem mudar durante o treinamento, como acurácia, perda e F1 score. Podemos registrar múltiplos valores da mesma métrica ao longo do tempo. Os artefatos são os arquivos de saída, modelos, gráficos e dados, como o modelo treinado, o gráfico de performance e o dataset processado.

Preparando para a prática com MLFlow

Aqui temos um exemplo básico, e depois vamos detalhar o código. Há uma interface do MLFlow que também será abordada em detalhes. A instalação é feita com o comando pip install mlflow, e as configurações serão discutidas no próximo vídeo, onde abordaremos a parte prática. Após a instalação e configuração, acessamos o servidor MLFlow UI. Explicaremos isso na prática, mas já é importante entender a dinâmica dos códigos que utilizamos.

Para acessar a interface do usuário do MLFlow, utilizamos o seguinte comando:

mlflow ui

Isso abrirá a interface do MLFlow no navegador, onde podemos visualizar e gerenciar nossos experimentos.

Agora, vamos para a parte prática. Agradecemos e até o próximo vídeo.

Conhecendo o MLFlow - Fluxo De Machine Learning Sem Mlflow

Iniciando a prática com MLflow

Vamos dar início à parte prática, entrando no código e colocando em prática tudo o que vimos na teoria sobre o MLflow. Começaremos do básico, com um exemplo inicial do MLflow, para avançarmos gradualmente. Faremos uma espécie de "Hello World" do MLflow. O MLflow é interessante porque permite trabalhar com diferentes abordagens. Vamos utilizar notebooks, que são úteis para aprender uma nova ferramenta e visualizar os códigos gradualmente. Após aprender o MLflow, é recomendável integrá-lo a um arquivo .py estruturado, o que permite modularizar o script e deixá-lo bem organizado. O MLflow também possui integração com o Databricks, incluindo componentes como runs e experimentos, diretamente integrados ao Databricks.

Aqui, utilizaremos o VS Code, mas sinta-se à vontade para usar o ambiente de sua preferência, como o PyCharm. Eu prefiro o VS Code. Vamos abrir o terminal, pois é importante criar um ambiente virtual antes de iniciar qualquer projeto. Vamos criar o ambiente virtual e trabalhar a partir dele. Para isso, utilizamos o seguinte comando:

python -m venv .venv

Configurando o ambiente virtual

Para entrar no ambiente virtual, utilizamos o comando source, mas isso pode variar dependendo do sistema operacional, seja Macbook, Windows ou Linux. No caso de sistemas baseados em Unix, o comando é:

source .venv/bin/activate

Disponibilizaremos o arquivo requirements, que contém tudo o que é necessário para instalar as bibliotecas. O conteúdo do arquivo requirements.txt é o seguinte:

mlflow==2.8.0
numpy==1.26.0
matplotlib==3.8.0
scikit-learn==1.3.0
pandas==2.1.0
jupyter==1.0.0

Após a instalação, continuaremos. Para instalar as bibliotecas, utilizamos:

pip install -r requirements.txt

Preparando o ambiente de trabalho

As bibliotecas necessárias já foram instaladas. Vamos limpar o terminal e abrir o notebook, ampliando-o para melhor visualização. Na primeira aula, veremos um "Hello World" do MLflow. Sempre que aprendemos uma nova linguagem, começamos com um "Hello World". Aqui, apresentaremos um "Hello World" do MLflow para entender o básico e, posteriormente, avançar. A ideia é compreender o fluxo básico do MLflow e implementar um exemplo simples de regressão linear. É desejável ter algum conhecimento sobre modelos de regressão e ciência de dados. Caso não tenha, há muitos cursos na Alura sobre modelos de regressão. Não entraremos em detalhes sobre o modelo de regressão, mas daremos uma visão geral. Não é necessário ser especialista em machine learning, mas ter um conhecimento geral é importante para realizar o tracking e outras atividades.

Vamos aprender a registrar parâmetros, métricas e artefatos, e depois visualizar os resultados na interface web, que é uma das partes mais interessantes do MLflow, pois permite visualizar tudo integrado, incluindo experimentos e runs. Começaremos importando as bibliotecas principais, como NumPy, Matplotlib e Scikit-learn. Vamos preparar as métricas, como o erro quadrático médio (mean squared error) e o coeficiente de determinação (R2), e fazer alguns ajustes. Importaremos o NumPy como np e o Matplotlib como plt, que é nossa biblioteca de visualização de gráficos.

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_squared_error, r2_score

Introdução ao curso

Neste curso, abordaremos o MLflow, que também servirá como uma revisão de conceitos presentes nos códigos de ciência de dados, visualização e outros. Explicaremos tudo em detalhes para garantir que todos estejam na mesma página. Utilizaremos o Scikit-learn, uma biblioteca essencial para modelos de machine learning. Ela oferece diversas ferramentas, incluindo Datasets, mas, neste caso, focaremos nos Linear Models. Sempre que trabalhamos com machine learning, o Scikit-learn é uma das principais bibliotecas. Vamos trabalhar com a classe LinearRegression para criar e treinar um modelo de regressão linear. O Scikit-learn também oferece métricas de performance, que traremos com o Metrics. Utilizaremos duas delas: mean_squared_error e r2_score, que são funções para avaliar a performance do nosso modelo.

Configuração do ambiente

Vamos configurar o ambiente utilizando o componente mágico para exibir o Matplotlib inline, permitindo que os gráficos sejam exibidos diretamente no Jupyter Notebook. Definiremos o estilo visual dos gráficos como Seaborn WhiteGrid.

%matplotlib inline
plt.style.use('seaborn-v0.8-whitegrid')

Após importar as principais bibliotecas, geraremos alguns dados sintéticos para nossa regressão linear. Inicialmente, faremos isso sem o MLflow e, posteriormente, introduziremos o MLflow para demonstrar sua conexão com nosso código.

Geração de dados sintéticos

Para gerar dados sintéticos para a regressão linear, definiremos uma amostra de 100 pontos de dados.

n_amostras = 100
X = np.linspace(0, 10, n_amostras).reshape(-1, 1)

Geraremos valores y com uma relação linear mais ruído. A fórmula da regressão linear é y = ax + b + ruído, onde a será 2, b será 5, e o ruído terá uma intensidade fixa de 10.

ruido = 10
y_true = 2 * X + 5
y = y_true + ruido * np.random.randn(n_amostras, 1)

Visualização dos dados

Para visualizar os dados sintéticos e a curva, criaremos uma figura com plt.figure de tamanho 10x6.

plt.figure(figsize=(10, 6))
plt.scatter(X, y, alpha=0.5, label='Dados')
plt.plot(X, y_true, color='green', linestyle='--', linewidth=2, label='Relação verdadeira')
plt.title('Dados Sintéticos para Regressão Linear')
plt.xlabel('X')
plt.ylabel('Y')
plt.legend()
plt.grid(True)
plt.show()

Próximos passos

No próximo vídeo, continuaremos treinando o modelo que criamos, inicialmente sem o MLflow, e depois introduziremos o MLflow para demonstrar sua integração. Agradecemos e até o próximo vídeo.

Sobre o curso MLFlow: gerenciamento de experimentos e integração com IA generativa

O curso MLFlow: gerenciamento de experimentos e integração com IA generativa possui 150 minutos de vídeos, em um total de 36 atividades. Gostou? Conheça nossos outros cursos de IA para Dados em Inteligência Artificial, ou leia nossos artigos de Inteligência Artificial.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Conhecendo o MLFlow
• Tracking Avançado e Model Registry
• MLFlow 3.0 para Generative AI - Fundamentos
• MLFlow para LLMs e LangChain
• Pipeline Completo Generative AI e Avaliação