Qwen2.5-32B batchinferentie met Ray Data en vLLM

Notitieblokversie van deze pagina openen

Gebruik Qwen2.5-32B-Instruct om 16.000 meertalige voice-assistant-uitingen te classificeren op een aangehechte 8xH100 AI Runtime. Dit notitieboekje laat zien hoe je:

• Bouw een gebalanceerde meertalige Ray Dataset van MASSIVE 1.1.
• Draai één persistent vLLM-modelreplica op elke beschikbare GPU.
• Monitor de werklast met het Ray-dashboard en MLflow-systeemstatistieken.
• Sla volledige voorspellingsresultaten op als Parquet in een Unity Catalog-volume.

Note

Dit voorbeeld vereist de Databricks AI-omgeving versie 5 of hoger.

Verbinding maken met serverloze GPU-rekenkracht

1. Selecteer Serverless GPU in de rekenselectie van het notebook.
2. Selecteer in het Omgevingspaneel de 8xH100-accelerator en de AI v5-omgeving .
3. Klik op Aanpassen en bevestig vervolgens de omgeving.

Het Qwen-model is openbaar en vereist geen Hugging Face-authenticatie. Het notebook downloadt MASSIVE 1.1 uit het openbare archief van Amazon.

Bibliotheken importeren

AI v5 bevat de Ray-, vLLM-, Hugging Face Datasets-, Transformers-, PyTorch- en MLflow-pakketten die in dit notebook worden gebruikt, dus er is geen pakketinstallatie nodig.

import json
import re
import time
from pathlib import Path

import mlflow
import pandas as pd
from datasets import DownloadConfig, DownloadManager, concatenate_datasets, load_dataset
from datasets.utils.logging import disable_progress_bar
from pyspark.sql import functions as F
from vllm import LLM, SamplingParams
from vllm.sampling_params import StructuredOutputsParams

Configureer de werklast

Stel het model, locaties, steekproefgrootte en inferentieparameters in.

MODEL_NAME = "Qwen/Qwen2.5-32B-Instruct"
DATASET_NAME = "AmazonScience/massive"
MASSIVE_ARCHIVE_URL = "https://amazon-massive-nlu-dataset.s3.amazonaws.com/amazon-massive-dataset-1.1.tar.gz"
LOCALES = ["en-US", "es-ES", "de-DE", "ar-SA", "hi-IN", "ja-JP", "sw-KE", "zh-CN"]
ROWS_PER_LOCALE = 2_000
BATCH_SIZE = 64
MAX_MODEL_LEN = 512
MAX_OUTPUT_TOKENS = 8
SEED = 42

Unity Catalog-opslag configureren

Gebruik de widgets om een bestaande Unity Catalog-catalogus, schema en volume aan te geven. Het notebook slaat de MASSIVE-cache en Parquet-voorspellingen op in dit volume. Je hebt deze privileges nodig:

• USE CATALOG op de catalogus en USE SCHEMA op het schema.
• READ VOLUME en WRITE VOLUME voor het volume.

Elke MLflow-run schrijft voorspellingen naar zijn eigen submap onder de geconfigureerde Parquet-uitvoerroot.

widget_defaults = {
    "uc_catalog": "main",
    "uc_schema": "default",
    "uc_volume": "ray_data",
}
for widget_name, default_value in widget_defaults.items():
    dbutils.widgets.text(widget_name, default_value)

CATALOG = dbutils.widgets.get("uc_catalog")
SCHEMA = dbutils.widgets.get("uc_schema")
VOLUME = dbutils.widgets.get("uc_volume")

volume_path = f"/Volumes/{CATALOG}/{SCHEMA}/{VOLUME}"
parquet_output_root = f"{volume_path}/sgc-raydata-vllm-batch-inference"
massive_cache_path = f"{volume_path}/hf-cache/amazon-massive-1.1"
print(f"Parquet output root: {parquet_output_root}")
print(f"Dataset cache: {massive_cache_path}")

Ray starten

ray_init() start Ray op de gekoppelde rekenomgeving en toont de dashboard-URL voor dit notebook. De Ray-verbinding blijft actief terwijl het notebook verbonden blijft. De actorpool gebruikt het GPU-aantal dat door Ray wordt gerapporteerd, zodat elke beschikbare GPU één vLLM-modelreplica draait.

