EasyLLM : Simplifiez le traitement du modèle de langage et réalisez une commutation transparente entre les clients OpenAI et Hugging Face

avant-propos

Au cours de cette courte période de moins d'un an, les modèles linguistiques à grande échelle (LLM) qui ont émergé au pays et à l'étranger peuvent être décrits comme une centaine de fleurs épanouies, et de très bons modèles ont émergé, qu'ils soient open source ou fermé. Cependant, lorsque vous utilisez LLM pour le développement d'applications, vous constaterez qu'il existe plus ou moins de différences dans chaque modèle, du déploiement à la formation, au réglage fin, au développement d'interface API, au format de mot d'invite, etc. C'est plus compliqué, pas si pratique à utiliser et pas facile à entretenir.

Premièrement, le processus d'utilisation et de déploiement de LLM est relativement compliqué. Il existe des différences entre les différents fournisseurs et cadres LLM, ce qui entraîne un travail fastidieux de configuration et d'adaptation pour les utilisateurs. Par exemple, il peut y avoir des incompatibilités entre l'utilisation de l'API de complétion d'OpenAI, ChatCompletion, Completion et Embedding et les fonctions correspondantes utilisant Hugging Face, obligeant les utilisateurs à modifier manuellement le code pour s'adapter à différents modèles.

Deuxièmement, le format d'invite du LLM est également un problème. Différents LLM peuvent utiliser différents formats d'invite, nécessitant une conversion de format lors du basculement entre différents modèles. Cela entraîne une charge de travail et des coûts d'apprentissage supplémentaires pour les utilisateurs.

De plus, le temps de réponse du LLM est également un facteur à prendre en compte. Dans certains scénarios, en particulier ceux qui nécessitent une interaction en temps réel, attendre que l'ensemble du LLM finisse de générer des résultats peut entraîner des retards et des inconvénients.

Afin de résoudre les problèmes ci-dessus, EasyLLM a vu le jour, ce qui peut nous aider à résoudre facilement ces problèmes.

1. Introduction à EasyLLM

EasyLLM est un projet open source visant à simplifier et à améliorer le processus de traitement des LLM. Il fournit un client compatible qui permet aux utilisateurs de basculer facilement entre différents LLM en modifiant une seule ligne de code. De plus, EasyLLM fournit également un assistant rapide pour aider les utilisateurs à convertir entre différents formats LLM. De plus, EasyLLM prend en charge le streaming, les utilisateurs peuvent obtenir immédiatement des résultats partiels générés sans attendre la réponse complète.

La première version d'EasyLLM implémente un client compatible avec l'API de complétion d'OpenAI. Cela signifie que vous pouvez facilement remplacer openai.ChatCompletion, openai.Completion, openai.Embeddingpar huggingface.ChatCompletion, huggingface.Completionou huggingface.Embedding. Il suffit de le remplacer en modifiant une ligne de code.

Grâce à EasyLLM, nous pouvons utiliser et appliquer différents modèles de LLM plus facilement, améliorant ainsi l'efficacité et la flexibilité du travail. Ensuite, plongeons dans les principales caractéristiques et fonctions d'EasyLLM et comment cela peut nous apporter une meilleure expérience LLM.

2. Caractéristiques d' EasyLLM

Vous trouverez ci-dessous une liste des fonctionnalités actuelles

• Client compatible - Implémente un client compatible avec l'API d'OpenAI ChatCompletion, et . Basculez facilement entre différents LLM en modifiant une seule ligne de code.CompletionEmbedding

• Prompt Helper - Utilitaire pour aider à convertir les invites entre différents formats de LLM. Par exemple, passez du format de message OpenAI aux conseils pour des modèles comme LLaMA.

• Prise en charge du streaming - Diffusez les résultats d'achèvement de votre LLM au lieu d'attendre la réponse complète. Idéal pour des choses comme les interfaces de chat.

Plans jusqu'à présent :

