Jina Embeddings et Jina Reranker sont désormais disponibles sur Amazon SageMaker via l'AWS Marketplace. Pour les utilisateurs enterprise qui accordent une grande importance à la sécurité, la fiabilité et la cohérence dans leurs opérations cloud, cela permet d'intégrer l'IA de pointe de Jina AI dans leurs déploiements AWS privés, où ils bénéficient de tous les avantages de l'infrastructure stable et établie d'AWS.
Avec notre gamme complète de modèles d'embedding et de reranking sur AWS Marketplace, les utilisateurs de SageMaker peuvent profiter de fenêtres de contexte révolutionnaires de 8k et d'embeddings multilingues de premier rang à la demande à des prix compétitifs. Vous n'avez pas à payer pour transférer des modèles vers ou depuis AWS, les prix sont transparents, et votre facturation est intégrée à votre compte AWS.
Les modèles actuellement disponibles sur Amazon SageMaker comprennent :
- Jina Embeddings v2 Base - English
- Jina Embeddings v2 Small - English
- Modèles Bilingues Jina Embeddings v2 :
- Jina Embeddings v2 Base - Code
- Jina Reranker v1 Base - English
- Jina ColBERT v1 - English
- Jina ColBERT Reranker v1 - English
Pour la liste complète des modèles, consultez la page vendeur de Jina AI sur AWS Marketplace, et profitez d'un essai gratuit de sept jours.
Cet article vous guidera dans la création d'une application de Retrieval-augmented generation (RAG) utilisant exclusivement des composants d'Amazon SageMaker. Les modèles que nous utiliserons sont Jina Embeddings v2 - English, Jina Reranker v1, et le modèle de langage Mistral-7B-Instruct.
Vous pouvez également suivre avec un Notebook Python, que vous pouvez télécharger ou exécuter sur Google Colab.
tagRetrieval-Augmented Generation
La Retrieval-augmented generation est un paradigme alternatif en IA générative. Au lieu d'utiliser des grands modèles de langage (LLM) pour répondre directement aux requêtes des utilisateurs avec ce qu'ils ont appris pendant l'entraînement, elle exploite leur production fluide du langage tout en déplaçant la logique et la recherche d'informations vers un appareil externe mieux adapté.
Avant d'invoquer un LLM, les systèmes RAG récupèrent activement les informations pertinentes d'une source de données externe puis les intègrent dans le prompt du LLM. Le rôle du LLM est de synthétiser les informations externes en une réponse cohérente aux demandes des utilisateurs, minimisant le risque d'hallucination et augmentant la pertinence et l'utilité du résultat.
Un système RAG comporte schématiquement au moins quatre composants :
- Une source de données, généralement une base de données vectorielle, adaptée à la recherche d'informations assistée par l'IA.
- Un système de recherche d'informations qui traite la requête de l'utilisateur et récupère les données pertinentes pour y répondre.
- Un système, incluant souvent un reranker basé sur l'IA, qui sélectionne certaines des données récupérées et les transforme en prompt pour un LLM.
- Un LLM, par exemple l'un des modèles GPT ou un LLM open-source comme celui de Mistral, qui prend la requête de l'utilisateur et les données fournies pour générer une réponse.
Les modèles d'embedding sont bien adaptés à la recherche d'informations et sont souvent utilisés à cette fin. Un modèle d'embedding de texte prend des textes en entrée et produit un embedding — un vecteur de haute dimension — dont la relation spatiale avec d'autres embeddings indique leur similarité sémantique, c'est-à-dire les sujets, contenus et significations apparentés. Ils sont souvent utilisés dans la recherche d'informations car plus les embeddings sont proches, plus l'utilisateur sera satisfait de la réponse. Ils sont également relativement faciles à affiner pour améliorer leurs performances dans des domaines spécifiques.
Les modèles de reranking de texte utilisent des principes d'IA similaires pour comparer des collections de textes à une requête et les trier par similarité sémantique. L'utilisation d'un modèle de reranking spécifique à la tâche, plutôt que de s'appuyer uniquement sur un modèle d'embedding, augmente souvent considérablement la précision des résultats de recherche. Dans une application RAG, le reranker sélectionne certains des résultats de la recherche d'informations afin de maximiser la probabilité que les bonnes informations se trouvent dans le prompt du LLM.
tagTests de Performance des Modèles d'Embedding comme Points de Terminaison SageMaker
Nous avons testé les performances et la fiabilité du modèle Jina Embeddings v2 Base - English comme point de terminaison SageMaker, fonctionnant sur une instance g4dn.xlarge. Dans ces expériences, nous avons continuellement créé un nouvel utilisateur chaque seconde, chacun envoyant une requête, attendant sa réponse, et répétant l'opération après réception.
- Pour les requêtes de moins de 100 tokens, jusqu'à 150 utilisateurs simultanés, les temps de réponse par requête sont restés inférieurs à 100ms. Ensuite, les temps de réponse ont augmenté linéairement de 100ms à 1500ms avec l'ajout d'utilisateurs simultanés.
- À environ 300 utilisateurs simultanés, nous avons reçu plus de 5 échecs de l'API et avons terminé le test.
- Pour les requêtes entre 1K et 8K tokens, jusqu'à 20 utilisateurs simultanés, les temps de réponse par requête sont restés inférieurs à 8s. Ensuite, les temps de réponse ont augmenté linéairement de 8s à 60s avec l'ajout d'utilisateurs simultanés.
- À environ 140 utilisateurs simultanés, nous avons reçu plus de 5 échecs de l'API et avons terminé le test.
Sur la base de ces résultats, nous pouvons conclure que pour la plupart des utilisateurs ayant des charges de travail d'embedding normales, les instances g4dn.xlarge ou g5.xlarge devraient répondre à leurs besoins quotidiens. Cependant, pour les tâches d'indexation importantes, qui sont généralement exécutées beaucoup moins souvent que les tâches de recherche, les utilisateurs pourraient préférer une option plus performante. Pour une liste de toutes les instances Sagemaker disponibles, veuillez consulter l'aperçu des instances EC2 d'AWS.
tagConfigurez votre compte AWS
Tout d'abord, vous devez avoir un compte AWS. Si vous n'êtes pas déjà un utilisateur AWS, vous pouvez vous inscrire pour un compte sur le site web d'AWS.
tagConfigurez les outils AWS dans votre environnement Python
Installez dans votre environnement Python les outils et bibliothèques AWS nécessaires pour ce tutoriel :
pip install awscli jina-sagemaker
Vous devrez obtenir une clé d'accès et une clé d'accès secrète pour votre compte AWS. Pour ce faire, suivez les instructions sur le site web d'AWS.
Vous devrez également choisir une région AWS dans laquelle travailler.
Ensuite, définissez les valeurs dans les variables d'environnement. En Python ou dans un notebook Python, vous pouvez le faire avec le code suivant :
import os
os.environ["AWS_ACCESS_KEY_ID"] = <YOUR_ACCESS_KEY_ID>
os.environ["AWS_SECRET_ACCESS_KEY"] = <YOUR_SECRET_ACCESS_KEY>
os.environ["AWS_DEFAULT_REGION"] = <YOUR_AWS_REGION>
os.environ["AWS_DEFAULT_OUTPUT"] = "json"
Définissez la sortie par défaut sur json.
Vous pouvez également le faire via l'application en ligne de commande AWS ou en configurant un fichier de configuration AWS sur votre système de fichiers local. Consultez la documentation sur le site web d'AWS pour plus de détails.
tagCréez un rôle
Vous aurez également besoin d'un rôle AWS avec des permissions suffisantes pour utiliser les ressources requises pour ce tutoriel.
Ce rôle doit :
- Avoir AmazonSageMakerFullAccess activé.
- Soit :
- Avoir l'autorité pour faire des abonnements AWS Marketplace et avoir activé les trois éléments suivants :
- aws-marketplace:ViewSubscriptions
- aws-marketplace:Unsubscribe
- aws-marketplace:Subscribe
- Ou votre compte AWS a un abonnement à jina-embedding-model.
- Avoir l'autorité pour faire des abonnements AWS Marketplace et avoir activé les trois éléments suivants :
Stockez l'ARN (Amazon Resource Name) du rôle dans la variable nommée role :
role = <YOUR_ROLE_ARN>
Consultez la documentation sur les rôles sur le site web d'AWS pour plus d'informations.
tagAbonnez-vous aux modèles Jina AI sur AWS Marketplace
Dans cet article, nous utiliserons le modèle Jina Embeddings v2 base English. Abonnez-vous sur l'AWS Marketplace.
Vous verrez les informations de tarification en faisant défiler la page vers le bas. AWS facture à l'heure pour les modèles du marketplace, vous serez donc facturé pour le temps écoulé entre le démarrage du point de terminaison du modèle et son arrêt. Cet article vous montrera comment faire les deux.
Nous utiliserons également le modèle Jina Reranker v1 - English, auquel vous devrez vous abonner.
Une fois que vous vous êtes abonné, récupérez les ARN des modèles pour votre région AWS et stockez-les dans les noms de variables embedding_package_arn et reranker_package_arn respectivement. Le code de ce tutoriel y fera référence en utilisant ces noms de variables.
Si vous ne savez pas comment obtenir les ARN, mettez le nom de votre région Amazon dans la variable region et utilisez le code suivant :
region = os.environ["AWS_DEFAULT_REGION"]
def get_arn_for_model(region_name, model_name):
model_package_map = {
"us-east-1": f"arn:aws:sagemaker:us-east-1:253352124568:model-package/{model_name}",
"us-east-2": f"arn:aws:sagemaker:us-east-2:057799348421:model-package/{model_name}",
"us-west-1": f"arn:aws:sagemaker:us-west-1:382657785993:model-package/{model_name}",
"us-west-2": f"arn:aws:sagemaker:us-west-2:594846645681:model-package/{model_name}",
"ca-central-1": f"arn:aws:sagemaker:ca-central-1:470592106596:model-package/{model_name}",
"eu-central-1": f"arn:aws:sagemaker:eu-central-1:446921602837:model-package/{model_name}",
"eu-west-1": f"arn:aws:sagemaker:eu-west-1:985815980388:model-package/{model_name}",
"eu-west-2": f"arn:aws:sagemaker:eu-west-2:856760150666:model-package/{model_name}",
"eu-west-3": f"arn:aws:sagemaker:eu-west-3:843114510376:model-package/{model_name}",
"eu-north-1": f"arn:aws:sagemaker:eu-north-1:136758871317:model-package/{model_name}",
"ap-southeast-1": f"arn:aws:sagemaker:ap-southeast-1:192199979996:model-package/{model_name}",
"ap-southeast-2": f"arn:aws:sagemaker:ap-southeast-2:666831318237:model-package/{model_name}",
"ap-northeast-2": f"arn:aws:sagemaker:ap-northeast-2:745090734665:model-package/{model_name}",
"ap-northeast-1": f"arn:aws:sagemaker:ap-northeast-1:977537786026:model-package/{model_name}",
"ap-south-1": f"arn:aws:sagemaker:ap-south-1:077584701553:model-package/{model_name}",
"sa-east-1": f"arn:aws:sagemaker:sa-east-1:270155090741:model-package/{model_name}",
}
return model_package_map[region_name]
embedding_package_arn = get_arn_for_model(region, "jina-embeddings-v2-base-en")
reranker_package_arn = get_arn_for_model(region, "jina-reranker-v1-base-en")
tagCharger le jeu de données
Dans ce tutoriel, nous allons utiliser une collection de vidéos fournie par la chaîne YouTube TU Delft Online Learning. Cette chaîne produit divers supports pédagogiques dans les matières STEM. Sa programmation est sous licence CC-BY.
Nous avons téléchargé 193 vidéos de la chaîne et les avons traitées avec le modèle de reconnaissance vocale open-source Whisper d'OpenAI. Nous avons utilisé le plus petit modèle openai/whisper-tiny pour transformer les vidéos en transcriptions.
Les transcriptions ont été organisées dans un fichier CSV, que vous pouvez télécharger ici.
Chaque ligne du fichier contient :
- Le titre de la vidéo
- L'URL de la vidéo sur YouTube
- Une transcription textuelle de la vidéo
Pour charger ces données en Python, installez d'abord pandas et requests :
pip install requests pandas
Chargez les données CSV directement dans un DataFrame Pandas nommé tu_delft_dataframe :
import pandas
# Load the CSV file
tu_delft_dataframe = pandas.read_csv("https://raw.githubusercontent.com/jina-ai/workshops/feat-sagemaker-post/notebooks/embeddings/sagemaker/tu_delft.csv")
Vous pouvez inspecter le contenu en utilisant la méthode head() du DataFrame. Dans un notebook, cela devrait ressembler à ceci :
Vous pouvez également regarder les vidéos en utilisant les URLs fournies dans ce jeu de données et vérifier que la reconnaissance vocale est imparfaite mais globalement correcte.
tagDémarrer le point de terminaison Jina Embeddings v2
Le code ci-dessous lancera une instance ml.g4dn.xlarge sur AWS pour exécuter le modèle d'embedding. Cela peut prendre plusieurs minutes pour se terminer.
import boto3
from jina_sagemaker import Client
# Choose a name for your embedding endpoint. It can be anything convenient.
embeddings_endpoint_name = "jina_embedding"
embedding_client = Client(region_name=boto3.Session().region_name)
embedding_client.create_endpoint(
arn=embedding_package_arn,
role=role,
endpoint_name=embeddings_endpoint_name,
instance_type="ml.g4dn.xlarge",
n_instances=1,
)
embedding_client.connect_to_endpoint(endpoint_name=embeddings_endpoint_name)
Modifiez le instance_type pour sélectionner un autre type d'instance cloud AWS si nécessaire.
tagConstruire et indexer le jeu de données
Maintenant que nous avons chargé les données et que nous exécutons un modèle Jina Embeddings v2, nous pouvons préparer et indexer les données. Nous stockerons les données dans une base de données vectorielle FAISS, une base de données vectorielle open-source spécialement conçue pour les applications d'IA.
Tout d'abord, installez les prérequis restants pour notre application RAG :
pip install tdqm numpy faiss-cpu
tagDécoupage
Nous devrons prendre les transcriptions individuelles et les diviser en parties plus petites, c'est-à-dire des "chunks", afin de pouvoir intégrer plusieurs textes dans une invite pour le LLM. Le code ci-dessous découpe les transcriptions individuelles aux limites des phrases, en s'assurant que tous les chunks ne contiennent pas plus de 128 mots par défaut.
```python
def chunk_text(text, max_words=128):
"""
Divise le texte en morceaux où chaque morceau contient le nombre maximal
de phrases complètes avec moins de mots que `max_words`.
"""
sentences = text.split(".")
chunk = []
word_count = 0
for sentence in sentences:
sentence = sentence.strip(".")
if not sentence:
continue
words_in_sentence = len(sentence.split())
if word_count + words_in_sentence <= max_words:
chunk.append(sentence)
word_count += words_in_sentence
else:
# Retourner le morceau actuel et en démarrer un nouveau
if chunk:
yield ". ".join(chunk).strip() + "."
chunk = [sentence]
word_count = words_in_sentence
# Retourner le dernier morceau s'il n'est pas vide
if chunk:
yield " ".join(chunk).strip() + "."
```
### Obtenir les Embeddings pour chaque Morceau
Nous avons besoin d'un embedding pour chaque morceau afin de le stocker dans la base de données FAISS. Pour les obtenir, nous passons les morceaux de texte au point de terminaison du modèle d'embedding Jina AI, en utilisant la méthode `embedding_client.embed()`. Ensuite, nous ajoutons les morceaux de texte et les vecteurs d'embedding au dataframe pandas `tu_delft_dataframe` comme nouvelles colonnes `chunks` et `embeddings` :
```python
import numpy as np
from tqdm import tqdm
tqdm.pandas()
def generate_embeddings(text_df):
chunks = list(chunk_text(text_df["Text"]))
embeddings = []
for i, chunk in enumerate(chunks):
response = embedding_client.embed(texts=[chunk])
chunk_embedding = response[0]["embedding"]
embeddings.append(np.array(chunk_embedding))
text_df["chunks"] = chunks
text_df["embeddings"] = embeddings
return text_df
print("Embedding des morceaux de texte ...")
tu_delft_dataframe = generate_embeddings(tu_delft_dataframe)
## si vous utilisez Google Colab ou un notebook Python, vous pouvez
## supprimer la ligne ci-dessus et décommenter la ligne suivante :
# tu_delft_dataframe = tu_delft_dataframe.progress_apply(generate_embeddings, axis=1)
```
### Configurer la Recherche Sémantique avec Faiss
Le code ci-dessous crée une base de données FAISS et insère les morceaux et les vecteurs d'embedding en itérant sur `tu_delft_pandas` :
```python
import faiss
dim = 768 # dimension des embeddings Jina v2
index_with_ids = faiss.IndexIDMap(faiss.IndexFlatIP(dim))
k = 0
doc_ref = dict()
for idx, row in tu_delft_dataframe.iterrows():
embeddings = row["embeddings"]
for i, embedding in enumerate(embeddings):
normalized_embedding = np.ascontiguousarray(np.array(embedding, dtype="float32").reshape(1, -1))
faiss.normalize_L2(normalized_embedding)
index_with_ids.add_with_ids(normalized_embedding, k)
doc_ref[k] = (row["chunks"][i], idx)
k += 1
```
## Démarrer le Point de Terminaison Jina Reranker v1
Comme pour le modèle Jina Embedding v2 ci-dessus, ce code lancera une instance de `ml.g4dn.xlarge` sur AWS pour exécuter le modèle de reranking. De même, cela peut prendre plusieurs minutes à exécuter.
```python
import boto3
from jina_sagemaker import Client
# Choisissez un nom pour votre point de terminaison reranker. Il peut être n'importe quoi de pratique.
reranker_endpoint_name = "jina_reranker"
reranker_client = Client(region_name=boto3.Session().region_name)
reranker_client.create_endpoint(
arn=reranker_package_arn,
role=role,
endpoint_name=reranker_endpoint_name,
instance_type="ml.g4dn.xlarge",
n_instances=1,
)
reranker_client.connect_to_endpoint(endpoint_name=reranker_endpoint_name)
```
## Définir les Fonctions de Requête
Ensuite, nous allons définir une fonction qui identifie les morceaux de transcription les plus similaires à n'importe quelle requête textuelle.
C'est un processus en deux étapes :
1. Convertir l'entrée utilisateur en un vecteur d'embedding en utilisant la méthode `embedding_client.embed()`, comme nous l'avons fait dans l'étape de préparation des données.
2. Passer l'embedding à l'index FAISS pour récupérer les meilleures correspondances. Dans la fonction ci-dessous, la valeur par défaut est de retourner les 20 meilleures correspondances, mais vous pouvez contrôler cela avec le paramètre `n`.
La fonction `find_most_similar_transcript_segment` retournera les meilleures correspondances en comparant les cosinus des embeddings stockés à l'embedding de la requête.
```python
def find_most_similar_transcript_segment(query, n=20):
query_embedding = embedding_client.embed(texts=[query])[0]["embedding"] # En supposant que la requête est assez courte pour ne pas nécessiter de découpage
query_embedding = np.ascontiguousarray(np.array(query_embedding, dtype="float32").reshape(1, -1))
faiss.normalize_L2(query_embedding)
D, I = index_with_ids.search(query_embedding, n) # Obtenir les n meilleures correspondances
results = []
for i in range(n):
distance = D[0][i]
index_id = I[0][i]
transcript_segment, doc_idx = doc_ref[index_id]
results.append((transcript_segment, doc_idx, distance))
# Trier les résultats par distance
results.sort(key=lambda x: x[2])
return [(tu_delft_dataframe.iloc[r[1]]["Title"].strip(), r[0]) for r in results]
```
Nous allons également définir une fonction qui accède au point de terminaison reranker `reranker_client`, lui passe les résultats de `find_most_similar_transcript_segment`, et retourne seulement les trois résultats les plus pertinents. Elle appelle le point de terminaison reranker avec la méthode `reranker_client.rerank()`.
```python
def rerank_results(query_found, query, n=3):
ret = reranker_client.rerank(
documents=[f[1] for f in query_found],
query=query,
top_n=n,
)
return [query_found[r['index']] for r in ret[0]['results']]
```
## Utiliser JumpStart pour Charger Mistral-Instruct
Pour ce tutoriel, nous utiliserons le modèle `mistral-7b-instruct`, qui est [disponible via Amazon SageMaker JumpStart](https://aws.amazon.com/blogs/machine-learning/mistral-7b-foundation-models-from-mistral-ai-are-now-available-in-amazon-sagemaker-jumpstart/?ref=jina-ai-gmbh.ghost.io), comme partie LLM du système RAG.
```python
from sagemaker.jumpstart.model import JumpStartModel
jumpstart_model = JumpStartModel(model_id="huggingface-llm-mistral-7b-instruct", role=role)
model_predictor = jumpstart_model.deploy()
```
Le point de terminaison pour accéder à ce LLM est stocké dans la variable `model_predictor`.
⚠️ L'utilisation de ce modèle est également un service facturé par AWS, alors n'oubliez pas de l'arrêter lorsque vous aurez terminé ce tutoriel. Voir la section [**Arrêt**](#shutting-down) pour arrêter ce déploiement une fois terminé.
### Mistral-Instruct avec JumpStart
Voici le code pour créer un modèle de prompt pour Mistral-Instruct pour cette application en utilisant [la classe de modèle de chaîne intégrée à Python](https://docs.python.org/3/library/string.html?ref=jina-ai-gmbh.ghost.io#template-strings). Il suppose que pour chaque requête, il y a trois morceaux de transcription correspondants qui seront présentés au modèle.
Vous pouvez expérimenter avec ce modèle vous-même pour modifier cette application ou voir si vous pouvez obtenir de meilleurs résultats.
```python
from string import Template
prompt_template = Template("""
[INST] Répondez à la question ci-dessous en utilisant uniquement le contexte donné.
La question de l'utilisateur est basée sur des transcriptions de vidéos d'une chaîne
YouTube.
Le contexte est présenté sous forme d'une liste classée d'informations sous la forme
(titre-vidéo, segment-transcription), qui est pertinente pour répondre à la
question de l'utilisateur.
La réponse ne doit utiliser que le contexte présenté. Si la question ne peut pas être
répondue sur la base du contexte, dites-le.
Contexte :
1. Titre-vidéo : $title_1, segment-transcription : $segment_1
2. Titre-vidéo : $title_2, segment-transcription : $segment_2
3. Titre-vidéo : $title_3, segment-transcription : $segment_3
Question : $question
Réponse : [/INST]
""")
```
Avec ce composant en place, nous avons maintenant toutes les parties d'une application RAG complète.
## Interroger le Modèle
L'interrogation du modèle est un processus en trois étapes.
1. Rechercher les morceaux pertinents pour une requête donnée.
2. Assembler le prompt.
3. Envoyer le prompt au modèle Mistral-Instruct et retourner sa réponse.
Pour rechercher les morceaux pertinents, nous utilisons la fonction `find_most_similar_transcript_segment` que nous avons définie ci-dessus.
```python
question = "Quand a été mise en service la première ferme éolienne offshore ?"
search_results = find_most_similar_transcript_segment(question)
reranked_results = rerank_results(search_results, question)
```Vous pouvez examiner les résultats de recherche dans l'ordre reclassé :
for title, text, _ in reranked_results:
print(title + "\n" + text + "\n")
Résultat :
Offshore Wind Farm Technology - Course Introduction
Since the first offshore wind farm commissioned in 1991 in Denmark, scientists and engineers have adapted and improved the technology of wind energy to offshore conditions. This is a rapidly evolving field with installation of increasingly larger wind turbines in deeper waters. At sea, the challenges are indeed numerous, with combined wind and wave loads, reduced accessibility and uncertain-solid conditions. My name is Axel Vire, I'm an assistant professor in Wind Energy at U-Delf and specializing in offshore wind energy. This course will touch upon the critical aspect of wind energy, how to integrate the various engineering disciplines involved in offshore wind energy. Each week we will focus on a particular discipline and use it to design and operate a wind farm.
Offshore Wind Farm Technology - Course Introduction
I'm a researcher and lecturer at the Wind Energy and Economics Department and I will be your moderator throughout this course. That means I will answer any questions you may have. I'll strengthen the interactions between the participants and also I'll get you in touch with the lecturers when needed. The course is mainly developed for professionals in the field of offshore wind energy. We want to broaden their knowledge of the relevant technical disciplines and their integration. Professionals with a scientific background who are new to the field of offshore wind energy will benefit from a high-level insight into the engineering aspects of wind energy. Overall, the course will help you make the right choices during the development and operation of offshore wind farms.
Offshore Wind Farm Technology - Course Introduction
Designed wind turbines that better withstand wind, wave and current loads Identify great integration strategies for offshore wind turbines and gain understanding of the operational and maintenance of offshore wind turbines and farms We also hope that you will benefit from the course and from interaction with other learners who share your interest in wind energy And therefore we look forward to meeting you online.
Nous pouvons utiliser ces informations directement dans le modèle de prompt :
prompt_for_llm = prompt_template.substitute(
question = question,
title_1 = search_results[0][0],
segment_1 = search_results[0][1],
title_2 = search_results[1][0],
segment_2 = search_results[1][1],
title_3 = search_results[2][0],
segment_3 = search_results[2][1],
)
Imprimez la chaîne résultante pour voir quel prompt est réellement envoyé au LLM :
print(prompt_for_llm)
<s>[INST] Answer the question below only using the given context.
The question from the user is based on transcripts of videos from a YouTube
channel.
The context is presented as a ranked list of information in the form of
(video-title, transcript-segment), that is relevant for answering the
user's question.
The answer should only use the presented context. If the question cannot be
answered based on the context, say so.
Context:
1. Video-title: Offshore Wind Farm Technology - Course Introduction, transcript-segment: Since the first offshore wind farm commissioned in 1991 in Denmark, scientists and engineers have adapted and improved the technology of wind energy to offshore conditions. This is a rapidly evolving field with installation of increasingly larger wind turbines in deeper waters. At sea, the challenges are indeed numerous, with combined wind and wave loads, reduced accessibility and uncertain-solid conditions. My name is Axel Vire, I'm an assistant professor in Wind Energy at U-Delf and specializing in offshore wind energy. This course will touch upon the critical aspect of wind energy, how to integrate the various engineering disciplines involved in offshore wind energy. Each week we will focus on a particular discipline and use it to design and operate a wind farm.
2. Video-title: Offshore Wind Farm Technology - Course Introduction, transcript-segment: For example, we look at how to characterize the wind and wave conditions at a given location. How to best place the wind turbines in a farm and also how to retrieve the electricity back to shore. We look at the main design drivers for offshore wind turbines and their components. We'll see how these aspects influence one another and the best choices to reduce the cost of energy. This course is organized by the two-delfd wind energy institute, an interfaculty research organization focusing specifically on wind energy. You will therefore benefit from the expertise of the lecturers in three different faculties of the university. Aerospace engineering, civil engineering and electrical engineering. Hi, my name is Ricardo Pareda.
3. Video-title: Systems Analysis for Problem Structuring part 1B the mono actor perspective example, transcript-segment: So let's assume the demarcation of the problem and the analysis of objectives has led to the identification of three criteria. The security of supply, the percentage of offshore power generation and the costs of energy provision. We now reason backwards to explore what factors have an influence on these system outcomes. Really, the offshore percentage is positively influenced by the installed Wind Power capacity at sea, a key system factor. Capacity at sea in turn is determined by both the size and the number of wind farms at sea. The Ministry of Economic Affairs cannot itself invest in new wind farms but hopes to simulate investors and energy companies by providing subsidies and by expediting the granting process of licenses as needed.
Question: When was the first offshore wind farm commissioned?
Answer: [/INST]
Passez ce prompt au point de terminaison LLM — model_predictor — via la méthode model_predictor.predict() :
answer = model_predictor.predict({"inputs": prompt_for_llm})
Cela renvoie une liste, mais puisque nous n'avons passé qu'un seul prompt, ce sera une liste avec une seule entrée. Chaque entrée est un dict avec le texte de réponse sous la clé generated_text :
answer = answer[0]['generated_text']
print(answer)
Résultat :
The first offshore wind farm was commissioned in 1991. (Context: Video-title: Offshore Wind Farm Technology - Course Introduction, transcript-segment: Since the first offshore wind farm commissioned in 1991 in Denmark, ...)
Simplifions l'interrogation en écrivant une fonction pour effectuer toutes les étapes : prendre la question en chaîne comme paramètre et renvoyer la réponse sous forme de chaîne :
def ask_rag(question):
search_results = find_most_similar_transcript_segment(question)
reranked_results = rerank_results(search_results, question)
prompt_for_llm = prompt_template.substitute(
question = question,
title_1 = search_results[0][0],
segment_1 = search_results[0][1],
title_2 = search_results[1][0],
segment_2 = search_results[1][1],
title_3 = search_results[2][0],
segment_3 = search_results[2][1],
)
answer = model_predictor.predict({"inputs": prompt_for_llm})
return answer[0]["generated_text"]
Maintenant, nous pouvons poser d'autres questions. Les réponses dépendront du contenu des transcriptions vidéo. Par exemple, nous pouvons poser des questions détaillées lorsque la réponse est présente dans les données et obtenir une réponse :
ask_rag("What is a Kaplan Meyer estimator?")
The Kaplan Meyer estimator is a non-parametric estimator for the survival
function, defined for both censored and not censored data. It is represented
as a series of declining horizontal steps that approaches the truths of the
survival function if the sample size is sufficiently large enough. The value
of the empirical survival function obtained is assumed to be constant between
two successive distinct observations.
ask_rag("Who is Reneville Solingen?")
Reneville Solingen is a professor at Delft University of Technology in Global
Software Engineering. She is also a co-author of the book "The Power of Scrum."
answer = ask_rag("What is the European Green Deal?")
print(answer)
The European Green Deal is a policy initiative by the European Union to combat
climate change and decarbonize the economy, with a goal to make Europe carbon
neutral by 2050. It involves the use of green procurement strategies in various
sectors, including healthcare, to reduce carbon emissions and promote corporate
social responsibility.
Nous pouvons également poser des questions qui sortent du cadre des informations disponibles :
ask_rag("What countries export the most coffee?")
Based on the context provided, there is no clear answer to the user's
question about which countries export the most coffee as the context
only discusses the Delft University's cafeteria discounts and sustainable
coffee options, as well as lithium production and alternatives for use in
electric car batteries.
ask_rag("How much wood could a woodchuck chuck if a woodchuck could chuck wood?")
The context does not provide sufficient information to answer the question.
The context is about thermit welding of rails, stress concentration factors,
and a lyrics video. There is no mention of woodchucks or the ability of
woodchuck to chuck wood in the context.
Essayez vos propres requêtes. Vous pouvez également modifier la façon dont le LLM est invité pour voir si cela améliore vos résultats.
tagArrêt
Puisque vous êtes facturé à l'heure pour les modèles que vous utilisez et pour l'infrastructure AWS pour les exécuter, il est très important d'arrêter les trois modèles d'IA lorsque vous terminez ce tutoriel :
- Le point de terminaison du modèle d'embedding
embedding_client - Le point de terminaison du modèle de reranking
reranker_client - Le point de terminaison du grand modèle de langage
model_predictor
Pour arrêter les trois points de terminaison du modèle, exécutez le code suivant :
# shut down the embedding endpoint
embedding_client.delete_endpoint()
embedding_client.close()
# shut down the reranker endpoint
reranker_client.delete_endpoint()
reranker_client.close()
# shut down the LLM endpoint
model_predictor.delete_model()
model_predictor.delete_endpoint()
tagCommencez dès maintenant avec les modèles Jina AI sur AWS Marketplace
Avec nos modèles d'embedding et de reranking sur SageMaker, les utilisateurs d'IA d'entreprise sur AWS ont maintenant un accès instantané à la proposition de valeur exceptionnelle de Jina AI sans compromettre les avantages de leurs opérations cloud existantes. Toute la sécurité, la fiabilité, la cohérence et la tarification prévisible d'AWS sont intégrées.
Chez Jina AI, nous travaillons dur pour apporter l'état de l'art aux entreprises qui peuvent bénéficier de l'intégration de l'IA dans leurs processus existants. Nous nous efforçons d'offrir des modèles solides, fiables et performants à des prix accessibles via des interfaces pratiques et pratiques, minimisant vos investissements en IA tout en maximisant vos retours.
Consultez la page AWS Marketplace de Jina AI pour une liste de tous les modèles d'embeddings et de reranking que nous proposons et pour essayer nos modèles gratuitement pendant sept jours.
Nous aimerions connaître vos cas d'utilisation et discuter de la façon dont les produits de Jina AI peuvent répondre aux besoins de votre entreprise. Contactez-nous via notre site web ou notre canal Discord pour partager vos commentaires et rester informé de nos derniers modèles.
