Entrene su propio LLM similar a ChatGPT con FlanT5 y Replicate

Con el crecimiento de modelos LLM como ChatGPT, las empresas se han apresurado a comercializar aplicaciones de aprendizaje profundo basadas en lenguajes. Empresas como Duolingo y Blinkist están creando aplicaciones de chat educativas, empresas como Cocounsel están creando modelos de análisis de documentos y algunas, como MedGPT, incluso están creando modelos especializados que pueden hacer cosas como diagnósticos médicos. En un artículo anterior, escribí sobre cómo alguien puede usar ChatGPT y solicitar ingeniería para construir un potente analizador de documentos.

Para admitir aplicaciones LLM más potentes y específicas de dominio, los proveedores de tecnología han puesto a disposición muchas soluciones en la nube. OpenAI, la compañía detrás de ChatGPT, por ejemplo, ha puesto a disposición de los usuarios una API de ajuste simple pero potente, que les permite crear sus propios modelos de lenguaje basados en la tecnología GPT3. Google, para no quedarse atrás, puso a disposición su modelo de texto bisonte, ampliamente considerado un competidor capaz de GPT 3 y GPT 3.5, para realizar ajustes a través de la plataforma Google Cloud. En un artículo anterior, escribí sobre cómo utilizar la API de ajuste para crear un LLM experto en dominios.

Por muy poderosos que puedan ser estos servicios, una empresa que esté considerando una inversión seria en tecnología LLM querrá aprender a entrenar sus propios modelos a partir de tecnologías de código abierto. En comparación con el uso de estos puntos finales proporcionados por proveedores, entrenar su propio modelo ofrece las siguientes ventajas :

• Obtiene la flexibilidad de elegir y cambiar su infraestructura de implementación. Esto puede generar ahorros de costos, una integración más estrecha y, quizás lo más importante en aplicaciones médicas y financieras, más privacidad.
• Obtendrá más control sobre la tecnología subyacente, lo que le permitirá elegir entre modelos de código abierto para utilizar. Se crean diferentes modelos de código abierto teniendo en cuenta diferentes casos de uso, y usted puede elegir la mejor herramienta para el trabajo.
• Sus aplicaciones estarán más preparadas para el futuro. Al utilizar tecnología de código abierto, usted puede establecer su propio ritmo de desarrollo. Puede utilizar tecnología de última generación y no tendrá que preocuparse por la baja de los proveedores ni las interrupciones del servicio.

En este artículo, tomaremos un modelo LLM de código abierto popular y capaz, lo entrenaremos con nuestros propios datos de manera similar a lo que hicimos en un artículo anterior y validaremos los resultados. Si bien el ejemplo que estamos abordando no es comercial y se basa en información pública, las técnicas pueden aplicarse fácilmente a iniciativas comerciales. Profundizaremos en sugerencias específicas sobre qué aplicaciones comerciales se pueden construir utilizando esta técnica en la sección "Modelo LLM experto" donde definimos el problema que resolveremos en este artículo.

Tecnologías subyacentes

Flan-T5

Para el experimento de hoy, confiaremos en Flan-T5 Large, que es un modelo de lenguaje grande lanzado por Google. Si bien esta no es la tecnología subyacente a Bard, se considera que este modelo es competitivo con las tecnologías basadas en GPT. Sin embargo, lo impresionante de los modelos Flan T5 es que logran resultados satisfactorios utilizando muchos menos parámetros que los modelos basados en GPT. Incluso la versión XL del modelo, por ejemplo, sólo tiene 3 mil millones de parámetros, frente a GPT3, que tiene 175 mil millones.

Como resultado de esta compacidad, resulta relativamente económico entrenar y almacenar estos modelos en activos de computación en la nube. Además, la familia de modelos Flan-T5 se lanza con la licencia Apache, que permite el uso comercial, lo que reduce los posibles dolores de cabeza que acompañan a algunos de los otros LLM de código abierto. LLaMa de Facebook, por ejemplo, todavía está disponible sólo para fines de investigación y no comerciales.

