outlines
v0.1.7
?️ Faça com que os LLMs falem a linguagem de cada aplicação. ?️
Feito com ❤?️ pela equipe em .txt.
Canal do Youtube | blog .txt | Twitter
pip install outlinesPrimeira vez aqui? Acesse nosso guia de configuração
outlinesdev/outlines !Outlines tem novos lançamentos e recursos todas as semanas. Certifique-se de marcar com estrela e ? assista a este repositório, siga @dottxtai para se manter atualizado!
Começamos uma empresa para continuar ultrapassando os limites da geração estruturada. Saiba mais sobre .txt e experimente nossa API .json se precisar de uma solução hospedada
O primeiro passo para a confiabilidade de sistemas que incluem grandes modelos de linguagem é garantir que haja uma interface bem definida entre sua saída e o código definido pelo usuário. Outlines fornece maneiras de controlar a geração de modelos de linguagem para tornar sua saída mais previsível.
Você pode reduzir a conclusão a uma escolha entre múltiplas possibilidades:
import outlines
model = outlines . models . transformers ( "microsoft/Phi-3-mini-4k-instruct" )
prompt = """You are a sentiment-labelling assistant.
Is the following review positive or negative?
Review: This restaurant is just awesome!
"""
generator = outlines . generate . choice ( model , [ "Positive" , "Negative" ])
answer = generator ( prompt )Você pode instruir o modelo para retornar apenas números inteiros ou flutuantes:
import outlines
model = outlines . models . transformers ( "WizardLM/WizardMath-7B-V1.1" )
prompt = "<s>result of 9 + 9 = 18</s><s>result of 1 + 2 = "
answer = outlines . generate . format ( model , int )( prompt )
print ( answer )
# 3
prompt = "sqrt(2)="
generator = outlines . generate . format ( model , float )
answer = generator ( prompt , max_tokens = 10 )
print ( answer )
# 1.41421356 Outlines também vem com geração rápida estruturada de regex. Na verdade, as funções de choice e format usam acima de tudo a geração estruturada de regex nos bastidores:
import outlines
model = outlines . models . transformers ( "microsoft/Phi-3-mini-4k-instruct" )
prompt = "What is the IP address of the Google DNS servers? "
generator = outlines . generate . text ( model )
unstructured = generator ( prompt , max_tokens = 30 )
generator = outlines . generate . regex (
model ,
r"((25[0-5]|2[0-4]d|[01]?dd?).){3}(25[0-5]|2[0-4]d|[01]?dd?)" ,
)
structured = generator ( prompt , max_tokens = 30 )
print ( unstructured )
# What is the IP address of the Google DNS servers?
#
# Passive DNS servers are at DNS servers that are private.
# In other words, both IP servers are private. The database
# does not contain Chelsea Manning
print ( structured )
# What is the IP address of the Google DNS servers?
# 2.2.6.1Ao contrário de outras bibliotecas, a geração estruturada de regex no Outlines é quase tão rápida quanto a geração não estruturada.
Outlines permite orientar o processo de geração para que a saída siga um esquema JSON ou modelo Pydantic:
from enum import Enum
from pydantic import BaseModel , constr
import outlines
import torch
class Weapon ( str , Enum ):
sword = "sword"
axe = "axe"
mace = "mace"
spear = "spear"
bow = "bow"
crossbow = "crossbow"
class Armor ( str , Enum ):
leather = "leather"
chainmail = "chainmail"
plate = "plate"
class Character ( BaseModel ):
name : constr ( max_length = 10 )
age : int
armor : Armor
weapon : Weapon
strength : int
model = outlines . models . transformers ( "microsoft/Phi-3-mini-4k-instruct" )
# Construct structured sequence generator
generator = outlines . generate . json ( model , Character )
# Draw a sample
seed = 789001
character = generator ( "Give me a character description" , seed = seed )
print ( repr ( character ))
# Character(name='Anderson', age=28, armor=<Armor.chainmail: 'chainmail'>, weapon=<Weapon.sword: 'sword'>, strength=8)
character = generator ( "Give me an interesting character description" )
print ( repr ( character ))
# Character(name='Vivian Thr', age=44, armor=<Armor.plate: 'plate'>, weapon=<Weapon.crossbow: 'crossbow'>, strength=125)O método funciona com tipos de união, tipos opcionais, arrays, esquemas aninhados, etc. Algumas restrições de campo ainda não são suportadas, mas todo o resto deve funcionar.
Às vezes, você só deseja passar um esquema JSON em vez de um modelo Pydantic. Nós ajudamos você:
import outlines
schema = '''{
"title": "Character",
"type": "object",
"properties": {
"name": {
"title": "Name",
"maxLength": 10,
"type": "string"
},
"age": {
"title": "Age",
"type": "integer"
},
"armor": {"$ref": "#/definitions/Armor"},
"weapon": {"$ref": "#/definitions/Weapon"},
"strength": {
"title": "Strength",
"type": "integer"
}
},
"required": ["name", "age", "armor", "weapon", "strength"],
"definitions": {
"Armor": {
"title": "Armor",
"description": "An enumeration.",
"enum": ["leather", "chainmail", "plate"],
"type": "string"
},
"Weapon": {
"title": "Weapon",
"description": "An enumeration.",
"enum": ["sword", "axe", "mace", "spear", "bow", "crossbow"],
"type": "string"
}
}
}'''
model = outlines . models . transformers ( "microsoft/Phi-3-mini-4k-instruct" )
generator = outlines . generate . json ( model , schema )
character = generator ( "Give me a character description" )As gramáticas formais governam o mundo, e os Outlines fazem com que elas também governem os LLMs. Você pode passar qualquer gramática livre de contexto no formato EBNF e o Outlines gerará uma saída válida para esta gramática:
import outlines
arithmetic_grammar = """
?start: expression
?expression: term (("+" | "-") term)*
?term: factor (("*" | "/") factor)*
?factor: NUMBER
| "-" factor
| "(" expression ")"
%import common.NUMBER
"""
model = outlines . models . transformers ( "WizardLM/WizardMath-7B-V1.1" )
generator = outlines . generate . cfg ( model , arithmetic_grammar )
sequence = generator ( "Alice had 4 apples and Bob ate 2. Write an expression for Alice's apples:" )
print ( sequence )
# (8-2) Esta era uma gramática muito simples e você pode usar outlines.generate.cfg para gerar Python, SQL sintaticamente válidos e muito mais do que isso. Qualquer tipo de texto estruturado, na verdade. Basta pesquisar por "gramática X EBNF" na web e dar uma olhada no módulo grammars Outlines.
Os contornos podem inferir a estrutura da saída a partir da assinatura de uma função. O resultado é um dicionário e pode ser passado diretamente para a função usando a sintaxe usual de expansão de dicionário ** :
import outlines
def add ( a : int , b : int ):
return a + b
model = outlines . models . transformers ( "WizardLM/WizardMath-7B-V1.1" )
generator = outlines . generate . json ( model , add )
result = generator ( "Return json with two integers named a and b respectively. a is odd and b even." )
print ( add ( ** result ))
# 3Uma grande vantagem de passar funções diretamente para especificar a estrutura é que a estrutura do LLM mudará com a definição da função. Não há necessidade de alterar o código em vários lugares!
Você também pode incorporar várias funções em um enum para gerar parâmetros:
from enum import Enum
from functools import partial
import outlines
def add ( a : int , b : int ) -> int :
return a + b
def mul ( c : float , d : float ) -> float :
return c * d
class Operation ( Enum ):
add = partial ( add )
mul = partial ( mul )
model = outlines . models . transformers ( "WizardLM/WizardMath-7B-V1.1" )
generator = outlines . generate . json ( model , add )
result = generator ( "Return json with two float named c and d respectively. c is negative and d greater than 1.0." )
print ( result )
# {'c': -3.14, 'd': 1.5} Criar prompts pode ficar confuso. O Outlines facilita escrever e gerenciar prompts encapsulando modelos dentro de "funções de modelo".
Estas funções tornam possível separar nitidamente a lógica do prompt da lógica geral do programa; eles podem ser importados de outros módulos e bibliotecas.
As funções de modelo não requerem abstração supérflua, elas usam o mecanismo de modelagem Jinja2 para ajudar a construir prompts complexos de maneira concisa:
import outlines
examples = [
( "The food was disgusting" , "Negative" ),
( "We had a fantastic night" , "Positive" ),
( "Recommended" , "Positive" ),
( "The waiter was rude" , "Negative" )
]
@ outlines . prompt
def labelling ( to_label , examples ):
"""You are a sentiment-labelling assistant.
{% for example in examples %}
{{ example[0] }} // {{ example[1] }}
{% endfor %}
{{ to_label }} //
"""
model = outlines . models . transformers ( "microsoft/Phi-3-mini-4k-instruct" )
prompt = labelling ( "Just awesome" , examples )
answer = outlines . generate . text ( model )( prompt , max_tokens = 100 ) @article{willard2023efficient,
title={Efficient Guided Generation for LLMs},
author={Willard, Brandon T and Louf, R{'e}mi},
journal={arXiv preprint arXiv:2307.09702},
year={2023}
}
