hfppl

Lllamppl + Huggingface

Llamppl adalah prototipe penelitian untuk model bahasa pemrograman probabilistik: menentukan tugas pembuatan bahasa dengan menulis program probabilistik yang menggabungkan panggilan ke LLMS, logika program simbolik, dan pengkondisian probabilistik. Untuk menyelesaikan tugas -tugas ini, Lllamppl menggunakan algoritma inferensi Monte Carlo berurutan khusus. Teknik ini, SMC Steering, dijelaskan dalam lokakarya terbaru kami Abstrak.

Repositori ini mengimplementasikan Llllapppl untuk digunakan dengan transformator huggingface.

Instalasi

Jika Anda hanya ingin mencoba Llamppl, lihat buku catatan demo kami di Colab, yang melakukan tugas generasi terbatas sederhana menggunakan GPT-2. (Model yang lebih besar mungkin memerlukan lebih banyak sumber daya RAM atau GPU daripada yang disediakan versi gratis Colab.)

Catatan

Kami menggunakan puisi untuk mengelola dependensi. Jika Anda tidak menginstal puisi, Anda dapat menginstalnya dengan pip install poetry .

Untuk memulai mesin Anda sendiri, klon repositori ini dan jalankan poetry install untuk menginstal hfppl dan dependensinya.

 git clone https://github.com/probcomp/hfppl
cd hfppl
poetry install

Kemudian, coba jalankan contoh. Perhatikan bahwa ini akan menyebabkan bobot untuk Vicuna-7b-V1.5 diunduh.

 poetry run python examples/hard_constraints.py

Jika semuanya berfungsi, Anda harus melihat model menghasilkan berita politik menggunakan kata -kata yang paling lama lima huruf (misalnya, "Dr. Jill Biden mungkin masih setahun lagi dari Gedung Putih tetapi dia akan melakukan perjalanan pertamanya ke PBB hari ini.").

Pemodelan dengan llamppl

Program LLAMPPL adalah subclass dari kelas hfppl.Model .

 from hfppl import Model , LMContext , CachedCausalLM

# A LLaMPPL model subclasses the Model class
class MyModel ( Model ):

    # The __init__ method is used to process arguments
    # and initialize instance variables.
    def __init__ ( self , lm , prompt , forbidden_letter ):
        super (). __init__ ()

        # A stateful context object for the LLM, initialized with the prompt
        self . context = LMContext ( lm , prompt )
        self . eos_token = lm . tokenizer . eos_token_id
        
        # The forbidden letter
        self . forbidden_tokens = set ( i for ( i , v ) in enumerate ( lm . vocab )
                                      if forbidden_letter in v )
    
    # The step method is used to perform a single 'step' of generation.
    # This might be a single token, a single phrase, or any other division.
    # Here, we generate one token at a time.
    async def step ( self ):
        # Condition on the next token *not* being a forbidden token.
        await self . observe ( self . context . mask_dist ( self . forbidden_tokens ), False )
        
        # Sample the next token from the LLM -- automatically extends `self.context`.
        token = await self . sample ( self . context . next_token ())

        # Check for EOS or end of sentence
        if token . token_id == self . eos_token or str ( token ) in [ '.' , '!' , '?' ]:
            # Finish generation
            self . finish ()

    # To improve performance, a hint that `self.forbidden_tokens` is immutable
    def immutable_properties ( self ):
        return set ([ 'forbidden_tokens' ])

Kelas Model menyediakan sejumlah metode yang berguna untuk menentukan program LLAMPPL:

• self.sample(dist[, proposal]) sampel dari distribusi yang diberikan. Memberikan proposal tidak memodifikasi deskripsi tugas, tetapi dapat meningkatkan inferensi. Di sini, misalnya, kami menggunakan proposal yang sebelumnya menghindari surat terlarang.
• Kondisi self.condition(cond) pada ekspresi boolean yang diberikan.
• self.finish() menunjukkan bahwa generasi selesai.
• self.observe(dist, obs) melakukan bentuk 'pengkondisian lunak' pada distribusi yang diberikan. Ini setara dengan (tetapi lebih efisien dari) mencicipi nilai v dari dist dan kemudian segera berjalan condition(v == obs) .

Untuk menjalankan inferensi, kami menggunakan metode smc_steer atau smc_standard :

 import asyncio
from hfppl import smc_steer

# Initialize the HuggingFace model
lm = CachedCausalLM . from_pretrained ( "meta-llama/Llama-2-7b-hf" , auth_token = < YOUR_HUGGINGFACE_API_TOKEN_HERE > )

# Create a model instance
model = MyModel ( lm , "The weather today is expected to be" , "e" )

# Run inference
particles = asyncio . run ( smc_steer ( model , 5 , 3 )) # number of particles N, and beam factor K

Output sampel:

 sunny.
sunny and cool.
34° (81°F) in Chicago with winds at 5mph.
34° (81°F) in Chicago with winds at 2-9 mph.
hot and humid with a possibility of rain, which is not uncommon for this part of Mississippi.

Dokumentasi lebih lanjut dapat ditemukan di https://probcomp.github.io/hfppl.