import ray
from serverless_gpu import ray_init

ray_context = ray_init()
ACTOR_COUNT = int(ray.cluster_resources().get("GPU", 0))
if ACTOR_COUNT < 1:
    raise RuntimeError("Ray did not detect a GPU. Attach GPU compute and run the notebook again.")
print(f"Ray detected {ACTOR_COUNT} GPUs; using {ACTOR_COUNT} predictor actors.")

Laad en sample MASSIVE

Download MASSIVE 1.1 naar de geconfigureerde cache en selecteer vervolgens bij elke run dezelfde 2.000 trainingsvoorbeelden van elke locatie. De eerste locatie geeft ook de scenario- en intentienamen die zijn gebruikt om de classificatieprompt te bouwen.

disable_progress_bar()
download_config = DownloadConfig(cache_dir=f"{massive_cache_path}/downloads")
download_manager = DownloadManager(download_config=download_config)
massive_archive_dir = Path(download_manager.download_and_extract(MASSIVE_ARCHIVE_URL))
massive_data_dir = massive_archive_dir / "1.1" / "data"
locale_datasets = []
scenario_names = None
scenario_intents = None

for locale in LOCALES:
    locale_dataset = load_dataset(
        "json",
        data_files=str(massive_data_dir / f"{locale}.jsonl"),
        split="train",
        cache_dir=f"{massive_cache_path}/datasets",
    )
    locale_dataset = locale_dataset.filter(lambda row: row["partition"] == "train")
    locale_scenarios = sorted(locale_dataset.unique("scenario"))
    if scenario_names is not None and locale_scenarios != scenario_names:
        raise ValueError(f"Scenario labels differ for locale {locale}.")
    if scenario_names is None:
        scenario_names = locale_scenarios
        label_frame = locale_dataset.select_columns(["scenario", "intent"]).to_pandas()
        scenario_intents = {
            scenario: sorted(group["intent"].unique())
            for scenario, group in label_frame.groupby("scenario")
        }
    sample = locale_dataset.shuffle(seed=SEED).select(range(ROWS_PER_LOCALE))
    locale_datasets.append(sample.select_columns(["id", "locale", "utt", "scenario"]))

Maak de Ray Dataset aan

Combineer de locale samples, behoud de velden die nodig zijn voor inferentie en evaluatie, en herpartitioneer de data zodat Ray alle predictor-actoren bezig kan houden.

massive_sample = concatenate_datasets(locale_datasets)
records = [
    {
        "input_id": f"{row['locale']}:{row['id']}",
        "locale": row["locale"],
        "utterance": row["utt"],
        "expected_scenario": row["scenario"],
    }
    for row in massive_sample
]
input_dataset = ray.data.from_items(records).repartition(ACTOR_COUNT * 8)
print(f"Prepared {len(records):,} records across {len(LOCALES)} locales and {len(scenario_names)} scenarios.")

Definieer de vLLM-voorspeller

MASSIVE groepeert uitingen in 18 scenario's, zoals alarm, weather, en music. Dit notitieboekje bouwt de toegestane labels en scenario-naar-intentie-richtlijnen uit de dataset in plaats van ze hardcodend te coderen.

De scenario-naar-intentie-mapping helpt Qwen labels met vergelijkbare betekenissen te onderscheiden. vLLM geeft een van de toegestane labels terug, en een laatste normalisatiestap markeert elke andere reactie als ongeldig.

scenario_set = set(scenario_names)
scenario_guidance = "\n".join(
    f"- {scenario}: {', '.join(scenario_intents[scenario])}"
    for scenario in scenario_names
)
system_prompt = (
    "Classify the user utterance into exactly one MASSIVE scenario. "
    "Use these scenario-to-intent mappings to distinguish similar labels:\n"
    f"{scenario_guidance}\n"
    "Return only the scenario label."
)

def format_prompt(tokenizer, utterance: str) -> str:
    messages = [
        {"role": "system", "content": system_prompt},
        {"role": "user", "content": utterance},
    ]
    return tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)

def normalize_label(response: str) -> str | None:
    normalized = re.sub(r"[^a-z]+", " ", response.lower()).strip()
    return normalized if normalized in scenario_set else None