Para escribir este artículo, experimenté con algunas clases diferentes de tareas para probar la efectividad de la tecnología. En general, Flan-T5, especialmente la variante XL, parece tener grandes capacidades de comprensión del lenguaje natural similares a algunos de los modelos GPT del mercado. Sin embargo, el modelo se queda corto al dibujar conexiones abstractas y tiene algunos problemas para generar resultados largos. Por lo tanto, hay que tener cuidado al seleccionar el modelo adecuado para la tarea adecuada.

Reproducir exactamente

Replicate es una empresa de plataforma como servicio que permite a las personas alquilar GPU para entrenar y ejecutar grandes modelos de IA a un precio asequible. Su conjunto de herramientas de gestión de modelos de IA permite a los usuarios centrarse en trabajar con datos en lugar de gestionar los recursos del servidor.

Para escribir este artículo, probé varias ofertas de PaaS de entrenamiento de IA, incluidas AWS SageMaker, Google Colab y PaperSpace Gradient. Replicate fue, con diferencia, la plataforma más sencilla para empezar y ofrecía precios muy competitivos en comparación con los otros servicios mencionados.

Pitón

Python es la lengua franca de la ingeniería de datos. El extenso ecosistema permite a los programadores ingerir, analizar y procesar datos rápidamente. La mayoría de las principales plataformas de formación de IA tienen soporte de primera clase para Python, lo que facilita mucho nuestro trabajo. Debido a la excelente integración de Replicate, hoy escribiremos todo nuestro código en Python.

Modelo LLM experto

Clasificador de dramaturgos

Debido a que la familia de modelos Flan-T5 es mucho mejor para comprender texto que para generar texto, queremos elegir una tarea que tenga mucha entrada pero poca salida. Los clasificadores de lenguaje natural son un caso de uso perfecto para este tipo de escenario, por lo que hoy crearemos un identificador de dramaturgo. Específicamente, le daremos al modelo pasajes de William Shakespeare o Anton Chekhov, y veremos si podemos enseñarle al modelo a identificar al dramaturgo según el estilo de escritura y la elección de palabras.

Por supuesto, debido a que este es un tutorial público, elegimos intencionalmente un modelo con datos públicos y de fácil acceso. Sin embargo, esto se puede adaptar fácilmente a un contexto comercial . A continuación se muestran algunos ejemplos en los que los clasificadores de lenguaje natural pueden resultar útiles:

• Clasificar las opiniones y quejas de los clientes en varias categorías, como problemas de envío, calidad del producto, servicio al cliente, etc.
• Realizar un análisis de sentimiento en la transcripción de una llamada de ventas para ver si el cliente potencial tuvo un cambio en su estado de ánimo durante la llamada.
• Analizar una gran cantidad de transcripciones de llamadas de resultados para determinar si los directores ejecutivos son generalmente alcistas o bajistas.

Construyendo los datos de entrenamiento

Para crear los datos de entrenamiento, podemos descargar algunas obras de Anton Chekhov y William Shakespeare del Proyecto Gutenberg. Para configurar la ingesta de datos, podemos ejecutar el siguiente script de Python.

 import requests import openai import replicate import os import pandas as pd import random texts = { 'chekhov': 'https://www.gutenberg.org/files/7986/7986-0.txt', 'chekhov_2': 'https://www.gutenberg.org/cache/epub/1755/pg1755.txt', 'shakespeare_midsummer': 'https://www.gutenberg.org/cache/epub/1514/pg1514.txt', 'shakespeare_romeo_juliet': 'https://www.gutenberg.org/cache/epub/1112/pg1112.txt', 'shakespeare_macbeth': 'https://www.gutenberg.org/cache/epub/2264/pg2264.txt', 'shakespeare_hamlet': 'https://www.gutenberg.org/cache/epub/2265/pg2265.txt', }

