pyaskit
1.0.0
AskIt sert de bibliothèque dédiée ou de langage spécifique à un domaine conçu pour rationaliser l'utilisation de grands modèles linguistiques (LLM) tels que GPT-4, Gemini, Claude, COHERE et LLama2. Il simplifie les complexités de l'ingénierie rapide et élimine la nécessité d'analyser les réponses des LLM, rendant ainsi les tâches de programmation plus fluides.
Grâce à AskIt , vous pouvez déployer des LLM pour une multitude de tâches, telles que :
pyaskit peut utiliser GPT, Gemini, Claude, COHERE ou LLama2 comme backend. pyaskit fonctionne via l'API OpenAI, l'API Gemini, l'API Claude et l'API COHERE ou l'API LLama2. Outre Python, AskIt a également été implémenté dans TypeScript. Vous pouvez accéder à la version TypeScript, ts-askit.
from pyaskit import ask
# Automatically parses the response to an integer
sum = ask ( int , "add 1 + 1" )
# `sum` is an integer with a value of 2 from typing import TypedDict , List
from pyaskit import ask
# Define a typed dictionary for programming languages
class PL ( TypedDict ):
name : str
year_created : int
# Automatically extracts structured information into a list of dictionaries
langs = ask ( List [ PL ], "List the two oldest programming languages." )
# `langs` holds information on the oldest programming languages in a structured format like
# [{'name': 'Fortran', 'year_created': 1957},
# {'name': 'Lisp', 'year_created': 1958}] from pyaskit import function
@ function ( codable = False )
def translate ( s : str , lang : str ) -> str :
"""Translate {{s}} into {{lang}} language."""
s = translate ( "こんにちは世界。" , "English" )
# `s` would be "Hello, world." from pyaskit import function
@ function ( codable = True )
def get_html ( url : str ) -> str :
"""Get the webpage from {{url}}."""
# When `codable` is set to True, the body of the function is automatically coded by an LLM.
html = get_html ( "https://github.com/katsumiok/pyaskit/blob/main/README.md" )
# `html` contains the HTML version of this README.md Pour installer AskIt , exécutez cette commande dans votre terminal :
pip install pyaskitou
pip install git+https://github.com/katsumiok/pyaskit.gitAvant d'utiliser AskIt , vous devez définir votre clé API comme variable d'environnement appropriée :
OPENAI_API_KEYGOOGLE_API_KEYANTHROPIC_API_KEYCO_API_KEYGROQ_API_KEY Par exemple, pour utiliser l'API OpenAI, vous devez définir votre clé API OpenAI comme variable d'environnement OPENAI_API_KEY :
export OPENAI_API_KEY= < your OpenAI API key > <your OpenAI API key> est une chaîne qui ressemble à ceci : sk-<your key> . Vous pouvez trouver votre clé API OpenAI dans le tableau de bord OpenAI.
Vous devez spécifier le nom du modèle en tant que variable d'environnement ASKIT_MODEL :
export ASKIT_MODEL= < model name > <model name> est le nom du modèle que vous souhaitez utiliser. Le dernier AskIt est testé avec gpt-4 , gpt-3.5-turbo-16k , gemini-pro , claude-2.1 et cohere-2.0 . Vous pouvez trouver la liste des modèles disponibles dans la documentation de l'API OpenAI, la documentation de l'API Gemini, la documentation de l'API Claude et la documentation de l'API COHERE. Vous pouvez également retrouver les modèles disponibles dans le fichier models.py .
Avant d'utiliser AskIt avec Llama 2, vous devez l'installer. Pour installer Llama 2, exécutez cette commande dans votre terminal :
pip install git+https://github.com/facebookresearch/llama.gitVous devez également télécharger le modèle de tokenizer et le point de contrôle du modèle que vous souhaitez utiliser. Veuillez vous référer à la documentation de Llama 2 pour plus de détails.
Nous fournissons un exemple d'utilisation d'AskIt avec Llama 2 dans le répertoire d'exemples. Pour exécuter l'exemple, exécutez cette commande dans votre terminal :
torchrun --nproc_per_node 1 examples/use_llama2.py
--ckpt_dir llama-2-7b-chat/
--tokenizer_path tokenizer.model
--max_seq_len 512 --max_batch_size 6Voici quelques exemples de base pour vous aider à vous familiariser avec AskIt :
import pyaskit as ai
s = ai . ask ( str , 'Paraphrase "Hello World!"' )
print ( s ) Pour utiliser AskIt , commencez par importer le module pyaskit . L'API ask , qui prend deux arguments - le type de sortie et l'invite - produit la sortie du LLM dans le format désigné. Dans ce cas, le type de sortie est str et l'invite est Paraphrase "Hello World!" . Une explication complète des types dans AskIt est fournie dans la section Types. L'exécution de ce code produira une paraphrase de l'invite, telle que :
Greetings, Planet!
function Le décorateur function permet de définir une fonction avec un modèle d'invite. Les paramètres d'une fonction définie peuvent être utilisés comme paramètres d'un modèle d'invite. Par exemple,
from pyaskit import function
@ function ( codable = False )
def paraphrase ( text : str ) -> str :
"""Paraphrase {{text}}"""
s = paraphrase ( 'Hello World!' )
print ( s ) Où {{text}} représente un paramètre de modèle et correspond au paramètre de fonction.
define L'API define permet un paramétrage rapide à l'aide de la syntaxe du modèle :
import pyaskit as ai
paraphrase = ai . define ( str , 'Paraphrase {{text}}' )
s = paraphrase ( text = 'Hello World!' )
# s = paraphrase('Hello World!') # This is also valid
print ( s ) Dans ce cas, l'API define crée une fonction basée sur un modèle qui demande au LLM de paraphraser le texte spécifié. Invocation de la fonction paraphrase avec « Hello World ! » renverra une version paraphrasée de ce texte. L'exécution de ce code pourrait générer quelque chose comme "Salutations, Planète!".
L'API define permet de créer facilement des fonctions personnalisées pour exploiter les capacités de grands modèles de langage pour diverses tâches. D'autres exemples peuvent être trouvés dans le répertoire des exemples.
Certaines tâches, telles que celles nécessitant des données en temps réel, des ressources externes comme l'accès au réseau, l'accès aux fichiers ou l'accès à la base de données, ne conviennent pas à l'exécution de LLM. Cependant, AskIt peut gérer ces tâches en convertissant l'invite en un programme Python en arrière-plan.
L'exemple suivant montre l'utilisation d'AskIt pour aborder une tâche nécessitant un accès au réseau :
import pyaskit as ai
get_html = ai . define ( str , 'Get the webpage from {{url}}' ). compile ()
html = get_html ( url = 'https://csail.mit.edu' )
print ( html ) Dans ce scénario, il vous suffit d'appeler compile() sur la fonction renvoyée par l'API define . La fonction compile transforme l'invite en un programme Python et renvoie une fonction qui exécute ce code, se comportant comme une fonction Python classique.
Bien que l'exemple ci-dessus ne spécifie pas le type du paramètre url , AskIt fournit l'API defun pour le faire. Le code suivant montre comment définir une fonction dans laquelle le type du paramètre url est spécifié comme str :
import pyaskit as ai
get_html = ai . defun ( str , { "url" : str }, 'Get the webpage from {{url}}' ). compile ()
html = get_html ( url = 'https://csail.mit.edu' )
print ( html ) Le deuxième argument de l'API defun est un dictionnaire qui mappe les noms de paramètres à leurs types.
On peut faire la même chose avec le code suivant :
from pyaskit import function
@ function ( codable = True )
def get_html ( url : str ) -> str :
"""Get the webpage from {{url}}"""
html = get_html ( url = 'https://csail.mit.edu' )
print ( html )Les modèles d'apprentissage des langues (LLM) offrent l'avantage d'un apprentissage en quelques étapes, une capacité qu'AskIt utilise dans les tâches de programmation. AskIt vous permet de résoudre des tâches en utilisant la technique de programmation par exemple (PBE), où vous fournissez des exemples d'entrée et de sortie souhaitées.
Envisageons de créer une fonction pour ajouter deux nombres binaires (représentés sous forme de chaînes). Cette fonction accepte deux nombres binaires et renvoie leur somme, également sous forme binaire. Le code suivant montre la définition d'une telle fonction à l'aide d'exemples illustratifs.
from pyaskit import define
training_examples = [
{ "input" : { "x" : "1" , "y" : "0" }, "output" : "1" },
{ "input" : { "x" : "1" , "y" : "1" }, "output" : "10" },
{ "input" : { "x" : "101" , "y" : "11" }, "output" : "1000" },
{ "input" : { "x" : "1001" , "y" : "110" }, "output" : "1111" },
{ "input" : { "x" : "1111" , "y" : "1" }, "output" : "10000" },
]
add_binary_numbers = define ( str , "Add {{x}} and {{y}}" , training_examples = training_examples )
sum_binary = add_binary_numbers ( x = "101" , y = "11" )
print ( sum_binary ) # Output: "1000" Dans cet exemple, l'API define prend trois arguments : le type de sortie, l'invite et les exemples de formation. Chaque entrée de la liste des exemples de formation est un dictionnaire contenant un dictionnaire « d'entrée » (avec des noms et des valeurs de variables) et une « sortie » représentant la sortie de fonction attendue compte tenu de l'entrée. L'API define renvoie ensuite une fonction qui accepte les variables d'entrée comme arguments de mot-clé et génère la sortie du LLM dans le type spécifié.
La fonction add_binary_numbers , qui ajoute deux nombres binaires, se comporte comme n'importe quelle fonction Python classique.
Vous pouvez utiliser la fonction compile pour tester la fonction générée à l'aide d'une liste facultative d'exemples de test.
Le code suivant montre comment tester la fonction définie ci-dessus avec de nouveaux exemples de tests :
test_examples = [
{ "input" : { "x" : "0" , "y" : "1" }, "output" : "1" },
{ "input" : { "x" : "10" , "y" : "0" }, "output" : "10" },
{ "input" : { "x" : "110" , "y" : "10" }, "output" : "1000" },
]
f = add_binary_numbers . compile ( test_examples = test_examples )
sum_binary = f ( x = "101" , y = "11" )
print ( sum_binary ) # Output: "1000" Ici, f est la fonction générée qui fonctionne de la même manière que add_binary_numbers . En comparant le résultat de la fonction générée avec le résultat attendu pour chaque exemple de test, AskIt garantit que la fonction générée se comporte comme prévu. En cas de divergence, AskIt réessaye la traduction. Après plusieurs tentatives de traduction infructueuses, AskIt génère une exception.
AskIt propose des API pour désigner les types de sortie pour les modèles d'apprentissage des langues (LLM). En fournissant ces types comme premier argument des API ask et define , vous pouvez gérer le format de sortie du LLM. Vous pouvez également utiliser les astuces de type fournies par Python.
Le tableau suivant décrit les différents types pris en charge par AskIt :
| Taper | Description | Exemple de type | Exemple de valeur |
|---|---|---|---|
int | Entier | t.int | 123 |
float | Nombre à virgule flottante | t.float | 1.23 |
bool | Booléen | t.bool | Vrai |
str | Chaîne | t.str | "Bonjour le monde!" |
literal | Littéral | t.literal(123) | 123 |
list | Liste | t.list(t.int) | [1, 2, 3] |
dict | Dictionnaire | t.dict({'a': t.int,'b': t.str}) | {'a' : 1, 'b' : "abc"} |
record | Dictionnaire | t.record(t.str, t.int) | {'a' : 1, 'b' : 2} |
tuple | Tuple | t.tuple(t.int, t.str) | (1, "abc") |
union | Union (plusieurs valeurs possibles) | t.union(t.literal('yes'), t.literal('no')) | "oui" ou "non" |
t.literal('yes') | t.literal('no') | "oui" ou "non" | ||
t.literal('yes', 'no') | "oui" ou "non" | ||
None | Aucun | None | Aucun |
Notez que chaque déclaration de type aide AskIt à analyser et à comprendre le résultat souhaité, garantissant ainsi que votre LLM renvoie les données dans le format précis dont vous avez besoin.
Le modèle d'invite est une chaîne composée d'espaces réservés pour les paramètres de la fonction en cours de définition. Les espaces réservés sont désignés par des doubles accolades {{ et }} et ne peuvent contenir qu'un nom de variable. Ce nom de variable est ensuite utilisé comme paramètre dans la fonction définie.
Les paramètres de fonction peuvent être définis de deux manières : soit par des arguments de mot-clé, soit par des arguments de position. Pour les arguments de mot-clé, le nom de la variable dans l'espace réservé sert de nom de l'argument de mot-clé. Pour les arguments positionnels, l'ordre dans lequel les espaces réservés apparaissent définit l'ordre des arguments positionnels.
Considérons l'exemple suivant qui montre comment définir une fonction, add , qui accepte deux arguments x et y et renvoie leur somme :
from pyaskit import define
import pyaskit . types as t
add = define ( t . int , '{{x}} + {{y}}' )
print ( add ( x = 1 , y = 2 )) # keyword arguments
print ( add ( 1 , 2 )) # positional arguments Dans ce cas, la fonction add peut être invoquée à l'aide d'un mot-clé ou d'arguments de position, avec la somme de x et y renvoyée en sortie.
Notamment, si le même nom de variable est utilisé plusieurs fois dans le modèle d'invite, les utilisations ultérieures sont mappées à l'occurrence initiale. Observez ce comportement dans l'exemple suivant :
from pyaskit import define
import pyaskit . types as t
add = define ( t . int , '{{x}} + {{y}} + {{x}} + {{z}}' )
print ( add ( x = 1 , y = 2 , z = 3 ))
print ( add ( 1 , 2 , 3 )) Ici, {{x}} apparaît deux fois dans le modèle d'invite. La deuxième occurrence de {{x}} correspond à la première. Par conséquent, même si {{z}} est le quatrième espace réservé du modèle, il s'aligne sur le troisième argument de la fonction.
Voir CONTRIBUTING.md pour plus de détails sur notre code de conduite et le processus de soumission des demandes de tirage.
Ce projet est sous licence MIT - voir le fichier LICENSE.md pour plus de détails
Si vous utilisez notre logiciel dans votre recherche, veuillez citer notre article :
@misc { okuda2023askit ,
title = { AskIt: Unified Programming Interface for Programming with Large Language Models } ,
author = { Katsumi Okuda and Saman Amarasinghe } ,
year = { 2023 } ,
eprint = { 2308.15645 } ,
archivePrefix = { arXiv } ,
primaryClass = { cs.PL }
}
