Codierung eines AutoAI -RAG-Experiments mit einem Milvus -Vektorspeicher

Schritt 1: Vorbereiten der Voraussetzungen für die Datenaufbereitung und den Aufbau des Experiments

Bereiten Sie die Voraussetzungen für das Experiment vor.

• Installieren und importieren Sie die erforderlichen Module und Abhängigkeiten. Beispiel:

pip install 'ibm-watsonx-ai[rag]>=1.1.11'
pip install langchain-community==0.2.4

• Wenn Sie watsonx.data verwenden, um einen Milvus -Vektorspeicher zu erstellen, überprüfen Sie, ob Sie über eine watsonx.data -Instanz verfügen.

• Geben Sie die Anmeldedaten für die Aufgabe ein. Siehe Hinzufügen von Anmeldeinformationen für Aufgaben.

• watsonx.ai Laufzeitdienst. Siehe Dienste erstellen.

• Geben Sie den API-Schlüssel ein. Siehe Verwalten des Benutzer-API-Schlüssels.

• Verwenden Sie diesen Code, um den Client zu initialisieren. Beispiel:

from ibm_watsonx_ai import APIClient, Credentials

credentials = Credentials(
                   url = "https://us-south.ml.cloud.mydomain.com",
                   api_key = "***********"
                  )

client = APIClient(credentials)

• Schaffen Sie ein Projekt oder einen Raum für Ihre Arbeit. Siehe Erstellen eines Projekts oder Erstellen eines Bereichs.

• Abrufen der ID für das Projekt oder den Bereich. Siehe Finden der Projekt-ID.

• Legen Sie ein Standardprojekt oder einen Standardbereich fest:

client.set.default_project("<Project ID>")

client.set.default_space("<Space GUID>")

• Vorbereiten der Erdungsunterlagen
• Bereiten Sie die Bewertungsdaten vor

from ibm_watsonx_ai.helpers import DataConnection, S3Location

conn_meta_props= {
    client.connections.ConfigurationMetaNames.NAME: f"Connection to input data - {datasource_name} ",
    client.connections.ConfigurationMetaNames.DATASOURCE_TYPE: client.connections.get_datasource_type_id_by_name(datasource_name),
    client.connections.ConfigurationMetaNames.DESCRIPTION: "ibm-watsonx-ai SDK documentation",
    client.connections.ConfigurationMetaNames.PROPERTIES: {
        'bucket': <BUCKET_NAME>,
        'access_key': <ACCESS_KEY>,
        'secret_key': <SECRET_ACCESS_KEY>,
        'iam_url': 'https://iam.cloud.ibm.com/identity/token',
        'url': <ENDPOINT_URL>
    }
}

conn_details = client.connections.create(meta_props=conn_meta_props)
cos_connection_id = client.connections.get_id(conn_details)

input_data_references = [DataConnection(
    connection_asset_id=cos_connection_id,
    location=S3Location(
        bucket=<BACKET_NAME>,
        path=<BACKET_PATH>
    )
)]

import os, wget
from ibm_watsonx_ai.helpers import DataConnection

input_data_filename = "core_api.html"
input_data_path = f"https://ibm.github.io/watsonx-ai-python-sdk/{input_data_filename}"

if not os.path.isfile(input_data_filename): 
    wget.download(input_data_path, out=input_data_filename)
    
asset_details = client.data_assets.create(input_data_filename, input_data_filename)
asset_id = client.data_assets.get_id(asset_details)

input_data_references = [DataConnection(data_asset_id=asset_id)]

[
    {
        "question": "What is the purpose of get_token()?",
        "correct_answer": "get_token() is used to retrieve an authentication token for secure API access.",
        "correct_answer_document_ids": [
            "core_api.html"
        ]
    },
    {
        "question": "How does the delete_model() function operate?",
        "correct_answer": "delete_model() method allows users to delete models they've created or managed.",
        "correct_answer_document_ids": [
            "core_api.html"
        ]
    }
]

import os, wget
from ibm_watsonx_ai.helpers import DataConnection

test_data_filename = "benchmarking_data_core_api.json"
test_data_path = f"https://github.com/IBM/watsonx-ai-samples/tree/master/cloud/data/autoai_rag{test_data_filename}"

if not os.path.isfile(test_data_filename): 
    wget.download(test_data_path, out=test_data_filename)

test_asset_details = client.data_assets.create(name=test_data_filename, file_path=test_data_filename)
test_asset_id = client.data_assets.get_id(test_asset_details)

test_data_references = [DataConnection(data_asset_id=test_asset_id)]

