Gemini Embedding 2 : l'IA de Google révolutionne l'intégration

Gemini Embedding 2 : Une avancée dans l'intégration multimodale

Les systèmes d'embedding traditionnels étaient souvent limités au traitement du texte, nécessitant des pipelines distincts pour gérer d'autres types de contenu comme les images ou l'audio. Gemini Embedding 2, développé par Google, bouleverse cette approche en intégrant divers formats de données dans un espace vectoriel unifié, facilitant ainsi leur traitement simultané.

Google a conçu Gemini Embedding 2 pour gérer plusieurs types de contenu :

• Texte avec une capacité d'entrée allant jusqu'à 8192 tokens.
• Images, avec une prise en charge de jusqu'à 6 images par requête, aux formats PNG et JPEG.
• Vidéos d'une durée maximale de 120 secondes, compatibles avec les formats mp4 et mov.
• Audio, sans nécessité de transcription préalable.
• Documents PDF pouvant contenir jusqu'à 6 pages.

Ce modèle permet également des entrées multimodales, combinant par exemple une image et du texte dans une même requête, ce qui enrichit la compréhension des relations entre différents types de données.

Une autre caractéristique notable est la flexibilité dimensionnelle offerte par le Matryoshka Representation Learning. Par défaut, la sortie est en 3072 dimensions, mais elle peut être ajustée à 1536 ou 768 dimensions, ce qui permet aux développeurs d'optimiser entre qualité, espace de stockage et rapidité de traitement selon leurs besoins spécifiques.

Développement d'un système de correspondance d'images avec Gemini Embedding 2

Pour illustrer l'application de Gemini Embedding 2, un projet a été mis en place pour créer un système de correspondance d'images. Ce projet utilise trois dossiers au sein d'un répertoire de données :

• dataset/nitika/vasu/janvi/

Chaque dossier contient plusieurs images d'une même personne. Le processus est structuré comme suit :

• Lecture de toutes les images du dataset.
• Génération d'un embedding pour chaque image avec Gemini Embedding 2.
• Stockage des embeddings en mémoire et mise en cache localement.
• Prise d'une image de requête.
• Génération de son embedding.
• Comparaison de cet embedding avec ceux stockés, à l'aide de la similarité cosinus.
• Retour des images les plus similaires et prédiction du nom de la personne.

Ce projet démontre comment Gemini Embedding 2 peut être utilisé pour la récupération d'images et la classification légère, sans nécessiter de formation approfondie en apprentissage profond. Il n'y a pas besoin de CNN personnalisés, de réglages fins ou de processus lourds d'annotation, ce qui accélère considérablement le développement.

Grâce à la nature multimodale de Gemini Embedding 2, cette approche peut être étendue à d'autres types de contenu, comme :

• Associer un extrait audio à un profil de personne.
• Trouver un PDF pertinent à partir d'une image.
• Récupérer un segment vidéo à partir d'une requête textuelle.
• Comparer des descriptions d'images et de textes mélangées dans un espace d'embedding unique.

Ainsi, ce projet sert de point de départ vers une architecture de récupération multimodale plus vaste.

Utilisation de l'API Gemini Embedding 2

Google propose Gemini Embedding 2 via l'API Gemini et Vertex AI. La méthode embed_content est utilisée pour appeler l'embedding.

Un exemple multimodal fourni par Google pourrait ressembler à ceci :

from google import genai
from google.genai import types

client = genai.Client()

with open("example.png", "rb") as f:
    image_bytes = f.read()

with open("sample.mp3", "rb") as f:
    audio_bytes = f.read()

result = client.models.embed_content(
    model="gemini-embedding-2-preview",
    "What is the meaning of life?",
    types.Part.from_bytes(
        data=image_bytes,
        mime_type="image/png",
        types.Part.from_bytes(
            data=audio_bytes,
            mime_type="audio/mpeg",
        )
    )
)

print(result.embeddings)

Pour mon projet, je n'avais besoin que de la partie image de ce flux de travail. Plutôt que d'envoyer du texte, une image et de l'audio ensemble, j'ai utilisé une seule image par requête pour générer son embedding.

