Créer une application de recommandation de tenues optimisée par l'IA avec AlloyDB et des environnements d'exécution sans serveur

1. Présentation

Imaginez une application de mode qui vous aide non seulement à trouver la tenue parfaite, mais qui vous fournit également des conseils de style en temps réel, le tout grâce à la puissance de l'intégration de l'IA générative de pointe. Dans cette présentation, nous verrons comment nous avons créé une telle application à l'aide des fonctionnalités de recherche vectorielle d'AlloyDB, associées à l'index ScaNN de Google, qui permettent d'effectuer des recherches ultra-rapides pour trouver des tenues assorties et de fournir des recommandations de mode instantanées.

Nous verrons également comment l'index ScaNN d'AlloyDB optimise les requêtes complexes pour générer des suggestions de style personnalisées. Nous utiliserons également Gemini et Imagen, des modèles d'IA générative puissants, pour vous proposer des idées de style créatives et même visualiser vos looks personnalisés. L'ensemble de cette application est basé sur une architecture sans serveur, ce qui garantit une expérience fluide et évolutive pour les utilisateurs.

Le défi : en proposant des suggestions de tenues personnalisées, l'application vise à aider les personnes qui ont du mal à se décider en matière de mode. Cela permet également d'éviter la fatigue décisionnelle liée à la planification des tenues.

La solution : l'application de recommandation de tenues résout le problème en offrant aux utilisateurs une expérience de mode intelligente, personnalisée et attrayante, tout en mettant en avant les capacités d'AlloyDB, de l'IA générative et des technologies sans serveur.

Ce que vous allez faire

Au cours de cet atelier, vous allez :

1. Créer une instance AlloyDB et charger l'ensemble de données sur l'e-commerce
2. Activer les extensions pgvector et de modèle d'IA générative dans AlloyDB
3. Générer des embeddings à partir de la description du produit
4. Déployer la solution dans Cloud Run Functions sans serveur
5. Importer une image dans Gemini et générer une requête de description d'image
6. Générez des résultats de recherche basés sur des requêtes associées à des embeddings d'ensembles de données d'e-commerce.
7. Ajoutez d'autres requêtes pour personnaliser la requête et générer des recommandations de style.
8. Déployer la solution dans Cloud Run Functions sans serveur

Conditions requises

• Un navigateur tel que Chrome ou Firefox
• Un projet Google Cloud avec facturation activée.

2. Architecture

L'architecture générale de l'application est la suivante :

Les sections suivantes mettent en évidence le flux contextuel du tutoriel :

Ingestion :

La première étape consiste à ingérer les données Retail (inventaire, descriptions de produits, interactions client) dans AlloyDB.

Moteur Analytics :

Nous utiliserons AlloyDB comme moteur d'analyse pour effectuer les opérations suivantes :

1. Extraction du contexte : le moteur analyse les données stockées dans AlloyDB pour comprendre les relations entre les produits, les catégories, le comportement des clients, etc., le cas échéant.
2. Création d'embeddings : des embeddings (représentations mathématiques du texte) sont générés à la fois pour la requête de l'utilisateur et pour les informations stockées dans AlloyDB.
3. Recherche vectorielle : le moteur effectue une recherche de similarité en comparant l'embedding de la requête à ceux des descriptions de produits, des avis et d'autres données pertinentes. Cela identifie les 25 "voisins les plus proches" les plus pertinents.

Recommandation Gemini :

Le tableau d'octets de l'image est transmis au modèle Gemini via l'API Vertex AI, ainsi que la requête demandant une description textuelle du haut et des suggestions de bas.

RAG et recherche vectorielle AlloyDB :

La description du vêtement est utilisée pour interroger la base de données. La requête convertit le texte de recherche (recommandation du modèle Gemini pour les vêtements bas assortis) en embeddings et effectue une recherche vectorielle sur les embeddings stockés dans la base de données pour trouver les voisins les plus proches (résultats correspondants). Les embeddings vectoriels de la base de données AlloyDB sont indexés à l'aide de l'index ScaNN pour un meilleur rappel.

Génération d'images de réponse :

Les réponses validées sont structurées dans un tableau JSON, et l'ensemble du moteur est intégré dans une fonction Cloud Run sans serveur, qui est appelée à partir d'Agent Builder.

Génération d'images Imagen :

Le prompt de style de l'utilisateur, une recommandation sélectionnée par l'utilisateur et toute demande de personnalisation sont combinés pour inviter Imagen 3 avec une image existante. L'image de style est générée en fonction de cette requête, à l'aide de l'API Vertex AI.

3. Avant de commencer

Créer un projet

