kani
v1.2.3
Kani (カニ) est un framework léger et hautement piratable pour les modèles de langage basés sur le chat avec utilisation d'outils / appels de fonction.
Par rapport à d'autres cadres LM, Kani est moins opiniâtre et offre une personnalisation plus fine sur les parties du flux de contrôle qui comptent, ce qui en fait le choix parfait pour les chercheurs, les amateurs et les développeurs.
Kani est livré avec une prise en charge des modèles suivants hors de la boîte, avec un framework d'automobiles de modèle pour ajouter la prise en charge de bien d'autres:
Modèles hébergés
Modèles open source
Kani prend en charge tous les modèles de chat disponibles sur les câlins à travers transformers ou llama.cpp !
En particulier, nous avons des implémentations de référence pour les modèles de base suivants et leurs fins fines:
Consultez le Zoo Model pour voir comment utiliser chacun de ces modèles dans votre application!
Intéressé à contribuer? Consultez notre guide.
Lisez les documents sur ReadTheDocs!
Lisez notre article sur Arxiv!
Kani nécessite Python 3.10 ou plus. Pour installer des dépendances spécifiques au modèle, Kani utilise divers extras (supports après le nom de la bibliothèque dans pip install ). Pour déterminer les supplémentaires à installer, consultez la table du modèle ou utilisez le [all] supplémentaire pour tout installer.
# for OpenAI models
$ pip install " kani[openai] "
# for Hugging Face models
$ pip install " kani[huggingface] " torch
# or install everything:
$ pip install " kani[all] " Pour les modifications les plus à jour et les nouveaux modèles, vous pouvez également installer la version de développement de la branche main de Git:
$ pip install " kani[all] @ git+https://github.com/zhudotexe/kani.git@main " Kani nécessite Python 3.10 ou plus.
Installez d'abord la bibliothèque. Dans ce quickstart, nous utiliserons le moteur Openai, bien que Kani soit agnostique modèle.
$ pip install " kani[openai] "Ensuite, utilisons Kani pour créer un chatbot simple à l'aide de Chatgpt comme backend.
# import the library
import asyncio
from kani import Kani , chat_in_terminal
from kani . engines . openai import OpenAIEngine
# Replace this with your OpenAI API key: https://platform.openai.com/account/api-keys
api_key = "sk-..."
# kani uses an Engine to interact with the language model. You can specify other model
# parameters here, like temperature=0.7.
engine = OpenAIEngine ( api_key , model = "gpt-4o-mini" )
# The kani manages the chat state, prompting, and function calling. Here, we only give
# it the engine to call ChatGPT, but you can specify other parameters like
# system_prompt="You are..." here.
ai = Kani ( engine )
# kani comes with a utility to interact with a kani through your terminal...
chat_in_terminal ( ai )
# or you can use kani programmatically in an async function!
async def main ():
resp = await ai . chat_round ( "What is the airspeed velocity of an unladen swallow?" )
print ( resp . text )
asyncio . run ( main ())Kani prend le temps de configurer un modèle de chat de travail court, tout en offrant au programmeur une personnalisation profonde sur chaque invite, un appel de fonction et même le modèle de langue sous-jacent.
L'appel de fonction donne aux modèles de langage la possibilité de choisir quand appeler une fonction que vous fournissez en fonction de sa documentation.
Avec Kani, vous pouvez écrire des fonctions dans Python et les exposer au modèle avec une seule ligne de code: le décorateur @ai_function .
# import the library
import asyncio
from typing import Annotated
from kani import AIParam , Kani , ai_function , chat_in_terminal , ChatRole
from kani . engines . openai import OpenAIEngine
# set up the engine as above
api_key = "sk-..."
engine = OpenAIEngine ( api_key , model = "gpt-4o-mini" )
# subclass Kani to add AI functions
class MyKani ( Kani ):
# Adding the annotation to a method exposes it to the AI
@ ai_function ()
def get_weather (
self ,
# and you can provide extra documentation about specific parameters
location : Annotated [ str , AIParam ( desc = "The city and state, e.g. San Francisco, CA" )],
):
"""Get the current weather in a given location."""
# In this example, we mock the return, but you could call a real weather API
return f"Weather in { location } : Sunny, 72 degrees fahrenheit."
ai = MyKani ( engine )
# the terminal utility allows you to test function calls...
chat_in_terminal ( ai )
# and you can track multiple rounds programmatically.
async def main ():
async for msg in ai . full_round ( "What's the weather in Tokyo?" ):
print ( msg . role , msg . text )
asyncio . run ( main ())Kani garantit que les appels de fonction sont valables au moment où ils atteignent vos méthodes tout en vous permettant de vous concentrer sur l'écriture de code. Pour plus d'informations, consultez la fonction d'appel des documents.
Kani prend en charge les réponses en streaming à partir du token de langue sous-jacente par token par-token, même en présence d'appels de fonction. Le streaming est conçu pour être un superset sans rendez-vous des méthodes chat_round et full_round , vous permettant de refacter progressivement votre code sans jamais le quitter dans un état brisé.
async def stream_chat ():
stream = ai . chat_round_stream ( "What does kani mean?" )
async for token in stream :
print ( token , end = "" )
print ()
msg = await stream . message () # or `await stream`
async def stream_with_function_calling ():
async for stream in ai . full_round_stream ( "What's the weather in Tokyo?" ):
async for token in stream :
print ( token , end = "" )
print ()
msg = await stream . message ()Les cadres existants pour les modèles de langage comme Langchain et SimpleAichat sont opinionnés et / ou les poids lourds - ils modifient les invites des développeurs sous le capot, sont difficiles à apprendre et sont difficiles à personnaliser sans ajouter beaucoup de ballonnements à haute maintenance à votre base de code.
Nous avons construit Kani comme une alternative plus flexible, simple et robuste. Une bonne analogie entre les cadres serait de dire que Kani est à Langchain comme Flask (ou Fastapi) est à Django.
Kani est approprié pour tous, des chercheurs universitaires aux professionnels de l'industrie, aux amateurs de lanceurs sans se soucier des hacks sous le capot.
Pour en savoir plus sur la façon de personnaliser Kani avec vos propres emballages rapides, appels de fonction, etc., lisez les documents!
Ou jetez un œil aux exemples pratiques de ce dépôt.
Vous voulez voir Kani en action? En utilisant la quantification 4 bits pour réduire le modèle, nous exécutons LLAMA V2 dans le cadre de notre suite de tests sur les actions GitHub:
https://github.com/zhudotexe/kani/actions/Workflow
Cliquez simplement sur la dernière version pour voir la sortie de Llama!
L'équipe de développement de base est composée de trois doctorants du Département des sciences informatiques et de l'information à l'Université de Pennsylvanie. Nous sommes tous membres du laboratoire du professeur Chris Callison-Burch, travaillant à faire progresser l'avenir de la PNL.
Nous utilisons activement Kani dans nos recherches et visons à le maintenir à jour avec les pratiques de PNL modernes.
Si vous utilisez Kani, veuillez nous citer comme:
@inproceedings{zhu-etal-2023-kani,
title = "Kani: A Lightweight and Highly Hackable Framework for Building Language Model Applications",
author = "Zhu, Andrew and
Dugan, Liam and
Hwang, Alyssa and
Callison-Burch, Chris",
editor = "Tan, Liling and
Milajevs, Dmitrijs and
Chauhan, Geeticka and
Gwinnup, Jeremy and
Rippeth, Elijah",
booktitle = "Proceedings of the 3rd Workshop for Natural Language Processing Open Source Software (NLP-OSS 2023)",
month = dec,
year = "2023",
address = "Singapore",
publisher = "Association for Computational Linguistics",
url = "https://aclanthology.org/2023.nlposs-1.8",
doi = "10.18653/v1/2023.nlposs-1.8",
pages = "65--77",
}
Nous tenons à remercier les membres du laboratoire de Chris Callison-Burch pour leurs tests et leurs commentaires détaillés sur le contenu de notre article et du référentiel Kani. De plus, nous tenons à remercier Henry Zhu (pas de relation avec le premier auteur) pour son soutien précoce et enthousiaste du projet.
Cette recherche est basée sur les travaux soutenus en partie par le Laboratoire de recherche de l'Air Force (Contrat FA8750-23-C-0507), le programme IARPA Hiatus (Contrat 2022-22072200005) et le NSF (Award 1928631). Approuvé pour la libération publique, Distribution Unlimited. Les opinions et les conclusions contenues ici sont celles des auteurs et ne doivent pas être interprétées comme représentant nécessairement les politiques officielles, exprimées ou implicites, de l'IARPA, du NSF ou du gouvernement américain.
