kani
v1.2.3
Kani (カニ) es un marco ligero y altamente hackable para modelos de idiomas basados en chat con uso/llamadas de funciones de herramientas.
En comparación con otros marcos de LM, Kani es menos obstinado y ofrece una personalización más de grano fino sobre las partes del flujo de control que importa, lo que lo convierte en la opción perfecta para los investigadores, aficionados y desarrolladores de PNL, tanto.
Kani viene con soporte para los siguientes modelos fuera de la caja, con un marco agnóstico modelo para agregar soporte para muchos más:
Modelos alojados
Modelos de código abierto
Kani admite cada modelo de chat disponible en la cara de abrazo a través de transformers o llama.cpp !
En particular, tenemos implementaciones de referencia para los siguientes modelos base y sus ajustes finos:
¡Vea el zoológico del modelo para ver cómo usar cada uno de estos modelos en su aplicación!
¿Interesado en contribuir? Echa un vistazo a nuestra guía.
¡Lea los documentos en Readthedocs!
¡Lea nuestro artículo sobre Arxiv!
Kani requiere Python 3.10 o superior. Para instalar dependencias específicas del modelo, Kani utiliza varios extras (soportes después del nombre de la biblioteca en pip install ). Para determinar qué extra (s) instalar, consulte la tabla de modelos o use los [all] extra para instalar todo.
# for OpenAI models
$ pip install " kani[openai] "
# for Hugging Face models
$ pip install " kani[huggingface] " torch
# or install everything:
$ pip install " kani[all] " Para los cambios más actualizados y los nuevos modelos, también puede instalar la versión de desarrollo de la rama main de Git:
$ pip install " kani[all] @ git+https://github.com/zhudotexe/kani.git@main " Kani requiere Python 3.10 o superior.
Primero, instale la biblioteca. En este arranque rápido, usaremos el motor Operai, aunque Kani es agnóstico modelo.
$ pip install " kani[openai] "Luego, usemos Kani para crear un chatbot simple usando chatgpt como 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 se toma el tiempo de configurar un modelo de chat de trabajo corto, al tiempo que ofrece al programador una profunda personalización sobre cada llamada de solicitud, función de función e incluso el modelo de lenguaje subyacente.
La llamada de función le da a los modelos de lenguaje la capacidad de elegir cuándo llamar a una función que proporciona en función de su documentación.
Con Kani, puede escribir funciones en Python y exponerlas al modelo con solo una línea de código: el decorador @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 garantiza que las llamadas de funciones son válidas para el momento en que llegan a sus métodos al tiempo que le permiten concentrarse en escribir código. Para obtener más información, consulte la función llamando a los documentos.
Kani admite las respuestas de transmisión del modelo de lenguaje subyacente token-by-token, incluso en presencia de llamadas de funciones. La transmisión está diseñada para ser un superconjunto de los métodos chat_round y full_round , lo que le permite refactorizar gradualmente su código sin dejarlo en un estado roto.
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 ()Los marcos existentes para modelos de idiomas como Langchain y Simpleaichat son de peso pesado y/o pesado: editan las indicaciones de los desarrolladores bajo el capó, son difíciles de aprender y son difíciles de personalizar sin agregar una gran cantidad de hinchazón de alto mantenimiento a su base de código.
Construimos Kani como una alternativa más flexible, simple y robusta. Una buena analogía entre los marcos sería decir que Kani es Langchain como frasco (o fastapi) es para Django.
Kani es apropiado para todos, desde investigadores académicos hasta profesionales de la industria y aficionados a usar sin preocuparse por los trucos subterráneos.
Para obtener más información sobre cómo personalizar a Kani con sus propios envoltorios rápidos, llamar a funciones y más, ¡lea los documentos!
O eche un vistazo a los ejemplos prácticos en este repositorio.
¿Quieres ver a Kani en acción? Usando cuantificación de 4 bits para encoger el modelo, ejecutamos Llama V2 como parte de nuestro conjunto de pruebas directamente en las acciones de GitHub:
https://github.com/zhudotexe/kani/acciones/workflows/pytest.yml?query=Branch%3amain+is%3Asuccess
¡Simplemente haga clic en la última compilación para ver la salida de Llama!
El equipo de desarrollo principal está hecho de tres estudiantes de doctorado en el Departamento de Informática y Ciencias de la Información de la Universidad de Pensilvania. Todos somos miembros del laboratorio del profesor Chris Callison-Burch, trabajando para avanzar en el futuro de la PNL.
Usamos Kani activamente en nuestra investigación y tenemos el objetivo de mantenerlo actualizado con las prácticas modernas de PNL.
Si usa Kani, cíquanos como:
@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",
}
Nos gustaría agradecer a los miembros del laboratorio de Chris Callison-Burch por sus pruebas y comentarios detallados sobre el contenido de nuestro documento y el repositorio de Kani. Además, nos gustaría agradecer a Henry Zhu (sin relación con el primer autor) por su apoyo temprano y entusiasta del proyecto.
Esta investigación se basa en el trabajo apoyado en parte por el Laboratorio de Investigación de la Fuerza Aérea (Contrato FA8750-23-C-0507), el Programa IARPA Hiatus (Contrato 2022-22072200005) y el NSF (premio 1928631). Aprobado para la liberación pública, distribución ilimitada. Las opiniones y conclusiones contenidas en este documento son las de los autores y no deben interpretarse como necesariamente que representen las políticas oficiales, ya sea expresadas o implícitas, de IARPA, NSF o el gobierno de los Estados Unidos.