class VLLMPredictor:
    def __init__(self):
        gpu_ids = ray.get_runtime_context().get_accelerator_ids().get("GPU", [])
        if len(gpu_ids) != 1:
            raise RuntimeError(f"Expected one GPU per actor, but received {gpu_ids}.")
        self.gpu_assignment = str(gpu_ids[0])
        self.llm = LLM(
            model=MODEL_NAME,
            tensor_parallel_size=1,
            dtype="bfloat16",
            max_model_len=MAX_MODEL_LEN,
            max_num_seqs=BATCH_SIZE,
            gpu_memory_utilization=0.90,
            enable_prefix_caching=True,
        )
        self.tokenizer = self.llm.get_tokenizer()
        self.sampling_params = SamplingParams(
            temperature=0.0,
            max_tokens=MAX_OUTPUT_TOKENS,
            structured_outputs=StructuredOutputsParams(choice=scenario_names),
        )

    def __call__(self, batch: pd.DataFrame) -> pd.DataFrame:
        prompts = [format_prompt(self.tokenizer, utterance) for utterance in batch["utterance"]]
        outputs = self.llm.generate(prompts, self.sampling_params, use_tqdm=False)
        raw_responses = [output.outputs[0].text.strip() for output in outputs]
        predicted_scenarios = [normalize_label(response) for response in raw_responses]

        result = batch.copy()
        result["raw_response"] = raw_responses
        # Preserve invalid responses as nulls with a stable string type across batches.
        result["predicted_scenario"] = pd.array(predicted_scenarios, dtype="string")
        result["valid_prediction"] = result["predicted_scenario"].notna()
        result["correct"] = (result["predicted_scenario"] == result["expected_scenario"]).fillna(False)
        result["model_name"] = MODEL_NAME
        result["ray_gpu_assignment"] = self.gpu_assignment
        return result

Voer batchinferentie uit en monitor

VLLMPredictor laadt Qwen één keer wanneer elke actor begint, en hergebruikt dat model dan voor elke batch die het ontvangt. Ray Data start één actor per gedetecteerde GPU en plant elke batch in op de volgende beschikbare actor.

Terwijl de inferentie draait, open je de Ray-dashboard-URL die in cel 10 door ray_init() is afgedrukt. Gebruik het dashboard om de acht predictor actors, GPU-reserveringen, taakvoortgang, logs en achterblijvers te inspecteren.

predictions = input_dataset.map_batches(
    VLLMPredictor,
    batch_format="pandas",
    batch_size=BATCH_SIZE,
    compute=ray.data.ActorPoolStrategy(size=ACTOR_COUNT),
    num_gpus=1,
)

Materialiseren en de resultaten bijhouden

Ray Data stelt deze pijplijn lui samen, zodat write_parquet() inferentie uitvoert en de resultaten in één stap opslaat. Spark leest vervolgens de Parquet-bestanden voor evaluatie zonder het model opnieuw uit te voeren. De bijbehorende MLflow-run legt workloadparameters, kwaliteitsstatistieken, tijdsgegevens, doorvoersnelheid en systeemstatistieken vast, en Databricks voegt een klikbare koppeling (1 MLflow run) toe onder de cel wanneer die is voltooid.

