1. Einführung
In diesem Codelab erstellen Sie eine Anwendung, die mithilfe der Vektorsuche Yoga-Posen empfiehlt.
Im Codelab gehen Sie so vor:
- Verwenden Sie einen vorhandenen Hugging Face-Datensatz mit Yoga-Posen (JSON-Format).
- Ergänzen Sie den Datensatz um eine zusätzliche Feldbeschreibung, mit der mit Gemini Beschreibungen für jede der Posen generiert werden.
- Verwenden Sie LangChain, um ein Dokument zu erstellen, und die Firestore LangChain-Integration, um die Sammlung und die Einbettungen in Firestore zu erstellen.
- Erstellen Sie einen zusammengesetzten Index in Firestore, um die Vektorsuche zu ermöglichen.
- Verwenden Sie die Vektorsuche in einer Flask-Anwendung, die alles wie unten gezeigt zusammenführt:
Aufgabe
- Eine Webanwendung entwerfen, erstellen und bereitstellen, die Yoga-Posen anhand der Vektorsuche empfiehlt.
Aufgaben in diesem Lab
- Mit Gemini Textinhalte generieren und im Rahmen dieses Codelabs Beschreibungen für Yoga-Posen generieren
- Mit dem LangChain Document Loader für Firestore Datensätze aus einem erweiterten Hugging Face-Dataset zusammen mit Vektor-Embeddings in Firestore laden
- Mit dem LangChain-Vektorspeicher für Firestore nach Daten anhand einer Abfrage in natürlicher Sprache suchen
- Audioinhalte mit der Google Cloud Text-to-Speech API generieren
Voraussetzungen
- Chrome-Webbrowser
- Ein Gmail-Konto
- Ein Cloud-Projekt mit aktivierter Abrechnung
Dieses Codelab richtet sich an Entwickler aller Stufen (einschließlich Anfänger) und verwendet in der Beispielanwendung Python. Python-Kenntnisse sind jedoch nicht erforderlich, um die vorgestellten Konzepte zu verstehen.
2. Hinweis
Projekt erstellen
- Wählen Sie in der Google Cloud Console auf der Seite der Projektauswahl ein Google Cloud-Projekt aus oder erstellen Sie eines.
- Die Abrechnung für das Cloud-Projekt muss aktiviert sein. So prüfen Sie, ob die Abrechnung für ein Projekt aktiviert ist.
- Sie verwenden Cloud Shell, eine Befehlszeilenumgebung, die in Google Cloud ausgeführt wird und bq bereits vorinstalliert hat. Klicken Sie oben in der Google Cloud Console auf „Cloud Shell aktivieren“.
- Nachdem Sie eine Verbindung zu Cloud Shell hergestellt haben, prüfen Sie mit dem folgenden Befehl, ob Sie bereits authentifiziert sind und das Projekt auf Ihre Projekt-ID festgelegt ist:
gcloud auth list
- Führen Sie in Cloud Shell den folgenden Befehl aus, um zu prüfen, ob der gcloud-Befehl Ihr Projekt kennt.
gcloud config list project
- Wenn Ihr Projekt nicht festgelegt ist, verwenden Sie den folgenden Befehl, um es festzulegen:
gcloud config set project <YOUR_PROJECT_ID>
- Aktivieren Sie die erforderlichen APIs mit dem folgenden Befehl. Dies kann einige Minuten dauern.
gcloud services enable firestore.googleapis.com \
compute.googleapis.com \
cloudresourcemanager.googleapis.com \
servicenetworking.googleapis.com \
run.googleapis.com \
cloudbuild.googleapis.com \
cloudfunctions.googleapis.com \
aiplatform.googleapis.com \
texttospeech.googleapis.com
Wenn der Befehl erfolgreich ausgeführt wurde, sollte eine Meldung ähnlich der folgenden angezeigt werden:
Operation "operations/..." finished successfully.
Alternativ können Sie in der Console nach den einzelnen Produkten suchen oder diesen Link verwenden.
Wenn eine API fehlt, können Sie sie jederzeit während der Implementierung aktivieren.
Weitere Informationen zu gcloud-Befehlen und deren Verwendung finden Sie in der Dokumentation.
Repository klonen und Umgebungseinstellungen einrichten
Im nächsten Schritt klonen wir das Beispiel-Repository, auf das wir im Rest des Codelabs verweisen werden. Angenommen, Sie befinden sich in Cloud Shell, geben Sie in Ihrem Basisverzeichnis den folgenden Befehl ein:
git clone https://github.com/rominirani/yoga-poses-recommender-python
Klicken Sie zum Starten des Editors in der Symbolleiste des Cloud Shell-Fensters auf „Editor öffnen“. Klicken Sie links oben auf die Menüleiste und wählen Sie „Datei“ > „Ordner öffnen“ aus (siehe Abbildung unten).
Wählen Sie den Ordner yoga-poses-recommender-python
aus. Der Ordner sollte sich mit den folgenden Dateien öffnen:
Jetzt müssen wir die Umgebungsvariablen einrichten, die wir verwenden werden. Klicken Sie auf die Datei config.template.yaml
. Der Inhalt sollte wie unten dargestellt aussehen:
project_id: your-project-id
location: us-central1
gemini_model_name: gemini-1.5-flash-002
embedding_model_name: text-embedding-004
image_generation_model_name: imagen-3.0-fast-generate-002
database: (default)
collection: poses
test_collection: test-poses
top_k: "3"
Bitte aktualisieren Sie die Werte für project_id
und location
gemäß den Angaben, die Sie beim Erstellen des Google Cloud-Projekts und der Firestore-Datenbankregion ausgewählt haben. Idealerweise sollten die Werte von location
für das Google Cloud-Projekt und die Firestore-Datenbank gleich sein, z.B. us-central1
.
Für dieses Codelab verwenden wir die vorkonfigurierten Werte, mit Ausnahme von project_id
und location
, die Sie gemäß Ihrer Konfiguration festlegen müssen.
Speichern Sie diese Datei als config.yaml
im selben Ordner wie die Datei config.template.yaml
.
Im letzten Schritt erstellen wir eine Python-Umgebung, die wir lokal mit allen für uns eingerichteten Python-Abhängigkeiten verwenden. Sehen Sie sich die Datei pyproject.toml
an, die die Details dazu enthält. Der Inhalt ist unten dargestellt:
dependencies = [
"datasets>=3.2.0",
"flask>=3.1.0",
"google-cloud-aiplatform>=1.78.0",
"google-cloud-texttospeech>=2.24.0",
"langchain-community>=0.3.15",
"langchain-core>=0.3.31",
"langchain-google-community>=2.0.4",
"langchain-google-firestore>=0.5.0",
"langchain-google-vertexai>=2.0.7",
"pydantic-settings>=2.7.1",
"pyyaml>=6.0.2",
"tenacity>=9.0.0",
]
Diese Abhängigkeiten sind in requirements.txt
bereits versionsgemäß gesperrt..
Zusammenfassend müssen wir eine virtuelle Python-Umgebung mit den Python-Paketabhängigkeiten in requirements.txt
erstellen, die in der virtuellen Umgebung installiert werden sollen. Klicken Sie dazu in der Cloud Shell IDE auf Command Palette
(Strg + Umschalttaste + P) und geben Sie Python: Create Environment
ein. Führen Sie die nächsten Schritte aus, um eine Virtual Environment(venv)
, eine Python 3.x interpreter
und die Datei requirements.txt
auszuwählen.
Nachdem die Umgebung erstellt wurde, müssen wir sie mit dem folgenden Befehl aktivieren:
source .venv/bin/activate
In der Konsole sollte (.venv) angezeigt werden. Beispiel: -> (.venv) yourusername@cloudshell:
Sehr gut! Jetzt können wir mit der Einrichtung der Firestore-Datenbank fortfahren.
3. Firestore einrichten
Cloud Firestore ist eine vollständig verwaltete serverlose Dokumentendatenbank, die wir als Backend für unsere Anwendungsdaten verwenden. Daten in Cloud Firestore sind in Sammlungen von Dokumenten strukturiert.
Firestore-Datenbank initialisieren
Rufen Sie in der Cloud Console die Seite „Firestore“ auf.
Wenn Sie noch keine Firestore-Datenbank im Projekt initialisiert haben, erstellen Sie die Datenbank default
, indem Sie auf Create Database
klicken. Verwenden Sie beim Erstellen der Datenbank die folgenden Werte:
- Firestore-Modus:
Native.
- Standort: Verwenden Sie die Standardeinstellungen für die Standortermittlung.
- Verwenden Sie für die Sicherheitsregeln
Test rules
. - Erstellen Sie die Datenbank.
Im nächsten Abschnitt legen wir die Grundlage für die Erstellung einer Sammlung mit dem Namen poses
in unserer Standard-Firestore-Datenbank. Diese Sammlung enthält Beispieldaten (Dokumente) oder Informationen zu Yoga-Posen, die wir dann in unserer Anwendung verwenden.
Damit ist der Abschnitt zur Einrichtung der Firestore-Datenbank abgeschlossen.
4. Yoga-Pose-Dataset vorbereiten
Als Erstes müssen wir das Dataset mit Yoga-Posen vorbereiten, das wir für die Anwendung verwenden werden. Wir beginnen mit einem vorhandenen Hugging Face-Datensatz und ergänzen ihn dann um zusätzliche Informationen.
Sehen Sie sich den Hugging Face-Dataset für Yoga-Posen an. In diesem Codelab wird zwar einer der Datasets verwendet, Sie können aber auch ein beliebiges anderes Dataset verwenden und dieselben Techniken anwenden, um es zu optimieren.
Im Bereich Files and versions
können wir die JSON-Datendatei für alle Posen abrufen.
Wir haben die Datei yoga_poses.json
heruntergeladen und Ihnen zur Verfügung gestellt. Diese Datei heißt yoga_poses_alldata.json
und befindet sich im Ordner /data
.
Rufen Sie im Cloud Shell-Editor die Datei data/yoga_poses.json
auf und sehen Sie sich die Liste der JSON-Objekte an. Jedes JSON-Objekt steht für eine Yoga-Pose. Es gibt insgesamt drei Einträge. Unten sehen Sie ein Beispiel:
{
"name": "Big Toe Pose",
"sanskrit_name": "Padangusthasana",
"photo_url": "https://pocketyoga.com/assets/images/full/ForwardBendBigToe.png",
"expertise_level": "Beginner",
"pose_type": ["Standing", "Forward Bend"]
}
Das ist eine gute Gelegenheit, Gemini vorzustellen und zu zeigen, wie wir mit dem Standardmodell ein description
-Feld generieren können.
Rufen Sie im Cloud Shell-Editor die Datei generate-descriptions.py
auf. Der Inhalt dieser Datei ist unten zu sehen:
import json
import time
import logging
import vertexai
from langchain_google_vertexai import VertexAI
from tenacity import retry, stop_after_attempt, wait_exponential
from settings import get_settings
settings = get_settings()
logging.basicConfig(
level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
)
# Initialize Vertex AI SDK
vertexai.init(project=settings.project_id, location=settings.location)
logging.info("Done Initializing Vertex AI SDK")
@retry(
stop=stop_after_attempt(5),
wait=wait_exponential(multiplier=1, min=4, max=10),
)
def generate_description(pose_name, sanskrit_name, expertise_level, pose_types):
"""Generates a description for a yoga pose using the Gemini API."""
prompt = f"""
Generate a concise description (max 50 words) for the yoga pose: {pose_name}
Also known as: {sanskrit_name}
Expertise Level: {expertise_level}
Pose Type: {", ".join(pose_types)}
Include key benefits and any important alignment cues.
"""
try:
model = VertexAI(model_name=settings.gemini_model_name, verbose=True)
response = model.invoke(prompt)
return response
except Exception as e:
logging.info(f"Error generating description for {pose_name}: {e}")
return ""
def add_descriptions_to_json(input_file, output_file):
"""Loads JSON data, adds descriptions, and saves the updated data."""
with open(input_file, "r") as f:
yoga_poses = json.load(f)
total_poses = len(yoga_poses)
processed_count = 0
for pose in yoga_poses:
if pose["name"] != " Pose":
start_time = time.time() # Record start time
pose["description"] = generate_description(
pose["name"],
pose["sanskrit_name"],
pose["expertise_level"],
pose["pose_type"],
)
end_time = time.time() # Record end time
processed_count += 1
end_time = time.time() # Record end time
time_taken = end_time - start_time
logging.info(
f"Processed: {processed_count}/{total_poses} - {pose['name']} ({time_taken:.2f} seconds)"
)
else:
pose["description"] = ""
processed_count += 1
logging.info(
f"Processed: {processed_count}/{total_poses} - {pose['name']} ({time_taken:.2f} seconds)"
)
# Adding a delay to avoid rate limit
time.sleep(30)
with open(output_file, "w") as f:
json.dump(yoga_poses, f, indent=2)
def main():
# File paths
input_file = "./data/yoga_poses.json"
output_file = "./data/yoga_poses_with_descriptions.json"
# Add descriptions and save the updated JSON
add_descriptions_to_json(input_file, output_file)
if __name__ == "__main__":
main()
Mit dieser Anwendung wird jedem JSON-Eintrag für Yoga-Posen ein neues Feld description
hinzugefügt. Die Beschreibung wird über einen Aufruf des Gemini-Modells abgerufen, in dem wir den erforderlichen Prompt bereitstellen. Das Feld wird der JSON-Datei hinzugefügt und die neue Datei wird in die Datei data/yoga_poses_with_descriptions.json
geschrieben.
Sehen wir uns die wichtigsten Schritte an:
- In der Funktion
main()
wird die Funktionadd_descriptions_to_json
aufgerufen und die erwartete Eingabe- und Ausgabedatei angegeben. - Die Funktion
add_descriptions_to_json
führt für jeden JSON-Datensatz, also für die Informationen zum Yoga-Beitrag, Folgendes aus: - Es werden
pose_name
,sanskrit_name
,expertise_level
undpose_types
extrahiert. - Dabei wird die Funktion „generate_description“ aufgerufen, die einen Prompt erstellt, und dann die Modellklasse Langchain VertexAI, um den Antworttext abzurufen.
- Dieser Antworttext wird dann dem JSON-Objekt hinzugefügt.
- Die aktualisierte JSON-Liste der Objekte wird dann in die Zieldatei geschrieben.
Führen wir diese Anwendung aus. Öffnen Sie ein neues Terminalfenster (Strg + Umschalt + C) und geben Sie den folgenden Befehl ein:
python generate-descriptions.py
Wenn Sie um eine Autorisierung gebeten werden, stellen Sie diese bitte zur Verfügung.
Die Anwendung wird ausgeführt. Wir haben eine Verzögerung von 30 Sekunden zwischen den Einträgen hinzugefügt, um Ratenlimitquoten zu vermeiden, die bei neuen Google Cloud-Konten auftreten können. Bitte haben Sie etwas Geduld.
Unten sehen Sie ein Beispiel für einen laufenden Test:
Sobald alle drei Einträge mit dem Gemini-Aufruf erweitert wurden, wird die Datei data/yoga_poses_with_description.json
generiert. Sie können sich das ansehen.
Wir haben jetzt unsere Datendatei. Im nächsten Schritt erfahren Sie, wie Sie damit eine Firestore-Datenbank füllen und Einbettungen generieren.
5. Daten in Firestore importieren und Vektoreinbettungen generieren
Wir haben die Datei data/yoga_poses_with_description.json
und müssen sie jetzt in die Firestore-Datenbank einfügen und vor allem die Vektor-Embeddings für jeden der Einträge generieren. Die Vektor-Embeddings sind später nützlich, wenn wir eine Ähnlichkeitssuche mit der Nutzerabfrage in natürlicher Sprache durchführen müssen.
Wir verwenden die Langchain Firestore-Komponenten, um den oben beschriebenen Prozess zu implementieren.
Gehen Sie dazu so vor:
- Wir konvertieren die Liste der JSON-Objekte in eine Liste von Langchain-Dokument-Objekten. Jedes Dokument hat zwei Attribute:
page_content
undmetadata
. Das Metadatenobjekt enthält das gesamte JSON-Objekt mit Attributen wiename
,description
undsanskrit_name
.page_content
ist ein Stringtext, der aus mehreren Feldern zusammengesetzt ist. - Sobald wir eine Liste von
Document
-Objekten haben, verwenden wir dieFirestoreVectorStore
-Langchain-Klasse und insbesondere diefrom_documents
-Methode mit dieser Liste von Dokumenten, einem Sammlungsnamen (wir verwenden die VariableTEST_COLLECTION
, die auftest-poses
verweist), einer Vertex AI-Embedding-Klasse und den Firestore-Verbindungsdetails (PROJECT_ID
undDATABASE
-Name). Dadurch wird die Sammlung erstellt und für jedes Attribut wird einembedding
-Feld generiert.
Der Code für import-data.py
ist unten zu sehen (Teile des Codes wurden aus Gründen der Übersichtlichkeit gekürzt):
...
def create_langchain_documents(poses):
"""Creates a list of Langchain Documents from a list of poses."""
documents = []
for pose in poses:
# Convert the pose to a string representation for page_content
page_content = (
f"name: {pose.get('name', '')}\n"
f"description: {pose.get('description', '')}\n"
f"sanskrit_name: {pose.get('sanskrit_name', '')}\n"
f"expertise_level: {pose.get('expertise_level', 'N/A')}\n"
f"pose_type: {pose.get('pose_type', 'N/A')}\n"
).strip()
# The metadata will be the whole pose
metadata = pose
document = Document(page_content=page_content, metadata=metadata)
documents.append(document)
logging.info(f"Created {len(documents)} Langchain documents.")
return documents
def main():
all_poses = load_yoga_poses_data_from_local_file(
"./data/yoga_poses_with_descriptions.json"
)
documents = create_langchain_documents(all_poses)
logging.info(
f"Successfully created langchain documents. Total documents: {len(documents)}"
)
embedding = VertexAIEmbeddings(
model_name=settings.embedding_model_name,
project=settings.project_id,
location=settings.location,
)
client = firestore.Client(project=settings.project_id, database=settings.database)
vector_store = FirestoreVectorStore.from_documents(
client=client,
collection=settings.test_collection,
documents=documents,
embedding=embedding,
)
logging.info("Added documents to the vector store.")
if __name__ == "__main__":
main()
Führen wir diese Anwendung aus. Öffnen Sie ein neues Terminalfenster (Strg + Umschalt + C) und geben Sie den folgenden Befehl ein:
python import-data.py
Wenn alles wie geplant ausgeführt wird, sollte eine Meldung wie die folgende angezeigt werden:
2025-01-21 14:50:06,479 - INFO - Added documents to the vector store.
Ob die Einträge erfolgreich eingefügt und die Einbettungen generiert wurden, können Sie in der Cloud Console auf der Firestore-Seite prüfen.
Klicken Sie auf die (Standard-)Datenbank. Daraufhin sollten die Sammlung test-poses
und mehrere Dokumente in dieser Sammlung angezeigt werden. Jedes Dokument ist eine Yoga-Pose.
Klicken Sie auf eines der Dokumente, um die Felder zu untersuchen. Zusätzlich zu den importierten Feldern finden Sie das Feld embedding
. Es handelt sich dabei um ein Vektorfeld, das automatisch für Sie über die von uns verwendete LangChain-Klasse VertexAIEmbeddings
generiert wurde, in der wir das Vertex AI-Embedding-Modell text-embedding-004
angegeben haben.
Nachdem wir die Einträge mit den Einbettungen in die Firestore-Datenbank hochgeladen haben, können wir mit dem nächsten Schritt fortfahren und uns ansehen, wie eine Vektorähnlichkeitssuche in Firestore funktioniert.
6. Vollständige Yoga-Posen in die Firestore-Datenbanksammlung importieren
Wir erstellen jetzt die Sammlung poses
, eine vollständige Liste von 160 Yoga-Posen. Dazu haben wir eine Datenbankimportdatei generiert, die Sie direkt importieren können. So sparen Sie Zeit im Lab. Das Erstellen der Datenbank mit Beschreibung und Einbettungen erfolgt wie im vorherigen Abschnitt beschrieben.
So importieren Sie die Datenbank:
- Erstellen Sie mit dem Befehl
gsutil
unten einen Bucket in Ihrem Projekt. Ersetzen Sie die Variable<PROJECT_ID>
im folgenden Befehl durch Ihre Google Cloud-Projekt-ID.
gsutil mb -l us-central1 gs://<PROJECT_ID>-my-bucket
- Nachdem der Bucket erstellt wurde, müssen wir den vorbereiteten Datenbankexport in diesen Bucket kopieren, bevor wir ihn in die Firebase-Datenbank importieren können. Verwenden Sie den folgenden Befehl:
gsutil cp -r gs://yoga-database-firestore-export-bucket/2025-01-27T05:11:02_62615 gs://<PROJECT_ID>-my-bucket
Nachdem wir die Daten zum Importieren haben, können wir mit dem letzten Schritt fortfahren, bei dem die Daten in die von uns erstellte Firebase-Datenbank (default
) importiert werden.
- Verwenden Sie den folgenden gcloud-Befehl:
gcloud firestore import gs://<PROJECT_ID>-my-bucket/2025-01-27T05:11:02_62615
Der Import dauert einige Sekunden. Sobald er abgeschlossen ist, können Sie Ihre Firestore-Datenbank und die Sammlung validieren. Rufen Sie dazu https://console.cloud.google.com/firestore/databases auf und wählen Sie die Datenbank default
und die Sammlung poses
aus (siehe Abbildung unten):
Damit ist die Erstellung der Firestore-Sammlung abgeschlossen, die wir in unserer Anwendung verwenden werden.
7. Vektorähnlichkeitssuche in Firestore ausführen
Für die Suche nach Vektorähnlichkeiten nehmen wir die Suchanfrage des Nutzers auf. Ein Beispiel für diese Abfrage ist "Suggest me some exercises to relieve back pain"
.
Sehen Sie sich die Datei search-data.py
an. Die wichtigste Funktion ist die Suchfunktion, die unten dargestellt ist. Im Wesentlichen wird eine Einbettungsklasse erstellt, die zum Generieren der Einbettung für die Nutzerabfrage verwendet wird. Anschließend wird die Klasse FirestoreVectorStore
verwendet, um die Funktion similarity_search
aufzurufen.
def search(query: str):
"""Executes Firestore Vector Similarity Search"""
embedding = VertexAIEmbeddings(
model_name=settings.embedding_model_name,
project=settings.project_id,
location=settings.location,
)
client = firestore.Client(project=settings.project_id, database=settings.database)
vector_store = FirestoreVectorStore(
client=client, collection=settings.collection, embedding_service=embedding
)
logging.info(f"Now executing query: {query}")
results: list[Document] = vector_store.similarity_search(
query=query, k=int(settings.top_k), include_metadata=True
)
for result in results:
print(result.page_content)
Bevor Sie dies mit einigen Abfragebeispielen ausführen, müssen Sie zuerst einen Firestore-zusammengesetzten Index generieren, der für erfolgreiche Suchanfragen erforderlich ist. Wenn Sie die Anwendung ausführen, ohne den Index zu erstellen, wird ein Fehler angezeigt, der darauf hinweist, dass Sie den Index zuerst erstellen müssen.
Unten sehen Sie den Befehl gcloud
zum Erstellen des zusammengesetzten Index:
gcloud firestore indexes composite create --project=<YOUR_PROJECT_ID> --collection-group=poses --query-scope=COLLECTION --field-config=vector-config='{"dimension":"768","flat": "{}"}',field-path=embedding
Die Indexierung dauert einige Minuten, da sich mehr als 150 Einträge in der Datenbank befinden. Sobald der Vorgang abgeschlossen ist, können Sie den Index mit dem folgenden Befehl aufrufen:
gcloud firestore indexes composite list
Der gerade erstellte Index sollte in der Liste angezeigt werden.
Probieren Sie jetzt den folgenden Befehl aus:
python search-data.py --prompt "Recommend me some exercises for back pain relief"
Sie sollten einige Empfehlungen erhalten. Unten sehen Sie ein Beispiel für einen Testlauf:
2025-01-21 15:48:51,282 - INFO - Now executing query: Recommend me some exercises for back pain relief
name: Supine Spinal Twist Pose
description: A gentle supine twist (Supta Matsyendrasana), great for beginners. Releases spinal tension, improves digestion, and calms the nervous system. Keep shoulders flat on the floor and lengthen the spine.
sanskrit_name: Supta Matsyendrasana
expertise_level: Beginner
pose_type: ['Supine', 'Twist']
name: Cow Pose
description: Cow Pose (Bitilasana) is a gentle backbend, stretching the chest, shoulders, and abdomen. Maintain a neutral spine, lengthen the tailbone, and avoid hyperextension. Benefits include improved posture and stress relief.
sanskrit_name: Bitilasana
expertise_level: Beginner
pose_type: ['Arm Leg Support', 'Back Bend']
name: Locust I Pose
description: Locust Pose I (Shalabhasana A) strengthens the back, glutes, and shoulders. Lie prone, lift chest and legs simultaneously, engaging back muscles. Keep hips grounded and gaze slightly forward.
sanskrit_name: Shalabhasana A
expertise_level: Intermediate
pose_type: ['Prone', 'Back Bend']
Sobald das funktioniert, wissen Sie, wie Sie mit der Firestore-Vektordatenbank Datensätze hochladen, Einbettungen generieren und eine Vektorähnlichkeitssuche durchführen. Wir können jetzt eine Webanwendung erstellen, in der die Vektorsuche in ein Web-Frontend eingebunden wird.
8. Die Webanwendung
Die Python Flask-Webanwendung ist in der Datei main.py
verfügbar und die Front-End-HTML-Datei befindet sich in templates/index.html.
.
Wir empfehlen, sich beide Dateien anzusehen. Beginnen Sie mit der Datei main.py
, die den Handler /search
enthält, der den Prompt übernimmt, der von der Front-End-HTML-Datei index.html
übergeben wurde. Dadurch wird die Suchmethode aufgerufen, die die im vorherigen Abschnitt beschriebene Suche nach Vektorähnlichkeit durchführt.
Die Antwort wird dann mit der Liste der Empfehlungen an die index.html
zurückgesendet. Über das Symbol index.html
werden die Empfehlungen dann als verschiedene Karten angezeigt.
Anwendung lokal ausführen
Öffnen Sie ein neues Terminalfenster (Strg + Umschalt + C) oder ein vorhandenes Terminalfenster und geben Sie den folgenden Befehl ein:
python main.py
Eine Beispielausführung ist unten dargestellt:
* Serving Flask app 'main'
* Debug mode: on
2025-01-21 16:02:37,473 - INFO - WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on all addresses (0.0.0.0)
* Running on http://127.0.0.1:8080
* Running on http://10.88.0.4:8080
2025-01-21 16:02:37,473 - INFO - Press CTRL+C to quit
2025-01-21 16:02:37,474 - INFO - * Restarting with stat
2025-01-21 16:02:41,462 - WARNING - * Debugger is active!
2025-01-21 16:02:41,484 - INFO - * Debugger PIN: 440-653-555
Wenn die Anwendung einsatzbereit ist, rufen Sie die Start-URL der Anwendung auf, indem Sie auf die Schaltfläche „Webvorschau“ unten klicken:
Es sollte die index.html
-Datei angezeigt werden, die wie unten dargestellt bereitgestellt wird:
Geben Sie eine Beispielabfrage ein (z. B. Provide me some exercises for back pain relief
) und klicken Sie auf die Schaltfläche Search
. Dadurch sollten einige Empfehlungen aus der Datenbank abgerufen werden. Außerdem wird die Schaltfläche Play Audio
angezeigt. Wenn Sie darauf klicken, wird anhand der Beschreibung ein Audiostream generiert, den Sie direkt anhören können.
9. Optional: In Google Cloud Run bereitstellen
Im letzten Schritt stellen wir diese Anwendung in Google Cloud Run bereit. Der Befehl zum Bereitstellen wird unten angezeigt. Ersetzen Sie vor dem Bereitstellen die Werte für die Variable (<<YOUR_PROJECT_ID>>) durch die für Ihr Projekt spezifischen Werte. Diese Werte können Sie aus der Datei config.yaml
abrufen.
gcloud run deploy yogaposes --source . \
--port=8080 \
--allow-unauthenticated \
--region=us-central1 \
--platform=managed \
--project=<<YOUR_PROJECT_ID>> \
--env-vars-file=config.yaml
Führen Sie den Befehl oben im Stammverzeichnis der Anwendung aus. Möglicherweise werden Sie auch aufgefordert, Google Cloud APIs zu aktivieren und Ihre Einwilligung für verschiedene Berechtigungen zu erteilen. Bitte tun Sie dies.
Die Bereitstellung dauert etwa 5 bis 7 Minuten. Bitte haben Sie etwas Geduld.
Nach der erfolgreichen Bereitstellung wird in der Bereitstellungsausgabe die URL des Cloud Run-Dienstes angezeigt. Sie hat folgendes Format:
Service URL: https://yogaposes-<<UNIQUEID>.us-central1.run.app
Wenn Sie diese öffentliche URL aufrufen, sollte dieselbe Webanwendung bereitgestellt und erfolgreich ausgeführt werden.
Sie können auch Cloud Run in der Google Cloud Console aufrufen. Dort sehen Sie eine Liste der Cloud Run-Dienste. Der Dienst yogaposes
sollte einer der dort aufgeführten Dienste sein (falls nicht der einzige).
Sie können Details zum Dienst wie URL, Konfigurationen und Protokolle aufrufen, indem Sie auf den jeweiligen Dienstnamen klicken (in unserem Fall yogaposes
).
Damit ist die Entwicklung und Bereitstellung unserer Webanwendung für Yoga-Pose-Empfehlungen in Cloud Run abgeschlossen.
10. Glückwunsch
Herzlichen Glückwunsch! Sie haben eine Anwendung erstellt, die einen Datensatz in Firestore hochlädt, die Einbettungen generiert und eine Vektorähnlichkeitssuche basierend auf der Nutzerabfrage durchführt.