AI Engineering Academy: 2.6 RAG Beobachtbarkeit - Arize Phoenix Setup

🚀 Einladung zum Erleben: Chinas erste KI-IDE Intelligente Programmiersoftware Trae Chinesische Version downloadDer DeepSeek-R1 und Doubao-pro sind unbegrenzt verfügbar!

Willkommen zu diesem Notizbuch, in dem wir erforschen werden, wie man Llama Index benutzt, um die Generierung von Retrieval-Erweiterungen einzurichten und zu beobachten (RAG) Rationalisieren.

https://github.com/adithya-s-k/AI-Engineering.academy/tree/main/RAG/01_RAG_Observability

kurz

Dieses Handbuch bietet eine vollständige Anleitung zur Konfiguration der erforderlichen Tools und Bibliotheken, einschließlich eingebetteter Modelle und Vektorspeicherindizes, für eine effiziente Dokumentensuche und Abfrageverarbeitung. Wir behandeln alles von der Installation und Einrichtung bis hin zur Abfrage und zum Abruf relevanter Informationen, um Ihnen zu helfen, die erweiterten Suchfunktionen der RAG-Pipeline in den Griff zu bekommen.

Einführung (ein Thema)

Für den Einstieg in dieses Notizbuch benötigen Sie ein grundlegendes Verständnis von Python und eine gewisse Vertrautheit mit Konzepten des maschinellen Lernens. Wenn Sie mit diesen Konzepten nicht vertraut sind, machen Sie sich keine Sorgen - wir werden Sie Schritt für Schritt durch sie führen!

Vorbedingungen

Python 3.7+
Jupyter Notebook oder JupyterLab
Grundlagen von Python und Machine Learning-Konzepten

1. einstellung

1.1 Installation der erforderlichen Softwarepakete

Um mit der Einrichtung von Arize Phoenix zu beginnen, müssen Sie die erforderlichen Softwarepakete installieren.

Arize Phoenix ist ein umfassendes Tool für die Beobachtbarkeit und Überwachung von maschinellem Lernen und KI-Systemen. Es bietet die Möglichkeit, alle Aspekte von Machine-Learning-Modellen und Datenpipelines zu verfolgen und zu analysieren.

!pip install arize-phoenix
!pip install openinference-instrumentation-openai

Diese Befehle werden installiert:

arize-phoenixTools für die Beobachtbarkeit von Arbeitsabläufen beim maschinellen Lernen.
openinference-instrumentation-openaiPakete für die Integration von OpenAI-Modellen mit Beobachtungstools wie Arize Phoenix.

1.2 Einrichten der Arize Phoenix

Es gibt drei Möglichkeiten, die Einstellungen wie folgt vorzunehmen:

Mehr lesen Hier.

Befehlszeile (Informatik)
```
python3 -m phoenix.server.main serve
```
Docker startet das Docker-Image von phoenix mit dem folgenden Befehl:
```
docker run -p 6006:6006 -p 4317:4317 arizephoenix/phoenix:latest
```
Dadurch werden die Phoenix-Benutzeroberfläche und die REST-API auf localhost:6006 und der gRPC-Endpunkt für Spans auf localhost:4317 bereitgestellt.
Notizbücher
```
import phoenix as px
px.launch_app()
```

1.3 Importieren Sie die erforderlichen Bibliotheken und konfigurieren Sie die Umgebung

Importieren Sie die erforderlichen Bibliotheken und richten Sie die Umgebung ein, bevor Sie mit der Datenverarbeitung und -auswertung fortfahren:

import json
import os
from getpass import getpass
import nest_asyncio
import pandas as pd
from tqdm import tqdm
import phoenix as px
# 允许在笔记本环境中进行并发评估
nest_asyncio.apply()
# 设置 pandas DataFrame 的显示选项以展示更多内容
pd.set_option("display.max_colwidth", 1000)

