pyaskit

AskIt (pyaskit)

Einführung

AskIt dient als dedizierte Bibliothek oder domänenspezifische Sprache, die darauf ausgelegt ist, die Nutzung von Large Language Models (LLMs) wie GPT-4, Gemini, Claude, COHERE und LLama2 zu optimieren. Es vereinfacht die Komplexität des Prompt-Engineerings und macht das Analysieren von Antworten von LLMs überflüssig, wodurch Programmieraufgaben reibungsloser werden.

Mit AskIt können Sie LLMs für eine Vielzahl von Aufgaben einsetzen, wie zum Beispiel:

• Verarbeitung natürlicher Sprache: einschließlich Übersetzung, Paraphrasierung und Stimmungsanalyse.
• Problemlösung: Lösen mathematischer Probleme.
• Codegenerierung: Erstellen neuer Codes und mehr.

pyaskit kann GPT, Gemini, Claude, COHERE oder LLama2 als Backend verwenden. pyaskit arbeitet über die OpenAI API, Gemini API, Claude API und COHERE API oder LLama2 API. Neben Python wurde AskIt auch in TypeScript implementiert. Sie können auf die TypeScript-Version ts-askit zugreifen.

Hauptmerkmale

• Typgesteuerte Ausgabesteuerung: Erhalten Sie eine Antwort im angegebenen Typ.
  • Es ist nicht erforderlich, das Ausgabeformat in der Eingabeaufforderung anzugeben
  • Es ist nicht erforderlich, die Antwort zu analysieren, um die gewünschte Ausgabe zu extrahieren

 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}] 

• Vorlagenbasierte Funktionsdefinition: Definieren Sie Funktionen mithilfe einer Eingabeaufforderungsvorlage.

 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." 

• Codegenerierung: Generieren Sie Funktionen über die einheitliche Schnittstelle.

 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 

• Beispielprogrammierung (PBE): Definieren Sie Funktionen anhand von Beispielen. Weitere Einzelheiten finden Sie im Abschnitt „Programmierung anhand von Beispielen“ (PBE).

Installation

Um AskIt zu installieren, führen Sie diesen Befehl in Ihrem Terminal aus:

pip install pyaskit

oder

pip install git+https://github.com/katsumiok/pyaskit.git

Vorbereitung für OpenAI API, Gemini API, Claude API oder COHERE API

Bevor Sie AskIt verwenden, müssen Sie Ihren API-Schlüssel als geeignete Umgebungsvariable festlegen:

• OpenAI-API: OPENAI_API_KEY
• Gemini-API: GOOGLE_API_KEY
• Claude-API: ANTHROPIC_API_KEY
• COHERE-API: CO_API_KEY
• groq-API: GROQ_API_KEY

Um beispielsweise die OpenAI-API zu verwenden, müssen Sie Ihren OpenAI-API-Schlüssel als Umgebungsvariable OPENAI_API_KEY festlegen:

 export OPENAI_API_KEY= < your OpenAI API key >

<your OpenAI API key> ist eine Zeichenfolge, die wie folgt aussieht: sk-<your key> . Sie finden Ihren OpenAI-API-Schlüssel im OpenAI-Dashboard.

Sie müssen den Modellnamen als Umgebungsvariable ASKIT_MODEL angeben:

 export ASKIT_MODEL= < model name >

<model name> ist der Name des Modells, das Sie verwenden möchten. Das neueste AskIt wurde mit gpt-4 , gpt-3.5-turbo-16k , gemini-pro , claude-2.1 und cohere-2.0 getestet. Die Liste der verfügbaren Modelle finden Sie in der OpenAI-API-Dokumentation, der Gemini-API-Dokumentation, der Claude-API-Dokumentation und der COHERE-API-Dokumentation. Sie können die verfügbaren Modelle auch in der Datei models.py finden.

Vorbereitung für die Llama 2 API (experimentell)

Bevor Sie AskIt mit Llama 2 verwenden können, müssen Sie es installieren. Um Llama 2 zu installieren, führen Sie diesen Befehl in Ihrem Terminal aus:

pip install git+https://github.com/facebookresearch/llama.git

Sie müssen außerdem das Tokenizer-Modell und den Prüfpunkt des Modells herunterladen, das Sie verwenden möchten. Weitere Informationen finden Sie in der Dokumentation zu Llama 2.

Im Beispielverzeichnis finden Sie ein Beispiel für die Verwendung von AskIt mit Llama 2. Um das Beispiel auszuführen, führen Sie diesen Befehl in Ihrem Terminal aus:

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 6

Erste Schritte

Hier sind einige grundlegende Beispiele, die Ihnen helfen sollen, sich mit AskIt vertraut zu machen:

Hallo Welt

 import pyaskit as ai

s = ai . ask ( str , 'Paraphrase "Hello World!"' )
print ( s )