• evol_instruct(en cours) - est une méthode de création d'instructions à l'aide de LLM qui peut transformer des instructions simples en instructions complexes.

• prompt_utils- Les méthodes d'assistance peuvent facilement convertir entre des formats d'astuces comme les messages OpenAI et des astuces de modèles open source comme Llama 2.

• sagemakerLes clients peuvent facilement interagir avec LLM déployé sur Amazon SageMaker

3. Premiers pas avec EasyLLM

Installez EasyLLM via pip :

pip install easyllm

Importez ensuite un client et commencez à l'utiliser :

from easyllm.clients import huggingface

# D定义要使用的提示
huggingface.prompt_builder = "llama2"
# huggingface.api_key="hf_xxx" # change api key if needed

response = huggingface.ChatCompletion.create(
    model="meta-llama/Llama-2-70b-chat-hf",
    messages=[
        {"role": "system", "content": "\nYou are a helpful assistant speaking like a pirate. argh!"},
        {"role": "user", "content": "What is the sun?"},
    ],
      temperature=0.9,
      top_p=0.6,
      max_tokens=256,
)

print(response)

Résultat de sortie :

{
  "id": "hf-lVC2iTMkFJ",
  "object": "chat.completion",
  "created": 1690661144,
  "model": "meta-llama/Llama-2-70b-chat-hf",
  "choices": [
    {
      "index": 0,
      "message": {
        "role": "assistant",
        "content": " Arrrr, the sun be a big ol' ball o' fire in the sky, me hearty! It be the source o' light and warmth for our fair planet, and it be a mighty powerful force, savvy? Without the sun, we'd be sailin' through the darkness, lost and cold, so let's give a hearty \"Yarrr!\" for the sun, me hearties! Arrrr!"
      },
      "finish_reason": null
    }
  ],
  "usage": {
    "prompt_tokens": 111,
    "completion_tokens": 299,
    "total_tokens": 410
  }
}

Consultez la documentation pour plus d'exemples et des instructions d'utilisation détaillées. Le code est sur GitHub .

4. Client EasyLLM

Dans le contexte d'EasyLLM, "client" fait référence au code qui interagit avec une API LLM spécifique (comme OpenAI). Les clients actuellement pris en charge sont :

• ChatCompletion- ChatCompletion est utilisé pour interagir avec les LLM compatibles avec l'API OpenAI ChatCompletion.

• Completion- Pour interagir avec les LLM compatibles avec l'API OpenAI Completion.

• Embedding- Pour interagir avec les LLM compatibles avec l'API OpenAI Embedding.

5. Compatible avec le client Hugging Face

EasyLLM fournit un client qui s'interface avec le modèle HuggingFace. Le client est compatible avec l'API d'inférence HuggingFace , les points de terminaison d'inférence Hugging Face ou tout service Web qui exécute l'inférence générant du texte ou des points de terminaison d'API compatibles.

• huggingface.ChatCompletion- Un client pour interagir avec le modèle HuggingFace, compatible avec l'API OpenAI ChatCompletion.

• huggingface.Completion- Client d'interfaçage avec les modèles HuggingFace compatibles avec l'API OpenAI Completion.

• huggingface.Embedding- Client pour l'interfaçage avec les modèles HuggingFace compatibles avec l'API OpenAI Embedding.

5.1、huggingface.ChatCompletion

Ce huggingface.ChatCompletionclient est utilisé pour interagir avec les modèles HuggingFace exécutés sur l'inférence de génération de texte qui sont compatibles avec l'API OpenAI ChatCompletion.

from easyllm.clients import huggingface

# hubbingface模块会自动从环境变量HUGGINGFACE_TOKEN或HuggingFace CLI配置文件中加载HuggingFace API密钥。
# huggingface.api_key="hf_xxx"
hubbingface.prompt_builder = "llama2"