from ibm_watsonx_ai.helpers import DataConnection

milvus_data_source_type_id = client.connections.get_datasource_type_uid_by_name("milvus")
details = client.connections.create(
    {
        client.connections.ConfigurationMetaNames.NAME: "Milvus Connection",
        client.connections.ConfigurationMetaNames.DATASOURCE_TYPE: milvus_data_source_type_id,
        client.connections.ConfigurationMetaNames.PROPERTIES: {
            "host": <PASTE MILVUS HOST HERE>,
            "port": <PASTE MILVUS PORT HERE>,
            "username": <PASTE MILVUS USERNAME HERE>,
            "password": <PASTE MILVUS PASSWORD HERE>,
            "ssl": True,
        },
    }
)

milvus_connection_id = client.connections.get_id(details)
vector_store_references = [DataConnection(connection_asset_id=milvus_connection_id)]

Schritt 2: Konfigurieren Sie den RAG-Optimierer

Das rag_optimizer Objekt bietet eine Reihe von Methoden für die Arbeit mit dem AutoAI RAG Experiment. In diesem Schritt geben Sie die Details ein, um das Experiment zu definieren. Die verfügbaren Konfigurationsoptionen sind wie folgt:

Der folgende Beispielcode zeigt die Konfigurationsoptionen für die Ausführung des Experiments mit der ibm-watsonx-ai SDK Dokumentation:

from ibm_watsonx_ai.experiment import AutoAI

experiment = AutoAI(credentials, project_id=project_id)

rag_optimizer = experiment.rag_optimizer(
    name='DEMO - AutoAI RAG ibm-watsonx-ai SDK documentation',
    description="AutoAI RAG experiment grounded with the ibm-watsonx-ai SDK documentation",
    max_number_of_rag_patterns=5,
    optimization_metrics=[AutoAI.RAGMetrics.ANSWER_CORRECTNESS]
)

rag_optimizer = experiment.rag_optimizer(
    name='DEMO - AutoAI RAG ibm-watsonx-ai SDK documentation',
    description="AutoAI RAG experiment grounded with the ibm-watsonx-ai SDK documentation",
    embedding_models=["ibm/slate-125m-english-rtrvr"],
    foundation_models=["ibm/granite-13b-chat-v2","mistralai/mixtral-8x7b-instruct-v01"],
    max_number_of_rag_patterns=5,
    optimization_metrics=[AutoAI.RAGMetrics.ANSWER_CORRECTNESS]
)

Schritt 3: Durchführung des Experiments

Führen Sie den Optimierer aus, um die RAG-Muster unter Verwendung der angegebenen Konfigurationsoptionen zu erstellen. In diesem Codebeispiel wird die Aufgabe im interaktiven Modus ausgeführt. Sie können die Aufgabe im Hintergrund laufen lassen, indem Sie das background_mode auf True setzen.

run_details = rag_optimizer.run(
    input_data_references=input_data_references,
    test_data_references=test_data_references,
    vector_store_references=vector_store_references,
    background_mode=False
)

Schritt 4: Prüfen Sie die Muster und wählen Sie das beste aus

Nachdem das AutoAI RAG-Experiment erfolgreich abgeschlossen wurde, können Sie die Muster überprüfen. Verwenden Sie die Methode " summary, um abgeschlossene Muster und Informationen zu den Bewertungsmetriken in Form eines Pandas DataFrame aufzulisten, so dass Sie die Muster in einer Rangfolge nach Leistung gegenüber der optimierten Metrik überprüfen können.

summary = rag_optimizer.summary()
summary

Die Ergebnisse werden beispielsweise wie folgt angezeigt:

best_pattern = rag_optimizer.get_pattern()

payload = {
    client.deployments.ScoringMetaNames.INPUT_DATA: [
        {
            "values": ["How to use new approach of providing credentials to APIClient?"],
        }
    ]
}

resp = best_pattern.query(payload)
print(resp["predictions"][0]["values"][0][0])

According to the document, the new approach to provide credentials to APIClient is by using the Credentials class. Here's an example:


from ibm_watsonx_ai import APIClient
from ibm_watsonx_ai import Credentials

credentials = Credentials(
                   url = "https://us-south.ml.cloud.ibm.com",
                   token = "***********",
                  )

client = APIClient(credentials)


This replaces the old approach of passing a dictionary with credentials to the APIClient constructor.

Schritt 5: Einsatz eines Musters

