Lernprogramm: Nachverfolgen und Analysieren von Benutzern und Umgebungen

Notizbuchversion dieser Seite öffnen

Dieses Tutorial veranschaulicht das Hinzufügen von Kontext zu Traces, um Benutzer, Sitzungen und Bereitstellungen nachzuverfolgen und zu analysieren.

  • In einer einfachen Chat-App verwenden Sie mlflow.update_current_trace(), um benutzerdefinierte Metadaten und Tags zu Ablaufverfolgungen hinzuzufügen.
  • Um Ablaufverfolgungen zu analysieren, verwenden mlflow.search_traces() Sie diese, um relevante Ablaufverfolgungen zu extrahieren und Statistiken für Benutzer, Sitzungen, Umgebungen und App-Versionen zu berechnen.

Einrichten der Umgebung

Installieren Sie die erforderlichen Pakete:

  • mlflow[databricks]: Verwenden Sie die neueste Version von MLflow, um weitere Features und Verbesserungen zu erhalten.
  • openai: Diese App verwendet den OpenAI-API-Client, um von Databricks gehostete Modelle aufzurufen.
%pip install -qq --upgrade "mlflow[databricks]>=3.1.0" openai
dbutils.library.restartPython()

Erstellen Sie ein MLflow-Experiment. Wenn Sie ein Databricks-Notizbuch verwenden, können Sie diesen Schritt überspringen und das Standard-Notizbuchexperiment verwenden. Folgen Sie andernfalls der Schnellstartanleitung der Umgebung , um das Experiment zu erstellen und eine Verbindung mit dem MLflow Tracking-Server herzustellen.

Definieren und Nachverfolgen Ihrer Anwendung

Die folgende einfache Chatanwendung ruft ein von Databricks gehostetes Foundation-Modell auf, um Benutzerabfragen zu beantworten.

Die Ablaufverfolgung erfolgt mit:

  • mlflow.openai.autolog() zum automatischen Loggen von OpenAI-Clientaufrufen
  • @mlflow.trace um die Anwendungslogik in my_app() zu verfolgen
  • mlflow.update_current_trace() Kontext zu Traces in my_app() hinzufügen:
    • Benutzer- und Sitzungskontext: Abfragespezifische Informationen wie Benutzer-IDs können als Argumente an die Anwendungslogik übergeben werden.
    • Bereitstellungskontext: Bereitstellungsspezifische Informationen wie die Umgebung oder App-Version werden über Umgebungsvariablen an die Anwendung übergeben, wodurch Konfigurationsänderungen über Bereitstellungen hinweg vereinfacht werden.

MLflow füllt automatisch einige Metadaten in Spuren aus, aber Sie können die Standardwerte überschreiben. Sie können auch benutzerdefinierte Metadaten definieren. Das folgende Beispiel veranschaulicht beide.


import mlflow
import os
from databricks_openai import DatabricksOpenAI

mlflow.openai.autolog()

@mlflow.trace
def my_app(user_id: str, session_id: str, message: str) -> str:
    """Process a chat message with extra content logging for traces."""

    # Add user and session context to the current trace.
    # The @mlflow.trace decorator ensures there is an active trace.
    mlflow.update_current_trace(
        metadata={
            "mlflow.trace.user": user_id,
            "mlflow.trace.session": session_id,
        },
        tags={
          "query_category": "chat",  # Example of a custom tag
        },
    )

    app_environment = os.getenv("APP_ENVIRONMENT", "development")
    mlflow.update_current_trace(
        metadata={
            # Override automatically populated metadata
            "mlflow.source.type": app_environment,  # Override default LOCAL/NOTEBOOK
            # Add custom metadata
            "app_version": os.getenv("APP_VERSION", "1.0.0"),
            "deployment_id": os.getenv("DEPLOYMENT_ID", "unknown"),
        }
    )

    # The trace will capture the execution time, inputs, outputs, and any errors
    # Your chat logic here
    response = chat_completion(message)
    return response