1. Dans la console Google Cloud, sur la page du sélecteur de projet, sélectionnez ou créez un projet Google Cloud.
2. Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier si la facturation est activée sur un projet .
3. Vous allez utiliser Cloud Shell, un environnement de ligne de commande exécuté dans Google Cloud et fourni avec bq. Cliquez sur Activer Cloud Shell ( ) en haut de la console Google Cloud.
4. Une fois connecté à Cloud Shell, vérifiez que vous êtes déjà authentifié et que le projet est défini sur votre ID de projet à l'aide de la commande suivante :

gcloud auth list

5. Exécutez la commande suivante pour vérifier que les futures commandes gcloud identifieront correctement votre projet.

gcloud config list project

6. Si votre projet n'est pas défini, utilisez la commande suivante pour le définir explicitement :

gcloud config set project <YOUR_PROJECT_ID>

7. Activez les API requises.

Suivez le lien pour activer les API.

Si vous oubliez d'activer une API, vous pourrez toujours le faire au cours de l'implémentation.

Pour en savoir plus sur les commandes gcloud et leur utilisation, consultez la documentation.

4. Configuration de la base de données

Dans cet atelier, nous allons utiliser AlloyDB comme base de données pour stocker l'ensemble de données d'e-commerce. Il utilise des clusters pour stocker toutes les ressources, telles que les bases de données et les journaux. Chaque cluster possède une instance principale qui fournit un point d'accès aux données. Les tables sont la ressource qui stocke les données.

Commençons par créer un cluster, une instance et une table AlloyDB dans lesquels l'ensemble de données e-commerce sera chargé.

Créer un cluster et une instance

1. Dans la console Google Cloud, recherchez AlloyDB. Pour trouver la plupart des pages de la console Cloud, le plus simple est de les rechercher à l'aide de la barre de recherche de la console.
2. Cliquez sur CRÉER UN CLUSTER.

3. Créez un cluster et une instance avec les valeurs suivantes :

• ID du cluster : "shopping-cluster"
• password: "alloydb"
• Compatible avec PostgreSQL 15
• Région : "us-central1"
• Mise en réseau : "default"

4. Dans "Réseau", lorsque vous sélectionnez le réseau par défaut, l'option suivante s'affiche. Cliquez sur CONFIGURER LA CONNEXION pour configurer un réseau par défaut.
   
5. Sélectionnez Utiliser une plage d'adresses IP automatiquement allouée, puis cliquez sur Continuer. Après avoir vérifié les informations, cliquez sur CRÉER UNE CONNEXION.

Attendez que la création du réseau par défaut soit terminée.

6. Dans "Configurer votre instance principale", définissez l'ID de l'instance sur shopping-instance".

7. Cliquez sur CRÉER UN CLUSTER pour terminer la configuration du cluster comme suit :

La création du cluster prendra environ 10 minutes. Une fois l'opération réussie, le champ État affiche l'état "Prêt". Voici un exemple d'écran montrant un cluster prêt à l'emploi.

5. Ingestion de données

Il est maintenant temps d'ajouter un tableau contenant les données sur le magasin. Attendez que votre instance soit créée. Une fois le cluster créé, vous pouvez vous connecter à AlloyDB à l'aide des identifiants que vous avez définis lors de sa création.

S'authentifier auprès d'une base de données AlloyDB

1. Dans la console Google Cloud, accédez à AlloyDB. Sélectionnez le cluster principal, puis cliquez sur AlloyDB Studio dans le panneau de navigation de gauche :

2. Saisissez les informations suivantes pour vous authentifier auprès de la base de données AlloyDB :

• Nom d'utilisateur : "postgres"
• Base de données : "postgres"
• Mot de passe : "alloydb"

Une fois l'authentification réussie dans AlloyDB Studio, les commandes SQL sont saisies dans les onglets Éditeur. Vous pouvez ajouter plusieurs fenêtres de l'éditeur en cliquant sur le signe plus à droite du premier onglet de l'éditeur.

Vous saisirez des commandes pour AlloyDB dans les fenêtres de l'éditeur, en utilisant les options "Exécuter", "Mettre en forme" et "Effacer" selon les besoins.

Activer les extensions

Pour créer cette application, nous utiliserons les extensions "pgvector"" et "google_ml_integration"".

• L'extension pgvector vous permet de stocker et de rechercher des embeddings vectoriels.
• L'extension google_ml_integration fournit les fonctions que vous utilisez pour accéder aux points de terminaison de prédiction Vertex AI afin d'obtenir des prédictions en SQL.

1. Activez ces extensions en exécutant les LDD suivants :

CREATE EXTENSION IF NOT EXISTS google_ml_integration CASCADE;
CREATE EXTENSION IF NOT EXISTS vector;

2. Vérifiez si les extensions sont installées en exécutant cette commande SQL :

select extname, extversion from pg_extension;

Créer une table

1. Créez une table à l'aide de l'instruction LDD suivante :

