Dela via

Kom igång: MLflow-spårning för GenAI (lokal IDE)

Den här snabbstarten hjälper dig att integrera din GenAI-app med MLflow Tracing om du använder en lokal utvecklingsmiljö, till exempel en IDE (VS Code, PyCharm, Cursor eller andra) eller en lokalt värdbaserad notebook-miljö (Jupyter eller andra). Om du använder en Databricks Notebook använder du snabbstarten Databricks Notebook i stället.

Vad du kommer att uppnå

I slutet av den här självstudien har du:

  • Ett MLflow-experiment för din GenAI-app
  • Din lokala utvecklingsmiljö som är ansluten till MLflow
  • Ett enkelt GenAI-program som instrumenterats med MLflow Tracing
  • En spårning från appen i ditt MLflow-experiment

spåra

Förutsättningar

  • Databricks-arbetsyta: Åtkomst till en Databricks-arbetsyta.

Steg 1: Installera MLflow

När du arbetar i din lokala IDE måste du installera MLflow med Databricks-anslutningen.

pip install --upgrade "mlflow[databricks]>=3.1" openai

Steg 2: Skapa ett nytt MLflow-experiment

Ett MLflow-experiment är containern för ditt GenAI-program. Läs mer om experiment i avsnittet begrepp.

  1. Öppna databricks-arbetsytan
  2. I det vänstra sidofältet, under AI/ML, klickar du på Experiment.
  3. Överst på sidan Experiment klickar du på GenAI-appar och agenter
  4. Hämta experiment-ID och sökväg genom att klicka på informationsikonen Info-ikonen. Längst upp till vänster. Du kommer att använda dessa senare.

skapa experiment

Steg 3: Ansluta din miljö till MLflow

Kodfragmenten nedan visar hur du konfigurerar autentisering med hjälp av en personlig Databricks-åtkomsttoken. MLflow fungerar också med andra autentiseringsmetoder som stöds av Databricks.

Använda miljövariabler

  1. I din MLflow-experiment klickar du på Kebab-menyn Kebabmenyikonen.> Logga lokalt> klicka på Generera API-nyckel.

  2. Kopiera och kör den genererade koden i terminalen.

    export DATABRICKS_TOKEN=<databricks-personal-access-token>
export DATABRICKS_HOST=https://<workspace-name>.cloud.databricks.com
export MLFLOW_TRACKING_URI=databricks
export MLFLOW_REGISTRY_URI=databricks-uc
export MLFLOW_EXPERIMENT_ID=<experiment-id>

Använda en .env-fil

  1. I din MLflow-experiment klickar du på Kebab-menyn Kebabmenyikonen.> Logga lokalt> klicka på Generera API-nyckel.

  2. Kopiera den genererade koden till en .env fil i projektroten

    DATABRICKS_TOKEN=<databricks-personal-access-token>
DATABRICKS_HOST=https://<workspace-name>.cloud.databricks.com
MLFLOW_TRACKING_URI=databricks
MLFLOW_REGISTRY_URI=databricks-uc
MLFLOW_EXPERIMENT_ID=<experiment-id>

  3. Installera python-dotenv-paketet

    pip install python-dotenv

  4. Läsa in miljövariabler i koden

    # At the beginning of your Python script
from dotenv import load_dotenv

# Load environment variables from .env file
load_dotenv()

Steg 4: Skapa och instrumentera ditt program

Skapa din GenAI-app med spårning aktiverat.

  1. Skapa en Python-fil med namnet app.py i projektkatalogen.

  2. Initiera en OpenAI-klient för att ansluta till antingen Databricks-värdbaserade LLM:er eller LLM:er som hanteras av OpenAI.

    Databricks-värdbaserade LLM:er

    Använd MLflow för att hämta en OpenAI-klient som ansluter till Databricks-värdbaserade LLM:er. Välj en modell från de tillgängliga grundmodellerna.

    import mlflow
from databricks.sdk import WorkspaceClient

# Enable MLflow's autologging to instrument your application with Tracing
mlflow.openai.autolog()

# Set up MLflow tracking to Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/docs-demo")

# Create an OpenAI client that is connected to Databricks-hosted LLMs
w = WorkspaceClient()
client = w.serving_endpoints.get_open_ai_client()

# Select an LLM
model_name = "databricks-claude-sonnet-4"

    OpenAI-värdbaserade LLM:er

    Använd det inbyggda OpenAI SDK för att ansluta till OpenAI-hanterade modeller. Välj en modell från tillgängliga OpenAI-modeller.

    import mlflow
import os
import openai

# Ensure your OPENAI_API_KEY is set in your environment
# os.environ["OPENAI_API_KEY"] = "<YOUR_API_KEY>" # Uncomment and set if not globally configured

# Enable auto-tracing for OpenAI
mlflow.openai.autolog()

# Set up MLflow tracking to Databricks
mlflow.set_tracking_uri("databricks")
mlflow.set_experiment("/Shared/docs-demo")

# Create an OpenAI client connected to OpenAI SDKs
client = openai.OpenAI()

# Select an LLM
model_name = "gpt-4o-mini"

  3. Definiera och kör ditt program:

    Använd dekoratören@mlflow.trace, vilket gör det enkelt att spåra alla Python-funktioner i kombination med OpenAI-automatisk instrumentering för att samla in information om anropet till OpenAI SDK.

    # Use the trace decorator to capture the application's entry point
@mlflow.trace
def my_app(input: str):
    # This call is automatically instrumented by `mlflow.openai.autolog()`
    response = client.chat.completions.create(
        model=model_name,  # This example uses a Databricks hosted LLM - you can replace this with any AI Gateway or Model Serving endpoint. If you provide your own OpenAI credentials, replace with a valid OpenAI model e.g., gpt-4o, etc.
        messages=[
            {
                "role": "system",
                "content": "You are a helpful assistant.",
            },
            {
                "role": "user",
                "content": input,
            },
        ],
    )
    return response.choices[0].message.content

result = my_app(input="What is MLflow?")
print(result)

  4. Starta programmet

    python app.py

Mer information om hur du lägger till spårning i appar finns i guiden för spårningsinstrumentation och 20+-biblioteksintegreringar.

Steg 5: Visa spårningen i MLflow

  1. Gå tillbaka till användargränssnittet för MLflow-experimentet.
  2. Nu visas den genererade spårningen på fliken Spårningar .
  3. Klicka på spårningen för att visa dess information.

Spårningsinformation

Förstå spårningen

Spårningen som du just har skapat visar:

  • Rotintervall: Representerar indata till my_app(...) funktionen
    • Child span: Representerar en begäran om färdigställande från OpenAI
  • Attribut: Innehåller metadata som modellnamn, tokenantal och tidsinformation
  • Indata: De meddelanden som skickas till modellen
  • Utdata: Svaret som togs emot från modellen

Den här enkla spårningen ger redan värdefulla insikter om programmets beteende, till exempel:

  • Det som efterfrågades
  • Vilket svar genererades
  • Hur lång tid begäran tog
  • Hur många token som användes (vilket påverkar kostnaden)

För mer komplexa program som RAG-system eller multistegsagenter ger MLflow Tracing ännu mer värde genom att avslöja det inre arbetet för varje komponent och steg.

Guider och referenser

Mer information om begrepp och funktioner i den här guiden finns i: