Integrações da Plataforma de Machine Learning #1: Weights & Biases

O rastreamento de experimentos é um aspecto crítico do desenvolvimento de machine learning, permitindo que os profissionais gerenciem e acompanhem o progresso de seus experimentos de forma eficiente. O rastreamento de experimentos envolve o registro e monitoramento de vários fatores, como desempenho do modelo, hiperparâmetros e dados de treinamento, para obter insights sobre o desempenho do modelo de machine learning.

Desafios Enfrentados no Gerenciamento de Experimentos

Gerenciar experimentos e rastrear resultados pode ser uma tarefa desafiadora para profissionais de machine learning devido à complexidade dos modelos, à grande quantidade de dados envolvidos e à variedade de ferramentas e frameworks utilizados no desenvolvimento de machine learning. Aqui estão alguns dos principais desafios enfrentados pelos profissionais no gerenciamento de experimentos e rastreamento de resultados:

1. Reprodutibilidade: Reproduzir experimentos é essencial para verificar resultados e garantir que os modelos tenham um bom desempenho em cenários do mundo real. No entanto, reproduzir experimentos pode ser desafiador, especialmente ao lidar com modelos complexos, múltiplos frameworks e diferentes ambientes de computação.
2. Escalabilidade: Profissionais de machine learning frequentemente trabalham com grandes conjuntos de dados e, como tal, o treinamento de modelos pode ser um processo demorado que exige uma quantidade significativa de poder computacional. Gerenciar experimentos e rastrear resultados em escala requer ferramentas e infraestrutura que possam lidar com grandes volumes de dados e computações.
3. Colaboração: A colaboração é essencial no desenvolvimento de machine learning, mas gerenciar experimentos e rastrear resultados entre vários membros da equipe pode ser desafiador. Requer uma infraestrutura robusta para compartilhar dados, código e resultados de experimentos e garantir que todos tenham acesso aos mesmos recursos.
4. Gerenciamento de Dados: Modelos de machine learning dependem muito de dados, e gerenciar dados de forma eficaz é fundamental para o sucesso do modelo. No entanto, o gerenciamento de dados envolve vários desafios, como limpeza de dados, rotulagem de dados e versionamento de dados, que podem ser demorados e complexos.
5. Otimização de Hiperparâmetros: Encontrar os melhores hiperparâmetros para um modelo pode ser um processo desafiador e iterativo que envolve a execução de múltiplos experimentos com diferentes hiperparâmetros. Gerenciar esses experimentos e rastrear os resultados pode ser demorado e complexo.

Explorando os Recursos do Weights & Biases

Weights & Biases (W&B) é uma plataforma projetada para ajudar profissionais de machine learning a gerenciar e rastrear seus experimentos de forma eficaz. Ela oferece um conjunto de ferramentas para rastreamento de experimentos, visualização e colaboração, facilitando o desenvolvimento de modelos de machine learning robustos e escaláveis para os profissionais.

As principais características e benefícios da plataforma W&B são:

1. Rastreamento de Experimentos: O W&B permite que os usuários rastreiem seus experimentos registrando automaticamente hiperparâmetros do modelo, métricas e artefatos de saída. Isso permite que os profissionais acompanhem seus experimentos e comparem diferentes modelos e hiperparâmetros facilmente.
2. Visualizações: O W&B oferece um conjunto de ferramentas de visualização que permitem aos usuários visualizar seus experimentos e resultados. Isso inclui visualizações 3D, matrizes de confusão e gráficos de dispersão, entre outros. Isso ajuda os profissionais a entender melhor seus dados e a identificar padrões e tendências nos resultados dos experimentos.
3. Colaboração: O W&B facilita a colaboração com membros da equipe, fornecendo recursos para compartilhar experimentos, dados e resultados. Ele também oferece controle de versão para código e dados, garantindo que todos estejam trabalhando com os mesmos recursos.
4. Integração: O W&B pode ser facilmente integrado a uma ampla gama de frameworks de aprendizado de máquina, incluindo TensorFlow, PyTorch, Keras e Scikit-learn. Isso permite que os profissionais usem o W&B com seus fluxos de trabalho e frameworks existentes, sem exigir grandes mudanças em seu processo de desenvolvimento. [SEG 8] Organização:
5. O W&B oferece recursos para organizar experimentos, como projetos, execuções e tags. Isso facilita o gerenciamento e o rastreamento de experimentos entre vários membros da equipe e projetos. Guia Passo a Passo: Configurando Weights & Biases de Forma Fácil

A configuração do W&B para rastreamento de experimentos envolve várias etapas:

Crie uma conta W&B: O primeiro passo é criar uma conta gratuita no site do W&B. Isso pode ser feito visitando o site e seguindo o processo de inscrição.

1. Instale a biblioteca W&B: Após criar uma conta, o próximo passo é instalar a biblioteca W&B no ambiente de desenvolvimento. A biblioteca W&B pode ser instalada usando pip ou conda, dependendo da preferência do usuário e do ambiente de desenvolvimento.
2. Inicialize o W&B: Uma vez que a biblioteca esteja instalada, o usuário precisa inicializar o W&B no código chamando a
3. wandb.init() função. Esta função inicializa a biblioteca W&B e configura uma nova execução. Registre métricas: O usuário pode registrar métricas como perda e precisão durante o treinamento chamando a
4. wandb.log() função. Esta função recebe um dicionário de métricas como entrada e as registra no painel do W&B. Registre hiperparâmetros: O usuário também pode registrar hiperparâmetros como taxa de aprendizado e tamanho do lote chamando a
5. wandb.config função. Esta função recebe um dicionário de hiperparâmetros como entrada e os registra no painel do W&B.
6. Registrar visualizações: Finalmente, o usuário pode registrar visualizações como imagens e gráficos chamando a wandb.log() função com os dados de visualização apropriados. O W&B oferece uma ampla gama de ferramentas de visualização, incluindo visualizações 3D, matrizes de confusão e gráficos de dispersão, entre outros.

