prompter.vim
1.0.0
Utilisez VIM comme outil pour concevoir et exécuter efficacement, déboguer et enregistrer vos invites de modèles de langue grande (LLMS).
PromPter.VIM transforme l'éditeur VIM en un environnement d'ingénierie rapide efficace, remplaçant efficacement les terrains de jeux Web de fournisseurs propriétaires LLM comme: Azure Openai Service Playground ou Openai Playground.
À partir de la version 0.2, le plugin utilise Litellm comme couche d'abstraction du fournisseur LLM.
Litellm appelle toutes les API LLM en utilisant le format OpenAI: ombratage, azure, openai, cohere, anthropic, olllama, sagemaker, huggingface, reprolever (100+ LLMS). Vous pouvez donc utiliser ProMPter.vim avec une vaste liste de différents fournisseurs LLM!
<F9> (raccourci des touches pour :PrompterSetup )<F12> (raccourci de touche pour :PrompterGenerate ) pour obtenir l'achèvement de LLMmyexperiment.prompt )  |
|---|
| PromPter.vim en action: modification / interaction avec une invite qui simule une conversation téléphonique (avec une technique ci-dessous décrite comme "Dialogues comme faisant partie de l'invite de texte") |
ProMPter.vim n'est pas principalement conçu comme un outil de complétion de code, bien que vous puissiez l'utiliser également à cette fin.
Au lieu de cela, ce plugin vise à remplacer les terrains de jeux d'achèvement du texte Web, destinés aux ingénieurs rapides qui souhaitent tester et déboguer les invites en langage naturel.
L'idée a émergé au printemps 2023 pendant que j'écrivais des invites LLM et expérimentant des techniques d'ingénierie rapides. J'utilisais une approche simple «complétion du texte», où vous saisissez votre corpus d'invite de texte et demandez une réalisation d'un modèle grand langage (LLM).
Mon approche initiale a été d'utiliser les terrains de jeux Web offerts par les fournisseurs de LLM. Cependant, j'ai rencontré de nombreux problèmes en particulier en interagissant avec les terrains de jeux Web Azure Openai.
Pour des raisons que je ne comprends pas encore, l'interaction Web sur le terrain de jeu Web Azure ralentit considérablement après un certain point. Je soupçonne un bogue dans les cases d'achèvement. De plus, je n'aime pas l'interface Web Azure pour le mode "Complétion du chat". Un gâchis total! Au lieu de cela, le terrain de jeu OpenAI d'origine est mieux mis en œuvre et je n'ai pas rencontré les problèmes susmentionnés.
Néanmoins, les deux terrains de jeux Web mentionnés ne permettent qu'une seule invite par onglet de navigateur. Par conséquent, lorsque vous traitez plusieurs invites actives (en développant une application composite composée d'invites de modèle imbriquées / enchaînées), vous devez maintenir plusieurs terrains de jeux ouverts dans des onglets distincts. Lorsque vous atteignez certains résultats (intermédiaires) notables, vous devez copier toutes les zones de texte et les enregistrer dans des fichiers versionnés.
Entreprendre tout cela avec des terrains de jeux Web est un processus lourd et sujet aux erreurs. La pensée finale était: et si je pouvais exécuter mon achèvement directement dans mon éditeur VIM?
text ou chat ?Il y a deux «modes d'achèvement» courants prévus dans les LLM ouverts ou à courant similaire:
Achèvement text
Le mode d'achèvement défini comme text signifie que LLM se termine, le texte de l'invite de la fenêtre de contexte donné avec un texte de complétion (texte dans -> texte out). Un exemple d'un tel paramètre de modèle est le modèle OpenAAI text-da-vinci-003 . Pour utiliser un mode de réalisation de texte, le modèle doit prendre en charge ce mode via une API spécifique.
┌────────────────────────┐
┌─ │ │ ─┐
context │ │ bla bla bla │ │
window │ │ bla bla │ │
= │ │ bla bla bla bla │ │ prompt
prompt │ │ bla │ │
+ │ │ bla bla │ │
completion │ │ │ ─┘
│ └────────────────────────┘
│ |
│ LLM generation
│ |
│ v
│ ┌────────────────────────┐
│ │ │ ─┐
│ │ bla bla │ │
│ │ bla bla bla │ │ text completion
│ │ bla │ │
└─ │ │ ─┘
└────────────────────────┘
Achèvement chat
Le mode d'achèvement défini comme chat signifie que LLM s ajusté pour les "rôles" de chat (l'utilisateur dit, l'assistant dit, ...). Détails avant, veuillez lire ceci. L'invite de fenêtre de contexte est en fait réalisée par
gpt3.5-turbo OpenAI. Pour utiliser un mode de complétion de chat, le modèle doit prendre en charge ce mode, API spécifique à la caisse. ┌────────────────────────┐
┌─ │ bla bla bla bla │ ─┐
│ │ bla bla bla │ │
│ │ bla bla │ │ system
│ │ bla bla bla bla │ │ prompt
context │ │ bla │ │
window │ │ bla bla │ ─┘
= │ └────────────────────────┘
system prompt │ ┌────────────────────────┐
+ │ │ user: blablabla │ ─┐
chat │ ├────────────────────────┤ │
+ │ │ assistant: bla bla bla │ │
completion │ ├────────────────────────┤ │ chat
│ │ user: bla bla bla │ │ prompt
│ ├────────────────────────┤ │
│ │ assistant: blabla bla │ │
│ ├────────────────────────┤ │
│ │ user: blabla bla │ ─┘
│ └────────────────────────┘
│ |
│ LLM generation
│ |
│ v
│ ┌────────────────────────┐
│ │ │ ─┐
└─ │ assistant: bla bla bla │ │ chat completion
│ │ ─┘
└────────────────────────┘
Le plugin PromPter.VIM est conçu pour fonctionner comme un terrain de jeu de prototypage rapide de texte, en évitant les complications des rôles de chat.
Donc, si un modèle qui ne fonctionne que en mode chat (par exemple Openai GPT3.5-Turbo ) est utilisé, dans les coulisses (via une méthode Litellm text_completion() ) Le contenu texte de l'éditeur (l'invite) est inséré sous forme d'invite de rôle "système". Voir aussi: Discussion.
Je suis conscient que l'utilisation d'un modèle basé sur le chat comme modèle basé sur le texte, comme décrit ci-dessus, n'est pas l'utilisation optimale, mais c'est un compromis entre la simplicité d'avoir un terrain de jeu d'achèvement de texte et la complexité de la gestion des rôles de chat.
Ce plugin est fabriqué en Python3. Vérifiez si votre installation VIM prend en charge Python3:
vim --version | grep " +python3 " | awk ' {print $3} ' Dans mon cas, j'ai eu +python3 . C'est la principale condition préalable.
Vérifiez également quelle est la version Python qui est compilée VIM. Extraire la version Python précise avec la commande:
vim --version | grep -o -P ' (?<=/python)[0-9]+.[0-9]+ ' Dans mon cas, j'ai eu 3.8 .
Notez que VIM ne peut utiliser que la version Python (et les packages associés) qui sont compilés. Par exemple, si la version actuelle de votre système Python (
python3 --version==Python 3.11.6) diffère de la version VIM Python, disonsPython 3.8, rappelez-vous que VIM ne verra que les packagesPython 3.8. Pour utiliser les packagesPython 3.11.6, vous devez recompiler VIM.
Installez Python Package litellm . Vous devez installer litellm à l'aide de pip de la version Python correspondante, par exemple pip3.8 .
pip3.8 install -U litellm Installez le plugin à l'aide de votre gestionnaire de plugin préféré, par exemple à l'aide du gestionnaire de plug-in vim-plug, insérer dans votre fichier .vimrc :
Plug ' solyarisoftware/prompter.vim ' # PROVIDER DEPENDENT SETTINGS USING LiteLLM CONFIGURATION
# https://docs.litellm.ai/docs/providers
# https://docs.litellm.ai/docs/providers/azure
# LLM PROVIDER MANDATORY SETTINGS
export AZURE_API_VERSION=2023-09-01-preview
export AZURE_API_BASE= " https://XXXXXXXXXXXXXXX.openai.azure.com/ "
export AZURE_API_KEY= " YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY "
export MODEL= " azure/your_deployment-name "
# LLM PARAMETERS OPTIONAL SETTINGS
# translated OpenAI model parameters
# https://docs.litellm.ai/docs/completion/input#translated-openai-params
export TEMPERATURE=0.3
export MAX_TOKENS=3000
export OPENAI_STOP= " " Une bonne idée est de modifier et de garder toutes les variables au-dessus dans un fichier caché, par exemple vi ~/.prompter_azure.vim , et l'exécuter avec source ~/.prompter_azure.vim
Vous pouvez exécuter des commandes en mode commande vim ( : ou dans la clé associée:
| Commande | Clé | Action |
|---|---|---|
:PrompterSetup | <F9> | Configuration du modèle et configurations initiales |
:PrompterGenerate | <F12> | Exécutez l'achèvement du texte LLM |
:PrompterInfo | <F10> | Signaler la configuration actuelle |
:PrompterSetupLorsque vous entrez VIM, pour activer l'environnement de terrain de jeu de ProMper, tout d'abord l'exécution en mode commande:
:PrompterSetupEn suivant les paramètres d'environnement, en cas de succès, la commande imprime dans la ligne d'état les configurations du modèle:
Model: azure/gpt-35-turbo completion mode: chat temperature: 0.7 max_tokens: 100
Explication des valeurs dans le rapport de la ligne de statut:
temperature preset value ───────────────────────────┐
│
max_tokens preset value ──────────┐ │
│ │
┌─────┐ ┌────────────┐ ┌────┐ ┌─┴─┐ ┌─┴─┐
Model:│azure│/│gpt-35-turbo│ completion mode:│chat│ temperature:│0.7│ max_tokens:│100│
└──┬──┘ └─────┬──────┘ └──┬─┘ └───┘ └───┘
│ │ │
│ │ └─ chat or text, depending on the model
│ │
│ └── name of the Azure deployment
│
└───────────── name of the LLM provider
:PrompterGenerateModifiez votre invite sur une fenêtre VIM et pour exécuter l'achèvement LLM juste
:PrompterGenerateLa ligne d'état rapporte certaines statistiques:
Latency: 1480ms (1.5s) Tokens: 228 (prompt: 167 completion: 61) Throughput: 154 Words: 28 Chars: 176, Lines: 7
Explication des valeurs dans le rapport de la ligne de statut:
┌─ latency in milliseconds and seconds
│
│ ┌───────────────────────────────── total nr. of tokens
│ │
│ │ ┌──────────────────── nr. of tokens in prompt
│ │ │
│ │ │ ┌──── nr. of tokens in completion
│ │ │ │
┌─┴───────────┐ ┌─┴─┐ ┌─┴─┐ ┌─┴┐ ┌───┐ ┌──┐ ┌───┐ ┌─┐
Latency:│1480ms (1.5s)│Tokens:│228│(prompt:│167│completion:│61│) Throughput:│154│Words:│28│Chars:│176│ Lines:│7│
└─────────────┘ └───┘ └───┘ └──┘ └─┬─┘ └─┬┘ └─┬─┘ └┬┘
│ │ │ │
│ │ │ │
Latency / Tokens ───────────────────────┘ │ │ │
│ │ │
nr. of words ───────────┘ │ │
│ │
nr. of characters ─────────────────────┘ │
│
nr. of lines ────────────────────────────────┘
Les statistiques signalent ces mesures:
| Métrique | Description | Exemple |
|---|---|---|
| Latence | Bot en millisecondes et deuxième approximation | 1480ms (1.5s) |
| Jetons | Montant total des jetons, sous-total rapide et sous-total | 228 |
| Déborder | Tokens d'achèvement / rapport de latence (en secondes). Voir la discussion sur le concept de débit ici | 154 |
| Mots | Nombre de mots générés dans l'achèvement | 28 |
| Charbon | Nombre de caractères dans l'achèvement | 176 |
| Lignes | Nombre de lignes générées dans l'achèvement | 7 |
Par défaut, la commande est attribuée à la clé de fonction
F12. De cette manière, vous pouvez exécuter l'achèvement en appuyant simplement sur la touche uniqueF12.
:PrompterInfoSignale la version du plugin actuelle, la liste des commandes du plugin, les paramètres du modèle actuels.
:PrompterInfoLa commande imprime ces informations:
Version:
prompter.vim, by [email protected], version 0.2 (November 28, 2023)
Model:
Model: azure/gpt-35-turbo completion mode: chat temperature: 0.5 max_tokens: 1500
Commands:
PrompterGenerate <F12>
PrompterInfo <F10>
PrompterSetup <F9>
Obtenez et définissez des couleurs de fond et de premier plan:
echo g: prompter_completion_ctermbg
echo g: prompter_completion_ctermfg
let g: prompter_completion_ctermbg = 3
let g: prompter_completion_ctermfg = 0Si vous n'aimez pas les couleurs de surbrillance par défaut, vous pouvez remplacer les valeurs
ctermbgetctermfgen utilisant un sous-ensemble de couleurs CTERT / XTERM 256. Pour afficher toutes les couleurs disponibles, vous pouvez utiliser la commande:HighlightColorspartie de mon plugin: Highlight.
Pour modifier la valeur de température
let g: temperature = 0.2Pour modifier la valeur des jetons max
let g: max_tokens = 2000
Pour modifier la ou les séquences d'arrêt (s)
let g: stop = [ ' x: ' , ' y: ' , ' z: ' ]Les commandes sont associées aux touches de fonction avec ce paramètre par défaut:
let g: prompter_setup_keystroke = ' <F9> '
let g: prompter_info_keystroke = ' <F10> '
let g: prompter_generate_keystroke = ' <F12> '
let g: prompter_regenerate_keystroke = ' <F8> ' Même si dans VIM, vous pouvez attribuer une commande à un mappage de clé de votre préférence, par exemple: map <F2> :PrompterGenerate<CR> et vous pouvez voir quel mappage pour une clé particulière, par exemple F2 , vous pouvez utiliser la commande VIM: map <F12> , le moyen suggéré de procéder est de modifier à nouveau une ou plusieurs des variables et de l'exécution mentionnés ci-dessus :PrompterSetup .
Utiliser (Vim-included)
Lorsque vous écrivez une invite LLM, il est très très important d'éviter les fautes de frappe! J'ai beaucoup éprouvé le pire de l'achèvement de LLM si vous ne confondez qu'un verbe.
Les choses vont encore pire si vous écrivez des invites dans plus d'une langue. Personnellement, j'écris habituellement des invites conversationnelles en anglais, pour certaines raisons décrites dans mon article, les langues non anglophones ingénients ingénieurs compromis, mais la langue cible de l'invite de chat est ma langue maternelle: l'italien. Dans l'ensemble, l'invite contient du texte en anglais et en italien. Dans ce cas, j'exécute cette petite fonction vimscript:
function ! Spell ()
set spelllang = en_us,it
setlocal spell
echom " Spell check set for Italian and English languages "
endfunction
com ! SPELL call Spell ()Lisez toutes vos statistiques d'achèvement précédentes
messagesVIM affichera les informations sur les statistiques de la dernière fin. Par exemple, si vous exécutez 3 complétions:
Latency: 961ms (1.0s) Tokens: 616 (prompt: 577 completion: 39) Throughput: 641 Words: 21 Chars: 134
Latency: 368ms (0.4s) Tokens: 648 (prompt: 642 completion: 6) Throughput: 1761 Words: 2 Chars: 15
Latency: 4227ms (4.2s) Tokens: 775 (prompt: 660 completion: 115) Throughput: 183 Words: 60 Chars: 377, Lines: 5
Activer les lignes enveloppe douce
Je travaille habituellement avec un paramètre VIM complet. Cela m'aide à maximiser mon attention. Néanmoins, avoir des lignes très longues (après un PrompterGenerate ) n'aide pas la lecture.
Malheureusement, dans VIM n'est pas facile à configurer une largeur de colonne fixe enveloppe douce. Voir la discussion. Vous pouvez définir Set Soft Warp avec la commande suivante:
set wrap linebreak nolist Une technique que j'utilise pour prototype les invites de dialogue, consiste à insérer un bloc de virage de dialogue comme dans l'exemple suivant, où le bloc de dialogue se termine avec la "séquence d'arrêt" (par exemple a: :) déclenchant LLM pour terminer le rôle assistant:
TASK
You (a:) are a customer care assistant and you are assisting a user (u:).
...
...
DIALOG
a: Hello! How can I assist you today?
u: I want to open a report.
a: Fantastic! First, could you provide me with a detailed description of the issue you're experiencing?
u: The computer monitor won't turn on.
a: Thank you for the description. What is the name or model of the product or system you're having trouble with?
u: I can't read the brand. It's the company's PC monitor.
a: Thank you for the information. What is your preferred method of contact?
u: via email at [email protected]
a: Thank you. Please confirm the provided email address: [email protected]
u: that's correct!
a:
Dans le cas ci-dessus, pour définir le LLM STOP en attendant l'entrée utilisateur, vous pouvez définir la séquence d'arrêt comme u: avec commande:
let g: stop = [ ' u: ' ] Veuillez noter que si vous ne définissez pas la séquence d'arrêt comme décrit ci-dessus, le LLM essaiera de terminer toute la conversation. Ce n'est en général pas voulu parce que vous voulez écrire la phrase qui u: . Néanmoins, il est parfois utile de ne pas se déclencher le g:stop juste pour voir comment le LLM imagine la conversation.
Autres commandes VIM qui pourraient être utiles:
u: en appuyant simplement sur la touche F6 : map <F6> :normal ou: <CR> a: , en appuyant simplement sur la touche F7 : map <F7> :normal oa: <CR> Version 0.1
Première version. Seuls les modèles OpenAI / Azure OpenAI sont pris en charge via le module Python OpenAI version 0.28.
Version 0.2
Les compléments LLMS sont effectués via le package Python de couche abstraction LLMS, LLMS, permettant d'utiliser une multitude de différents fournisseurs LLM.
Prise en charge de tous les paramètres d'entrée LLM
Jusqu'à présent, ProMPter.VIM ne supporte que temperature , max_tokens , stop Arguments.
Litellm accepte et traduit les paramètres d'achèvement du chat OpenAI à tous les fournisseurs.
Invites de modèle de support
Vous concevez des "invites de modèle" composées de différentes pièces qui peuvent être construites dynamiquement au moment de l'exécution. Considérez, par exemple, que vous souhaitez prototyper une "invite de modèle" contenant des variables d'espace réservé, qui sont des références à certaines variables remplies par d'autres invites ou fichiers, comme ainsi:
TASK
{some_task_description}
DATA
{some_yaml}
DIALOG
{dialog_history}
Dans l'exemple ci-dessus, lorsque vous utilisez des terrains de jeux Web, vous fonctionnez comme un intermédiaire de coller. Vous devez ouvrir quatre onglets Web, exécuter les compléments de texte dans chacun et enfin coller manuellement les compléments, substituer des variables telles que {some_data} , {dialog_history} . De plus, vous devrez peut-être charger un fichier dans une variable, comme {some_yaml} .
L'idée est de prendre en charge le modèle d'invites édition permettant de remplacer à la volée (par une touche) les espaces réservés variables, par le contenu d'autres tampons / fenêtres.
Achèvement LLM asynchrone
Actuellement, la commande de complétion LLM PrompterGenerate est une commande synchrone: l'éditeur est bloqué jusqu'à ce que l'API LLM renvoie un texte d'achèvement. Cela pourrait être fastidieux pour des invites très complexes et longues qui nécessitent de nombreuses secondes pour terminer (par exemple >> 10). Dans ce cas, il pourrait être mieux si la commande pouvait être asynchre, permettant au développeur d'utiliser l'éditeur VIM avec l'achèvement est en cours.
Support de streaming
Jusqu'à présent, l'achèvement du streaming n'est pas pris en considération.
David Shapiro pour son énorme travail de diffusion sur les LLM et l'IA générative. J'ai suivi avec enthousiasme, en particulier son LLM Inside Engineering Live Coding YouTube Videos!
Vivian de Smedt Vim Expert pour son aide à résoudre un problème rencontré lors du développement de ce plugin.
Créateurs Litellm pour avoir intégré certaines fonctionnalités suggérées, comme format de réalisation de texte!
Ce projet est une version Alfa de preuve de concept de travail en cours!
Je ne suis pas un expert vimscript, donc toute contribution ou suggestion est la bienvenue. Pour toute proposition et problème, veuillez vous soumettre ici sur les problèmes de github pour les bogues, les suggestions, etc. Vous pouvez également me contacter par e-mail ([email protected]).
Si vous aimez le projet, veuillez perdre ce référentiel pour montrer votre support!
Copyright (c) 2023 Giorgio Robino
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
haut
