flowchart TB
    subgraph encoder [Encoder]
        direction TB
        enc_input(Input Embedding) --> enc_pos(Positional Encoding)
        enc_pos --> enc_Nx1[Multi-Head Attention]
        enc_Nx1 --> enc_addnorm1[Add & Norm]
        enc_addnorm1 --> enc_ff1[Feed Forward]
        enc_ff1 --> enc_addnorm2[Add & Norm]
        enc_addnorm2 -.-> enc_Nx2[Multi-Head Attention]
        enc_Nx2 -.-> enc_addnorm3[Add & Norm]
        enc_addnorm3 -.-> enc_ff2[Feed Forward]
        enc_ff2 -.-> enc_addnorm4[Add & Norm]
        enc_addnorm4 -.-> enc_NxN[...]
        enc_NxN -.-> enc_output[Encoder Output]
    end

    subgraph decoder [Decoder]
        direction TB
        dec_input(Output Embedding) --> dec_pos(Positional Encoding)
        dec_pos --> dec_Nx1[Masked Multi-Head Attention]
        dec_Nx1 --> dec_addnorm1[Add & Norm]
        dec_addnorm1 --> dec_ff1[Feed Forward]
        dec_ff1 --> dec_addnorm2[Add & Norm]
        dec_addnorm2 -.-> dec_Nx2[Masked Multi-Head Attention]
        dec_Nx2 -.-> dec_addnorm3[Add & Norm]
        dec_addnorm3 -.-> dec_ff2[Feed Forward]
        dec_ff2 -.-> dec_addnorm4[Add & Norm]
        dec_addnorm4 -.-> dec_NxN[...]
        dec_NxN -.-> dec_output[Decoder Output]
    end

    enc_output --> dec_input
    dec_output --> lin[Linear]
    lin --> softmax[Softmax]
    softmax --> out(Output Probabilities)

    %% Styling
    classDef addnorm fill:#FFDD6B,stroke:#333,stroke-width:2px;
    class enc_addnorm1,enc_addnorm2,enc_addnorm3,enc_addnorm4,dec_addnorm1,dec_addnorm2,dec_addnorm3,dec_addnorm4 addnorm;
    classDef feedforward fill:#6BCB77,stroke:#333,stroke-width:2px;
    class enc_ff1,enc_ff2,dec_ff1,dec_ff2 feedforward;
    classDef attention fill:#4D96FF,stroke:#333,stroke-width:2px;
    class enc_Nx1,dec_Nx1,dec_Nx2 attention;
    classDef embedding fill:#FFAFCC,stroke:#333,stroke-width:2px;
    class enc_input,dec_input embedding;
    classDef softmaxlinear fill:#DB6E6E,stroke:#333,stroke-width:2px;
    class lin,softmax softmaxlinear;
    classDef output fill:#FFFFFF,stroke:#333,stroke-width:2px;
    class out output;

• 检索增强生成 (RAG) 是一种将传统文本生成技术与基于检索的方法相结合的方法，旨在提高对话式 AI 系统中生成响应的质量和相关性。
• 在 GPT 等传统生成模型中，响应仅根据输入查询或上下文生成。然而，在 RAG 中，模型还会从数据库中检索相关文档或段落，并将它们纳入生成过程中。

• 检索模型：这些模型负责根据输入查询从数据库中检索相关文档或段落。
• 生成模型：这些模型通过结合输入查询和检索到的文档中的信息来生成响应。
• 语义搜索：RAG 依赖语义搜索技术来检索与输入查询语义相似的文档，而不是仅仅依赖关键词匹配。

• RAG 通过整合来自检索文档的外部知识，提高了生成响应的相关性和连贯性。
• 它使聊天机器人能够提供信息量更大且与上下文相关的响应，从而增强整体用户体验。

• RAG 广泛应用于对话式 AI 系统、聊天机器人、问答系统和信息检索应用程序。
• 它可应用于客户支持、医疗保健、教育和电子商务等各个领域，为用户查询提供个性化且准确的响应。

• La génération augmentée par récupération (RAG) est une approche qui combine les techniques traditionnelles de génération de texte avec des méthodes basées sur la récupération pour améliorer la qualité et la pertinence des réponses générées dans les systèmes de conversation AI.
• Dans les modèles génératifs traditionnels comme GPT, les réponses sont générées uniquement sur la base de la requête d'entrée ou du contexte. Cependant, dans RAG, le modèle récupère également des documents ou des passages pertinents d'une base de données et les intègre dans le processus de génération.

