Usage prévu

Le modèle est conçu pour calculer les scores de pertinence pour les paires requête-document, ce qui le rend bien adapté aux tâches de reclassement dans les applications de recherche d'informations et de recherche.

Utilisation avec les transformateurs de phrases

Le modèle est compatible avec la bibliothèque SentenceTransformer et est très facile à utiliser :

Tout d'abord, installez la bibliothèque des transformateurs de phrases

pip install sentence_transformers

Le modèle peut ensuite être utilisé pour coder conjointement des paires de textes afin de calculer un score de pertinence.

from sentence_transformers import CrossEncoder, util

model_path = "ibm-granite/granite-embedding-reranker-english-r2"
# Load the Sentence Transformer model
model = CrossEncoder(model_path)

passages = [
               "Romeo and Juliet is a play by William Shakespeare.",
               "Climate change refers to long-term shifts in temperatures.",
               "Shakespeare also wrote Hamlet and Macbeth.",
               "Water is an inorganic compound with the chemical formula H2O.",
               "In liquid form, H2O is also called 'water' at standard temperature and pressure."
            ]

query = "what is the chemical formula of water?"

# encodes query and passages jointly and computes relevance score.
ranks = model.rank(query, passages, return_documents=True)

# Print document rank and relevance score
for rank in ranks:
    print(f"- #{rank['corpus_id']} ({rank['score']:.2f}): {rank['text']}")

Utilisation avec les transformateurs Huggingface :

Il s'agit d'un exemple simple d'utilisation du modèle de reranking avec la bibliothèque Transformers et PyTorch.

Tout d'abord, installez les bibliothèques nécessaires

pip install transformers torch

Le modèle peut ensuite être utilisé pour coder des paires de textes

import torch
from transformers import AutoModelForSequenceClassification, AutoTokenizer

model_path = "ibm-granite/granite-embedding-reranker-english-r2"

# Load the model and tokenizer
model = AutoModelForSequenceClassification.from_pretrained(model_path).eval()
tokenizer = AutoTokenizer.from_pretrained(model_path)

pairs = [
    ["what is the chemical formula of water?", "Water is an inorganic compound with the chemical formula H2O."],
    ["what is the chemical formula of water?", "In liquid form, H2O is also called 'water' at standard temperature and pressure."],
    ["how to implement quick sort in python?", "The weather is nice today"],
]


# tokenize inputs
tokenized_pairs = tokenizer(pairs, padding=True, truncation=True, return_tensors='pt')

# encode and compute scores
with torch.no_grad():
    scores = model(**tokenized_pairs, return_dict=True).logits.view(-1, ).float()
    print(scores)

Utilisation avec Huggingface Transformers (Retriever + Reranker E2E )

Il s'agit d'un exemple simple d'utilisation de Granite retriever et reranker de bout en bout avec la bibliothèque Transformers et PyTorch. Le retriever trouve d'abord les documents candidats les plus pertinents pour une requête, puis le reranker réordonne ces candidats pour produire la liste finale classée.

import torch
from transformers import AutoModel, AutoTokenizer, AutoModelForSequenceClassification

# --------------------------
# 1. Load retriever (149M)
# --------------------------
retriever_model_path = "ibm-granite/granite-embedding-english-r2"
retriever = AutoModel.from_pretrained(retriever_model_path).eval()
retriever_tokenizer = AutoTokenizer.from_pretrained(retriever_model_path)

# Example query + candidate documents
query = "what is the chemical formula of water?"
documents = [
    "Water is an inorganic compound with the chemical formula H2O.",
    "In liquid form, H2O is also called 'water' at standard temperature and pressure.",
    "The weather is nice today",
    "Quick sort is a divide and conquer algorithm that sorts by partitioning."
]

# Encode query and documents
with torch.no_grad():
    query_emb = retriever(
        **retriever_tokenizer(query, return_tensors="pt", truncation=True, padding=True)
    ).last_hidden_state[:, 0, :]   # CLS embedding

    doc_embs = retriever(
        **retriever_tokenizer(documents, return_tensors="pt", truncation=True, padding=True)
    ).last_hidden_state[:, 0, :]