Nachdem Sie ein Muster lokal getestet haben, können Sie das Muster bereitstellen, um den Endpunkt zu erhalten und ihn in Anwendungen einzubinden. Die Bereitstellung erfolgt durch Speichern der definierten RAG-Funktion und anschließendes Erstellen eines bereitgestellten Assets. Weitere Informationen zum Einsatz finden Sie unter Einsatz und Verwaltung von KI-Assets und Online-Einsätze.

So erstellen Sie die Bereitstellung:

deployment_details = best_pattern.deploy(
    name="AutoAI RAG deployment - ibm_watsonx_ai documentataion",
    space_id=space_id
)

Abrufen der Bereitstellungs-ID für das bereitgestellte Asset.

deployment_id = client.deployments.get_id(deployment_details)
deployment_scoring_href = client.deployments.get_scoring_href(deployment_details)
print(deployment_scoring_href)

Der RAG-Dienst ist jetzt in einem Raum eingerichtet und kann getestet werden.

questions = ["How to use new approach of providing credentials to APIClient?"]

payload = {
    client.deployments.ScoringMetaNames.INPUT_DATA: [
        {
            "values": questions,
            "access_token": client.service_instance._get_token()
        }
    ]
}

resp = client.deployments.score(deployment_id, payload)
print(resp["predictions"][0]["values"][0][0])

According to the document, the new approach to provide credentials to APIClient is by using the Credentials class. Here's an example:


from ibm_watsonx_ai import APIClient
from ibm_watsonx_ai import Credentials

credentials = Credentials(
                   url = "https://us-south.ml.cloud.ibm.com",
                   token = "***********",
                  )

client = APIClient(credentials)


This replaces the old approach of passing a dictionary with credentials to the APIClient constructor.

Überprüfung der Versuchsergebnisse in Cloud Object Storage.

Wenn der endgültige Status des Experiments "fehlgeschlagen" oder "Fehler" lautet, verwenden Sie rag_optimizer.get_logs() oder lesen Sie die Ergebnisse des Experiments, um zu verstehen, was falsch gelaufen ist. Experimentergebnisse und Protokolle werden in der Standardinstanz Cloud Object Storage gespeichert, die mit Ihrem Konto verknüpft ist. Standardmäßig werden die Ergebnisse nach Experiment-Trainings-ID im Verzeichnis default_autoai_rag_out gespeichert.

Die Ergebnisse sind nach Mustern geordnet. Beispiel:

|-- Pattern1
|      | -- evaluation_results.json
|      | -- indexing_notebook.ipynb (Milvus)
|      | -- inference_notebook.ipynb (Milvus)
|-- Pattern2
|    ...
|-- training_status.json

Jedes Muster enthält diese Ergebnisse:

• Die Datei evaluation_results.json enthält die Bewertungsergebnisse für jede Benchmark-Frage.
• Der indexing_notebook.ipynb enthält den Python-Code für die Erstellung eines Vektor-Datenbankindex. Es werden Befehle zum Abrufen von Daten, zum Chunking und zur Erstellung von Einbettungen vorgestellt.
• Das inference_notebook.ipynb-Notebook konzentriert sich darauf, für Benutzeranfragen relevante Passagen aus einer Wissensbasis abzurufen und Antworten zu generieren, indem die abgerufenen Passagen in ein großes Sprachmodell eingespeist werden.

Sie können die Notizbücher überprüfen oder ausführen, indem Sie die Authentifizierungsdaten hinzufügen.

rag_optimizer.get_inference_notebook(pattern_name='Pattern3')

Schritt 6: Aufräumen (optional)

Wenn Sie Ihre Sammlung aus der Milvus Vektordatenbank entfernen möchten, verwenden Sie das Python-SDK für Milvus.

Um den Namen der Sammlung zu finden, gehen Sie zu Musterdetails und sehen Sie den Indexnamen des Vektorspeichers.

Beispiel:

from pymilvus import MilvusClient

password = "<YOUR APIKEY>"
user = "ibmlhapikey"
uri = f"https://<HOST>:<PORT_NUMBER>"

collection_name = "autoai_rag_5c74df6a_20250319124623"   

client = MilvusClient(uri=uri, password=password, user=milvus_credentials["username"])

client.drop_collection(collection_name=collection_name)

Nächste Schritte

• Führen Sie das Schlussfolgerungsnotizbuch mit neuen Fragen aus, um das ausgewählte RAG-Muster zu verwenden.
• Verwenden Sie die indizierten Dokumente aus diesem Experiment in der Prompt Lab, um Aufforderungen für ein Gründungsmodell zu begründen. Siehe Verwendung eines AutoAI Rag-Index zum Chatten mit Dokumenten.

Übergeordnetes Thema: Automatisierung eines RAG-Musters mit dem AutoAI SDK