Ahora creamos la carpeta de datos de entrenamiento y descargamos los textos:

 if not os.path.exists('training_text'): os.mkdir('training_text') for name, url in texts.items(): print(name) res = requests.get(url) with open(os.path.join('training_text', '%s.txt' % name), 'w') as fp_write: fp_write.write(res.text)

Debería ver algunos resultados como este para mostrarle que tuvo éxito:

 chekhov chekhov_2 shakespeare_midsummer shakespeare_romeo_juliet shakespeare_macbeth Shakespeare_hamlet

También puede consultar la carpeta Training_text para ver que los archivos se descargaron correctamente.

Ahora queremos volver a leer estos archivos en la memoria y dividirlos en una lista de líneas. Mientras estamos en eso, contaremos el número de líneas en cada archivo.

 lines_by_file = {} for fn in os.listdir('training_text'): if not fn.endswith('.txt'): continue with open(os.path.join('training_text', fn)) as fp_file: lines_by_file[fn.split('.')[0]] = '\n'.join(fp_file.readlines()) print(fn, len(lines_by_file[fn.split('.')[0]]))

Deberías ver un resultado como el siguiente:

 shakespeare_midsummer.txt 120198 shakespeare_romeo_juliet.txt 179726 shakespeare_macbeth.txt 140022 shakespeare_hamlet.txt 204169 chekhov.txt 419063 chekhov_2.txt 148324

Ahora viene la parte divertida. Queremos dividir las líneas en datos de entrenamiento reales. Para hacerlo, primero eliminamos las primeras y últimas 1000 líneas, que ocupan el contenido de la introducción, el encabezado y el pie de página. Luego, tomaremos el texto restante 50 líneas a la vez. Luego convertiremos las 50 líneas en un par de indicaciones y finalización.

 train_data = [] for k in lines_by_file: is_chekhov = 'chekhov' in k useful_lines = lines_by_file[k].split('\n')[1000:-1000] prompt_fmt = "Which playwright wrote the following passage? \n ==== \n %s \n ====" for i in range(0, len(useful_lines), 50): training_set = useful_lines[i: i+50] train_data.append({ 'prompt': prompt_fmt % '\n'.join(training_set), 'completion': 'Anton Chekhov' if is_chekhov else 'William Shakespeare' })

Ahora hemos definido claramente el problema: dadas 50 líneas de texto de una obra de teatro, determine si el dramaturgo es Anton Chekov o William Shakespeare. Aún no hemos terminado. Necesitamos escribir los datos en formato jsonl (líneas JSON) para el entrenamiento y también queremos reservar algunas muestras para fines de prueba. Ejecute el siguiente código así:

 df = pd.DataFrame(train_data) df_chekhov = df[df['completion'] == 'Anton Chekhov'] df_shakespeare = df[df['completion'] == 'William Shakespeare'] chekhov_test_indices = random.sample(df_chekhov.index.tolist(), 15) shakespeare_test_indices = random.sample(df_shakespeare.index.tolist(), 15) df_chekhov_test = df_chekhov.loc[chekhov_test_indices] df_shakespeare_test = df_shakespeare.loc[shakespeare_test_indices] df_chekhov_train = df_chekhov.loc[[i for i in df_chekhov.index if i not in chekhov_test_indices]] df_shakespeare_train = df_shakespeare.loc[[i for i in df_shakespeare.index if i not in shakespeare_test_indices]] pd.concat([df_chekhov_train, df_shakespeare_train]).to_json('chekhov_shakespeare_train.jsonl', orient='records', lines=True) pd.concat([df_chekhov_test, df_shakespeare_test]).to_json('chekhov_shakespeare_test.jsonl', orient='records', lines=True)

Por supuesto, si desea utilizar todo el corpus para el entrenamiento, simplemente puede ejecutar

pd.DataFrame(train_data).to_json('output.jsonl', orient='records', lines=True) .

Entrenamiento con réplica

