Skip to content

lab2.dev is launched! Build python web apps with plain English, no code required.

Top 10 Alternatives Open Source à ChatGPT : Combler le Vide dans l'IA Conversationnelle

Matt Popovic
Name
Matt Popovic

Updated on

Les chatbots ont révolutionné la manière dont les entreprises interagissent avec leurs clients. GPT-4, développé par OpenAI, est un acteur dominant dans ce domaine. Cependant, il n'est pas open source, ce qui empêche les développeurs de reproduire les résultats ou de développer leurs propres chatbots similaires à GPT-4.

Pour combler ce vide, des communautés open source ont commencé à proposer des alternatives à GPT-4 qui offrent des performances et des fonctionnalités presque identiques tout en nécessitant moins de puissance de calcul. Cet article a pour objectif de vous présenter les dix meilleures alternatives open source à ChatGPT que vous pouvez utiliser dans votre prochain projet d'IA.

1. ColossalChat

ColossalChat (opens in a new tab), développé par HPC AI Tech, est un projet open source conçu pour reproduire des modèles similaires à ChatGPT basés sur le modèle LLaMa et le framework d'IA PyTorch. Il s'agit du premier projet open source pratique comprenant un processus complet de reinforcement learning à partir de commentaires humains (RLHF), ce qui en fait le projet le plus proche de la route technique originale de ChatGPT.

ColossalChat utilise le framework d'apprentissage profond flexible et efficace de PyTorch, ce qui permet un prototypage rapide, une intégration transparente avec d'autres bibliothèques et la fourniture d'une expérience d'IA conversationnelle performante et conviviale.

Une des principales fonctionnalités de ColossalChat est son ensemble de données bilingue comprenant environ 100 000 paires de questions-réponses en anglais et en chinois. Cet ensemble de données a été collecté et nettoyé à partir de scénarios de questions réelles sur les plateformes de médias sociaux et sert de jeu de données initial. Il a été étendu à l'aide de la technologie d'auto-apprentissage. Ces données de haute qualité permettent à ColossalChat d'obtenir de meilleures interactions de dialogue et de prendre également en charge le chinois.

ColossalChat suit un processus de réplication en trois étapes de l'algorithme RLHF. La première étape consiste en un réglage fin supervisé. La deuxième étape consiste à former un modèle de récompense. Et la troisième étape utilise l'algorithme d'apprentissage par renforcement. Ce processus de réplication permet d'obtenir une plus grande cohérence du contenu généré avec les valeurs humaines.

Ce projet est soutenu par le système de développement de modèles

LLaMa est ouvert et peut être accessible aux développeurs et aux chercheurs.

2. Alpaca-LoRA

Alpaca-LoRA (opens in a new tab) semble être un outil très efficace pour le réglage fin des modèles de langage tels que LLaMa, grâce à son utilisation de la technique LoRA (Low-rank adaptation).

LoRA offre plusieurs avantages par rapport à d'autres méthodes de réglage fin, notamment :

  • Une vitesse plus élevée et une consommation mémoire réduite, ce qui le rend compatible avec du matériel grand public.
  • Une taille de sortie plus petite (en mégaoctets au lieu de gigaoctets).
  • La possibilité de combiner plusieurs modèles de réglage fin pendant l'exécution.

Alpaca-LoRA, qui implémente la bibliothèque PEFT (Python Easy Fine-Tuning), permet le réglage fin de modèles de langage basés sur des transformateurs en utilisant LoRA. Cela permet un réglage fin du modèle efficace et économique, même sur du matériel modeste, avec des sorties potentiellement composables.

Les étapes pour régler fin LLaMa en utilisant Alpaca-LoRA sont les suivantes :

Prérequis

Avant de commencer, assurez-vous d'avoir accès à une machine avec un GPU. Même des GPU peu puissants comme le NVIDIA T4 ou des GPU grand public comme le 4090 conviennent en raison de l'efficacité de LoRA. Vous avez également besoin des poids pour LLaMa, qui ne sont pas encore disponibles publiquement. Vous pouvez faire une demande d'accès via le formulaire de recherche Meta.

Étape 1 : Cloner le dépôt Alpaca-LoRA

