Modelo de lenguaje: aplicación de GPT y HuggingFace

Este artículo se comparte desde la comunidad de la nube de Huawei "¿ Conoce los principios subyacentes del modelo de lenguaje grande?" Arquitectura subyacente del modelo de lenguaje grande, parte 2: implementación de GPT ", autor: Hua Shanghua_Lancer.

Afectado por el paradigma de usar ImageNet para entrenar previamente el modelo en el campo de la visión por computadora, de modo que el modelo pueda aprender completamente cómo extraer características a través de imágenes masivas y luego ajustar el modelo de acuerdo con los objetivos de la tarea, métodos basados Los modelos de lenguaje previamente entrenados en el campo del procesamiento del lenguaje natural también se están generalizando gradualmente. El modelo dinámico de vector de palabras representado por ELMo abrió la puerta al preentrenamiento de modelos de lenguaje. Desde entonces, la aparición de modelos de lenguaje preentrenados a gran escala basados en Transformer representado por GPT y BERT ha llevado el procesamiento del lenguaje natural a un nuevo paradigma de ajuste previo al entrenamiento.era.

Utilizando un rico corpus de entrenamiento, tareas de preentrenamiento autosupervisadas y estructuras de redes neuronales profundas como Transformer, el modelo de lenguaje preentrenado tiene capacidades universales y poderosas de representación del lenguaje natural y puede aprender vocabulario, gramática e información semántica de manera efectiva. Al aplicar el modelo previamente entrenado a tareas posteriores, no es necesario conocer demasiados detalles de la tarea ni diseñar una estructura de red neuronal específica, solo necesita "afinar" el modelo previamente entrenado, es decir, usar el modelo anotado. datos de la tarea específica en el modelo de lenguaje previamente entrenado. Con el entrenamiento supervisado, se pueden lograr mejoras significativas en el rendimiento.

El preentrenamiento generativo (GPT) propuesto por OpenAI en 2018 es uno de los modelos típicos de lenguaje generativo de preentrenamiento. La estructura del modelo GPT se muestra en la Figura 2.3. Es un modelo de lenguaje unidireccional compuesto por un transformador multicapa, que se divide principalmente en tres partes: capa de entrada, capa de codificación y capa de salida.
A continuación, me centraré en el entrenamiento previo no supervisado de GPT, el ajuste fino de tareas posteriores supervisadas y la práctica del modelo de lenguaje previo al entrenamiento basado en HuggingFace.

1. Entrenamiento previo sin supervisión

GPT utiliza un método de preentrenamiento generativo. Unidireccional significa que el modelo solo puede modelar secuencias de texto de izquierda a derecha o de derecha a izquierda. La estructura del transformador y la estrategia de decodificación adoptadas garantizan que cada posición del texto de entrada solo pueda depender del momento pasado Información.
Dada una secuencia de texto w = w1w2...wn, GPT primero la asigna a un vector denso en la capa de entrada:

Entre ellos, se encuentra el vector de palabra de la palabra wi, el vector de posición de la palabra wi y vi es la salida de la palabra en la posición i-ésima después de pasar por la capa de entrada del modelo (capa 0). La capa de entrada del modelo GPT es diferente del modelo de lenguaje de red neuronal introducido anteriormente en que necesita agregar

Figura 1.1 Estructura del modelo de lenguaje previamente entrenado GPT

Vector de posición, que se debe a que la propia estructura del Transformador no puede detectar la posición, por lo que se requiere información de posición adicional de la capa de entrada. Después de la codificación de la capa de entrada, el modelo obtiene la secuencia de vectores de representación v = v1...vn y luego envía v a la capa de codificación del modelo. La capa de codificación consta de módulos Transformador L. Bajo la acción del mecanismo de autoatención, cada vector de representación de cada capa contendrá la información del vector de representación de posición anterior, de modo que cada vector de representación tenga información contextual rica, y después de múltiples Codificación de capas, GPT puede obtener una representación combinada jerárquica de cada palabra. El proceso de cálculo se expresa de la siguiente manera:

Entre ellos, representa la secuencia de vectores de representación de la capa L, n es la longitud de la secuencia, d es la dimensión de la capa oculta del modelo y L es el número total de capas del modelo. La capa de salida del modelo GPT predice la probabilidad condicional en cada posición en función de la representación h (L) de la última capa. El proceso de cálculo se puede expresar como:

Entre ellos, se encuentra la matriz de vectores de palabras, |V| es el tamaño del vocabulario. El modelo de lenguaje unidireccional ingresa la secuencia de texto w de acuerdo con el orden de lectura y utiliza el objetivo del modelo de lenguaje convencional para optimizar la estimación de máxima verosimilitud de w, de modo que pueda hacer predicciones precisas para la palabra actual según la secuencia histórica de entrada. :

