Integrações de Ferramentas de Machine Learning #2 DVC para o seu Versionamento de Dados

O controle de versão de dados (DVC) é uma ferramenta poderosa para gerenciar e versionar grandes conjuntos de dados e modelos em projetos de aprendizado de máquina.

DVC é uma ferramenta de código aberto que funciona com uma ampla gama de opções de armazenamento, incluindo disco local, sistemas de arquivos de rede, Amazon S3, Google Cloud Storage e muitos outros. O DVC pode ser usado em conjunto com frameworks populares de aprendizado de máquina como TensorFlow, PyTorch e scikit-learn.

Além de rastrear alterações em dados e modelos, o DVC também pode ajudar os usuários a gerenciar dependências entre diferentes componentes de um projeto de aprendizado de máquina, como código, dados e modelos. Ao manter o controle dessas dependências, o DVC facilita a reprodução de experimentos de aprendizado de máquina e o compartilhamento de projetos com outras pessoas.

Desafios do Controle de Versão em Aprendizado de Máquina

O controle de versão em Aprendizado de Máquina é uma tarefa mais difícil em comparação com a Engenharia de Software pelos seguintes motivos:

1. Conjuntos de dados grandes e complexos: Em aprendizado de máquina, os conjuntos de dados usados para treinar e testar modelos podem ser massivos, tornando desafiador gerenciá-los e versioná-los. Além disso, os dados podem ser não estruturados, dificultando o rastreamento de alterações nos dados ao longo do tempo.
2. Múltiplos componentes: Projetos de aprendizado de máquina frequentemente envolvem múltiplos componentes, incluindo dados, código e modelos, tornando desafiador acompanhar as alterações em cada componente e como eles interagem entre si.
3. Processo de desenvolvimento iterativo: Em Aprendizado de Máquina, o processo de desenvolvimento é frequentemente iterativo, com desenvolvedores atualizando modelos frequentemente com base em novos dados ou melhorando a precisão do modelo. Gerenciar essas alterações e versões pode ser complexo e demorado.

O DVC resolve esses problemas fornecendo uma maneira simples e eficiente de controlar a versão de dados e modelos em projetos de aprendizado de máquina. O DVC permite que você controle a versão não apenas do código, mas também dos dados e modelos, e rastreie os relacionamentos entre eles. Com o DVC, você pode reproduzir facilmente experimentos anteriores, colaborar com membros da equipe e automatizar fluxos de trabalho para otimizar o processo de desenvolvimento.

Instalação e Configuração de Sistemas de Controle de Versão

Para começar com o DVC, você precisa instalá-lo e configurá-lo em sua máquina local. Nesta seção, forneceremos instruções passo a passo sobre como fazer isso, incluindo como configurar o DVC para funcionar com diferentes serviços de armazenamento em nuvem e como criar um novo projeto DVC.

1. Instalar DVC: O primeiro passo é instalar o DVC em sua máquina local. Você pode fazer isso seguindo as instruções de instalação para o seu sistema operacional no site do DVC.
2. Criar um novo projeto DVC: Uma vez que o DVC esteja instalado, você pode criar um novo projeto DVC executando o seguinte comando em seu terminal:

dvc init


Isso criará um novo projeto DVC no seu diretório atual.

3. Configure o DVC para funcionar com armazenamento em nuvem: Se você deseja usar o DVC com serviços de armazenamento em nuvem como Amazon S3 ou Google Cloud Storage, você precisa configurar o DVC para funcionar com esses serviços. Você pode fazer isso adicionando um novo remoto usando o seguinte comando:

dvc remote add -d <remote-name> <storage-url>


Por exemplo, se você quiser adicionar um remoto Amazon S3 chamado "my-s3-remote", você pode executar o seguinte comando:

dvc remote add -d my-s3-remote s3://my-bucket-name


Isso adicionará um novo remoto ao seu projeto DVC que está configurado para funcionar com o Amazon S3.

4. Adicione dados ao seu projeto DVC: Depois de configurar seu projeto DVC e configurá-lo para funcionar com armazenamento em nuvem, você pode começar a adicionar dados a ele. Você pode fazer isso executando o seguinte comando:

dvc add <path-to-data-file>


Isso adicionará o arquivo de dados ao seu projeto DVC e criará um arquivo DVC correspondente que rastreia as alterações nos dados.

5. Envie as alterações para o armazenamento remoto: Se você configurou seu projeto DVC para funcionar com armazenamento remoto, você pode enviar as alterações para este armazenamento executando o seguinte comando:

dvc push


Isso enviará quaisquer alterações que você tenha feito aos seus dados ou modelos para o armazenamento remoto.

Executando Comandos DVC para Controle de Versão Aprimorado

O DVC oferece uma série de comandos úteis para gerenciar e versionar projetos de aprendizado de máquina. Aqui está uma lista de alguns dos comandos DVC mais comumente usados:

