Ce que vous pouvez faire avec les modèles d'OpenAI est fascinant. De plus, des outils tels que LangChain et llama-index facilitent la mise en place d'un système de base de type ChatGPT en quelques lignes de code. Cependant, la plupart des exemples s'appuient sur les API d'OpenAI, ce qui n'est pas pratique dans tous les cas, par exemple parce que vous ne pouvez pas envoyer vos données dans le cloud ou que vous ne pouvez pas dépenser d'argent .

Comme j'ai récemment essayé de faire fonctionner un système de base à l'aide du chariot de databrick et qu'il fallait un peu d'essais et d'erreurs, voici mon tutoriel rapide sur la façon d'utiliser un LLM ouvert et personnalisé pour créer une interface de discussion avec vos propres données !

Étape 1 : Collectez vos données et installez les dépendances

Pour cette étape, collectez simplement toutes les données que vous souhaitez utiliser et placez-les dans un répertoire sur votre machine locale. Dans mon cas, il s'agissait d'un tas de fichiers de démarquage que j'ai extraits de la documentation de notre outil de curation de données Spotlight (vérifiez-le aussi ;-)).

Ensuite, installez tout ce dont vous avez besoin :

pip install torch transformers langchain llama-index====0.6.0.alpha3

Copiez le code suivant et ajustez le chemin d'accès à votre dossier d'entrée. Il utilise la bibliothèque de transformateurs Huggingface pour générer des intégrations à récupérer et le chariot de databrick pour générer la sortie finale.

from pathlib import Path
import torch
from transformers import pipeline
from langchain.llms.base import LLM
from llama_index import SimpleDirectoryReader, LangchainEmbedding, GPTVectorStoreIndex, PromptHelper, LLMPredictor, ServiceContext
from llama_index.langchain_helpers.text_splitter import TokenTextSplitter
from llama_index.node_parser.simple import SimpleNodeParser
from langchain.embeddings.huggingface import HuggingFaceEmbeddings

INPUT_FOLDER = "path/to/your/data/folder"

index_files = list(Path(INPUT_FOLDER).glob("*"))

max_input_size = 2048
num_output = 256
max_chunk_overlap = 20
prompt_helper = PromptHelper(max_input_size, num_output, max_chunk_overlap)


pipe = pipeline("text-generation", model="databricks/dolly-v2-3b", trust_remote_code=True, torch_dtype=torch.bfloat16, device_map="auto")
embed_model = LangchainEmbedding(HuggingFaceEmbeddings())

class CustomLLM(LLM):
    model_name = "databricks/dolly-v2-3b"

    def _call(self, prompt, stop = None):
        response = pipe(prompt, max_new_tokens=num_output)[0]["generated_text"]
        return response

    @property
    def _identifying_params(self):
        return {"name_of_model": self.model_name}

    @property
    def _llm_type(self):
        return "custom"

# define our LLM
llm_predictor = LLMPredictor(llm=CustomLLM())

node_parser = SimpleNodeParser(text_splitter=TokenTextSplitter(chunk_size=512, chunk_overlap=max_chunk_overlap))
prompt_helper = PromptHelper(max_input_size, num_output, max_chunk_overlap)
service_context = ServiceContext.from_defaults(llm_predictor=llm_predictor, embed_model=embed_model, prompt_helper=prompt_helper, node_parser=node_parser, chunk_size_limit=512)
# Load your data
documents = SimpleDirectoryReader(input_files=index_files).load_data()

index = GPTVectorStoreIndex.from_documents(documents, service_context=service_context)

query_engine = index.as_query_engine()

Étape 3 : Utilisez votre système

Nous avons déjà terminé ! Vous pouvez désormais utiliser l' objet moteur de requête pour poser des questions sur vos données !

Un exemple d'invite que j'ai essayé sur nos documents ressemble à ceci :

print(query_engine.query("Summarize typical use cases of the similarity map in few sentences."))

The Similarity Map helps to explore simulation similarities and find explanations for observable phenomens.
It can be used to group designs by similarity, find outliers and detect correlations between features and target values.