json, osPython: Standard-Python-Bibliothek für die Verarbeitung von JSON-Daten und die Interaktion mit dem Betriebssystem.
getpassEin Tool zur sicheren Eingabe von Passwörtern.
nest_asyncioErmöglicht die Verwendung von asyncio in Jupyter-Notebooks.
pandas (pd): Eine leistungsstarke Python-Bibliothek zur Datenmanipulation.
tqdmFortschrittsanzeige für die Schleife, um den Fortschritt der Datenverarbeitung zu verfolgen.
phoenix (px): Teil des Arize Observability Tools, das eine interaktive Benutzeroberfläche für die Untersuchung von Daten und die Überwachung von Machine-Learning-Modellen bietet.

konfigurieren. nest_asyncio um gleichzeitige Auswertungen in einer Notebook-Umgebung zu ermöglichen und um die maximale Spaltenbreite des Pandas DataFrame zu setzen, um die Lesbarkeit zu verbessern.

1.4 Starten der Phoenix-Anwendung

px.launch_app()

Diese Funktion initialisiert und startet die Phoenix-Anwendung, die in einer neuen Registerkarte des Standardbrowsers geöffnet wird und eine interaktive Schnittstelle zur Untersuchung von Datensätzen, zur Visualisierung der Modellleistung und zur Fehlersuche bietet.

1.5 Anzeigen von Phoenix-Anwendungssitzungen

Sobald die Phoenix-Anwendung gestartet ist, können Sie mithilfe von Sitzungsobjekten direkt im Notebook mit der Anwendung interagieren. Führen Sie den folgenden Code aus, um die Phoenix-Anwendung zu starten und sie in der aktuellen Sitzung anzuzeigen:

# 启动并查看 Phoenix 应用会话
(session := px.launch_app()).view()

Diese Codezeile startet die Phoenix-Anwendung und weist die Sitzung einer Variablen namens Sitzung zu, indem sie die view() Die Methode zeigt Phoenix-Anwendungen direkt auf der Notebook-Oberfläche an und bietet so ein integriertes Erlebnis, ohne zwischen Browser und Notebook wechseln zu müssen.

1.6 Einstellung des Endpunkts der Aufzeichnung

Um Trace-Daten an eine Phoenix-Anwendung zur Analyse und Beobachtung zu senden, definieren Sie die Endpunkt-URL, an der die Phoenix-Anwendung auf eingehende Daten wartet.

endpoint = "http://127.0.0.1:6006/v1/traces"

endpoint Variable zur Speicherung der Endpunkt-URL, die von der Phoenix-Anwendung verwendet wird, um auf eingehende Trace-Daten zu warten.

2. die Verfolgung von OpenAI

Mehr Integration. Lesen.

2.1 OpenAI-Pakete installieren und importieren

!pip install openai
import openai

openaiPython-Client-Bibliothek für die OpenAI-API. Sie ermöglicht es Ihnen, Anfragen an die OpenAI-Modelle (einschließlich GPT-3 und GPT-4) für eine Vielzahl von Aufgaben zu senden.

2.2 Konfigurieren des OpenAI-API-Schlüssels

import openai
import os
from getpass import getpass
# 从环境变量中获取 API 密钥，若未设置则提示用户输入
if not (openai_api_key := os.getenv("OPENAI_API_KEY")):
openai_api_key = getpass("🔑 输入您的 OpenAI API 密钥：")
# 为 OpenAI 客户端设置 API 密钥
openai.api_key = openai_api_key
# 将 API 密钥存储到环境变量中以供后续使用
os.environ["OPENAI_API_KEY"] = openai_api_key

Abrufen des API-Schlüssels: Der Code versucht zunächst, den API-Schlüssel aus der Umgebungsvariablen (OPENAI_API_KEY) abzurufen. Wenn der Schlüssel nicht gefunden wird, wird der Benutzer zur sicheren Eingabe über getpass aufgefordert.
API-Schlüssel setzen: Der abgefragte oder gelieferte API-Schlüssel wird dann als Schlüssel für die OpenAI-Client-Bibliothek gesetzt.
Speichern Sie den API-Schlüssel: Speichern Sie den API-Schlüssel schließlich in einer Umgebungsvariablen, um sicherzustellen, dass er während der Sitzung immer verfügbar ist.

2.3 Einrichten von OpenTelemetry für das Tracking

Um das Tracing für Ihre OpenAI-Interaktionen zu aktivieren, konfigurieren Sie OpenTelemetry und richten Sie die erforderlichen Komponenten ein.