response = huggingface.ChatCompletion.create(
    model="meta-llama/Llama-2-70b-chat-hf",
    messages=[
        {"role": "system", "content": "\nYou are a helpful, respectful and honest assistant."},
        {"role": "user", "content": "Knock knock."},
    ],
    temperature=0.9,
    top_p=0.6,
    max_tokens=1024,
)

Les paramètres pris en charge sont :

• model- Le modèle utilisé pour générer le résultat fini. Si elle n'est pas fournie, l'URL de base est utilisée par défaut.

• messages- List[ChatMessage]Liste des messages de chat pour générer des résultats d'achèvement.

• temperature- Le paramètre de température utilisé pour générer le résultat final. La valeur par défaut est 0,9.

• top_p- Le paramètre top_p utilisé pour générer les résultats de complétion. La valeur par défaut est 0,6.

• top_k- Le paramètre top_k pour générer des résultats terminés. La valeur par défaut est 10.

• n- Le nombre de résultats terminés à générer. La valeur par défaut est 1.

• max_tokens- Le nombre maximum de jetons à générer. La valeur par défaut est 1024.

• stop- Une séquence d'arrêt pour générer des résultats finis. La valeur par défaut est Aucun.

• stream- Que ce soit pour diffuser les résultats d'achèvement. Le défaut est faux.

• frequency_penalty- Paramètre de pénalité de fréquence pour générer des complétions. La valeur par défaut est 1.0.

• debug- S'il faut activer la journalisation de débogage. Le défaut est faux.

5.2、huggingface.Achèvement

Ce huggingface.Completionclient est utilisé pour interagir avec les modèles HuggingFace exécutés sur l'inférence de génération de texte, qui sont compatibles avec l'API OpenAI Completion.

from easyllm.clients import huggingface

# hubbingface模块会自动从环境变量HUGGINGFACE_TOKEN或HuggingFace CLI配置文件中加载HuggingFace API密钥。
# huggingface.api_key="hf_xxx"
hubbingface.prompt_builder = "llama2"

response = huggingface.Completion.create(
    model="meta-llama/Llama-2-70b-chat-hf",
    prompt="What is the meaning of life?",
    temperature=0.9,
    top_p=0.6,
    max_tokens=1024,
)

Les paramètres pris en charge sont :

• model- Le modèle utilisé pour générer le résultat fini. Si elle n'est pas fournie, l'URL de base est utilisée par défaut.

• prompt- Texte à utiliser pour l'achèvement, si prompt_builder est défini, l'invite sera formatée à l'aide de prompt_builder.

• temperature- Le paramètre de température utilisé pour générer le résultat final. La valeur par défaut est 0,9.

• top_p- Le paramètre top_p utilisé pour générer les résultats de complétion. La valeur par défaut est 0,6.

• top_k- Le paramètre top_k pour générer des résultats terminés. La valeur par défaut est 10.

• n- Le nombre de résultats terminés à générer. La valeur par défaut est 1.

• max_tokens- Le nombre maximum de jetons à générer. La valeur par défaut est 1024.

• stop- Une séquence d'arrêt pour générer des résultats finis. La valeur par défaut est Aucun.

• stream- Que ce soit pour diffuser les résultats d'achèvement. Le défaut est faux.

• frequency_penalty- Paramètre de pénalité de fréquence pour générer des complétions. La valeur par défaut est 1.0.

• debug- S'il faut activer la journalisation de débogage. Le défaut est faux.

• echo- Que ce soit pour faire écho à l'invite. Le défaut est faux.

• logprobs- S'il faut retourner logprobs (log probabilités). La valeur par défaut est Aucun.

5.3、huggingface.Incorporation

Ce huggingface.Embeddingclient est utilisé pour interagir avec les modèles HuggingFace fonctionnant comme une API compatible avec l'API OpenAI Embedding.

from easyllm.clients import huggingface

# hubbingface模块会自动从环境变量HUGGINGFACE_TOKEN或HuggingFace CLI配置文件中加载HuggingFace API密钥。
# huggingface.api_key="hf_xxx"

