Dela via

Frågeserverslutpunkter för anpassade modeller

  • Artikel

I den här artikeln lär du dig hur du formaterar bedömningsbegäranden för din betjänade modell och hur du skickar dessa begäranden till den modell som betjänar slutpunkten. Vägledningen är relevant för att hantera anpassade modeller, som Databricks definierar som traditionella ML-modeller eller anpassade Python-modeller som paketeras i MLflow-format. De kan registreras antingen i Unity Catalog eller i arbetsytans modellregister. Exempel är scikit-learn, XGBoost, PyTorch och Hugging Face transformermodeller. Mer information om den här funktionen och modellkategorier som stöds finns i Distribuera modeller med hjälp av Mosaic AI Model Serving.

Information om frågebegäranden för generativa AI- och LLM-arbetsbelastningar finns i Grundläggande modellsökning.

Krav

Viktigt!

Som bästa säkerhet för produktionsscenarier rekommenderar Databricks att du använder OAuth-token från dator till dator för autentisering under produktion.

För testning och utveckling rekommenderar Databricks att du använder en personlig åtkomsttoken som tillhör tjänstens huvudnamn i stället för arbetsyteanvändare. Information om hur du skapar token för tjänstens huvudnamn finns i Hantera token för tjänstens huvudnamn.

Frågemetoder och exempel

Mosaic AI Model Serving innehåller följande alternativ för att skicka bedömningsbegäranden till hanterade modeller:

Metod Detaljer
Serveringsgränssnitt Välj frågeslutpunkt från sidan tjänstslutpunkt i din Databricks-arbetsyta. Infoga indata för JSON-formatmodellen och klicka på Skicka begäran. Om modellen har ett indataexempel loggat använder du Visa exempel för att läsa in det.
SQL-funktion Anropa modellinferens direkt från SQL med hjälp av ai_query SQL-funktionen. Se ai_query funktion.
REST-API Anropa och fråga modellen med hjälp av REST-API:et. Mer information finns i POST /serving-endpoints/{name}/invocations . Information om bedömning av begäranden till slutpunkter som betjänar flera modeller finns i Fråga efter enskilda modeller bakom en slutpunkt.
SDK för MLflow-distributioner Använd SDK:s predict()-funktion för MLflow Deployments för att fråga modellen.

Pandas DataFrame-bedömningsexempel

I följande exempel förutsätts en MODEL_VERSION_URI som https://<databricks-instance>/model/iris-classifier/Production/invocations, där <databricks-instance> är det namnet på din Databricks-instansoch en Databricks REST API-token som heter DATABRICKS_API_TOKEN.

Se Bedömningsformat som stöds.

REST-API

Poängsätt en modell som accepterar dataramens delade indataformat.

curl -X POST -u token:$DATABRICKS_API_TOKEN $MODEL_VERSION_URI \
  -H 'Content-Type: application/json' \
  -d '{"dataframe_split": [{
    "columns": ["sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"],
    "data": [[5.1, 3.5, 1.4, 0.2], [4.9, 3.0, 1.4, 0.2]]
    }]
  }'

Poängsätta en modell som accepterar tensor-indata. Tensor-indata ska formateras enligt beskrivningen i TensorFlow Servings API-dokumentation.

curl -X POST -u token:$DATABRICKS_API_TOKEN $MODEL_VERSION_URI \
  -H 'Content-Type: application/json' \
  -d '{"inputs": [[5.1, 3.5, 1.4, 0.2]]}'

SDK för MLflow-distributioner

Viktigt!

I följande exempel används API:et predict()från MLflow Deployments SDK.


import mlflow.deployments

export DATABRICKS_HOST="https://<workspace_host>.databricks.com"
export DATABRICKS_TOKEN="dapi-your-databricks-token"

client = mlflow.deployments.get_deploy_client("databricks")

response = client.predict(
            endpoint="test-model-endpoint",
            inputs={"dataframe_split": {
                    "index": [0, 1],
                    "columns": ["sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"],
                    "data": [[5.1, 3.5, 1.4, 0.2], [4.9, 3.0, 1.4, 0.2]]
                    }
                }
          )

Power BI

Du kan poängsätta en datauppsättning i Power BI Desktop med hjälp av följande steg:

  1. Öppna datasettet som du vill analysera.

  2. Gå till Bearbeta data.

  3. Högerklicka på den vänstra panelen och välj Skapa ny fråga.

  4. Gå till Visa > Avancerad redigerare.

  5. Ersätt frågetexten med kodfragmentet nedan när du har fyllt i en lämplig DATABRICKS_API_TOKEN och MODEL_VERSION_URI.

    (dataset as table ) as table =>
let
  call_predict = (dataset as table ) as list =>
  let
    apiToken = DATABRICKS_API_TOKEN,
    modelUri = MODEL_VERSION_URI,
    responseList = Json.Document(Web.Contents(modelUri,
      [
        Headers = [
          #"Content-Type" = "application/json",
          #"Authorization" = Text.Format("Bearer #{0}", {apiToken})
        ],
        Content = {"dataframe_records": Json.FromValue(dataset)}
      ]
    ))
  in
    responseList,
  predictionList = List.Combine(List.Transform(Table.Split(dataset, 256), (x) => call_predict(x))),
  predictionsTable = Table.FromList(predictionList, (x) => {x}, {"Prediction"}),
  datasetWithPrediction = Table.Join(
    Table.AddIndexColumn(predictionsTable, "index"), "index",
    Table.AddIndexColumn(dataset, "index"), "index")