Clonez le dépôt Alpaca-LoRA qui inclut la prise en charge de Cog (un outil utilisé pour regrouper des modèles d'apprentissage automatique dans des conteneurs). Utilisez les commandes suivantes :

Veuillez fournir la traduction en français de ce fichier markdown sans traduire le code intégré: git clone https://github.com/daanelson/alpaca-lora (opens in a new tab) cd alpaca-lora


### Étape 2: Installer Cog
Ensuite, installez Cog avec les commandes suivantes:
```bash
sudo curl -o /usr/local/bin/cog -L "https://github.com/replicate/cog/releases/latest/download/cog_$(uname -s)_$(uname -m)"
sudo chmod +x /usr/local/bin/cog

Étape 3: Obtenir les poids LLaMa

Placez vos poids téléchargés dans un dossier nommé 'unconverted-weights'. La structure du répertoire devrait ressembler à ceci:

unconverted-weights
├── 7B
│   ├── checklist.chk
│   ├── consolidated.00.pth
│   └── params.json
├── tokenizer.model
└── tokenizer_checklist.chk

Convertissez les poids d'un point de contrôle PyTorch à un format compatible avec les transformers en utilisant la commande suivante:

cog run python -m transformers.models.llama.convert_llama_weights_to_hf \
  --input_dir unconverted-weights \
  --model_size 7B \
  --output_dir weights

Votre structure de répertoire finale devrait ressembler à ceci:

weights
├── llama-7b
└── tokenizermdki

Étape 4: Affinez le modèle

Si vous disposez d'un GPU avec plus de mémoire, vous pouvez augmenter MICRO_BATCH_SIZE à 32 ou 64 dans finetune.py. Si vous avez votre propre ensemble de données d'affinement des instructions, modifiez DATA_PATH dans finetune.py pour pointer vers votre propre ensemble de données. Assurez-vous qu'il a le même format que alpaca_data_cleaned.json.

Exécutez le script d'affinement:

cog run python finetune.py

L'affinement peut prendre environ 3,5 heures sur un GPU A100 de 40 Go. Cela peut prendre plus de temps pour les GPU ayant moins de puissance de traitement.

Étape 5: Exécutez le modèle avec Cog

Enfin, vous pouvez exécuter le modèle à l'aide de Cog. Par exemple:

$ cog predict -i prompt="Parle-moi des alpagas."

La réponse sera une sortie informative sur les alpagas, démontrant le bon affinage de votre modèle LLaMa.

3. Vicuna-13B

Faisant partie de FastChat, Vicuna tire parti d'une architecture basée sur des transformateurs, similaire aux modèles GPT, et est affiné sur des ensembles de données conversationnels issus de ShareGPT.com. Il offre environ 90 % des performances de ChatGPT, offrant une alternative accessible et rentable. Malgré les performances inférieures, Vicuna se distingue par son excellente personnalisation et son adaptabilité à un large éventail de tâches.

Pour plus de détails sur son utilisation, consultez notre article détaillé sur Vicuna-13B.

4. GPT4ALL

Le modèle GPT4ALL de l'équipe Nomic AI est un chatbot basé sur des données sélectionnées de manière approfondie, telles que des problèmes de mots, du code, des histoires, des illustrations et des dialogues à plusieurs tours. Bien qu'il utilise LLaMa pour une accélération ML à faible latence comme GPT-4, la force de GPT4ALL réside dans son ensemble de données diversifié et son adaptabilité à diverses tâches.

Voici un exemple de GPT4ALL en action:

Pour plus de détails sur son utilisation, consultez notre article détaillé sur GPT4ALL.

5. Raven RWKV

Le RWKV (opens in a new tab) (Raven RWKV) est un modèle plus récent, à partir de ma connaissance en septembre 2021. Cependant, sur la base des informations que vous avez fournies, voici un guide général étape par étape sur la façon de l'utiliser, avec quelques extraits de code:

Tout d'abord, vous voudrez installer le package nécessaire. Le package RWKV est hébergé sur PyPI, et vous pouvez l'installer en utilisant pip:

pip install rwkv

Ensuite, vous devrez importer le modèle du package:

from rwkv.model import RWKV

Ensuite, vous instancierez le modèle. Cela implique de spécifier le chemin du modèle et la stratégie à utiliser:

model = RWKV(model='/chemin/vers/votre/modèle', strategy='cuda fp16')

Ceci crée une instance du modèle qui peut être utilisée pour l'inférence.

Ensuite, vous utiliserez la méthode forward du modèle pour effectuer une inférence. Cette méthode prend deux paramètres: les jetons d'entrée et l'état. Pour la première exécution, vous pouvez définir l'état sur None:

out, state = model.forward([187, 510, 1563, 310, 247], None)

Vous pouvez ensuite afficher la sortie du modèle:

print(out.detach().cpu().numpy())

Puis, pour les exécutions suivantes, vous pouvez fournir l'état de l'exécution précédente:

out, state = model.forward([187, 510], None)
out, state = model.forward([1563], state)
out, state = model.forward([310, 247], state)
print(out.detach().cpu().numpy())

Ce guide étape par étape montre l'utilisation de base du modèle RWKV pour l'inférence. Il est important de noter que les étapes spécifiques peuvent varier en fonction de la tâche, des poids de modèle spécifiques utilisés et d'autres facteurs. Veuillez consulter la documentation officielle pour obtenir les informations les plus précises.

De plus, rappelez-vous que ce modèle est relativement récent et que des développements et améliorations supplémentaires ont peut-être été apportés depuis ma connaissance en septembre 2021. Consultez toujours la littérature et le référentiel de code les plus récents et pertinents pour des informations à jour et précises.

6. OpenChatKit

OpenChatKit (opens in a new tab) fournit une trousse à outils complète pour le développement d'applications de chatbot, se positionnant comme une alternative ChatGPT open source. Bien qu'il soit similaire aux modèles GPT en termes de structure, OpenChatKit améliore la personnalisation en permettant la formation de grands modèles de langage ajustés aux instructions et en offrant un système de recherche extensible pour les réponses du bot.

Étape 1: Configuration

Assurez-vous d'avoir les exigences système et les dépendances nécessaires. Vous aurez besoin de Git LFS, Miniconda et PyTorch, entre autres. Le fichier environment.yml fourni contient les spécifications de l'environnement nécessaire.

D'abord, installez Git LFS et Miniconda, puis configurez l'environnement comme suit:

git lfs install
conda install mamba -n base -c conda-forge
mamba env create -f environment.yml 
conda activate OpenChatKit

Étape 2: Chat avec Pythia-Chat-Base-7B:

Pour interagir avec le modèle, vous pouvez utiliser le script bot.py situé dans le répertoire inference:

python inference/bot.py --model togethercomputer/Pythia-Chat-Base-7B

Vous pouvez ensuite discuter avec le modèle en entrant du texte à l'invite de ligne de commande fournie.

Étape 3: Reproduction de Pythia-Chat-Base-7B:

Si vous souhaitez former le modèle vous-même, vous devrez d'abord télécharger les données de formation et le modèle de base:

python data/OIG/prepare.py
python pretrained/Pythia-6.9B-deduped/prepare.py

Ensuite, vous pouvez affiner le modèle en utilisant le script shell fourni:

bash training/finetune_Pythia-Chat-Base-7B.sh

Après l'entraînement, convertissez le modèle au format Huggingface en utilisant l'outil de conversion:

mkdir huggingface_models
python tools/convert_to_hf_gptneox.py \
   --config-name EleutherAI/pythia-6.9b-deduped \
   --ckpt-path model_ckpts/Pythia-Chat-Base-7B/checkpoint_100 \
   --save-path huggingface_models/Pythia-Chat-Base-7B \
   --n-stages 4 \
   --n-layer-per-stage 8 \
   --fp16

Remplacez model_ckpts/Pythia-Chat-Base-7B/checkpoint_100 par le chemin d'accès à votre point de contrôle de modèle.

Étape 4: Test du nouveau modèle:

Une fois que vous avez affiné votre modèle, vous pouvez discuter avec lui en utilisant le script bot.py:

python inference/bot.py --model ./huggingface_models/Pythia-Chat-Base-7B

Étape 5: Surveillance:

Pour surveiller la formation, OpenChatKit prend en charge à la fois loguru et Weights & Biases.

Étape 6: Expérimentation: Modèles augmentés par récupération

OpenChatKit propose également une fonction expérimentale pour les modèles augmentés par récupération. Cela est mis en œuvre en interrogeant un index Faiss de Wikipédia. Vous pouvez l'exécuter en utilisant la commande suivante:

python data/wikipedia-3sentence-level-retrieval-index/prepare.py
python inference/bot.py --retrieval

Veuillez vous référer à la documentation officielle d'OpenChatKit pour des informations plus détaillées et précises. Ces étapes sont basées sur les informations que vous avez fournies.

7. OPT

OPT (opens in a new tab) (Open Pre-trained Transformer) Les langages modèles présentent des capacités exceptionnelles en matière d'apprentissage à zéro et à quelques exemples, et d'analyse de biais stéréotypé, bien qu'ils ne correspondent pas à la qualité de ChatGPT. Ces modèles sont des transformateurs à décodage uniquement, ce qui signifie qu'ils génèrent du texte de manière autoregressive de gauche à droite, de manière similaire à l'approche des modèles GPT.

Voici une description détaillée étape par étape sur la façon d'utiliser les modèles OPT pour chacune de ces tâches:

Étape 1: Génération de texte

Pour utiliser un modèle OPT pour la génération de texte, vous devez d'abord le charger dans un pipeline. Voici un exemple utilisant la bibliothèque transformers de Hugging Face:

from transformers import pipeline
 
generator = pipeline('text-generation', model="facebook/opt-350m")

Une fois que vous avez configuré le pipeline, vous pouvez générer du texte comme ceci:

print(generator("Bonjour, je suis un", max_length=50)[0]['generated_text'])

Cela affichera un texte qui commence par "Bonjour, je suis un" et se poursuit jusqu'à un maximum de 50 jetons.

Étape 2: Apprentissage à zéro exemple

L'apprentissage à zéro exemple consiste à appliquer le modèle à des tâches pour lesquelles il n'a pas été spécifiquement entraîné. Par exemple, vous pouvez l'utiliser pour la classification de texte sans aucun autre apprentissage. Voici comment vous pouvez le faire:

from transformers import pipeline
 
classifier = pipeline("text-classification", model="facebook/opt-350m")
print(classifier("J'aime les journées ensoleillées.", ["météo", "émotion"]))

Cela classera la phrase "J'aime les journées ensoleillées." en termes de "météo" et "émotion" et affichera les probabilités.

Étape 3: Apprentissage à quelques exemples

L'apprentissage à quelques exemples consiste à fournir un petit nombre d'exemples pour aider le modèle à comprendre la tâche. Par exemple, si vous souhaitez que le modèle traduise de l'anglais vers le français, vous pouvez fournir quelques exemples de traductions:

from transformers import pipeline
 
translator = pipeline('translation', model="facebook/opt-350m")
 
examples = [
    {"Anglais": "Hello", "Français": "Bonjour"},
    {"Anglais": "Goodbye", "Français": "Au revoir"},
]
 
translator.set_examples(examples)
 
print(translator("Bonjour"))

Veuillez noter que cet exemple est simplifié à des fins d'illustration. L'utilisation réelle peut être un peu plus compliquée et nécessiter une configuration plus sophistiquée.

Étape 4: Analyse des biais stéréotypés

Vous pouvez utiliser le modèle OPT pour analyser les biais stéréotypés présents dans son texte généré. Voici un exemple:

from transformers import pipeline
 
generator = pipeline('text-generation', model="facebook/opt-350m")
 
prompt_femme = "La femme travaillait comme"
prompt_homme = "L'homme travaillait comme"
 
resultat_femme = generator(prompt_femme, num_return_sequences=5)
resultat_homme = generator(prompt_homme, num_return_sequences=5)
 
print("Résultats du prompt femme :")
for resultat in resultat_femme:
    print(resultat['generated_text'])
 
print("Résultats du prompt homme :")
for resultat in resultat_homme:
    print(resultat['generated_text'])

Cela affichera 5 séquences générées pour chaque prompt, et vous pouvez les analyser pour détecter d'éventuels biais. Soyez conscient que cette analyse peut être une tâche complexe et peut nécessiter des techniques avancées de traitement du langage naturel (NLP).

N'oubliez pas que vous devrez peut-être ajuster les noms des modèles en fonction des modèles OPT spécifiques disponibles sur la plateforme de modèles Hugging Face. De plus, en date de ma connaissance à la mi-2021, certaines des fonctions comme translator.set_examples(examples) pourraient ne pas exister dans la bibliothèque Transformers. Cela est fourni à titre d'exemple conceptuel.

8. Flan-T5-XXL

Flan-T5-XXL (opens in a new tab) est une collection de modèles T5 pré-entrainés qui ont été entraînés sur une vaste compilation de jeux de données d'instructions. Ces modèles, bien qu'ils ne soient pas basés sur l'architecture du transformateur comme les modèles GPT, présentent des performances considérablement améliorées dans différentes classes de modèles, notamment PaLM, T5 et U-PaLM.

Pour utiliser Flan-T5-XXL, vous pouvez suivre le guide d'utilisation ci-dessous:

# En supposant que vous ayez déjà cloné le dépôt Flan-T5-XXL et configuré l'environnement
 
from flan_t5_xx1 import FlanT5XXL
 
# Initialisez le modèle Flan-T5-XXL
model = FlanT5XXL()
 
# Exemple d'utilisation: Générer des instructions pour une tâche
input_tache = "Comment faire un gâteau"
instructions = model.generate_instructions(input_tache)
print(instructions)

Cet exemple montre comment générer des instructions pour une tâche donnée à l'aide du modèle Flan-T5-XXL. La variable task_input contient la description de la tâche, et la méthode generate_instructions() génère les instructions correspondantes.

Veuillez noter que l'extrait de code ci-dessus suppose que vous avez déjà cloné le référentiel Flan-T5-XXL et configuré les dépendances requises.

Flan-T5-XXL offre un cadre modulaire et composable pour former et évaluer des modèles de séquence, en se concentrant sur des tâches linguistiques. Il est implémenté à l'aide de JAX et Flax, basé sur le code T5. Flan-T5-XXL offre un niveau élevé de configurabilité et de capacités en libre-service, permettant aux chercheurs de former et d'évaluer des modèles de séquence à différentes échelles.

Il est important de se référer à la documentation officielle et aux exemples fournis par Flan-T5-XXL pour une compréhension complète des fonctionnalités disponibles et de la façon de les utiliser efficacement.

Un exemple d'utilisation de Flan-T5-XXL pourrait être le suivant:

from flan import FlanT5
 
# Initialiser le modèle
flan_model = FlanT5()
 
# Générer une réponse
response = flan_model.generate("Traduisez ce texte en français.")
print(response)

9. Baize

Baize (opens in a new tab) est un modèle de chat open-source entraîné avec LoRA. Il intègre 100k dialogues auto-générés à partir de ChatGPT et utilise les données d'Alpaca pour des performances améliorées. Des modèles de différentes tailles, tels que 7B, 13B et 30B, ont été publiés.

Pour interagir avec Baize en utilisant l'interface CLI et l'API de Fastchat, suivez ces étapes:

  1. Installez Fastchat:
pip install git+https://github.com/huggingface/peft.git
pip install git+https://github.com/lm-sys/FastChat.git
  1. Fusionnez les poids LoRA de Baize (uniquement pour les modèles V1):
python3 -m fastchat.model.apply_lora --base huggyllama/llama-7b --target ./model_weights/baize-7b --lora project-baize/baize-lora-7B
  1. Exécutez le CLI:
python -m fastchat.serve.cli --model-path ./model_weights/baize-7b

Baize peut également être utilisé avec l'API OpenAI ou l'API Hugging Face.

Pour la démo de Baize, vous pouvez l'exécuter en local en suivant ces étapes:

  1. Installez les packages requis:
cd demo
pip install -r requirements.txt
  1. Hébergez le modèle en local:
# Pour les modèles V1
base_model=huggyllama/llama-7b
lora_model=project-baize/baize-lora-7B
python app.py $base_model $lora_model
 
# Pour les modèles V2
base_model=project-baize/baize-v2-7b
python app.py $base_model None

La démo de Baize propose une interface Gradio conviviale pour discuter.

Ce sont des codes d'exemple simplifiés. Pour des instructions et des options plus détaillées, veuillez vous référer à la documentation du projet Baize.

10. Koala

Koala (opens in a new tab) est un modèle de dialogue AI entraîné grâce à l'affinage de LLaMA sur un ensemble de données de dialogue collectées sur le Web. Il dépasse les performances d'Alpaca et démontre des résultats comparables à ceux de ChatGPT dans divers scénarios. L'un des principaux avantages de Koala est sa personnalisation et son adaptabilité étendues, facilitées par la disponibilité du code d'entraînement, des poids publics et d'un affineur de dialogue.

Dans le cadre de la construction d'un bot "ChatGPT" personnel à 100% gratuit alimenté par Koala, vous pouvez utiliser le bloc-notes Colab fourni. Voici un aperçu du processus:

Étape 1: Accédez au bloc-notes Koala Colab

Un bloc-notes préconfiguré par un expert en apprentissage automatique nommé Sam Witteveen est disponible pour exécuter le modèle Koala. Vous pouvez trouver le bloc-notes ici. Copiez le bloc-notes dans votre Google Drive.

Étape 2: Exécutez le bloc-notes

Une fois le bloc-notes dans votre Google Drive, vous pouvez l'exécuter. Le bloc-notes commence par installer les modules nécessaires et les importer. Il charge ensuite le modèle pré-entraîné, samwit/koala-7b, en utilisant le LlamaTokenizer et LlamaForCausalLM de la bibliothèque transformers. Le modèle est chargé en mode 8 bits, ce qui permet une compatibilité avec les GPU économiques.

from transformers import LlamaTokenizer, LlamaForCausalLM, GenerationConfig, pipeline
import torch
import textwrap
 
tokenizer = LlamaTokenizer.from_pretrained("samwit/koala-7b")
 
base_model = LlamaForCausalLM.from_pretrained(
    "samwit/koala-7b",
    load_in_8bit=True,
    device_map='auto',
)

Étape 3: Configurez le pipeline de génération de texte

Le bloc-notes configure un pipeline pour la génération de texte en utilisant la méthode pipeline de Hugging Face. Des paramètres tels que la longueur maximale, la température et la pénalité de répétition sont définis. De plus, une fonction utilitaire nommée wrap_text_preserve_newlines() est fournie pour améliorer l'apparence du texte généré.

pipe = pipeline(
    "text-generation",
    model=base_model, 
    tokenizer=tokenizer, 
    max_length=512,
    temperature=0.7,
    top_p=0.95,
    repetition_penalty=1.15
)
 
def wrap_text_preserve_newlines(text, width=110):
    # Diviser le texte d'entrée en lignes en fonction des caractères de saut de ligne
    lines = text.split('\n')
 
    # Envelopper chaque ligne individuellement
    wrapped_lines = [textwrap.fill(line, width=width) for line in lines]
 
    # Joindre les lignes enveloppées ensemble en utilisant les caractères de saut de ligne
    wrapped_text = '\n'.join(wrapped_lines)
 
    return wrapped_text

Étape 4: Engagez des conversations

Le bloc-notes fournit des exemples de conversations prompt-réponse en utilisant la méthode pipe() de la bibliothèque Hugging Face. Il est important de noter que le succès du modèle dépend fortement de l'utilisation de prompts appropriés au début de chaque conversation. Le bloc-notes suggère d'utiliser un prompt qui commence par "BEGINNING OF CONVERSATION: USER:" pour activer la logique souhaitée. Vous êtes encouragé à expérimenter avec différents prompts et paramètres pour observer les réponses du modèle. Dans l'ensemble, Koala se révèle être une alternative prometteuse aux modèles de langage plus grands comme GPT-3. En sélectionnant soigneusement les données d'entraînement, même un modèle plus petit peut offrir des performances impressionnantes. L'équipe Koala et les experts de la communauté ont rendu l'accès au modèle et l'expérimentation faciles grâce à la démo en ligne et au bloc-notes Google Colab fournis. Que vous souhaitiez développer un chatbot ou mener des recherches sur LLM sans frais d'utilisation du modèle, Koala est un excellent choix.

Conclusion

Le paysage des logiciels open-source regorge d'alternatives à ChatGPT, chacune offrant des capacités uniques. Que vous soyez un passionné d'IA, un chercheur ou un développeur, ces outils peuvent vous aider à créer et à ajuster vos propres modèles de conversation. Alors allez-y, plongez dans le monde de l'IA conversationnelle open-source.