• Modèles de récupération : Ces modèles sont responsables de la récupération de documents ou passages pertinents d'une base de données sur la base de la requête d'entrée.
• Modèles de génération : Ces modèles génèrent des réponses en incorporant des informations provenant à la fois de la requête d'entrée et des documents récupérés.
• Recherche sémantique : RAG s'appuie sur des techniques de recherche sémantique pour récupérer des documents qui sont sémantiquement similaires à la requête d'entrée, plutôt que de se baser uniquement sur une correspondance de mots-clés.

• RAG améliore la pertinence et la cohérence des réponses générées en incorporant des connaissances externes provenant de documents récupérés.
• Cela permet au chatbot de fournir des réponses plus informatives et contextuellement pertinentes, améliorant ainsi l'expérience utilisateur globale.

• RAG est largement utilisé dans les systèmes de conversation AI, les chatbots, les systèmes de réponse aux questions et les applications de récupération d'informations.
• Il peut être appliqué dans divers domaines tels que le support client, les soins de santé, l'éducation et le commerce électronique pour fournir des réponses personnalisées et précises aux requêtes des utilisateurs.

• LangChain 是一个框架，旨在促进检索模型与语言模型的集成，以完成检索增强生成任务。
• 它为构建聊天机器人和对话式 AI 系统提供了一个统一的接口，并增强了响应生成能力。

• 自然语言处理 (NLP) 流水线： LangChain 包含一个全面的 NLP 流水线，用于分词、嵌入生成和语义相似度计算等任务。

• 检索模型集成： LangChain 无缝集成了检索模型，允许系统根据输入查询检索相关文档或段落。

  • 密集检索阅读器 (DRQA)： 该模型使用密集向量表示从大型语料库中检索相关文档，然后使用阅读器模型从这些文档中提取相关信息以生成响应。
  • 带检索机制的神经生成对话模型： 该模型首先使用信息检索技术从大量过往对话数据库中检索相关上下文或响应，然后根据检索到的上下文和当前输入生成响应。
  • 带检索增强生成的双编码器 (DIALOGPT)： 该架构使用双编码器对输入查询和检索到的上下文进行编码，然后基于这种组合表示生成响应。它可以在对话数据上进行微调，以生成更具上下文相关性的响应。
  • 顺序检索模型 (SeqRM)： 该模型从知识库中顺序检索相关段落，并将它们纳入生成过程。在生成的每一步，它都会根据当前上下文检索最相关的段落，并相应地生成下一个 token。
  • 用于阅读器的 BERT (BRR)： 该模型采用基于 BERT 的检索器和阅读器组件。检索器从大型语料库中选择相关段落，阅读器从这些段落中提取相关信息以生成响应。
• 语言模型集成： 它还集成了用于响应生成的语言模型，使系统能够通过整合输入查询和检索文档中的信息来生成连贯且与上下文相关的响应。

• 向量数据库接口： LangChain 提供了一个与向量数据库交互的接口，允许用户高效地存储和检索文档嵌入以进行语义搜索。

  • Milvus： Milvus 是一个开源向量数据库，旨在管理和提供大规模向量嵌入服务。它支持多种相似度搜索算法，并提供高效的索引和查询能力。
  • Faiss： 由 Facebook AI Research (FAIR) 开发，Faiss 是一个广泛使用的库，用于高效的相似度搜索和密集向量聚类。它针对高维向量进行了优化，并提供 GPU 加速的索引和查询。
  • Annoy： Annoy (Approximate Nearest Neighbors Oh Yeah) 是一个带有 Python 绑定的 C++ 库，用于近似最近邻搜索。它专为大规模相似度搜索任务而设计，支持 CPU 和 GPU 实现。
  • Pinecone： Pinecone 是一个托管的向量数据库服务，提供实时相似度搜索和推荐功能。它提供无服务器架构、自动扩展以及与流行机器学习框架的集成。
  • 带向量插件的 Elasticsearch： Elasticsearch 是一个分布式搜索和分析引擎，可以通过插件扩展以支持向量数据。Elasticsearch 向量插件允许对向量嵌入进行索引和查询，从而在 Elasticsearch 中实现相似度搜索。
  • HNSW (Hierarchical Navigable Small World)： 虽然不是独立的数据库，但 HNSW 是一种常用于近似最近邻搜索的数据结构和算法。它可以集成到现有数据库或搜索引擎中，以实现高效的相似度搜索。