Um AskIt zu nutzen, importieren Sie zunächst das pyaskit -Modul. Die ask -API, die zwei Argumente akzeptiert – den Ausgabetyp und die Eingabeaufforderung – erzeugt die Ausgabe des LLM im angegebenen Format. In diesem Fall ist der Ausgabetyp str und die Eingabeaufforderung ist Paraphrase "Hello World!" . Eine umfassende Erläuterung der Typen in AskIt finden Sie im Abschnitt „Typen“. Wenn Sie diesen Code ausführen, erhalten Sie eine Umschreibung der Eingabeaufforderung, z. B.:

 Greetings, Planet!

Definieren einer Funktion aus einer Eingabeaufforderungsvorlage

Mit der function decorator

Der function ermöglicht das Definieren einer Funktion mit einer Eingabeaufforderungsvorlage. Die Parameter einer definierten Funktion können als Parameter einer Eingabeaufforderungsvorlage verwendet werden. Zum Beispiel,

 from pyaskit import function

@ function ( codable = False )
def paraphrase ( text : str ) -> str :
    """Paraphrase {{text}}"""

s = paraphrase ( 'Hello World!' )
print ( s )

Wobei {{text}} einen Vorlagenparameter darstellt und dem Funktionsparameter entspricht.

Mit der define -API

Die define -API ermöglicht eine prompte Parametrisierung mithilfe der Vorlagensyntax:

 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 )

In diesem Fall erstellt die define -API eine Vorlagenfunktion, die den LLM anweist, den angegebenen Text zu paraphrasieren. Aufrufen der paraphrase -Funktion mit „Hello World!“ gibt eine paraphrasierte Version dieses Textes zurück. Wenn Sie diesen Code ausführen, wird möglicherweise etwas wie „Grüße, Planet!“ ausgegeben.

Die define -API ermöglicht die einfache Erstellung benutzerdefinierter Funktionen, um die Fähigkeiten großer Sprachmodelle für verschiedene Aufgaben zu nutzen. Weitere Beispiele finden Sie im Beispielverzeichnis.

Generieren von Funktionen für programmierbare Aufgaben

Bestimmte Aufgaben, beispielsweise solche, die Echtzeitdaten oder externe Ressourcen wie Netzwerkzugriff, Dateizugriff oder Datenbankzugriff erfordern, sind für die LLM-Ausführung ungeeignet. AskIt kann diese Aufgaben jedoch bewältigen, indem es die Eingabeaufforderung im Hintergrund in ein Python-Programm umwandelt.

Das folgende Beispiel zeigt die Verwendung von AskIt zur Bewältigung einer Aufgabe, die einen Netzwerkzugriff erfordert:

 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 )

In diesem Szenario müssen Sie nur compile() für die von der define -API zurückgegebene Funktion aufrufen. Die compile wandelt die Eingabeaufforderung in ein Python-Programm um und gibt eine Funktion zurück, die diesen Code ausführt und sich dabei wie eine normale Python-Funktion verhält.

Während das obige Beispiel den Typ des Parameters url nicht angibt, stellt AskIt dafür die defun -API bereit. Der folgende Code zeigt, wie eine Funktion definiert wird, in der der Typ der Parameter url als str angegeben wird:

 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 )

Das zweite Argument der defun -API ist ein Wörterbuch, das Parameternamen ihren Typen zuordnet.

Das Gleiche können wir mit dem folgenden Code erreichen:

 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 )

Programmieren anhand von Beispielen (PBE)

Funktionsdefinition anhand von Beispielen

Language Learning Models (LLMs) bieten den Vorteil des Wenig-Schuss-Lernens, eine Fähigkeit, die AskIt bei Programmieraufgaben nutzt. Mit AskIt können Sie Aufgaben mithilfe der PBE-Technik (Programming by Beispiel) lösen, bei der Sie Beispiele für die gewünschte Eingabe und Ausgabe bereitstellen.

Betrachten wir die Erstellung einer Funktion zum Addieren zweier Binärzahlen (dargestellt als Zeichenfolgen). Diese Funktion akzeptiert zwei Binärzahlen und gibt deren Summe ebenfalls in binärer Form zurück. Der folgende Code veranschaulicht die Definition einer solchen Funktion anhand anschaulicher Beispiele.

 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"

In diesem Beispiel akzeptiert die define -API drei Argumente: den Ausgabetyp, die Eingabeaufforderung und die Trainingsbeispiele. Jeder Eintrag in der Trainingsbeispielliste ist ein Wörterbuch, das ein „Eingabe“-Wörterbuch (mit Variablennamen und -werten) und eine „Ausgabe“ enthält, die die erwartete Funktionsausgabe angesichts der Eingabe darstellt. Die define -API gibt dann eine Funktion zurück, die Eingabevariablen als Schlüsselwortargumente akzeptiert und die Ausgabe des LLM im angegebenen Typ ausgibt.

