kani
v1.2.3
Kani (カニ カニ) ist ein leichtes und sehr hackbares Framework für Chat-basierte Sprachmodelle mit Tools-Nutzung/Funktionsaufruf.
Im Vergleich zu anderen LM-Frameworks ist Kani weniger aufmerksam und bietet eine feinkörnigere Anpassbarkeit gegenüber den Teilen des Kontrollflusss, was es zur perfekten Wahl für NLP-Forscher, Hobbyisten und Entwickler macht.
Kani unterstützt die folgenden Modelle mit einem modellagnostischen Rahmen, um viele weitere Unterstützung zu unterstützen:
Gehostete Modelle
Open Source -Modelle
Kani unterstützt jedes Chat -Modell, das auf Umarmung von Face durch transformers oder llama.cpp verfügbar ist!
Insbesondere haben wir Referenzimplementierungen für die folgenden Basismodelle und deren Feinhöhe:
Schauen Sie sich den Modellzoo an, um zu sehen, wie Sie jedes dieser Modelle in Ihrer Anwendung verwenden!
Interessiert an einem Beitrag? Schauen Sie sich unseren Leitfaden an.
Lesen Sie die Dokumente über Redethedocs!
Lesen Sie unser Papier über Arxiv!
Kani benötigt Python 3.10 oder höher. Um modellspezifische Abhängigkeiten zu installieren, verwendet Kani verschiedene Extras (Klammern nach dem Namen der Bibliothek in pip install ). Um zu bestimmen, welche zusätzlichen (n) installiert werden sollen, siehe die Modelltabelle oder verwenden Sie die [all] zusätzliche, um alles zu installieren.
# for OpenAI models
$ pip install " kani[openai] "
# for Hugging Face models
$ pip install " kani[huggingface] " torch
# or install everything:
$ pip install " kani[all] " Für die aktuellsten Änderungen und neuen Modelle können Sie die Entwicklungsversion auch aus main von GIT installieren:
$ pip install " kani[all] @ git+https://github.com/zhudotexe/kani.git@main " Kani benötigt Python 3.10 oder höher.
Installieren Sie zuerst die Bibliothek. In diesem QuickStart werden wir den OpenAI-Motor verwenden, obwohl Kani modellagnostisch ist.
$ pip install " kani[openai] "Verwenden wir dann Kani, um einen einfachen Chatbot mit Chatgpt als Backend zu erstellen.
# 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 hat sich die Zeit, ein Arbeitsmodell kurz zu errichten, und bietet dem Programmierer eine tiefe Anpassung in Bezug auf jeden Eingabeaufruf, jeden Funktionsaufruf und sogar das zugrunde liegende Sprachmodell an.
Das Aufrufen von Funktionen gibt Sprachmodelle die Möglichkeit zu wählen, wann Sie eine Funktion aufrufen, die Sie basierend auf der Dokumentation bereitstellen sollen.
Mit Kani können Sie Funktionen in Python schreiben und sie dem Modell mit nur einer Codezeile aussetzen: dem Dekorator @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 garantiert, dass Funktionsaufrufe zum Zeitpunkt der Erreichung Ihrer Methoden gültig sind und gleichzeitig sich auf das Schreiben von Code konzentrieren können. Weitere Informationen finden Sie in den Funktionen, die Dokumente aufrufen.
Kani unterstützt Streaming-Antworten aus dem zugrunde liegenden Sprachmodell-Token-by-Token, selbst in Gegenwart von Funktionsaufrufen. Das Streaming ist so konzipiert, dass es sich um ein Drop-In-Superset der Methoden chat_round und full_round handelt, sodass Sie Ihren Code nach und nach nach oben nacharbeiten können, ohne ihn jemals in einem kaputten Zustand zu lassen.
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 ()Vorhandene Frameworks für Sprachmodelle wie Langchain und SimpleAichat sind überlegen und/oder schweres Gewicht - sie bearbeiten die Aufforderungen der Entwickler unter der Haube, sind schwierig zu lernen und sind schwer anpassen, ohne Ihrem Codebasis viel wartungsfreie Aufblähen hinzuzufügen.
Wir haben Kani als flexiblere, einfache und robustere Alternative gebaut. Eine gute Analogie zwischen Frameworks wäre zu sagen, dass Kani Langchain als Flask (oder Fastapi) zu Django ist.
Kani ist für alle, von akademischen Forschern bis hin zu Branchenfachleuten bis hin zu Hobbyisten, angemessen, ohne sich über Hacks unter dem Haus zu sorgen.
Um mehr darüber zu erfahren, wie Sie Kani mit Ihren eigenen Schnellverpackungen, Funktionen aufrufen und mehr anpassen können, lesen Sie die Dokumente!
Oder werfen Sie einen Blick auf die praktischen Beispiele in diesem Repo.
Möchten Sie Kani in Aktion sehen? Mit der 4-Bit-Quantisierung, um das Modell zu verkleinern, führen wir Lama V2 als Teil unserer Testsuite direkt auf Github-Aktionen aus:
https://github.com/zhudotexe/kani/actions/workflows/pytest.yml?query=branch%3amain+ iis%3asuccess
Klicken Sie einfach auf den neuesten Build, um Lamas Ausgabe zu sehen!
Das Kern -Entwicklungsteam besteht aus drei Doktoranden der Abteilung für Computer- und Informationswissenschaft der Universität von Pennsylvania. Wir sind alle Mitglieder des Labors von Prof. Chris Callison-Burch und arbeiten daran, die Zukunft von NLP voranzutreiben.
Wir nutzen Kani aktiv in unserer Forschung und wollen es mit modernen NLP-Praktiken auf dem Laufenden halten.
Wenn Sie Kani verwenden, zitieren Sie uns bitte als:
@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",
}
Wir möchten uns bei den Mitgliedern des Labors von Chris Callison-Burch für ihre Tests und detailliertes Feedback zum Inhalt unseres Papiers und des Kani-Repositorys bedanken. Außerdem möchten wir Henry Zhu (keine Beziehung zum Erstautor) für seine frühe und enthusiastische Unterstützung des Projekts danken.
Diese Forschung basiert auf Arbeiten, die teilweise vom Air Force Research Laboratory (Vertrag FA8750-23-C-0507), dem IARPA-Pause (Vertrag 2022-22072200005) und dem NSF (Award 1928631) unterstützt werden. Für die öffentliche Freigabe zugelassen, Distribution Unlimited. Die hierin enthaltenen Ansichten und Schlussfolgerungen sind die der Autoren und sollten nicht so interpretiert werden, dass die offiziellen Politiken, die entweder ausgedrückt oder impliziert sind, von IARPA, NSF oder der US -Regierung.
