GenAI ist einfach zu demonstrieren und
schwer einfach in die Produktion zu überführen
Weights & Biases ist die KI-Entwicklerplattform zum Trainieren und Optimieren Ihrer KI-Modelle und zum Entwickeln von KI-Anwendungen, denen Sie vertrauen können.
import weave
weave.init("quickstart")
@weave.op()
def llm_app(prompt):
pass # Track LLM calls, document retrieval, agent steps
import wandb
run = wandb.init(project="my-model-training-project")
run.config = {"epochs": 1337, "learning_rate": 3e-4}
run.log({"metric": 42})
my_model_artifact = run.log_artifact("./my_model.pt", type="model")
Die weltbesten KI-Teams vertrauen Gewichtungen und Vorurteilen.
System, das Aufzeichnungsentwickler verwenden möchten
Experiment
Tracking- und VisualisierungML-Experimente
fegen
Optimierung für Hyperparameter
Start
Packen und Ausführen von ML-Workflow-Aufgaben
Modellregister
Registrierung und Verwaltung
Hyperparameter-Optimierung
Automatisierung
워크플로 트리거
자동으로
Modell
Bau- und Feinabstimmungsmodell
Beweis
Überwachung und Fehlerbehebung für LLM und Eingabeaufforderungen
salzig
GenAI-Entwicklung
Anwendungen
Auswertung
Strenge Evaluierung
von GenAI-Anwendungen
W&B Core: Ein grundlegendes Framework zur Unterstützung von KI-Entwicklern
Schnell integrieren, Track & Version automatisch
- Verfolgen, versionieren und visualisieren mit nur 5 Codezeilen
- Reproduzieren Sie alle Modellprüfpunkte
- Überwachen Sie die CPU- und GPU-Auslastung in Echtzeit
„Wir führen jetzt 50- oder 100-mal mehr ML-Experimente durch als vorher.“
import wandb
# 1. Start a W&B run
run = wandb.init(project="my_first_project")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
# 3. Log metrics to visualize performance over time
for i in range(10):
run.log({"loss": 2**-i})
import weave
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI
# Initialize Weave with your project name
weave.init("langchain_demo")
llm = ChatOpenAI()
prompt = PromptTemplate.from_template("1 + {number} = ")
llm_chain = prompt | llm
output = llm_chain.invoke({"number": 2})
print(output)
import weave
from llama_index.core.chat_engine import SimpleChatEngine
# Initialize Weave with your project name
weave.init("llamaindex_demo")
chat_engine = SimpleChatEngine.from_defaults()
response = chat_engine.chat(
"Say something profound and romantic about fourth of July"
)
print(response)
import wandb
# 1. Start a new run
run = wandb.init(project="gpt5")
# 2. Save model inputs and hyperparameters
config = run.config
config.dropout = 0.01
# 3. Log gradients and model parameters
run.watch(model)
for batch_idx, (data, target) in enumerate(train_loader):
...
if batch_idx % args.log_interval == 0:
# 4. Log metrics to visualize performance
run.log({"loss": loss})
import wandb
# 1. Define which wandb project to log to and name your run
run = wandb.init(project="gpt-5",
run_name="gpt-5-base-high-lr")
# 2. Add wandb in your `TrainingArguments`
args = TrainingArguments(..., report_to="wandb")
# 3. W&B logging will begin automatically when your start training your Trainer
trainer = Trainer(..., args=args)
trainer.train()
from lightning.pytorch.loggers import WandbLogger
# initialise the logger
wandb_logger = WandbLogger(project="llama-4-fine-tune")
# add configs such as batch size etc to the wandb config
wandb_logger.experiment.config["batch_size"] = batch_size
# pass wandb_logger to the Trainer
trainer = Trainer(..., logger=wandb_logger)
# train the model
trainer.fit(...)
import wandb
# 1. Start a new run
run = wandb.init(project="gpt4")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
# Model training here
# 3. Log metrics to visualize performance over time
with tf.Session() as sess:
# ...
wandb.tensorflow.log(tf.summary.merge_all())
import wandb
from wandb.keras import (
WandbMetricsLogger,
WandbModelCheckpoint,
)
# 1. Start a new run
run = wandb.init(project="gpt-4")
# 2. Save model inputs and hyperparameters
config = wandb.config
config.learning_rate = 0.01
... # Define a model
# 3. Log layer dimensions and metrics
wandb_callbacks = [
WandbMetricsLogger(log_freq=5),
WandbModelCheckpoint("models"),
]
model.fit(
X_train, y_train, validation_data=(X_test, y_test),
callbacks=wandb_callbacks,
)
import wandb
wandb.init(project="visualize-sklearn")
# Model training here
# Log classifier visualizations
wandb.sklearn.plot_classifier(clf, X_train, X_test, y_train, y_test, y_pred, y_probas, labels,
model_name="SVC", feature_names=None)
# Log regression visualizations
wandb.sklearn.plot_regressor(reg, X_train, X_test, y_train, y_test, model_name="Ridge")
# Log clustering visualizations
wandb.sklearn.plot_clusterer(kmeans, X_train, cluster_labels, labels=None, model_name="KMeans")
import wandb
from wandb.xgboost import wandb_callback
# 1. Start a new run
run = wandb.init(project="visualize-models")
# 2. Add the callback
bst = xgboost.train(param, xg_train, num_round, watchlist, callbacks=[wandb_callback()])
# Get predictions
pred = bst.predict(xg_test)
Die führende KI-Entwicklerplattform bietet Wert für Ihr gesamtes Team
Die Benutzererfahrung, die überflüssig macht Arbeit verschwinden
Verfolgen Sie jedes Detail Ihrer ML-Pipeline automatisch. Visualisieren Sie Ergebnisse mit relevantem Kontext. Drag & Drop-Analysen zur Gewinnung von Erkenntnissen – Ihr nächstes bestes Modell ist nur ein paar Klicks entfernt
Der ML-Workflow gemeinsam mit ML-Ingenieuren entwickelt
Erstellen Sie schrittweise optimierte ML-Workflows. Konfigurieren und passen Sie jeden Schritt an. Nutzen Sie intelligente Standardeinstellungen, damit Sie das Rad nicht neu erfinden müssen.
Ein Aufzeichnungssystem, das alle Geschichten reproduzierbar und auffindbar
Reproduzieren Sie jedes Experiment sofort. Verfolgen Sie die Modellentwicklung und lassen Sie sich dabei Änderungen erklären. Entdecken Sie die Arbeit Ihres Teams ganz einfach und bauen Sie darauf auf.
Die Benutzererfahrung, die überflüssig macht Arbeit verschwinden
Verfolgen Sie jedes Detail Ihrer ML-Pipeline automatisch. Visualisieren Sie Ergebnisse mit relevantem Kontext. Drag & Drop-Analysen zur Gewinnung von Erkenntnissen – Ihr nächstes bestes Modell ist nur ein paar Klicks entfernt
Jede Branche, jeder Anwendungsfall
Kunden aus unterschiedlichsten Branchen vertrauen W&B bei einer Vielzahl von ML-Anwendungsfällen. Von autonomen Fahrzeugen bis zur Arzneimittelforschung und von der Automatisierung des Kundensupports bis zur generativen KI – der flexible Workflow von W&B erfüllt alle Ihre individuellen Anforderungen.
Konzentriert sich das Team auf Wertschöpfungsaktivitäten
Konzentriert sich nur auf die Kernaktivitäten des ML – W&B übernimmt automatisch langweilige Aufgaben für Sie: Reproduzierbarkeit, Überprüfbarkeit, Infrastrukturmanagement sowie Sicherheit und Governance. Machen Sie Ihren ML-Workflow zukunftssicher – W&B entwickelt gemeinsam mit OpenAI und anderen Innovatoren deren Geheimrezepte, damit Sie das Rad nicht neu erfinden müssen.
Flexible Bereitstellungen, Einfache Integration
Stellen Sie W&B in der Infrastruktur Ihrer Wahl bereit. W&B-verwaltet oder selbstverwaltet verfügbar. Einfache Integration mit Ihrem ML-Stack und Ihren ML-Tools ohne Abhängigkeit von einem Anbieter.
Bridge ML Practitioners und MLOps
Automatisieren und skalieren Sie ML-Workloads in einer kollaborativen Schnittstelle – ML-Praktiker profitieren von der Einfachheit, MLOps von der Transparenz.
Skalieren Sie die ML-Produktion mit Governance
Ein zentrales Aufzeichnungssystem für alle Ihre ML-Projekte. Verwalten Sie den Modelllebenszyklus und CI/CD, um die Produktion zu beschleunigen. Verstehen Sie die Modellentwicklung und erklären Sie der Geschäftsleitung die geschäftlichen Auswirkungen.
Entwickelt, um Softwareentwicklern zu helfen, GenAI-Anwendungen sicher einzusetzen
Die Tools, die Entwickler benötigen, um dynamische, nicht-deterministische große Sprachmodelle zu bewerten, zu verstehen und zu iterieren.
Automatisches Protokollieren aller Ein- und Ausgaben sowie Traces zur einfachen Fehlerbehebung
Weave erfasst alle Eingabe- und Ausgabedaten und erstellt einen Baum, um Entwicklern vollständige Sichtbarkeit und Verständnis darüber zu geben, wie die Daten durch ihre Anwendungen fließen.
Rigorose Evaluierungsrahmen für eine solide LLM-Leistung
Vergleichen Sie verschiedene Auswertungen von Modellergebnissen anhand unterschiedlicher Leistungsdimensionen, um sicherzustellen, dass die Anwendungen bei der Bereitstellung in der Produktion so robust wie möglich sind.