donde θ representa los parámetros del modelo. También es posible utilizar sólo una parte de las palabras pasadas para el entrenamiento basado en la hipótesis de Markov. Durante el entrenamiento previo, el método de descenso de gradiente estocástico generalmente se usa para la retropropagación para optimizar la función de probabilidad negativa.

2. Ajuste supervisado de las tareas posteriores.

A través del entrenamiento previo del modelo de lenguaje no supervisado, el modelo GPT tiene ciertas capacidades de representación semántica general. El propósito del ajuste fino de tareas posteriores es adaptarse de acuerdo con las características de las tareas posteriores basadas en la representación semántica universal. Las tareas posteriores generalmente necesitan usar conjuntos de datos etiquetados para el entrenamiento, que están representados por D. Cada muestra consta de una secuencia de texto x = x1x2...xn de longitud de entrada n y la etiqueta correspondiente y.
Primero, ingrese la secuencia de texto x en el modelo GPT para obtener la salida de la capa oculta h (L) n correspondiente a la última palabra de la última capa. Sobre esta base, el resultado de la predicción de la etiqueta se obtiene mediante la transformación de capa completamente conectada combinada con la función Softmax.

donde están los parámetros de la capa completamente conectada y k es el número de etiquetas.
Ajuste las tareas posteriores optimizando la siguiente función objetivo para todo el conjunto de datos anotado D :

Durante el proceso de ajuste de las tareas posteriores, la optimización de los objetivos de la tarea puede hacer que el modelo olvide fácilmente la representación del conocimiento semántico general aprendido en la etapa previa al entrenamiento, perdiendo así la versatilidad y la capacidad de generalización del modelo, lo que provoca el problema del olvido catastrófico ( Olvido Catastrófico). Por lo tanto, a menudo se adopta una pérdida híbrida de tareas previas al entrenamiento y una pérdida de ajuste posterior para aliviar los problemas anteriores . En aplicaciones prácticas, la siguiente fórmula generalmente se usa para ajustar las tareas posteriores:

El valor de λ es [0,1], que se utiliza para ajustar la tasa de pérdida de las tareas previas al entrenamiento.

3. Práctica del modelo de lenguaje previo al entrenamiento basado en HuggingFace

HuggingFace es una biblioteca de software de procesamiento de lenguaje natural de código abierto. Su objetivo es hacer que la tecnología de procesamiento del lenguaje natural sea más accesible para desarrolladores e investigadores proporcionando un conjunto completo de herramientas, bibliotecas y modelos. Una de las contribuciones más famosas de HuggingFace es la biblioteca Transformer, a partir de la cual los investigadores pueden implementar rápidamente modelos entrenados e implementar nuevas estructuras de red. Además, HuggingFace también proporciona una biblioteca de conjuntos de datos, lo que hace que sea muy conveniente descargar los conjuntos de datos de referencia más utilizados en la investigación del procesamiento del lenguaje natural. En esta sección, tomaremos la construcción del modelo BERT como ejemplo para presentar la construcción y el uso del modelo BERT basado en Huggingface.

3.1 Preparación de la recopilación de datos

Los conjuntos de datos comunes a gran escala utilizados para los modelos de lenguaje previo al entrenamiento se pueden descargar y cargar directamente en la biblioteca de conjuntos de datos. Por ejemplo, si utiliza la colección de corpus en inglés de Wikipedia, puede obtener datos directamente a través del siguiente código:

desde conjuntos de datos importe concatenate_datasets, load_dataset 
bookcorpus = load_dataset("bookcorpus", split="train") 
wiki = load_dataset("wikipedia", "20230601.en", split="train") 
# Solo mantenga la columna 'texto' 
wiki = wiki .remove_columns([col for col in wiki.column_names if col != "text"]) 
dataset = concatenate_datasets([bookcorpus, wiki]) 
# Divida el conjunto de datos en 90% para entrenamiento y 10% para prueba 
d = conjunto de datos. tren_prueba_split(test_size=0.1)

A continuación, guarde los datos de entrenamiento y prueba en archivos locales respectivamente.

def dataset_to_text(dataset, output_filename="data.txt"): 
    """Función de utilidad para guardar el texto del conjunto de datos en el disco, 
    útil para usar los textos para entrenar el tokenizador 
    (ya que el tokenizador acepta archivos)""" 
    con open(output_filename, "w") como f: 
        para t en el conjunto de datos["text"]: 
            print(t, file=f) 
# guardar el conjunto de entrenamiento en train.txt 
dataset_to_text(d["train"], "train.txt") 
# guarde el conjunto de pruebas en test.txt 
dataset_to_text(d["test"], "test.txt")

3.2 Tokenizador de entrenamiento