from opentelemetry import trace as trace_api
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
# 设置 Tracer 提供程序
tracer_provider = trace_sdk.TracerProvider()
# 定义带有端点的 OTLP Span 导出器
span_exporter = OTLPSpanExporter(endpoint)
# 设置 Span Processor 以处理和导出 spans
span_processor = SimpleSpanProcessor(span_exporter)
# 将 Span Processor 添加到 Tracer 提供程序
tracer_provider.add_span_processor(span_processor)
# 设置全局 Tracer 提供程序
trace_api.set_tracer_provider(tracer_provider)

OpenTelemetry-Bibliothek

In dem mitgelieferten Code werden mehrere OpenTelemetry-Bibliotheken verwendet, um die Verfolgung einzurichten. Im Folgenden finden Sie eine Übersicht über die einzelnen Bibliotheken:

opentelemetry:entspricht Englisch -ity, -ism, -izationOpenTelemetry: Die Kernbibliothek von OpenTelemetry, die APIs für Tracking und Metriken bereitstellt.VerwendungTrace-Modul: Enthält das Trace-Modul zur Erstellung und Verwaltung von Traces.
opentelemetry.exporter.otlp.proto.http.trace_exporter:entspricht Englisch -ity, -ism, -izationBietet einen Trace-Exporter mit OTLP (OpenTelemetry Protocol) über HTTP.Verwendung: Das Modul OTLPSpanExporter Klasse wird verwendet, um Tracking-Daten an ein OTLP-kompatibles Backend zu senden, und wird durch die Einrichtung von Endpunkten konfiguriert.
opentelemetry.sdk.trace:entspricht Englisch -ity, -ism, -izationSDK: Enthält SDK-Implementierungen für die Nachverfolgung, einschließlich TracerProvider.Verwendung::
- TracerProviderTracer: Verwaltet Tracer-Instanzen und ist verantwortlich für den Export von Spans (Arbeitseinheiten), die in Traces gesammelt werden.
- SimpleSpanProcessorEin Prozessor, der Exportspannen synchronisiert, um Daten zu verarbeiten und an den Exporteur zu senden.
opentelemetry.sdk.trace.export:entspricht Englisch -ity, -ism, -izationKlassen für den Export von Tracking-Daten.Verwendung::
- SimpleSpanProcessorSpans: Die Verarbeitung von Spans und deren Export mit dem angegebenen Exporter stellt sicher, dass die Daten zur Analyse an das Backend gesendet werden.

2.4 Instrumentierung von OpenAI mit OpenInference

Um OpenTelemetry in OpenAI zu integrieren und Tracking für OpenAI-Modellinteraktionen zu ermöglichen, verwenden Sie das Tracking aus dem openinference Bibliotheken OpenAIInstrumentor.

from openinference.instrumentation.openai import OpenAIInstrumentor
# 实例化并为 OpenAI 应用 instrumentation
OpenAIInstrumentor().instrument()

OpenAIInstrumentor: Von openinference Bibliotheksklassen für die Instrumentierung von OpenAIs API-Aufrufen, um Tracking und Beobachtbarkeit zu ermöglichen.
instrument()Diese Methode konfiguriert den OpenAI-API-Client, um automatisch Trace-Daten zu erzeugen und an das OpenTelemetry-Backend zu senden. Sie integriert die konfigurierten Trace-Einstellungen und ermöglicht es Ihnen, den Prozess der Interaktion mit OpenAI-Modellen zu überwachen und zu analysieren.

Durch die Ausführung dieses Codes können Sie sicherstellen, dass alle OpenAI-API-Aufrufe nachverfolgt werden, um detaillierte Einblicke in die Modellnutzung und -leistung zu erhalten.

2.5 Eine Anfrage an die OpenAI-API stellen

Um mit OpenAIs API zu interagieren und eine Antwort zu erhalten, verwenden Sie den folgenden Code. Dieses Beispiel zeigt, wie man eine Anfrage zur Chatvervollständigung erstellt und die Ergebnisse über die OpenAI-API ausgibt:

import openai
# 创建 OpenAI 客户端实例
client = openai.OpenAI()
# 向 OpenAI API 发起聊天补全请求
response = client.chat.completions.create(
model="gpt-4o",
messages=[{"role": "user", "content": "Write a haiku."}],
)
# 打印响应内容
print(response.choices[0].message.content)

openai.OpenAI()Initialisieren einer OpenAI-Client-Instanz, die für die Interaktion mit der OpenAI-API verwendet werden kann.
client.chat.completions.create()Senden Sie eine Anfrage an die OpenAI-API, um ein Chat-Komplement zu erstellen.
- model="gpt-4o"Geben Sie den Namen des Modells an, das für die Erstellung des Komplements verwendet wird. Vergewissern Sie sich, dass der Modellname korrekt ist und dass Sie ihn in Ihrem OpenAI-API-Konto aktiviert haben.
- messages:: Eine Liste von Nachrichten, die den Dialogverlauf enthält. Dieses Beispiel enthält eine einzige vom Benutzer gesendete Nachrichtenanfrage: "Schreibe ein Haiku".
response.choices[0].message.contentExtrahiert und druckt modellgenerierte Ergänzungen.

3. den Llama-Index verfolgen

3.1 Installieren und Importieren der erforderlichen Bibliotheken

!pip install llama-index
!pip install llama-index-core
!pip install llama-index-llms-openai
!pip install openinference-instrumentation-llama-index==2.2.4
!pip install -U llama-index-callbacks-arize-phoenix
!pip install "arize-phoenix[llama-index]"

llama-index:: Kernpaket für Llama-Index-Funktionalität.
llama-index-coreLlama Index: Bietet die Kernfunktionen und Werkzeuge von Llama Index.
llama-index-llms-openaiLlama Index: Ein Paket zur Integration von Llama Index mit OpenAI-Modellen.
openinference-instrumentation-llama-index==2.2.4Llama Index: Stellt Werkzeuge für die Instrumentierung von Llama-Index-Interaktionen bereit.
llama-index-callbacks-arize-phoenixBietet Integration mit Arize Phoenix Rückrufe.
arize-phoenix[llama-index]Erweiterung von Arize Phoenix zur Unterstützung von Llama Index Tracking.

3.2 Abrufen der URL der aktiven Phoenix-Sitzung

# 获取当前活动的 Phoenix 会话的 URL
px.active_session().url

Greifen Sie auf die derzeit aktive Phoenix-Sitzung zu und rufen Sie deren URL ab, um die Phoenix-Schnittstelle zur Überwachung und Analyse von Tracking-Daten anzuzeigen oder freizugeben.

3.3 Einrichten der Llama-Index-Verfolgung

Um OpenTelemetry-Tracking für Llama Index einzurichten, konfigurieren Sie den Tracer-Anbieter und integrieren Sie Llama Index Instrumentor.

from openinference.instrumentation.llama_index import LlamaIndexInstrumentor
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor
# 设置 Tracer 提供程序
tracer_provider = trace_sdk.TracerProvider()
# 添加 Span Processor 到 Tracer 提供程序
tracer_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter(endpoint)))
# 使用 Tracer 提供程序 对 Llama Index 进行 Instrumentation
LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)

LlamaIndexInstrumentor: Von openinference.instrumentation.llama_index Klasse für die Verfolgung und Beobachtung von Instrumenten des Llama-Index.
trace_sdk.TracerProvider()Initialisieren eines neuen Tracer-Providers zur Erstellung und Verwaltung von Trace-Daten.
SimpleSpanProcessorSynchronisierung des Exports von Spans und Übermittlung der Daten an das Backend.
LlamaIndexInstrumentor().instrument(tracer_provider=tracer_provider)Llama Index: Wenden Sie die Instrumentierung auf den Llama-Index an und verwenden Sie den mitgelieferten Tracer-Anbieter für das Tracing.

3.4 Verwendung von OpenAI zur Interaktion mit Llama Index

Um eine Abschlussanfrage über Llama Index unter Verwendung eines OpenAI-Modells durchzuführen, verwenden Sie den folgenden Code:

from llama_index.llms.openai import OpenAI
# 初始化 OpenAI 模型
llm = OpenAI(model="gpt-4o-mini")
# 发起完成请求
resp = llm.complete("Paul Graham is ")
# 打印响应结果
print(resp)

