Proporcionar un LLM perfeccionado con REST API

Afinar un modelo lingüístico es una buena forma de adaptarlo a un dominio o caso de uso específico. En nuestro Guía Konfuzio para el ajuste fino mostramos cómo entrenar un LLM con datos estructurados de permisos de circulación alemanes. Este tipo de documentos, con campos muy específicos y formatos de datos legalmente relevantes, se benefician enormemente de un LLM personalizado que entienda el contexto y la terminología.

Pero una vez entrenado el modelo, el siguiente paso es hacerlo accesible, idealmente en un entorno escalable, mantenible y seguro. En esta entrada de blog, nos basamos en este trabajo preliminar. Ahora el LLM personalizado se implementará con Docker, una API REST, el Konfuzio SDK y BentoML proporcionado.

¿Por qué proporcionar su modelo afinado?

El perfeccionamiento de un modelo lingüístico amplio (LLM) le permite utilizar la comprensión lingüística general adaptándola a las características únicas de sus datos, ya sea procesando documentos jurídicos, informes financieros o, como en nuestro caso, documentos de matriculación de vehículos. Pero un modelo perfeccionado sólo adquiere su valor cuando está listo para su uso de forma fiable.

Por lo tanto, la prestación de su LLM es importante:

• Suministro a través de una interfaz HTTPLas aplicaciones necesitan interfaces sencillas para interactuar con el modelo. Una API REST es el estándar para proporcionar predicciones de un LLM.
• Integración en otras aplicacionesTanto si se trata de un flujo de documentos, un chatbot o un servicio backend, debe ser capaz de integrar su modelo a la perfección.
• Reproducibilidad y aislamientoLos experimentos locales pueden fallar en producción si los entornos no son estables. Docker garantiza la coherencia.
• Acceso escalableComo contenedor y proporcionado a través de API, su modelo se convierte en un microservicio escalable, compatible con la nube y preparado para Kubernetes.
• Despliegues versionadosBentoML permite realizar el seguimiento, la actualización o la reversión de versiones de modelos, sin ningún esfuerzo de infraestructura.

La combinación de Docker para el aislamiento y BentoML para el empaquetado y despliegue sienta las bases para un despliegue sólido y fácil de mantener, con una sobrecarga mínima. El modelo es fácilmente accesible a través de una API REST generada automáticamente basada en FastAPI.

Paso 1: Integrar LLM en un canal SDK Konfuzio

Ampliamos AbstractExtractionAI y construir un proceso completo de extracción de licencias de vehículos con un LLM ajustado. Suponemos que los pesos entrenados se encuentran en el directorio de trabajo actual. Aquí, en la carpeta Vinlora:

from konfuzio_sdk.trainer.information_extraction import AbstractExtractionAI
class LLMExtractionAI(AbstractExtractionAI):
    alpaca_prompt = """Below is an instruction that describes a task, paired with an input that provides further context. Write a response that appropriately completes the request.
        ### Instruction:
        {}
        ### Input:
        {}
        ### Response:
        {}"""
    llm_model_name = "vinlora"
    llm_model = None
    llm_tokenizer = None
    def check_is_ready(self):
        pass
    def load_llm(self):
        from unsloth import FastLanguageModel
        max_seq_length = 2048
        self.llm_model, self.llm_tokenizer = FastLanguageModel.from_pretrained(
            model_name=self.llm_model_name,
            max_seq_length=max_seq_length,
            dtype=None,
            load_in_4bit=True,
        )
        FastLanguageModel.for_inference(self.llm_model)
    def run_llm(self, instruction: str, text: str) -> str:
        self.load_llm()
        inputs = self.llm_tokenizer([
            self.alpaca_prompt.format(instruction, text, "")
        ], return_tensors="pt").to("cuda")
        outputs = self.llm_model.generate(**inputs, max_new_tokens=128, use_cache=True)
        response = self.llm_tokenizer.batch_decode(outputs)
        return response[-1].split("\n")[-1].split("<|end_of_text|>")[0].strip()
    def extract(self, document: Document) -> Document:
        json_str = self.run_llm("Extract values from german car registration certificate and return them as JSON.", document.text)
        self.parse_json_to_annotations(json_str, document)
        return document
    def parse_json_to_annotations(self, json_str: str, document: Document) -> None:
        import re, json
        def normalize_ws(s: str) -> str:
            return re.sub(r'\s+', ' ', s).strip()
        data = json.loads(json_str)
        annotation_set = document.default_annotation_set
        label_mapping = {label.name: label for label in document.project.labels}
        for field_name, value in data.items():
            if field_name in label_mapping:
                label = label_mapping[field_name]
                value_pattern = re.escape(value.strip()).replace(r'\ ', r'\s+')
                match = re.search(value_pattern, document.text)
                if match:
                    span = Span(start_offset=match.start(), end_offset=match.end())
                    Annotation(
                        document=document,
                        label=label,
                        confidence=1.0,
                        label_set=label.label_sets[0],
                        annotation_set=annotation_set,
                        spans=[span]
                    )

Paso 2: Crear el servicio bento automáticamente

No necesita su propio servicio BentoML. Nuestro LLMExtractionAI contiene un método build_bentoque proporciona todo el flujo de trabajo de modelado como un paquete Bento:

project = Project(id_=PROJECT_ID, update=True)
pipeline = LLMExtractionAI(category=project.categories[0])
bento = pipeline.build_bento(pipeline)

Este método:

• Copia las plantillas de servicio Bento del konfuzio_sdk
• Integra metadatos e identificación de modelos
• Todo en un paquete BentoML listo para usar

Paso 3: Crear un contenedor Docker

Utilice la línea de comandos para la contenedorización. Esto crea una imagen Docker:

bentoml containerize extraction_<NAME>:latest

Contenedor de inicio:

docker run -p 3000:3000 extraction_<NAME>:latest

Llamada de prueba:

curl -X POST http://localhost:3000/predict -H "Content-Type: application/json" -d '{"text": "..."}'

La API proporcionada ya está documentada por una interfaz Swagger con especificación Open-API.

Conclusión

Esta guía le muestra cómo llevar su LLM afinado desde el entorno de desarrollo local hasta el despliegue listo para producción - integrado en el SDK Konfuzio, entregado como una API REST en el contenedor Docker. Tanto si eres un científico de datos como un ingeniero de ML, esta arquitectura crea una base estructurada y escalable.

El método build_bento es una herramienta útil para empaquetar modelos junto con metadatos, pesos de modelos y dependencias, y hacerlos versionables, pero no es la panacea. La atención se centra en una arquitectura general robusta: un modelo bien ajustado, integrado en un proceso versionado, proporcionado en un servicio en contenedor.

Se trata de un paso concreto hacia una IA lista para la producción: mantenible, comprobable y lista para su uso. En este artículo encontrará más información sobre la contenedorización y sus ventajas: Por qué las empresas deben recurrir a la contenedorización