1. dvc init: Inicializa um novo projeto DVC no diretório atual.
2. dvc add <path-to-file>: Adiciona um arquivo ao DVC e cria um arquivo DVC correspondente para rastrear alterações no arquivo.
3. dvc run: Executa um comando ou script com o rastreamento DVC ativado, para que quaisquer entradas e saídas sejam rastreadas pelo DVC.
4. dvc repro: Reproduz um comando ou script rastreado pelo DVC, garantindo que todas as dependências estejam atualizadas.
5. dvc push: Envia todos os arquivos de dados e arquivos de modelo para o armazenamento remoto, como AWS S3 ou Google Cloud Storage.
6. dvc pull: Puxa todos os arquivos de dados e arquivos de modelo do armazenamento remoto para a máquina local.
7. dvc status: Mostra o status dos arquivos rastreados, incluindo se foram modificados, adicionados ou excluídos.
8. dvc log: Mostra uma lista de todas as versões de um arquivo, juntamente com suas mensagens de commit correspondentes e outros metadados.

Reproduzindo Experimentos de ML usando DVC

Um dos benefícios mais significativos do uso do DVC é sua capacidade de reproduzir experimentos de aprendizado de máquina. Com o DVC, você pode definir e rastrear as dependências entre seu código, dados e modelos, e usar o dvc repro comando para reproduzir experimentos anteriores.

Fluxo de Trabalho de Exemplo:
Claro, aqui está um exemplo de fluxo de trabalho para um conjunto de dados iris do sklearn usando um arquivo .yaml:

1. Primeiro, inicialize um novo projeto DVC executando o comando dvc init.
2. Crie um data diretório na sua pasta de projeto para armazenar o conjunto de dados, e baixe o conjunto de dados iris do sklearn para este diretório.
3. Adicione os arquivos de dados ao DVC usando o comando dvc add. Por exemplo: dvc add data/iris.csv.
4. Crie um .yaml arquivo para definir o pipeline. Por exemplo, iris.yaml. Este arquivo conterá os comandos para pré-processamento, treinamento e avaliação do modelo.
5. Defina os passos no .yaml arquivo usando os comandos DVC. Por exemplo:

stages:
 preprocess:
   cmd: python preprocess.py data/iris.csv data/preprocessed.csv
   deps:
     - data/iris.csv
   outs:
     - data/preprocessed.csv

 train:
   cmd: python train.py data/preprocessed.csv models/model.pkl
   deps:
     - data/preprocessed.csv
   outs:
     - models/model.pkl

 evaluate:
   cmd: python evaluate.py models/model.pkl data/iris.csv
   deps:
     - models/model.pkl
     - data/iris.csv


6. Execute o pipeline usando o comando dvc repro. Este comando executará as etapas definidas no arquivo .yaml na ordem correta, garantindo que todas as dependências estejam atualizadas. Por exemplo: dvc repro iris.yaml.

Ao definir seu pipeline em um .yaml arquivo e usando o dvc repro comando, você pode reproduzir facilmente seus experimentos, rastrear as versões dos seus dados e modelos, e colaborar com os membros da equipe no seu projeto de aprendizado de máquina.

Aqui está um exemplo de fluxo de trabalho:

1. Configure as credenciais e as informações de endpoint apropriadas para o servidor S3:

dvc remote add -d s3remote s3://your-s3-bucket-name/path/to/models


2. Baixe os arquivos de modelo necessários do servidor S3 para a máquina local:

dvc pull -r s3remote path/to/models/model.pkl


3. Copie os arquivos de modelo baixados para o servidor remoto de destino:

scp path/to/models/model.pkl user@target-remote-server:/path/to/models/


4. Use os arquivos copiados para inferência no servidor remoto de destino:

# Carregar o modelo
import pickle
with open('/path/to/models/model.pkl', 'rb') as f:
   model = pickle.load(f)

# Fazer previsões
X_test = [[5.1, 3.5, 1.4, 0.2], [7.7, 3.0, 6.1, 2.3], [6.0, 3.0, 4.8, 1.8]]
y_pred = model.predict(X_test)
print(y_pred)


Este fluxo de trabalho pressupõe que você configurou as credenciais e informações de endpoint necessárias para o servidor S3, e que você tem acesso tanto aos servidores locais quanto remotos de destino. Você pode modificar o fluxo de trabalho com base nas suas necessidades e configuração específicas.

Como o TrueFoundry se integra com o DVC:

O TrueFoundry integra-se perfeitamente com o DVC Model Registry para permitir que você implante modelos registrados no DVC no seu Cluster Kubernetes usando o TrueFoundry.

📌

Além de usar o DVC para gerenciamento de modelos e rastreamento de experimentos, você também pode usar o MLFoundry de Rastreamento de Experimentos da Truefoundry.

Passo 1 - Instalar e configurar:

• Configurar DVC

# Instalar DVC e suporte S3
pip install dvc dvc-s3

# Inicializar Git no diretório local
git init