from llama_index.llms.openai import OpenAI: Von llama_index Paket, um OpenAI-Klassen zu importieren und die Interaktion mit OpenAI-Modellen zu ermöglichen.
OpenAI(model="gpt-4o-mini")Initialisieren der OpenAI-Klasseninstanz mit dem angegebenen Modell (z.B. gpt-4).
llm.complete(...)Sendet Aufforderungstext an das Modell, um Antwortinhalte zu erzeugen.

3.5 Chat-Interaktion mit Llama Index unter Verwendung von OpenAI

from llama_index.llms.openai import OpenAI
from llama_index.core.llms import ChatMessage
# 初始化 OpenAI 模型
llm = OpenAI()
# 定义聊天消息
messages = [
ChatMessage(
role="system", content="You are a pirate with a colorful personality"
),
ChatMessage(role="user", content="What is your name"),
]
# 获取模型的响应结果
resp = llm.chat(messages)

OpenAIKlassen, die zur Interaktion mit OpenAI-Modellen verwendet werden.
ChatMessageKlasse zur Formatierung von Chat-Nachrichten.
OpenAI()Initialisieren einer Instanz der OpenAI-Klasse.
ChatMessageErzeugt ein Chat-Nachrichten-Objekt mit Angabe der Rolle (z. B. "System", "Benutzer") und des Inhalts der Nachricht.
- role="system"Systemnachrichten: Definieren Sie Systemnachrichten, um den Kontext oder die Persönlichkeit des Modells festzulegen.
- role="user"Repräsentiert eine vom Benutzer gesendete Nachricht.
llm.chat(messages)Sendet die definierte Nachricht an das Modell und empfängt das Ergebnis der Antwort.

Dieser Code interagiert mit dem OpenAI-Modell durch System- und Benutzernachrichteneinstellungen für den Chat.

4. die Beobachtung des RAG-Prozesses

4.1 Einrichten der Umgebung für die Beobachtung des RAG-Prozesses

!pip install llama-index
!pip install llama-index-vector-stores-qdrant
!pip install llama-index-readers-file
!pip install llama-index-embeddings-fastembed
!pip install llama-index-llms-openai
!pip install -U qdrant_client fastembed

llama-indexLlama Index: Kernpaket für Llama Index Funktionalität.
llama-index-vector-stores-qdrantQdrant: Integration von Qdrant als Vektorspeicher für Llama Index.
llama-index-readers-fileLlama Index: Ermöglicht das Lesen von Dateien für Llama Index.
llama-index-embeddings-fastembedFastEmbed: Unterstützung für Llama Index zur Erzeugung von Vektoreinbettungen.
llama-index-llms-openaiLlama Index: Integration von OpenAI-Modellen in Llama Index.
qdrant_clientQdrant: Client-seitige Bibliothek für die Interaktion mit Qdrant, einer Vektorsuchmaschine.
fastembedLibrary for fast generation of embedding vectors: Bibliothek zur schnellen Erzeugung von Einbettungsvektoren.

4.2 Vorbereitung eines RAG-Prozesses mit Einbettung und Dokumentenindizierung

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.embeddings.fastembed import FastEmbedEmbedding
# from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core.settings import Settings
Settings.embed_model = FastEmbedEmbedding(model_name="BAAI/bge-base-en-v1.5")
# Settings.embed_model = OpenAIEmbedding(embed_batch_size=10)
documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

