Wykonywanie zapytań dotyczących punktów końcowych dla modeli niestandardowych

W tym artykule dowiesz się, jak sformatować żądania oceniania dla obsługiwanego modelu oraz jak wysyłać te żądania do punktu końcowego obsługującego model. Wskazówki dotyczą obsługi modeli niestandardowych, które usługa Databricks definiuje jako tradycyjne modele uczenia maszynowego lub dostosowane modele języka Python spakowane w formacie MLflow. Można je zarejestrować w Unity Catalog lub w rejestrze modeli przestrzeni roboczej. Przykłady obejmują modele przekształcania twarzy scikit-learn, XGBoost, PyTorch i Hugging Face transformer. Zobacz Deploy models using Mosaic AI Model Serving, aby uzyskać więcej informacji na temat tej funkcjonalności i obsługiwanych kategorii modeli.

Aby uzyskać zapytania dotyczące obciążenia wynikającego z generatywnej SI i LLM, zobacz Podstawowe modele zapytań.

Wymagania

• Model obsługujący punkt końcowy.
• W przypadku zestawu MLflow Deployment SDK wymagany jest zestaw MLflow 2.9 lub nowszy.
• Żądanie oceniania w akceptowanym formacie.
• Aby wysłać żądanie oceniania za pomocą interfejsu API REST lub zestawu MLflow Deployment SDK, musisz mieć token interfejsu API usługi Databricks.

Metody i przykłady wykonywania zapytań

Obsługa modelu mozaiki sztucznej inteligencji udostępnia następujące opcje wysyłania żądań oceniania do obsługiwanych modeli:

Przykład oceniania ramek danych biblioteki Pandas

W poniższym przykładzie założono, że MODEL_VERSION_URI, podobnie jak https://<databricks-instance>/model/iris-classifier/Production/invocations, where<databricks-instance>, to nazwa Twojego wystąpienia usługi Databricks, a to token interfejsu API REST usługi Databricks o nazwie DATABRICKS_API_TOKEN.

Zobacz Obsługiwane formaty oceniania.

Interfejs API REST

Ocenianie modelu akceptującego podzielony format wejściowy ramki danych.

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]]
    }]
  }'

Ocenianie modelu akceptującego dane wejściowe tensor. Dane wejściowe tensor powinny być sformatowane zgodnie z opisem w dokumentacji interfejsu API usługi TensorFlow.

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]]}'

Zestaw SDK wdrożeń MLflow

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]]
                    }
                }
          )

SQL

W poniższym przykładzie model znajduje się za sentiment-analysis punktem końcowym z zestawem text danych i określa zwracany typ żądania.

SELECT text, ai_query(
    "sentiment-analysis",
    text,
    returnType => "STRUCT<label:STRING, score:DOUBLE>"
  ) AS predict
FROM
  catalog.schema.customer_reviews

PowerBI

Zestaw danych można ocenić w programie Power BI Desktop, wykonując następujące kroki:

1. Otwórz zestaw danych, który chcesz ocenić.

2. Przejdź do pozycji Przekształć dane.

3. Kliknij prawym przyciskiem myszy na panelu po lewej stronie i selectUtwórz nowe zapytanie.

4. Przejdź do pozycji Wyświetl > Edytor zaawansowany.

5. Zastąp treść zapytania poniższym fragmentem kodu po wypełnieniu odpowiedniego DATABRICKS_API_TOKEN elementu i 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. Nadaj kwerendzie nazwę żądanego modelu.

7. Otwórz zaawansowany edytor zapytań dla zestawu danych i zastosuj funkcję modelu.

Przykład danych wejściowych tensor

Poniższy przykład ocenia model akceptujący dane wejściowe tensor. Dane wejściowe tensor powinny być sformatowane zgodnie z opisem w dokumentacji interfejsu API usługi TensorFlow . W tym przykładzie przyjęto założenie, że MODEL_VERSION_URI, taki jak https://<databricks-instance>/model/iris-classifier/Production/invocations, where<databricks-instance> jest nazwą wystąpienia usługi Databricksoraz tokenem interfejsu API REST usługi Databricks o nazwie 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]]}'

Obsługiwane formaty oceniania

W przypadku modeli niestandardowych obsługa modeli obsługuje ocenianie żądań w ramce danych Biblioteki Pandas lub danych wejściowych Tensor.

Ramka danych biblioteki Pandas

Żądania powinny być wysyłane przez skonstruowanie zserializowanej ramki danych Pandas w formacie JSON z jednym z obsługiwanych kluczy i obiektu JSON odpowiadającego formatowi wejściowemu.

• (Zalecane)dataframe_split format to serializowana ramka danych Biblioteki Pandas w formacie JSON w orientacji 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 to serializowana ramka danych Biblioteki Pandas w formacie JSON w orientacji records .

  Uwaga

  Ten format nie gwarantuje zachowania kolejności column, a format split jest preferowany od formatu records.

  {
    "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
    }
    ]
  }
  

Odpowiedź z punktu końcowego zawiera dane wyjściowe z modelu, serializowane przy użyciu kodu JSON, opakowane w predictions klucz.

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

Dane wejściowe programu Tensor

Gdy model oczekuje tensorów, takich jak model TensorFlow lub Pytorch, istnieją dwie obsługiwane opcje formatowania wysyłania żądań: instances i inputs.

Jeśli masz wiele nazwanych tensorów na wiersz, musisz mieć jeden z poszczególnych tensorów dla każdego wiersza.

• instances jest formatem opartym na tensorach, który akceptuje tensory w formacie wiersza. Użyj tego formatu, jeśli wszystkie tensory wejściowe mają ten sam wymiar 0-ty. Koncepcyjnie każdy tensor w wystąpieniach list można połączyć z innymi tensorami o tej samej nazwie w pozostałej części list, aby skonstruować pełny tensor wejściowy dla modelu, co byłoby możliwe tylko wtedy, gdy wszystkie tensory mają ten sam wymiar 0.

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

  W poniższym przykładzie pokazano, jak określić wiele nazwanych tensorów.

  {
  "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 wysyłać zapytania z tensorami w formacie kolumnowym. To żądanie jest inne, ponieważ istnieje w rzeczywistości inna liczba wystąpień tensorów (3) niż t2 i t1, więc nie można reprezentować tych danych wejściowych t3 w instances formacie.

  {
  "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]]]
  }
  }
  

Odpowiedź z punktu końcowego ma następujący format.

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

Przykład notesu

Zapoznaj się z poniższym notesem, aby zapoznać się z przykładem testowania punktu końcowego obsługującego model modelu przy użyciu modelu w języku Python:

Notes punktu końcowego obsługującego model testowy

Get notesu

Dodatkowe zasoby

• Wnioskowanie tables na potrzeby monitorowania i debugowania modeli.
• Modele podstawowe zapytań.
• Przewodnik debugowania dotyczący obsługi modelu.