in
  datasetWithPrediction

  6. Namnge frågan med önskat modellnamn.

  7. Öppna den avancerade frågeredigeraren för datamängden och tillämpa modellfunktionen.

Exempel på Tensor-indata

I följande exempel poängsättas en modell som accepterar tensor-indata. Tensor-indata ska formateras enligt beskrivningen i TensorFlow Servings API-dokument. I det här exemplet förutsätts en MODEL_VERSION_URI som https://<databricks-instance>/model/iris-classifier/Production/invocations, där <databricks-instance> är namnet på din Databricks-instansoch en Rest API-token för Databricks med namnet DATABRICKS_API_TOKEN.

curl -X POST -u token:$DATABRICKS_API_TOKEN $MODEL_VERSION_URI \
    -H 'Content-Type: application/json' \
    -d '{"inputs": [[5.1, 3.5, 1.4, 0.2]]}'

Bedömningsformat som stöds

För anpassade modeller har modellservern stöd för bedömningsbegäranden i Pandas DataFrame- eller Tensor-indata.

Pandas DataFrame

Begäranden ska skickas genom att skapa en JSON-serialiserad Pandas DataFrame med en av de nycklar som stöds och ett JSON-objekt som motsvarar indataformatet.

  • (Rekommenderas)dataframe_split formatet är en JSON-serialiserad Pandas DataFrame i orienteringen split .

    {
  "dataframe_split": {
    "index": [0, 1],
    "columns": ["sepal length (cm)", "sepal width (cm)", "petal length (cm)", "petal width (cm)"],
    "data": [
      [5.1, 3.5, 1.4, 0.2],
      [4.9, 3.0, 1.4, 0.2]
    ]
  }
}

  • dataframe_records är en JSON-serialiserad Pandas DataFrame i records-orientering.

    Kommentar

    Det här formatet garanterar inte att kolumnordningen bevaras, och split format föredras framför det records formatet.

    {
  "dataframe_records": [
    {
      "sepal length (cm)": 5.1,
      "sepal width (cm)": 3.5,
      "petal length (cm)": 1.4,
      "petal width (cm)": 0.2
    },
    {
      "sepal length (cm)": 4.9,
      "sepal width (cm)": 3,
      "petal length (cm)": 1.4,
      "petal width (cm)": 0.2
    },
    {
      "sepal length (cm)": 4.7,
      "sepal width (cm)": 3.2,
      "petal length (cm)": 1.3,
      "petal width (cm)": 0.2
    }
  ]
}

Svaret från slutpunkten innehåller utdata från din modell, serialiserade med JSON, inlindade i en predictions nyckel.

{
  "predictions": [0, 1, 1, 1, 0]
}

Tensorinmatning

När din modell förväntar sig tensorer, till exempel en TensorFlow- eller Pytorch-modell, finns det två formatalternativ som stöds för att skicka begäranden: instances och inputs.

Om du har flera namngivna tensorer per rad måste du ha en av varje tensor för varje rad.

  • instances är ett tensors-baserat format som accepterar tensorer i radformat. Använd det här formatet om alla indata tensorer har samma 0:e dimension. Konceptuellt kan varje tensor i instanslistan kopplas samman med de andra tensorerna med samma namn i resten av listan för att konstruera den fullständiga indatatensorn för modellen, vilket bara skulle vara möjligt om alla tensorer har samma nollte dimension.

    { "instances": [1, 2, 3] }

    I följande exempel visas hur du anger flera namngivna tensorer.

    {
  "instances": [
    {
      "t1": "a",
      "t2": [1, 2, 3, 4, 5],
      "t3": [
        [1, 2],
        [3, 4],
        [5, 6]
      ]
    },
    {
      "t1": "b",
      "t2": [6, 7, 8, 9, 10],
      "t3": [
        [7, 8],
        [9, 10],
        [11, 12]
      ]
    }
  ]
}

  • inputs skicka frågor med tensorer i kolumnformat. Den här begäran skiljer sig eftersom det faktiskt finns ett annat antal tensor-instanser av t2 (3) än t1 och t3, så det går inte att representera dessa indata i instances formatet.

    {
  "inputs": {
    "t1": ["a", "b"],
    "t2": [
      [1, 2, 3, 4, 5],
      [6, 7, 8, 9, 10]
    ],
    "t3": [
      [
        [1, 2],
        [3, 4],
        [5, 6]
      ],
      [
        [7, 8],
        [9, 10],
        [11, 12]
      ]
    ]
  }
}

Svaret från slutpunkten är i följande format.

{
  "predictions": [0, 1, 1, 1, 0]
}

Notebook-exempel

I följande notebook-fil finns ett exempel på hur du testar din modellserveringsslutpunkt med en Python-modell:

Anteckningsbok för modellserveringsslutpunkt

Hämta anteckningsbok

Ytterligare resurser