embedding = huggingface.Embedding.create(
    model="sentence-transformers/all-MiniLM-L6-v2",
    text="What is the meaning of life?",
)

len(embedding["data"][0]["embedding"])

Les paramètres pris en charge sont :

• model- Utilisé pour créer des modèles intégrés. S'il n'est pas fourni, la valeur par défaut est l'URL de base.

• input- Union[str, List[str]]Le document à intégrer.

5.4. Configuration de l'environnement

Le client peut être configuré en définissant la variable d'environnement Hugging Face ou en remplaçant la valeur par défaut. Voici comment régler les générateurs de jetons HF, d'URL et d'indices.

5.4.1. Définir le jeton HF

Par défaut, huggingfacele client tentera de lire HUGGINGFACE_TOKENles variables d'environnement. S'il n'est pas défini, il essaiera ~/.huggingfacede lire le jeton à partir du dossier. S'il n'est pas défini, aucun jeton ne sera utilisé.

Alternativement, vous pouvez définir manuellement le jeton via les paramètres huggingface.api_key.

Définissez la clé API manuellement :

from easyllm.clients import huggingface

huggingface.api_key="hf_xxx"

res = huggingface.ChatCompletion.create(...)

Utilisez des variables d'environnement :

import os
os.environ["HUGGINGFACE_TOKEN"] = "hf_xxx"

from easyllm.clients import huggingface

5.4.2. Modifier l'adresse URL

Par défaut, Hugging Facele client tentera de lire HUGGINGFACE_API_BASEles variables d'environnement. Si cette variable n'est pas définie, elle utilisera l'adresse URL par défaut :

https://api-inference.huggingface.co/models

