kani
v1.2.3
Kani (カニ) é uma estrutura leve e altamente hackeable para modelos de idiomas baseados em bate-papo com uso de ferramentas/função.
Comparado a outras estruturas de LM, Kani é menos opinativo e oferece mais personalização de granulação fina sobre as partes do fluxo de controle que importam, tornando-a a escolha perfeita para pesquisadores, entusiastas e desenvolvedores da PNL.
Kani vem com suporte para os seguintes modelos prontos para a caixa, com uma estrutura modelo-agnóstica para adicionar suporte a muito mais:
Modelos hospedados
Modelos de código aberto
A Kani suporta todos os modelo de bate -papo disponíveis para abraçar o rosto através de transformers ou llama.cpp !
Em particular, temos implementações de referência para os seguintes modelos básicos e seus tunes finos:
Confira o zoológico do modelo para ver como usar cada um desses modelos em seu aplicativo!
Interessado em contribuir? Confira nosso guia.
Leia os documentos no ReadThedocs!
Leia nosso artigo sobre Arxiv!
Kani requer Python 3.10 ou acima. Para instalar dependências específicas do modelo, o Kani usa vários extras (colchetes após o nome da biblioteca na pip install ). Para determinar quais extras instalar, consulte a tabela modelo ou use o [all] extra para instalar tudo.
# for OpenAI models
$ pip install " kani[openai] "
# for Hugging Face models
$ pip install " kani[huggingface] " torch
# or install everything:
$ pip install " kani[all] " Para as alterações mais atualizadas e novos modelos, você também pode instalar a versão de desenvolvimento da filial main do Git:
$ pip install " kani[all] @ git+https://github.com/zhudotexe/kani.git@main " Kani requer Python 3.10 ou acima.
Primeiro, instale a biblioteca. Nesse início rápido, usaremos o mecanismo Openai, embora Kani seja modelo-agnóstico.
$ pip install " kani[openai] "Então, vamos usar o KANI para criar um chatbot simples usando o ChatGPT como back -end.
# 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 faz o tempo para configurar um modelo de bate -papo em funcionamento curto, oferecendo ao programador a personalização profunda em todas as chamadas de função, e até o modelo de idioma subjacente.
A chamada de função oferece aos modelos de idiomas a capacidade de escolher quando chamar uma função que você fornece com base na sua documentação.
Com Kani, você pode escrever funções no Python e expô -las ao modelo com apenas uma linha de código: o 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 garante que as chamadas de função sejam válidas quando atingem seus métodos, permitindo que você se concentre na redação do código. Para mais informações, consulte a função que chama documentos.
Kani suporta respostas de streaming do modelo de idioma subjacente a token, mesmo na presença de chamadas de função. O streaming foi projetado para ser um superconjunto dos métodos chat_round e full_round , permitindo que você refatore gradualmente seu código sem nunca deixá-lo em um estado quebrado.
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 ()As estruturas existentes para modelos de idiomas como Langchain e Simpleaichat são opinativas e/ou pesos pesados - eles editam os prompts dos desenvolvedores sob o capô, são desafiadores de aprender e são difíceis de personalizar sem adicionar muito inchaço de alta manutenção à sua base de código.
Construímos Kani como uma alternativa mais flexível, simples e robusta. Uma boa analogia entre estruturas seria dizer que Kani é para Langchain como frasco (ou fastapi) é para Django.
Kani é apropriado para todos, de pesquisadores acadêmicos a profissionais do setor e a quemedistas, sem se preocupar com hacks embaixo do alojamento.
Para saber mais sobre como personalizar Kani com seus próprios invólucros, chamadas de funcionamento e muito mais, leia os documentos!
Ou dê uma olhada nos exemplos práticos neste repositório.
Quer ver Kani em ação? Usando quantização de 4 bits para reduzir o modelo, executamos o LLAMA V2 como parte de nossa suíte de teste corretamente nas ações do GitHub:
https://github.com/zhudotexe/kani/actions/workflows/pytest.yml?Query=branch%3Amain+is%3asuccess
Basta clicar na versão mais recente para ver a produção da LLAMA!
A equipe de desenvolvimento principal é feita de três estudantes de doutorado no Departamento de Computação e Ciência da Informação da Universidade da Pensilvânia. Somos todos membros do laboratório do Prof. Chris Callison-Burch, trabalhando para avançar no futuro da PNL.
Usamos Kani ativamente em nossa pesquisa e pretendemos mantê-la atualizada com as práticas modernas da PNL.
Se você usa Kani, cite -nos 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",
}
Gostaríamos de agradecer aos membros do laboratório de Chris Callison-Burch por seus testes e feedback detalhado sobre o conteúdo do nosso artigo e do repositório Kani. Além disso, gostaríamos de agradecer a Henry Zhu (sem relação com o primeiro autor) por seu apoio inicial e entusiasmado ao projeto.
Esta pesquisa é baseada no trabalho apoiado em parte pelo Laboratório de Pesquisa da Força Aérea (contrato FA8750-23-C-0507), o Programa de Hiato da IARPA (Contrato 2022-220722005) e o NSF (Prêmio 1928631). Aprovado para liberação pública, distribuição ilimitada. As opiniões e conclusões aqui contidas são as dos autores e não devem ser interpretadas como necessariamente representando as políticas oficiais, expressas ou implícitas, de IARPA, NSF ou governo dos EUA.
