Jak uruchomić ocenę i wyświetlić wyniki
Ważne
Ta funkcja jest dostępna w publicznej wersji zapoznawczej.
W tym artykule opisano sposób uruchamiania oceny i wyświetlania wyników podczas opracowywania aplikacji sztucznej inteligencji. Aby uzyskać informacje na temat monitorowania jakości wdrożonych agentów w ruchu produkcyjnym, zobacz Jak monitorować jakość agenta w ruchu produkcyjnym.
Aby użyć oceny agenta podczas opracowywania aplikacji, należy określić zestaw oceny. Zestaw oceny to zestaw typowych żądań wysyłanych przez użytkownika do aplikacji. Zestaw oceny może również zawierać oczekiwaną odpowiedź (prawda podstawy) dla każdego żądania wejściowego. Jeśli zostanie podana oczekiwana odpowiedź, ocena agenta może obliczyć dodatkowe metryki jakości, takie jak poprawność i niedobór kontekstu. Celem zestawu oceny jest ułatwienie mierzenia i przewidywania wydajności aplikacji agenta przez przetestowanie jej na reprezentatywnych pytaniach.
Aby uzyskać więcej informacji na temat zestawów oceny, zobacz Zestawy oceny. Aby uzyskać wymagany schemat, zobacz Schemat danych wejściowych oceny agenta.
Aby rozpocząć ocenę, należy użyć mlflow.evaluate() metody z interfejsu API MLflow. mlflow.evaluate() oblicza oceny jakości wraz z metrykami opóźnienia i kosztów dla poszczególnych danych wejściowych w zestawie oceny, a także agreguje te wyniki we wszystkich danych wejściowych. Wyniki te są również określane jako wyniki oceny. Poniższy kod przedstawia przykład wywołania metody mlflow.evaluate():
%pip install databricks-agents
dbutils.library.restartPython()
import mlflow
import pandas as pd
eval_df = pd.DataFrame(...)
# Puts the evaluation results in the current Run, alongside the logged model parameters
with mlflow.start_run():
logged_model_info = mlflow.langchain.log_model(...)
mlflow.evaluate(data=eval_df, model=logged_model_info.model_uri,
model_type="databricks-agent")
W tym przykładzie mlflow.evaluate() rejestruje wyniki oceny w otaczającym przebiegu platformy MLflow wraz z informacjami rejestrowanymi przez inne polecenia (takie jak parametry modelu). Jeśli wywołasz mlflow.evaluate() przebieg poza przebiegiem platformy MLflow, zostanie uruchomiony nowy przebieg i wyniki oceny dzienników w tym przebiegu. Aby uzyskać więcej informacji o mlflow.evaluate()systemie , w tym szczegółowe informacje o wynikach oceny, które są rejestrowane w przebiegu, zobacz dokumentację platformy MLflow.
Wymagania
Funkcje pomocnicze sztucznej inteligencji oparte na sztucznej inteligencji platformy Azure muszą być włączone dla obszaru roboczego.
Jak dostarczyć dane wejściowe do przebiegu oceny
Istnieją dwa sposoby dostarczania danych wejściowych do przebiegu oceny:
Podaj wcześniej wygenerowane dane wyjściowe, aby porównać je z zestawem oceny. Ta opcja jest zalecana, jeśli chcesz ocenić dane wyjściowe z aplikacji, która jest już wdrożona w środowisku produkcyjnym, lub jeśli chcesz porównać wyniki oceny między konfiguracjami oceny.
W przypadku tej opcji należy określić zestaw oceny, jak pokazano w poniższym kodzie. Zestaw oceny musi zawierać wcześniej wygenerowane dane wyjściowe. Aby uzyskać bardziej szczegółowe przykłady, zobacz Przykład: Jak przekazać wcześniej wygenerowane dane wyjściowe do oceny agenta.
evaluation_results = mlflow.evaluate( data=eval_set_with_chain_outputs_df, # pandas DataFrame with the evaluation set and application outputs model_type="databricks-agent", )Przekaż aplikację jako argument wejściowy.
mlflow.evaluate()wywołuje aplikację dla każdego danych wejściowych w zestawie oceny i raportuje oceny jakości oraz inne metryki dla każdego wygenerowanego danych wyjściowych. Ta opcja jest zalecana, jeśli aplikacja została zarejestrowana przy użyciu biblioteki MLflow z włączonym śledzeniem MLflow lub jeśli aplikacja jest implementowana jako funkcja języka Python w notesie. Ta opcja nie jest zalecana, jeśli aplikacja została opracowana poza usługą Databricks lub jest wdrażana poza usługą Databricks.W przypadku tej opcji należy określić zestaw oceny i aplikację w wywołaniu funkcji, jak pokazano w poniższym kodzie. Aby uzyskać bardziej szczegółowe przykłady, zobacz Przykład: jak przekazać aplikację do oceny agenta.
evaluation_results = mlflow.evaluate( data=eval_set_df, # pandas DataFrame containing just the evaluation set model=model, # Reference to the MLflow model that represents the application model_type="databricks-agent", )
Aby uzyskać szczegółowe informacje na temat schematu zestawu oceny, zobacz Schemat danych wejściowych oceny agenta.
Dane wyjściowe oceny
Ocena agenta zwraca swoje dane wyjściowe z mlflow.evaluate() ramek danych, a także rejestruje te dane wyjściowe w uruchomieniu platformy MLflow. Możesz sprawdzić dane wyjściowe w notesie lub na stronie odpowiedniego przebiegu platformy MLflow.
Przeglądanie danych wyjściowych w notesie
Poniższy kod przedstawia kilka przykładów sposobu przeglądania wyników przebiegu oceny z notesu.
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
###
# Run evaluation
###
evaluation_results = mlflow.evaluate(..., model_type="databricks-agent")
###
# Access aggregated evaluation results across the entire evaluation set
###
results_as_dict = evaluation_results.metrics
results_as_pd_df = pd.DataFrame([evaluation_results.metrics])
# Sample usage
print(f"The percentage of generated responses that are grounded: {results_as_dict['response/llm_judged/groundedness/percentage']}")
###
# Access data about each question in the evaluation set
###
per_question_results_df = evaluation_results.tables['eval_results']
# Show information about responses that are not grounded
per_question_results_df[per_question_results_df["response/llm_judged/groundedness/rating"] == "no"].display()
Ramka per_question_results_df danych zawiera wszystkie kolumny w schemacie wejściowym i wszystkie wyniki oceny specyficzne dla każdego żądania. Aby uzyskać więcej informacji na temat obliczonych wyników, zobacz Jak jakość, koszt i opóźnienie są oceniane przez ocenę agenta.
Przeglądanie danych wyjściowych przy użyciu interfejsu użytkownika platformy MLflow
Wyniki oceny są również dostępne w interfejsie użytkownika platformy MLflow. Aby uzyskać dostęp do interfejsu użytkownika platformy MLflow, kliknij ikonę 
Eksperyment na prawym pasku bocznym notesu, a następnie na odpowiednim uruchomieniu lub kliknij linki wyświetlane w wynikach komórki notesu, w której uruchomiono mlflow.evaluate()polecenie .
Przeglądanie wyników oceny dla pojedynczego przebiegu
W tej sekcji opisano sposób przeglądania wyników oceny dla pojedynczego przebiegu. Aby porównać wyniki między przebiegami, zobacz Porównanie wyników oceny między przebiegami.
Omówienie ocen jakości przez sędziów LLM
Oceny sędziów na żądanie są dostępne w databricks-agents wersji 0.3.0 lub nowszej.
Aby wyświetlić przegląd jakości ocenianej przez llM dla każdego żądania w zestawie oceny, kliknij kartę Wyniki oceny na stronie Uruchamianie platformy MLflow. Na tej stronie przedstawiono tabelę podsumowania każdego przebiegu oceny. Aby uzyskać więcej informacji, kliknij identyfikator oceny przebiegu.
W tym omówieniu przedstawiono oceny różnych sędziów dla każdego wniosku, stan jakości/-niepowodzenie każdego żądania na podstawie tych ocen oraz główną przyczynę żądań niepomyślnie. Kliknięcie wiersza w tabeli spowoduje przejście do strony szczegółów dla tego żądania zawierającego następujące elementy:
- Dane wyjściowe modelu: wygenerowana odpowiedź z aplikacji agenta i jej ślad, jeśli zostanie uwzględniona.
- Oczekiwane dane wyjściowe: oczekiwana odpowiedź dla każdego żądania.
- Szczegółowe oceny: oceny sędziów LLM dotyczące tych danych. Kliknij pozycję Zobacz szczegóły , aby wyświetlić uzasadnienia podane przez sędziów.
Zagregowane wyniki w pełnym zestawie oceny
Aby wyświetlić zagregowane wyniki w całym zestawie oceny, kliknij kartę Przegląd (dla wartości liczbowych) lub kartę Metryki modelu (dla wykresów).
Porównanie wyników oceny między przebiegami
Ważne jest, aby porównać wyniki oceny między przebiegami, aby zobaczyć, jak aplikacja agentyczna reaguje na zmiany. Porównanie wyników może pomóc zrozumieć, czy zmiany wpływają pozytywnie na jakość lub ułatwiają rozwiązywanie problemów ze zmieniającym się zachowaniem.
Porównanie wyników poszczególnych żądań między przebiegami
Aby porównać dane dla każdego pojedynczego żądania w różnych uruchomieniach, kliknij kartę Ocena na stronie Eksperyment. W tabeli przedstawiono każde pytanie w zestawie oceny. Użyj menu rozwijanych, aby wybrać kolumny do wyświetlenia.
Porównanie zagregowanych wyników między przebiegami
Dostęp do tych samych zagregowanych wyników można uzyskać na stronie Eksperyment, co umożliwia również porównywanie wyników między różnymi przebiegami. Aby uzyskać dostęp do strony Eksperyment, kliknij ikonę Eksperyment na prawym pasku bocznym notesu lub kliknij linki wyświetlane w wynikach komórki notesu, w której uruchomiono mlflow.evaluate()polecenie .
Na stronie Eksperyment kliknij pozycję 
. Dzięki temu można wizualizować zagregowane wyniki dla wybranego przebiegu i porównać je z wcześniejszymi przebiegami.
Którzy sędziowie są uruchamiani
Domyślnie dla każdego rekordu oceny ocena agenta Mozaika AI stosuje podzbiór sędziów, który najlepiej pasuje do informacji znajdujących się w rekordzie. Szczególnie:
- Jeśli rekord zawiera odpowiedź z podstawy, ocena agenta stosuje
context_sufficiencysędziów ,groundedness,correctnessisafety. - Jeśli rekord nie zawiera odpowiedzi podstawowej prawdy, ocena agenta stosuje
chunk_relevancesędziów ,groundedness,relevance_to_queryisafety.
Można również jawnie określić sędziów do zastosowania do każdego wniosku, używając argumentu evaluator_config w mlflow.evaluate() następujący sposób:
# Complete list of built-in LLM judges
# "chunk_relevance", "context_sufficiency", "correctness", "groundedness", "relevance_to_query", "safety"
evaluation_results = mlflow.evaluate(
data=eval_df,
model_type="databricks-agent",
evaluator_config={
"databricks-agent": {
# Run only LLM judges that don't require ground-truth. Use an empty list to not run any built-in judge.
"metrics": ["groundedness", "relevance_to_query", "chunk_relevance", "safety"]
}
}
)
Uwaga
Nie można wyłączyć metryk sędziego innego niż LLM na potrzeby pobierania fragmentów, liczby tokenów łańcucha lub opóźnienia.
Oprócz wbudowanych sędziów można zdefiniować niestandardowy sędziego LLM, aby ocenić kryteria specyficzne dla twojego przypadku użycia. Zobacz Dostosowywanie sędziów LLM.
Zobacz Informacje o modelach, które umożliwiają sędziom LLM informowanie o zaufaniu i bezpieczeństwie sędziów LLM.
Aby uzyskać więcej informacji na temat wyników i metryk oceny, zobacz Jak jakość, koszt i opóźnienie są oceniane przez ocenę agenta.
Przykład: Jak przekazać aplikację do oceny agenta
Aby przekazać aplikację do mlflow_evaluate()metody , użyj argumentu model . Istnieje 5 opcji przekazywania aplikacji w argumencie model .
- Model zarejestrowany w wykazie aparatu Unity.
- Zarejestrowany model MLflow w bieżącym eksperymencie MLflow.
- Model PyFunc załadowany w notesie.
- Funkcja lokalna w notesie.
- Wdrożony punkt końcowy agenta.
Zapoznaj się z poniższymi sekcjami, aby zapoznać się z przykładami kodu ilustrującymi każdą opcję.
Sposób 1. Model zarejestrowany w wykazie aparatu Unity
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
evaluation_results = mlflow.evaluate(
data=eval_set_df, # pandas DataFrame with just the evaluation set
model = "models:/catalog.schema.model_name/1" # 1 is the version number
model_type="databricks-agent",
)
Sposób 2. Zarejestrowany model MLflow w bieżącym eksperymencie MLflow
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
# In the following lines, `6b69501828264f9s9a64eff825371711` is the run_id, and `chain` is the artifact_path that was
# passed with mlflow.xxx.log_model(...).
# If you called model_info = mlflow.langchain.log_model() or mlflow.pyfunc.log_model(), you can access this value using `model_info.model_uri`.
evaluation_results = mlflow.evaluate(
data=eval_set_df, # pandas DataFrame with just the evaluation set
model = "runs:/6b69501828264f9s9a64eff825371711/chain"
model_type="databricks-agent",
)
Sposób 3. Model PyFunc załadowany w notesie
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
evaluation_results = mlflow.evaluate(
data=eval_set_df, # pandas DataFrame with just the evaluation set
model = mlflow.pyfunc.load_model(...)
model_type="databricks-agent",
)
Opcja 4. Funkcja lokalna w notesie
Funkcja odbiera dane wejściowe sformatowane w następujący sposób:
{
"messages": [
{
"role": "user",
"content": "What is MLflow?",
}
],
...
}
Funkcja musi zwrócić wartość w jednym z następujących trzech obsługiwanych formatów:
Zwykły ciąg zawierający odpowiedź modelu.
Słownik w
ChatCompletionResponseformacie. Na przykład:{ "choices": [ { "message": { "role": "assistant", "content": "MLflow is a machine learning toolkit.", }, ... } ], ..., }Słownik w
StringResponseformacie, takim jak{ "content": "MLflow is a machine learning toolkit.", ... }.
W poniższym przykładzie użyto funkcji lokalnej do opakowania punktu końcowego modelu podstawowego i oceny go:
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
def model(model_input):
client = mlflow.deployments.get_deploy_client("databricks")
return client.predict(endpoint="endpoints:/databricks-meta-llama-3-1-405b-instruct", inputs={"messages": model_input["messages"]})
evaluation_results = mlflow.evaluate(
data=eval_set_df, # pandas DataFrame with just the evaluation set
model = model
model_type="databricks-agent",
)
Opcja 5. Wdrożony punkt końcowy agenta
Ta opcja działa tylko wtedy, gdy używasz punktów końcowych agenta, które zostały wdrożone przy użyciu zestawu databricks.agents.deploy SDK lub nowszej databricks-agents wersji 0.8.0 zestawu SDK. W przypadku modeli podstawowych lub starszych wersji zestawu SDK użyj opcji 4, aby opakowować model w funkcji lokalnej.
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
# In the following lines, `endpoint-name-of-your-agent` is the name of the agent endpoint.
evaluation_results = mlflow.evaluate(
data=eval_set_df, # pandas DataFrame with just the evaluation set
model = "endpoints:/endpoint-name-of-your-agent"
model_type="databricks-agent",
)
Jak przekazać zestaw oceny, gdy aplikacja jest uwzględniona w wywołaniu mlflow_evaluate()
W poniższym kodzie data element jest ramką danych biblioteki pandas z zestawem oceny. Są to proste przykłady. Aby uzyskać szczegółowe informacje, zobacz schemat wejściowy.
# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.
# Minimal evaluation set
bare_minimum_eval_set_schema = [
{
"request": "What is the difference between reduceByKey and groupByKey in Spark?",
}]
# Complete evaluation set
complete_eval_set_schema = [
{
"request_id": "your-request-id",
"request": "What is the difference between reduceByKey and groupByKey in Spark?",
"expected_retrieved_context": [
{
# In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
"content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
"doc_uri": "doc_uri_2_1",
},
{
"content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
"doc_uri": "doc_uri_2_2",
},
],
"expected_response": "There's no significant difference.",
}]
# Convert dictionary to a pandas DataFrame
eval_set_df = pd.DataFrame(bare_minimum_eval_set_schema)
# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_df = spark_df.toPandas()
Przykład: Jak przekazać wcześniej wygenerowane dane wyjściowe do oceny agenta
W tej sekcji opisano sposób przekazywania wcześniej wygenerowanych danych wyjściowych w wywołaniu mlflow_evaluate() . Aby uzyskać wymagany schemat zestawu oceny, zobacz Schemat danych wejściowych oceny agenta.
W poniższym kodzie data element jest ramką danych biblioteki pandas z zestawem oceny i danymi wyjściowymi wygenerowanymi przez aplikację. Są to proste przykłady. Aby uzyskać szczegółowe informacje, zobacz schemat wejściowy.
%pip install databricks-agents pandas
dbutils.library.restartPython()
import mlflow
import pandas as pd
evaluation_results = mlflow.evaluate(
data=eval_set_with_app_outputs_df, # pandas DataFrame with the evaluation set and application outputs
model_type="databricks-agent",
)
# You do not have to start from a dictionary - you can use any existing pandas or Spark DataFrame with this schema.
# Minimum required input
bare_minimum_input_schema = [
{
"request": "What is the difference between reduceByKey and groupByKey in Spark?",
"response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
}]
# Input including optional arguments
complete_input_schema = [
{
"request_id": "your-request-id",
"request": "What is the difference between reduceByKey and groupByKey in Spark?",
"expected_retrieved_context": [
{
# In `expected_retrieved_context`, `content` is optional, and does not provide any additional functionality.
"content": "Answer segment 1 related to What is the difference between reduceByKey and groupByKey in Spark?",
"doc_uri": "doc_uri_2_1",
},
{
"content": "Answer segment 2 related to What is the difference between reduceByKey and groupByKey in Spark?",
"doc_uri": "doc_uri_2_2",
},
],
"expected_response": "There's no significant difference.",
"response": "reduceByKey aggregates data before shuffling, whereas groupByKey shuffles all data, making reduceByKey more efficient.",
"retrieved_context": [
{
# In `retrieved_context`, `content` is optional. If provided, the Databricks Context Relevance LLM Judge is executed to check the `content`'s relevance to the `request`.
"content": "reduceByKey reduces the amount of data shuffled by merging values before shuffling.",
"doc_uri": "doc_uri_2_1",
},
{
"content": "groupByKey may lead to inefficient data shuffling due to sending all values across the network.",
"doc_uri": "doc_uri_6_extra",
},
],
}]
# Convert dictionary to a pandas DataFrame
eval_set_with_app_outputs_df = pd.DataFrame(bare_minimum_input_schema)
# Use a Spark DataFrame
import numpy as np
spark_df = spark.table("catalog.schema.table") # or any other way to get a Spark DataFrame
eval_set_with_app_outputs_df = spark_df.toPandas()
Przykład: używanie funkcji niestandardowej do przetwarzania odpowiedzi z języka LangGraph
Agenci LangGraph, zwłaszcza ci, którzy mają funkcje czatu, mogą zwracać wiele wiadomości dla jednego wywołania wnioskowania. Użytkownik ponosi odpowiedzialność za przekonwertowanie odpowiedzi agenta na format, który obsługuje ocena agenta.
Jedną z metod jest użycie funkcji niestandardowej do przetwarzania odpowiedzi. W poniższym przykładzie pokazano funkcję niestandardową, która wyodrębnia ostatni komunikat czatu z modelu LangGraph. Ta funkcja jest następnie używana do mlflow.evaluate() zwracania pojedynczej odpowiedzi ciągu, która może być porównywana z kolumną ground_truth .
Przykładowy kod przyjmuje następujące założenia:
- Model akceptuje dane wejściowe w formacie {"messages": [{"role": "user", "content": "hello"}]}.
- Model zwraca listę ciągów w formacie ["odpowiedź 1", "odpowiedź 2".
Poniższy kod wysyła concatenated odpowiedzi do sędziego w tym formacie: "response 1nresponse2"
import mlflow
import pandas as pd
from typing import List
loaded_model = mlflow.langchain.load_model(model_uri)
eval_data = pd.DataFrame(
{
"inputs": [
"What is MLflow?",
"What is Spark?",
],
"expected_response": [
"MLflow is an open-source platform for managing the end-to-end machine learning (ML) lifecycle. It was developed by Databricks, a company that specializes in big data and machine learning solutions. MLflow is designed to address the challenges that data scientists and machine learning engineers face when developing, training, and deploying machine learning models.",
"Apache Spark is an open-source, distributed computing system designed for big data processing and analytics. It was developed in response to limitations of the Hadoop MapReduce computing model, offering improvements in speed and ease of use. Spark provides libraries for various tasks such as data ingestion, processing, and analysis through its components like Spark SQL for structured data, Spark Streaming for real-time data processing, and MLlib for machine learning tasks",
],
}
)
def custom_langgraph_wrapper(model_input):
predictions = loaded_model.invoke({"messages": model_input["messages"]})
# Assuming `predictions` is a list of strings
return predictions.join("\n")
with mlflow.start_run() as run:
results = mlflow.evaluate(
custom_langgraph_wrapper, # Pass the function defined above
data=eval_data,
model_type="databricks-agent",
)
print(results.metrics)
Tworzenie pulpitu nawigacyjnego z metrykami
Gdy iterujesz jakość agenta, możesz udostępnić pulpit nawigacyjny uczestnikom projektu, który pokazuje, jak jakość poprawiła się wraz z upływem czasu. Możesz wyodrębnić metryki z przebiegów oceny platformy MLflow, zapisać wartości w tabeli delty i utworzyć pulpit nawigacyjny.
W poniższym przykładzie pokazano, jak wyodrębnić i zapisać wartości metryk z ostatniego przebiegu oceny w notesie:
uc_catalog_name = "catalog"
uc_schema_name = "schema"
table_name = "results"
eval_results = mlflow.evaluate(
model=logged_agent_info.model_uri, # use the logged Agent
data=evaluation_set, # Run the logged Agent for all queries defined above
model_type="databricks-agent", # use Agent Evaluation
)
# The `append_metrics_to_table function` is defined below
append_metrics_to_table("<identifier-for-table>", eval_results.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")
W poniższym przykładzie pokazano, jak wyodrębnić i zapisać wartości metryk dla poprzednich przebiegów zapisanych w eksperymencie MLflow.
import pandas as pd
def get_mlflow_run(experiment_name, run_name):
runs = mlflow.search_runs(experiment_names=[experiment_name], filter_string=f"run_name = '{run_name}'", output_format="list")
if len(runs) != 1:
raise ValueError(f"Found {len(runs)} runs with name {run_name}. {run_name} must identify a single run. Alternatively, you can adjust this code to search for a run based on `run_id`")
return runs[0]
run = get_mlflow_run(experiment_name ="/Users/<user_name>/db_docs_mlflow_experiment", run_name="evaluation__2024-10-09_02:27:17_AM")
# The `append_metrics_to_table` function is defined below
append_metrics_to_table("<identifier-for-table>", run.data.metrics, f"{uc_catalog_name}.{uc_schema_name}.{table_name}")
Teraz możesz utworzyć pulpit nawigacyjny przy użyciu tych danych.
Poniższy kod definiuje funkcję append_metrics_to_table używaną w poprzednich przykładach.
# Definition of `append_metrics_to_table`
def append_metrics_to_table(run_name, mlflow_metrics, delta_table_name):
data = mlflow_metrics.copy()
# Add identifying run_name and timestamp
data["run_name"] = run_name
data["timestamp"] = pd.Timestamp.now()
# Remove metrics with error counts
data = {k: v for k, v in mlflow_metrics.items() if "error_count" not in k}
# Convert to a Spark DataFrame(
metrics_df = pd.DataFrame([data])
metrics_df_spark = spark.createDataFrame(metrics_df)
# Append to the Delta table
metrics_df_spark.write.mode("append").saveAsTable(delta_table_name)
Ograniczenie
W przypadku konwersacji obejmujących wiele kolei dane wyjściowe oceny rejestrują tylko ostatni wpis w konwersacji.
Informacje o modelach, które napędzają sędziów LLM
- Sędziowie LLM mogą korzystać z usług innych firm do oceny aplikacji GenAI, w tym azure OpenAI obsługiwanych przez firmę Microsoft.
- W przypadku usługi Azure OpenAI usługa Databricks zrezygnowała z monitorowania nadużyć, więc w usłudze Azure OpenAI nie są przechowywane żadne monity ani odpowiedzi.
- W przypadku obszarów roboczych Unii Europejskiej (UE) sędziowie LLM używają modeli hostowanych w UE. Wszystkie inne regiony używają modeli hostowanych w Stanach Zjednoczonych.
- Wyłączenie funkcji pomocniczych sztucznej inteligencji opartej na sztucznej inteligencji platformy Azure uniemożliwia sędziego LLM wywoływanie modeli opartych na sztucznej inteligencji platformy Azure.
- Dane wysyłane do sędziego LLM nie są używane do trenowania modelu.
- Sędziowie LLM mają pomóc klientom ocenić swoje aplikacje RAG, a wyniki sędziów LLM nie powinny być używane do trenowania, ulepszania ani dostrajania LLM.