Garis Besar Logo

?️ Jadikan LLM berbicara dalam bahasa setiap aplikasi. ?️

Dibuat dengan ❤?️ oleh tim di .txt.

saluran Youtube | blog .txt | Twitter

pip install outlines

Pertama kali ke sini? Buka panduan pengaturan kami

Fitur

Outlines memiliki rilis dan fitur baru yang hadir setiap minggu. Pastikan untuk memberi bintang dan ? tonton repositori ini, ikuti @dottxtai untuk mendapatkan informasi terbaru!

Mengapa saya harus menggunakan generasi terstruktur?

Itu tidak menambah overhead apa pun selama inferensi (bebas biaya)
Hal ini memungkinkan model Sumber Terbuka mengalahkan model sumber tertutup (Mistral, GPT-4)
Ini mempercepat inferensi
Ini meningkatkan kinerja model dasar (GSM8K)
Ini meningkatkan kinerja model yang disempurnakan (CoNNL)
Ini meningkatkan efisiensi model (lebih sedikit contoh yang diperlukan)

.txt perusahaan

Kami memulai sebuah perusahaan untuk terus mendorong batas-batas generasi terstruktur. Pelajari lebih lanjut tentang .txt, dan cobalah API .json kami jika Anda memerlukan solusi yang dihosting

Generasi terstruktur

Langkah pertama menuju keandalan sistem yang mencakup model bahasa besar adalah memastikan bahwa ada antarmuka yang terdefinisi dengan baik antara keluarannya dan kode yang ditentukan pengguna. Garis besar menyediakan cara untuk mengontrol pembuatan model bahasa agar keluarannya lebih dapat diprediksi.

Pilihan ganda

Anda dapat mengurangi penyelesaian menjadi pilihan di antara beberapa kemungkinan:

 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 )

Ketik batasan

Anda dapat menginstruksikan model untuk hanya mengembalikan bilangan bulat atau float:

 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

Generasi terstruktur regex yang efisien

Garis besar juga dilengkapi dengan pembuatan terstruktur regex yang cepat. Faktanya, fungsi choice dan format terutama menggunakan pembuatan terstruktur regex:

 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.1

Tidak seperti perpustakaan lainnya, pembuatan terstruktur regex di Outlines hampir sama cepatnya dengan pembuatan tidak terstruktur.

Pembuatan JSON yang efisien mengikuti model Pydantic

Garis besar memungkinkan untuk memandu proses pembuatan sehingga keluaran dijamin mengikuti skema JSON atau model 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)

Metode ini berfungsi dengan tipe gabungan, tipe opsional, array, skema bersarang, dll. Beberapa batasan bidang belum didukung, tetapi yang lainnya akan berfungsi.

Pembuatan JSON yang efisien mengikuti Skema JSON

Terkadang Anda hanya ingin meneruskan Skema JSON alih-alih model Pydantic. Kami siap membantu Anda:

 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" )

Menggunakan tata bahasa bebas konteks untuk memandu pembuatan

Tata bahasa formal menguasai dunia, dan Garis Besar menjadikannya menguasai LLM juga. Anda dapat meneruskan tata bahasa bebas konteks apa pun dalam format EBNF dan Garis Besar akan menghasilkan keluaran yang valid untuk tata bahasa ini:

 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)

Ini adalah tata bahasa yang sangat sederhana, dan Anda dapat menggunakan outlines.generate.cfg untuk menghasilkan Python, SQL, dan banyak lagi yang valid secara sintaksis. Teks terstruktur apa pun, kok. Yang harus Anda lakukan adalah mencari "X EBNF grammar" di web, dan melihat modul Outlines grammars .

Buka fungsi

Garis besar dapat menyimpulkan struktur keluaran dari tanda tangan suatu fungsi. Hasilnya adalah kamus, dan dapat diteruskan langsung ke fungsi menggunakan sintaks perluasan kamus biasa ** :

 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 ))
# 3

Keuntungan besar meneruskan fungsi secara langsung untuk menentukan struktur adalah bahwa struktur LLM akan berubah seiring dengan definisi fungsi. Tidak perlu mengubah kode di beberapa tempat!

Anda juga dapat menyematkan berbagai fungsi ke dalam enum untuk menghasilkan params:

 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}

Dorongan

Perintah pembuatan bisa menjadi berantakan. Garis besar mempermudah penulisan dan pengelolaan perintah dengan merangkum templat di dalam "fungsi templat".

Fungsi-fungsi ini memungkinkan pemisahan logika prompt dari logika program umum dengan rapi; mereka dapat diimpor dari modul dan perpustakaan lain.

Fungsi template tidak memerlukan abstraksi yang berlebihan, fungsi template menggunakan mesin template Jinja2 untuk membantu membuat perintah kompleks dengan cara yang ringkas:

 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 )

Bergabunglah dengan kami

Punya ide? Ayo ngobrol dengan kami di Discord
? Ingin berkontribusi? Konsultasikan panduan kontribusi kami.
? Menemukan bug? Buka masalah

Kutip Garis Besar

 @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}
}