# Basic chat logic
def chat_completion(message: str) -> str:
    # Create an OpenAI client that is connected to Databricks-hosted LLMs
    client = DatabricksOpenAI()

    response = client.chat.completions.create(
        model="databricks-claude-sonnet-4",
        messages=[
            {
                "role": "system",
                "content": "You are a helpful assistant. Give brief, 1-2 sentence responses.",
            },
            {
                "role": "user",
                "content": message,
            },
        ]
    )
    return response.choices[0].message.content

Die oben genannte Anwendungslogik verwendet Benutzer-, Sitzungs- und andere Metadaten als Funktionsargumente. In einer Produktionsanwendung kann die Implementierung Metadaten aus Headern in einem Anforderungsobjekt extrahieren. Wenn die Anwendung beispielsweise als Databricks-App bereitgestellt wird, kann die App auf HTTP-Header mit Metadaten zugreifen.

Simulieren Sie als Nächstes ein paar verschiedene Benutzer und Sitzungen mit jeweils einer oder mehreren Chatinteraktionen. Legen Sie Bereitstellungsinformationen mithilfe von Umgebungsvariablen fest.

# Set environment variables to log deployment-specific metadata with traces.
os.environ["APP_ENVIRONMENT"] = "staging"
os.environ["APP_VERSION"] = "1.0.0"
os.environ["DEPLOYMENT_ID"] = "deployment-123"

# Run the chat completion with user and session context to generate example traces:
for session in range(2):
  # 2 chat interactions per session for this user
  result = my_app(
      user_id="user-123",
      session_id=f"session-abc-{session}",
      message="What is MLflow and how does it help with GenAI?"
  )
  result = my_app(
      user_id="user-123",
      session_id=f"session-abc-{session}",
      message="What is ML vs. AI?"
  )

os.environ["APP_VERSION"] = "1.1.0"
os.environ["DEPLOYMENT_ID"] = "deployment-456"

for session in range(2):
  # 1 chat interaction per session for this user
  result = my_app(
      user_id="user-456",
      session_id=f"session-def-{session}",
      message="What is MLflow and how does it help with machine learning?"
  )

Suchspuren

Alle nachstehenden Analysen basieren auf der Verwendung von mlflow.search_traces() zur Sammlung relevanter Ablaufverfolgungen für die Analyse.

import mlflow
traces = mlflow.search_traces()
traces

Jede Trace wird mit dem zusätzlichen Kontext angereichert, der in der App protokolliert wird, z. B. Benutzer-IDs:

first_trace = traces.iloc[0]
first_trace.trace_metadata['mlflow.trace.user']

'user-456'

Analysieren des Benutzerverhaltens

Analysieren Sie zunächst das Verhalten eines bestimmten Benutzers.

import pandas as pd
import time

def analyze_user_behavior(user_id: str, days: int = 7):
    """Analyze activity patterns for a specific user."""

    cutoff_ms = int((time.time() - days * 86400) * 1000)

    traces = mlflow.search_traces(
        filter_string=f"metadata.`mlflow.trace.user` = '{user_id}' AND "
                      f"trace.timestamp_ms > {cutoff_ms}",
        order_by=["trace.timestamp_ms DESC"],
    )

    if len(traces) == 0:
        print(f"No activity found for user {user_id}")
        return

    # Calculate key metrics
    total_interactions = len(traces)
    unique_sessions = set(row.trace_metadata.get("mlflow.trace.session", "") for index, row in traces.iterrows())
    unique_sessions.discard("")

    print(f"User {user_id} Activity Report ({days} days)")
    print("=" * 50)
    print(f"Total interactions: {total_interactions}")
    print(f"Unique sessions: {len(unique_sessions)}")

    # Daily activity
    traces['date'] = pd.to_datetime(traces['request_time'], unit='ms').dt.date
    daily_activity = traces.groupby('date').size()
    print(f"\nDaily activity:")
    print(daily_activity.to_string())

    # Query categories
    query_categories = traces['tags'].apply(lambda tags: tags.get('query_category'))
    unique_categories = set(query_categories.dropna())
    category_counts = query_categories.value_counts()
    print(f"\nQuery categories:")
    print(category_counts.to_string())

    # Performance stats
    print(f"\nPerformance:")
    print(f"Average response time: {traces['execution_duration'].mean():.1f}ms")
    print(f"Error rate: {(traces['state'] == 'ERROR').mean() * 100:.1f}%")

    return traces

