outlines
v0.1.7
?️ Lassen Sie LLMs die Sprache jeder Bewerbung sprechen. ?️
Hergestellt mit ❤?️ vom Team von .txt.
Youtube-Kanal | .txt-Blog | Twitter
pip install outlinesZum ersten Mal hier? Gehen Sie zu unserer Einrichtungsanleitung
outlinesdev/outlines !Outlines bringt jede Woche neue Veröffentlichungen und Funktionen auf den Markt. Stellen Sie sicher, dass Sie ein Sternchen und ? Sehen Sie sich dieses Repository an, folgen Sie @dottxtai, um auf dem Laufenden zu bleiben!
Wir haben ein Unternehmen gegründet, um die Grenzen der strukturierten Generierung weiter zu erweitern. Erfahren Sie mehr über .txt und probieren Sie unsere .json-API aus, wenn Sie eine gehostete Lösung benötigen
Der erste Schritt zur Zuverlässigkeit von Systemen, die große Sprachmodelle umfassen, besteht darin, sicherzustellen, dass zwischen ihrer Ausgabe und dem benutzerdefinierten Code eine klar definierte Schnittstelle besteht. Outlines bietet Möglichkeiten, die Generierung von Sprachmodellen zu steuern, um deren Ausgabe vorhersehbarer zu machen.
Sie können die Vervollständigung auf eine Auswahl zwischen mehreren Möglichkeiten reduzieren:
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 )Sie können das Modell anweisen, nur Ganzzahlen oder Gleitkommazahlen zurückzugeben:
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 verfügt außerdem über eine schnelle Generierung von Regex-Strukturen. Tatsächlich nutzen die choice und format vor allem die Regex-strukturierte Generierung unter der Haube:
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.1Im Gegensatz zu anderen Bibliotheken ist die Regex-strukturierte Generierung in Outlines fast so schnell wie die nichtstrukturierte Generierung.
Outlines ermöglicht die Steuerung des Generierungsprozesses, sodass die Ausgabe garantiert einem JSON-Schema oder einem Pydantic-Modell folgt:
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)Die Methode funktioniert mit Union-Typen, optionalen Typen, Arrays, verschachtelten Schemata usw. Einige Feldeinschränkungen werden noch nicht unterstützt, aber alles andere sollte funktionieren.
Manchmal möchten Sie einfach ein JSON-Schema anstelle eines Pydantic-Modells übergeben können. Wir sind für Sie da:
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" )Formale Grammatiken beherrschen die Welt, und Outlines sorgt dafür, dass sie auch LLMs beherrschen. Sie können jede kontextfreie Grammatik im EBNF-Format übergeben und Outlines generiert eine Ausgabe, die für diese Grammatik gültig ist:
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) Dies war eine sehr einfache Grammatik, und Sie können outlines.generate.cfg verwenden, um syntaktisch gültiges Python, SQL und vieles mehr zu generieren. Eigentlich jede Art von strukturiertem Text. Sie müssen lediglich im Internet nach „X EBNF-Grammatik“ suchen und einen Blick auf das Outlines grammars werfen.
Outlines können aus der Signatur einer Funktion auf die Struktur der Ausgabe schließen. Das Ergebnis ist ein Wörterbuch und kann mithilfe der üblichen Wörterbucherweiterungssyntax ** direkt an die Funktion übergeben werden:
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 ))
# 3Ein großer Vorteil der direkten Übergabe von Funktionen zur Angabe der Struktur besteht darin, dass sich die Struktur des LLM mit der Definition der Funktion ändert. Der Code muss nicht an mehreren Stellen geändert werden!
Sie können auch verschiedene Funktionen in eine Aufzählung einbetten, um Parameter zu generieren:
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} Eingabeaufforderungen beim Erstellen können chaotisch werden. Outlines erleichtert das Schreiben und Verwalten von Eingabeaufforderungen, indem Vorlagen in „Vorlagenfunktionen“ gekapselt werden.
Diese Funktionen ermöglichen es, die Eingabeaufforderungslogik sauber von der allgemeinen Programmlogik zu trennen; Sie können aus anderen Modulen und Bibliotheken importiert werden.
Vorlagenfunktionen erfordern keine überflüssige Abstraktion, sie nutzen die Jinja2-Template-Engine, um komplexe Eingabeaufforderungen auf prägnante Weise zu erstellen:
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}
}