Die Funktion add_binary_numbers , die zwei Binärzahlen addiert, verhält sich wie jede reguläre Python-Funktion.

Testen der generierten Funktion

Mit der compile können Sie die generierte Funktion mithilfe einer optionalen Liste von Testbeispielen testen.

Der folgende Code zeigt, wie die oben definierte Funktion anhand neuer Testbeispiele getestet wird:

 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"

Hier ist f die generierte Funktion, die ähnlich wie add_binary_numbers funktioniert. Durch den Vergleich der Ausgabe der generierten Funktion mit der erwarteten Ausgabe für jedes Testbeispiel stellt AskIt sicher, dass sich die generierte Funktion wie erwartet verhält. Wenn Unstimmigkeiten auftreten, versucht AskIt die Übersetzung erneut. Nach mehreren erfolglosen Übersetzungsversuchen löst AskIt eine Ausnahme aus.

Angeben von Typen in AskIt

AskIt bietet APIs zur Festlegung der Ausgabetypen für Sprachlernmodelle (Language Learning Models, LLMs). Durch die Bereitstellung dieser Typen als erstes Argument für die ask und define -APIs können Sie das Ausgabeformat des LLM verwalten. Sie können auch die von Python bereitgestellten Typhinweise verwenden.

In der folgenden Tabelle werden die verschiedenen von AskIt unterstützten Typen beschrieben:

Typ	Beschreibung	Typbeispiel	Wertbeispiel
int	Ganze Zahl	t.int	123
float	Gleitkommazahl	t.float	1.23
bool	Boolescher Wert	t.bool	WAHR
str	Zeichenfolge	t.str	„Hallo Welt!“
literal	Wörtlich	t.literal(123)	123
list	Liste	t.list(t.int)	[1, 2, 3]
dict	Wörterbuch	t.dict({ 'a': t.int, 'b': t.str })	{'a': 1, 'b': "abc"}
record	Wörterbuch	t.record(t.str, t.int)	{'a': 1, 'b': 2}
tuple	Tupel	t.tuple(t.int, t.str)	(1, „abc“)
union	Union (mehrere mögliche Werte)	t.union(t.literal('yes'), t.literal('no'))	"ja oder nein"
		t.literal('yes') | t.literal('no')	"ja oder nein"
		t.literal('yes', 'no')	"ja oder nein"
None	Keiner	None	Keiner

Beachten Sie, dass jede Typdeklaration AskIt beim Analysieren und Verstehen der gewünschten Ausgabe unterstützt und sicherstellt, dass Ihr LLM Daten genau in dem Format zurückgibt, das Sie benötigen.

Sofortige Verwendung von Vorlagen

Die Eingabeaufforderungsvorlage ist eine Zeichenfolge, die aus Platzhaltern für die Parameter der zu definierenden Funktion besteht. Platzhalter werden durch doppelte geschweifte Klammern {{ und }} gekennzeichnet und können nur einen Variablennamen enthalten. Dieser Variablenname wird dann als Parameter in der definierten Funktion verwendet.

Funktionsparameter können auf zwei Arten definiert werden: entweder durch Schlüsselwortargumente oder durch Positionsargumente. Bei Schlüsselwortargumenten dient der Variablenname im Platzhalter als Name des Schlüsselwortarguments. Bei Positionsargumenten bestimmt die Reihenfolge, in der Platzhalter erscheinen, die Reihenfolge der Positionsargumente.

Betrachten Sie das folgende Beispiel, das zeigt, wie eine Funktion add definiert wird, die zwei Argumente x und y akzeptiert und deren Summe zurückgibt:

 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

In diesem Fall kann die add -Funktion entweder mit Schlüsselwort- oder Positionsargumenten aufgerufen werden, wobei die Summe von x und y als Ausgabe zurückgegeben wird.

Insbesondere wenn derselbe Variablenname in der Eingabeaufforderungsvorlage mehrmals verwendet wird, werden nachfolgende Verwendungen dem ersten Vorkommen zugeordnet. Beobachten Sie dieses Verhalten im folgenden Beispiel:

 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 ))

Hier erscheint {{x}} zweimal in der Eingabeaufforderungsvorlage. Das zweite Vorkommen von {{x}} wird auf das erste zurückgeführt. Obwohl {{z}} der vierte Platzhalter in der Vorlage ist, stimmt er daher mit dem dritten Argument der Funktion überein.

Mitwirken

Weitere Informationen zu unserem Verhaltenskodex und dem Verfahren zum Einreichen von Pull-Anfragen an uns finden Sie unter CONTRIBUTING.md.

Lizenz

Dieses Projekt ist unter der MIT-Lizenz lizenziert – Einzelheiten finden Sie in der Datei LICENSE.md

Zitat

Wenn Sie unsere Software in Ihrer Forschung nutzen, zitieren Sie bitte unseren Artikel:

 @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 }
}