hfppl

Llamppl + Umarmung

LLAMPPL ist ein Forschungsprototyp für das probabilistische Programmieren von Sprachmodell: Angabe von Aufgaben der Sprachgenerierung durch Schreiben von probabilistischen Programmen, die Aufrufe an LLMs, symbolische Programmlogik und probabilistische Konditionierung kombinieren. Um diese Aufgaben zu lösen, verwendet Llamppl einen spezialisierten sequentiellen Monte -Carlo -Inferenzalgorithmus. Diese Technik, SMC -Lenkung, wird in unserem jüngsten Workshop -Zusammenfassung beschrieben.

Dieses Repository implementiert LLAMPPL zur Verwendung mit Harmgingface -Transformatoren.

Installation

Wenn Sie nur LlamPPL ausprobieren möchten, lesen Sie unser Demo-Notizbuch in Colab, das eine einfache Aufgabe der eingeschränkten Generation mit GPT-2 ausführt. (Größere Modelle erfordern möglicherweise mehr RAM- oder GPU -Ressourcen als die kostenlose Version von Colab bietet.)

Notiz

Wir verwenden Poesie, um Abhängigkeiten zu verwalten. Wenn Sie keine Gedichte installiert haben, können Sie sie mit pip install poetry installieren.

Klonen Sie dieses Repository und führen Sie poetry install aus, um hfppl und seine Abhängigkeiten zu installieren.

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

Versuchen Sie dann ein Beispiel auszuführen. Beachten Sie, dass dies dazu führt, dass die Gewichte für Vicuna-7b-V1.5 heruntergeladen werden.

 poetry run python examples/hard_constraints.py

Wenn alles funktioniert, sollten Sie sehen, dass das Modell politische Nachrichten mit Wörtern generiert, die höchstens fünf Buchstaben sind (z. B. "Dr. Jill Biden ist möglicherweise noch ein Jahr vom Weißen Haus entfernt, aber sie wird heute ihre erste Reise zur UNO machen.")

Modellierung mit llamppl

Ein LLAMPPL -Programm ist eine Unterklasse der hfppl.Model -Klasse.

 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' ])

Die Modellklasse bietet eine Reihe nützlicher Methoden zur Angabe eines LLAMPPL -Programms:

• self.sample(dist[, proposal]) Proben aus der gegebenen Verteilung. Die Bereitstellung eines Vorschlags ändert die Aufgabenbeschreibung nicht, kann jedoch die Schlussfolgerung verbessern. Hier verwenden wir beispielsweise einen Vorschlag, der den verbotenen Brief präventiv vermeidet.
• self.condition(cond) Bedingungen für den gegebenen booleschen Ausdruck.
• self.finish() gibt an, dass die Generation vollständig ist.
• self.observe(dist, obs) führt eine Form der „weichen Konditionierung“ auf der gegebenen Verteilung durch. Es entspricht (aber effizienter als) einen Wert v aus dist und dann sofort laufende condition(v == obs) .

Um den Inferenz auszuführen, verwenden wir die Methoden smc_steer oder 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

Beispielausgabe:

 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.

Weitere Dokumentationen finden Sie unter https://probcomp.github.io/hfppl.