VectorStoreIndexVektorspeicher: Klassen zur Erstellung und Verwaltung von Vektorspeicherindizes. Der Index führt eine effiziente Ähnlichkeitssuche und -abfrage auf der Grundlage von Dokumentvektoren durch.
SimpleDirectoryReaderKlasse, die Dokumente aus einem bestimmten Verzeichnis liest und die geladenen Dateien für die Indizierung vorverarbeitet.
FastEmbedEmbeddingEinbettungsmodell: Klasse zur Erzeugung von Texteinbettungsvektoren unter Verwendung der FastEmbed-Bibliothek. Geben Sie den Modellnamen als "BAAI/bge-base-en-v1.5".
from llama_index.embeddings.openai import OpenAIEmbedding::
- OpenAIEmbeddingEinbettungsmodell: Die Einbettungsmodellklasse, die zur Erzeugung von Vektoren über den OpenAI-Einbettungsdienst verwendet wird. Sie ist standardmäßig auskommentiert. Wenn Sie ein OpenAI-Modell anstelle von FastEmbed verwenden möchten, können Sie es auskommentieren und die Parameter konfigurieren, z. B. embed_batch_size.
SettingsKlasse zur Einstellung der globalen Einbettungsmodellkonfiguration. Die Konfiguration des globalen Einbettungsmodells kann durch die Angabe der embed_model Attributzuweisung, die das zu verwendende Einbettungsmodell angibt.
Settings.embed_model = FastEmbedEmbedding(model_name="BAAI/bge-base-en-v1.5")Einrichten der globalen Nutzung FastEmbedEmbedding als ein Einbettungsvektormodell.
documents = SimpleDirectoryReader("data").load_data(): Aus dem Katalog "data" Laden und Vorverarbeiten von Dokumentendaten. Stellen Sie sicher, dass die Verzeichnisnamen an den tatsächlichen Pfad des Projekts angepasst sind.
index = VectorStoreIndex.from_documents(documents)Erstellen eines Vektor-Speicher-Index auf der Grundlage vorverarbeiteter Dokumente. Dieser Schritt implementiert eine vektorisierte Darstellung des Dokuments und ermöglicht vektorbasierte Abfragen.

4.3 Abfrage-Vektor-Speicherindex

Sobald der Index des Vektorspeichers eingerichtet ist, können Sie ihn verwenden, um Abfragen durchzuführen und relevante Informationen abzurufen.

query_engine = index.as_query_engine()
response = query_engine.query("What did the author do growing up?")
print(response)

as_query_engine():: Wille VectorStoreIndex Konvertieren in eine Abfrage-Engine. Mit dieser Engine können Sie auf der Grundlage einer Vektordarstellung der in einem Index gespeicherten Dokumente Suchen durchführen und Informationen abrufen.
query()Ausführen einer Abfrage in einem Vektorspeicherindex. Die Abfragezeichenfolge "Was hat der Autor gemacht, als er aufwuchs?" wird verwendet, um nach relevanten Dokumenten zu suchen und Informationen auf der Grundlage des durch die Vektoreinbettung bereitgestellten Kontexts abzurufen.

Endlich.response Enthält Informationen, die aus Vektorspeicherindizes abgerufen werden, die auf der Grundlage von Abfragen und Indexdokumenten erstellt werden.

zu einem Urteil gelangen

In dieser Anleitung haben wir einen Retrieval Augmented Generation (RAG)-Prozess mit Llama Index eingerichtet und ihn mit verschiedenen Komponenten integriert, um seine Funktionalität zu beobachten. Zunächst haben wir die erforderlichen Bibliotheken konfiguriert und installiert, darunter Llama Index, OpenTelemetry und verschiedene Einbettungsmodelle.

Als Nächstes haben wir Folgendes getan:

Initialisieren und konfigurieren Sie das Einbettungsmodell, ggf. unter Verwendung von FastEmbed- oder OpenAI-Modellen.
Lädt und indiziert Dokumente aus dem Katalog, um Daten für die Abfrage vorzubereiten.
Richten Sie die Abfragemaschine ein, um Suchen durchzuführen und relevante Informationen auf der Grundlage indizierter Dokumente abzurufen.

Wenn Sie diese Schritte befolgt haben, haben Sie erfolgreich einen RAG-Prozess vorbereitet, der ein effizientes Abrufen von Dokumenten und die Verarbeitung von Anfragen ermöglicht. Die Einrichtung bietet fortgeschrittene Such- und Informationsabfragefunktionen unter Verwendung vektorbasierter Einbettung und Indizierung.

Sie können gerne mit verschiedenen Konfigurationen und Abfragen experimentieren, um die Möglichkeiten des RAG-Prozesses weiter zu erforschen. Wenn Sie Fragen haben oder weitere Anpassungen vornehmen möchten, konsultieren Sie bitte die Dokumentation der von Ihnen verwendeten Bibliothek, um weitere Hinweise zu erhalten.