analyze_user_behavior(user_id="user-123")

User user-123 Activity Report (7 days)
==================================================
Total interactions: 4
Unique sessions: 2

Daily activity:
date
2025-12-12    4

Query categories:
tags
chat    4

Performance:
Average response time: 2177.5ms
Error rate: 0.0%

Analysieren des Sitzungsflusses

Ein Benutzer kann über Ihre Anwendung an Dialogen mit mehreren Wechseln teilnehmen. Die Analyse der Turn-by-Turn-Sitzung kann dazu beitragen, die Benutzererfahrung zu erläutern. Unten werden die Gesprächswechsel anhand von Ablaufverfolgungs-Zeitstempeln geordnet.

def analyze_session_flow(session_id: str):
    """Analyze conversation flow within a session."""

    # Get all traces from a session, ordered chronologically
    session_traces = mlflow.search_traces(
        filter_string=f"metadata.`mlflow.trace.session` = '{session_id}'",
        order_by=["timestamp ASC"]
    )

    # Build a timeline of the conversation
    conversation_turns = []
    for index, row in session_traces.iterrows():
        conversation_turns.append({
            "turn": index + 1,
            "timestamp": int(row.request_time),
            "duration_ms": int(row.execution_duration),
            "status": str(row.state),
            "response": row.response,
        })

    return conversation_turns

analyze_session_flow(session_id="session-abc-0")

[{'turn': 1,
  'timestamp': 1765560306051,
  'duration_ms': 2570,
  'status': 'OK',
  'response': 'MLflow is an open-source platform for managing the machine learning lifecycle, including experiment tracking, model packaging, and deployment. For GenAI, it helps by providing tools to track experiments with large language models, manage model versions, log prompts and responses, and deploy AI models at scale while maintaining reproducibility and governance.'},
 {'turn': 2,
  'timestamp': 1765560308943,
  'duration_ms': 2644,
  'status': 'OK',
  'response': 'AI (Artificial Intelligence) is the broader field focused on creating machines that can perform tasks requiring human-like intelligence, while ML (Machine Learning) is a subset of AI that specifically uses algorithms to learn patterns from data without being explicitly programmed for each task. Think of AI as the goal and ML as one of the main methods to achieve it.'}]

Analysieren von Umgebungen und Versionen

Bereitstellungsmetadaten wie Umgebung oder App-Version können ähnlich wie Benutzer und Sitzungen analysiert werden. Die Analyse von Implementierungen kann helfen, Verbesserungen oder Beeinträchtigungen von Qualität, Latenz oder anderen wichtigen Metriken nachzuverfolgen, während Sie an Ihrer Anwendung iterieren.

traces = mlflow.search_traces()

traces['app_version'] = traces['trace_metadata'].apply(lambda meta: meta.get('app_version'))
traces['user_id'] = traces['trace_metadata'].apply(lambda meta: meta.get('mlflow.trace.user'))
traces['app_environment'] = traces['trace_metadata'].apply(lambda meta: meta.get('mlflow.source.type'))

interactions_per_version = traces.groupby('app_version').size()
print(f"Interactions per app version:")
print(interactions_per_version.to_string())

users_per_version = traces.groupby('app_version')['user_id'].nunique()
print(f"\nDistinct users per app version:")
print(users_per_version.to_string())

interactions_per_environment = traces.groupby('app_environment').size()
print(f"\nInteractions per app environment:")
print(interactions_per_environment.to_string())

Interactions per app version:
app_version
1.0.0    4
1.1.0    4

Distinct users per app version:
app_version
1.0.0    1
1.1.0    1

Interactions per app environment:
app_environment
staging    8

Nächste Schritte

Beispiel-Notebook

Lernprogramm: Nachverfolgen und Analysieren von Benutzern und Umgebungen

Notebook abrufen

  • Last updated on