Necesitamos hacer dos cosas antes de poder invocar la capacitación: primero, debemos cargar los datos de capacitación en algún lugar accesible mediante replicación. Una forma muy sencilla de hacerlo sería cargar el archivo en un depósito en la nube de Google, hacer públicos el depósito y el archivo y proporcionar la URL en el formato https://storage.googleapis.com/<bucket_name>/<file_name> .

A continuación, necesitamos crear un destino. Para hacer esto, simplemente inicie sesión en Replicate (lo que puede hacer a través de Github OAuth) y cree un nuevo modelo. Una vez creado y nombrado el modelo, podrá enviar su modelo a este espacio.

Una vez que todo esté configurado, puedes iniciar la capacitación así:

 training = replicate.trainings.create( version="[flant5-large location]", input={ "train_data": "[Data Location]", }, destination="[Destination]" ) print(training)

Debería ver algún resultado que le indique que el entrenamiento está comenzando. Espere unos minutos y vuelva a consultar la capacitación ejecutando el siguiente código:

 training.reload() print(training)

También puede controlar el progreso del entrenamiento en el sitio web de Replicate. Una vez finalizada la capacitación, puede volver a cargar el objeto de capacitación para obtener el nombre de salida y continuar con el siguiente paso.

Tenga en cuenta que hay períodos en los que los recursos de la GPU son escasos y es posible que reciba un error de "Error de entrenamiento". Si esto te sucede, espera unas horas y vuelve a intentarlo. ¡Hay escasez de GPU y los proveedores de PaaS no son inmunes!

Probando el modelo

¡Está bien! Ahora que tenemos nuestro modelo ajustado, necesitamos probarlo. Recuerde que reservamos 15 pasajes de Chéjov y Shakespeare para realizar pruebas. Podemos usarlos aquí así:

 for _, row in df_chekhov_test.iterrows(): output = replicate.run( training.output["version"], input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('')

Después de un breve período de inicio, debería ver el resultado impreso en la consola. El modelo debe ser extremadamente preciso y devolver "Anton Chejov" cada vez. Probemos esto con Shakespeare:

 for _, row in df_shakespeare_test.iterrows(): output = replicate.run( training.output["version"], input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('')

Al igual que en el ejemplo de Chéjov, deberías ver que el modelo es capaz de identificar a Shakespeare en todo momento.

Por si acaso, veamos si el modelo base es capaz de identificar a Shakespeare o Chéjov:

 for _, row in df_shakespeare_test.iterrows(): output = replicate.run( "[base flant5-large location]", input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('') for _, row in df_chekhov_test.iterrows(): output = replicate.run( "[base flant5-large location]", input={"prompt": row['prompt']} ) for s in output: print(s, end="", flush=True) print('')

Debería ver que el modelo base no puede identificar de manera confiable al dramaturgo de los mismos pasajes. Esto muestra que nuestro ajuste fino le dio al modelo nueva información de manera confiable, ¡y hemos construido un clasificador de dramaturgos en lenguaje natural!

Conclusión

En el artículo de hoy, entrenamos un clasificador de lenguaje natural simple basado en Flan-T5, un modelo de lenguaje grande proporcionado por Google. Debido a su tamaño compacto y licencia permisiva, Flan-T5 se puede entrenar e implementar en infraestructura privada, lo que lo distingue de muchos de los otros modelos populares en el mercado, como ChatGPT.

Si bien el ejemplo de hoy se basó en datos públicos y decididamente no era comercial, esta prueba de concepto se puede adaptar fácilmente a muchas otras aplicaciones comerciales como se describió anteriormente. Si tiene una idea sobre LLM que le gustaría ver convertida en realidad, no dude en iniciar una conversación visitando mi página de GitHub o LinkedIn . Además, no dude en leer mis artículos anteriores de LLM, incluido uno sobre cómo crear un analizador de documentos usando ChatGPT y crear un LLM experto en dominios usando la API de ajuste fino de OpenAI .

¡Feliz pirateo!