Ceci est utile si vous souhaitez utiliser une adresse URL différente (telle que https://zj5lt7pmzqzbp0d1.us-east-1.aws.endpoints.huggingface.cloud) ou une adresse URL locale (telle que http://localhost:8000 ) ou Hugging Face inference endpoint très utile.

De plus, vous pouvez huggingface.api_basedéfinir manuellement l'adresse URL via les paramètres. Si vous définissez une adresse URL personnalisée, vous devez laisser modelle paramètre vide.

Définissez manuellement la base de l'API :

from easyllm.clients import huggingface

huggingface.api_base="https://my-url"


res = huggingface.ChatCompletion.create(...)

Utilisez des variables d'environnement :

import os
os.environ["HUGGINGFACE_API_BASE"] = "https://my-url"

from easyllm.clients import huggingface

5.4.3, Conseils de construction

Par défaut, huggingfacele client tentera de lire HUGGINGFACE_PROMPTles variables d'environnement et tentera de mapper les valeurs aux PROMPT_MAPPINGdictionnaires. S'il n'est pas défini, il utilisera le générateur d'indices par défaut. Vous pouvez également le définir manuellement.

Configurez manuellement le générateur d'indices :

from easyllm.clients import huggingface

huggingface.prompt_builder = "llama2"

res = huggingface.ChatCompletion.create(...)

Utilisez des variables d'environnement :

import os
os.environ["HUGGINGFACE_PROMPT"] = "llama2"

from easyllm.clients import huggingface

6. Migrer d'OpenAI vers HuggingFace

Migrer d'OpenAI vers HuggingFace est facile. Modifiez simplement l'instruction d'importation et le client à utiliser, ainsi que le générateur d'indices facultatif.

- import openai
+ from easyllm.clients import huggingface
+ huggingface.prompt_builder = "llama2"


- response = openai.ChatCompletion.create(
+ response = huggingface.ChatCompletion.create(
-    model="gpt-3.5-turbo",
+    model="meta-llama/Llama-2-70b-chat-hf",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Knock knock."},
    ],
)

Assurez-vous que vos hyperparamètres sont toujours valides lorsque vous basculez entre différents clients (c'est-à-dire en utilisant différents modèles ou systèmes). Par exemple, le paramètre de température du modèle GPT-3 peut être différent du paramètre de température du modèle Llama-2.

Les hyperparamètres sont des paramètres utilisés dans l'apprentissage automatique et l'apprentissage en profondeur pour ajuster le comportement et les performances du modèle. L'un des hyperparamètres courants est la température, qui contrôle la diversité et le caractère aléatoire du texte généré. Différents modèles peuvent avoir des exigences ou des valeurs par défaut différentes pour le paramètre de température, donc lors du basculement entre différents modèles, il faut veiller à ce que les paramètres des hyperparamètres correspondent au modèle utilisé pour obtenir les résultats attendus.

7. Info-bulle

Le module prompt_utils contient des fonctions permettant de convertir un dictionnaire de messages en invites pouvant être utilisées avec le client ChatCompletion.

Les formats d'invite actuellement pris en charge sont :

• Lama 2

• Vigogne

• Visage étreignant ChatML

• AssistantLM

• StableBeluga2

• Ouvrir l'assistant

Les utilitaires d'invite exportent également un dictionnaire de mappage PROMPT_MAPPING qui mappe un nom de modèle à un constructeur d'invite. Le constructeur d'indice correct peut être sélectionné via une variable d'environnement.

PROMPT_MAPPING = {
    "chatml_falcon": build_chatml_falcon_prompt,
    "chatml_starchat": build_chatml_starchat_prompt,
    "llama2": build_llama2_prompt,
    "open_assistant": build_open_assistant_prompt,
    "stablebeluga": build_stablebeluga_prompt,
    "vicuna": build_vicuna_prompt,
    "wizardlm": build_wizardlm_prompt,
}

Le code suivant illustre la configuration du générateur d'indices pour le client Hugging Face

from easyllm.clients import huggingface

# vicuna, chatml_falcon, chatml_starchat, wizardlm, stablebeluga, open_assistant
huggingface.prompt_builder = "llama2" 

7.1. Constructeur de chat LLama 2

Conseils pour créer des sessions de chat LLama 2. Des conseils sur l'utilisation de LLama 2 sont disponibles sur le blog Hugging Face. Si un message avec un rôle non pris en charge est transmis, une erreur sera générée.

Exemple de modèle :

• méta-lama/Llama-2-70b-chat-hf

from easyllm.prompt_utils import build_llama2_prompt

messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain asynchronous programming in the style of the pirate Blackbeard."},
]
prompt = build_llama2_prompt(messages)

7.2. Générateur de chat Vicuna

Conseils pour créer des conversations de chat Vicuna. Si un message avec un rôle non pris en charge est transmis, une erreur sera générée.

Exemple de modèle :

• ehartford/WizardLM-13B-V1.0-Non censuré

from easyllm.prompt_utils import build_vicuna_prompt

messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain asynchronous programming in the style of the pirate Blackbeard."},
]
prompt = build_vicuna_prompt(messages)

7.3. Étreignant le visage ChatML Builder

Conseils pour créer Hugging Face ChatMLdes conversations de chat. Hugging Face ChatML propose différentes astuces pour différents exemples de modèles, tels que StarChatou Falcon. Si un message avec un rôle non pris en charge est transmis, une erreur sera générée.

Exemple de modèle :

• HuggingFaceH4/starchat-bêta

7.3.1, StarChat

from easyllm.prompt_utils import build_chatml_starchat_prompt

messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain asynchronous programming in the style of the pirate Blackbeard."},
]
prompt = build_chatml_starchat_prompt(messages)

7.3.2、Faucon

from easyllm.prompt_utils import build_chatml_falcon_prompt

messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain asynchronous programming in the style of the pirate Blackbeard."},
]
prompt = build_chatml_falcon_prompt(messages)

7.4. Générateur de chat WizardLM

