Hantera anpassade LLM:er med anpassad modellservering

Den här sidan visar hur du kan drifta din egen LLM på en Model Serving GPU-endpoint. Varje modell som vLLM kör blir en produktionsändpunkt med ett OpenAI-kompatibelt API. Så här fungerar det:

• Du kör inferensservern, till exempel vLLM, och väljer dess version och inställningar.
• Du testar servern i en serverless GPU notebook. En felaktig flagga eller ett minnesbristfel dyker upp inom sekunder istället för efter en utplacering.
• Du driftsätter samma kommando och miljö som du byggt och vet fungerar till en produktionstjänst-endpoint.

Quickstart

Importera följande notebook till din arbetsyta och klicka på Kör allt på AI Runtime med ett A10-grafikkort. På cirka 15 minuter har du en Qwen3.5-4B-endpoint som svarar på OpenAI-kompatibla chattförfrågningar.

Kör Qwen3.5-4B med vLLM

Hämta anteckningsbok

När du ska använda anpassad LLM-servering

Använd anpassad LLM-drift i följande fall:

• Du finjusterade en LLM på AI Runtime och vill driftsätta den. Se avsnittet nedan för ett exempel.
• Du vill leverera en öppen modell som Foundation Model API:er (FMAPI) inte stödjer, som en ny LLM, en tal-till-text-modell eller en embedding-modell.
• Du vill ändra körtiden eller arkitekturen för en LLM och behöver kontroll över körtiden och miljön.

Använd inte anpassad LLM-servering i följande fall:

• FMAPI levererar modellen du behöver, oförändrad. FMAPI är enklare att använda och mycket optimerad.
• Modellen passar inte på ett enda grafikkort med cirka 80 GB minne. Till exempel passar Qwen3.8-27B och gpt-oss-120b, men Kimi K3 och GLM 5.3 gör det inte.
• Du behöver genomströmning på toppnivå eller pris per token utan att justera. Prestandan matchar open-source vLLM på samma GPU.

Requirements

Anpassad LLM-servering har följande krav:

• Din arbetsyta måste ha serverless GPU-beräkning.
• Du måste registrera modellen från en serverlös GPU-notebook. En modell som har loggats från en CPU-miljö paketerar CPU-beroenden, och GPU-ändpunkten startar inte.
• Du måste ha behörighet att skapa modeller i ett Unity Catalog-schema.
• Du måste registrera modellen hos env_pack="databricks_model_serving". Anpassad LLM-servering byggs på express-driftsättningar, som paketerar notebookens miljö med modellen.
• Du måste använda MLflow 3.12 eller högre och databricks-sdk 0.102.0 eller högre. AI v6-miljön inkluderar båda.

startanteckningsböcker

Varje notebook tar en modell från Hugging Face till en endpoint som anropas, som quickstart. Kör en som den är, eller börja från en för att driftsätta din egen modell.

AI v6 och Standard v6 är AI-miljöer för runtime. AI v6 levereras med vLLM, PyTorch, Transformers och andra vanliga maskininlärningspaket förinstallerade och redo att användas. Se AI v6-paketlistan. En Standard v6-notebook installerar vLLM själv, så du väljer vilken version av vLLM som ska användas. Använd en Standard v6-notebook när din modell behöver en nyare vLLM eller transformers än vad AI v6 har, som med Muse Glimmer.

Kör din egen modell

För att använda en annan modell, välj startnotebooken med samma uppgift och den GPU som din modell behöver. Byt MODEL_REPO_ID och flaggorna i vllm_command, kör sedan anteckningsboken. Varje notebook kör följande steg:

1. Ladda ner modellvikterna från Hugging Face, eller hämta dem från en träningscheckpunkt.
2. Starta vLLM i anteckningsboken och fråga den.
3. Logga modellen med vLLM-kommandot som dess ingångspunkt och registrera den i Unity Catalog som en express-driftsättning.
4. Skapa en endpoint för servering som startar samma kommando.
5. Fråga ändpunkten med OpenAI-klienten, Databricks SDK eller SQL ai_query.

I följande exempel lagrar modellen metadata uppgiften och ingångspunkten:

import mlflow
from mlflow.pyfunc.model import ChatCompletionResponse, ChatModel

# The endpoint runs the entrypoint and never calls predict, but MLflow needs a model class to log.
class Placeholder(ChatModel):
    def predict(self, context, messages, params):
        return ChatCompletionResponse.from_dict({"choices": []})

model_info = mlflow.pyfunc.log_model(
    name="my-model",
    python_model=Placeholder(),
    artifacts={"model_dir": "my-model"},  # the weights folder, which --model names
    metadata={
        "task": "llm/v1/chat",
        "entrypoint": (
            "python -u -m vllm.entrypoints.openai.api_server "
            "--model my-model --served-model-name my-model "
            "--host 0.0.0.0 --port 8080 --max-model-len 16384"
        ),
    },
)
mlflow.register_model(model_info.model_uri, "<catalog>.<schema>.my_model", env_pack="databricks_model_serving")

Driftsätt en finjusterad modell

Finjustera en modell i AI Runtime och driftsätt den från samma notebook. För ett exempel, se Supervised fine-tuning (Full) and serving of Qwen3.5-0.8B. Handledningen finjusterar Qwen3.5-0.8B på en enda H100, jämför svar före och efter träning och driftsätter den finjusterade modellen.

Uppgifter som stöds

