Blank white background with no objects or features visible.

Olá, EMEA! A TrueFoundry está expandindo sua presença pela Europa, Oriente Médio e África. Leia mais. →

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

By TrueFoundry

Updated: novembro 3, 2026

Published: maio 20, 2026

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 maneira eficiente. O rastreamento de experimentos envolve registrar e monitorar 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 na Gestão de Experimentos

Gerenciar experimentos e rastrear resultados pode ser uma tarefa desafiadora para praticantes de machine learning devido à complexidade dos modelos, às grandes quantidades de dados envolvidas e à variedade de ferramentas e frameworks usados no desenvolvimento de machine learning. Aqui estão alguns dos principais desafios enfrentados por profissionais ao gerenciar experimentos e rastrear resultados:

  1. Reprodutibilidade: Reproduzir experimentos é essencial para verificar resultados e garantir que os modelos apresentem 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: Praticantes de machine learning frequentemente trabalham com grandes conjuntos de dados e, por isso, 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 capazes de 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 múltiplos membros da equipe pode ser desafiador. Isso exige uma infraestrutura robusta para compartilhar dados, código e resultados de experimentos, garantindo que todos tenham acesso aos mesmos recursos.
  4. Gestão de Dados: Os modelos de machine learning dependem fortemente de dados, e gerenciar dados de forma eficaz é crítico para o sucesso do modelo. No entanto, a gestão 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 praticantes de machine learning a gerenciar e rastrear seus experimentos de forma eficaz. Ela fornece um conjunto de ferramentas para rastreamento de experimentos, visualização e colaboração, facilitando para os profissionais o desenvolvimento de modelos de machine learning robustos e escaláveis.