• LangChain 可用于构建聊天机器人、问答系统和信息检索应用程序，利用生成式和基于检索的技术来生成响应。
• 它提供了灵活性和可扩展性，允许开发人员根据特定用例和需求自定义和微调系统。

• LangChain est un cadre qui facilite l'intégration de modèles de récupération avec des modèles de langage pour des tâches de génération augmentée par récupération.
• Il fournit une interface unifiée pour la construction de chatbots et de systèmes de conversation AI avec des capacités améliorées de génération de réponses.

• Pipeline de Traitement du Langage Naturel (NLP) : LangChain intègre un pipeline NLP complet pour des tâches telles que la tokenisation, la génération d'embedding et le calcul de similarité sémantique.

• Intégration de Modèles de Récupération : LangChain intègre de manière transparente des modèles de récupération, permettant au système de récupérer des documents ou des passages pertinents en fonction de la requête d'entrée.

  • Retriever-Reader de Récupération Dense (DRQA) : Ce modèle récupère des documents pertinents d'un large corpus en utilisant des représentations vectorielles denses puis utilise un modèle lecteur pour extraire des informations pertinentes de ces documents afin de générer des réponses.
  • Modèle Conversationnel Génératif Neuronal avec Mécanisme de Récupération : Ce modèle récupère d'abord le contexte ou les réponses pertinents d'une grande base de données de conversations antérieures en utilisant des techniques de récupération d'informations puis génère des réponses basées à la fois sur le contexte récupéré et l'entrée actuelle.
  • Encodeur Dual avec Génération Augmentée par Récupération (DIALOGPT) : Cette architecture utilise un encodeur dual pour encoder à la fois la requête d'entrée et le contexte récupéré, puis génère une réponse basée sur cette représentation combinée. Il peut être ajusté sur des données conversationnelles pour générer des réponses plus contextuellement pertinentes.
  • Modèle de Récupération Séquentielle (SeqRM) : Ce modèle récupère séquentiellement des passages pertinents d'une base de connaissances et les intègre dans le processus de génération. À chaque étape de la génération, il récupère le passage le plus pertinent en fonction du contexte actuel et génère le jeton suivant en conséquence.
  • BERT pour Retriever-Reader (BRR) : Ce modèle emploie des composants retriever et reader basés sur BERT. Le retriever sélectionne des passages pertinents d'un large corpus, et le reader extrait des informations pertinentes de ces passages pour générer des réponses.
• Intégration de Modèles de Langage : Il intègre également des modèles de langage pour la génération de réponses, permettant au système de générer des réponses cohérentes et contextuellement pertinentes en incorporant des informations à la fois de la requête d'entrée et des documents récupérés.

• Interface de Base de Données Vectorielle : LangChain fournit une interface pour interagir avec les bases de données vectorielles, permettant aux utilisateurs de stocker et de récupérer efficacement des embeddings de documents pour la recherche sémantique.

  • Milvus : Milvus est une base de données vectorielle open-source conçue pour gérer et servir des embeddings vectoriels à grande échelle. Elle prend en charge une variété d'algorithmes de recherche de similarité et offre des capacités efficaces d'indexation et de requête.
  • Faiss : Développé par Facebook AI Research (FAIR), Faiss est une bibliothèque largement utilisée pour la recherche de similarité et le clustering de vecteurs denses efficaces. Elle est optimisée pour les vecteurs de haute dimension et offre des capacités d'indexation et de requête accélérées par GPU.
  • Annoy : Annoy (Approximate Nearest Neighbors Oh Yeah) est une bibliothèque C++ avec des liaisons Python pour la recherche approximative des plus proches voisins. Elle est conçue pour les tâches de recherche de similarité à grande échelle et prend en charge les implémentations CPU et GPU.
  • Pinecone : Pinecone est un service de base de données vectorielle géré qui fournit des capacités de recherche de similarité et de recommandation en temps réel. Il offre une architecture sans serveur, une mise à l'échelle automatique et une intégration avec des cadres d'apprentissage automatique populaires.
  • Elasticsearch avec Plugin Vectoriel : Elasticsearch est un moteur de recherche et d'analyse distribué qui peut être étendu avec des plugins pour supporter les données vectorielles. Le Plugin Vectoriel Elasticsearch permet l'indexation et la requête d'embeddings vectoriels, activant la recherche de similarité au sein d'Elasticsearch.
  • HNSW (Hierarchical Navigable Small World) : Bien qu'il ne soit pas une base de données autonome, HNSW est une structure de données et un algorithme couramment utilisé pour la recherche approximative des plus proches voisins. Il peut être intégré dans des bases de données ou des moteurs de recherche existants pour permettre une recherche de similarité efficace.