CREATE TABLE
 apparels ( id BIGINT,
   category VARCHAR(100),
   sub_category VARCHAR(50),
   uri VARCHAR(200),
   image VARCHAR(100),
   content VARCHAR(2000),
   pdt_desc VARCHAR(5000),
   embedding vector(768) );

Si la commande ci-dessus s'exécute correctement, vous devriez pouvoir afficher le tableau dans

pour un pâté de maisons. L'image suivante en est un exemple :

Ingérer des données

Pour cet atelier, nous disposons de données de test d'environ 200 enregistrements dans ce fichier SQL. Il contient id, category, sub_category, uri, image et content. Les autres champs seront remplis plus tard dans l'atelier.

1. Copiez les 20 lignes/instructions d'insertion du fichier SQL dans un nouvel onglet de l'éditeur d'AlloyDB Studio, puis cliquez sur RUN.

Le nombre de lignes dépend du compte de facturation Google Cloud que vous utilisez.

que vous pouvez ingérer peut varier. Si vous rencontrez des problèmes, réduisez le nombre de lignes à 10.

ou moins.

2. Développez la section "Explorateur" jusqu'à ce que la table nommée apparels s'affiche.
3. Cliquez sur l'icône de menu [⋮], puis sur Requête. Une instruction SELECT s'ouvre dans un nouvel onglet de l'éditeur.

4. Cliquez sur Exécuter pour vérifier que les lignes sont insérées.

Accorder des autorisations à un utilisateur

Nous allons accorder à l'utilisateur postgres l'autorisation de générer des embeddings dans AlloyDB.. Dans AlloyDB Studio, exécutez l'instruction suivante pour accorder les droits d'exécution sur la fonction embedding à l'utilisateur postgres :

GRANT EXECUTE ON FUNCTION embedding TO postgres;

Attribuer le RÔLE Utilisateur Vertex AI au compte de service AlloyDB

Nous allons utiliser les modèles d'embedding de texte de Vertex AI pour générer des embeddings pour lesquels le rôle Utilisateur Vertex AI est attribué au compte de service AlloyDB.

Dans la console Google Cloud, cliquez sur l'icône Terminal Cloud Shell [] et exécutez la commande suivante :

PROJECT_ID=$(gcloud config get-value project)

gcloud projects add-iam-policy-binding $PROJECT_ID \
  --member="serviceAccount:service-$(gcloud projects describe $PROJECT_ID --format="value(projectNumber)")@gcp-sa-alloydb.iam.gserviceaccount.com" \
--role="roles/aiplatform.user"

6. Contexte de compilation

Pour créer un embedding, nous avons besoin d'un context, c'est-à-dire de toutes les informations que nous voulons inclure dans un seul champ. Pour ce faire, nous allons créer une description de produit que nous stockerons dans la colonne pdt_desc de la table apparels.

Dans notre cas, nous utiliserons toutes les informations sur chaque produit. Toutefois, lorsque vous effectuerez cette opération avec vos propres données, n'hésitez pas à les organiser de la manière qui vous semble la plus pertinente pour votre entreprise.

Dans l'onglet "Éditeur" d'AlloyDB Studio, exécutez la commande suivante pour mettre à jour le champ pdt_desc avec les données de contexte :

UPDATE
 apparels
SET
 pdt_desc = CONCAT('This product category is: ', category, ' and sub_category is: ', sub_category, '. The description of the product is as follows: ', content, '. The product image is stored at: ', uri)
WHERE
 id IS NOT NULL;