# Inicializar DVC no diretório local
dvc init

# Definir o armazenamento remoto do DVC como seu bucket
dvc remote add s3://<your_bucket_name>

Nota: Você terá que configurar seu s3 cli para que isso funcione

• Importar dvc

import dvc

x

• Instalar servicefoundry

pip install -U "servicefoundry"

• Fazer login no truefoundry

sfy login

Passo 2 - Treinar e registrar o modelo:

Vamos treinar nosso modelo de ML e salvá-lo como um arquivo joblib
Em seguida, adicionaremos o modelo e as métricas de avaliação usando **`dvc add`**
Em seguida, enviaremos nosso arquivo joblib para o dvc via **`dvc push`**

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report
import joblib
import os

# Carregar e pré-processar os dados
X, y = load_iris(as_frame=True, return_X_y=True)
X = X.rename(columns={
       "sepal length (cm)": "sepal_length",
       "sepal width (cm)": "sepal_width",
       "petal length (cm)": "petal_length",
       "petal width (cm)": "petal_width",
})

X_train, X_test, y_train, y_test = train_test_split(
   X, y, test_size=0.2, random_state=42, stratify=y
)

# Inicializar o modelo
clf = LogisticRegression(solver="liblinear")

# Treinar o modelo
clf.fit(X_train, y_train)

# Avaliar o modelo
preds = clf.predict(X_test)

# Salvar o modelo usando joblib e DVC
joblib.dump(clf, "model.joblib")
os.system("dvc add model.joblib")

# Registrar as métricas de avaliação
report = classification_report(y_test, preds, output_dict=True)
with open("classification_report.txt", "w") as f:
   f.write(str(report))

# Enviar o modelo e as métricas de avaliação para o armazenamento remoto
os.system("dvc push")

Passo 3 - Criar uma aplicação de inferência e arquivo de dependência:

Teremos que criar dois arquivos para implantar no truefoundry, um app.py arquivo que contém o código da nossa aplicação, e um requirements.txt arquivo que contém as nossas dependências.

.
├── app.py
├── deploy.py
└── requirements.txt


• app.py:

import os
import joblib
import pandas as pd
from fastapi import FastAPI

# Recuperar o modelo do S3 usando DVC
os.system("dvc pull model.joblib.dvc")

# Carregar o modelo
model = joblib.load("model.joblib")

# Carregar o modelo
app = FastAPI()

@app.post("/predict")
def predict(
   sepal_length: float, sepal_width: float, petal_length: float, petal_width: float
):
   data = dict(
       sepal_length=sepal_length,
       sepal_width=sepal_width,
       petal_length=petal_length,
       petal_width=petal_width,
   )
   prediction = int(model.predict(pd.DataFrame([data]))[0])
   return {"prediction": prediction}

• requirements.txt:

fastapi
pandas
joblib
dvc

Passo 4 - Use o SDK Python da truefoundry e configure a implantação

• deploy.py:

import argparse
import logging
from servicefoundry import Build, PythonBuild, Service, Resources, Port

# Configurar o logger
logging.basicConfig(level=logging.INFO)

# Configurar o parser de argumentos
parser = argparse.ArgumentParser()
parser.add_argument("--workspace_fqn", required=True, type=str)
args = parser.parse_args()

service = Service(
   name="fastapi",
   image=Build(
       build_spec=PythonBuild(
           command="uvicorn app:app --port 8000 --host 0.0.0.0",
           requirements_path="requirements.txt",
       )
   ),
   ports=[
       Port(
           port=8000,
           host="ml-deploy-aditya-ws-8000.demo.truefoundry.com",
       )
   ],
   resources=Resources(
       cpu_request=0.25,
       cpu_limit=0.5,
       memory_request=200,
       memory_limit=400,
       ephemeral_storage_request=200,
       ephemeral_storage_limit=400,
   ),
)
service.deploy(workspace_fqn=args.workspace_fqn)

Passo 5 - Implemente seu Serviço via Truefoundry

Execute o seguinte comando e passe seu

• Workspace FQN: que você pode encontrar no painel

python deploy.py --workspace_fqn your_workspace_fqn

E pronto!!! Nos logs você pode encontrar o painel do seu serviço implementado. E então, no canto superior direito, você encontrará o endpoint das suas aplicações implementadas.

TrueFoundry é uma PaaS de Implementação de ML sobre Kubernetes para acelerar os fluxos de trabalho dos desenvolvedores, permitindo-lhes total flexibilidade no teste e implementação de modelos, ao mesmo tempo que garante total segurança e controle para a equipe de Infraestrutura. Através da nossa plataforma, capacitamos as equipes de Machine Learning a implementar e monitorar modelos em 15 minutos com 100% de confiabilidade, escalabilidade e a capacidade de reverter em segundos - permitindo-lhes economizar custos e lançar Modelos em produção mais rapidamente, possibilitando a realização de valor de negócio real.