ESG-BERT

Cómo empezar con el modelo

pip install torchserve torch-model-archiver
pip install torchvision
pip install transformers

Luego, configuraremos el script de manejador (handler). Es un manejador básico para la clasificación de texto que puede mejorarse. Guarde este script como "handler.py" en su directorio.

from abc import ABC
import json
import logging
import os
import torch
from transformers import AutoModelForSequenceClassification, AutoTokenizer
from ts.torch_handler.base_handler import BaseHandler
logger = logging.getLogger(__name__)
class TransformersClassifierHandler(BaseHandler, ABC):
    def __init__(self):
        super(TransformersClassifierHandler, self).__init__()
        self.initialized = False
    def initialize(self, ctx):
        self.manifest = ctx.manifest
        properties = ctx.system_properties
        model_dir = properties.get("model_dir")
        self.device = torch.device("cuda:" + str(properties.get("gpu_id")) if torch.cuda.is_available() else "cpu")
        # Leer archivo de modelo serializado/pt
        self.model = AutoModelForSequenceClassification.from_pretrained(model_dir)
        self.tokenizer = AutoTokenizer.from_pretrained(model_dir)
        self.model.to(self.device)
        self.model.eval()
        logger.debug('Modelo de transformador cargado exitosamente desde {0}'.format(model_dir))
        # Leer archivo de mapeo, índice a nombre de objeto
        mapping_file_path = os.path.join(model_dir, "index_to_name.json")
        if os.path.isfile(mapping_file_path):
            with open(mapping_file_path) as f:
                self.mapping = json.load(f)
        else:
            logger.warning('Falta el archivo index_to_name.json. La salida de inferencia no incluirá el nombre de la clase.')
        self.initialized = True
    def preprocess(self, data):
        text = data[0].get("data")
        if text is None:
            text = data[0].get("body")
        sentences = text.decode('utf-8')
        logger.info("Texto recibido: '%s'", sentences)
        inputs = self.tokenizer.encode_plus(
            sentences,
            add_special_tokens=True,
            return_tensors="pt"
        )
        return inputs
    def inference(self, inputs):
        prediction = self.model(
            inputs['input_ids'].to(self.device),
            token_type_ids=inputs['token_type_ids'].to(self.device)
        )[0].argmax().item()
        logger.info("Predicción del modelo: '%s'", prediction)
        if self.mapping:
            prediction = self.mapping[str(prediction)]
        return [prediction]
    def postprocess(self, inference_output):
        return inference_output
_service = TransformersClassifierHandler()
def handle(data, context):
    try:
        if not _service.initialized:
            _service.initialize(context)
        if data is None:
            return None
        data = _service.preprocess(data)
        data = _service.inference(data)
        data = _service.postprocess(data)
        return data
    except Exception as e:
        raise e

TorchServe usa un formato llamado MAR (Archivo de Modelo). Podemos convertir nuestro modelo de PyTorch a un archivo .mar usando este comando:

torch-model-archiver --model-name "bert" --version 1.0 --serialized-file ./bert_model/pytorch_model.bin --extra-files "./bert_model/config.json,./bert_model/vocab.txt" --handler "./handler.py"

Mover el archivo .mar a un nuevo directorio:

mkdir model_store && mv bert.mar model_store

Finalmente, podemos iniciar TorchServe usando el comando:

torchserve --start --model-store model_store --models bert=bert.mar

Ahora podemos consultar el modelo desde otra ventana de terminal usando la API de Inferencia. Pasamos un archivo de texto que contiene texto que el modelo intentará clasificar.

curl -X POST http://127.0.0.1:8080/predictions/bert -T predict.txt