Ce DML crée un résumé de contexte simple à l'aide des informations de tous les champs disponibles dans le tableau et d'autres dépendances (le cas échéant dans votre cas d'utilisation). Pour obtenir des informations plus précises et créer du contexte, n'hésitez pas à manipuler les données de la manière qui vous semble la plus pertinente pour votre entreprise.

7. Créer des embeddings pour le contexte

Il est beaucoup plus facile pour les ordinateurs de traiter des nombres que du texte. Un système d'embedding convertit le texte en une série de nombres à virgule flottante qui doivent représenter le texte, quelle que soit sa formulation, la langue utilisée, etc.

Essayez de décrire un lieu au bord de la mer. Il peut s'agir de "on the water, beachfront, walk from your room to the ocean, sur la mer, на берегу океана, etc. Ces termes sont tous différents, mais leur signification sémantique, ou leur représentation vectorielle en termes de machine learning, devrait être très proche.

Maintenant que les données et le contexte sont prêts, nous allons exécuter le code SQL pour ajouter les embeddings de la colonne de description du produit ((pdt_desc) à la table dans le champ embedding. Vous pouvez utiliser différents modèles d'embedding. Nous utilisons text-embedding-005 de Vertex AI.

Assurez-vous d'utiliser le même modèle d'intégration dans l'ensemble du projet.

1. Dans AlloyDB Studio, exécutez la commande suivante pour générer des embeddings et mettre à jour la colonne pdt_desc avec les embeddings des données qu'elle stocke :

Si vous utilisez un projet Google Cloud existant créé il y a quelque temps, vous devrez peut-être continuer à utiliser d'anciennes versions du modèle d'embedding de texte, comme textembedding-gecko.

UPDATE
 apparels
SET
 embedding = embedding( 'text-embedding-005',
   pdt_desc)
WHERE
 TRUE;

2. Vérifiez que les embeddings sont générés en exécutant la commande suivante :

SELECT
 id,
 category,
 sub_category,
 content,
 embedding
FROM
 Apparels
LIMIT 5;

Voici un exemple de vecteur d'embedding, qui ressemble à un tableau de valeurs flottantes, pour l'exemple de texte de la requête :

Les projets Google Cloud nouvellement créés dans le niveau sans frais peuvent rencontrer des problèmes de quota concernant le nombre de requêtes d'embedding autorisées par seconde pour les modèles d'embedding. Nous vous suggérons d'utiliser une requête de filtre pour l'ID, puis de sélectionner de manière sélective un à cinq enregistrements, et ainsi de suite, lors de la génération de l'embedding.

8. Effectuer une recherche vectorielle

Maintenant que la table, les données et les embeddings sont prêts, effectuons la recherche vectorielle en temps réel pour le texte de recherche de l'utilisateur.

Supposons que le texte de recherche de l'utilisateur soit "pink color, casual, pure cotton tops for women".

Pour trouver des correspondances pour cette requête, exécutez la requête SQL suivante :

SELECT
id,
category,
sub_category,
content,
pdt_desc AS description
FROM
apparels
ORDER BY
embedding <=> embedding('text-embedding-005',
  'pink color, casual, pure cotton tops for women')::vector
LIMIT
5;

Examinons cette requête en détail :

Dans cette requête,

1. Le texte de recherche de l'utilisateur est : "I want womens tops, pink casual only pure cotton."
2. Nous convertissons ce texte de recherche en embeddings à l'aide de la méthode embedding() et du modèle text-embedding-005. Cette étape devrait vous sembler familière après la dernière étape, où nous avons appliqué la fonction d'embedding à tous les éléments du tableau.
3. "<=>" représente l'utilisation de la méthode de distance COSINE SIMILARITY. Vous trouverez toutes les mesures de similarité disponibles dans la documentation de pgvector.
4. Nous convertissons le résultat de la méthode d'embedding en type de données vector pour le rendre compatible avec les vecteurs stockés dans la base de données.
5. LIMIT 5 indique que nous souhaitons extraire les cinq voisins les plus proches du texte de recherche.

Voici un exemple de réponse à cette requête SQL :

Comme vous pouvez le voir dans vos résultats, les correspondances sont assez proches du texte de recherche. Essayez de changer la couleur pour voir comment les résultats changent.

Index ScaNN AlloyDB pour les performances des requêtes

Supposons maintenant que nous voulions améliorer les performances (temps de réponse), l'efficacité et le rappel de ce résultat de recherche vectorielle à l'aide de l'index ScaNN.

Lisez les étapes de ce blog pour comparer la différence de résultat avec et sans l'index.

Si vous souhaitez utiliser l'index ScaNN, procédez comme suit :

1. Comme nous avons déjà créé le cluster, l'instance, le contexte et les embeddings, il nous suffit d'installer l'extension ScaNN à l'aide de l'instruction suivante :

CREATE EXTENSION IF NOT EXISTS alloydb_scann;

2. Créez l'index ScaNN :

CREATE INDEX apparel_index ON apparels
USING scann (embedding cosine)
WITH (num_leaves=54);

Dans le LDD ci-dessus :

• apparel_index est le nom de l'index.
• apparels est le nom de la table.
• scann est la méthode d'index.
• embedding correspond à la colonne de la table que vous souhaitez indexer.
• cosine correspond à la méthode de distance que vous souhaitez utiliser avec l'index.
• 54 est le nombre de partitions à appliquer à cet index. Définissez une valeur comprise entre 1 et 1 048 576. Pour savoir comment déterminer cette valeur, consultez Régler un index ScaNN.

Conformément à la recommandation du dépôt ScaNN, nous avons utilisé la RACINE CARRÉE du nombre de points de données. Lors du partitionnement, num_leaves doit être à peu près égal à la racine carrée du nombre de points de données.

3. Vérifiez si l'index a été créé à l'aide de la requête suivante :

SELECT * FROM pg_stat_ann_indexes;

4. Effectuez une recherche vectorielle à l'aide de la même requête que celle que nous avons utilisée sans l'index :

select * from apparels
   ORDER BY embedding <=> CAST(embedding('textembedding-gecko', 'white tops for girls without any print') as vector(768))
   LIMIT 20

La requête ci-dessus est la même que celle que nous avons utilisée à l'étape 8 de l'atelier. Cependant, le champ est désormais indexé à l'aide de l'index ScaNN.

5. Testez avec une requête de recherche simple, avec et sans l'index. Pour effectuer des tests sans index, vous devez supprimer l'index :

white tops for girls without any print

Le texte de recherche ci-dessus dans la requête Vector Search sur les données d'embedding INDEXÉES permet d'obtenir des résultats de recherche de qualité et de l'efficacité. L'efficacité est considérablement améliorée (en termes de temps d'exécution : 10,37 ms sans ScaNN et 0,87 ms avec ScaNN) avec l'index. Pour en savoir plus à ce sujet, consultez cet article de blog.

9. Validation des correspondances avec le LLM

Avant de passer à la création d'un service permettant de renvoyer les meilleures correspondances à une application, utilisons un modèle d'IA générative pour valider si ces réponses potentielles sont réellement pertinentes et sûres à partager avec l'utilisateur.

S'assurer que l'instance est configurée pour Gemini

1. Vérifiez que google_ml_integration est déjà activé pour votre cluster et votre instance. Dans AlloyDB Studio, exécutez la commande suivante :

show google_ml_integration.enable_model_support;

Si la valeur est activée, vous pouvez ignorer les deux étapes suivantes et passer directement à la configuration.

l'intégration d'AlloyDB et de Vertex AI Model.

1. Accédez à l'instance principale de votre cluster AlloyDB, puis cliquez sur MODIFIER L'INSTANCE PRINCIPALE.

2. Dans Options de configuration avancées, développez la section Nouveau flag de base de données et assurez-vous que google_ml_integration.enable_model_support flag est défini sur "on" comme suit :

3. Si la valeur n'est pas définie sur "on", définissez-la sur "on", puis cliquez sur UPDATE INSTANCE (METTRE À JOUR L'INSTANCE).

Cette étape prendra quelques minutes.

Intégration d'AlloyDB et de Vertex AI Model

Vous pouvez maintenant vous connecter à AlloyDB Studio et exécuter l'instruction DML suivante pour configurer l'accès au modèle Gemini depuis AlloyDB, en utilisant votre ID de projet là où il est indiqué. Vous pouvez recevoir un avertissement concernant une erreur de syntaxe avant d'exécuter la commande, mais elle devrait s'exécuter correctement.

1. Dans la console Google Cloud, accédez à AlloyDB. Sélectionnez le cluster principal, puis cliquez sur AlloyDB Studio dans le panneau de navigation de gauche.
2. Nous allons utiliser le gemini-1.5-pro:generateContent disponible par défaut avec l'extension google_ml_integration.
3. Vous pouvez vérifier les modèles configurés pour l'accès à l'aide de la commande suivante dans AlloyDB Studio :

select model_id,model_type from google_ml.model_info_view;        

4. Accordez aux utilisateurs de la base de données l'autorisation d'exécuter la fonction ml_predict_row pour effectuer des prédictions à l'aide des modèles Google Vertex AI en exécutant la commande suivante :

GRANT EXECUTE ON FUNCTION ml_predict_row to postgres;

Si vous utilisez un projet Google Cloud existant et un cluster/une instance AlloyDB existant créé il y a quelque temps, vous pouvez mettre à niveau la version google_ml_integration vers la dernière version en exécutant la commande ALTER EXTENSION google_ml_integration UPDATE; pour accéder aux modèles avec prise en charge intégrée.

Évaluer les réponses

Bien que nous finissions par utiliser une grande requête pour la section suivante, où nous transférons réellement l'application vers Cloud Run, il peut être difficile de comprendre la requête afin de s'assurer que les réponses sont raisonnables.

Nous examinerons les différentes sections qui composent la requête plus large que nous utiliserons finalement.

1. Nous allons d'abord envoyer une requête à la base de données pour obtenir les cinq correspondances les plus proches d'une requête utilisateur. Nous codons en dur la requête pour simplifier les choses, mais ne vous inquiétez pas, nous l'interpolerons dans la requête plus tard.

Nous incluons la description du produit de la table apparels et ajoutons deux nouveaux champs : l'un qui combine la description avec l'index et l'autre avec la demande d'origine. Ces données sont enregistrées dans une table appelée xyz, qui est un nom de table temporaire.

CREATE TABLE
 xyz AS
SELECT
 id || ' - ' || pdt_desc AS literature,
 pdt_desc AS content,
 'I want womens tops, pink casual only pure cotton.' AS  user_text
FROM
 apparels
ORDER BY
 embedding <=> embedding('text-embedding-005',
   'I want womens tops, pink casual only pure cotton.')::vector
LIMIT
 5;

Le résultat de cette requête sera 5 lignes les plus similaires concernant la requête des utilisateurs. La

La nouvelle table xyz contiendra cinq lignes, chacune avec les colonnes suivantes :

• literature
• content
• user_text

2. Pour déterminer la validité des réponses, nous allons utiliser une requête complexe dans laquelle nous expliquons comment évaluer les réponses. Il utilise user_text et content dans le tableau xyz dans la requête.

"Read this user search text: ', user_text, 
' Compare it against the product inventory data set: ', content, 
' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."

3. À l'aide de cette requête, nous examinerons ensuite la qualité des réponses dans la table xyz. Lorsque nous parlons de qualité, nous faisons référence à la justesse des réponses générées par rapport à ce que nous attendons.

CREATE TABLE
  x AS
SELECT
  json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
      request_body => CONCAT('{
 "contents": [ 
        { "role": "user", 
          "parts": 
             [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match." 
             } ]
         } 
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
FROM
    xyz;

4. predict_row renvoie son résultat au format JSON. Le code -> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'" est utilisé pour extraire le texte réel de ce JSON. Pour afficher le code JSON renvoyé, vous pouvez supprimer ce code.
5. Enfin, pour obtenir le champ LLM, il vous suffit de l'extraire du tableau x :

SELECT 
LLM_RESPONSE 
FROM 
        x;

6. Vous pouvez combiner ces deux requêtes en une seule comme suit :

Avertissement : Si vous avez exécuté les requêtes ci-dessus pour vérifier les résultats intermédiaires,

Veillez à supprimer les tables xyz et x de la base de données AlloyDB avant d'exécuter cette requête.

SELECT
 LLM_RESPONSE
FROM (
 SELECT
 json_array_elements( google_ml.predict_row( model_id => 'gemini-1.5',
     request_body => CONCAT('{
     "contents": [
       { "role": "user",
         "parts":
            [ { "text": "Read this user search text: ', user_text, ' Compare it against the product inventory data set: ', content, ' Return a response with 3 values: 1) MATCH: if the 2 contexts are at least 85% matching or not: YES or NO 2) PERCENTAGE: percentage of match, make sure that this percentage is accurate 3) DIFFERENCE: A clear short easy description of the difference between the 2 products. Remember if the user search text says that some attribute should not be there, and the record has it, it should be a NO match."
            } ]
        }
] }'
)::json))-> 'candidates' -> 0 -> 'content' -> 'parts' -> 0 -> 'text'
AS LLM_RESPONSE
   FROM (
         SELECT
           id || ' - ' || pdt_desc AS literature,
           pdt_desc AS content,
         'I want womens tops, pink casual only pure cotton.' user_text
         FROM
           apparels
         ORDER BY
             embedding <=> embedding('text-embedding-005',
             'I want womens tops, pink casual only pure cotton.')::vector
         LIMIT
           5 ) AS xyz ) AS X;

La requête plus volumineuse est une combinaison de toutes les requêtes que nous exécutons dans les étapes précédentes. Les résultats indiquent s'il y a une correspondance ou non, le pourcentage de correspondance et une explication de la classification.

Notez que le modèle Gemini est configuré par défaut pour le streaming on. La réponse réelle est donc répartie sur plusieurs lignes :

10. Transférer l'application sur le Web

Nous allons maintenant héberger cette application afin qu'elle soit accessible depuis Internet.

Créer la fonction Cloud Run

1. Dans la console Google Cloud, accédez à Cloud Run Functions en cliquant sur le lien suivant :

https://console.cloud.google.com/run/create?deploymentType=function

2. Dans "Configurer", définissez le nom de la fonction sur retail-engine et sélectionnez la région us-central1.
3. Dans "URL du point de terminaison", sélectionnez l'environnement d'exécution Java 17.
4. Dans "Authentification", sélectionnez Autoriser les appels non authentifiés.
5. Développez Conteneur(s), volumes, mise en réseau, sécurité, puis cliquez sur l'onglet Mise en réseau.
6. Sélectionnez Se connecter à un VPC pour le trafic sortant, puis cliquez sur Utiliser des connecteurs d'accès VPC sans serveur.
7. Dans "Réseau", cliquez sur Ajouter un connecteur VPC. Activez l'API Serverless VPC Access, si ce n'est pas déjà fait.
8. Dans "Créer un connecteur", définissez le nom sur alloydb-test-conn.
9. Définissez la région sur us-central.
10. Laissez la valeur du réseau sur default (par défaut), puis définissez Subnet (Sous-réseau) sur Custom IP Range (Plage d'adresses IP personnalisée) avec la plage d'adresses IP 10.8.0.0 ou une plage similaire disponible.
11. Développez les paramètres Afficher le scaling, puis définissez Instances minimales sur 2 et Instances maximales sur 3.
12. Sélectionnez le type d'instance f1-micro. Les options de création de connecteur sont les suivantes :

13. Cliquez sur "Créer" pour créer le connecteur.
14. Dans "Routage du trafic", sélectionnez Acheminer tout le trafic vers le VPC.
15. Cliquez sur Créer pour créer la fonction.

Déployer l'application

Une fois la fonction créée, mettez à jour la source et redéployez l'application.

1. Dans Cloud Run, cliquez sur l'onglet Services, puis sur la fonction retail-engine.
2. Cliquez sur l'onglet "Source". Laissez le point d'entrée de la fonction par défaut défini sur "gcfv2.HelloHttpFunction".
3. Remplacez le contenu du fichier HelloHttpFunction.java par le contenu de ce fichier Java.
4. Mettez à jour les détails de AlloyDbJdbcConnector dans le fichier en fonction des détails de votre instance et de votre cluster AlloyDB. Remplacez $PROJECT_ID par l'ID de projet de votre cluster et de votre instance AlloyDB.

5. Remplacez le contenu du fichier pom.xml par celui de ce fichier XML.
6. Cliquez sur Enregistrer et redéployer pour déployer la fonction.

11. Tester l'application retail-engine

Une fois la fonction Cloud mise à jour déployée, le point de terminaison doit s'afficher au format suivant :

Pour trouver le numéro de projet de votre projet Google Cloud, dans le panneau de navigation de gauche de la console Google Cloud, cliquez sur Présentation du cloud > Tableau de bord. Vous trouverez le numéro de projet dans "Informations sur le projet".

https://retail-engine-PROJECT_NUMBER.us-central1.run.app

Vous pouvez le tester à partir du terminal Cloud Shell en exécutant la commande suivante :

gcloud functions call retail-engine --region=us-central1 --gen2 --data '{"search": "I want some kids clothes themed on Disney"}'

Vous pouvez également tester la fonction Cloud Run comme suit :

PROJECT_ID=$(gcloud config get-value project)

curl -X POST https://retail-engine-$PROJECT_NUMBER.us-central1.run.app \
  -H 'Content-Type: application/json' \
  -d '{"search":"I want some kids clothes themed on Disney"}' \
  | jq .

Résultat :

Maintenant que nous avons effectué une recherche vectorielle de similarité à l'aide du modèle d'embeddings sur les données AlloyDB, nous pouvons passer à la création de l'application qui utilise ces embeddings avec votre image et des invites pour générer des suggestions de style.

12. Comprendre le parcours de recommandation de tenues

L'application de recommandation de tenues est une application Sprint Boot configurée pour fonctionner avec les embeddings que nous avons créés dans l'application AlloyDB retail-engine, ainsi qu'avec Gemini et Imagen pour générer des options de style visuel pour les tenues. Il vous permet également d'ajouter des requêtes personnalisées et d'improviser la recommandation.

Imaginez que vous importez l'image d'un haut rose fuchsia de votre garde-robe dans cette application. Lorsque vous cliquez sur "Afficher", l'application génère plusieurs options correspondant à l'image d'origine, en fonction de la requête définie dans le code de l'application et des embeddings de la base de données AlloyDB. Vous vous demandez maintenant à quoi ressembleraient les options suggérées avec un collier bleu. Vous ajoutez donc une requête dans ce sens et cliquez sur "Style". L'image finale est générée en combinant l'image d'origine et les recommandations pour créer une tenue assortie.

Pour commencer à créer l'application de recommandation de tenues, procédez comme suit :

1. Dans Cloud Run, ouvrez l'application retail-engine et notez l'URL de votre application. Il s'agit du dépôt d'embeddings que nous utiliserons pour générer des suggestions similaires.
2. Dans votre IDE, clonez le dépôt https://github.com/AbiramiSukumaran/outfit-recommender/. Pour cet exercice, les étapes présentées sont effectuées dans l'IDE Visual Studio Code.

git clone https://github.com/AbiramiSukumaran/outfit-recommender/

Voici quelques-uns des fichiers importants du répertoire de l'application :

• src/main : répertoire source où résident les fichiers d'application et le code HTML :
• HelloWorldApplication.java : point d'entrée principal de l'application Spring Boot.
• HelloWorldController.java : contrôleur REST Spring Boot qui gère les requêtes HTTP liées à une application de recommandation de tenues. Ce fichier gère les requêtes GET et POST, traite les requêtes utilisateur, analyse les images, interagit avec les embeddings AlloyDB et renvoie la réponse finale à l'UI. Ce contrôleur appelle la classe GenerateImageSample.
• GenerateImageSample.java : contient la classe de génération d'images qui se connecte à Vertex AI, met en forme la requête utilisateur, effectue des appels d'API au modèle Imagen et renvoie l'image prédite à la classe de contrôleur.
• Resources : ce répertoire contient les images et les fichiers HTML nécessaires à la génération de l'UI de l'application.
• Pom.xml : définit les dépendances et les configurations du projet.

3. Dans Visual Studio Code, ouvrez le fichier HelloWorldController.java et mettez à jour les instances de l'ID et de l'emplacement du projet en fonction de l'endroit où votre instance AlloyDB est créée.

4. Remplacez endpoint par l'URL de l'application retail-engine que vous avez hébergée précédemment.

5. Ouvrez le fichier GenerateImageSample.java, puis mettez à jour l'ID du projet et l'emplacement en fonction de l'endroit où votre instance AlloyDB a été créée.

Pour les projets de niveau tarifaire sans frais ou si vous rencontrez des restrictions pour générer des images avec des humains

, vous pouvez modifier l'invite post_context en Generate a high-quality, aesthetically pleasing image suitable for fashion recommendations. Show a two piece outfit from the provided image without a human figure and using other details described in the prompt. pour générer des recommandations de style. De plus, mettez en commentaire le paramètre paramsMap.put("personGeneration", "allow_adult");.

6. Enregistrez tous les fichiers.

Nous allons maintenant déployer cette application dans l'environnement d'exécution sans serveur Cloud Run.

13. Transférer l'application sur le Web

Maintenant que nous avons ajouté les détails du projet, de l'emplacement et de l'application retail-engine à l'application Spring Boot de recommandation de tenues, nous pouvons déployer l'application sur Cloud Run.

Nous allons utiliser la commande gcloud run deploy dans le terminal Visual Studio Code pour déployer l'application. Pour Visual Studio Code, vous pouvez installer l'extension Google Cloud Code pour commencer à utiliser la gcloud CLI.

Pour déployer l'application, procédez comme suit :

1. Dans votre IDE, ouvrez le répertoire cloné et démarrez le terminal. Pour Visual Code Studio, cliquez sur Terminal > New Terminal.
2. Suivez les instructions de ce document pour installer la gcloud CLI.
3. Si vous utilisez Visual Studio Code, cliquez sur Extensions, recherchez Google Cloud Code, puis installez l'extension.
4. Dans le terminal de votre IDE, authentifiez votre compte Google en exécutant la commande suivante :

gcloud auth application-default login

5. Définissez votre ID de projet sur le même projet que celui dans lequel se trouve votre instance AlloyDB.

gcloud config set project PROJECT_ID

6. Démarrez le processus de déploiement.

gcloud run deploy

7. Dans Source code location, appuyez sur Entrée pour sélectionner le répertoire GitHub cloné.
8. Dans Service name, saisissez un nom pour le service, tel que outfit-recommender, puis appuyez sur Entrée.
9. Dans Please specify a region, saisissez l'emplacement où votre instance AlloyDB et votre application retail-engine sont hébergées (par exemple, 32 pour us-central1), puis appuyez sur Entrée.

10. Dans Allow unauthenticated invocations to [..], saisissez Y, puis appuyez sur Entrée.

L'image suivante montre la progression du déploiement de votre application :

14. Tester l'application de recommandation de tenues

Une fois l'application déployée sur Cloud Run, vous pouvez voir le service dans la console Google Cloud comme suit :

1. Dans la console Google Cloud, accédez à Cloud Run.
2. Dans "Services", cliquez sur le service outfit recommender que vous avez déployé. Vous devriez voir les services retail-engine et outfit-recommender comme suit :

3. Cliquez sur l'URL de l'application pour ouvrir l'interface utilisateur de l'application de recommandation.

    The following is a sample URL that you will use:

https://outfit-recommender-22905290964.us-central1.run.app/style

L'application déployée peut se présenter comme suit :

Utiliser l'application

Pour commencer à utiliser l'application, procédez comme suit :

1. Cliquez sur Importer, puis importez une photo d'un vêtement.
2. Une fois l'image importée, cliquez sur Style. L'application utilise l'image comme requête et génère des options de bas en fonction de la requête de l'application retail-engine, qui inclut des embeddings pour l'ensemble de données retail.

L'application génère des suggestions d'images ainsi qu'un prompt basé sur l'image avec des recommandations de style. Par exemple : A white semi-sheer button up blouse with pink floral patterns on it, with balloon sleeves.

3. Vous pouvez transmettre des requêtes supplémentaires à cette recommandation de style générée automatiquement. Par exemple : STYLE RECOMMENDATION: Cute brown skirt on a curly updo. Make it photo realistic. Accessorize with cherry earrings and burgundy plastic case sling bag.
4. Cliquez sur Afficher pour voir le style final.

15. Effectuer un nettoyage

Pour éviter que les ressources utilisées dans cet article soient facturées sur votre compte Google Cloud, procédez comme suit :

1. Dans la console Google Cloud, accédez à la page Gérer les ressources.
2. Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

16. Félicitations

Félicitations ! Vous avez effectué une recherche de similarité à l'aide d'AlloyDB, de pgvector et de Vector Search, et vous avez utilisé les résultats de recherche avec le puissant modèle Imagen pour générer des recommandations de style.