# Compute cosine similarity
query_emb = torch.nn.functional.normalize(query_emb, dim=-1)
doc_embs = torch.nn.functional.normalize(doc_embs, dim=-1)
similarities = torch.matmul(query_emb, doc_embs.T).squeeze(0)

# Rank docs by retriever
retriever_ranked = sorted(
    zip(documents, similarities.tolist()),
    key=lambda x: x[1],
    reverse=True
)
print("Retriever ranking:")
for doc, score in retriever_ranked:
    print(f"{score:.4f} | {doc}")


# --------------------------
# 2. Load reranker (149M)
# --------------------------
reranker_model_path = "ibm-granite/granite-embedding-reranker-english-r2"
reranker = AutoModelForSequenceClassification.from_pretrained(reranker_model_path).eval()
reranker_tokenizer = AutoTokenizer.from_pretrained(reranker_model_path)

# Prepare top-k candidates (say top 3 from retriever)
top_k = 3
candidate_pairs = [[query, doc] for doc, _ in retriever_ranked[:top_k]]

# Tokenize and rerank
with torch.no_grad():
    tokenized_pairs = reranker_tokenizer(
        candidate_pairs, padding=True, truncation=True, return_tensors="pt"
    )
    rerank_scores = reranker(**tokenized_pairs).logits.view(-1, ).float()

# Rank docs by reranker
reranker_ranked = sorted(
    zip([doc for doc, _ in retriever_ranked[:top_k]], rerank_scores.tolist()),
    key=lambda x: x[1],
    reverse=True
)

print("\nReranker final ranking:")
for doc, score in reranker_ranked:
    print(f"{score:.4f} | {doc}")

Résultats de l'évaluation

Les performances du modèle Granite Embedding English reranking sur les benchmarks BEIR, MLDR et Miracl sont présentées ci-dessous. Tous les modèles sont évalués sur les documents top-20 récupérés par les moteurs de recherche granite-embedding-english-small-r2 ou granite-embedding-english-r2 respectivement. Chaque modèle de reclassement est évalué avec sa longueur de séquence maximale supportée, tandis que les requêtes sont tronquées à 64 mots.

Collecte de données

Granite est formé à l'aide de données provenant de quatre sources principales :

1. Données jumelées titre-corps non supervisées extraites du web
2. Mise à disposition publique couplée à une licence permissive et adaptée aux entreprises
3. IBM -données internes appariées ciblant des domaines techniques spécifiques
4. IBM -données synthétiques générées

Notamment, nous n'utilisons pas le populaire ensemble de données de recherche MS-MARCO dans notre corpus de formation en raison de sa licence non commerciale (de nombreux modèles open-source utilisent cet ensemble de données en raison de sa haute qualité).

L'encodeur sous-jacent modélise à l'aide de GneissWeb, un ensemble de données créé par IBM et composé exclusivement de sources ouvertes et compatibles avec le commerce.

En matière de gouvernance, toutes nos données font l'objet d'un processus d'autorisation soumis à un examen technique, commercial et de gouvernance. Ce processus complet permet de recueillir des informations essentielles sur les données, y compris, mais sans s'y limiter, la description du contenu, la propriété, l'utilisation prévue, la classification des données, les informations relatives aux licences, les restrictions d'utilisation, les modalités d'acquisition des données, ainsi qu'une évaluation des informations sensibles (c'est-à-dire des informations personnelles).

hyper-convergée

Nous entraînons le modèle de reclassement Granite à l'aide de la grappe de calcul de IBM, BlueVela Cluster, qui est équipée de NVIDIA H100 80gb GPU. Ce cluster fournit une infrastructure évolutive et efficace pour l'entraînement de nos modèles sur plusieurs GPU.

Considérations éthiques et limites

Les données utilisées pour former le modèle linguistique de base ont été filtrées pour supprimer les textes contenant des propos haineux, injurieux et blasphématoires. granite-embedding-reranker-english-r2 est réglé sur l'anglais et a une longueur de contexte de 8192 tokens (les textes plus longs seront tronqués à cette taille).

Ressources

• Découvrez les dernières mises à jour avec Granite : IBM Granite website
• Démarrez avec des tutoriels, les meilleures pratiques et des conseils d'ingénierie rapides : IBM Granite Documentation
• Découvrez les dernières ressources d'apprentissage Granite : IBM Développeur