Elementet task i modellens metadata anger vilket API endpointen betjänar. Din server måste exponera det OpenAI-kompatibla API:et för den uppgiften. Andra uppgifter, såsom llm/v1/completions, stöds inte. Följande tabell listar de stödda uppgifterna.

Välj ett grafikkort

Azure Databricks rekommenderar att utveckla på samma GPU som du kör på, så de inställningar du testar är de inställningar du distribuerar. Följande tabell listar GPU:erna för anpassad LLM-servering.

Vanliga problem

Följande problem är de vanligaste när du byter bärbar dator:

• Nedladdningen misslyckas i /Workspace, vilket inte accepterar filer med flera GB. Ladda ner modellvikterna till lokal disk, precis som startanteckningsböckerna gör.
• Den lokala servern startar inte. Serverlösa GPU-notebooks tillåter bara portar från 3000 till 3999, så testa på någon av dessa portar. Endast entrypoint använder port 8080, och den måste annars matcha kommandot du testade.
• Ändpunkten kan inte hitta vikterna. Instegspunkten körs i modellens artefaktmapp, så --model måste ange viktmappen du loggade.
• En embeddingmodell tillhandahåller inte embeddingar. Starta vLLM med --runner pooling.
• Registreringen ger TimeoutError('Timed out after 0:05:00') vid uppladdning av model_version.tar eller model_environment.tar. Uppgradera till databricks-sdk 0.102.0 eller högre och registrera modellen igen.

Skapa en slutpunkt

Skapa endpointen från Serving UI eller med Databricks SDK, som startnotebooks gör. workload_type väljer GPU:n, och workload_size (Small, Medium, eller Large) sätter antalet repliker.

ServedEntityInput(
    entity_name="<catalog>.<schema>.<model>",
    entity_version="<version>",
    workload_type=ServingModelWorkloadType.GPU_MEDIUM,
    workload_size="Small",
    scale_to_zero_enabled=False,
)

Scale-to-zero och kapacitet

För närvarande skalar anpassade LLM-endpoints inte automatiskt, så dimensionera workload_size för din topptrafik.

Med scale-to-zero stoppas alla repliker för en inaktiv endpoint. Nästa förfrågan dröjer en till flera minuter medan vLLM laddar modellen igen och alla repliker startar. Azure Databricks rekommenderar att man stänger av skal-till-noll för produktionstrafik.

Ställ en fråga till din ändpunkt

En färdig chatt-endpoint visas i AI Playground. Följande exempel gör anrop till en endpoint med Databricks SDK, OpenAI-klienten och REST.

Databricks SDK

from databricks.sdk import WorkspaceClient
from databricks.sdk.service.serving import ChatMessage, ChatMessageRole

w = WorkspaceClient()
w.serving_endpoints.query(
    name="<endpoint-name>",
    messages=[ChatMessage(role=ChatMessageRole.USER, content="Hello")],
)

OpenAI-klient

from openai import OpenAI

client = OpenAI(api_key=DATABRICKS_TOKEN, base_url=f"{DATABRICKS_HOST}/serving-endpoints")

client.chat.completions.create(model="<endpoint-name>", messages=[{"role": "user", "content": "Hello"}])
client.embeddings.create(model="<endpoint-name>", input=["The quick brown fox jumps over the lazy dog."])
with open("speech.flac", "rb") as audio:
    client.audio.transcriptions.create(model="<endpoint-name>", file=audio)

REST: chatt

curl -X POST \
  -u "token:$DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"messages":[{"role":"user","content":"Hello"}]}' \
  https://<workspace-url>/serving-endpoints/<endpoint-name>/invocations

REST: inbäddningar

curl -X POST \
  -u "token:$DATABRICKS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"input":["The quick brown fox jumps over the lazy dog."]}' \
  https://<workspace-url>/serving-endpoints/<endpoint-name>/invocations

Vissa inbäddningsmodeller förväntar sig ett prefix på varje indata, såsom search_query: eller search_document:. Kolla modellkortet.

Övervaka slutpunkten

Slutpunktens flik Loggar visar din servers stdout och stderr i realtid. logs API returnerar samma utdata.

Azure Databricks vidarebefordrar din vLLM-servers metrics och visar dem på endpointens Metrics-flik:

• Latens: tid till första token, tid per utgångstoken, förfrågningslatens och kötid.
• Belastning: förfrågningar körs och väntar.
• KV-cache: användning och träfffrekvens.
• Genomströmning: prompt- och genereringstokens per sekund.

Exportmetrics API returnerar samma mätvärden i Prometheus-format, så du kan skrapa dem in i Prometheus eller Datadog.

Med telemetri aktiverat sparar Azure Databricks också serverloggarna och vLLM Prometheus-metrikerna i Unity Catalog-tabeller, så att du kan fråga dem under längre perioder. Se Persistera anpassad modellserveringsdata till Unity Catalog.

Pricing

Du betalar per GPU-instanstimme, samma som för annan GPU-anpassad modelldrift. Se Model Serving-prissättning.

Begränsningar och regiontillgänglighet

Du registrerar en anpassad LLM från AI Runtime, så anpassad LLM-servering finns tillgänglig i samma regioner som serverless GPU-beräkning. Det är amerikanska regioner på AWS och Azure. GCP stöds inte.

Följande funktioner kommer snart:

• LoRA-adapter.
• Tjänst över flera regioner.
• Logga modeller utanför AI Runtime, till exempel från Databricks Runtime eller CPU-serverlös.

Följande funktioner stöds inte:

• KV-cachemedveten routning.
• Ruttoptimering.