Conseils pour créer des sessions de chat WizardLM. Si un message avec un rôle non pris en charge est transmis, une erreur sera générée.

Exemple de modèle :

• AssistantLM/WizardLM-13B-V1.2

from easyllm.prompt_utils import build_wizardlm_prompt

messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain asynchronous programming in the style of the pirate Blackbeard."},
]
prompt = build_wizardlm_prompt(messages)

7.5. Générateur de chat StableBeluga2

Conseils pour créer des sessions de chat StableBeluga2. Si un message avec un rôle non pris en charge est transmis, une erreur sera générée.

from easyllm.prompt_utils import build_stablebeluga_prompt

messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain asynchronous programming in the style of the pirate Blackbeard."},
]
prompt = build_stablebeluga_prompt(messages)

7.6. Ouvrir le générateur de chat de l'assistant

Créez un modèle Open Assistant ChatML. Utilisez les balises <|prompter|>, et . Si un message avec un rôle non pris en charge est transmis, une erreur sera générée.</s><|system|><|assistant|>

Exemple de modèle :

• OpenAssistant/llama2-13b-orca-8k-3319

from easyllm.prompt_utils import build_open_assistant_prompt

messages=[
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Explain asynchronous programming in the style of the pirate Blackbeard."},
]
prompt = build_open_assistant_prompt(messages)

8. Cas d'application

Voici quelques exemples pour vous aider à démarrer avec la bibliothèque easyllm :

exemple	décrire
Exemple détaillé d'achèvement de chat https://philschmid.github.io/easyllm/examples/chat-completion-api/	Montre comment utiliser l'API ChatCompletion pour avoir une conversation conversationnelle avec un modèle
Exemple de comment diffuser des demandes de chat https://philschmid.github.io/easyllm/examples/stream-chat-completions/	Démontre la diffusion en continu de plusieurs demandes de chat pour discuter efficacement avec un modèle.
Exemple de diffusion de complétions de texte https://philschmid.github.io/easyllm/examples/stream-text-completions/	Montre comment diffuser plusieurs requêtes de complétion de texte.
Exemple d'achèvement détaillé https://philschmid.github.io/easyllm/examples/text-completion-api/	Générez du texte à partir d'un modèle à l'aide de l'API TextCompletion.
Créer des intégrations https://philschmid.github.io/easyllm/examples/get-embeddings/	Utilisez le modèle pour incorporer du texte dans des représentations vectorielles.
Hug face inference endpoint example https://philschmid.github.io/easyllm/examples/inference-endpoints-example/	Exemples d'utilisation de points de terminaison personnalisés tels que les points de terminaison d'inférence ou localhost
Utilisation de la génération améliorée de récupération de Llama 2 https://philschmid.github.io/easyllm/examples/llama2-rag-example/	Exemple d'utilisation de Llama 2 70B pour l'amélioration de la récupération contextuelle
Exemple d'utilisation de l'agent/outil Llama 2 70B https://philschmid.github.io/easyllm/examples/llama2-agent-example/	Exemple d'utilisation de Llama 2 70B pour interagir avec des outils et peut être utilisé comme proxy

Ces exemples couvrent les principales fonctionnalités d'EasyLLM - Chat, Complétion de texte et Embedding.

Neuf, Références

• EasyLLM GitHub

  • https://github.com/philschmid/easyllm

• Invite d'appel 2

  • https://huggingface.co/blog/llama2#how-to-prompt-llama-2

• Invite de vigogne

  • https://github.com/lm-sys/FastChat/blob/main/docs/vicuna_weights_version.md#prompt-template

• Invite StarChat

  • https://huggingface.co/HuggingFaceH4/starchat-beta

• Invite WizardLM

  • https://github.com/nlpxucan/WizardLM/blob/main/WizardLM/src/infer_wizardlm13b.py#L79

• StableBeluga2

  • https://huggingface.co/stabilityai/StableBeluga2