mlflow.set_system_metrics_sampling_interval(2)
with mlflow.start_run(run_name="raydata-massive-qwen25-32b", log_system_metrics=True) as active_run:
    parquet_output_path = f"{parquet_output_root}/{active_run.info.run_id}"
    print(f"Parquet output: {parquet_output_path}")
    mlflow.log_params(
        {
            "model": MODEL_NAME,
            "dataset": DATASET_NAME,
            "dataset_version": "1.1",
            "locales": json.dumps(LOCALES),
            "record_count": len(records),
            "actor_count": ACTOR_COUNT,
            "batch_size": BATCH_SIZE,
            "max_model_len": MAX_MODEL_LEN,
            "max_output_tokens": MAX_OUTPUT_TOKENS,
            "temperature": 0.0,
            "output_constraint": "scenario_choices",
            "system_metrics_interval_seconds": 2,
            "gpu_memory_utilization": 0.90,
        }
    )
    mlflow.set_tags(
        {
            "dataset_source": MASSIVE_ARCHIVE_URL,
            "parquet_output_path": parquet_output_path,
        }
    )

    start_time = time.perf_counter()
    predictions.write_parquet(parquet_output_path)
    cold_start_inclusive_duration_seconds = time.perf_counter() - start_time

    results_df = spark.read.parquet(parquet_output_path)
    aggregate = results_df.agg(
        F.count("*").alias("record_count"),
        F.avg(F.col("correct").cast("double")).alias("overall_accuracy"),
        F.avg(F.col("valid_prediction").cast("double")).alias("valid_prediction_rate"),
        F.countDistinct("ray_gpu_assignment").alias("unique_gpu_assignments"),
    ).first()
    scenario_accuracy_df = results_df.groupBy("expected_scenario").agg(
        F.count("*").alias("record_count"),
        F.avg(F.col("correct").cast("double")).alias("accuracy"),
        F.avg(F.col("valid_prediction").cast("double")).alias("valid_prediction_rate"),
    ).orderBy("expected_scenario")
    macro_scenario_accuracy = scenario_accuracy_df.agg(F.avg("accuracy")).first()[0]
    cold_start_inclusive_records_per_second = (
        aggregate["record_count"] / cold_start_inclusive_duration_seconds
    )
    mlflow.log_metrics(
        {
            "overall_accuracy": aggregate["overall_accuracy"],
            "macro_scenario_accuracy": macro_scenario_accuracy,
            "valid_prediction_rate": aggregate["valid_prediction_rate"],
            "cold_start_inclusive_duration_seconds": cold_start_inclusive_duration_seconds,
            "cold_start_inclusive_records_per_second": cold_start_inclusive_records_per_second,
        }
    )
    mlflow_run_id = active_run.info.run_id

print(f"MLflow run ID: {mlflow_run_id}")
print("Open the '(1 MLflow run)' link attached to this cell for parameters and metrics.")

De resultaten valideren

De onderstaande controles bevestigen dat de output één rij per invoer bevat en dat elke predictor actor ten minste één batch heeft verwerkt.

De timing begint voordat Ray de actoren aanmaakt en het model laadt, dus de gerapporteerde duur en doorvoer omvatten de koude starttijd.

if aggregate["record_count"] != len(records):
    raise RuntimeError("The persisted result count does not match the input count.")
if aggregate["unique_gpu_assignments"] != ACTOR_COUNT:
    raise RuntimeError(f"Expected results from {ACTOR_COUNT} Ray GPU assignments.")

print(f"Records: {aggregate['record_count']:,}")
print(f"Overall accuracy: {aggregate['overall_accuracy']:.2%}")
print(f"Macro scenario accuracy: {macro_scenario_accuracy:.2%}")
print(f"Valid prediction rate: {aggregate['valid_prediction_rate']:.2%}")
print(f"Inference duration including actor and model cold start: {cold_start_inclusive_duration_seconds:.1f} seconds")
print(f"Throughput including actor and model cold start: {cold_start_inclusive_records_per_second:.1f} records/second")
print(f"Unique GPU assignments: {aggregate['unique_gpu_assignments']}")

Analyseer de voorspellingskwaliteit

Toon nauwkeurigheid per locatie, een steekproef van voorspellingen en de verdeling van records over GPU-actoren.

locale_accuracy_df = (
    results_df.groupBy("locale")
    .agg(
        F.count("*").alias("record_count"),
        F.avg(F.col("correct").cast("double")).alias("accuracy"),
        F.avg(F.col("valid_prediction").cast("double")).alias("valid_prediction_rate"),
    )
    .orderBy("locale")
)

print("Accuracy by locale:")
locale_accuracy_df.show(truncate=False)

prediction_columns = [
    "locale", "utterance", "expected_scenario", "predicted_scenario",
    "correct", "ray_gpu_assignment",
]
sample_predictions_df = (
    results_df.select(prediction_columns)
    .orderBy(F.rand(SEED))
    .limit(16)
)
actor_distribution_df = (
    results_df.groupBy("ray_gpu_assignment")
    .agg(F.count("*").alias("record_count"))
    .orderBy("ray_gpu_assignment")
)

print("Sample predictions:")
sample_predictions_df.show(truncate=80)
print("Records by Ray GPU assignment:")
actor_distribution_df.show(truncate=False)

Voorbeeld van notebook

Qwen2.5-32B batchinferentie met Ray Data en vLLM

Notebook krijgen