## Mise en œuvre du projet

Le projet commence par charger la clé API de **Gemini** à partir d'un fichier `.env` et créer un client :

```python
from dotenv import load_dotenv
from google import genai

GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
client = genai.Client(api_key=GEMINI_API_KEY)

Ensuite, des fonctions d'assistance sont définies pour valider les images, détecter le type MIME, normaliser les données, calculer la similarité cosinus et afficher les images.

La fonction principale d'embedding lit les octets de l'image et les envoie à Gemini Embedding 2 :

def embed_image(image_path):
    image_path = Path(image_path)
    mime_type = guess_mime_type(image_path)
    with open(image_path, "rb") as f:
        image_bytes = f.read()
    result = client.models.embed_content(
        model="gemini-embedding-2-preview",
        types.Part.from_bytes(
            data=image_bytes,
            mime_type=mime_type,
            config=types.EmbedContentConfig(
                output_dimensionality=3072
            )
        )
    )
    emb = np.array(result.embeddings[0].values, dtype=np.float32)
    return normalize(emb)

Cette fonction est le cœur du pipeline, transformant chaque image en une représentation vectorielle de 3072 dimensions.

Construction de la base de données d'embeddings du dataset

L'étape suivante consiste à parcourir le dossier du dataset, lire toutes les images pour chaque personne et les intégrer individuellement.

Chaque image intégrée est stockée sous forme de dictionnaire contenant :

• le label de la personne
• le vecteur d'embedding

Pour éviter de recalculer les embeddings à chaque fois, ils sont mis en cache dans un fichier pickle local :

def build_embeddings_db(dataset, cache_file="image_embeddings_cache.pkl", force_rebuild=False):
    cache_path = Path(cache_file)
    if cache_path.exists() and not force_rebuild:
        with open(cache_path, "rb") as f:
            embeddings_db = pickle.load(f)
        return embeddings_db

    embeddings_db = []
    for item in dataset:
        emb = embed_image(item["path"])
        embeddings_db.append({
            "label": item["label"],
            "path": item["path"],
            "embedding": emb
        })
    
    with open(cache_path, "wb") as f:
        pickle.dump(embeddings_db, f)
    
    return embeddings_db

Cela rend le processus beaucoup plus efficace, car les embeddings ne sont générés qu'une seule fois, sauf si le dataset change.

Correspondre une image de requête

Une fois les embeddings du dataset prêts, l'étape suivante est de tester le système avec une nouvelle image de requête.

L'image de requête est intégrée en utilisant la même fonction, puis son embedding est comparé à tous les embeddings stockés via la similarité cosinus.

def find_best_matches(query_image_path, top_k=5):
    query_emb = embed_image(query_image_path)
    results = []
    
    for item in embeddings_db:
        score = cosine_similarity(query_emb, item["embedding"])
        results.append({
            "label": item["label"],
            "path": item["path"],
            "score": score
        })
    
    results.sort(key=lambda x: x["score"], reverse=True)
    return results[:top_k]

Cette fonction retourne les meilleures images correspondantes du dataset.

Pour prédire le label final de la personne, un vote des top-k est utilisé :

def predict_person(query_image_path, top_k=5):
    matches = find_best_matches(query_image_path, top_k=top_k)
    labels = [m["label"] for m in matches]
    predicted_label = Counter(labels).most_common(1)[0][0]
    return predicted_label, matches

Cette méthode est plus fiable que de se baser sur une seule image la plus proche.

Tester le projet

Dans le cadre du projet, des tests ont été effectués avec des images de requête telles que :

query_image = "Nitika_Test_Image.jpeg"
predicted_person, matches = predict_person(query_image, top_k=2)
print("\nImage de requête :")
show_image(query_image, title="Image de requête")
print("Personne prédite :", predicted_person)
print("\nMeilleures correspondances :")
for i, match in enumerate(matches, 1):
    print(f"{i}. {match['label']} | score={match['score']:.4f} | path={match['path']}")
    show_image(match["path"], title=f"Rang {i} | {match['label']} | score={match['score']:.4f}")

Cela permet de visualiser les résultats et de vérifier la précision du système de correspondance d'images.