Como se mencionó anteriormente, BERT utiliza la segmentación de palabras de WordPiece para decidir si dividir una palabra completa en varios tokens según la frecuencia de las palabras en el corpus de entrenamiento. Por lo tanto, primero es necesario entrenar el Tokenizer. Puede utilizar la clase BertWordPiezaTokenizer en la biblioteca de transformadores para realizar la tarea. El código es el siguiente:

special_tokens = [ 
"[PAD]", "[UNK]", "[CLS]", "[SEP]", "[MASK]", "<S>", "<T>" 
]# 
si quieres entrenar el tokenizador en ambos conjuntos 
# archivos = ["train.txt", "test.txt"] 
# entrenar el tokenizador en los 
archivos del conjunto de entrenamiento = ["train.txt"] 
# 30,522 vocabulario es el tamaño de vocabulario predeterminado de BERT, siéntete libre para modificar 
vocab_size = 30_522 
# longitud máxima de la secuencia, reducirla resultará en un entrenamiento más rápido (al aumentar el tamaño del lote) 
max_length = 512 
# si se debe truncar 
truncate_longer_samples = False 
# inicializar el tokenizador de tokenizador de WordPieza 
= BertWordPiezaTokenizer() 
# entrenar el tokenizador 
tokenizer.train( files=files, vocab_size=vocab_size, special_tokens=special_tokens) 
# habilitar el truncamiento hasta el máximo de 512 tokens 
tokenizer.enable_truncation(max_length=max_length) 
model_path = "pretrained-bert" 
# crear el directorio si aún no está allí 
si no es os.path. isdir(model_path): 
    os.mkdir(model_path) 
# guarda el tokenizer 
tokenizer.save_model(model_path) 
# volca algunas de las configuraciones del tokenizer al archivo de configuración, 
# incluye tokens especiales, si están en minúsculas y la longitud máxima de la secuencia 
con open(os .path.join(model_path, "config.json"), "w") como f: 
    tokenizer_cfg = { 
        "do_lower_case": True, 
        "unk_token": "[UNK]", 
        "sep_token": "[SEP]", 
        "pad_token": "[PAD]", 
        "cls_token": "[CLS]", 
        "mask_token": "[MASK]", 
        "model_max_length": max_length, 
        "max_len": max_length, 
    } 
    json.dump(tokenizer_cfg, f ) 
# cuando el tokenizador esté entrenado y configurado, cárguelo como 
tokenizador BertTokenizerFast = BertTokenizerFast.from_pretrained(model_path)

3.3 Colección de corpus de preprocesamiento

Antes de comenzar todo el entrenamiento del modelo, el corpus de preentrenamiento debe procesarse de acuerdo con el Tokenizer entrenado. Si la longitud del documento supera los 512 tokens, se truncará directamente. El código de procesamiento de datos es el siguiente:

def encode_with_truncation(examples): 
    """Función de mapeo para tokenizar las oraciones pasadas con truncamiento""" 
    return tokenizer(examples["text"], truncation=True, padding="max_length", 
        max_length=max_length, return_special_tokens_mask=True) 
def encode_ without_truncation(examples): 
    """Función de mapeo para tokenizar las oraciones pasadas sin truncamiento""" 
    return tokenizer(examples["text"], return_special_tokens_mask=True) 
# la función de codificación dependerá de la variable truncate_longer_samples 
encode = encode_with_truncation if truncate_longer_samples else encode_ without_truncation 
# tokenizar el conjunto de datos del tren 
train_dataset = d["train"].map(encode, lotes=True) 
# tokenizar el conjunto de datos de prueba 
test_dataset = d["test"].map(encode, lotes=True) 
if truncate_longer_samples: 
    # eliminar otras columnas y establezca input_ids y atencion_mask como tensores de PyTorch 

    train_dataset.set_format(type="torch", columns=["input_ids", "attention_mask"]) 
    test_dataset.set_format(type="torch", columns=["input_ids", " atención_mask"]) 
else: 
    # eliminar otras columnas y dejarlas como listas de Python 
    test_dataset.set_format(columns=["input_ids", "attention_mask", "special_tokens_mask"]) 
    train_dataset.set_format(columns=["input_ids", "attention_mask ", "máscara_de_tokens_especiales"])

truncate_longer_samples Variable booleana para controlar la función de devolución de llamada encode() utilizada para tokenizar el conjunto de datos. Si se establece en Verdadero, las oraciones que excedan la longitud máxima de la secuencia (max_length) se truncarán. De lo contrario, no se producirá el truncamiento. Si truncate_longer_samples se establece en False, las muestras sin truncamiento deben concatenarse y combinarse en un vector de longitud fija.

3.4 Entrenamiento modelo

Después de construir el corpus de preentrenamiento procesado, se puede iniciar el entrenamiento del modelo. El código se ve así:

# inicializa el modelo con la configuración 
model_config = BertConfig(vocab_size=vocab_size, max_position_embeddings=max_length) 
model = BertForMaskedLM(config=model_config) 
# inicializa el recopilador de datos, enmascarando aleatoriamente el 20 % (el valor predeterminado es el 15 %) de los tokens 
# para los enmascarados Tarea de modelado de lenguaje (MLM) 
data_collator = DataCollatorForLanguageModeling( 
    tokenizer=tokenizer, mlm=True, mlm_probability=0.2 
) 
training_args = TrainingArguments( 
    output_dir=model_path, # directorio de salida donde guardar el punto de control del modelo 
    development_strategy="steps", # evaluar cada `logging_steps` pasos 
    overwrite_output_dir=True, 
    num_train_epochs=10, # número de épocas de entrenamiento, siéntete libre de modificar 
    per_device_train_batch_size=10, # el tamaño del lote de entrenamiento, ponlo tan alto como se ajuste a la memoria de tu GPU 
    gradient_accumulation_steps=8, # acumulando los gradientes antes de actualizar los pesos 
    per_device_eval_batch_size=64, # tamaño del lote de evaluación 
    logging_steps=1000, # evaluar, registrar y guardar puntos de control del modelo cada 1000 pasos 
    save_steps=1000, 
    # load_best_model_at_end=True, # si se carga el mejor modelo (en términos de pérdida) 
    # al final de entrenamiento 
    # save_total_limit=3, # si no tienes mucho espacio, por lo que 
    # dejas que solo se guarden 3 pesos de modelo en el disco 
) 
trainer = Trainer( 
    model=model, 
    args=training_args, 
    data_collator=data_collator, 
    train_dataset=train_dataset, 
    eval_dataset= test_dataset, 
) 
# entrenar el modelo 
trainer.train()

Después de comenzar el entrenamiento, los resultados se pueden generar de la siguiente manera:

[10135/79670 18:53:08 < 129:35:53, 0.15 it/s, Época 1.27/10] 
Pérdida de entrenamiento de pasos Pérdida de validación 
1000 6.904000 6.558231 
2000 6.498800 6.401168 
3000 6.362600 6. 277831 4000 
6,251000 6,172856 
5000 6,155800 6,071129 
6000 6,052800 5,942584 
7000 5,834900 5,546123 
8000 5,537200 
5,248503 9000 5,272700 4,934949 
10000 4,915900 4,549236

3.5 Uso del modelo

Según el modelo entrenado, se puede utilizar según diferentes requisitos de aplicación.

# cargar el modelo de punto de control model 
= BertForMaskedLM.from_pretrained(os.path.join(model_path, "checkpoint-10000")) 
# cargar el tokenizador 
tokenizer = BertTokenizerFast.from_pretrained(model_path) 
fill_mask = pipeline("fill-mask", model= model, tokenizer=tokenizer) 
# realizar predicciones 
ejemplos = [ 
"Los hashtags más populares de hoy en [MASK] es Donald Trump", 
"La [MASK] estuvo nublada ayer, pero hoy llueve.", 
] 
por ejemplo en ejemplos: 
    para predicción en fill_mask(ejemplo): 
        print(f"{prediction['sequence']}, confianza: {prediction['score']}") 
    print("="*50)

Puede obtener el siguiente resultado:

los hashtags más populares de hoy en Twitter es donald trump, confianza: 0.1027069091796875 los 
hashtags más populares de hoy el lunes es donald trump, confianza: 0.09271949529647827 los 
hashtags más populares de hoy el martes es donald trump, confianza: 0.08099588006734848 
el más popular de hoy Los hashtags de tendencia en Facebook son Donald Trump, confianza. : 0.04266013577580452 
Los hashtags más populares de hoy el miércoles son Donald Trump, confianza: 0.041206110268883125 
===================================== =============== 
el clima estuvo nublado ayer, pero hoy está lluvioso., confianza: 0.04445931687951088 
el día estuvo nublado ayer, pero hoy está lluvioso., confianza: 0.037249673157930374 
la mañana estuvo nublada ayer , pero hoy está lluvioso., confianza: 0.023775646463036537 
el fin de semana estuvo nublado ayer, pero hoy está lluvioso., confianza: 0.022554103285074234 
la tormenta estuvo nublada ayer, pero hoy está lluvioso., confianza: 0.019406016916036606 
========== ==========================================

Este artículo se centra en el entrenamiento previo no supervisado de GPT, el ajuste fino de tareas posteriores supervisadas y la práctica del modelo de lenguaje previo al entrenamiento basado en HuggingFace. En el próximo artículo, presentaré la estructura de red del modelo de lenguaje grande y la optimización del mecanismo de atención y otros aspectos relacionados. prácticas.

Artículo de referencia:

https://zhuanlan.zhihu.com/p/617643272
https://zhuanlan.zhihu.com/p/604592680

Haga clic para seguir y conocer las nuevas tecnologías de Huawei Cloud lo antes posible ~