• LangChain peut être utilisé pour construire des chatbots, des systèmes de réponse aux questions et des applications de récupération d'informations qui tirent parti des techniques génératives et basées sur la récupération pour la génération de réponses.
• Il offre de la flexibilité et de l'extensibilité, permettant aux développeurs de personnaliser et d'ajuster le système selon des cas d'utilisation et des exigences spécifiques.

• 演示 - 我们将探索 LLM 的实现
• 上下文提示 + LLM
• 多源上下文提示 + LLM

• Démo - Nous allons explorer la mise en œuvre de LLM
• Contexte d'invite + LLM
• Contexte d'invite multi-sources + LLM

# !pip install -q torch transformers accelerate bitsandbytes transformers sentence-transformers faiss-cpu pypdf streamlit langchain==0.1.6 langchain-community==0.0.19 langchain-core==0.1.23
# !pip install -q torch transformers
# !pip install -q transformers sentence-transformers
# !pip install -q faiss-cpu pypdf streamlit
# !pip install -q langchain==0.1.6 langchain-community==0.0.19 langchain-core==0.1.23

import locale  # In Google Colab, use UTF-8 locale to install LangChain
from langchain_community.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.vectorstores import FAISS
from langchain_community.embeddings import HuggingFaceEmbeddings
from transformers import pipeline
from langchain_community.llms import HuggingFacePipeline
from langchain_core.prompts import ChatPromptTemplate
from langchain.chains import LLMChain
from langchain.schema.runnable import RunnablePassthrough
import streamlit as st

locale.getpreferredencoding = lambda: "UTF-8"

# Constants
PDF_FILE_PATH = "test_pdf.pdf"  # Update with your file path
CHUNK_SIZE = 500
CHUNK_OVERLAP = 100
OLLAMA_MODEL_NAME = "mistral"

loader = PyPDFLoader(PDF_FILE_PATH)
pages = loader.load_and_split()

print(f"Pages from the loader: {pages[0]} \n\n")

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=CHUNK_SIZE, chunk_overlap=CHUNK_OVERLAP
)
doc_splits = text_splitter.split_documents(pages)

print(f"Pages from the loader: {doc_splits} \n\n")

db = FAISS.from_documents(
    doc_splits, HuggingFaceEmbeddings(model_name="BAAI/bge-base-en-v1.5")
)
retriever = db.as_retriever(search_type="similarity", search_kwargs={"k": 4})

## Summarization
bart_model_name = "facebook/bart-large-cnn"
summarizer = pipeline("summarization", model=bart_model_name)

llm = HuggingFacePipeline(pipeline=summarizer)

prompt = ChatPromptTemplate.from_messages(
    [("system", "Summarize the story about Daisy:\n\n{context}")]
)

llm_chain = LLMChain(llm=llm, prompt=prompt)

"""**Combine the LLM + Retriever to create the RAG**"""
# retriever = db.as_retriever()
rag_chain = {"context": retriever, "question": RunnablePassthrough()} | llm_chain

# question = "Tell a story about a girl in the country side"

# print(llm_chain.invoke({"context": "", "question": question}))
# print('\n\n\n')
# print(rag_chain.invoke(question))

if __name__ == "__main__":
    st.title("Summarization with RAG Development")
    question = st.text_input("Summarize tex:", value=" ")
    if question != " ":
        st.title("Summarization - LLM Chain with no context")
        st.write(llm_chain.invoke({"context": "", "question": question})["text"])

    if question != " ":
        st.title("Summarization with RAG")
        st.write(rag_chain.invoke(question)["text"])