Os principais recursos e benefícios da plataforma W&B são:

  • 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.
  • Visualizações: O W&B fornece um conjunto de ferramentas de visualização que permitem aos usuários visualizar seus experimentos e resultados. Elas incluem visualizações em 3D, matrizes de confusão e gráficos de dispersão, entre outras. Isso ajuda os profissionais a entenderem melhor seus dados e a identificarem padrões e tendências nos resultados dos experimentos.
  • 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.
  • Integração: O W&B pode ser facilmente integrado a uma ampla gama de frameworks de machine learning, 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 alterações significativas em seu processo de desenvolvimento.
  • Organização: O W&B oferece recursos para organizar experimentos, como projetos, execuções (runs) e tags. Isso facilita o gerenciamento e o rastreamento de experimentos entre múltiplos membros da equipe e projetos.
  • Guia Passo a Passo: Configurando o Weights & Biases de Forma Fácil

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

    1. Crie uma conta no W&B: A primeira etapa é criar uma conta gratuita no site do W&B. Isso pode ser feito visitando o site e seguindo o processo de cadastro.
    2. Instale a biblioteca do W&B: Após criar uma conta, a próxima etapa é instalar a biblioteca do W&B no ambiente de desenvolvimento. A biblioteca do W&B pode ser instalada usando pip ou conda, dependendo da preferência do usuário e do ambiente de desenvolvimento.
    3. Inicialize o W&B: Assim que a biblioteca estiver instalada, o usuário precisa inicializar o W&B no código chamando a função wandb.init(). Esta função inicializa a biblioteca do W&B e configura uma nova execução (run).
    4. Registre métricas: O usuário pode registrar métricas como loss e accuracy durante o treinamento chamando a função wandb.log(). Esta função recebe um dicionário de métricas como entrada e as registra no painel do W&B.
    5. Registre hiperparâmetros: O usuário também pode registrar hiperparâmetros como taxa de aprendizado e tamanho de lote chamando a função wandb.config. Esta função recebe um dicionário de hiperparâmetros como entrada e os registra no painel do W&B.
    6. Registre visualizações: Por fim, o usuário pode registrar visualizações como imagens e gráficos chamando a função wandb.log() com os dados de visualização adequados. O W&B fornece uma ampla gama de ferramentas de visualização, incluindo visualizações em 3D, matrizes de confusão e gráficos de dispersão, entre outras.

    Exemplo:

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

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

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

    # Step 2: Log hyperparameters
    config = {
       "learning_rate": 0.001,
       "batch_size": 32,
       "epochs": 10
    }
    wandb.config.update(config)

    # Step 3: Train model and log metrics
    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']):
       # ... train model ...
       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})

    # Step 4: Log visualizations and model
    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')

    # Step 5: Finish run
    wandb.finish()

    c

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

    A TrueFoundry integra-se perfeitamente com o Model Registry do Weights & Biases para permitir que você faça o deploy de modelos registrados no Weights & Biases em seu Cluster Kubernetes usando a TrueFoundry.

    📌

    Além de usar o Weights & Biases para gestão de modelos e rastreamento de experimentos, você também pode usar o MLFoundry, a solução de Rastreamento de Experimentos da TrueFoundry.

    📌

    Você também pode acompanhar o código abaixo por meio do seguinte colab notebook:
    Colab Notebook

    Passo 1 - Instalar e configurar:

    • Instalar o wandb

    pip install wandb -qU

    • Fazer login em sua conta do W&B

    import wandb
    wandb.login()

    • Instalar o 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
    Depois, salvaremos nosso arquivo joblib no wandb por meio do 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

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

    # Load and preprocess the data
    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
    )

    # Initialize the model
    clf = LogisticRegression(solver="liblinear")

    # Fit the model
    clf.fit(X_train, y_train)

    # Evaluate the model
    preds = clf.predict(X_test)

    # Log the model and the evaluation metrics to W&B
    joblib.dump(clf, "model.joblib")
    wandb.save("model.joblib")

    # Finish the run
    wandb.finish()

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

    Teremos que criar dois arquivos para implantar na TrueFoundry: um arquivo app.py contendo o código da nossa aplicação e um arquivo requirements.txt contendo nossas dependências.

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

    c

    • app.py:
      Aqui você precisa passar os seguintes argumentos no 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"])

    # Retrieve the model from W&B
    model_joblib = wandb.restore(
       'model.joblib',
       run_path="adityajha-tfy/iris-logistic-regression/00r5xvyy",
     )

    model = joblib.load(model_joblib.name)

    # Load the model
    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 - Usar o SDK Python da TrueFoundry e configurar a implantação

    • deploy.py:

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

    # Setup the logger
    logging.basicConfig(level=logging.INFO)

    # Setup the argument parser
    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 - Implantar seu Serviço via TrueFoundry

    Execute o seguinte comando e passe o seu

    • FQN do Workspace: que você pode encontrar no painel
    • Wandb API Key

    python deploy.py --workspace_fqn "<Your Workspace FQN>" --wandb_api_key "<Your Wandb API Key>"

    E pronto!!! Nos logs você pode encontrar o painel do seu serviço implantado. E no canto superior direito você encontrará o endpoint da sua aplicação implantada.

    TrueFoundry é uma PaaS de Implantação de ML sobre Kubernetes para acelerar os fluxos de trabalho dos desenvolvedores, permitindo flexibilidade total no teste e na implantação de modelos, enquanto garante total segurança e controle para a equipe de Infraestrutura. Através de nossa plataforma, capacitamos equipes de Machine Learning a implantar e monitorar modelos em 15 minutos com 100% de confiabilidade, escalabilidade e a capacidade de realizar rollback em segundos - permitindo economizar custos e lançar Modelos em produção mais rápido, viabilizando o real valor de negócio.  

    Try now.

    One gateway for all your models, MCP servers, and agents. No credit card needed.

    Start free
    Table of Contents

    One Gateway for Every LLM, Agent and MCP Server

    Book a 30-min with our AI expert

    Book a Demo

    The fastest way to build, govern and scale your AI

    Book Demo
    Summarize with
    ChatGPT logo by OpenAI
    Perplexity AI logo
    Blurry red snowflake on white background, symmetrical frosty design with soft edges and abstract shape.

    Discover More

    outubro 5, 2023
    |
    5 min read

    <Webinar> Vitrine de GenAI para Empresas

    Best Fine Tuning Tools for Model Training
    maio 3, 2024
    |
    5 min read

    As 6 Principais Ferramentas de Ajuste Fino (Fine-Tuning) para Treinamento de Modelos em 2026

    maio 25, 2023
    |
    5 min read

    LLMs Open Source: Adote ou Desapareça

    agosto 24, 2023
    |
    5 min read

    Machine Learning Deployments em 2023

    novembro 18, 2026
    |
    5 min read

    Limites do Claude Code Explicados (Edição 2026)

    No items found.
    Analyzing how Cloudflare detects MCP traffic
    novembro 18, 2026
    |
    5 min read

    How Cloudflare Detects MCP Traffic and Helps Secure It

    No items found.
    novembro 18, 2026
    |
    5 min read

    What Is AI Search? How It Works, Architecture, and Enterprise Use Cases

    No items found.
    Explaining LLM fine-tuning for enterprise AI teams
    novembro 18, 2026
    |
    5 min read

    A Practical Guide to LLM Fine-Tuning: Methods, Data, Costs, and Deployment

    No items found.
    No items found.

    Recent Blogs

    Black left pointing arrow symbol on white background, directional indicator.
    Black left pointing arrow symbol on white background, directional indicator.
    Take a quick product tour
    Start Product Tour
    Product Tour