Exemplo:

Aqui está um exemplo de como registrar métricas, modelos, hiperparâmetros e visualizações usando W&B:

import wandb
import numpy as np
import matplotlib.pyplot as plt
import tensorflow as tf

# Passo 1: Inicializar W&B
wandb.init(project="my-project")

# Passo 2: Registrar hiperparâmetros
config = {
   "learning_rate": 0.001,
   "batch_size": 32,
   "epochs": 10
}
wandb.config.update(config)

# Passo 3: Treinar modelo e registrar métricas
model = tf.keras.models.Sequential([
   tf.keras.layers.Dense(10, activation='relu', input_shape=(10,)),
   tf.keras.layers.Dense(1)
])
model.compile(optimizer=tf.keras.optimizers.Adam(config['learning_rate']),
             loss=tf.keras.losses.MeanSquaredError(),
             metrics=[tf.keras.metrics.MeanAbsoluteError()])
for epoch in range(config['epochs']):
   # ... treinar modelo ...
   history = model.fit(x_train, y_train, batch_size=config['batch_size'])
   loss = history.history['loss'][-1]
   mae = history.history['mean_absolute_error'][-1]
   wandb.log({"epoch": epoch, "loss": loss, "mae": mae})

# Passo 4: Registrar visualizações e modelo
x = np.linspace(0, 10, 100)
y = np.sin(x)
fig, ax = plt.subplots()
ax.plot(x, y)
wandb.log({"my_plot": wandb.Image(fig)})
wandb.save('my_model.h5')

# Passo 5: Finalizar execução
wandb.finish()

c

Integração Perfeita: A Abordagem da TrueFoundry com Weights & Biases

A TrueFoundry integra-se perfeitamente com o Registro de Modelos do Weights & Biases para permitir que você implante modelos registrados no Weights & Biases no seu Cluster Kubernetes usando a TrueFoundry.

📌

Além de usar o Weights & Biases para gerenciamento de modelos e rastreamento de experimentos, você também pode usar o MLFoundy de Rastreamento de Experimentos da Truefoundry.

📌

Você também pode acompanhar o código abaixo através do seguinte notebook Colab:
Notebook Colab

Passo 1 - Instalar e configurar:

• Instalar wandb

pip install wandb -qU

• Fazer login na sua conta W&B

import wandb
wandb.login()

• Instalar servicefoundry

pip install -U "servicefoundry"

• Fazer login na Truefoundry

sfy login

Passo 2 - Treinar e registrar o modelo:

Primeiro, usaremos wandb.init() para inicializar o projeto
Em seguida, treinaremos nosso modelo de ML e o salvaremos como um arquivo joblib
Em seguida, salvaremos nosso arquivo joblib no wandb via wandb.save()

import wandb
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

# Inicializar W&B
wandb.init(project="iris-logistic-regression")

# 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",
       "largura da sépala (cm)": "sepal_width",
       "comprimento da pétala (cm)": "petal_length",
       "largura da pétala (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)

# Registrar o modelo e as métricas de avaliação no W&B
joblib.dump(clf, "model.joblib")
wandb.save("model.joblib")

# Finalizar a execução
wandb.finish()

Passo 3 - Criar uma aplicação de inferência e um 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


c

• app.py:
  Aqui você precisa passar o seguinte argumento em wandb.restore() : <name_of_saved_file> e "username/project/run_id"
  Ex: wandb.restore("model.joblib", "adityajha-tfy/iris-logistic-regression/00r5xvyv")

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

wandb.login(key=os.environ["WANDB_API_KEY"])

# Recuperar o modelo do W&B
model_joblib = wandb.restore(
   'model.joblib',
   run_path="adityajha-tfy/iris-logistic-regression/00r5xvyy",
 )

model = joblib.load(model_joblib.name)

# Carregar o modelo
app = FastAPI(root_path=os.getenv("TFY_SERVICE_ROOT_PATH"))

@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
joblib
numpy
pandas
scikit-learn
uvicorn
wandb

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 analisador de argumentos
parser = argparse.ArgumentParser()
parser.add_argument("--workspace_fqn", required=True, type=str)
parser.add_argument("--wandb_api_key", 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,
   ),
   env={
       "WANDB_API_KEY": args.wandb_api_key
   }
)
service.deploy(workspace_fqn=args.workspace_fqn)

Passo 5 - Implante seu Serviço via Truefoundry

Execute o seguinte comando e insira seu/sua

• Workspace FQN: que você pode encontrar no painel
• Chave de API Wandb

python deploy.py --workspace_fqn "<Seu Workspace FQN>" --wandb_api_key "<Sua Chave de API Wandb>"

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

TrueFoundry é uma PaaS de Implantação de ML sobre Kubernetes para acelerar os fluxos de trabalho dos desenvolvedores, ao mesmo tempo que lhes permite total flexibilidade no teste e implantação de modelos, garantindo total segurança e controle para a equipe de Infraestrutura. Através da nossa plataforma, capacitamos as Equipes de Machine Learning a implantar 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.