hfppl

Llamppl + Huggingface

LAMPLPL es un prototipo de investigación para la programación probabilística del modelo de lenguaje: especificando tareas de generación de idiomas escribiendo programas probabilísticos que combinan llamadas a LLM, lógica del programa simbólico y condicionamiento probabilístico. Para resolver estas tareas, LLAMPPL utiliza un algoritmo de inferencia de Monte Carlo secuencial especializado. Esta técnica, la dirección SMC, se describe en nuestro reciente resumen del taller.

Este repositorio implementa LAMPPL para su uso con los transformadores de Huggingface.

Instalación

Si solo desea probar LLAMPPL, consulte nuestro cuaderno de demostración en Colab, que realiza una tarea de generación limitada simple con GPT-2. (Los modelos más grandes pueden requerir más recursos de RAM o GPU que la versión gratuita de Colab).

Nota

Usamos poesía para administrar las dependencias. Si no tiene la poesía instalada, puede instalarla con pip install poetry .

Para comenzar con su propia máquina, clone este repositorio y ejecute poetry install para instalar hfppl y sus dependencias.

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

Luego, intente ejecutar un ejemplo. Tenga en cuenta que esto hará que se descarguen los pesos para Vicuna-7B-V1.5.

 poetry run python examples/hard_constraints.py

Si todo funciona, debería ver que el modelo genera noticias políticas utilizando palabras que tienen como máximo cinco letras (por ejemplo ", la Dra. Jill Biden aún puede estar a un año de la Casa Blanca, pero está listo para hacer su primer viaje a la ONU hoy").

Modelado con LlamPPL

Un programa LLAMPPL es una subclase de la clase 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' ])

La clase Model proporciona una serie de métodos útiles para especificar un programa LAMPPL:

• self.sample(dist[, proposal]) muestras de la distribución dada. Proporcionar una propuesta no modifica la descripción de la tarea, pero puede mejorar la inferencia. Aquí, por ejemplo, utilizamos una propuesta que evita preventamente la carta prohibida.
• condición self.condition(cond) en la expresión booleana dada.
• self.finish() indica que la generación está completa.
• self.observe(dist, obs) realiza una forma de 'acondicionamiento suave' en la distribución dada. Es equivalente a (pero más eficiente que) muestreando un valor v de dist y luego condition(v == obs) .

Para ejecutar inferencia, usamos los métodos smc_steer o 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

Salida de muestra:

 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.

Se puede encontrar más documentación en https://probcomp.github.io/hfppl.