Hands-On Large Language Models (Traducido)

Machine Translated by Google
Elogios para los modelos de lenguaje grandes y prácticos
Esta es una guía excepcional sobre el mundo de los modelos lingüísticos y sus
aplicaciones prácticas en la industria. Su cobertura altamente visual de las
aplicaciones generativas, representacionales y de recuperación de los modelos
lingüísticos permite a los lectores comprender, usar y perfeccionar rápidamente los modelos lingüísticos.
¡Muy recomendable!
—Nils Reimers, director de aprendizaje automático en Cohere | creador
de los transformadores de oraciones
Jay y Maarten han continuado su tradición de brindar descripciones ilustradas y

esclarecedoras de temas complejos en su nuevo libro. Su libro, que cuenta con
código funcional, cronogramas y referencias a artículos clave, es un recurso valioso
para cualquiera que desee comprender las principales técnicas detrás de
cómo se construyen los modelos de lenguaje grandes.
—Andrew Ng, fundador de DeepLearning.AI
No puedo pensar en otro libro que sea más importante para leer en este momento. En
cada página, aprendí algo que es fundamental para el éxito en esta era de modelos
lingüísticos.
—Josh Starmer, StatQuest
Si buscas ponerte al día en todo lo relacionado con los LLM, ¡no busques más! En este
maravilloso libro, Jay y Maarten te llevarán de cero a experto en la historia y los últimos
avances en modelos de lenguaje grandes. Con explicaciones muy intuitivas,
excelentes ejemplos de la vida real, ilustraciones claras y laboratorios de código
completos, este libro levanta el telón sobre las complejidades de los modelos de
transformadores, tokenizadores, búsqueda semántica, RAG y muchas otras
tecnologías de vanguardia. ¡Una lectura obligada para cualquier persona interesada en la
última tecnología de IA!
—Luis Serrano, PhD, Fundador y Director Ejecutivo de Serrano
Academy
Este libro es de lectura obligada para cualquier persona interesada en el campo de

la IA generativa, que evoluciona rápidamente. Se centra tanto en las incrustaciones de
texto como en las visuales y es una excelente combinación de evolución algorítmica, rigor
teórico y orientación práctica. Ya sea que sea estudiante, investigador o
profesional de la industria, este libro le brindará los casos de uso y las soluciones
necesarias para mejorar su conocimiento de la IA generativa. ¡Bien hecho!
—Chris Fregly, arquitecto principal de soluciones, inteligencia artificial
generativa en AWS
En el corazón de la revolución GenAI, esta guía indispensable equilibra magistralmente

la teoría y la práctica, navegando por el vasto paisaje de grandes modelos de
lenguaje para equipar a los lectores con el conocimiento necesario para un
impacto inmediato y transformador en el campo de la IA.
—Tarun Narayanan Venkatachalam, investigador de IA,
Universidad de Washington
Lectura oportuna para obtener experiencia práctica con modelos de lenguaje.

—Emir Muñoz, Genesys
HandsOn Large Language Models aporta claridad y ejemplos prácticos para superar el
revuelo en torno a la IA. Ofrece una gran cantidad de excelentes diagramas y ayudas
visuales para complementar las explicaciones claras. Los ejemplos prácticos y el
código concretan lo que otros libros dejan en abstracto. El libro comienza con una
introducción sencilla y va ampliando su alcance de forma constante. En los capítulos
finales, estará perfeccionando y construyendo sus propios modelos de lenguaje
de gran tamaño con confianza.
—Leland McInnes, investigador del Instituto Tutte para
Matemáticas y Computación
Por fin, un libro que no solo evita la cobertura superficial de grandes modelos
lingüísticos, sino que también explora a fondo los antecedentes de un modo accesible
y atractivo. Los autores han creado con maestría una guía definitiva que seguirá
siendo una lectura imprescindible a pesar de los rápidos avances en este campo.
—Prof. DDr. Roman Egger, director ejecutivo de Smartvisions.at y de

la Universidad Modul de Viena
OceanofPDF.com
Lenguaje amplio y práctico

Modelos
Comprensión y generación del lenguaje
Jay Alammar y Maarten Grootendorst
OceanofPDF.com
Modelos de lenguaje prácticos de gran tamaño
por Jay Alammar y Maarten Grootendorst
Copyright © 2024 Jay Alammar y Maarten Pieter Grootendorst. Reservados todos los
derechos.
Impreso en los Estados Unidos de América.
Publicado por O'Reilly Media, Inc., 1005 Gravenstein Highway North, Sebastopol, CA
95472.
Los libros de O'Reilly se pueden comprar con fines educativos, comerciales o

promocionales. También hay ediciones en línea disponibles para la mayoría de
los títulos (http://oreilly.com). Para obtener más información,
comuníquese con nuestro departamento de ventas corporativo/
institucional: 8009989938 o corporate@oreilly.com.
Editora de adquisiciones: Nicole Butterfield
Editor de desarrollo: Michele Cronin
Editor de producción: Ashley Stussy
Redactor: Charles Roumeliotis
Corrector de pruebas: Kim Cofer
Indexador: BIM Creatives, LLC
Diseñador de interiores: David Futato
Diseñador de la portada: Karen Montgomery
Ilustrador: Kate Dullea
Septiembre de 2024: Primera edición

Historial de revisiones de la primera edición
10092024: Primer lanzamiento
Consulte http://oreilly.com/catalog/errata.csp?isbn=9781098150969 para detalles del

lanzamiento.
El logotipo de O'Reilly es una marca registrada de O'Reilly Media, Inc. HandsOn Large
Language Models, la imagen de portada y la imagen comercial relacionada son marcas
comerciales de O'Reilly Media, Inc.
Las opiniones expresadas en este trabajo son las de los autores y no representan
las opiniones del editor. Si bien el editor y los autores han hecho todos los esfuerzos
posibles para garantizar que la información y las instrucciones contenidas en este
trabajo sean precisas, el editor y los autores declinan toda responsabilidad por errores u
omisiones, incluida, sin limitación, la responsabilidad por daños resultantes del uso o
la confianza depositada en este trabajo. El uso de la información y las instrucciones
contenidas en este trabajo se realiza bajo su propio riesgo. Si algún ejemplo de código u
otra tecnología que este trabajo contiene o describe está sujeto a licencias de código abierto
o a los derechos de propiedad intelectual de terceros, es su responsabilidad asegurarse
de que su uso de los mismos cumpla con dichas licencias y/o derechos.
9781098150969
[LSI]
OceanofPDF.com
Prefacio
Los grandes modelos lingüísticos (LLM) han tenido un impacto profundo y de largo
alcance en el mundo. Al permitir que las máquinas comprendan mejor y generen un
lenguaje similar al humano, los LLM han abierto nuevas posibilidades en el campo de la IA y
han impactado en industrias enteras.
Este libro ofrece una introducción completa y muy visual al mundo de los LLM, que abarca
tanto los fundamentos conceptuales como las aplicaciones prácticas. Desde las
representaciones de palabras que precedieron al aprendizaje profundo hasta la arquitectura de
vanguardia (en el momento de escribir este artículo) Transformer, exploraremos la historia y la
evolución de los LLM. Profundizaremos en el funcionamiento interno de los LLM,
explorando sus arquitecturas, métodos de entrenamiento y técnicas de ajuste. También
examinamos varias aplicaciones de los LLM en la clasificación de texto, la agrupación, el
modelado de temas, los chatbots, los motores de búsqueda y
más.
Con su combinación única de desarrollo de la intuición, aplicaciones y estilo ilustrativo,

esperamos que este libro proporcione la base ideal para quienes deseen explorar el apasionante
mundo de los LLM. Ya sea que sea un principiante o un experto, lo invitamos a unirse a
nosotros en este viaje para comenzar a desarrollarse con los LLM.
Una filosofía que prioriza la intuición

El objetivo principal de este libro es proporcionar una intuición sobre el campo de los LLM.
El ritmo de desarrollo en el campo de la inteligencia artificial lingüística es increíblemente
rápido y puede generar frustración intentar mantenerse al día con las últimas tecnologías. En
cambio, nos centramos en los fundamentos de los LLM y pretendemos ofrecer un proceso
de aprendizaje divertido y sencillo.
Para lograr esta filosofía de intuición primero, hacemos un uso generoso del lenguaje visual.
Las ilustraciones ayudarán a dar una identidad visual a los conceptos y procesos principales
involucrados en el proceso de aprendizaje de los LLM.1 Con nuestras ilustraciones
Mediante nuestro método de contar historias, queremos llevarte a un viaje a este campo
apasionante y potencialmente transformador del mundo.
A lo largo del libro, hacemos una clara distinción entre modelos de lenguaje de representación y
modelos de lenguaje generativos. Los modelos de representación son modelos de lenguaje
generativos que no generan texto, pero se utilizan comúnmente para casos de uso específicos
de tareas, como la clasificación, mientras que los modelos de generación son modelos de lenguaje
generativos que generan texto, como los modelos GPT. Aunque los modelos generativos suelen
ser lo primero que viene a la mente cuando se piensa en modelos de lenguaje generativos,
los modelos de representación siguen teniendo mucho uso. También utilizamos de forma vaga la
palabra "grande" en los modelos de lenguaje grandes y, a menudo, optamos por llamarlos
simplemente modelos de lenguaje, ya que las descripciones de tamaño suelen ser bastante
arbitrarias y no siempre indican capacidad.
Prerrequisitos
Este libro asume que tienes algo de experiencia en programación en Python y estás familiarizado
con los fundamentos del aprendizaje automático. El enfoque estará en desarrollar una intuición sólida
en lugar de derivar ecuaciones matemáticas. Como tal, las ilustraciones combinadas con
ejemplos prácticos impulsarán los ejemplos y el aprendizaje a lo largo de este libro. Este libro no
asume ningún conocimiento previo de marcos de aprendizaje profundo populares como PyTorch o
TensorFlow ni ningún conocimiento previo de modelado generativo.
Si no está familiarizado con Python, un excelente lugar para comenzar es Learn Python. donde
encontrarás muchos tutoriales sobre los conceptos básicos del lenguaje. Para facilitar aún más el
proceso de aprendizaje, hemos puesto todo el código a disposición en Google Colab, una plataforma
donde puedes ejecutar todo el código sin necesidad de instalar nada localmente.
Estructura del libro

El libro se divide en tres partes, que se ilustran en la Figura P1 para ofrecerle
una visión completa del libro. Tenga en cuenta que cada capítulo se puede leer de
forma independiente, así que siéntase libre de hojear los capítulos con los que ya está
familiarizado.
Parte I: Comprensión de los modelos lingüísticos

En la Parte I del libro, exploramos el funcionamiento interno de los modelos de
lenguaje, tanto pequeños como grandes. Comenzamos con una descripción
general del campo y las técnicas comunes (ver Capítulo 1) antes de pasar a dos
componentes centrales de estos modelos, la tokenización y las incrustaciones
(ver Capítulo 2). Terminamos esta parte del libro con una versión actualizada y
ampliada del conocido Transformador Ilustrado de Jay, que profundiza en la
arquitectura de estos modelos (véase el Capítulo 3). Se introducirán muchos
términos y definiciones que se utilizan a lo largo del libro.
Figura P1. Todas las partes y capítulos del libro.

Parte II: Uso de modelos de lenguaje preentrenados

En la segunda parte del libro, exploramos cómo se pueden utilizar los LLM a través de
casos de uso comunes. Utilizamos modelos previamente entrenados y demostramos
sus capacidades sin necesidad de ajustarlos.
Aprenderá a utilizar modelos de lenguaje para la clasificación supervisada (ver Capítulo

4), la agrupación de texto y el modelado de temas (ver Capítulo 5), el aprovechamiento
de modelos de incrustación para la búsqueda semántica (ver Capítulo 6), la generación de
texto (ver Capítulos 7 y 8) y la ampliación de las capacidades de generación de texto al
dominio visual (ver Capítulo 9).
El aprendizaje de estas capacidades de modelos de lenguaje individuales le brindará el

conjunto de habilidades para resolver problemas con LLM y construir sistemas
y canales cada vez más avanzados.
Parte III: Entrenamiento y ajuste de modelos lingüísticos

En la Parte III del libro, exploramos conceptos avanzados mediante el entrenamiento y el ajuste fino de
todo tipo de modelos de lenguaje. Exploraremos cómo crear y ajustar un modelo de incrustación (ver
Capítulo 10), repasaremos cómo ajustar BERT para la clasificación (ver Capítulo 11) y finalizaremos
el libro con varios métodos para ajustar los modelos de generación (ver Capítulo 12).
Requisitos de hardware y software

La ejecución de modelos generativos es, por lo general, una tarea que requiere un uso intensivo
de recursos informáticos y una computadora con una GPU potente. Como no están disponibles
para todos los lectores, todos los ejemplos de este libro están diseñados para ejecutarse mediante
una plataforma en línea, concretamente Google Colaboratory. A menudo abreviado como “Google Colab”.
Al momento de escribir este artículo, esta plataforma te permite usar una GPU NVIDIA (T4) de
forma gratuita para ejecutar tu código. Esta GPU tiene 16 GB de VRAM (que es la memoria de tu
GPU), que es la cantidad mínima de VRAM que esperamos para los ejemplos a lo largo del libro.
NOTA
No todos los capítulos requieren un mínimo de 16 GB de VRAM, ya que algunos ejemplos, como el
entrenamiento y el ajuste fino, requieren un uso más intensivo de recursos informáticos que otros, como la
ingeniería de indicaciones. En el repositorio, encontrará los requisitos mínimos de GPU para cada capítulo.
Todo el código, los requisitos y los tutoriales adicionales están disponibles en el repositorio de este
libro . Si desea ejecutar los ejemplos localmente, le recomendamos que tenga acceso a una GPU
NVIDIA con un mínimo de 16 GB de VRAM. Para una instalación local, por ejemplo con conda,
puede seguir esta configuración para crear su entorno:
conda create n thellmbook python=3.10

conda activa el libro electrónico
Puede instalar todas las dependencias necesarias bifurcando o clonando el repositorio y

luego ejecutando lo siguiente en su entorno Python 3.10 recién creado:
pip install r requisitos.txt
Claves API
Usamos modelos de código abierto y de propiedad exclusiva en todos los ejemplos para demostrar
las ventajas y desventajas de ambos. Para los modelos de propiedad exclusiva,
utilizando la oferta de OpenAI y Cohere, deberá crear una cuenta gratuita:
IA abierta
Haga clic en “Registrarse” en el sitio para crear una cuenta gratuita. Esta cuenta le permite crear
una clave API, que puede usarse para acceder a GPT3.5. Luego,
Vaya a “Claves API” para crear una clave secreta.
Adherirse
Registre una cuenta gratuita en el sitio web. Luego, vaya a “Claves API” para crear
una clave secreta.
Tenga en cuenta que con ambas cuentas se aplican límites de velocidad y que estas claves API
gratuitas solo permiten una cantidad limitada de llamadas por minuto. En todos los
ejemplos, hemos tenido eso en cuenta y brindamos alternativas locales si es necesario.
necesario.
Para los modelos de código abierto, no es necesario crear una cuenta, con la excepción del modelo
Llama 2 del Capítulo 2. Para usar ese modelo, necesitará una cuenta de Hugging Face:
Cara abrazada
Haga clic en “Registrarse” en el sitio web de Hugging Face para crear una cuenta gratuita.
Luego, en “Configuración” ve a “Tokens de acceso” para crear un token que puedas
Úselo para descargar ciertos LLM.
Convenciones utilizadas en este libro

En este libro se utilizan las siguientes convenciones tipográficas:
Itálico
Indica nuevos términos, URL, direcciones de correo electrónico, nombres de archivos y

extensiones de archivos.
Ancho constante
Se utiliza para listados de programas, así como dentro de párrafos para hacer
referencia a elementos del programa, como nombres de variables o funciones, bases de
datos, tipos de datos, variables de entorno, declaraciones y palabras clave.
Ancho constante en negrita
Muestra comandos u otro texto que el usuario debe escribir literalmente.
Cursiva de ancho constante
Muestra texto que debe reemplazarse con valores proporcionados por el usuario o por
valores determinados por el contexto.
CONSEJO
Este elemento significa un consejo o sugerencia.

NOTA
Este elemento significa una nota general.
Usando ejemplos de código

El material complementario (ejemplos de código, ejercicios, etc.) está disponible
para descargar en https://github.com/HandsOnLLM/HandsOnLargeLanguageModels.
Si tiene una pregunta técnica o un problema al utilizar los ejemplos de código,

envíe un correo electrónico a support@oreilly.com.
Este libro está aquí para ayudarle a hacer su trabajo. En general, si se ofrece código de
ejemplo con este libro, puede usarlo en sus programas y documentación.
No necesita ponerse en contacto con nosotros para solicitar permiso a menos que esté
reproduciendo una parte importante del código. Por ejemplo, escribir un programa
que utilice varios fragmentos de código de este libro no requiere permiso. Vender o
distribuir ejemplos de los libros de O'Reilly sí requiere permiso. Responder a una
pregunta citando este libro y citando código de ejemplo no requiere permiso. Incorporar
una cantidad significativa de código de ejemplo de este libro en la documentación
de su producto sí requiere permiso.
Agradecemos la atribución, pero por lo general no la exigimos. Una atribución suele

incluir el título, el autor, la editorial y el ISBN. Por ejemplo: “HandsOn Large
Language Models de Jay Alammar y Maarten Grootendorst (O'Reilly). Copyright
2024 Jay Alammar y Maarten Pieter Grootendorst, 9781098150969”.
Si considera que su uso de ejemplos de código no se ajusta al uso justo o al permiso otorgado
anteriormente, no dude en contactarnos a permissions@oreilly.com.

Aprendizaje en línea de O'Reilly
NOTA
Durante más de 40 años, O'Reilly Media Ha proporcionado capacitación, conocimiento y visión
tecnológica y empresarial para ayudar a las empresas a tener éxito.
Nuestra red única de expertos e innovadores comparte sus conocimientos y

experiencia a través de libros, artículos y nuestra plataforma de aprendizaje en línea.
La plataforma de aprendizaje en línea de O'Reilly le brinda acceso a pedido a
cursos de capacitación en vivo, rutas de aprendizaje en profundidad, entornos de
codificación interactivos y una vasta colección de textos y videos de O'Reilly y
más de 200 editoriales. Para obtener más información, visite https://oreilly.com.
Cómo contactarnos
Por favor, dirija sus comentarios y preguntas sobre este libro al editor:
O'Reilly Media, Inc.
1005 Gravenstein Highway Norte
Sebastopol, CA 95472
8008898969 (en Estados Unidos o Canadá)
7078277019 (internacional o local)
7078290104 (fax)
soporte@oreilly.com
https://www.oreilly.com/about/contact.html
Contamos con una página web para este libro, donde enumeramos erratas, ejemplos y
cualquier información adicional. Puede acceder a esta página
en https://oreil.ly/hands_on_LLMs_1e.
Para noticias e información sobre nuestros libros y cursos, visita https://

oreilly.com.
Encuéntrenos en LinkedIn: https://linkedin.com/company/oreillymedia.
Míranos en YouTube: https://youtube.com/oreillymedia.
Expresiones de gratitud
Escribir este libro ha sido una experiencia, una colaboración y un viaje increíble para
nosotros.
El campo de los modelos lingüísticos (de gran tamaño) es una de las áreas más dinámicas
de la tecnología actual y, en el lapso en que se escribió este libro, hemos sido
testigos de avances extraordinarios. Sin embargo, a pesar del rápido ritmo de cambio,
los principios fundamentales siguen siendo sorprendentemente consistentes, lo que hizo que
el proceso de escritura fuera particularmente fascinante. Estamos agradecidos de haber
tenido la oportunidad de explorar este campo en profundidad en un momento tan crucial.
¡Trabajar con nuestro equipo de O'Reilly fue increíble! Un agradecimiento especial a Michele
Cronin por sus increíbles comentarios, apoyo y entusiasmo por este libro desde el primer
día. No podríamos haber pedido una mejor editora, ¡eres increíble! Gracias, Nicole
Butterfield, por dar inicio a este libro y ayudarnos a mantener un enfoque estructurado
durante la escritura. Gracias a Karen Montgomery por crear nuestra maravillosa portada,
¡nos encanta el canguro! Muchas gracias a Kate Dullea por ser tan paciente con nosotros
cuando tuvimos que revisar cientos de ilustraciones muchas veces. Los lanzamientos
tempranos y oportunos de Clare Laylock nos ayudaron a ver crecer nuestro trabajo, lo
que fue una gran motivación, gracias. Gracias a Ashley Stussy y Charles Roumeliotis por
el desarrollo en las etapas finales del libro y a todos los demás en O'Reilly que contribuyeron.
Gracias a nuestro increíble equipo de revisores técnicos. Harm Buisman, Emir Muñoz,
Luba Elliott, Guarav Chawla, Rafael V. Pierre, Luba Elliott, Tarun Narayanan, Nikhil
Buduma y Patrick Harrison nos brindaron valiosos comentarios.
Arrendajo
Quisiera expresar mi más profundo agradecimiento a mi familia por su inquebrantable apoyo e

inspiración. Quisiera expresar un reconocimiento especial a mis padres, Abdullah y
Mishael, y a mis tías, Hussah y Aljoharah.
Agradezco a los amigos, colegas y colaboradores que me ayudaron a entender y explicar

los conceptos complejos que se tratan en este libro, así como a la gente de Cohere que cultiva
un entorno propicio para el aprendizaje y el intercambio. Gracias a Adrien Morisot,
Aidan Gomez, Andy Toulis, Anfal Alatawi, Arash Ahmadian, Bharat Venkitesh, Edward
Grefenstette, Ivan Zhang, Joao Araújo, Luis Serrano, Matthias Gallé, Meor Amer, Nick Frosst,
Patrick Lewis, Phil Blunsom, Sara Hooker y Suhas Pai.
No podría concebir que este proyecto se hubiera logrado al nivel que lo ha hecho sin el
extraordinario talento y el esfuerzo incansable de Maarten, mi coautor.
Tu capacidad para clavar repetidamente los detalles técnicos (desde la versión fijada de la
enésima dependencia de importación hasta lo último en cuantificación LLM) mientras tejes
algunas de las mejores narrativas visuales del mundo es absolutamente
impresionante.
Por último, quiero agradecer a la increíble escena de cafeterías de Riad, Arabia Saudita, por
proporcionarme cafeína y un buen lugar para concentrarme desde el amanecer hasta la
medianoche. Es donde leí la mayoría de estos artículos y donde aprendí a trabajar (te estoy
mirando a ti, Elixir Bunn).
Martín
Quisiera comenzar expresando mi más sincero agradecimiento a mi coautor, Jay.

Sus ideas han hecho que esto no sólo sea posible, sino también increíblemente gratificante.
Este viaje ha sido increíble y colaborar contigo ha sido una alegría absoluta.
Quiero agradecer sinceramente a mis maravillosos colegas de IKNL por su continuo

apoyo durante todo este viaje. Una mención especial para Harm
—Nuestras pausas para tomar café los lunes por la mañana para hablar sobre este libro fueron
una fuente constante de aliento.
Gracias a mi familia y amigos por su apoyo inquebrantable, y a mis padres en particular.

Papá, a pesar de los desafíos que enfrentaste, siempre encontraste una manera de estar ahí
para mí cuando más lo necesitaba, gracias. Mamá, las conversaciones que tuvimos como
aspirantes a escritores fueron maravillosas y me motivaron más de lo que jamás podrías
imaginar. Gracias a ambos por su apoyo y aliento infinitos.
Por último, no tengo palabras para expresar adecuadamente mi gratitud a mi maravillosa

esposa, Ilse. Lieverd, tu entusiasmo y paciencia sin límites han sido legendarios, especialmente
cuando yo hablaba sin parar sobre los últimos avances del LLM durante horas y
horas. Eres mi mayor apoyo. Mis disculpas a mi maravillosa hija, Sarah. ¡Con solo dos años,
ya has escuchado más sobre modelos lingüísticos grandes de lo que nadie debería tener
que soportar en toda su vida! Prometo que lo compensaremos con un sinfín de juegos y
aventuras juntos.
1
J. Alammar. “Comunicación de la investigación sobre aprendizaje automático a través de artículos web ilustrados e
interactivos”. Más allá de los artículos estáticos: replanteando cómo compartimos la comprensión científica en el aprendizaje automático.
Taller ICLR 2021 (2021).
OceanofPDF.com
Parte I. Comprensión de los modelos lingüísticos
OceanofPDF.com
Capítulo 1. Introducción a los

modelos de lenguaje de gran tamaño
La humanidad se encuentra en un punto de inflexión. A partir de 2012, los avances en

la creación de sistemas de IA (utilizando redes neuronales profundas) se aceleraron de tal
manera que, a finales de la década, se obtuvo el primer sistema de software capaz
de escribir artículos que no se diferenciaban de los escritos por humanos. Este sistema
era un modelo de IA llamado Generative Pretrained Transformer 2 o GPT2. En 2022 se
lanzó ChatGPT, que demostró hasta qué punto esta tecnología estaba
preparada para revolucionar la forma en que interactuamos con la tecnología y la
información. Alcanzando un millón de usuarios activos en cinco días y luego cien
millones de usuarios activos en dos meses, la nueva generación de modelos de
IA comenzó como chatbots similares a los humanos, pero rápidamente evolucionó
hasta convertirse en un cambio monumental en nuestro enfoque de tareas comunes,
como la traducción, la generación de textos, los resúmenes y más. Se convirtió en
una herramienta invaluable para programadores, educadores e investigadores.
El éxito de ChatGPT no tuvo precedentes y popularizó más investigaciones sobre la

tecnología que lo sustentaba, es decir, los modelos de lenguaje grandes (LLM). Se
lanzaban modelos propietarios y públicos a un ritmo constante, acercándose y finalmente
alcanzando el rendimiento de ChatGPT. No es una exageración afirmar que casi toda la
atención se centró en los LLM.
Como resultado, 2023 siempre será conocido, al menos para nosotros, como el
año que cambió drásticamente nuestro campo, la Inteligencia Artificial del Lenguaje
(Language AI), un campo caracterizado por el desarrollo de sistemas capaces de
comprender y generar lenguaje humano.
Sin embargo, los LLM ya existen desde hace algún tiempo y los modelos más pequeños
siguen siendo relevantes hoy en día. Los LLM son mucho más que un modelo único y
existen muchas otras técnicas y modelos en el campo de la IA lingüística que vale la pena
explorar.
En este libro, nuestro objetivo es brindar a los lectores una comprensión sólida
de los fundamentos de los LLM y del campo de la IA lingüística en general. Este capítulo
sirve como andamiaje para el resto del libro y presentará conceptos y términos que
utilizaremos a lo largo de los capítulos.
Pero sobre todo, en este capítulo pretendemos responder a las siguientes preguntas:
¿Qué es Language AI?
¿Qué son los modelos de lenguaje de gran tamaño?
¿Cuáles son los casos de uso y aplicaciones comunes de los modelos de lenguaje
grandes?
¿Cómo podemos utilizar nosotros mismos modelos de lenguaje de gran tamaño?
¿Qué es la IA del lenguaje?

El término inteligencia artificial (IA) se utiliza a menudo para describir sistemas
informáticos dedicados a realizar tareas similares a las de la inteligencia humana, como el
reconocimiento de voz, la traducción de idiomas y la percepción visual. Es la inteligencia
del software, en contraposición a la inteligencia de los humanos.
He aquí una definición más formal de uno de los fundadores de la disciplina de la

inteligencia artificial:
[La inteligencia artificial es] la ciencia y la ingeniería que se encarga de crear

máquinas inteligentes, especialmente programas informáticos inteligentes. Está
relacionada con la tarea similar de utilizar ordenadores para comprender la
inteligencia humana, pero la IA no tiene por qué limitarse a métodos que sean
biológicamente observables.
—John McCarthy, 20071
Debido a la naturaleza en constante evolución de la IA, el término se ha utilizado para

describir una amplia variedad de sistemas, algunos de los cuales podrían no encarnar
verdaderamente un comportamiento inteligente. Por ejemplo, a los personajes de los juegos
de computadora (PNJ [personajes no jugables]) a menudo se los ha denominado IA, aunque
muchos no son más que declaraciones ifelse .
La IA del lenguaje se refiere a un subcampo de la IA que se centra en el desarrollo

de tecnologías capaces de comprender, procesar y generar lenguaje humano. El término IA del
lenguaje a menudo se puede utilizar indistintamente con el procesamiento del lenguaje natural
(PLN), debido al éxito continuo de los métodos de aprendizaje automático para abordar los
problemas de procesamiento del lenguaje.
Usamos el término IA del lenguaje para abarcar tecnologías que técnicamente podrían no ser
LLM, pero que aún así tienen un impacto significativo en el campo, como por ejemplo, cómo los
sistemas de recuperación pueden otorgarles superpoderes a los LLM (ver Capítulo 8).
En este libro, queremos centrarnos en los modelos que han tenido un papel importante en
la configuración del campo de la IA lingüística. Esto significa explorar más que solo los LLM de
forma aislada. Sin embargo, eso nos lleva a la pregunta: ¿qué son los grandes modelos
lingüísticos? Para comenzar a responder esta pregunta en este capítulo, exploremos primero la
historia de la IA lingüística.
Una historia reciente de la inteligencia artificial del lenguaje
La historia de la IA del lenguaje abarca muchos desarrollos y modelos que apuntan a representar
y generar lenguaje, como se ilustra en la Figura 11.
Figura 11. Un vistazo a la historia de la inteligencia artificial del lenguaje.
Sin embargo, el lenguaje es un concepto complicado para las computadoras. El texto no tiene
estructura por naturaleza y pierde su significado cuando se representa con ceros y unos
(caracteres individuales). Como resultado, a lo largo de la historia de la IA del lenguaje,
Se ha puesto mucho énfasis en representar el lenguaje de una manera estructurada para que las
computadoras puedan utilizarlo más fácilmente. En la Figura 12 se ofrecen ejemplos de estas tareas de
inteligencia artificial del lenguaje.
Figura 12. La IA del lenguaje es capaz de realizar muchas tareas procesando la entrada de texto.
Representar el lenguaje como una bolsa de palabras

Nuestra historia en el campo de la inteligencia artificial del lenguaje comienza con una técnica llamada bolsa
de palabras, un método para representar texto no estructurado.2 Se mencionó por primera vez alrededor de
la década de 1950, pero se hizo popular alrededor de la década de 2000.
El modelo de bolsa de palabras funciona de la siguiente manera: supongamos que tenemos dos oraciones para
las que queremos crear representaciones numéricas. El primer paso del modelo de bolsa de palabras es
la tokenización, el proceso de dividir las oraciones en palabras individuales o subpalabras (tokens),
como se ilustra en la Figura 13.

Figura 13. Cada oración se divide en palabras (tokens) al dividirlas en un espacio en blanco.
El método más común para la tokenización es dividir un espacio en blanco para crear palabras
individuales. Sin embargo, esto tiene sus desventajas, ya que algunos idiomas, como el
mandarín, no tienen espacios en blanco alrededor de las palabras individuales. En el próximo
capítulo, analizaremos en profundidad la tokenización y cómo esa técnica influye en los modelos de
lenguaje. Como se ilustra en la Figura 14, después de la tokenización, combinamos todas las
palabras únicas de cada oración para crear un vocabulario que podemos usar para representar
las oraciones.
Figura 14. Se crea un vocabulario conservando todas las palabras únicas en ambas oraciones.
Utilizando nuestro vocabulario, simplemente contamos la frecuencia con la que aparece una palabra
en cada oración, creando literalmente una bolsa de palabras. Como resultado, un modelo de bolsa
de palabras tiene como objetivo crear representaciones de texto en forma de números, también
denominados vectores o representaciones vectoriales, que se observan en la Figura 15. A lo largo del libro, nos
referimos a este tipo de modelos como modelos de representación.
Figura 15. Se crea una bolsa de palabras contando palabras individuales. Estos valores se denominan
representaciones vectoriales.
Aunque el método de la bolsa de palabras es un método clásico, no está completamente obsoleto. En el
capítulo 5, exploraremos cómo se puede seguir utilizando para complementar modelos
lingüísticos más recientes.
Mejores representaciones con incrustaciones de vectores densos

El método de la bolsa de palabras, aunque es elegante, tiene un defecto: considera que el lenguaje
no es más que una bolsa de palabras casi literal e ignora la naturaleza semántica, o el significado, del texto.
Lanzado en 2013, word2vec fue uno de los primeros intentos exitosos de capturar el significado del texto
3
en incrustaciones, es decir, representaciones de datos que intentan Las incrustaciones son vectoriales
capturar su significado. Para ello, word2vec aprende representaciones semánticas de palabras
mediante el entrenamiento con grandes cantidades de datos textuales, como la totalidad de Wikipedia.
Para generar estas representaciones semánticas, word2vec utiliza redes neuronales. Estas redes
consisten en capas interconectadas de nodos que procesan información. Como se ilustra en la Figura 16,
las redes neuronales pueden tener

Muchas capas en las que cada conexión tiene un peso determinado en función de la
entrada. Estos pesos suelen denominarse parámetros del modelo.
Figura 16. Una red neuronal consta de capas de nodos interconectados donde cada conexión es una
ecuación lineal.
Con estas redes neuronales, word2vec genera incrustaciones de palabras

observando qué otras palabras suelen aparecer junto a ellas en una oración
determinada. Comenzamos asignando a cada palabra de nuestro vocabulario una
incrustación vectorial, por ejemplo, de 50 valores para cada palabra inicializada con valores aleatorios.
Luego, en cada paso de entrenamiento, como se ilustra en la Figura 17, tomamos
pares de palabras de los datos de entrenamiento y un modelo intenta predecir si es
probable o no que sean vecinas en una oración.
Durante este proceso de entrenamiento, word2vec aprende la relación entre las

palabras y destila esa información en la incrustación. Si las dos palabras tienden a
tener los mismos vecinos, sus incrustaciones estarán más cerca una de la otra y
viceversa. En el Capítulo 2, analizaremos más de cerca el procedimiento de
entrenamiento de word2vec.
Figura 17. Se entrena una red neuronal para predecir si dos palabras son vecinas. Durante este proceso, las
incrustaciones se actualizan para que estén en línea con la realidad básica.
Las incrustaciones resultantes capturan el significado de las palabras, pero ¿qué significa eso
exactamente? Para ilustrar este fenómeno, simplifiquemos un poco e imaginemos que tenemos
incrustaciones de varias palabras, a saber, "manzana" y "bebé". Las incrustaciones intentan
capturar el significado al representar las propiedades de las palabras. Por ejemplo, la
palabra "bebé" puede tener una puntuación alta en las propiedades "recién nacido" y "humano",
mientras que la palabra "manzana" tiene una puntuación baja en estas propiedades.
Como se ilustra en la Figura 18, las incrustaciones pueden tener muchas propiedades
para representar el significado de una palabra. Dado que el tamaño de las incrustaciones
es fijo, sus propiedades se eligen para crear una representación mental de la palabra.
Figura 18. Los valores de las incrustaciones representan propiedades que se utilizan para representar palabras. Podemos
simplificar demasiado imaginando que las dimensiones representan conceptos (lo cual no es así), pero esto ayuda a
expresar la idea.
En la práctica, estas propiedades suelen ser bastante oscuras y rara vez se relacionan con
una sola entidad o concepto identificable por el ser humano. Sin embargo, en conjunto, estas
Las propiedades tienen sentido para una computadora y sirven como una buena manera de
traducir el lenguaje humano al lenguaje de computadora.
Las incrustaciones son tremendamente útiles, ya que nos permiten medir la similitud
semántica entre dos palabras. Mediante el uso de diversas métricas de distancia, podemos juzgar
qué tan cerca está una palabra de otra. Como se ilustra en la Figura 19, si comprimiéramos
estas incrustaciones en una representación bidimensional, observaríamos que las
palabras con significados similares tienden a estar más cerca. En el Capítulo 5, exploraremos cómo
comprimir estas incrustaciones en un espacio ndimensional.
Figura 19. Las incrustaciones de palabras que son similares estarán próximas entre sí en el espacio dimensional.
Tipos de incrustaciones
Hay muchos tipos de incrustaciones, como incrustaciones de palabras e incrustaciones de
oraciones que se utilizan para indicar diferentes niveles de abstracciones (palabra versus
oración), como se ilustra en la Figura 110.
Por ejemplo, Bagofwords crea incrustaciones a nivel de documento, ya que representa el

documento completo. Por el contrario, word2vec genera incrustaciones solo para
palabras.
A lo largo del libro, las incrustaciones tendrán un papel central, ya que se utilizan en
muchos casos de uso, como la clasificación (véase el Capítulo 4), la agrupación (véase el
Capítulo 5) y la búsqueda semántica y la generación aumentada por recuperación
(véase el Capítulo 8). En el Capítulo 2, profundizaremos por primera vez en las
incrustaciones de tokens.
Figura 110. Se pueden crear incrustaciones para diferentes tipos de entrada.
Codificación y decodificación del contexto con atención

El proceso de entrenamiento de word2vec crea representaciones estáticas y descargables
de palabras. Por ejemplo, la palabra “banco” siempre tendrá la misma incrustación independientemente del
contexto en el que se utilice. Sin embargo, “banco” puede referirse tanto a un banco financiero como a la orilla
de un río. Su significado, y por lo tanto sus incrustaciones, deberían cambiar según el contexto.
Un paso más en la codificación de este texto se logró mediante redes neuronales

recurrentes (RNN). Estas son variantes de redes neuronales que pueden modelar secuencias como
una entrada adicional.
Para ello, estas RNN se utilizan para dos tareas: codificar o representar una oración de
entrada y decodificar o generar una oración de salida. La figura 111 ilustra este concepto
mostrando cómo una oración como “Me encantan las llamas” se traduce al holandés “Ik
hou van lama's”.
Figura 111. Dos redes neuronales recurrentes (decodificador y codificador) que traducen una secuencia de
entrada del inglés al holandés.
Cada paso de esta arquitectura es autorregresivo. Al generar la siguiente palabra,

esta arquitectura debe consumir todas las palabras generadas anteriormente, como se
muestra en la Figura 112.
Figura 112. Cada token de salida anterior se utiliza como entrada para generar el siguiente token.
El paso de codificación tiene como objetivo representar la entrada lo mejor

posible, generando el contexto en forma de incrustación, que sirve como entrada
para el decodificador. Para generar esta representación, toma incrustaciones como
entradas para las palabras, lo que significa que podemos usar word2vec para las
representaciones iniciales. En la Figura 113, podemos observar este proceso. Observe
cómo se procesan las entradas de manera secuencial, una a la vez, así como la salida.
Figura 113. Al utilizar incrustaciones de word2vec, se genera una incrustación de contexto que representa la
secuencia completa.
Sin embargo, esta incrustación de contexto dificulta el manejo de oraciones más largas,
ya que se trata simplemente de una única incrustación que representa toda la entrada.
En 2014, se presentó una solución llamada atención Se introdujo una nueva
arquitectura que mejoró enormemente la arquitectura original.4 La atención permite que un
modelo se centre en partes de la secuencia de entrada que son relevantes entre sí
(«prestar atención» entre sí) y amplifique su señal, como se muestra en la Figura 114.
La atención determina de forma selectiva qué palabras son las más importantes en una oración determinada.
Por ejemplo, la palabra de salida “lama’s” significa “llamas” en holandés, por lo que la
atención entre ambas es alta. De manera similar, las palabras “lama’s” y “yo” tienen una
atención menor, ya que no están tan relacionadas. En el Capítulo 3, profundizaremos más
en el mecanismo de atención.
Figura 114. La atención permite que un modelo “preste atención” a ciertas partes de secuencias que podrían estar
más o menos relacionadas entre sí.
Al agregar estos mecanismos de atención al paso del decodificador, la RNN puede

generar señales para cada palabra de entrada en la secuencia relacionada con la salida
potencial. En lugar de pasar solo una incrustación de contexto al decodificador, se
pasan los estados ocultos de todas las palabras de entrada. Este proceso se muestra
en la Figura 115.
Figura 115. Después de generar las palabras “Ik”, “hou” y “van”, el mecanismo de atención del decodificador le
permite centrarse en la palabra “llamas” antes de generar la traducción al holandés (“lama's”).
Como resultado, durante la generación de “Ik hou van lama's”, la RNN lleva un registro
de las palabras a las que presta mayor atención para realizar la traducción. En comparación
con word2vec, esta arquitectura permite representar la naturaleza secuencial del texto y
el contexto en el que aparece al “prestar atención” a la oración completa. Sin
embargo, esta naturaleza secuencial impide la paralelización durante el entrenamiento
del modelo.
La atención es todo lo que necesitas
El verdadero poder de la atención y lo que impulsa las sorprendentes capacidades de

los grandes modelos lingüísticos se exploró por primera vez en el conocido artículo
“Attention is all you need” publicado en 2017.5 Los autores propusieron una arquitectura
de red llamada Transformer, que se basaba únicamente en el mecanismo de atención y
eliminaba la red de recurrencia que vimos anteriormente. En comparación con la red de
recurrencia, el Transformer podía entrenarse en paralelo, lo que aceleraba enormemente
el entrenamiento.
En el Transformador, los componentes de codificación y decodificación se apilan uno

sobre el otro, como se ilustra en la Figura 116. Esta arquitectura sigue siendo
autorregresiva y necesita consumir cada palabra generada antes de crear una nueva.
Figura 116. El transformador es una combinación de bloques codificadores y decodificadores apilados donde la
entrada fluye a través de cada codificador y decodificador.
Ahora, tanto el bloque codificador como el decodificador girarían en torno a la atención

en lugar de aprovechar una red neuronal recurrente con funciones de atención. El bloque
codificador del transformador consta de dos partes, la autoatención y una red
neuronal de retroalimentación, que se muestran en la Figura 117.
Figura 117. Un bloque codificador gira en torno a la autoatención para generar

representaciones intermedias.
En comparación con los métodos de atención anteriores, la autoatención puede prestar

atención a diferentes posiciones dentro de una sola secuencia, representando así
de manera más fácil y precisa la secuencia de entrada, como se ilustra en la Figura 118.
En lugar de procesar un token a la vez, se puede utilizar para mirar la secuencia completa
de una sola vez.
Figura 118. La autoatención atiende a todas las partes de la secuencia de entrada de modo que puede “mirar” tanto hacia
adelante como hacia atrás en una sola secuencia.
En comparación con el codificador, el decodificador tiene una capa adicional que

presta atención a la salida del codificador (para encontrar las partes relevantes
de la entrada). Como se muestra en la Figura 119, este proceso es similar al
decodificador de atención RNN que analizamos anteriormente.
Figura 119. El decodificador tiene una capa de atención adicional que atiende la salida del codificador.
Como se muestra en la Figura 120, la capa de autoatención del decodificador

enmascara las posiciones futuras, de modo que solo presta atención a las posiciones
anteriores para evitar fugas de información al generar la salida.
Figura 120. Preste atención únicamente a los tokens anteriores para evitar “mirar hacia el futuro”.
Juntos, estos bloques de construcción crean la arquitectura Transformer y son la base de

muchos modelos de gran impacto en la IA del lenguaje, como BERT y GPT1, que
abordaremos más adelante en este capítulo. A lo largo de este libro, la mayoría de los
modelos que utilizaremos son modelos basados en Transformer.
La arquitectura Transformer es mucho más compleja de lo que hemos explorado hasta ahora.
En los capítulos 2 y 3, analizaremos las diversas razones por las que los modelos
Transformer funcionan tan bien, incluida la atención de múltiples cabezas, las
incrustaciones posicionales y la normalización de capas.
Modelos de representación: modelos que solo utilizan codificadores
El modelo Transformer original es una arquitectura de codificadordescodificador que

realiza bien las tareas de traducción pero no puede usarse fácilmente para otras tareas,
como la clasificación de texto.
En 2018, se introdujo una nueva arquitectura denominada Representaciones de codificador

bidireccional a partir de transformadores (BERT, por sus siglas en inglés), que podría
aprovecharse para una amplia variedad de tareas y serviría como base de la IA del lenguaje
en los próximos años.6 BERT es una arquitectura que solo utiliza codificadores y se
centra en la representación del lenguaje, como se ilustra en la Figura 121. Esto significa que
solo utiliza el codificador y elimina por completo el decodificador.
Figura 121. Arquitectura de un modelo base BERT con 12 codificadores.
Estos bloques codificadores son los mismos que vimos antes: autoatención
seguida de redes neuronales de retroalimentación. La entrada contiene un token adicional,
el [CLS] o token de clasificación, que se utiliza como representación de
toda la entrada. A menudo, utilizamos este token [CLS] como la incrustación de entrada
para ajustar el modelo en tareas específicas, como la clasificación.
El entrenamiento de estas pilas de codificadores puede ser una tarea difícil que BERT
aborda adoptando una técnica llamada modelado de lenguaje enmascarado (consulte los
capítulos 2 y 11). Como se muestra en la Figura 122, este método enmascara una parte
de la entrada para que el modelo la prediga. Esta tarea de predicción es difícil, pero
permite a BERT crear representaciones más precisas (intermedias) de la entrada.
Figura 122. Entrene un modelo BERT mediante el uso de modelado de lenguaje enmascarado.
Esta arquitectura y este procedimiento de entrenamiento hacen que BERT y las

arquitecturas relacionadas sean increíbles para representar lenguaje contextual. Los
modelos similares a BERT se utilizan comúnmente para el aprendizaje por transferencia,
lo que implica primero entrenarlo previamente para el modelado del lenguaje y luego
ajustarlo para una tarea específica. Por ejemplo, al entrenar BERT en la totalidad de Wikipedia,
aprende a comprender la naturaleza semántica y contextual del texto. Luego, como se muestra
en la Figura 123, podemos usar ese modelo entrenado previamente para ajustarlo para una
tarea específica, como la clasificación de texto.
Figura 123. Después de entrenar previamente BERT en el modelo de lenguaje enmascarado, lo ajustamos para tareas específicas.
Una gran ventaja de los modelos preentrenados es que la mayor parte del entrenamiento ya
está hecho por nosotros. El ajuste fino de tareas específicas generalmente requiere
menos recursos computacionales y menos datos. Además, los modelos tipo BERT
generan incrustaciones en casi cada paso de su arquitectura. Esto también hace que
Los modelos BERT cuentan con máquinas de extracción sin necesidad de afinarlas para una
tarea específica.
En muchas partes del libro se utilizarán modelos basados sólo en codificador, como BERT.
Durante años, se han utilizado y se siguen utilizando para tareas comunes, incluidas tareas de
clasificación (véase el Capítulo 4), tareas de agrupamiento (véase el Capítulo 5) y búsqueda
semántica (véase el Capítulo 8).
A lo largo del libro, nos referiremos a los modelos que solo incluyen codificadores
como modelos de representación para diferenciarlos de los que solo incluyen decodificadores, a
los que llamaremos modelos generativos. Tenga en cuenta que la principal distinción no radica
entre la arquitectura subyacente y la forma en que funcionan estos modelos.
Los modelos de representación se centran principalmente en la representación del lenguaje, por
ejemplo, mediante la creación de incrustaciones, y normalmente no generan texto. Por el
contrario, los modelos generativos se centran principalmente en la generación de texto y
normalmente no están entrenados para generar incrustaciones.
La distinción entre modelos y componentes de representación y generativos también se

mostrará en la mayoría de las imágenes. Los modelos de representación son de color verde azulado
con un pequeño ícono vectorial (para indicar su enfoque en vectores e incrustaciones),
mientras que los modelos generativos son de color rosa con un pequeño ícono de chat (para
indicar sus capacidades generativas).
Modelos generativos: modelos que solo utilizan decodificadores
De manera similar a la arquitectura de solo codificador de BERT, en 2018 se propuso
una arquitectura de solo decodificador para tareas generativas.7 Esta arquitectura se

denominó Transformador preentrenado generativo (GPT) por sus capacidades generativas (ahora
se conoce como GPT1 para distinguirlo de las versiones posteriores). Como se muestra en la Figura
124, apila bloques de decodificador de manera similar a la arquitectura apilada de codificadores
de BERT.
GPT1 se entrenó con un corpus de 7000 libros y Common Crawl, un gran conjunto de datos de
páginas web. El modelo resultante consistió en 117 millones de parámetros. Cada
parámetro es un valor numérico que representa la comprensión del lenguaje por parte del modelo.
Si todo sigue igual, esperamos que más parámetros influyan en gran medida
en las capacidades y el rendimiento de los modelos de lenguaje. Teniendo esto
en cuenta, vimos que se lanzaban modelos cada vez más grandes a un ritmo
constante. Como se ilustra en la Figura 125, GPT2 tenía 1.500 millones de
parámetros8 y GPT3 utilizó 175.000 millones de parámetros9 .
Figura 124. Arquitectura de un GPT1. Utiliza una arquitectura que solo incluye decodificador y elimina el bloqueo
de atención del codificador.
Figura 125. Los modelos GPT crecieron rápidamente en tamaño con cada iteración.
Estos modelos generativos que solo incluyen decodificadores, especialmente los modelos “más
grandes”, se conocen comúnmente como modelos de lenguaje grandes (LLM). Como veremos más
adelante en este capítulo, el término LLM no solo se reserva para los modelos generativos
(solo incluyen decodificadores), sino también para los modelos de representación (solo incluyen codificadores).
Los LLM generativos, como máquinas secuencia a secuencia, toman un texto e intentan completarlo
automáticamente. Si bien es una característica útil, su verdadero poder se demostró al estar
entrenados como chatbots. En lugar de completar un texto, ¿qué pasaría si se los pudiera entrenar
para que respondieran preguntas? Al ajustar estos modelos, podemos crear modelos de instrucción o
chat que puedan seguir instrucciones.
Como se ilustra en la Figura 126, el modelo resultante podría tomar una consulta (solicitud) del usuario
y generar una respuesta que probablemente seguiría a esa solicitud.
Por ello, a menudo oirás que los modelos generativos son modelos de completitud .
Figura 126. Los modelos LLM generativos toman una determinada información e intentan completarla. Con los modelos de instrucción,
esto es más que simplemente completar automáticamente e intentar responder la pregunta.
Una parte vital de estos modelos de finalización es algo llamado longitud de contexto
o ventana de contexto. La longitud de contexto representa la cantidad máxima de
tokens que el modelo puede procesar, como se muestra en la Figura 127. Una ventana
de contexto grande permite que se pasen documentos completos al LLM. Tenga en
cuenta que debido a la naturaleza autorregresiva de estos modelos, la longitud de
contexto actual aumentará a medida que se generen nuevos tokens.
Figura 127. La longitud del contexto es el contexto máximo que un LLM puede manejar.
El año de la IA generativa
Los LLM tuvieron un tremendo impacto en el campo y llevaron a algunos a llamar a

2023 el Año de la IA Generativa con el lanzamiento, la adopción y la cobertura
mediática de ChatGPT (GPT3.5). Cuando nos referimos a ChatGPT, en realidad
estamos hablando del producto y no del modelo subyacente. Cuando se lanzó por
primera vez, estaba impulsado por el LLM GPT3.5 y desde entonces ha crecido
para incluir varias variantes de mayor rendimiento, como GPT4.10.
GPT3.5 no fue el único modelo que tuvo impacto en el Año de la IA

Generativa. Como se ilustra en la Figura 128, tanto los LLM de código
abierto como los propietarios se han abierto camino entre la gente a un ritmo increíble.
Estos modelos base de código abierto a menudo se denominan modelos de
fundación y pueden ajustarse para tareas específicas, como seguir instrucciones.
Figura 128. Una visión integral del Año de la IA Generativa. ¡Tenga en cuenta que todavía faltan muchos
modelos en esta descripción general!
Además de la popular arquitectura Transformer, han surgido nuevas arquitecturas prometedoras como
13 Estas novelas
Mamba11,12 y RWKV. Las arquitecturas intentan alcanzar el rendimiento de nivel
Transformer con ventajas adicionales, como ventanas de contexto más grandes o inferencia
más rápida.
Estos avances ejemplifican la evolución del campo y muestran que 2023 será un año verdaderamente
agitado para la IA. Tuvimos que hacer todo lo posible para mantenernos al día con los numerosos avances,
tanto dentro como fuera de la IA lingüística.
En este sentido, este libro no solo explora los últimos LLM. Exploraremos cómo otros modelos, como los
modelos de incrustación, los modelos de solo codificador e incluso los modelos de bolsa de palabras,
se pueden usar para potenciar los LLM.
La definición conmovedora de un “gran lenguaje”

Modelo"
En nuestros viajes a través de la historia reciente de la IA del lenguaje, observamos que los modelos
principalmente generativos basados únicamente en decodificadores (Transformadores) son comúnmente...
Se los denomina modelos de lenguaje grandes, especialmente si se los considera “grandes”. En la

práctica, ¡esta parece una descripción bastante limitada!
¿Qué sucedería si creáramos un modelo con las mismas capacidades que GPT3 pero diez veces
más pequeño? ¿Quedaría fuera de la categoría de modelo de lenguaje “grande”?
De manera similar, ¿qué pasaría si lanzáramos un modelo tan grande como GPT4 que puede
realizar una clasificación de texto precisa pero no tiene capacidades generativas?
¿Podría seguir calificándose como un gran “modelo de lenguaje” si su función principal no es la
generación de lenguaje, aunque todavía represente texto?
El problema con este tipo de definiciones es que excluimos a los modelos capaces. El nombre
que le demos a un modelo u otro no cambia su comportamiento.
Dado que la definición del término “modelo de lenguaje grande” tiende a evolucionar con el
lanzamiento de nuevos modelos, queremos ser explícitos en lo que significa para este libro.
“Grande” es arbitrario y lo que podría considerarse un modelo grande hoy podría ser pequeño
mañana. Actualmente hay muchos nombres para lo mismo y para nosotros, los “modelos de
lenguaje grande” también son modelos que no generan texto y pueden ejecutarse en hardware
de consumo.
Por lo tanto, además de cubrir los modelos generativos, este libro también cubrirá los modelos
con menos de mil millones de parámetros que no generan texto. Exploraremos cómo otros
modelos, como los modelos de incrustación, los modelos de representación e incluso los modelos
de bolsa de palabras, pueden usarse para potenciar los LLM.
El paradigma de formación de lenguajes de gran escala

Modelos
El aprendizaje automático tradicional generalmente implica entrenar un modelo para una
tarea específica, como la clasificación. Como se muestra en la Figura 129, consideramos que se
trata de un proceso de un solo paso.
Figura 129. El aprendizaje automático tradicional implica un solo paso: entrenar un modelo para una
tarea específica, como clasificación o regresión.
La creación de un LLM, por el contrario, normalmente consta de al menos dos pasos:
Modelado del lenguaje
El primer paso, llamado preentrenamiento, ocupa la mayor parte del tiempo de cómputo y
entrenamiento. Un LLM se entrena en un vasto corpus de texto de Internet.
permitiendo que el modelo aprenda gramática, contexto y patrones del lenguaje.
Esta amplia fase de entrenamiento aún no está orientada a tareas o aplicaciones
específicas más allá de predecir la siguiente palabra. El modelo resultante se suele
denominar modelo de base o modelo de base. Estos modelos
Generalmente no siguen instrucciones.
Sintonia FINA
El segundo paso, el ajuste fino o, a veces, el postentrenamiento, implica utilizar
el modelo entrenado previamente y entrenarlo aún más en una tarea más específica.
Esto permite que el LLM se adapte a tareas específicas o muestre el comportamiento
deseado. Por ejemplo, podríamos ajustar un modelo base para que funcione bien.
en una tarea de clasificación o para seguir instrucciones. Ahorra mucho tiempo.
cantidades de recursos porque la fase de preentrenamiento es bastante costosa y
En general, requiere datos y recursos informáticos que están fuera del alcance de la
mayoría de las personas y organizaciones. Por ejemplo, Llama 2 se entrenó con un conjunto
de datos que contiene 2 billones de tokens.14 Imaginemos el cálculo

¡Es necesario crear ese modelo! En el Capítulo 12, repasaremos varios métodos para ajustar
los modelos básicos en su conjunto de datos.
Cualquier modelo que pase por el primer paso, el preentrenamiento, se considera un modelo
preentrenado, que también incluye modelos ajustados. Este enfoque de entrenamiento en dos
pasos se visualiza en la Figura 130.
Figura 130. En comparación con el aprendizaje automático tradicional, el entrenamiento LLM adopta un enfoque de varios pasos.
Se pueden agregar pasos de ajuste adicionales para alinear aún más el modelo con las
preferencias del usuario, como exploraremos en el Capítulo 12.
Aplicaciones de modelos de lenguaje de gran tamaño:

¿Qué las hace tan útiles?
La naturaleza de los LLM los hace adecuados para una amplia gama de tareas. Con la generación
de textos y la indicación, casi parece que la imaginación es el límite. Para ilustrarlo, exploremos
algunas tareas y técnicas comunes:
Detectar si una reseña dejada por un cliente es positiva o negativa
Esta es una clasificación (supervisada) y se puede manejar tanto con modelos de
solo codificador como de solo decodificador, ya sea con modelos entrenados previamente
(ver Capítulo 4) o mediante modelos de ajuste fino (ver Capítulo 11).
Desarrollo de un sistema para encontrar temas comunes en los problemas de tickets

Esta es una clasificación (no supervisada) para la que no tenemos etiquetas predefinidas.
Podemos aprovechar los modelos de solo codificador para realizar la
la clasificación en sí y los modelos de solo decodificador para etiquetar los temas (ver
Capítulo 5).
Construcción de un sistema para la recuperación e inspección de documentos relevantes
Un componente importante de los sistemas de modelos lingüísticos es su capacidad de agregar
Recursos externos de información. Mediante la búsqueda semántica, podemos crear sistemas que
nos permitan acceder y encontrar fácilmente información para que la utilice un LLM (consulte el
Capítulo 8). Mejore su sistema creando o perfeccionando un
modelo de incrustación personalizado (ver Capítulo 12).
Construcción de un chatbot LLM que pueda aprovechar recursos externos, como

herramientas y documentos
Esta es una combinación de técnicas que demuestra cómo el verdadero
El poder de los LLM se puede encontrar a través de componentes adicionales. Métodos como la
ingeniería de avisos (ver Capítulo 6), la generación aumentada por recuperación (ver
Capítulo 8) y el ajuste fino de un LLM (ver Capítulo 12)
son todas piezas del rompecabezas del LLM.
Construir un LLM capaz de escribir recetas a partir de una imagen que muestre los productos
de tu refrigerador
Esta es una tarea multimodal donde el LLM toma una imagen y razona
sobre lo que ve (ver Capítulo 9). Los LLM se están adaptando a otras modalidades, como la
Visión, lo que abre una amplia variedad de usos interesantes.
casos.
Las aplicaciones LLM son increíblemente satisfactorias de crear, ya que están parcialmente
limitadas por las cosas que uno puede imaginar. A medida que estos modelos se vuelven
más precisos, su uso en la práctica para casos de uso creativos, como juegos de rol y la escritura
de libros para niños, se vuelve cada vez más divertido.
Desarrollo y uso responsable de LLM

El impacto de los LLM ha sido y probablemente siga siendo significativo debido a su adopción
generalizada. A medida que exploramos las increíbles capacidades de los LLM, es importante
tener en cuenta sus implicaciones sociales y éticas.
Algunos puntos clave a tener en cuenta:
Sesgo y equidad
Los LLM se entrenan con grandes cantidades de datos que pueden contener sesgos.
Los LLM podrían aprender de estos sesgos, comenzar a reproducirlos y
potencialmente amplificarlos. Dado que los datos con los que se entrenan los LLM rara vez
se comparten, no queda claro qué posibles sesgos podrían contener a menos que los
pruebes.
Transparencia y rendición de cuentas
Debido a las increíbles capacidades de los LLM, no siempre queda claro cuándo estás
hablando con un humano o con un LLM. Por ello, el uso de LLM cuando
Interactuar con humanos puede tener consecuencias no deseadas cuando hay
No hay ningún ser humano involucrado. Por ejemplo, las aplicaciones basadas en LLM que
se utilizan en el campo médico podrían ser reguladas como dispositivos médicos, ya que
podrían afectar el bienestar de un paciente.
Generar contenido dañino
Un LLM no necesariamente genera contenido veraz y puede generar texto incorrecto con
seguridad. Además, se pueden utilizar para

generar noticias falsas, artículos y otras fuentes engañosas

información.
Propiedad intelectual
¿El resultado de un LLM es su propiedad intelectual o la del creador del LLM?
Cuando el resultado es similar a una frase en los datos de entrenamiento, ¿
¿La propiedad intelectual pertenece al autor de esa frase? Sin
acceso a los datos de entrenamiento no queda claro cuándo el LLM utiliza material
protegido por derechos de autor.
Regulación
Debido al enorme impacto de los LLM, los gobiernos están empezando a
regular las aplicaciones comerciales. Un ejemplo es la Ley Europea de Inteligencia
Artificial , que regula el desarrollo y la implementación de modelos básicos.
incluidos los LLM.
A medida que desarrolla y utiliza sus LLM, queremos destacar la importancia de las
consideraciones éticas e instarlo a aprender más sobre el uso seguro y responsable
de los LLM y de los sistemas de IA en general.
Lo único que necesitas son recursos limitados

Los recursos informáticos a los que hemos hecho referencia varias veces hasta
ahora generalmente se relacionan con las GPU que tiene disponibles en su
sistema. Una GPU (tarjeta gráfica) potente hará que tanto el entrenamiento como el
uso de LLM sean mucho más eficientes y rápidos.
Al elegir una GPU, un componente importante es la cantidad de VRAM (memoria

de acceso aleatorio de video) que tiene disponible. Esto se refiere a la cantidad
de memoria que tiene disponible en su GPU. En la práctica, cuanto más
Cuanto más VRAM tenga, mejor. La razón es que algunos modelos simplemente no se
pueden utilizar si no se dispone de suficiente VRAM.
Debido a que el entrenamiento y el ajuste fino de los LLM puede ser un proceso costoso
en términos de GPU, a quienes no tienen una GPU potente se les ha denominado
a menudo pobres en GPU. Esto ilustra la batalla por los recursos informáticos para
entrenar estos enormes modelos. Para crear la familia de modelos Llama 2, por
ejemplo, Meta utilizó GPU A10080 GB. Suponiendo que alquilar una GPU de
este tipo costaría $1,50/hora, ¡los costos totales de creación de estos
modelos superarían los $5 000 000!15
Lamentablemente, no existe una regla única para determinar exactamente cuánta

VRAM necesitas para un modelo específico. Depende de la arquitectura y el
tamaño del modelo, la técnica de compresión, el tamaño del contexto, el backend
para ejecutar el modelo, etc.
Este libro es para aquellos que no tienen GPU. Usaremos modelos que los usuarios
pueden ejecutar sin las GPU más caras disponibles o un gran presupuesto. Para ello,
pondremos todo el código a disposición en instancias de Google Colab. Al momento de
escribir este artículo, una instancia gratuita de Google Colab le proporcionará una GPU T4
con 16 GB de VRAM, que es la cantidad mínima de VRAM que sugerimos.
Interfaz con modelos de lenguaje de gran tamaño

La interacción con los LLM es un componente vital no solo para utilizarlos, sino también
para desarrollar una comprensión de su funcionamiento interno. Debido a los
muchos avances en el campo, ha habido una gran cantidad de técnicas, métodos
y paquetes para comunicarse con los LLM. A lo largo del libro, pretendemos explorar
las técnicas más comunes para hacerlo, incluido el uso de modelos abiertos tanto
de código cerrado como de código abierto disponibles públicamente.
Modelos privados y propietarios

Los modelos LLM de código cerrado son modelos cuyos pesos y arquitectura
no se comparten con el público. Son desarrollados por expertos específicos.
Organizaciones cuyo código subyacente se mantiene en secreto. Entre los ejemplos

de estos modelos se incluyen GPT4 de OpenAI y Claude de Anthropic. Estos
modelos propietarios suelen estar respaldados por un importante apoyo comercial y se
han desarrollado e integrado en sus servicios.
Puede acceder a estos modelos a través de una interfaz que se comunica con el LLM,
llamada API (interfaz de programación de aplicaciones), como se ilustra en la Figura
131. Por ejemplo, para usar ChatGPT en Python, puede usar el paquete de
OpenAI para interactuar con el servicio sin acceder directamente a él.
Figura 131. Se accede a los LLM de código cerrado mediante una interfaz (API). Como resultado, los detalles
del LLM en sí, incluido su código y arquitectura, no se comparten con el usuario.
Una gran ventaja de los modelos propietarios es que el usuario no necesita tener una
GPU potente para utilizar el LLM. El proveedor se encarga de alojar y ejecutar el modelo
y, por lo general, tiene más recursos informáticos disponibles. No se necesita
experiencia en cuanto al alojamiento y el uso del modelo, lo que reduce significativamente
la barrera de entrada. Además, estos modelos tienden a tener un mejor rendimiento
que sus contrapartes de código abierto debido a la importante inversión de estas
organizaciones.
Una desventaja de esto es que puede ser un servicio costoso. El proveedor administra
el riesgo y los costos de hospedaje del LLM, lo que a menudo se traduce en un
servicio pago. Además, dado que no hay acceso directo al modelo, no hay ningún
método para ajustarlo usted mismo. Por último, sus datos se comparten con el proveedor,
lo que no es deseable en muchos casos de uso comunes, como compartir datos de
pacientes.
Modelos abiertos
Los modelos LLM abiertos son modelos que comparten sus ponderaciones y
arquitectura con el público para su uso. Aún son desarrollados por organizaciones
específicas, pero a menudo comparten su código para crear o ejecutar el modelo
localmente, con distintos niveles de licencia que pueden permitir o no el uso
comercial del modelo. Command R de Cohere, los modelos Mistral, Phi de
Microsoft y los modelos Llama de Meta son todos ejemplos de modelos abiertos.
NOTA
Actualmente se debate qué es lo que verdaderamente representa un modelo de código abierto. Por
ejemplo, algunos modelos compartidos públicamente tienen una licencia comercial permisiva, lo que
significa que el modelo no se puede utilizar con fines comerciales. Para muchos, esta no es la verdadera
definición de código abierto, que establece que el uso de estos modelos no debería tener ninguna restricción.
De manera similar, los datos con los que se entrena un modelo, así como su código fuente, rara vez se
comparten.
Puede descargar estos modelos y usarlos en su dispositivo siempre que tenga

una GPU potente que pueda manejar este tipo de modelos, como se muestra en la
Figura 132.
Figura 132. Los LLM de código abierto son creados directamente por el usuario. Como resultado, los detalles del
LLM en sí, incluido su código y arquitectura, se comparten con el usuario.
Una de las principales ventajas de estos modelos locales es que usted, el

usuario, tiene control total sobre el modelo. Puede utilizar el modelo sin depender de
la conexión API, ajustarlo y ejecutar datos confidenciales a través de él. No depende
de ningún servicio y tiene total transparencia sobre el funcionamiento del modelo.
procesos que conducen a la salida del modelo. Este beneficio se ve reforzado por las
grandes comunidades que permiten estos procesos, como Hugging Face, demostrando
las posibilidades de los esfuerzos colaborativos.
Una desventaja es que se necesita un hardware potente para ejecutar estos modelos y
aún más para entrenarlos o ajustarlos. Además, se requieren conocimientos específicos para
configurar y usar estos modelos (que cubriremos a lo largo de este libro).
En general, preferimos utilizar modelos de código abierto siempre que sea posible.
La libertad que esto nos brinda para experimentar con opciones, explorar el funcionamiento
interno y utilizar el modelo localmente ofrece, sin duda, más beneficios que utilizar
modelos LLM propietarios.
Marcos de código abierto

En comparación con los LLM de código cerrado, los LLM de código abierto requieren el
uso de determinados paquetes para ejecutarlos. En 2023, se lanzaron muchos
paquetes y marcos diferentes que, cada uno a su manera, interactúan con los LLM y los
utilizan. Explorar cientos y cientos de marcos potencialmente valiosos no es la experiencia
más agradable.
¡Como resultado, es posible que incluso te pierdas tu marco favorito en este libro!
En lugar de intentar cubrir todos los marcos de LLM existentes (hay demasiados y su número
sigue aumentando), nuestro objetivo es brindarle una base sólida para aprovechar los
LLM. La idea es que después de leer este libro, pueda comprender fácilmente la mayoría
de los demás marcos, ya que todos funcionan de manera muy similar.
La intuición que intentamos hacer realidad es un componente importante de esto. Si

comprendes intuitivamente no solo los LLM, sino también su uso en la práctica con marcos
comunes, extenderte a otros debería ser una tarea sencilla.
Más específicamente, nos centramos en los paquetes backend. Se trata de paquetes

sin GUI (interfaz gráfica de usuario) que se crean para ejecutar de manera eficiente
cargar y ejecutar cualquier LLM en su dispositivo, como llama.cpp, Cadena

Lang, y el núcleo de muchos marcos, Hugging Face Transformers.
CONSEJO
Cubriremos principalmente los marcos para interactuar con modelos de lenguaje grandes
a través del código. Si bien te ayuda a aprender los fundamentos de estos marcos, a veces
solo quieres una interfaz similar a ChatGPT con un LLM local. Afortunadamente, hay
muchos marcos increíbles que lo permiten. Algunos ejemplos incluyen textgeneration
webui, KoboldCpp, y LM Studio.
Generando tu primer texto

Un componente importante del uso de modelos lingüísticos es la selección de los
mismos. La principal fuente para buscar y descargar modelos lingüísticos es Hugging Face Hub.
Hugging Face es la organización detrás del conocido paquete Transformers, que
durante años ha impulsado el desarrollo de modelos de lenguaje en general. Como su
nombre lo indica, el paquete se creó sobre la base del marco de trabajo
Transformers. que discutimos en “Una historia reciente de la IA del lenguaje”.
En el momento de escribir este artículo, encontrará más de 800 000 modelos en la

plataforma de Hugging Face para distintos propósitos, desde modelos de LLM y de
visión artificial hasta modelos que funcionan con audio y datos tabulares. Aquí puede
encontrar casi cualquier LLM de código abierto.
Aunque exploraremos todo tipo de modelos a lo largo de este libro, comencemos

nuestras primeras líneas de código con un modelo generativo. El modelo generativo
principal que utilizamos a lo largo del libro es Phi3mini, que es un modelo relativamente
pequeño (3.8 mil millones de parámetros) pero bastante eficiente.16 Debido a su pequeño
tamaño, el modelo se puede ejecutar en dispositivos con menos de 8 GB de VRAM.
Si realiza una cuantificación, un tipo de compresión que analizaremos más a fondo en los
capítulos 7 y 12, puede utilizar incluso menos de 6 GB de VRAM. Además, el modelo
tiene licencia MIT, lo que permite utilizarlo con fines comerciales sin restricciones.
Tenga en cuenta que con frecuencia se publican nuevos y mejorados LLM. Para
garantizar que este libro se mantenga actualizado, la mayoría de los ejemplos están diseñados
para funcionar con cualquier LLM. También destacaremos diferentes modelos en el repositorio
asociado con este libro para que los pruebe.
¡Empecemos! Cuando se utiliza un LLM, se cargan dos modelos:
El modelo generativo en sí
Su tokenizador subyacente
El tokenizador se encarga de dividir el texto de entrada en tokens antes de introducirlo

en el modelo generativo. Puedes encontrar el tokenizador y el modelo en el sitio de Hugging
Face y solo necesitamos que se nos pasen los identificadores correspondientes. En este
caso, usamos “microsoft/Phi3mini4kinstruct” como ruta principal al modelo.
Podemos usar transformadores para cargar tanto el tokenizador como el modelo. Tenga
en cuenta que asumimos que tiene una GPU NVIDIA (device_map="cuda"), pero puede
elegir un dispositivo diferente. Si no tiene acceso a una GPU, puede usar los cuadernos
gratuitos de Google Colab que pusimos a su disposición en el repositorio de este libro:
desde transformadores importe AutoModelForCausalLM, AutoTokenizer
# Modelo de carga y modelo de tokenizador

= AutoModelForCausalLM.from_pretrained( "microsoft/Phi3mini4kinstruct",
device_map="cuda", Torch_dtype="auto",
trust_remote_code=True,
) tokenizador = AutoTokenizer.from_pretrained("microsoft/Phi3mini 4kinstruct")
Al ejecutar el código se iniciará la descarga del modelo y, dependiendo de su conexión a

Internet, puede tardar un par de minutos.
Aunque ya tenemos suficiente para empezar a generar texto, hay un truco muy útil en
transformers que simplifica el proceso, llamado
transformers.pipeline. Este truco encapsula el modelo, el tokenizador y el proceso de
generación de texto en una única función:
De la tubería de importación de transformadores
# Crear un generador de
canalización = pipeline( "text
generation", model=model,
tokenizer=tokenizer,
return_full_text=False,
max_new_tokens=500,
do_sample=False
Vale la pena mencionar los siguientes parámetros:
devolver_texto_completo
Al configurar esto como Falso, no se devolverá el mensaje, sino que simplemente
la salida del modelo.
máximo de nuevos tokens
El número máximo de tokens que generará el modelo. Al establecer un
límite, evitamos resultados largos y difíciles de manejar ya que algunos modelos
podrían continuar generando resultados hasta que alcancen su ventana de contexto.
do_sample Si el
modelo utiliza una estrategia de muestreo para elegir el próximo token.
Al configurar esto como Falso, el modelo siempre seleccionará el siguiente más
token probable. En el Capítulo 6, exploramos varios parámetros de muestreo que
invocan cierta creatividad en el resultado del modelo.

Para generar nuestro primer texto, le indicaremos al modelo que cuente un chiste
sobre gallinas. Para ello, formateamos el mensaje en una lista de diccionarios, donde
cada diccionario se relaciona con una entidad de la conversación. Nuestro rol es el de
“usuario” y usamos la clave “contenido” para definir nuestro mensaje:
# Los mensajes de solicitud (entrada del usuario/

consulta) = [
{"role": "user", "content": "Crea un chiste divertido sobre gallinas."} ]
# Generar salida salida

= generador(mensajes) print(salida[0]
["texto_generado"])
¿Por qué a las gallinas no les gusta ir al gimnasio? ¡Porque no pueden soportar la
resistencia del gimnasio!
¡Y eso es todo! El primer texto generado en este libro fue un chiste decente sobre gallinas.
Resumen
En este primer capítulo del libro, profundizamos en el impacto revolucionario que han
tenido los LLM en el campo de la IA lingüística. Ha cambiado significativamente nuestro
enfoque en tareas como la traducción, la clasificación, el resumen y más. A través de
una historia reciente de la IA lingüística, exploramos los fundamentos de
varios tipos de LLM, desde una simple representación de bolsa de palabras hasta
representaciones más complejas utilizando redes neuronales.
Analizamos el mecanismo de atención como un paso hacia la codificación del contexto

dentro de los modelos, un componente vital de lo que hace que los LLM sean tan
capaces. Mencionamos dos categorías principales de modelos que utilizan
este increíble mecanismo: modelos de representación (solo codificadores)
como BERT y modelos generativos (solo decodificadores) como la familia de modelos
GPT. Ambas categorías se consideran modelos de lenguaje grandes a lo largo de este libro.
En general, el capítulo proporcionó una descripción general del panorama de la IA del lenguaje,
incluidas sus aplicaciones, implicaciones sociales y éticas, y la
recursos necesarios para ejecutar dichos modelos. Terminamos generando nuestro primer texto
utilizando Phi3, un modelo que se utilizará a lo largo del libro.
En los próximos dos capítulos aprenderá sobre algunos procesos subyacentes.

Comenzamos explorando la tokenización y las incrustaciones en el Capítulo 2, dos
componentes subestimados pero vitales del campo de la IA del lenguaje.
En el capítulo 3 se presenta una mirada en profundidad a los modelos de lenguaje donde
Descubrirá los métodos precisos utilizados para generar texto.
1 J. McCarthy (2007). “¿Qué es la inteligencia artificial?”. Recuperado de https://oreil.ly/C7sja

y https://oreil.ly/n9X8O.
2
Fabrizio Sebastiani. “Aprendizaje automático en la categorización automática de textos”. ACM Computing
Encuestas (CSUR) 34.1 (2002): 1–47.
3
Tomas Mikolov et al. “Estimación eficiente de representaciones de palabras en el espacio vectorial”. arXiv
preimpresión arXiv:1301.3781 (2013).
4
Dzmitry Bahdanau, Kyunghyun Cho y Yoshua Bengio. “Traducción automática neuronal por
“Aprendiendo conjuntamente a alinear y traducir”. preimpresión arXiv arXiv:1409.0473 (2014).
5
Ashish Vaswani et al. “La atención es todo lo que necesitas”. Avances en el procesamiento de información neuronal
Sistemas 30 (2017).
6
Jacob Devlin et al. “BERT: preentrenamiento de transformadores bidireccionales profundos para el lenguaje
comprensión.” preimpresión arXiv arXiv:1810.04805 (2018).
7
Alec Radford et al. “Mejorar la comprensión del lenguaje mediante el preentrenamiento generativo”, (2018).
8
Alec Radford et al. “Los modelos de lenguaje son aprendices multitarea no supervisados”. OpenAI Blog 1.8
(2019): 9.
9
Tom Brown et al. “Los modelos de lenguaje son aprendices de pocas oportunidades”. Avances en la información neuronal
Sistemas de procesamiento 33 (2020): 1877–1901.
10
OpenAI, “Informe técnico Gpt4”. Preimpresión arXiv arXiv:2303.08774 (2023).
11
Albert Gu y Tri Dao. “Mamba: Modelado de secuencias de tiempo lineal con espacios de estados selectivos”.
Preimpresión de arXiv arXiv:2312.00752 (2023).
12
Consulte “Una guía visual para los modelos Mamba y de espacio de estados” para una guía ilustrada y visual de
Mamba como alternativa a la arquitectura Transformer.
13
Bo Peng et al. “RWKV: Reinventando las RNN para la era de los transformadores”. Preimpresión de arXiv
arXiv:2305.13048 (2023).
14
Hugo Touvron et al. “Llama 2: Bases abiertas y modelos de chat perfeccionados”. Preimpresión de arXiv
arXiv:2307.09288 (2023).
15
Los modelos se entrenaron durante 3.311.616 horas de GPU, que se refiere a la cantidad de tiempo que toma
para entrenar un modelo en una GPU, multiplicado por la cantidad de GPU disponibles.
16
Marah Abdin et al. “Informe técnico Phi3: Un modelo de lenguaje altamente capaz a nivel local en su
teléfono.” preimpresión arXiv arXiv:2404.14219 (2024).
OceanofPDF.com
Capítulo 2. Tokens e
incrustaciones
Los tokens y las incrustaciones son dos de los conceptos centrales del uso de
modelos de lenguaje grandes (LLM). Como hemos visto en el primer capítulo, no solo
son importantes para comprender la historia de la IA del lenguaje, sino que no podemos
tener una idea clara de cómo funcionan los LLM, cómo se construyen y hacia dónde
se dirigirán en el futuro sin un buen conocimiento de los tokens y las incrustaciones,
como podemos ver en la Figura 21.
Figura 21. Los modelos de lenguaje procesan el texto en pequeños fragmentos llamados tokens. Para que el modelo de
lenguaje calcule el lenguaje, necesita convertir los tokens en representaciones numéricas llamadas incrustaciones.
En este capítulo, analizamos más de cerca qué son los tokens y los
métodos de tokenización que se utilizan para impulsar los LLM. Luego,
profundizaremos en el famoso método de incrustación de word2vec que precedió a los
LLM modernos y veremos cómo extiende el concepto de incrustaciones de tokens para construir
sistemas de recomendación comercial que impulsan muchas de las aplicaciones que utilizas.
Finalmente, pasamos de incrustaciones de tokens a incrustaciones de oraciones o texto ,
donde una oración o documento completo puede tener un vector que lo representa, lo que
permite aplicaciones como la búsqueda semántica y el modelado de temas que vemos en
la Parte II de este libro.
Tokenización LLM
La forma en que la mayoría de las personas interactúan con los modelos de lenguaje, en el
momento de escribir este artículo, es a través de un entorno web que presenta una interfaz
de chat entre el usuario y un modelo de lenguaje. Es posible que notes que un modelo no
produce su respuesta de salida de una sola vez; en realidad, genera un token a la vez.
Pero los tokens no son solo el resultado de un modelo, también son la forma en que el modelo
ve sus entradas. Un mensaje de texto enviado al modelo primero se divide en tokens,
como veremos a continuación.
Cómo preparan los tokenizadores las entradas al lenguaje

Modelo
Vistos desde afuera, los LLM generativos toman una solicitud de entrada y generan
una respuesta, como podemos ver en la Figura 22.
Figura 22. Vista de alto nivel de un modelo de lenguaje y su mensaje de entrada.

Sin embargo, antes de que el mensaje se presente al modelo de lenguaje, primero

debe pasar por un tokenizador que lo divide en partes. Puede encontrar un ejemplo que
muestra el tokenizador de GPT4 en la Plataforma OpenAI. Si le introducimos el texto
de entrada, muestra la salida en la Figura 23, donde cada token se muestra en un color
diferente.
Figura 23. Un tokenizador descompone el texto en palabras o partes de palabras antes de que el modelo procese el
texto. Lo hace de acuerdo con un método y un procedimiento de entrenamiento específicos (de https://oreil.ly/ovUWO).
Veamos un ejemplo de código e interactuemos con estos tokens. Aquí descargaremos

un LLM y veremos cómo convertir en tokens la entrada antes de generar texto con el
LLM.
Descargar y ejecutar un LLM

Comencemos cargando nuestro modelo y su tokenizador como lo hicimos en
Capítulo 1:
desde transformadores importe AutoModelForCausalLM, AutoTokenizer

device_map="cuda", Torch_dtype="auto",
trust_remote_code=True,
Luego podemos proceder a la generación real. Primero declaramos nuestro mensaje, luego lo tokenizamos y luego
pasamos esos tokens al modelo, que genera su salida. En este caso, le pedimos al modelo que genere solo 20
tokens nuevos:
prompt = "Escribe un correo electrónico pidiendo disculpas a Sarah por el trágico accidente de
jardinería. Explica cómo sucedió.<|assistant|>"
# Tokenizar el mensaje de entrada input_ids

= tokenizer(prompt,
return_tensors="pt").input_ids.to("cuda")
# Generar el texto
generation_output = model.generate( input_ids=input_ids,
max_new_tokens=20
# Imprimir la salida
print(tokenizer.decode(generation_output[0]))
Producción:
<s> Escribe un correo electrónico para disculparte con Sarah por el trágico accidente de
jardinería. Explica cómo sucedió.<|assistant|> Asunto: Mis más sinceras disculpas por el accidente de
jardinería
Estimado
El texto en negrita son los 20 tokens generados por el modelo.
Al observar el código, podemos ver que, de hecho, el modelo no recibe el mensaje de texto. En
cambio, los tokenizadores procesaron el mensaje de entrada y devolvieron la información
que el modelo necesitaba en la variable input_ids, que el modelo utilizó como entrada.
Imprimamos input_ids para ver qué contiene dentro:
tensor([[1, 14350, 385, 4876, 27746, 5281, 304, 19235, 363, 278, 25305, 293, 16423,
292, 286, 728, 481, 29889, 12027, 7420, 920, 372, 9559, 29889, 32001]], dispositivo='cuda:0')
Esto revela las entradas a las que responden los LLM, una serie de números enteros como se
muestra en la Figura 24. Cada uno es el identificador único de un token específico (carácter,
palabra o parte de una palabra). Estos identificadores hacen referencia a una tabla dentro del
tokenizador que contiene todos los tokens que conoce.
Figura 24. Un tokenizador procesa la solicitud de entrada y prepara la entrada real en el modelo de lenguaje: una lista
de identificadores de token. Los identificadores de token específicos en la figura son solo demostrativos.
Si queremos inspeccionar esos ID, podemos usar el método de decodificación del tokenizador para
traducir los ID nuevamente a texto que podamos leer:
para id en input_ids [0]:

print(tokenizer.decode(id))
Esto imprime (cada token está en una línea separada):
<s>
Escribir
un
correo electrónico
Disculpa
enriquecimiento
Sara
para
el
Tragar
yo
jardín
En
metro
eso es
ap
Exp
Mentir
cómo
él
sucedió
<|asistente|>
Así es como el tokenizador descompuso nuestra solicitud de entrada. Observe lo

siguiente:
El primer token es ID 1 (<s>), un token especial que indica el comienzo del

texto.
Algunos tokens son palabras completas (por ejemplo, escribir, un, correo electrónico).
Algunos tokens son partes de palabras (por ejemplo, disculpa, izing, trag, ic).
Los caracteres de puntuación son su propio símbolo.
Observe cómo el carácter de espacio no tiene su propio token. En cambio, los tokens parciales
(como "izing" e "ic") tienen un carácter oculto especial al principio que indica que están
conectados con el token que los precede en el texto. Se supone que los tokens sin ese carácter
especial tienen un espacio antes de ellos.
En el lado de salida, también podemos inspeccionar los tokens generados por el modelo
imprimiendo la variable generation_output. Esto muestra los tokens de entrada y de salida
(resaltaremos los nuevos tokens en negrita):
tensor([[ 1, 14350, 385, 4876, 27746, 5281, 304, 19235, 363, 278,
25305, 293, 16423, 292, 286, 728, 481, 29889, 12027, 7420,
920, 372, 9559, 29889, 32001, 3323, 622, 29901, 1619, 317,
3742, 406, 6225, 11763, 363, 278, 19906, 292, 341, 728,
481, 13, 13, 29928, 799]], dispositivo='cuda:0')

Esto nos muestra que el modelo generó el token 3323, 'Sub', seguido del token 622, 'ject'. Juntos formaron
la palabra 'Subject'. Luego fueron seguidos por el token 29901, que son los dos puntos ':'... y así
sucesivamente.
Al igual que en el lado de entrada, necesitamos que el tokenizador del lado de salida traduzca el ID
del token al texto real. Lo hacemos usando el método de decodificación del tokenizador. Podemos pasarle
un ID de token individual o una lista de ellos:
imprimir(tokenizador.decodificar(3323))
imprimir(tokenizador.decodificar([3323, 622]))
Esto produce:
Sub
objeto
Sujeto
¿Cómo descompone el texto el tokenizador?
Hay tres factores principales que determinan cómo un tokenizador descompone una solicitud de entrada.
En primer lugar, en el momento del diseño del modelo, el creador del modelo elige un método de tokenización.
Los métodos populares incluyen la codificación de pares de bytes (BPE) (ampliamente utilizada por los modelos
GPT) y WordPiece (utilizado por BERT). Estos métodos son similares en el sentido de que apuntan a optimizar
un conjunto eficiente de tokens para representar un conjunto de datos de texto, pero llegan a ello de
diferentes maneras.
En segundo lugar, después de elegir el método, debemos tomar una serie de decisiones sobre el diseño del
tokenizador, como el tamaño del vocabulario y los tokens especiales que se utilizarán. Encontrará más
información sobre esto en “Comparación de tokenizadores LLM entrenados”.

En tercer lugar, el tokenizador debe entrenarse con un conjunto de datos específico para establecer el
mejor vocabulario que puede utilizar para representar ese conjunto de datos. Incluso si establecemos
los mismos métodos y parámetros, un tokenizador entrenado con un conjunto de datos de texto en
inglés será diferente de otro entrenado con un conjunto de datos de código o un conjunto de datos
de texto multilingüe.
Además de usarse para procesar el texto de entrada en un modelo de lenguaje, los tokenizadores
se utilizan en la salida del modelo de lenguaje para convertir el ID de token resultante en la palabra de
salida o el token asociado con él, como muestra la Figura 25 .
Figura 25. Los tokenizadores también se utilizan para procesar la salida del modelo convirtiendo el ID del token
de salida en la palabra o token asociado con ese ID.
Palabra versus subpalabra versus carácter versus byte

Fichas
El esquema de tokenización que acabamos de discutir se llama tokenización de subpalabras.
Es el esquema de tokenización más utilizado, pero no el único.
En la Figura 26 se muestran cuatro formas notables de tokenizar . Repasémoslas:
Fichas de palabras
Este enfoque era común en métodos anteriores como word2vec, pero se utiliza cada vez menos en el
procesamiento del lenguaje natural. Sin embargo, su utilidad hizo que se utilizara fuera del procesamiento
del lenguaje natural para casos de uso como los sistemas de recomendación, como veremos más adelante en
este capítulo.
Un desafío con la tokenización de palabras es que el tokenizador puede no ser capaz de manejar
nuevas palabras que ingresan al conjunto de datos después de que el tokenizador fue entrenado. Esto también
da como resultado un vocabulario que tiene muchos tokens con diferencias mínimas entre ellos (por
ejemplo, disculpa, disculparse, disculparse, apologista). Este último desafío se resuelve con la
tokenización de subpalabras , ya que tiene un token para disculparse y luego tokens de sufijo (por
ejemplo, y, ize, etic, ist) que son comunes con muchos otros tokens, lo que da como resultado un vocabulario
más expresivo.
Fichas de subpalabras
Este método contiene palabras completas y parciales. Además de la expresividad del vocabulario
mencionada anteriormente, otro beneficio de este enfoque es su capacidad para representar palabras
nuevas descomponiendo el nuevo símbolo en caracteres más pequeños, que tienden a ser parte del vocabulario.
Figura 26. Existen múltiples métodos de tokenización que dividen el texto en diferentes tamaños.
de componentes (palabras, subpalabras, caracteres y bytes).
Fichas de personajes
Este es otro método que puede manejar con éxito palabras nuevas porque tiene las
letras sin procesar como recurso. Si bien eso hace que la representación sea más fácil
de tokenizar, hace que el modelado sea más difícil.

Mientras que un modelo con tokenización de subpalabras puede representar "jugar" como un
token, un modelo que utiliza tokens a nivel de carácter necesita modelar la
información para deletrear "jugar" además de modelar el resto de la
secuencia.
Los tokens de subpalabras presentan una ventaja sobre los tokens de caracteres en la
capacidad de incluir más texto dentro de la longitud de contexto limitada de un
modelo de Transformer. Por lo tanto, con un modelo con una longitud de contexto de 1024, es
posible que pueda incluir aproximadamente tres veces más texto utilizando subpalabras.
tokenización que usar tokens de caracteres (los tokens de subpalabras suelen tener un promedio
de tres caracteres por token).
Fichas de bytes
Un método de tokenización adicional divide los tokens en:
bytes individuales que se utilizan para representar caracteres Unicode. Documentos
como “CANINE: Preentrenamiento de un codificador eficiente sin tokenización para
Los métodos de representación del lenguaje como este, que también se denominan “codificación sin tokenización”,
se describen en otros trabajos como “ByT5: Towards a tokenfree future with pretrained bytetobyte
models” (ByT5: Hacia un futuro sin tokens con modelos byte a byte previamente entrenados) que muestran que este
Puede ser un método competitivo, especialmente en escenarios multilingües.
Una distinción que se debe destacar aquí: algunos tokenizadores de subpalabras también incluyen
bytes como tokens en su vocabulario como el bloque de construcción final al que recurrir cuando
encuentran caracteres que no pueden representar de otra manera. Los tokenizadores GPT2 y
RoBERTa hacen esto, por ejemplo. Esto no los convierte en tokenizadores a nivel de bytes libres
de tokenización, porque no usan estos bytes para representar todo, solo un subconjunto, como
veremos en la siguiente sección.
Si desea profundizar en los tokenizadores, se analizan con más detalle en Diseño de aplicaciones
de modelos de lenguaje grandes.
Comparación de tokenizadores LLM entrenados

Hemos señalado anteriormente tres factores principales que determinan los tokens que
aparecen dentro de un tokenizador: el método de tokenización, los parámetros y tokens
especiales que utilizamos para inicializar el tokenizador y el conjunto de datos en el
que se entrena el tokenizador. Comparemos y contrastemos una serie de tokenizadores
reales y entrenados para ver cómo estas opciones cambian su comportamiento. Esta
comparación nos mostrará que los tokenizadores más nuevos han cambiado su comportamiento
para mejorar el rendimiento del modelo y también veremos cómo los modelos especializados
(como los modelos de generación de código, por ejemplo) a menudo necesitan
tokenizadores especializados.
Utilizaremos varios tokenizadores para codificar el siguiente texto:
texto = """
Inglés y MAYÚSCULAS
show_tokens False Ninguno elif == >= else: dos pestañas:" " Tres pestañas:
" "
12.0*50=600
"""
Esto nos permitirá ver cómo cada tokenizador maneja distintos tipos de tokens:
Capitalización.
Idiomas distintos del inglés.
Emojis.
Código de programación con palabras clave y espacios a menudo utilizados

para sangría (en lenguajes como Python, por ejemplo).
Números y dígitos.
Tokens especiales. Son tokens únicos que tienen una función distinta a la de
representar texto. Incluyen tokens que indican el comienzo del texto o el final
del texto (que es la forma en que el modelo le indica al sistema que ha
completado esta generación) u otras funciones, como veremos.
Pasemos de los tokenizadores más antiguos a los más nuevos para ver cómo
tokenizan este texto y qué podría decir eso sobre el modelo de lenguaje. Tokenizaremos
el texto y luego imprimiremos cada token con un color de fondo usando esta función:
lista_colores = [
'102;194;165', '252;141;98', '141;160;203', '231;138;195',

'166;216;84', '255;217;47'
]
def show_tokens(oración, nombre_del_tokenizador):

tokenizer = AutoTokenizer.from_pretrained(nombre_tokenizer) token_ids =
tokenizer(oración).input_ids para idx, t en enumerate(token_ids):
print( f'\x1b[0;30;48;2;{lista_colores[idx % len(lista_colores)]}
m' +
tokenizer.decode(t) + '\x1b[0m', fin=' '
Modelo base BERT (sin carcasa) (2018)
Enlace al modelo en el centro de modelos HuggingFace
Método de tokenización: WordPiece, introducido en “Búsqueda por voz en japonés

y coreano ”:
Tamaño del vocabulario: 30,522
Fichas especiales:
unk_token [UNK]
Un token desconocido para el cual el tokenizador no tiene una codificación específica.
token_sep [SEP]
Un separador que permite realizar determinadas tareas que requieren dar al modelo dos
textos (en estos casos, el modelo se denomina codificador cruzado). Un ejemplo
se está reordenando, como veremos en el Capítulo 8.
Ficha de pad [PAD]
Un token de relleno utilizado para rellenar posiciones no utilizadas en la entrada del modelo (dado
que el modelo espera una determinada longitud de entrada, su tamaño de contexto).
token_cls [CLS]
Un token de clasificación especial para tareas de clasificación, como veremos en
el Capítulo 4.
mask_token [MÁSCARA]
Un token de enmascaramiento utilizado para ocultar tokens durante el proceso de entrenamiento.
Texto tokenizado:
[CLS] inglés y ##ización de mayúsculas [UNK] [UNK] mostrar token ##s falso ninguno _
"
eli ##f = = > = else : dos pestañas ##s :
"" *
"tres pestañas ##s: 12 . 0 50 = 600 [SEP]
BERT se lanzó en dos versiones principales: con mayúsculas y minúsculas (donde se conservan
las mayúsculas) y sin mayúsculas y minúsculas (donde todas las letras mayúsculas se
convierten primero en minúsculas). Con la versión sin mayúsculas y minúsculas (y más
popular) del tokenizador BERT, notamos lo siguiente:
Los saltos de línea han desaparecido, lo que hace que el modelo sea ciego a la
información codificada en las líneas nuevas (por ejemplo, un registro de chat cuando cada
turno es en una línea nueva).
Todo el texto está en minúsculas.
La palabra “capitalización” se codifica como dos subtokens: mayúscula ##ización.

Los caracteres ## se utilizan para indicar que este token es un
token parcial conectado al token que lo precede. Este también es un método

para indicar dónde están los espacios, ya que se supone que los tokens sin
## al frente tienen un espacio antes de ellos.
Los emojis y caracteres chinos desaparecieron y fueron reemplazados por el

símbolo especial [UNK] que indica un “símbolo desconocido”.
Modelo base BERT (en caja) (2018)
Método de tokenización: WordPiece

Tamaño del vocabulario: 28.996
Fichas especiales: iguales que la versión sin carcasa
Texto tokenizado:
[CLS] Inglés y CA ##PI ##TA ##L ##I ##Z ##AT ##ION

[UNK] [UNK] mostrar = _ token ##s F ##als ##e Ninguno el ##if = = >
"" *
else : dos etiquetas : " " Tres pestañas: 12 . 0 50 =
600 [SEPTIEMBRE]
La versión en mayúsculas del tokenizador BERT se diferencia principalmente en que incluye

tokens en mayúsculas.
Observe cómo “CAPITALIZACIÓN” ahora se representa como ocho tokens: CA ##PI

##TA ##L ##I ##Z ##AT ##ION.
Ambos tokenizadores BERT envuelven la entrada dentro de un token de

inicio [CLS] y un token de cierre [SEP]. [CLS] y [SEP] son tokens de utilidad
que se utilizan para envolver el texto de entrada y cumplen sus propios
propósitos. [CLS] significa clasificación, ya que es un token que se utiliza a
veces para la clasificación de oraciones. [SEP] significa separador, ya que se
utiliza para separar oraciones en algunas aplicaciones que requieren pasar
dos oraciones a un modelo (por ejemplo, en el Capítulo 8, utilizaremos un
token [SEP] para separar el texto de la consulta y un resultado candidato).
GPT2 (2019)
Método de tokenización: codificación de pares de bytes (BPE), introducido en “ Traducción

automática neuronal de palabras raras con unidades de subpalabras”.
Fichas especiales: <|endoftext|>
espectáculo _ t ok ens Falso Ninguno el if == >= else : dos pestañas :" "
""
Tres pestañas:
*
12 . 0 50 = 600
Con el tokenizador GPT2, observamos lo siguiente:
Los saltos de nueva línea se representan en el tokenizador.
Se conserva la capitalización y se escribe la palabra “CAPITALIZACIÓN”.

representado en cuatro fichas.
Los personajes ahora están representados por múltiples fichas cada uno.
Si bien vemos estos tokens impresos como el carácter , en realidad
representan diferentes símbolos. Por ejemplo, el emoji se divide en dos partes.
en los tokens con los identificadores de token 8582, 236 y 113. El tokenizador es
tuvo éxito en reconstruir el carácter original de estos
tokens. Podemos comprobarlo imprimiendo
tokenizer.decode([8582, 236, 113]), que imprime
afuera .
Las dos pestañas se representan como dos tokens (token número 197 en
ese vocabulario) y los cuatro espacios se representan como tres fichas
(número 220) con el espacio final siendo parte de la ficha para el
carácter de cita de cierre.
Las dos pestañas se representan como dos tokens (token número 197 en
ese vocabulario) y los cuatro espacios se representan como tres fichas
(número 220) con el espacio final siendo parte de la ficha para el
carácter de cita de cierre.
NOTA
¿Cuál es la importancia de los espacios en blanco? Son importantes para los modelos
comprender o generar código. Un modelo que utiliza un solo token para representar cuatro
Los caracteres de espacio en blanco consecutivos se ajustan mejor a un conjunto de datos de código Python.
El modelo puede vivir representándolo como cuatro tokens diferentes, lo que hace que el modelado sea más fácil.
más difícil ya que el modelo necesita realizar un seguimiento del nivel de sangría, que a menudo
conduce a un peor rendimiento. Este es un ejemplo de cómo las opciones de tokenización pueden ayudar
El modelo mejora en una determinada tarea.
FlanT5 (2022)
Método de tokenización: FlanT5 utiliza una implementación de tokenizador llamada

SentencePiece, presentado en “SentencePiece: una herramienta de lenguaje simple y eficaz”
Tokenizador y destokenizador de subpalabras independiente para procesamiento de texto neuronal”,
que admite BPE y el modelo de lenguaje unigrama (descrito en
“Regularización de subpalabras: mejora de los modelos de traducción de redes neuronales con
“múltiples candidatos para subpalabras”).
Fichas especiales:
token desconocido
pad_token <pad>
Texto tokenizado:
Inglés y ca pi tal iz ation show _ Para conocer s

Falso Ninguno el if = = > = else : dos pestañas : " " Tres pestañas
:
""
12.0 * 50 = 600
La familia de modelos FlanT5 utiliza el método SentencePiece. Observamos

la siguiente:
Sin tokens de nueva línea o espacios en blanco; esto lo haría desafiante

para que el modelo funcione con código.
Los caracteres emoji y chinos son reemplazados por el token, lo que hace
que el modelo sea completamente ciego para ellos.
GPT4 (2023)
Método de tokenización: BPE
Tamaño del vocabulario: Un poco más de 100.000
Fichas especiales:
<|fin del texto|>
Rellene los tokens del medio. Estos tres tokens permiten que el LLM
Generar una terminación teniendo en cuenta no solo el texto anterior,
sino también el texto posterior. Este método se explica con más detalle
en el artículo “Entrenamiento eficiente de modelos de lenguaje para
completar el medio”; los detalles exactos quedan fuera del alcance de este libro.
Estos tokens especiales son:
<|prefijo_fim|>
<|fim_medio|>
<|sufijo_fim|>
Texto tokenizado:
mostrar _tokens Falso Ninguno elif == >= else : dos pestañas :" "
" "
Tres pestañas:
12 . 0 * 50 = 600
El tokenizador GPT4 se comporta de manera similar a su antecesor, el tokenizador GPT2.

Algunas diferencias son:
El tokenizador GPT4 representa los cuatro espacios como un solo token.

De hecho, tiene un token específico para cada secuencia de espacios en blanco.
a una lista de 83 espacios en blanco.
La palabra clave de Python elif tiene su propio token en GPT4. Tanto este
punto como el anterior se derivan del enfoque del modelo en el código
además del lenguaje natural.
El tokenizador GPT4 utiliza menos tokens para representar la mayoría de las palabras.
Algunos ejemplos incluyen “CAPITALIZACIÓN” (dos tokens versus cuatro)
y “tokens” (un token versus tres).
Regresemos a lo que dijimos sobre el tokenizador GPT2 con respecto a los

tokens Ł.
StarCoder2 (2024)
Codificador estrella 2 es un modelo de 15 mil millones de parámetros enfocado en

la generación de código descrito en el artículo “StarCoder 2 y la pila v2: La próxima
generación”, que continúa el trabajo del StarCoder original descrito en
“StarCoder: ¡Que la fuente te acompañe!”.
Método de tokenización: codificación de pares de bytes (BPE)
Ejemplo de tokens especiales:
<|fin del texto|>
Rellene las fichas del medio:
<prefijo_fim>
<fim_medio>
<sufijo_fim>
<fim_pad>
Al representar código, es importante gestionar el contexto. Un archivo puede

realizar una llamada de función a una función que está definida en un
archivo diferente. Por lo tanto, el modelo necesita alguna forma de poder
Identificar el código que se encuentra en distintos archivos del mismo repositorio de

código, a la vez que se hace una distinción entre el código que se encuentra en distintos
repositorios. Por eso StarCoder2 utiliza tokens especiales para el nombre del repositorio
y el nombre del archivo:
<nombre de archivo>
<nombre del repositorio>
<gh_estrellas>
Texto tokenizado:
_ tokens Falso Ninguno elif == >= else : dos pestañas :" "
espectáculo
" "
Tres pestañas:
12.0 * 50=600
Este es un codificador que se centra en la generación de código:
Similar a GPT4, codifica la lista de espacios en blanco como un solo

token.
Una diferencia importante con todo lo que hemos visto hasta ahora es que a
cada dígito se le asigna su propio token (por lo que 600 se convierte
en 6 0 0). La hipótesis aquí es que esto conduciría a una mejor representación
de los números y las matemáticas. En GPT2, por ejemplo, el número 870 se
representa como un solo token. Pero 871 se representa como dos tokens
(8 y 71). Puedes ver intuitivamente cómo esto puede ser confuso para
el modelo y cómo representa los números.
Galáctica
El modelo Galactica descrito en “Galactica: un gran modelo de lenguaje para la

ciencia” se centra en el conocimiento científico y se basa en muchos artículos
científicos, materiales de referencia y bases de conocimiento.
Atención a la tokenización que la hace más sensible a los matices del conjunto de
datos que representa. Por ejemplo, incluye tokens especiales para citas,
razonamiento, matemáticas, secuencias de aminoácidos y ADN.
secuencias.
Fichas especiales:
<s>
<pad>
</s>
<unun>
Referencias: Las citas se encuentran dentro de dos tokens especiales:
[INICIO_REF]
[FIN_REF]
Un ejemplo de uso del artículo es: Redes neuronales recurrentes,

memoria a corto y largo plazo.
[START_REF]Memoria a corto plazo y larga duración,
Altos reiter[END_REF]
Razonamiento paso a paso:
<work> es un token interesante que el modelo utiliza para el

razonamiento en cadena de pensamiento.
Texto tokenizado:
""
_ tokens Falso Ninguno elif == > = else : dos pestañas :
espectáculo
" "
Tres pestañas:
*
12.0 50=600
El tokenizador de Galactica se comporta de manera similar a StarCoder2 en el sentido de que tiene código en
mente. También codifica los espacios en blanco de la misma manera: asignando un solo token
a secuencias de espacios en blanco de diferentes longitudes. Se diferencia en que también hace
Eso es para las pestañas, sin embargo. De todos los tokenizadores que hemos visto hasta ahora, es el
solo uno que asigna un solo token a la cadena formada por dos pestañas
('_t_t').
Phi3 (y Llama 2)
El modelo Phi3 En este libro analizamos la reutilización del tokenizador de Llama 2. todavía
Añade una serie de tokens especiales.
Fichas especiales:
<|fin del texto|>
Tokens de chat: a medida que los LLM de chat ganaron popularidad en 2023,
La naturaleza conversacional de los LLM comenzó a ser un caso de uso principal.
Los tokenizadores se han adaptado a esta dirección mediante la adición de
fichas que indican los turnos en una conversación y los roles de
Cada orador. Estos obsequios especiales incluyen:
<|usuario|>
<|asistente|>
<|sistema|>
Ahora podemos resumir nuestro recorrido mirando todos estos ejemplos uno al lado del otro:
Base BERT [CLS] inglés y ##ización de mayúsculas [UNK] [UNK] sh
modelo (sin carcasa) Ay _ token ##s falso ninguno eli ##f = = > = else : dos
"" *
Pestaña ##s : " " tres pestañas ##s: 12 . 0 50 = 600 [SE
PAGS]
Base BERT [CLS] Inglés y CA ##PI ##TA ##L ##I ##Z ##AT ##I
modelo (en caja) EN [UNK] [UNK] mostrar _ token ##s F ##als ##e Ninguno el
##if = = > = else : dos etiquetas ##bs : " " Tres pestañas:
"" *
12 . 0 50 = 600 [SEP]
GPT2 Inglés y MAYÚSCULAS
espectáculo _ t ok ens Falso Ninguno el if == >= else : dos tabulaciones

""
s :" " Tres pestañas:
*
12 . 0 50 = 600
FLANT5 Inglés y ca pi tal iz ation show _ a

""
ken s False Ninguno el if = = > = else : dos pestañas :
"" *
Tres pestañas: 12.0 50 = 600
GPT4 Inglés y MAYÚSCULAS
mostrar _tokens Falso Ninguno elif == >= else : dos pestañas

" "
:" " Tres pestañas :
*
12 . 0 50 = 600
Codificador de estrellas Inglés y MAYÚSCULAS
espectáculo _ tokens Falso Ninguno elif == >= else : dos pestañas

" "
12.0 * 50=600
Galáctica Inglés y MAYÚSCULAS
espectáculo _ tokens Falso Ninguno elif == > = else : dos tabs

""
: " " Tres pestañas:
12.0 * 50=600
Phi3 y Llama <s>

2
Inglés y CAP IT AL IZ ACIÓN
espectáculo _ a kens Falso Ninguno elif == >= else : dos pestañas

" "
12.0 * 50=600
Propiedades del tokenizador
La visita guiada anterior de tokenizadores capacitados mostró varias formas

En qué se diferencian los tokenizadores reales entre sí. Pero, ¿qué determina su
¿Comportamiento de tokenización? Hay tres grupos principales de opciones de diseño que

determinar cómo el tokenizador descompondrá el texto: el método de tokenización,
los parámetros de inicialización y el dominio de los datos del tokenizador
objetivos.
Métodos de tokenización
Como hemos visto, hay varios métodos de tokenización con pares de bytes.
La codificación BPE es la más popular. Cada uno de estos métodos
describe un algoritmo sobre cómo elegir un conjunto apropiado de tokens para
representar un conjunto de datos. Puede encontrar una excelente descripción general de todos estos métodos en
La página de Hugging Face que resume los tokenizadores.

Parámetros del tokenizador
Después de elegir un método de tokenización, un diseñador de LLM debe tomar algunas decisiones sobre
los parámetros del tokenizador. Entre ellas, se incluyen:
Tamaño del vocabulario
¿Cuántos tokens se deben mantener en el vocabulario del tokenizador? (30K y 50K)
A menudo se utilizan como valores de tamaño de vocabulario, pero cada vez más los usamos.
viendo tamaños más grandes como 100K.)
Fichas especiales
¿Qué tokens especiales queremos que el modelo controle? Podemos agregar tantos como queramos,
especialmente si queremos crear un LLM para casos de uso especiales. Las opciones más comunes incluyen:
Comienzo de un token de texto (por ejemplo, <s>)
Token de fin de texto
Token de relleno
Token desconocido
Token CLS
Token de enmascaramiento
Además de esto, el diseñador de LLM puede agregar tokens que ayuden a
modelar mejor el dominio del problema en el que intenta centrarse, como
hemos visto con los tokens <work> y [START_REF] de Galactica.
Capitalización
En idiomas como el inglés, ¿cómo queremos abordar el tema?
¿Mayúsculas? ¿Deberíamos convertir todo a minúsculas? (La capitalización de
los nombres suele contener información útil, pero ¿queremos desperdiciar espacio
de vocabulario simbólico en versiones de palabras en mayúsculas?)
El dominio de los datos
Incluso si seleccionamos el mismo método y los mismos parámetros, el comportamiento del

tokenizador será diferente según el conjunto de datos en el que se haya entrenado (incluso
antes de comenzar el entrenamiento del modelo). Los métodos de tokenización mencionados
anteriormente funcionan optimizando el vocabulario para representar un conjunto de datos
específico. En nuestra visita guiada, hemos visto cómo esto tiene un impacto en
conjuntos de datos como el código y el texto multilingüe.
Para el código, por ejemplo, hemos visto que un tokenizador centrado en texto
puede tokenizar los espacios de sangría de esta manera (resaltaremos algunos
tokens en color):
def agregar_numeros(a, b):
...."""Suma los dos números `a` y `b`."""
...devuelve a + b
Esto puede no ser óptimo para un modelo centrado en el código. Los modelos centrados
en el código suelen mejorarse al tomar diferentes decisiones de tokenización:
def agregar_numeros(a, b):
...."""Suma los dos números `a` y `b`."""
...devuelve a + b
Estas opciones de tokenización facilitan el trabajo del modelo y, por lo tanto, su

rendimiento tiene una mayor probabilidad de mejorar.
Puede encontrar un tutorial más detallado sobre el entrenamiento de tokenizadores

en la sección Tokenizadores del curso Hugging Face y en Procesamiento del lenguaje
natural con Transformers, edición revisada.
Incrustaciones de tokens
Ahora que entendemos la tokenización, hemos resuelto una parte del problema de
representar el lenguaje en un modelo de lenguaje. En este sentido, el lenguaje es una
secuencia de tokens. Y si entrenamos un modelo lo suficientemente bueno en un conjunto de
tokens lo suficientemente grande, comienza a capturar los patrones complejos que
aparecen en su conjunto de datos de entrenamiento:
Si los datos de entrenamiento contienen mucho texto en inglés, ese patrón

se revela como un modelo capaz de representar y generar el idioma inglés.
Si los datos de entrenamiento contienen información factual (Wikipedia, por

ejemplo), el modelo tendría la capacidad de generar cierta información factual
(ver la siguiente nota).
La siguiente pieza del rompecabezas es encontrar la mejor representación numérica de estos

elementos que el modelo puede utilizar para calcular y modelar adecuadamente los
patrones en el texto. Estos patrones se nos revelan como la coherencia de un modelo en
un lenguaje específico, o la capacidad de codificar, o cualquiera de la creciente lista
de capacidades que esperamos de los modelos de lenguaje.
Como hemos visto en el Capítulo 1, eso es lo que son las incrustaciones: el espacio de
representación numérica utilizado para capturar los significados y patrones del lenguaje.
NOTA
¡Ups!: Sin embargo, lograr un buen umbral de coherencia lingüística y una generación de hechos
mejor que el promedio comienza a presentar un nuevo problema. Algunos usuarios comienzan a confiar en
la capacidad de generación de hechos del modelo (por ejemplo, a principios de 2023 algunos modelos
lingüísticos fueron denominados "asesinos de Google"). Los usuarios avanzados no tardaron mucho en darse
cuenta de que los modelos de generación por sí solos no son motores de búsqueda fiables. Esto dio
lugar al surgimiento de la generación aumentada por recuperación (RAG), que combina la búsqueda y los
LLM. Tratamos la RAG con más detalle en el Capítulo 8.
Un modelo de lenguaje contiene incrustaciones para el

Vocabulario de su tokenizador
Una vez que se inicializa y se entrena un tokenizador, se lo utiliza en el proceso de
entrenamiento de su modelo de lenguaje asociado. Por este motivo, un modelo de lenguaje
entrenado previamente se vincula con su tokenizador y no puede usar un tokenizador diferente
sin entrenamiento.
El modelo de lenguaje contiene un vector de incrustación para cada token en el

vocabulario del tokenizador, como podemos ver en la Figura 27. Cuando descargamos un
modelo de lenguaje entrenado previamente, una parte del modelo es esta matriz de
incrustaciones que contiene todos estos vectores.
Antes del inicio del proceso de entrenamiento, estos vectores se inicializan aleatoriamente
como el resto de los pesos del modelo, pero el proceso de entrenamiento les asigna los
valores que habilitan el comportamiento útil que están entrenados para realizar.
Figura 27. Un modelo de lenguaje contiene un vector de incrustación asociado con cada token en su tokenizador.
Creación de incrustaciones de palabras contextualizadas con

Modelos de lenguaje
Ahora que hemos cubierto las incrustaciones de tokens como entrada para un
modelo de lenguaje, veamos cómo los modelos de lenguaje pueden crear
mejores incrustaciones de tokens. Esta es una de las principales formas de usar
modelos de lenguaje para la representación de texto. Esto potencia aplicaciones
como el reconocimiento de entidades nombradas o el resumen de texto extractivo (que
resume un texto largo resaltando las partes más importantes del mismo, en lugar de
generar texto nuevo como resumen).
En lugar de representar cada token o palabra con un vector estático, los modelos de
lenguaje crean incrustaciones de palabras contextualizadas (mostradas en la Figura 28)
que representan una palabra con un token diferente según su contexto. Estos vectores
pueden ser utilizados por otros sistemas para una variedad de tareas. Además de las
aplicaciones de texto que mencionamos en el párrafo anterior, estos
vectores contextualizados, por ejemplo, son los que impulsan los sistemas de generación
de imágenes de IA como DALL∙E, Midjourney y Stable Diffusion, por ejemplo.
Figura 28. Los modelos de lenguaje producen incrustaciones de tokens contextualizadas que mejoran las incrustaciones de tokens
estáticas y sin procesar.
Veamos cómo podemos generar incrustaciones de palabras contextualizadas; la

mayor parte de este código ya debería resultarte familiar:
Desde los transformadores , importe AutoModel, AutoTokenizer
# Cargar un tokenizador
tokenizer = AutoTokenizer.from_pretrained("microsoft/deberta base")
# Cargar un modelo de lenguaje model

= AutoModel.from_pretrained("microsoft/debertav3xsmall")
# Tokenizar la oración tokens =

tokenizer('Hola mundo', return_tensors='pt')
# Procesar los tokens salida =

model(**tokens)[0]
El modelo que estamos usando aquí se llama DeBERTa v3, que al momento de
escribir este artículo es uno de los modelos de lenguaje con mejor
desempeño para incrustaciones de tokens, además de ser pequeño y altamente
eficiente. Se describe en el artículo “DeBERTaV3: Improving DeBERTa using
ELECTRAstyle pretraining gradientdisentangled embedding sharing”.
Este código descarga un tokenizador y un modelo previamente entrenados y luego

los utiliza para procesar la cadena “Hola mundo”. Luego, la salida del modelo se
guarda en la variable de salida. Inspeccionemos esa variable imprimiendo
primero sus dimensiones (esperamos que sea una matriz multidimensional):
salida.forma
Esto imprime:
antorcha.Tamaño([1, 4, 384])
Omitiendo la primera dimensión, podemos leer esto como cuatro tokens, cada uno
integrado en un vector de 384 valores. La primera dimensión es la dimensión de
lote que se utiliza en casos (como el entrenamiento) cuando queremos enviar múltiples
oraciones de entrada al modelo al mismo tiempo (se procesan al mismo tiempo, lo que
acelera el proceso).
Pero ¿qué son estos cuatro vectores? ¿El tokenizador dividió las dos palabras en cuatro
tokens o está sucediendo algo más? Podemos usar lo que hemos aprendido sobre los
tokenizadores para inspeccionarlos:
para token en tokens['input_ids'][0]:

print(tokenizer.decode(token))
Esto imprime:
[CLS]
Hola
Mundo
[SEP]
Este tokenizador y modelo en particular funcionan agregando los tokens [CLS] y

[SEP] al principio y al final de una cadena.
Nuestro modelo de lenguaje ya ha procesado la entrada de texto. El resultado de su

salida es el siguiente:
tensor([[ [3,3060, 0,0507, 0,1098, ..., 0,1704, 0,1618, 0,6932], [ 0,8918,

0,0740, 0,1583, ..., 0,1869, 1,4760, 0,0751], [ 0,0871, 0,6364, 0,3050, ...,
0,4729, 0,1829, 1,0157], [3,1624, 0,1436, 0,0941, ..., 0,0290, 0,1265,
0,7954] ]], grad_fn=<NativeLayerNormBackward0>)
Este es el resultado bruto de un modelo de lenguaje. Las aplicaciones de modelos de

lenguaje grandes se basan en resultados como este.
En la Figura 29, repasamos la tokenización de entrada y las salidas resultantes de un modelo

de lenguaje . Técnicamente, el cambio de identificadores de token a incrustaciones sin
procesar es el primer paso que ocurre dentro de un modelo de lenguaje.
Figura 29. Un modelo de lenguaje opera con incrustaciones estáticas y sin procesar como entrada y produce
incrustaciones de texto contextuales.
Una imagen como ésta es esencial para el próximo capítulo, cuando comenzamos a ver
cómo funcionan los LLM basados en Transformer.
Incrustaciones de texto (para oraciones y texto completo)

Documentos)
Si bien las incrustaciones de tokens son clave para el funcionamiento de los LLM, varias
aplicaciones de LLM requieren operar en oraciones completas, párrafos o incluso documentos
de texto. Esto ha dado lugar a modelos de lenguaje especiales que producen texto
incrustaciones: un vector único que representa un fragmento de texto más largo que un solo
token.
Podemos pensar en los modelos de incrustación de texto como si se tratara de tomar

un fragmento de texto y, en última instancia, producir un único vector que represente ese texto y
capture su significado de alguna forma útil. La figura 210 muestra ese proceso.
Figura 210. En el paso 1, utilizamos el modelo de incrustación para extraer las características y convertir el texto de entrada
en incrustaciones.
Existen múltiples formas de producir un vector de incrustación de texto . Una de las formas
más comunes es promediar los valores de todas las incrustaciones de tokens producidas
por el modelo. Sin embargo, los modelos de incrustación de texto de alta calidad tienden a ser
entrenados específicamente para tareas de incrustación de texto.
Podemos producir incrustaciones de texto con transformadores de oraciones, un paquete
popular para aprovechar los modelos de incrustación entrenados previamente.1 El

paquete, al igual que los transformadores en el capítulo anterior, se puede utilizar para cargar
modelos disponibles públicamente. Para ilustrar la creación de incrustaciones, utilizamos el paquete
Modelo mpnetbasev2. Tenga en cuenta que en el Capítulo 4, exploraremos más a fondo

cómo puede elegir un modelo de incrustación para su tarea.
de sentence_transformers importar SentenceTransformer
# Cargar modelo
model = SentenceTransformer("transformadoresdesentencias/allmpnetbasev2")
# Convertir texto en incrustaciones de texto

vector = model.encode("¡La mejor película de la historia!")
La cantidad de valores, o las dimensiones, del vector de incrustación dependen del modelo
de incrustación subyacente. Analicemos esto para nuestro modelo:
vector.forma
(768,)
Esta oración ahora está codificada en este vector con una dimensión de 768 valores
numéricos. En la Parte II de este libro, una vez que comencemos a analizar
las aplicaciones, comenzaremos a ver la inmensa utilidad de estos vectores de
incrustaciones de texto para impulsar todo, desde la categorización hasta la búsqueda
semántica y RAG.
Incrustaciones de palabras más allá de los LLM

Las incrustaciones son útiles incluso fuera de la generación de texto y lenguaje.
Las incrustaciones, o la asignación de representaciones vectoriales significativas a
los objetos, resultan útiles en muchos ámbitos, incluidos los motores de recomendación
y la robótica. En esta sección, veremos cómo utilizar incrustaciones de word2vec
preentrenadas y abordaremos cómo el método crea incrustaciones de palabras.
Ver cómo se entrena word2vec lo preparará para aprender sobre el entrenamiento
contrastivo en el Capítulo 10. Luego, en la siguiente sección, veremos cómo se pueden
usar esas integraciones para los sistemas de recomendación.
Uso de incrustaciones de palabras previamente entrenadas
Veamos cómo podemos descargar incrustaciones de palabras preentrenadas (como

word2vec o GloVe) usando la biblioteca Gensim:
Importar gensim.downloader como api
# Descargar incrustaciones (66 MB, guante, entrenado en wikipedia, tamaño del vector: 50)
# Otras opciones incluyen "word2vecgooglenews300"

# Más opciones en https://github.com/RaReTechnologies/gensimdata model = api.load("glovewiki
gigaword50")
Aquí, hemos descargado las incrustaciones de una gran cantidad de palabras

entrenadas en Wikipedia. Luego, podemos explorar el espacio de incrustaciones al ver
los vecinos más cercanos de una palabra específica, por ejemplo, "king":
modelo.más_similar([modelo['king']], topn=11)
Esto produce:
[('rey', 1.0000001192092896), ('príncipe',

0.8236179351806641), ('reina', 0.7839043140411377),
('ii', 0.7746230363845825), ('emperador',
0.7736247777938843), ('hijo',
0.766719400882721), ('tío', 0.7627150416374207),
('reino', 0.7542161345481873), ('trono',
0.7539914846420288), ('hermano',
0,7492411136627197), ('gobernante',
0,7434253692626953)]
El algoritmo Word2vec y el entrenamiento contrastivo
El algoritmo word2vec descrito en el artículo “Estimación eficiente de

representaciones de palabras en el espacio vectorial” se describe en detalle en The
Word2vec ilustrado. Las ideas centrales se condensan aquí, a medida que las desarrollamos
al analizar un método para crear incrustaciones para motores de recomendación
en la siguiente sección.
Al igual que los LLM, word2vec se entrena con ejemplos generados a partir de texto. Digamos,
por ejemplo, que tenemos el texto “No harás una máquina a semejanza de una mente
humana” de las novelas Dune de Frank Herbert. El algoritmo utiliza una ventana deslizante
para generar ejemplos de entrenamiento. Podemos, por ejemplo, tener un tamaño de ventana
dos, lo que significa que consideramos dos vecinos a cada lado de una palabra central.
Las incrustaciones se generan a partir de una tarea de clasificación. Esta tarea se utiliza
para entrenar una red neuronal para predecir si las palabras suelen aparecer en el mismo
contexto o no ( en este caso, contexto significa en muchas oraciones del conjunto de datos
de entrenamiento que estamos modelando). Podemos pensar en esto como una red
neuronal que toma dos palabras y genera 1 si tienden a aparecer en el mismo contexto y 0 si
no es así.
En la primera posición de la ventana deslizante, podemos generar cuatro ejemplos de

entrenamiento, como podemos ver en la Figura 211.
Figura 211. Se utiliza una ventana deslizante para generar ejemplos de entrenamiento para el algoritmo word2vec para
predecir posteriormente si dos palabras son vecinas o no.
En cada uno de los ejemplos de entrenamiento producidos, la palabra del centro se utiliza
como una entrada, y cada uno de sus vecinos es una segunda entrada distinta en
cada ejemplo de entrenamiento. Esperamos que el modelo entrenado final sea capaz de
clasificar esta relación de vecinos y generar 1 si las dos palabras de entrada que recibe son,
de hecho, vecinas. Estos ejemplos de entrenamiento se visualizan en la Figura 212.
Figura 212. Cada ejemplo de entrenamiento generado muestra un par de palabras vecinas.
Sin embargo, si tenemos un conjunto de datos con un valor objetivo de solo 1, entonces un modelo
puede hacer trampa y tener éxito generando un valor 1 todo el tiempo. Para solucionar esto,
necesitamos enriquecer nuestro conjunto de datos de entrenamiento con ejemplos de palabras
que normalmente no son vecinas. Estos se denominan ejemplos negativos y se muestran en la
Figura 213.
Figura 213. Necesitamos presentar nuestros modelos con ejemplos negativos: palabras que no suelen
ser vecinas. Un mejor modelo es capaz de distinguir mejor entre los ejemplos positivos y negativos.
Resulta que no tenemos que ser demasiado científicos a la hora de elegir los ejemplos
negativos. Muchos modelos útiles resultan de la simple capacidad de detectar ejemplos positivos
a partir de ejemplos generados aleatoriamente (inspirados en un
Una idea importante llamada estimación por contraste de ruido se describe en

“Estimación por contraste de ruido: un nuevo principio de estimación para
modelos estadísticos no normalizados”. En este caso, obtenemos palabras aleatorias y
las agregamos al conjunto de datos e indicamos que no son vecinas (y, por lo tanto,
el modelo debería generar 0 cuando las ve).
Con esto, hemos visto dos de los conceptos principales de word2vec (Figura 214): skip
gram, el método de selección de palabras vecinas, y muestreo negativo, agregar
ejemplos negativos mediante muestreo aleatorio del conjunto de datos.
Figura 214. El salto de gramo y el muestreo negativo son dos de las ideas principales detrás del algoritmo
word2vec y son útiles en muchos otros problemas que pueden formularse como problemas de secuencia de tokens.
Podemos generar millones e incluso miles de millones de ejemplos de entrenamiento

como este a partir de texto en ejecución. Antes de proceder a entrenar una red
neuronal con este conjunto de datos, debemos tomar un par de decisiones de tokenización
que, al igual que hemos visto con los tokenizadores LLM, incluyen cómo manejar la
capitalización y la puntuación y cuántos tokens queremos en nuestro vocabulario.
Luego creamos un vector de incrustación para cada token y los inicializamos

aleatoriamente, como se puede ver en la Figura 215. En la práctica, se trata
de una matriz de dimensiones vocab_size x embedding_dimensions.
Figura 215. Un vocabulario de palabras y sus vectores de incrustación iniciales, aleatorios y no inicializados.
Luego, se entrena un modelo en cada ejemplo para que tome dos vectores de
incrustación y prediga si están relacionados o no. Podemos ver cómo se ve esto
en la Figura 216.
Figura 216. Se entrena una red neuronal para predecir si dos palabras son vecinas. Actualiza las
incrustaciones en el proceso de entrenamiento para producir las incrustaciones finales entrenadas.
En función de si su predicción fue correcta o no, el paso típico de entrenamiento

de aprendizaje automático actualiza las incorporaciones para que la próxima vez
que se presenten esos dos vectores al modelo, tenga más posibilidades de ser correcto.
más correcto. Y al final del proceso de entrenamiento, tenemos mejores integraciones para
todos los tokens en nuestro vocabulario.
Esta idea de un modelo que toma dos vectores y predice si tienen una determinada relación es
una de las ideas más poderosas en el aprendizaje automático y, una y otra vez, ha demostrado que
funciona muy bien con los modelos de lenguaje. Por eso, dedicamos el Capítulo 10 a este concepto y
a cómo optimiza los modelos de lenguaje para tareas específicas (como la incorporación y
recuperación de oraciones).
La misma idea también es fundamental para unir modalidades como texto e imágenes, lo cual es
clave para los modelos de generación de imágenes de IA, como veremos en el Capítulo 9 sobre
modelos multimodales. En esa formulación, se presenta un modelo con una imagen y un título, y debe
predecir si ese título describe la imagen o no.
Integraciones para sistemas de recomendación

Como hemos mencionado, el concepto de incrustaciones es útil en muchos otros ámbitos. En la
industria, se utiliza mucho, por ejemplo, para sistemas de recomendación.
Recomendar canciones mediante incrustaciones

En esta sección, utilizaremos el algoritmo word2vec para incorporar canciones mediante listas
de reproducción de música creadas por humanos. Imaginemos que tratáramos cada canción como si
fuera una palabra o un símbolo y cada lista de reproducción como si fuera una oración.
Estas incorporaciones se pueden utilizar para recomendar canciones similares que suelen aparecer
juntas en las listas de reproducción.
El conjunto de datos Lo usaremos recopilado por Shuo Chen de la Universidad de Cornell.

Contiene listas de reproducción de cientos de estaciones de radio de todo Estados Unidos.
La figura 217 muestra este conjunto de datos.
Figura 217. Para las incrustaciones de canciones que capturan la similitud de las canciones, utilizaremos un conjunto de datos compuesto por una
Colección de listas de reproducción, cada una con una lista de canciones.
Demostremos el producto final antes de ver cómo está construido.

Dale algunas canciones y mira qué te recomienda como respuesta.
Empecemos por darle “Billie Jean” de Michael Jackson, la canción con identificación
3822:
# Definiremos y exploraremos esta función en detalle a continuación.

recomendaciones_de_impresión(3822)
identificación Título artista
4181 Beso El príncipe y el

Revolución
12749 ¿Quieres empezar? Michael Jackson

Algo
1506 La manera en que me haces Michael Jackson

Sentir
3396 Día festivo Virgen
500 No pares hasta que lo consigas Michael Jackson

Suficiente
Eso parece razonable. Madonna, Prince y otras canciones de Michael Jackson.

Son los vecinos más cercanos.
Alejémonos del pop y entremos en el rap, y veamos a los vecinos de 2Pac.

“Amor californiano”:
413 Si yo gobernara el mundo Nas

(Imagínate eso) (con Lauryn
Colina)
196 Te extrañaré Puff Daddy y el

Familia
330 Odiarlo o amarlo (con 50) El juego

Centavo)
211 Hipnotizar El notorio

GRANDE
5788 Déjalo caer como si estuviera caliente (con\/ Snoop Dogg

Pharrell)
¡Otra lista bastante razonable! Ahora que sabemos que funciona, veamos cómo
Construir un sistema así.
Entrenamiento de un modelo de incrustación de canciones
Comenzaremos cargando el conjunto de datos que contiene las listas de reproducción de canciones, así como
Los metadatos de cada canción, como su título y artista:

Importar pandas como pd desde

la solicitud de importación de urllib
# Obtener el archivo del conjunto de datos de la lista

de reproducción data = request.urlopen ('https://storage.googleapis.com/mapspremium/dataset/
yes_complete/train.txt')
# Analizar el archivo del conjunto de datos de la lista de reproducción. Omitir las dos primeras líneas ya
que # solo contienen metadatos lines =
data.read().decode("utf8").split('\n')[2:]
# Eliminar listas de reproducción con solo una canción playlists

= [s.rstrip().split() for s in lines if len(s.split()) > 1]
# Cargar metadatos de la canción

archivo_canciones
= request.urlopen('https://storage.googleapis.com/mapspremium/dataset/yes_complete/
song_hash.txt') archivo_canciones =
archivo_canciones.read().decode("utf8").split('\n') canciones = [s.rstrip().split('\t') para s en
archivo_canciones] df_canciones = pd.DataFrame(data=canciones, columnas = ['id',
'título', 'artista']) df_canciones = df_canciones.set_index('id')
Ahora que los hemos guardado, examinemos la lista de listas de reproducción. Cada elemento que
contiene es una lista de reproducción que contiene una lista de identificadores de canciones:
print( 'Lista de reproducción n.° 1:\n ', listas de reproducción[0], '\n')

print( 'Lista de reproducción n.° 2:\n ', listas de reproducción[1])
Lista de reproducción n.° 1: ['0', '1', '2', '3', '4', '5', ..., '43']
Lista de reproducción n.° 2: ['78', '79', '80', '3', '62', ..., '210']
Entrenemos el modelo:
Desde gensim.models importar Word2Vec
# Entrena nuestro modelo Word2Vec model

= Word2Vec( listas de
reproducción, vector_size=32, window=20, negative=50,
min_count=1, trabajadores=4 )
El entrenamiento lleva uno o dos minutos y da como resultado el cálculo de

incrustaciones para cada canción que tenemos. Ahora podemos usar esas incrustaciones para
encontrar canciones similares exactamente como lo hicimos antes con las palabras:
ID de canción = 2172
# Pídele al modelo canciones similares a la canción n.° 2172

model.wv.most_similar(positive=str(song_id))
Esto produce:
[('2976', 0.9977465271949768), ('3167',

0.9977430701255798), ('3094',
0.9975950717926025), ('2640',
0.9966474175453186), ('2849',
.9963167905807495)]
Esa es la lista de las canciones cuyas incrustaciones son más similares a la canción
2172.
En este caso la canción es:
imprimir(canciones_df.iloc[2172])
Título Fade To Black Artista

Metallica, dtype: objeto
Nombre: 2172
Esto da como resultado recomendaciones que pertenecen todas al mismo género de heavy
metal y hard rock:
importar numpy como np

def print_recomendaciones(id_canción):
canciones_similares = np.array(
modelo.wv.most_similar(positivo=str(id_canción),topn=5)
)[:,0]
devolver canciones_df.iloc[canciones_similares]
# Extraer recomendaciones
11473 Pequeñas guitarras Van Halen
3167 Desencadenado Van Halen
5586 El último en la fila Dio
5634 Señor Brownstone Guns N' Roses
3094 Judas Priest violando la ley
Resumen
En este capítulo, hemos cubierto los tokens LLM, los tokenizadores y las herramientas útiles.
Enfoques para el uso de incrustaciones de tokens. Esto nos prepara para comenzar a analizar
En el próximo capítulo nos adentraremos más en los modelos lingüísticos y también abriremos la puerta a
Descubra cómo se utilizan las incrustaciones más allá de los modelos de lenguaje.
Exploramos cómo los tokenizadores son el primer paso en el procesamiento de la entrada a un

LLM, transformación de entradas de texto sin procesar en identificadores de tokens. Tokenización común
Los esquemas incluyen dividir el texto en palabras, tokens de subpalabras,
caracteres o bytes, dependiendo de los requisitos específicos de un determinado
solicitud.
Un recorrido por tokenizadores preentrenados del mundo real (desde BERT hasta GPT2, GPT4
y otros modelos) nos mostró áreas en las que algunos tokenizadores son mejores (por ejemplo,
preservando información como mayúsculas, nuevas líneas o tokens en otros idiomas) y otras
áreas en las que los tokenizadores son simplemente diferentes entre sí (por ejemplo, cómo
descomponen ciertas palabras).
Tres de las principales decisiones de diseño del tokenizador son el algoritmo del tokenizador (por
ejemplo, BPE, WordPiece, SentencePiece), los parámetros de tokenización (incluido el tamaño del
vocabulario, los tokens especiales, la capitalización, el tratamiento de la capitalización y los
diferentes idiomas) y el conjunto de datos en el que se entrena el tokenizador.
Los modelos de lenguaje también son creadores de incrustaciones de tokens contextualizadas

de alta calidad que mejoran las incrustaciones estáticas sin procesar. Esas incrustaciones de
tokens contextualizadas son las que se utilizan para tareas que incluyen el reconocimiento
de entidades nombradas (NER), el resumen de texto extractivo y la clasificación de texto. Además de
producir incrustaciones de tokens, los modelos de lenguaje pueden producir incrustaciones de texto
que cubran oraciones completas o incluso documentos. Esto permite muchas aplicaciones que se
mostrarán en la Parte II de este libro que cubre las aplicaciones de modelos de lenguaje.
Antes de los LLM, los métodos de incrustación de palabras como word2vec, GloVe y
fastText eran populares. En el procesamiento del lenguaje, esto ha sido reemplazado en
gran medida por incrustaciones de palabras contextualizadas producidas por modelos de
lenguaje. El algoritmo word2vec se basa en dos ideas principales: skipgram y muestreo negativo.
También utiliza entrenamiento contrastivo similar al tipo que veremos en el Capítulo 10.
Las incrustaciones son útiles para crear y mejorar sistemas de recomendación, como analizamos en
el recomendador de música que creamos a partir de listas de reproducción de canciones
seleccionadas.
En el próximo capítulo, analizaremos en profundidad el proceso posterior a la

tokenización: ¿cómo procesa un LLM estos tokens y genera texto? Analizaremos algunas de las
principales intuiciones sobre cómo funcionan los LLM que utilizan la arquitectura
Transformer.
1
Nils Reimers e Iryna Gurevych. “SentenceBERT: incrustaciones de oraciones utilizando siameses
Redes BERT”. Preimpresión arXiv arXiv:1908.10084 (2019).
OceanofPDF.com
Capítulo 3. Observando el interior de

grandes modelos lingüísticos
Ahora que tenemos una idea de la tokenización y las incrustaciones, estamos listos para
profundizar en el modelo de lenguaje y ver cómo funciona. En este capítulo, veremos
algunas de las principales intuiciones de cómo funcionan los modelos de lenguaje de
Transformer. Nos centraremos en los modelos de generación de texto para obtener
una idea más profunda de los LLM generativos en particular.
Analizaremos los conceptos y algunos ejemplos de código que los demuestran.

Empecemos por cargar un modelo de lenguaje y prepararlo para su generación
mediante la declaración de una canalización. En la primera lectura, no dude en omitir el
código y centrarse en comprender los conceptos involucrados. Luego, en una
segunda lectura, el código le permitirá comenzar a aplicar estos conceptos.
importar antorcha
desde transformadores importar AutoModelForCausalLM, AutoTokenizer, pipeline
# Cargar modelo y tokenizador tokenizer =

AutoTokenizer.from_pretrained("microsoft/Phi3mini 4kinstruct")
modelo = AutoModelForCausalLM.from_pretrained( "microsoft/Phi3mini4k

instruct", mapa_de_dispositivo="cuda",
tipo_de_d_antorcha="auto",
código_remoto_de_confianza=True,
# Crear un pipeline generador =

pipeline( "textgeneration",
model=model,
max_new_tokens=50,
hacer_muestra=Falso,
)
Una descripción general de los modelos de transformadores
Comencemos nuestra exploración con una descripción general de alto nivel del modelo y
luego veremos cómo el trabajo posterior ha mejorado el modelo Transformer desde su
introducción en 2017.
Las entradas y salidas de un transformador entrenado LLM

La imagen más común para entender el comportamiento de un LLM de Transformer es pensarlo
como un sistema de software que recibe texto y genera texto como respuesta. Una vez que
se entrena un modelo de entrada de texto lo suficientemente grande en un conjunto de datos
de alta calidad lo suficientemente grande, se vuelve capaz de generar resultados
impresionantes y útiles. La Figura 31 muestra un modelo de este tipo utilizado para crear
un correo electrónico.
Figura 31. En un alto nivel de abstracción, los LLM de Transformer toman un mensaje de texto y
generan un texto.
El modelo no genera todo el texto en una sola operación; en realidad,

genera un token a la vez. La Figura 32 muestra cuatro pasos de generación
de tokens en respuesta a la solicitud de entrada. Cada paso de generación de
tokens es un paso hacia adelante a través del modelo (es la jerga del aprendizaje
automático para las entradas que ingresan a la red neuronal y fluyen a través de los
cálculos que necesita para producir una salida en el otro extremo del gráfico de cálculo).
Figura 32. Los LLM de Transformer generan un token a la vez, no todo el texto a la vez.
Después de cada generación de token, modificamos el mensaje de entrada para

el siguiente paso de generación agregando el token de salida al final del mensaje
de entrada. Podemos ver esto en la Figura 33.
Figura 33. Se agrega un token de salida al mensaje y luego este nuevo texto se presenta nuevamente al modelo para
que se realice otro pase hacia adelante para generar el siguiente token.
Esto nos da una imagen más precisa del modelo, ya que simplemente predice el siguiente token
en función de una solicitud de entrada. El software que rodea a la red neuronal
básicamente lo ejecuta en un bucle para expandir secuencialmente el texto generado hasta
completarlo.
Existe una palabra específica que se utiliza en el aprendizaje automático para describir los
modelos que consumen sus predicciones anteriores para realizar predicciones posteriores (por
ejemplo, el primer token generado del modelo se utiliza para generar el segundo token). Se
denominan modelos autorregresivos . Por eso, escuchará que los modelos LLM de generación
de texto se denominan modelos autorregresivos. Esto se suele utilizar para diferenciar
los modelos de generación de texto de los modelos de representación de texto como BERT,
que no son autorregresivos.
Esta generación autorregresiva, token por token, es lo que sucede en segundo plano cuando
generamos texto con LLM, como vemos aquí:
prompt = "Escribe un correo electrónico pidiendo disculpas a Sarah por el trágico

accidente de jardinería. Explica cómo sucedió".
salida = generador(prompt)
imprimir(salida[0]['texto_generado'])
Esto genera el texto:
Solución 1:
Asunto: Mis más sinceras disculpas por el percance con la jardinería.
Querida Sarah,
Espero que este mensaje te llegue bien. Te escribo para expresarte mi profundo pesar.
Podemos ver que el modelo comienza a escribir el correo electrónico comenzando por
el asunto. Se detuvo abruptamente porque alcanzó el límite de tokens que
establecimos al configurar max_new_tokens a 50 tokens. Si lo aumentamos,
continuará hasta concluir el correo electrónico.
Los componentes del pase hacia adelante

Además del bucle, dos componentes internos clave son el tokenizador y el cabezal de
modelado del lenguaje (cabeza LM). La Figura 34 muestra dónde se encuentran
estos componentes en el sistema. Vimos en el capítulo anterior cómo los
tokenizadores descomponen el texto en una secuencia de identificadores de token
que luego se convierten en la entrada del modelo.
Después del tokenizador viene la red neuronal: una pila de bloques Transformer que
realizan todo el procesamiento. Luego, esa pila va seguida del cabezal LM, que traduce
la salida de la pila en puntuaciones de probabilidad para determinar cuál es el token
más probable que aparecerá a continuación.
Figura 34. Un LLM de Transformer está compuesto por un tokenizador, una pila de bloques de Transformer y un
cabezal de modelado de lenguaje.
Recordemos que en el Capítulo 2 el tokenizador contiene una tabla de tokens: el

vocabulario del tokenizador. El modelo tiene una representación vectorial asociada
con cada uno de estos tokens en el vocabulario (incrustaciones de tokens). La Figura
35 muestra tanto el vocabulario como las incrustaciones de tokens asociadas para
un modelo con un vocabulario de 50.000 tokens.
Figura 35. El tokenizador tiene un vocabulario de 50 000 tokens. El modelo tiene incrustaciones de
tokens asociadas a esas incrustaciones.
El flujo del cálculo sigue la dirección de la flecha de arriba hacia abajo. Para cada
token generado, el proceso fluye una vez a través de cada uno de los bloques
Transformer en la pila en orden, luego al cabezal LM, que finalmente genera la
distribución de probabilidad para el siguiente token, como se ve en la Figura 36.
Figura 36. Al final del pase hacia adelante, el modelo predice una puntuación de probabilidad para cada
token del vocabulario.
El cabezal LM es en sí mismo una capa de red neuronal simple. Es uno de los múltiples
“cabezales” posibles que se pueden conectar a una pila de bloques Transformer para construir
diferentes tipos de sistemas. Otros tipos de cabezales Transformer incluyen cabezales
de clasificación de secuencias y cabezales de clasificación de tokens.
Podemos visualizar el orden de las capas simplemente imprimiendo la variable del modelo.
Para este modelo, tenemos:
Phi3ForCausalLM((modelo): Phi3Model(
(embed_tokens): Incrustación(32064, 3072, padding_idx=32000) (embed_dropout):
Dropout(p=0.0, inplace=False) (capas): ModuleList( (031): 32 x
Phi3DecoderLayer( (self_attn):
Phi3Attention(
(o_proj): Lineal(entrada_características=3072, salida_características=3072,

sesgo=Falso)
(qkv_proj): Lineal(entrada_características=3072,
salida_características=9216, sesgo=Falso)
(rotary_emb): incrustación rotatoria Phi3
) (mlp):
Phi3MLP( (gate_up_proj):
Lineal(características_de_entrada=3072, características_de_salida=16384, sesgo=Falso)
(proyección_abajo): Lineal(en_características=8192,
out_features=3072, sesgo=Falso) (función de

activación): SiLU()
) (capa_de_entrada_norma): Phi3RMSNorm()
(abandono_de_atención_residual): Abandono(p=0.0, inplace=Falso)
(abandono_de_mlp_residual): Abandono(p=0.0, inplace=Falso)
(capa_de_atención_posterior): Phi3RMSNorm()
)
) (norma): Phi3RMSNorm()
) (lm_head): Lineal(características_de_entrada=3072, características_de_salida=32064,

sesgo=Falso) )
Observando esta estructura podemos observar los siguientes aspectos destacados:
Esto nos muestra las distintas capas anidadas del modelo. La mayor parte del modelo
está etiquetada como modelo, seguida de lm_head.
Dentro del modelo Phi3Model, vemos la matriz de incrustaciones embed_tokens

y sus dimensiones. Tiene 32.064 tokens, cada uno con un tamaño de vector de
3.072.
Omitiendo por ahora la capa de abandono, podemos ver que el siguiente

componente principal es la pila de capas del decodificador Transformer. Contiene
32 bloques del tipo Phi3DecoderLayer.
Cada uno de estos bloques de Transformador incluye una capa de atención y una red
neuronal de retroalimentación (también conocida como mlp o perceptrón multinivel).
Los abordaremos con más detalle más adelante en este capítulo.
Finalmente, vemos que lm_head toma un vector de tamaño 3072 y genera un

vector equivalente a la cantidad de tokens que conoce el modelo. Ese resultado es
la puntuación de probabilidad de cada token que nos ayuda a seleccionar el
token de salida.
Elegir un solo token de la probabilidad

Distribución (Muestreo/Decodificación)
Al final del procesamiento, el resultado del modelo es una puntuación de probabilidad
para cada token del vocabulario, como vimos anteriormente en la Figura 36. El
método de elegir un solo token de la distribución de probabilidad se denomina estrategia
de decodificación. La Figura 37 muestra cómo esto lleva a elegir el token “Estimado” en
un ejemplo.
La estrategia de decodificación más sencilla sería elegir siempre el token con la

puntuación de probabilidad más alta. En la práctica, esto no suele dar los mejores
resultados para la mayoría de los casos de uso. Un enfoque mejor es añadir algo de
aleatoriedad y, a veces, elegir el segundo o tercer token con la probabilidad más alta.
La idea aquí es básicamente tomar muestras de la distribución de probabilidad en
función de la puntuación de probabilidad, como dirían los estadísticos.
Lo que esto significa para el ejemplo de la Figura 37 es que si el token “Estimado” tiene
una probabilidad del 40 % de ser el siguiente token, entonces tiene una probabilidad del
40 % de ser elegido (en lugar de la búsqueda voraz, que lo elegiría directamente por
tener la puntuación más alta). Por lo tanto, con este método, todos los demás tokens
tienen una probabilidad de ser elegidos según su puntuación.
Figura 37. Los tokens con la mayor probabilidad después del pase hacia adelante del modelo. Nuestra estrategia
de decodificación decide cuál de los tokens generar mediante un muestreo basado en las probabilidades.
Elegir la ficha con mayor puntuación cada vez se llama decodificación codiciosa.
Esto es lo que sucede si estableces el parámetro de temperatura en cero en un LLM.
Cubrimos el concepto de temperatura en el Capítulo 6.
Veamos más de cerca el código que demuestra este proceso. En este bloque de
código, pasamos los tokens de entrada a través del modelo y luego lm_head:
prompt = "La capital de Francia es"
# Tokenizar el mensaje de entrada

input_ids = tokenizer(prompt, return_tensors="pt").input_ids
# Tokenizar el mensaje de entrada

input_ids = input_ids.to("cuda")
# Obtener la salida del modelo antes de lm_head model_output

= model.model(input_ids)
# Obtener la salida de lm_head

lm_head_output = model.lm_head(model_output[0])
Ahora, lm_head_output tiene la forma [1, 6, 32064]. Podemos acceder a los puntajes de
probabilidad de token para el último token generado usando
lm_head_output[0,1], que usa el índice 0 en toda la dimensión del lote; el índice 1
nos da el último token en la secuencia. Esta es ahora una lista de puntajes de probabilidad
para los 32,064 tokens. Podemos obtener el ID del token con la puntuación más alta y
luego decodificarlo para llegar al texto del token de salida generado:
token_id = lm_head_output[0,1].argmax(1)
tokenizador.decode(token_id)
En este caso resulta ser:
París
Procesamiento de tokens en paralelo y tamaño del contexto
Una de las características más atractivas de los Transformers es que se prestan

mejor a la computación paralela que las arquitecturas de redes neuronales
anteriores en el procesamiento del lenguaje. En la generación de texto, obtenemos
un primer vistazo de esto al observar cómo se procesa cada token. Sabemos por el
capítulo anterior que el tokenizador descompondrá el texto en tokens.
Cada uno de estos tokens de entrada fluye luego a través de su propia ruta de cálculo
(al menos, esa es una buena primera intuición). Podemos ver estas pistas o
flujos de procesamiento individuales en la Figura 38.
Figura 38. Cada token se procesa a través de su propio flujo de cálculo (con cierta interacción entre ellos
en los pasos de atención, como veremos más adelante).
Los modelos de transformadores de corriente tienen un límite en cuanto a la cantidad de

tokens que pueden procesar a la vez. Ese límite se denomina longitud de contexto del
modelo. Un modelo con una longitud de contexto de 4K solo puede procesar tokens de 4K y solo
tendría 4K de estos flujos.
Cada uno de los flujos de tokens comienza con un vector de entrada (el vector de incrustación
y cierta información posicional; analizaremos las incrustaciones posicionales más adelante en
este capítulo). Al final del flujo, surge otro vector como resultado del procesamiento del
modelo, como se muestra en la Figura 39.
Figura 39. Cada flujo de procesamiento toma un vector como entrada y produce un vector resultante final del
mismo tamaño (a menudo denominado dimensión del modelo).
Para la generación de texto, solo se utiliza el resultado de salida del último flujo para
predecir el siguiente token. Ese vector de salida es la única entrada en el cabezal LM, ya que
calcula las probabilidades del siguiente token.
Quizás te preguntes por qué nos tomamos la molestia de calcular todos los flujos de
tokens si descartamos las salidas de todos los tokens excepto el último. La respuesta es
que los cálculos de los flujos anteriores son necesarios y se utilizan para calcular el
flujo final. Sí, no estamos utilizando su vector de salida final, pero usamos las salidas
anteriores (en cada bloque Transformer) en el mecanismo de atención del bloque
Transformer.
Si sigue los ejemplos de código, recuerde que la salida de lm_head tenía la forma [1, 6,
32064]. Esto se debió a que la entrada tenía la forma [1, 6, 3072], que es un lote de una
cadena de entrada, que contiene seis tokens, cada uno de ellos representado por
un vector de tamaño 3072 correspondiente a los vectores de salida después de la pila de
bloques Transformer.
Podemos acceder a estas matrices y ver sus dimensiones imprimiendo:
modelo_salida[0].forma
Esto produce:
De manera similar, podemos imprimir la salida del cabezal LM:
Forma de salida del cabezal lm_head
Esto produce:
Aceleración de la generación mediante el almacenamiento en caché de claves y valores
Recuerde que al generar el segundo token, simplemente agregamos el token de salida a la

entrada y realizamos otro paso hacia adelante a través del modelo. Si
Si le damos al modelo la capacidad de almacenar en caché los resultados del cálculo anterior
(especialmente algunos de los vectores específicos en el mecanismo de atención), ya no
necesitamos repetir los cálculos de los flujos anteriores. Esta vez, el único cálculo necesario es
para el último flujo. Esta es una técnica de optimización llamada caché de claves y
valores (kv) y proporciona una aceleración significativa del proceso de generación. Las claves y
los valores son algunos de los componentes centrales del mecanismo de atención, como
veremos más adelante en este capítulo.
La Figura 310 muestra cómo al generar el segundo token, solo un flujo de

procesamiento está activo mientras almacenamos en caché los resultados de los flujos anteriores.
Figura 310. Al generar texto, es importante almacenar en caché los resultados de los cálculos de
tokens anteriores en lugar de repetir el mismo cálculo una y otra vez.
En Hugging Face Transformers, la memoria caché está habilitada de forma predeterminada.

Podemos deshabilitarla configurando use_cache en Falso. Podemos ver la diferencia de velocidad al
solicitando una generación larga y cronometrando la generación con y sin almacenamiento

en caché:
prompt = "Escribe un correo electrónico muy largo pidiendo disculpas a Sarah por el trágico accidente de
jardinería. Explica cómo sucedió".
# Tokenizar el mensaje de entrada input_ids
= tokenizer(prompt, return_tensors="pt").input_ids input_ids = input_ids.to("cuda")
Luego cronometramos cuánto tiempo lleva generar 100 tokens con almacenamiento en
caché. Podemos usar el comando mágico %%timeit en Jupyter o Colab para cronometrar
cuánto tiempo lleva la ejecución (ejecuta el comando varias veces y obtiene el promedio):
%%timeit n 1 #
Generar el texto generation_output
= model.generate( input_ids=input_ids, max_new_tokens=100,
use_cache=True
En un Colab con una GPU T4, esto supone 4,5 segundos. Sin embargo, ¿cuánto tiempo tardaría
si deshabilitamos la memoria caché?
%%timeit n 1 #
Generar el texto generation_output
= model.generate( input_ids=input_ids, max_new_tokens=100,
use_cache=False
Esto equivale a 21,8 segundos. Una diferencia drástica. De hecho, desde el punto de vista de
la experiencia del usuario, incluso el tiempo de generación de cuatro segundos tiende a ser
mucho tiempo de espera para un usuario que está mirando una pantalla y esperando un
resultado del modelo. Esta es una de las razones por las que las API de LLM transmiten el resultado
tokens a medida que el modelo los genera en lugar de esperar a que se complete
toda la generación.
Dentro del bloque del transformador
Ahora podemos hablar de dónde se produce la mayor parte del procesamiento: los
bloques Transformer. Como muestra la Figura 311 , los LLM Transformer
están compuestos por una serie de bloques Transformer (que suelen estar en el rango
de seis en el artículo original de Transformer, hasta más de cien en muchos LLM
grandes). Cada bloque procesa sus entradas y luego pasa los resultados de su
procesamiento al bloque siguiente.
Figura 311. La mayor parte del procesamiento del LLM del Transformador ocurre dentro de una serie de bloques del
Transformador, cada uno de los cuales entrega el resultado de su procesamiento como entrada al bloque siguiente.
Un bloque Transformador (Figura 312) está formado por dos componentes

sucesivos:
1. La capa de atención se ocupa principalmente de incorporar información relevante de
otros tokens de entrada y posiciones.
2. La capa de avance alberga la mayoría de los componentes del modelo.
capacidad de procesamiento
Figura 312. Un bloque Transformador está formado por una capa de autoatención y una red neuronal de propagación
hacia adelante.
La red neuronal de propagación hacia adelante de un vistazo
Un ejemplo simple que da la intuición de la red neuronal de propagación hacia adelante sería si pasamos
la entrada simple “The Shawshank” a un modelo de lenguaje, con la expectativa de que generará
“Redención” como la siguiente palabra más probable (en referencia a la película de 1994).
La red neuronal de retroalimentación (en conjunto, en todas las capas del modelo) es la fuente de esta
información, como se muestra en la Figura 313 . Cuando el modelo se entrenó con éxito para modelar
un archivo de texto masivo (que incluía muchas menciones de “Cadena perpetua”), aprendió y almacenó la
información (y los comportamientos) que le permiten tener éxito en esta tarea.

Figura 313. El componente de red neuronal de propagación hacia adelante de un bloque Transformador probablemente
realiza la mayor parte de la memorización e interpolación del modelo.
Para que un LLM se entrene con éxito, necesita memorizar mucha información.
Pero no es simplemente una gran base de datos. La memorización es solo un ingrediente
en la receta de una generación de texto impresionante. El modelo puede usar esta
misma maquinaria para interpolar entre puntos de datos y patrones más complejos
para poder generalizar, lo que significa que funciona bien con entradas que no
había visto en el pasado y que no estaban en su conjunto de datos de entrenamiento.
NOTA
Cuando se utiliza un LLM comercial moderno, los resultados que se obtienen no son los
mencionados anteriormente en el sentido estricto de un “modelo de lenguaje”. Pasar
“The Shawshank” a un LLM de chat como GPT4 produce un resultado:
"The Shawshank Redemption" es una película de 1994 dirigida por Frank Darabont y está
basada en la novela corta "Rita Hayworth and Shawshank Redemption" escrita
por Stephen King. ...etc.
Esto se debe a que los modelos de lenguaje en bruto (como GPT3) son difíciles de utilizar correctamente
para las personas. Por eso, el modelo de lenguaje se entrena para ajustar las instrucciones y las preferencias
humanas y ajustar la retroalimentación para que coincida con las expectativas de las personas sobre lo que el
modelo debería generar.
La capa de atención de un vistazo El
contexto es vital para modelar adecuadamente el lenguaje. La simple memorización e

interpolación basada en el token anterior solo nos puede llevar hasta cierto punto. Lo
sabemos porque este fue uno de los enfoques principales para construir modelos de
lenguaje antes de las redes neuronales (ver Capítulo 3, “Modelos de lenguaje de N
gramas” de Speech and Language Processing por Daniel Jurafsky y James H.
Martín).
La atención es un mecanismo que ayuda al modelo a incorporar el contexto mientras

procesa un token específico. Piense en el siguiente mensaje:
“El perro persiguió a la ardilla porque ”
Para que el modelo prediga qué viene después de “it”, necesita saber a qué se refiere
“it”. ¿Se refiere al perro o a la ardilla?
En un LLM de Transformer entrenado, el mecanismo de atención toma esa

determinación. La atención agrega información del contexto a la representación
del token “it”. Podemos ver una versión simple de eso en la Figura 314.
Figura 314. La capa de autoatención incorpora información relevante de posiciones anteriores que
ayudan a procesar el token actual.
El modelo hace esto basándose en los patrones observados y aprendidos del

conjunto de datos de entrenamiento. Tal vez las oraciones anteriores también brinden
más pistas, como, por ejemplo, referirse al perro como "ella", lo que deja en claro que "eso"
se refiere a la ardilla.
La atención es todo lo que
necesitas Vale la pena profundizar en el mecanismo de atención. La versión más

simplificada del mecanismo se muestra en la Figura 315. Muestra múltiples posiciones
de token que ingresan a la capa de atención; la última es la que se está procesando
actualmente (la flecha rosa). El mecanismo de atención opera en el vector de entrada en
esa posición. Incorpora información relevante del contexto en el vector que produce
como salida para esa posición.
Figura 315. Un esquema simplificado de la atención: una secuencia de entrada y una posición actual en proceso.
Como nos interesa principalmente esta posición, la figura muestra un vector de entrada y un vector de salida que
incorpora información de los elementos anteriores en la secuencia según el mecanismo de atención.
En el mecanismo de atención intervienen dos pasos principales:
1. Una forma de puntuar la relevancia de cada uno de los tokens de entrada anteriores
con respecto al token actual que se está procesando (en la flecha rosa).
2. Utilizando esas puntuaciones, combinamos la información de los diversos

posiciones en un único vector de salida.
La figura 316 muestra estos dos pasos.
Figura 316. Atención se compone de dos pasos principales: puntuación de relevancia para cada posición y, luego, un paso
en el que combinamos la información en función de esas puntuaciones.
Para que el Transformador tenga una capacidad de atención más amplia, el

mecanismo de atención se duplica y se ejecuta varias veces en paralelo. Cada una
de estas aplicaciones paralelas de atención se dirige a un cabezal de atención.
Esto aumenta la capacidad del modelo para modelar patrones complejos en la
secuencia de entrada que requieren prestar atención a diferentes patrones a la vez.
La figura 317 muestra la intuición de cómo los cabezales de atención funcionan en paralelo con
un paso anterior de división de información y un paso posterior de combinación de los
resultados de todos los cabezales.
Figura 317. Obtenemos mejores LLM al realizar la atención varias veces en paralelo, lo que aumenta la capacidad del
modelo para prestar atención a diferentes tipos de información.
Cómo se calcula la atención
Veamos cómo se calcula la atención dentro de un solo cabezal de atención.

Antes de comenzar el cálculo, observemos lo siguiente como posición inicial:
La capa de atención (de un LLM generativo) procesa la atención para una

sola posición.
Las entradas a la capa son:
La representación vectorial de la posición actual o token
Las representaciones vectoriales de los tokens anteriores

El objetivo es producir una nueva representación de la posición actual que incorpore información
relevante de los tokens anteriores:
Por ejemplo, si estamos procesando la última posición de la oración “Sarah

alimentó al gato porque eso”, queremos que “eso” represente al gato, por lo que
la atención incorpora “información del gato” del token del gato.
El proceso de entrenamiento produce tres matrices de proyección que producen los
componentes que interactúan en este cálculo:
Una matriz de proyección de consultas
Una matriz de proyección clave
Una matriz de proyección de valores
La figura 318 muestra la posición inicial de todos estos componentes antes de que comiencen los cálculos
de atención. Para simplificar, observemos solo un cabezal de atención porque los demás cabezales
tienen cálculos idénticos pero con sus matrices de proyección individuales.
Figura 318. Antes de comenzar el cálculo de autoatención, tenemos las entradas a las matrices de
capas y proyecciones para consultas, claves y valores.
La atención comienza multiplicando las entradas por las matrices de proyección para
crear tres nuevas matrices. Estas se denominan matrices de consultas, claves y valores.
Estas matrices contienen la información de los tokens de entrada proyectados a tres
espacios diferentes que ayudan a llevar a cabo los dos pasos de la atención:
1. Puntuación de relevancia
2. Combinación de información
La Figura 319 muestra estas tres nuevas matrices y cómo la fila inferior de las tres matrices está
asociada con la posición actual, mientras que las filas superiores están asociadas con las
posiciones anteriores.
Figura 319. La atención se lleva a cabo mediante la interacción de las matrices de consultas, claves y valores.
Estos se producen multiplicando las entradas de la capa con las matrices de proyección.
Autoatención: puntuación de relevancia En
un transformador generativo, generamos un token a la vez. Esto significa que

procesamos una posición a la vez. Por lo tanto, el mecanismo de atención aquí solo
se ocupa de esta posición y de cómo se puede extraer información de otras
posiciones para informar esta posición.
El paso de puntuación de relevancia de la atención se lleva a cabo multiplicando

el vector de consulta de la posición actual por la matriz de claves. Esto produce una
puntuación que indica la relevancia de cada token anterior. Al pasar esto por una
operación softmax, se normalizan estas puntuaciones para que sumen 1. La figura
320 muestra la puntuación de relevancia resultante de este cálculo.
Figura 320. La puntuación de la relevancia de los tokens anteriores se logra multiplicando la

consulta asociada con la posición actual por la matriz de claves.
Autoatención: Combinando información
Ahora que tenemos las puntuaciones de relevancia, multiplicamos el vector de

valores asociado a cada token por la puntuación de ese token. Al sumar los
vectores resultantes, obtenemos el resultado de este paso de atención, como
vemos en la Figura 321.
Figura 321. Atención combina la información relevante de posiciones anteriores multiplicando sus puntuaciones
de relevancia por sus respectivos vectores de valores.
Mejoras recientes en el transformador

Arquitectura
Desde el lanzamiento de la arquitectura Transformer, se ha trabajado mucho para
mejorarla y crear mejores modelos. Esto abarca el entrenamiento en conjuntos de datos
más grandes y las optimizaciones para el proceso de entrenamiento y las tasas de
aprendizaje que se deben utilizar, pero también se extiende a la arquitectura en sí.
Al momento de escribir este artículo, muchas de las ideas del Transformer
original no han cambiado. Hay algunas ideas arquitectónicas que han demostrado
ser valiosas y que contribuyen al rendimiento de los modelos Transformer más
recientes, como Llama 2. En esta sección final del capítulo, repasamos varios
de los desarrollos recientes importantes de la arquitectura Transformer.
Atención más eficiente

El área que recibe la mayor atención de la comunidad de investigación es la capa de
atención del Transformador. Esto se debe a que el cálculo de la atención es la parte
computacionalmente más costosa del proceso.
Atención local/dispersa
A medida que los Transformers comenzaron a hacerse más grandes, surgieron ideas
como la atención dispersa ("Generar secuencias largas con transformadores dispersos")
y la atención de la ventana deslizante (“Longformer: El transformador de documentos
largos”) proporcionó mejoras para la eficiencia del cálculo de la atención.
La atención dispersa limita el contexto de los tokens anteriores a los que el modelo puede
prestar atención, como podemos ver en la Figura 322.
Figura 322. La atención local mejora el rendimiento al prestar atención únicamente a una pequeña cantidad de
posiciones anteriores.
Un modelo que incorpora un mecanismo de este tipo es GPT3, pero no lo utiliza para todos
los bloques Transformer (la calidad de la generación se degradaría enormemente si el modelo solo
pudiera ver una pequeña cantidad de tokens anteriores). La arquitectura GPT3 entrelazó
bloques Transformer de atención completa y de atención eficiente. De modo que los bloques
Transformer alternan entre atención completa (por ejemplo, bloques 1 y 3) y atención dispersa
(por ejemplo, bloques 2 y 4).
Para demostrar los diferentes tipos de atención, revise la Figura 323, que muestra cómo
funcionan los diferentes mecanismos de atención. Cada figura muestra a qué tokens anteriores
(azul claro) se puede prestar atención al procesar el token actual (azul oscuro).
Figura 323. Atención total versus atención dispersa. La figura 324 explica la coloración. (Fuente:
“Generación de secuencias largas con transformadores dispersos”).
Cada fila corresponde a un token que se está procesando. El código

de colores indica a qué tokens puede prestar atención el modelo
mientras procesa el token de la celda azul oscuro. La Figura 324 describe
esto con más claridad.
Figura 324. Las figuras de atención muestran qué token se está procesando y a qué tokens anteriores un mecanismo
de atención le permite prestar atención.
Esta figura también muestra la naturaleza autorregresiva de los bloques de decodificación

Transformer (que conforman la mayoría de los modelos de generación de texto); solo pueden
prestar atención a los tokens anteriores. Compárese esto con BERT, que puede prestar atención a
ambos lados (de ahí que la B en BERT signifique bidireccional).
Atención de consultas múltiples y consultas agrupadas
Un ajuste de atención eficiente más reciente para el Transformador es la atención de consultas

agrupadas (“GQA: Entrenamiento de modelos de transformadores de múltiples consultas
generalizados a partir de puntos de control de múltiples cabezales”), que es utilizada por modelos como Llama 2 y
3. La figura 325 muestra estos diferentes tipos de atención y la siguiente sección continúa
explicándolos.
Figura 325. Comparación de diferentes tipos de atención: atención multicabezal original, atención de consulta
agrupada y atención multiconsulta (fuente: “Decodificación rápida de transformadores: un cabezal de escritura es todo lo
que necesita”).
La atención de consultas agrupadas se basa en la atención de consultas múltiples (“ Decodificación

rápida de transformadores: un cabezal de escritura es todo lo que necesita”). Estos métodos
mejoran la escalabilidad de inferencia de modelos más grandes al reducir el tamaño de las matrices
involucradas.
Optimización de la atención: de consultas múltiples a consultas múltiples y consultas

agrupadas
Anteriormente en este capítulo mostramos cómo el artículo de Transformer describía la atención

multifocal. El Transformer ilustrado Se analiza en detalle cómo se utilizan las consultas, claves y
matrices de valores para realizar la operación de atención. La Figura 326 muestra cómo cada
“cabeza de atención” tiene sus propias matrices de consulta, clave y valores distintas calculadas para
una entrada determinada.
La forma en que la atención de consultas múltiples optimiza esto es compartiendo las matrices de
claves y valores entre todos los encabezados. Por lo tanto, las únicas matrices únicas para cada
encabezado serían las matrices de consultas, como podemos ver en la Figura 327.
Figura 326. La atención se lleva a cabo utilizando matrices de consultas, claves y valores. En la atención
multicabezal, cada cabeza tiene una versión distinta de cada una de estas matrices.
Figura 327. La atención de múltiples consultas presenta un mecanismo de atención más eficiente al compartir las matrices
de claves y valores entre todos los encabezados de atención.
Sin embargo, a medida que el tamaño de los modelos aumenta, esta optimización puede
ser demasiado exigente y podemos permitirnos usar un poco más de memoria para
mejorar la calidad de los modelos. Aquí es donde entra en juego la atención de consultas
agrupadas. En lugar de reducir la cantidad de matrices de claves y valores a una de cada
una, nos permite usar más (pero menos que la cantidad de cabezas). La Figura 328
muestra estos grupos y cómo cada grupo de cabezas de atención comparte matrices de claves y valores.
Figura 328. La atención de consultas agrupadas sacrifica un poco de la eficiencia de la atención de consultas múltiples
a cambio de una gran mejora en la calidad al permitir múltiples grupos de matrices de clave/valor compartidas;
cada grupo tiene su respectivo conjunto de encabezados de atención.
Atención flash
Flash Attention es un método y una implementación populares que proporcionan

aceleraciones significativas tanto para el entrenamiento como para la inferencia de los
LLM de Transformer en las GPU. Acelera el cálculo de la atención al optimizar qué
valores se cargan y se mueven entre la memoria compartida de una GPU (SRAM) y la
memoria de alto ancho de banda (HBM). Se describe en detalle en los
artículos “FlashAttention: Atención exacta rápida y eficiente en el uso de la
memoria con conciencia de E/S” y el posterior “FlashAttention2: Atención más rápida
con mejor paralelismo y partición del trabajo”.
El bloque del transformador
Recordemos que los dos componentes principales de un bloque Transformador

son una capa de atención y una red neuronal de retroalimentación. Una vista más
detallada del bloque también revelaría las conexiones residuales y las
operaciones de normalización de capas que podemos ver en la Figura 329.
Figura 329. Un bloque Transformer del artículo original Transformer.
Los últimos modelos de Transformer en el momento de escribir este artículo aún conservan
los componentes principales, aunque realizan una serie de ajustes como podemos ver en la Figura
330.
Una de las diferencias que vemos en esta versión del bloque Transformador es que la
normalización ocurre antes de la atención y las capas de avance.

Se ha informado que esto reduce el tiempo de entrenamiento requerido (lea: “Normalización en
capas en la arquitectura Transformer”). Otra mejora en
La normalización aquí se realiza mediante RMSNorm, que es más simple y eficiente

que la LayerNorm utilizada en el Transformer original (léase: “ Normalización de
capa de raíz cuadrada media”). Por último, en lugar de la función de activación
ReLU del Transformer original, ahora son más comunes variantes más nuevas como
SwiGLU (descrita en “ Las variantes de GLU mejoran el Transformer”) .
Figura 330. El bloque Transformer de un Transformer de la era 2024 como Llama 3 presenta algunos ajustes
como la prenormalización y una atención optimizada con atención de consultas agrupadas e
incrustaciones rotativas.
Incrustaciones posicionales (RoPE)

Las incrustaciones posicionales han sido un componente clave desde el Transformer
original. Permiten que el modelo lleve un registro del orden de los tokens/palabras en
una secuencia/oración, que es una fuente indispensable de información en el lenguaje. De los
muchos esquemas de codificación posicional propuestos en los últimos años, las
incrustaciones posicionales rotativas (o “RoPE”, introducidas en “RoFormer: Enhanced
Transformer with rotary position embedding”) son especialmente importantes de destacar.
El artículo original de Transformer y algunas de las primeras variantes tenían incrustaciones

posicionales absolutas que, en esencia, marcaban el primer token como posición 1, el segundo
como posición 2, etc. Estos podían ser métodos estáticos (donde los vectores posicionales se
generan utilizando funciones geométricas) o aprendidos (donde el entrenamiento del modelo les
asigna sus valores durante el proceso de aprendizaje). Algunos desafíos surgen de estos
métodos cuando ampliamos la escala de los modelos, lo que requiere que encontremos
formas de mejorar su eficiencia.
Por ejemplo, uno de los desafíos que presenta el entrenamiento eficiente de modelos con un contexto
amplio es que muchos documentos en el conjunto de entrenamiento son mucho más cortos
que ese contexto. Sería ineficiente asignar todo el contexto (por ejemplo, 4K) a una oración corta
de 10 palabras. Por lo tanto, durante el entrenamiento del modelo, los documentos se empaquetan
juntos en cada contexto en el lote de entrenamiento, como se muestra en la Figura 331 .
Figura 331. El empaquetado es el proceso de organizar de manera eficiente documentos de capacitación

breves en el contexto. Incluye la agrupación de varios documentos en un único contexto mientras se minimiza el
relleno al final del contexto.
Obtenga más información sobre empaquetamiento leyendo “Empaquetado eficiente de

secuencias sin contaminación cruzada: Aceleración de modelos de lenguaje grandes sin afectar
el rendimiento” y mirando las excelentes imágenes en “Presentación de BERT empaquetado
para acelerar el entrenamiento al doble en el procesamiento del lenguaje natural”.
Los métodos de incrustación posicional deben adaptarse a esta y otras consideraciones

prácticas. Si, por ejemplo, el Documento 50 comienza en la posición 50, estaríamos
desinformando al modelo si le decimos que ese primer token es el número 50 y eso afectaría
su rendimiento (porque supondría que hay un contexto previo mientras que, en realidad, los
tokens anteriores pertenecen a un documento diferente y no relacionado que el modelo debería
ignorar).
En lugar de las incrustaciones estáticas y absolutas que se agregan al comienzo del paso hacia
adelante, las incrustaciones rotativas son un método para codificar información posicional
de manera que capture información de posición absoluta y relativa del token. Se basa en
la idea de rotar vectores en su espacio de incrustaciones. En el paso hacia adelante, se
agregan en el paso de atención, como se muestra en la Figura 332 .
Figura 332. Las incrustaciones rotatorias se aplican en el paso de atención, no al comienzo del paso hacia adelante.
Durante el proceso de atención, la información posicional se mezcla específicamente

con las matrices de consultas y claves justo antes de que las multipliquemos para obtener la
puntuación de relevancia, como podemos ver en la Figura 333.
Figura 333. Se agregan incrustaciones posicionales rotatorias a la representación de tokens justo antes del paso
de puntuación de relevancia en la autoatención.
Otros experimentos y mejoras arquitectónicas

Se proponen y se investigan continuamente numerosos ajustes del Transformer. “Un
estudio sobre los Transformers” Destaca algunas de las direcciones principales. Las
arquitecturas de transformadores también se adaptan constantemente a dominios más allá de
los LLM. La visión por computadora es un área en la que se está realizando una gran
cantidad de investigación sobre arquitectura de transformadores (consulte: “Transformadores
en visión: una encuesta”) . y “Una encuesta sobre la visión transformadora”). Otros dominios
incluyen la robótica (ver “Open XEmbodiment: conjuntos de datos de aprendizaje robótico y
modelos RTX”) y series de tiempo (ver “Transformadores en series de tiempo: una encuesta”).
Resumen
En este capítulo, analizamos las principales intuiciones de Transformers y los desarrollos
recientes que permiten los últimos LLM de Transformers. Repasamos muchos conceptos
nuevos, así que analicemos los conceptos clave que analizamos en este capítulo:
Un Transformer LLM genera un token a la vez.
Ese token de salida se agrega al mensaje y luego este mensaje actualizado

se presenta nuevamente al modelo para otro pase hacia adelante para generar el
siguiente token.
Los tres componentes principales del Transformer LLM son el tokenizador,

una pila de bloques Transformer y un cabezal de modelado de lenguaje.
El tokenizador contiene el vocabulario de tokens para el modelo. El modelo

tiene incrustaciones de tokens asociadas con esos tokens.
Dividir el texto en tokens y luego utilizar las incrustaciones de estos tokens es
el primer paso en el proceso de generación de tokens.
El pase hacia adelante fluye a través de todas las etapas una vez, una por una.
Cerca del final del proceso, el líder del LM puntúa las probabilidades del siguiente
token posible. Las estrategias de decodificación indican qué token real elegir como
salida para este paso de generación (a veces es el siguiente token más probable,
pero no siempre).
Una de las razones por las que Transformer se destaca es su capacidad de procesar
tokens en paralelo. Cada uno de los tokens de entrada fluye hacia sus pistas o
flujos de procesamiento individuales. La cantidad de flujos es el "tamaño del
contexto" del modelo y representa la cantidad máxima de tokens con los que
puede operar el modelo.
Debido a que los LLM de Transformer realizan un bucle para generar el texto un token a la vez,
es una buena idea almacenar en caché los resultados del procesamiento de cada paso para que
No duplicamos el esfuerzo de procesamiento (estos resultados se almacenan

como varias matrices dentro de las capas).
La mayor parte del procesamiento ocurre dentro de los bloques Transformer.

Estas están formadas por dos componentes. Uno de ellos es la red
neuronal de propagación hacia adelante, que es capaz de almacenar información y
hacer predicciones e interpolaciones a partir de los datos con los que fue entrenada.
El segundo componente principal de un bloque Transformador es la capa

de atención . La atención incorpora información contextual para permitir que el
modelo capte mejor los matices del lenguaje.
La atención se produce en dos pasos principales: (1) evaluar la relevancia y (2)

combinar la información.
Una capa de atención de transformador realiza varias operaciones de atención en

paralelo, cada una de las cuales ocurre dentro de un cabezal de atención,
y sus salidas se agregan para formar la salida de la capa de atención.
La atención se puede acelerar compartiendo las matrices de claves y

valores entre todas las cabezas o grupos de cabezas (atención de consulta
agrupada).
Métodos como Flash Attention aceleran el cálculo de la atención al optimizar cómo

se realiza la operación en los diferentes sistemas de memoria de una GPU.
Los transformadores continúan viendo nuevos desarrollos y ajustes propuestos para

mejorarlos en diferentes escenarios, incluidos modelos de lenguaje y otros dominios y
aplicaciones.
En la segunda parte del libro, abordaremos algunas de estas aplicaciones prácticas de los
LLM. En el capítulo 4, comenzamos con la clasificación de textos, una tarea común en la
IA del lenguaje. El siguiente capítulo sirve como introducción a la aplicación de modelos
generativos y de representación.
OceanofPDF.com
Parte II. Uso de modelos de lenguaje

preentrenados
OceanofPDF.com
Capítulo 4. Clasificación de textos
Una tarea común en el procesamiento del lenguaje natural es la clasificación. El objetivo de la

tarea es entrenar un modelo para asignar una etiqueta o clase a un texto de entrada (ver
Figura 41). La clasificación de texto se utiliza en todo el mundo para una amplia gama de
aplicaciones, desde el análisis de sentimientos y la detección de intenciones hasta la
extracción de entidades y la detección del lenguaje. El impacto de los modelos de
lenguaje, tanto representativos como generativos, en la clasificación no se puede subestimar.
Figura 41. Uso de un modelo de lenguaje para clasificar texto.
En este capítulo, analizaremos varias formas de utilizar modelos de lenguaje para clasificar
textos. Servirá como una introducción accesible al uso de modelos de lenguaje que ya han sido
entrenados. Debido al amplio campo de la clasificación de textos, analizaremos varias
técnicas y las utilizaremos para explorar el campo de los modelos de lenguaje:
“Clasificación de texto con modelos de representación” demuestra la flexibilidad de

los modelos no generativos para la clasificación. Cubriremos tanto los modelos
específicos de la tarea como los modelos de incrustación.
“Clasificación de textos con modelos generativos” es una introducción a los modelos
de lenguaje generativo, ya que la mayoría de ellos se pueden utilizar para la

clasificación. Cubriremos tanto un modelo de lenguaje de código abierto como
uno de código cerrado.
En este capítulo, nos centraremos en aprovechar los modelos de lenguaje entrenados

previamente, modelos que ya han sido entrenados en grandes cantidades de datos que pueden ser
Se utiliza para clasificar textos. Como se ilustra en la Figura 42, examinaremos tanto los
modelos de representación como los de lenguaje y exploraremos sus diferencias.
Figura 42. Aunque tanto los modelos de representación como los generativos pueden utilizarse para la clasificación,
sus enfoques difieren.
Este capítulo sirve como introducción a una variedad de modelos de lenguaje, tanto
generativos como no generativos. Encontraremos paquetes comunes para cargar y usar
estos modelos.
CONSEJO
Aunque este libro se centra en los LLM, se recomienda encarecidamente comparar estos ejemplos
con líneas de base clásicas, pero sólidas, como la representación de texto con TFIDF y el entrenamiento
de un clasificador de regresión logística sobre eso.
El sentimiento de las críticas cinematográficas

Puedes encontrar los datos que usamos para explorar técnicas de clasificación de texto
en Hugging Face Hub, una plataforma para alojar modelos pero también datos. Utilizaremos
el conocido conjunto de datos “rotten_tomatoes” para entrenar y evaluar nuestros
modelos.1 Contiene 5.331 críticas positivas y 5.331 negativas de películas de

Tomates podridos.
Para cargar estos datos, utilizamos el paquete datasets, que se utilizará a lo largo del libro:
Desde conjuntos de datos, importar load_dataset
# Cargar nuestros datos

data = load_dataset("rotten_tomatoes") data
DatasetDict({ tren:
Dataset({ características:
['texto', 'etiqueta'], num_rows: 8530
})
validación: Conjunto de
datos({ características: ['texto', 'etiqueta'],
num_filas: 1066
})
prueba: Conjunto de
datos({ características: ['texto', 'etiqueta'],
num_filas: 1066
})
})
Los datos se dividen en divisiones de entrenamiento, prueba y validación . A lo largo de este

capítulo, utilizaremos la división de entrenamiento cuando entrenemos un modelo y la división de
prueba para validar los resultados. Tenga en cuenta que la división de validación adicional se
puede utilizar para validar aún más la generalización si utilizó las divisiones de entrenamiento y
prueba para realizar el ajuste de hiperparámetros.
Veamos algunos ejemplos en nuestra división de trenes:
datos["tren"][0, 1]
"
{'text': ['la roca está destinada a ser la nueva del siglo XXI
Conan " y que va a causar un revuelo aún mayor que
Arnold Schwarzenegger, JeanClaude van Damme o Steven Segal... las cosas realmente se ponen
raras. , aunque no da demasiado miedo: la película es pura

premonición y nada de contenido.'],
'etiqueta': [1, 0]}
Estas reseñas breves se etiquetan como positivas (1) o negativas (0). Esto significa que nos
centraremos en la clasificación binaria de sentimientos.
Clasificación de textos con representación

Modelos
La clasificación con modelos de representación preentrenados generalmente se presenta en
dos formas: mediante un modelo específico de la tarea o un modelo de integración. Como
exploramos en el capítulo anterior, estos modelos se crean mediante el ajuste fino de un
modelo de base, como BERT, en una tarea posterior específica, como se ilustra en la Figura
43.
Figura 43. Un modelo de base se ajusta para tareas específicas; por ejemplo, para realizar una clasificación
o generar incrustaciones de propósito general.
Un modelo específico de tarea es un modelo de representación, como BERT, entrenado para

una tarea específica, como el análisis de sentimientos. Como exploramos en el Capítulo
1, un modelo de incrustación genera incrustaciones de propósito general que se pueden usar
para una variedad de tareas que no se limitan a la clasificación, como la búsqueda semántica
(ver Capítulo 8).
El proceso de ajuste de un modelo BERT para la clasificación se cubre en el Capítulo 11,

mientras que la creación de un modelo de integración se cubre en el Capítulo 10. En este
capítulo, mantenemos ambos modelos congelados (no entrenables) y solo usamos su salida
como se muestra en la Figura 44.
Figura 44. Realice la clasificación directamente con un modelo específico de la tarea o indirectamente con
incrustaciones de propósito general.
Aprovecharemos modelos previamente entrenados que otros ya han perfeccionado para nosotros
y exploraremos cómo se pueden utilizar para clasificar nuestras reseñas de películas seleccionadas.
Selección de modelo
Elegir los modelos correctos no es tan sencillo como podría pensarse con más de 60.000 modelos
en Hugging Face Hub para la clasificación de texto. y más de 8.000 modelos que generan
incrustaciones En el momento de escribir este artículo, es fundamental seleccionar un
modelo que se adapte a su caso de uso y tener en cuenta su compatibilidad con el lenguaje, la
arquitectura subyacente, el tamaño y el rendimiento.
Comencemos con la arquitectura subyacente. Como exploramos en el Capítulo 1, BERT, una

arquitectura de solo codificador bien conocida, es una opción popular para crear modelos de
incrustación y específicos de tareas. Si bien los modelos generativos, como la familia GPT, son
modelos increíbles, los modelos de solo codificador también se destacan en casos de uso específicos
de tareas y tienden a ser significativamente más pequeños en tamaño.
A lo largo de los años, se han desarrollado muchas variaciones de BERT, incluidas

RoBERTa,2 DestilBERT, 3 ALBERTO, 4 y DeBERTa,5 cada uno capacitado en
Varios contextos. Puede encontrar una descripción general de algunos modelos similares a BERT
conocidos en la Figura 45.
Figura 45. Cronología de versiones de modelos similares a BERT comunes. Se consideran modelos básicos y, en
su mayoría, están pensados para perfeccionarse en una tarea posterior.
Seleccionar el modelo adecuado para el trabajo puede ser una forma de arte en sí misma.
Probar miles de modelos preentrenados que se pueden encontrar en el Hub de Hugging Face no
es factible, por lo que debemos ser eficientes con los modelos que elegimos.
Dicho esto, existen varios modelos que son excelentes puntos de partida y que te dan una idea
del rendimiento básico de este tipo de modelos. Considéralos puntos de referencia sólidos:
Modelo base BERT (sin carcasa)
Modelo base de RoBERTa
Modelo base de DistilBERT (sin carcasa)
Modelo base DeBERTa
bertpequeño
Base ALBERT v2
Para el modelo específico de la tarea, elegimos el modelo TwitterRoBERTabase para el análisis

de sentimientos . Se trata de un modelo RoBERTa optimizado para los tuits con el fin de analizar
los sentimientos. Aunque no se entrenó específicamente para reseñas de películas, es interesante
explorar cómo se generaliza este modelo.
Al seleccionar modelos para generar incrustaciones, la tabla de clasificación MTEB es

un buen lugar para comenzar. Contiene modelos de código abierto y cerrado evaluados en
varias tareas. Asegúrese de no solo tener en cuenta el rendimiento. La importancia de la
velocidad de inferencia no debe subestimarse en soluciones de la vida real. Por lo tanto, utilizaremos
sentencetransformers/allmpnetbasev2 como incrustación en esta sección. Es un
modelo pequeño pero de alto rendimiento.
Utilizando un modelo específico para cada tarea
Ahora que hemos seleccionado nuestro modelo de representación específico de la tarea,

comencemos cargando nuestro modelo:
# Ruta a nuestro modelo HF

model_path = "cardiffnlp/twitterrobertabasesentimentlatest"
# Cargar el modelo en la tubería pipe =

pipeline( model=model_path,
tokenizer=model_path,
return_all_scores=True,
device="cuda:0"
A medida que cargamos nuestro modelo, también cargamos el tokenizador, que es responsable
de convertir el texto de entrada en tokens individuales, como se ilustra en la Figura 46.
Aunque ese parámetro no es necesario ya que se carga automáticamente, ilustra lo que
está sucediendo bajo el capó.
Figura 46. Una oración de entrada se introduce primero en un tokenizador antes de que pueda ser procesada por el modelo específico
de la tarea.
Estos tokens son el núcleo de la mayoría de los modelos de lenguaje, como se explora en
profundidad en el Capítulo 2. Un beneficio importante de estos tokens es que se pueden
combinar para generar representaciones incluso si no estaban en los datos de
entrenamiento, como se muestra en la Figura 47.
Figura 47. Al descomponer una palabra desconocida en tokens, aún se pueden generar incrustaciones de palabras.
Después de cargar todos los componentes necesarios, podemos continuar y utilizar nuestro
modelo en la división de prueba de nuestros datos:

desde tqdm importar tqdm desde
transformers.pipelines.pt_utils importar KeyDataset
# Ejecutar inferencia
y_pred = [] para
salida en tqdm(pipe(KeyDataset(data["test"], "text")), total=len(data["test"])): puntuación_negativa
= salida[0]["puntuación"] puntuación_positiva
= salida[2]["puntuación"] asignación =
np.argmax([puntuación_negativa, puntuación_positiva])
y_pred.append(asignación)
Ahora que hemos generado nuestras predicciones, lo único que nos queda es la evaluación. Creamos
una pequeña función que podemos utilizar fácilmente a lo largo de este capítulo:
Desde sklearn.metrics, importe informe_de_clasificación
def evaluar_rendimiento(y_true, y_pred):

"""Crear e imprimir el informe de clasificación"""
rendimiento = informe_clasificación(
y_verdadero, y_pred,
target_names=[" Reseña negativa", "Reseña positiva"]
)
impresión(rendimiento)
A continuación, vamos a crear nuestro informe de clasificación:
evaluar_rendimiento(datos["prueba"]["etiqueta"], y_pred)
precisión Recordar el soporte de f1score
Reseña negativa 0,76 0,88 0,81 533

Reseña positiva 0,86 0,72 0,78 533
precisión 0,80 1066

macro 0,81 0,80 0,80 1066
promedio promedio ponderado 0,81 0,80 0,80 1066
Para leer el informe de clasificación resultante, comencemos primero por explorar cómo
Podemos identificar predicciones correctas e incorrectas. Hay cuatro
combinaciones dependiendo de si predecimos algo correctamente (Verdadero)
versus incorrectamente (Falso) y si predecimos la clase correcta
(Positivo) versus clase incorrecta (Negativo). Podemos ilustrar estos
combinaciones como una matriz, comúnmente denominada matriz de confusión, en
Figura 48.
Figura 48. La matriz de confusión describe cuatro tipos de predicciones que podemos hacer.
Utilizando la matriz de confusión, podemos derivar varias fórmulas para describir la calidad del
modelo. En el informe de clasificación generado anteriormente podemos ver cuatro de estos
métodos, a saber, precisión, recuperación, exactitud y F1.
puntaje:
La precisión mide cuántos de los elementos encontrados son relevantes, lo que

indica la exactitud de los resultados relevantes.
La recuperación se refiere a cuántas clases relevantes se encontraron, lo que indica

su capacidad para encontrar todos los resultados relevantes.
La precisión se refiere a cuántas predicciones correctas hace el modelo de todas las

predicciones, lo que indica la exactitud general del modelo.
La puntuación F1 equilibra tanto la precisión como la recuperación para crear el rendimiento

general de un modelo.
Estas cuatro métricas se ilustran en la Figura 49, que las describe utilizando el informe de clasificación
mencionado anteriormente.
Figura 49. El informe de clasificación describe varias métricas para evaluar el rendimiento de un modelo.
Consideraremos el promedio ponderado de la puntuación F1 en todos los ejemplos de este libro

para asegurarnos de que cada clase reciba el mismo trato. Nuestro modelo BERT entrenado
previamente nos da una puntuación F1 de 0,80 (lo leemos de la fila de promedio ponderado y la
columna de puntuación F1 ), lo cual es excelente para un modelo que no se entrenó específicamente
con los datos de nuestro dominio.
Para mejorar el rendimiento de nuestro modelo seleccionado, podríamos hacer algunas cosas
diferentes, entre ellas seleccionar un modelo entrenado con los datos de nuestro dominio, reseñas
de películas en este caso, como DistilBERT base uncased finetuned SST2.
También podríamos trasladar nuestro enfoque a otro tipo de modelos de representación,
concretamente los modelos de inserción.
Tareas de clasificación que aprovechan

Incrustaciones
En el ejemplo anterior, utilizamos un modelo específico de la tarea previamente entrenado para
el análisis de sentimientos. Sin embargo, ¿qué sucede si no podemos encontrar un modelo que
haya sido previamente entrenado para esta tarea específica? ¿Necesitamos ajustar un modelo de
representación nosotros mismos? ¡La respuesta es no!
Puede haber ocasiones en las que desee ajustar el modelo usted mismo si dispone de suficientes
recursos informáticos (consulte el Capítulo 11). Sin embargo, no todo el mundo tiene
acceso a recursos informáticos extensos. Aquí es donde entran en juego los modelos de incrustación
de propósito general.
Clasificación supervisada
A diferencia del ejemplo anterior, podemos realizar parte del proceso de entrenamiento
nosotros mismos al abordarlo desde una perspectiva más clásica. En lugar de utilizar
directamente el modelo de representación para la clasificación, utilizaremos un modelo
de incrustación para generar características. Esas características pueden luego introducirse
en un clasificador, creando así un enfoque de dos pasos como se muestra en la Figura 410.
Figura 410. El paso de extracción de características y los pasos de clasificación están separados.
Una de las principales ventajas de esta separación es que no necesitamos ajustar nuestro
modelo de incrustación, lo que puede resultar costoso. Por el contrario, podemos entrenar un
clasificador, como una regresión logística, en la CPU.
En el primer paso, convertimos nuestra entrada de texto en incrustaciones utilizando el

modelo de incrustación como se muestra en la Figura 411. Tenga en cuenta que este modelo
también se mantiene congelado y no se actualiza durante el proceso de entrenamiento.
Figura 411. En el paso 1, utilizamos el modelo de incrustación para extraer las características y convertir el texto de entrada
en incrustaciones.
Podemos realizar este paso con sentencetransformer, un paquete popular para

aprovechar modelos de incrustación entrenados previamente.6 Crear las
incrustaciones es sencillo:
# Cargar modelo
model = SentenceTransformer("transformadoresdesentencias/allmpnetbasev2")
# Convertir texto en incrustaciones

train_embeddings = model.encode(data["train"]["text"], show_progress_bar=True)
test_embeddings =
model.encode(data["test"]["text"], show_progress_bar=True)
Como vimos en el Capítulo 1, estas incrustaciones son representaciones

numéricas del texto de entrada. La cantidad de valores, o dimensión, de la incrustación
depende del modelo de incrustación subyacente. Analicemos eso para nuestro modelo:
incrustaciones_de_tren.forma
(8530, 768)
Esto demuestra que cada uno de nuestros 8.530 documentos de entrada tiene una
dimensión de incrustación de 768 y, por lo tanto, cada incrustación contiene 768 valores
numéricos.
En el segundo paso, estas incrustaciones sirven como características de entrada para

el clasificador ilustrado en la Figura 412. El clasificador es entrenable y no se limita
a la regresión logística, y puede adoptar cualquier forma siempre que realice la
clasificación.
Figura 412. Utilizando las incrustaciones como nuestras características, entrenamos un modelo de regresión logística en nuestros
datos de entrenamiento.
Mantendremos este paso simple y utilizaremos una regresión logística como clasificador.
Para entrenarlo, solo necesitamos utilizar las incrustaciones generadas
Junto con nuestras etiquetas:
desde sklearn.linear_model importar LogisticRegression
# Entrena una regresión logística en nuestras incrustaciones de tren

clf = Regresión logística (estado aleatorio = 42)
clf.fit(train_embeddings, datos["train"]["etiqueta"])
A continuación, evaluemos nuestro modelo:
# Predecir instancias nunca antes vistas

y_pred = clf.predict(prueba_incrustaciones)


macro 0,85 0,85 0,85 1066
Al entrenar un clasificador sobre nuestras incrustaciones, logramos obtener un F1

¡Puntuación de 0,85! Esto demuestra las posibilidades de entrenar un peso ligero.
clasificador mientras mantiene congelado el modelo de incrustación subyacente.
CONSEJO
En este ejemplo, usamos transformadores de oraciones para extraer nuestras incrustaciones,

que se beneficia de una GPU para acelerar la inferencia. Sin embargo, podemos eliminar esta GPU
dependencia mediante el uso de una API externa para crear las incrustaciones. Opciones populares para
La generación de incrustaciones es una de las ofertas de Cohere y OpenAI. Como resultado, esto sería
permitir que la tubería se ejecute completamente en la CPU.
¿Qué pasa si no tenemos datos etiquetados?
En nuestro ejemplo anterior, habíamos etiquetado datos que podíamos aprovechar, pero
esto no siempre sucede en la práctica. Obtener datos etiquetados es una tarea que
consume muchos recursos y puede requerir una cantidad significativa de trabajo humano.
Además, ¿realmente vale la pena recopilar estas etiquetas?
Para probar esto, podemos realizar una clasificación de cero disparos, donde no
tenemos datos etiquetados para explorar si la tarea parece factible. Aunque conocemos la
definición de las etiquetas (sus nombres), no tenemos datos etiquetados para
respaldarlas. La clasificación de cero disparos intenta predecir las etiquetas del texto de
entrada aunque no haya sido entrenado con ellas, como se muestra en la Figura 413.
Figura 413. En la clasificación de cero disparos, no tenemos datos etiquetados, solo las etiquetas mismas. El
modelo de cero disparos decide cómo se relaciona la entrada con las etiquetas candidatas.
Para realizar una clasificación de cero disparos con incrustaciones, hay un truco muy útil que
podemos utilizar. Podemos describir nuestras etiquetas en función de lo que deberían
representar. Por ejemplo, una etiqueta negativa para críticas de películas se puede describir como
"Esta es una crítica negativa de una película". Al describir e incrustar las etiquetas y los
documentos, tenemos datos con los que podemos trabajar. Este proceso, como se ilustra en la
Figura 414, nos permite generar nuestras propias etiquetas de destino sin la necesidad
de tener realmente ningún dato etiquetado.
Figura 414. Para insertar las etiquetas, primero debemos darles una descripción, como por ejemplo “una crítica negativa de
una película”. Esto puede insertarse luego mediante transformadores de oraciones.
Podemos crear estas incrustaciones de etiquetas utilizando la función .encode como lo hicimos
anteriormente:
# Crear incrustaciones para nuestras etiquetas

label_embeddings = model.encode(["Una reseña negativa", "Una reseña positiva"])
Para asignar etiquetas a los documentos, podemos aplicar la similitud de coseno a los
pares de etiquetas de los documentos. Este es el coseno del ángulo entre los vectores, que
se calcula a través del producto escalar de las incrustaciones y se divide por el producto
de sus longitudes, como se ilustra en la Figura 415.
Figura 415. La similitud del coseno es el ángulo entre dos vectores o incrustaciones. En este ejemplo, calculamos la similitud
entre un documento y las dos etiquetas posibles, positiva y negativa.
Podemos utilizar la similitud del coseno para comprobar la similitud de un documento

determinado con la descripción de las etiquetas candidatas. Se elige la etiqueta con la
mayor similitud con el documento, como se ilustra en la Figura 416.
Figura 416. Después de incorporar las descripciones de las etiquetas y los documentos, podemos utilizar la similitud de coseno
para cada par de etiquetas y documentos.
Para realizar la similitud de coseno en las incrustaciones, solo necesitamos comparar

Las incrustaciones de documentos con las incrustaciones de etiquetas y obtienen lo mejor
pares coincidentes:
de sklearn.metrics.pairwise importar cosine_similarity
# Encuentra la etiqueta que mejor se adapta a cada documento

matriz_sim = similitud_coseno(incrustaciones_de_prueba, incrustaciones_de_etiqueta)
y_pred = np.argmax(matriz_simulación, eje=1)
¡Y eso es todo! Solo nos faltaba pensar en nombres para nuestras etiquetas.
Realizamos nuestras tareas de clasificación. Veamos qué tan bien funciona este método:


macro 0,78 0,78 0,78 1066
NOTA
Si está familiarizado con la clasificación de disparo cero Con modelos basados en Transformers, usted
Tal vez se pregunten por qué elegimos ilustrar esto con incrustaciones. Aunque
Los modelos de inferencia de lenguaje natural son sorprendentes para la clasificación de disparo cero, el ejemplo
Aquí se demuestra la flexibilidad de las incrustaciones para una variedad de tareas. Como verás
A lo largo del libro, se pueden encontrar incrustaciones en la mayoría de los casos de uso de inteligencia artificial del lenguaje y son
Un componente a menudo subestimado pero increíblemente vital.
Una puntuación F1 de 0,78 es bastante impresionante teniendo en cuenta que no utilizamos ningún
¡Datos etiquetados en absoluto! Esto demuestra lo versátiles y útiles que son las incrustaciones.
lo son, especialmente si eres un poco creativo con la forma en que se utilizan.
CONSEJO
Pongamos a prueba esa creatividad. Hemos decidido que el nombre de nuestras etiquetas sea “Una
reseña negativa/positiva”, pero se puede mejorar. En su lugar, podemos hacerlas un poco más
concretas y específicas respecto de nuestros datos utilizando “Una reseña de película muy negativa/
positiva”. De esta manera, la incrustación captará que se trata de una reseña de película y se centrará
un poco más en los extremos de las dos etiquetas. Pruébelo y explore cómo afecta los resultados.
Clasificación de textos con modelos generativos

La clasificación con modelos de lenguaje generativo, como los modelos GPT de OpenAI,
funciona de forma un poco diferente a lo que hemos hecho hasta ahora. Estos modelos
toman como entrada un texto y un texto generativo y, por lo tanto, se denominan
apropiadamente modelos de secuencia a secuencia. Esto contrasta marcadamente con
nuestro modelo específico de tareas, que en su lugar genera una clase, como se ilustra en la Figura 417.
Figura 417. Un modelo específico de tarea genera valores numéricos a partir de secuencias de tokens, mientras
que un modelo generativo genera secuencias de tokens a partir de secuencias de tokens.
Estos modelos generativos generalmente se entrenan en una amplia variedad de tareas

y, por lo general, no ejecutan su caso de uso de manera inmediata. Por ejemplo, si le damos
a un modelo generativo una reseña de una película sin ningún contexto, no tiene idea de qué
hacer con ella.
En cambio, debemos ayudarlo a comprender el contexto y guiarlo hacia las respuestas que
estamos buscando. Como se muestra en la Figura 418, este proceso de guía se
realiza principalmente a través de la instrucción o indicación que le damos .
Proporcione un modelo de este tipo. Mejorar iterativamente su propuesta para obtener el resultado
deseado se denomina ingeniería de propuestas.
Figura 418. La ingeniería de indicaciones permite actualizar las indicaciones para mejorar el resultado generado por
el modelo.
En esta sección, demostraremos cómo podemos aprovechar diferentes tipos de modelos generativos
para realizar la clasificación sin nuestro conjunto de datos Rotten Tomatoes.
Uso del transformador de transferencia de texto a texto

A lo largo de este libro, exploraremos principalmente modelos de solo codificador (representación)
como BERT y modelos de solo decodificador (generativos) como ChatGPT.
Sin embargo, como se explicó en el Capítulo 1, la arquitectura original de Transformer en realidad
consiste en una arquitectura de codificadordecodificador. Al igual que los modelos que solo incluyen
decodificador, estos modelos de codificadordecodificador son modelos de secuencia a secuencia
y generalmente entran en la categoría de modelos generativos.
Una familia interesante de modelos que aprovechan esta arquitectura es el Transformador de

transferencia de texto a texto o modelo T5. Ilustrado en la Figura 419, su arquitectura es
similar a la del Transformador original, donde se apilan 12 decodificadores y 12 codificadores.
7
Figura 419. La arquitectura T5 es similar al modelo Transformer original, una arquitectura decodificadorcodificador.
Con esta arquitectura, estos modelos se entrenaron previamente utilizando el modelado de

lenguaje enmascarado. En el primer paso del entrenamiento, ilustrado en la Figura 420, en
lugar de enmascarar tokens individuales, se enmascararon conjuntos de tokens (o intervalos de
tokens) durante el entrenamiento previo.
Figura 420. En el primer paso del entrenamiento, es decir, el preentrenamiento, el modelo T5 debe predecir
máscaras que podrían contener múltiples tokens.
El segundo paso del entrenamiento, es decir, el ajuste fino del modelo base, es
donde ocurre la verdadera magia. En lugar de ajustar el modelo para una tarea
específica, cada tarea se convierte en una tarea secuencia a secuencia y se
entrena simultáneamente. Como se ilustra en la Figura 421, esto permite entrenar
el modelo en una amplia variedad de tareas.
Figura 421. Al convertir tareas específicas en instrucciones textuales, el modelo T5 puede entrenarse en una
variedad de tareas durante el ajuste fino.
Este método de ajuste fino se amplió en el artículo “Scaling instructionfinetuned language

models”, que introdujo más de mil tareas durante el ajuste fino que siguen más de cerca las
instrucciones tal como las conocemos de los modelos GPT.8 Esto dio como resultado la
familia de modelos FlanT5 que se benefician de esta gran variedad de tareas.
Para utilizar este modelo FlanT5 preentrenado para la clasificación, comenzaremos

cargándolo a través de la tarea "text2textgeneration", que generalmente está reservada
para estos modelos de codificadordecodificador:
# Cargar nuestro modelo

pipe = pipeline( "text2text
generation", model="google/flant5
small", device="cuda:0"
El modelo FlanT5 viene en varios tamaños (flant5small/base/large/xl/xxl) y usaremos el más

pequeño para acelerar un poco las cosas. Sin embargo, siéntete libre de experimentar con
modelos más grandes para ver si puedes mejorar los resultados.
En comparación con nuestro modelo específico para tareas, no podemos simplemente darle
un texto al modelo y esperar que muestre el sentimiento. En cambio, tendremos que indicarle
al modelo que lo haga.
Por lo tanto, anteponemos a cada documento la pregunta “¿La siguiente oración es positiva
o negativa?”:
# Prepara nuestros datos

prompt = "¿La siguiente oración es positiva o negativa?" data = data.map(lambda example: {"t5":
prompt + example['text']}) data
DatasetDict({ tren:
Dataset({ características:
['texto', 'etiqueta', 't5'], num_rows: 8530
})
validación: Conjunto de datos({
características: ['texto', 'etiqueta', 't5'],

num_filas: 1066
})
prueba: Conjunto de datos({
características: ['texto', 'etiqueta', 't5'],
num_filas: 1066
})
})
Después de crear nuestros datos actualizados, podemos ejecutar la canalización de manera similar al
ejemplo específico de la tarea:
# Ejecutar inferencia
y_pred = []
para salida en tqdm(pipe(KeyDataset(data["test"], "t5")),
total=len(datos["prueba"])):
texto = salida[0]["texto_generado"]
y_pred.append(0 si el texto == "negativo" de lo contrario 1)
Dado que este modelo genera texto, necesitábamos convertir la salida textual a
valores numéricos. La palabra de salida “negativo” se asignó a 0, mientras que
“positivo” fue asignado a 1.
Estos valores numéricos ahora nos permiten probar la calidad del modelo en el
De la misma manera que lo hemos hecho antes:


macro 0,84 0,84 0,84 1066
Con una puntuación F1 de 0,84, está claro que este modelo FlanT5 es un primer modelo sorprendente.
Analizar las capacidades de los modelos generativos.

ChatGPT para clasificación
Aunque a lo largo del libro nos centramos en los modelos de código abierto, otro
componente importante del campo de la IA del lenguaje son los modelos de código
cerrado; en particular, ChatGPT.
Aunque la arquitectura subyacente del modelo ChatGPT original (GPT3.5) no es compartida,

podemos asumir por su nombre que se basa en la arquitectura de solo decodificador
que hemos visto en los modelos GPT hasta ahora.
Afortunadamente, OpenAI compartió una descripción general del procedimiento de

capacitación. Esto implicó un componente importante, a saber, el ajuste de preferencias. Como
se ilustra en la Figura 422, OpenAI primero creó manualmente la salida deseada para una
solicitud de entrada (datos de instrucción) y utilizó esos datos para crear una primera
variante de su modelo.
Figura 422. Se utilizaron datos etiquetados manualmente que consisten en una instrucción (indicador) y una salida
para realizar un ajuste fino (ajuste de instrucciones).
OpenAI utilizó el modelo resultante para generar múltiples resultados que se clasificaron
manualmente de mejor a peor. Como se muestra en la Figura 423, esta clasificación
demuestra una preferencia por determinados resultados (datos de preferencia) y se utilizó
para crear su modelo final, ChatGPT.
Figura 423. Se utilizaron datos de preferencias clasificados manualmente para generar el modelo final, ChatGPT.
Una de las principales ventajas de utilizar datos de preferencias en lugar de datos de

instrucciones es el matiz que representa. Al demostrar la diferencia entre un resultado
bueno y uno mejor, el modelo generativo aprende a generar texto que se asemeja a la
preferencia humana. En el capítulo 12, exploraremos cómo funcionan estas
metodologías de ajuste fino y de preferencias y cómo puede llevarlas a cabo usted
mismo.
El proceso de uso de un modelo de código cerrado es bastante diferente de los ejemplos

de código abierto que hemos visto hasta ahora. En lugar de cargar el modelo, podemos
acceder a él a través de la API de OpenAI.
Antes de pasar al ejemplo de clasificación, primero deberá crear una cuenta gratuita en https://
oreil.ly/AEXvA y crea una clave API aquí: https://oreil.ly/lrTXl. Después de hacerlo,
puede usar su API para comunicarse con los servidores de OpenAI.
Podemos usar esta clave para crear un cliente:
importar openai
# Crear cliente cliente =

openai.OpenAI(api_key="SU_CLAVE_AQUI")
Usando este cliente, creamos la función chatgpt_generation, que nos permite generar un
texto basado en un mensaje específico, un documento de entrada y el modelo seleccionado:
def chatgpt_generation(prompt, document, model="gpt3.5turbo0125"): """Generar una salida basada

en un
mensaje y una entrada
documento."""
mensajes=[ {
"role": "system", "content":

"Eres un asistente útil. "
{
"rol": "usuario",
"contenido": prompt.replace("[DOCUMENTO]", documento) }
] chat_completion = cliente.chat.completions.create(
mensajes=mensajes,
modelo=modelo,
temperatura=0
) devuelve chat_completion.choices[0].message.content
A continuación, necesitaremos crear una plantilla para solicitarle al modelo que realice
la clasificación:
# Definir una plantilla de aviso como aviso base = """Predecir

si el siguiente documento es una reseña positiva o negativa de una película:
[DOCUMENTO]
Si es positivo devuelve 1 y si es negativo devuelve 0. No dé ninguna otra respuesta.
"""
# Predecir el objetivo usando GPT document = "sin

pretensiones, encantador, peculiar, original" chatgpt_generation(prompt, document)
Esta plantilla es sólo un ejemplo y puede modificarse como desees.

Por ahora lo hemos mantenido lo más simple posible para ilustrar cómo utilizar dicha
plantilla.
Antes de utilizar esta función en un conjunto de datos potencialmente grande, es importante que
lleves un registro de tu uso. Las API externas, como la que ofrece OpenAI, pueden volverse
costosas rápidamente si realizas muchas solicitudes. Al momento de escribir este artículo, ejecutar
nuestro conjunto de datos de prueba utilizando el modelo “gpt3.5turbo0125” cuesta 3 centavos,
que están cubiertos por la cuenta gratuita, pero esto podría cambiar en el futuro.
CONSEJO
Al trabajar con API externas, es posible que se produzcan errores de límite de velocidad. Estos aparecen
cuando se llama a la API con demasiada frecuencia, ya que algunas API pueden limitar la velocidad con la
que se puede usar por minuto u hora.
Para evitar estos errores, podemos implementar varios métodos para volver a intentar la solicitud,
incluido algo conocido como retroceso exponencial. Realiza una suspensión breve cada vez que
alcanzamos un error de límite de velocidad y luego vuelve a intentar la solicitud fallida. Cada vez que no
tiene éxito nuevamente, la duración de la suspensión se incrementa hasta que la solicitud se realiza
correctamente o alcanzamos un número máximo de reintentos.
Para usarlo con OpenAI, hay una excelente guía que puede ayudarle a empezar.
A continuación, podemos ejecutar esto para todas las revisiones en el conjunto de datos de prueba para obtener sus predicciones.
Puedes omitir este paso si deseas guardar tus créditos (gratuitos) para otras tareas.
# Puedes omitir esto si deseas guardar tus créditos (gratuitos) predictions =

[ chatgpt_generation(prompt,
doc) for doc in tqdm(data["test"] ["text"]) ]
Al igual que en el ejemplo anterior, necesitamos convertir la salida de cadenas a números

enteros para evaluar su rendimiento:
# Extraer predicciones y_pred =

[int(pred) para pred en predicciones]
# Evaluar el desempeño


macro 0,92 0,91 0,91 1066
La puntuación F1 de 0,91 ya da una idea del rendimiento del

modelo que llevó la IA generativa a las masas. Sin embargo, dado que no
Sabemos con qué datos se entrenó el modelo, no podemos usar fácilmente este tipo de datos.
de métricas para evaluar el modelo. Por lo que sabemos, podría haber sido así.
¡Hemos sido entrenados en nuestro conjunto de datos!
En el Capítulo 12, exploraremos cómo podemos evaluar tanto el código abierto como
modelos de código cerrado en tareas más generalizadas.
Resumen
En este capítulo, analizamos muchas técnicas diferentes para realizar una
Amplia variedad de tareas de clasificación, desde ajustar todo el modelo hasta
¡No hay ningún ajuste! La clasificación de datos textuales no es tan sencilla como parece.
Parece que en la superficie hay una increíble cantidad de técnicas creativas.
por hacerlo.
En este capítulo, exploramos la clasificación de texto utilizando tanto la clasificación generativa como la clasificación de texto.
modelos de lenguaje de representación. Nuestro objetivo era asignar una etiqueta o clase a
Texto de entrada para la clasificación del sentimiento de una reseña.
Exploramos dos tipos de modelos de representación, un modelo específico de tarea y

un modelo de incrustación. El modelo específico de la tarea se entrenó previamente en un gran
conjunto de datos específicamente para el análisis de sentimientos y nos mostró que los preentrenados
Los modelos son una excelente técnica para clasificar documentos. La incrustación
Se utilizó el modelo para generar incrustaciones multipropósito que usamos como

Entrada para entrenar un clasificador.
De manera similar, exploramos dos tipos de modelos generativos, uno de código abierto
modelo codificadordecodificador (FlanT5) y un modelo de código cerrado que solo incluye decodificador
(GPT3.5). Usamos estos modelos generativos en la clasificación de texto sin
requiriendo entrenamiento específico (adicional) sobre datos de dominio o conjuntos de datos etiquetados.
En el próximo capítulo continuaremos con la clasificación pero nos centraremos en

Clasificación no supervisada. ¿Qué podemos hacer si tenemos datos textuales sin
¿Alguna etiqueta? ¿Qué información podemos extraer? Nos centraremos en la agrupación

nuestros datos, así como la denominación de los clústeres con técnicas de modelado de temas.
1
Bo Pang y Lillian Lee. “Ver estrellas: explotar las relaciones de clase para generar sentimientos”
categorización con respecto a escalas de calificación”. arXiv preprint cs/0506075 (2005).
2
Yinhan Liuet et al. “RoBERTa: un enfoque de preentrenamiento BERT optimizado de manera sólida”. arXiv
3
Victor Sanh et al. “DistilBERT, una versión destilada de BERT: más pequeña, más rápida, más barata y
más ligero.” preimpresión arXiv arXiv:1910.01108 (2019).
4
Zhenzhong Lan et al. “ALBERT: un BERT ligero para el aprendizaje autosupervisado del lenguaje”
representaciones.” preimpresión arXiv arXiv:1909.11942 (2019).
5
Pengcheng He et al. “DeBERTa: BERT mejorado con decodificación y atención desenredada”.
6
7
Colin Raffel et al. “Explorando los límites del aprendizaje por transferencia con un sistema unificado de texto a texto”
transformador.” The Journal of Machine Learning Research 21.1 (2020): 5485–5551.
8
Hyung Won Chung et al. “Escalado de modelos de lenguaje ajustados a la instrucción”. Preimpresión de arXiv
arXiv:2210.11416 (2022).
OceanofPDF.com
Capítulo 5. Agrupamiento de textos y

modelado de temas
Si bien las técnicas supervisadas, como la clasificación, han reinado supremas en la

industria durante los últimos años, no se puede subestimar el potencial de las
técnicas no supervisadas, como la agrupación de texto.
La agrupación de textos tiene como objetivo agrupar textos similares en función de su

contenido semántico, significado y relaciones. Como se ilustra en la Figura 51, los
grupos resultantes de documentos semánticamente similares no solo facilitan la
categorización eficiente de grandes volúmenes de texto no estructurado, sino que también
permiten un rápido análisis exploratorio de datos.
Figura 51. Agrupamiento de datos textuales no estructurados.
La reciente evolución de los modelos lingüísticos, que permiten representaciones

contextuales y semánticas del texto, ha mejorado la eficacia de la agrupación de textos.
El lenguaje es más que un conjunto de palabras, y los modelos lingüísticos recientes
han demostrado ser muy capaces de captar esa noción. Texto
La agrupación, sin estar limitada por la supervisión, permite soluciones creativas y

diversas aplicaciones, como encontrar valores atípicos, acelerar el etiquetado y encontrar datos
etiquetados incorrectamente.
La agrupación de textos también se ha utilizado en el ámbito del modelado de temas, donde

queremos descubrir temas (abstractos) que aparecen en grandes colecciones de datos
textuales. Como se muestra en la Figura 52, generalmente describimos un tema utilizando
palabras clave o frases clave e idealmente, tenemos una única etiqueta general.
Figura 52. El modelado de temas es una forma de dar significado a grupos de documentos textuales.
En este capítulo, primero exploraremos cómo realizar agrupamiento con modelos de

incrustación y luego pasaremos a un método de modelado de temas inspirado en agrupamiento
de texto, denominado BERTopic.
La agrupación de textos y el modelado de temas tienen un papel importante en este libro, ya

que exploran formas creativas de combinar una variedad de modelos de lenguaje
diferentes. Exploraremos cómo la combinación de métodos que solo utilizan codificadores
(incrustaciones), decodificadores (generativos) e incluso métodos clásicos (bolsas de palabras)
puede dar como resultado técnicas y procesos nuevos y sorprendentes.
Artículos de ArXiv: Computación y lenguaje

A lo largo de este capítulo, ejecutaremos algoritmos de agrupamiento y modelado de temas en
artículos de ArXiv. ArXiv es una plataforma de acceso abierto para artículos
académicos, principalmente en los campos de la informática, las matemáticas,
y física. Exploraremos artículos en el campo de la Computación y el Lenguaje para

mantenernos en sintonía con el tema de este libro. El conjunto de datos Contiene 44.949
resúmenes entre 1991 y 2024 de cs.CL de ArXiv Sección (Computación y Lenguaje).
Cargamos los datos y creamos variables separadas para los resúmenes, títulos y años de
cada artículo:
# Cargar datos de Hugging Face desde conjuntos

de datos import load_dataset dataset =
load_dataset("maartengr/arxiv_nlp")["train"]
# Extraer metadatos abstracts

= dataset["Abstracts"] title = dataset["Titles"]
Una línea común para la agrupación de texto

La agrupación de textos permite descubrir patrones en datos con los que puede estar
familiarizado o no. Permite obtener una comprensión intuitiva de la tarea, por ejemplo, una
tarea de clasificación, pero también de su complejidad. Como resultado, la agrupación de
textos puede convertirse en algo más que un método rápido para el análisis exploratorio
de datos.
Si bien existen muchos métodos para agrupar texto, desde redes neuronales basadas en
gráficos hasta técnicas de agrupamiento basadas en centroides, un proceso común que ha
ganado popularidad implica tres pasos y algoritmos:
1. Convierta los documentos de entrada en incrustaciones con una incrustación

modelo.
2. Reducir la dimensionalidad de las incrustaciones con una dimensionalidad

modelo de reducción.
3. Encuentra grupos de documentos semánticamente similares con un cluster

modelo.
Incorporación de documentos
El primer paso es convertir nuestros datos textuales en incrustaciones, como se ilustra en la Figura 53.
Recuerde que en los capítulos anteriores las incrustaciones son representaciones numéricas del texto que
intentan capturar su significado.
Figura 53. Paso 1: Convertimos documentos en incrustaciones utilizando un modelo de incrustación.
La elección de modelos de incrustación optimizados para tareas de similitud semántica es especialmente
importante para la agrupación, ya que intentamos encontrar grupos de documentos
semánticamente similares. Afortunadamente, la mayoría de los modelos de incrustación en el momento de
escribir este artículo se centran precisamente en eso, la similitud semántica.
Como hicimos en el capítulo anterior, utilizaremos la tabla de clasificación de MTEB Para seleccionar un
modelo de incrustación, necesitaremos un modelo de incrustación que tenga una puntuación aceptable en
las tareas de agrupamiento, pero que también sea lo suficientemente pequeño para ejecutarse rápidamente.
En lugar de utilizar el modelo “transformadores de oraciones/allmpnetbasev2” que usamos en el capítulo
anterior, usamos el modelo “thenlper/gtesmall”. modelo en su lugar.
Es un modelo más reciente que supera al modelo anterior en tareas de agrupamiento y, debido a su pequeño
tamaño, es incluso más rápido para la inferencia. Sin embargo, ¡siéntete libre de experimentar con los
modelos más nuevos que se han lanzado desde entonces!
# Crea una incrustación para cada resumen

embedding_model = SentenceTransformer("thenlper/gtesmall") embeddings =
embedding_model.encode(abstracts, show_progress_bar=True)
Veamos cuántos valores contiene cada incrustación de documento:
# Verificar las dimensiones de las incrustaciones resultantes

embeddings.shape
(44949, 384)
Cada incrustación tiene 384 valores que juntos representan la representación

semántica del documento. Puedes ver estas incrustaciones como las características
que queremos agrupar.
Reducción de la dimensionalidad de las incrustaciones

Antes de agrupar las incrustaciones, primero debemos tener en cuenta su alta
dimensionalidad. A medida que aumenta el número de dimensiones, se produce un
crecimiento exponencial en el número de valores posibles dentro de cada dimensión.
Encontrar todos los subespacios dentro de cada dimensión se vuelve cada vez
más complejo.
Como resultado, los datos de alta dimensión pueden resultar problemáticos para muchas
técnicas de agrupamiento, ya que resulta más difícil identificar grupos significativos. En su
lugar, podemos hacer uso de la reducción de dimensionalidad. Como se ilustra en la Figura
54, esta técnica nos permite reducir el tamaño del espacio dimensional y representar
los mismos datos con menos dimensiones. Las técnicas de reducción de dimensionalidad
tienen como objetivo preservar la estructura global de los datos de alta dimensión mediante
la búsqueda de representaciones de baja dimensión.
Figura 54. La reducción de dimensionalidad permite que los datos en un espacio de alta dimensión se compriman a
una representación de menor dimensión.
Tenga en cuenta que se trata de una técnica de compresión y que el algoritmo subyacente
no elimina dimensiones de manera arbitraria. Para ayudar al modelo de clúster a crear
clústeres significativos, el segundo paso en nuestro proceso de agrupamiento es la
reducción de la dimensionalidad, como se muestra en la Figura 55.
Figura 55. Paso 2: Las incrustaciones se reducen a un espacio de menor dimensión mediante la reducción de
dimensionalidad.
Los métodos conocidos para la reducción de dimensionalidad son el análisis de componentes principales
(PCA)1 y la aproximación y proyección de variedad uniforme (UMAP).2 Para esta secuencia,
utilizaremos UMAP, ya que tiende a manejar las relaciones y estructuras no lineales un poco mejor
que el PCA.
NOTA
Sin embargo, las técnicas de reducción de dimensionalidad no son perfectas. No capturan
perfectamente datos de alta dimensión en una representación de menor dimensión. Con este
procedimiento siempre se perderá información. Existe un equilibrio entre reducir la dimensionalidad
y conservar la mayor cantidad de información posible.
Para realizar la reducción de dimensionalidad, necesitamos instanciar nuestra clase UMAP y

pasarle las incrustaciones generadas:
desde umap importar UMAP
# Reducimos las incrustaciones de entrada de 384 dimensiones a 5 dimensiones umap_model =
UMAP( n_components=5,
min_dist=0.0, metric='cosine', random_state=42 ) reduction_embeddings =
umap_model.fit_transform(embeddings)
Podemos utilizar el parámetro n_components para decidir la forma del espacio de menor
dimensión, es decir, 5 dimensiones. En general, los valores entre 5 y 10 funcionan bien para capturar
estructuras globales de alta dimensión.
El parámetro min_dist es la distancia mínima entre los puntos incrustados. Lo configuramos en 0,

ya que generalmente da como resultado grupos más compactos.
Establecemos la métrica en 'coseno' ya que los métodos basados en Euclides tienen problemas
Manejo de datos de alta dimensión.
Tenga en cuenta que configurar un random_state en UMAP hará que los resultados sean
reproducibles en todas las sesiones, pero deshabilitará el paralelismo y, por lo tanto, ralentizará el proceso.
Entrenamiento descendente.
Agrupar las incrustaciones reducidas

El tercer paso es agrupar las incrustaciones reducidas, como se ilustra en la Figura 56.
Figura 56. Paso 3: Agrupamos los documentos utilizando las incrustaciones con dimensionalidad reducida.
Aunque una opción común es un algoritmo basado en centroides como kmeans, que requiere
que se genere un conjunto de clústeres, no sabemos la cantidad de clústeres de antemano. En
cambio, un algoritmo basado en densidad calcula libremente la cantidad de clústeres y no obliga a
que todos los puntos de datos formen parte de un clúster, como se ilustra en la Figura 57.
Figura 57. El algoritmo de agrupamiento no solo afecta la forma en que se generan los clústeres, sino también la forma en
que se visualizan.
Un modelo común basado en la densidad es el agrupamiento espacial basado en la

densidad jerárquica de aplicaciones con ruido (HDBSCAN).3 HDBSCAN es una
variación jerárquica de un algoritmo de agrupamiento denominado DBSCAN que permite
encontrar (micro)agrupaciones densas sin tener que especificar explícitamente el número
de agrupaciones.4 Como método basado en la densidad, HDBSCAN también puede
detectar valores atípicos en los datos, que son puntos de datos que no pertenecen a
ninguna agrupación. Estos valores atípicos no se asignarán ni se forzará su
pertenencia a ninguna agrupación. En otras palabras, se ignorarán. Dado que los artículos de
ArXiv pueden contener algunos artículos especializados, podría resultar útil utilizar un modelo que detecte valo
Al igual que con los paquetes anteriores, el uso de HDBSCAN es sencillo. Solo
necesitamos crear una instancia del modelo y pasarle nuestras incrustaciones reducidas:
desde hdbscan importar HDBSCAN
# Ajustamos el modelo y extraemos los clústeres hdbscan_model =

HDBSCAN( min_cluster_size=50,
metric="euclidean", cluster_selection_method="eom" ).fit(reduced_embeddings)
clústeres = hdbscan_model.labels_
# ¿Cuántos clústeres generamos? len(set(clusters))
156
Con HDBSCAN, generamos 156 clústeres en nuestro conjunto de datos. Para

crear más clústeres, necesitaremos reducir el valor de min_cluster_size, ya que
representa el tamaño mínimo que puede tener un clúster.
Inspección de los clústeres

Ahora que hemos generado nuestros clústeres, podemos inspeccionar cada
uno de ellos manualmente y explorar los documentos asignados para comprender
su contenido. Por ejemplo, tomemos algunos documentos aleatorios del clúster 0:
# Imprimir los primeros tres documentos del clúster 0 clúster = 0
para el índice en np.where(clusters==cluster)[0][:3]: print(abstracts[index][:300] +

"... \n")
Este trabajo tiene como objetivo diseñar una traducción automática estadística de texto en inglés a
lenguaje de señas americano
(ASL). El sistema se basa en la herramienta Moses con algunas modificaciones y los resultados se
sintetizan a través de
un avatar 3D para su interpretación. En primer lugar, traducimos el texto de entrada a glosa, un
formato escrito...
Las investigaciones sobre lenguas de signos aún disocian fuertemente las cuestiones lingüísticas
relacionadas con los
aspectos fonológicos y fonéticos y los estudios de gestos con fines de reconocimiento y síntesis.
Este artículo se
centra en la imbricación del movimiento y el significado para el análisis, la síntesis y la evaluación de las
lenguas de signos...
Los programas informáticos de traducción de lenguaje de señas modernos no pueden reproducir

aspectos importantes de la
traducción de lenguaje de señas. A partir de algunas investigaciones, deducimos que la mayoría de los
sistemas de traducción
automática de lenguaje de señas ignoran muchos aspectos cuando generan animaciones, por lo que la
interpretación
pierde la veracidad de la información.
De estos documentos se desprende que este grupo contiene principalmente documentos

sobre traducción desde y hacia el lenguaje de señas, ¡interesante!
Podemos llevar esto un paso más allá e intentar visualizar nuestros resultados en lugar
de revisar todos los documentos manualmente. Para ello, necesitaremos reducir las
incrustaciones de nuestros documentos a dos dimensiones, ya que eso nos permite
trazar los documentos en un plano x/y:
importar pandas como pd
# Reduce las incrustaciones de 384 dimensiones a dos dimensiones para una visualización más sencilla.
reduction_embeddings
= UMAP( n_components=2, min_dist=0.0,
metric="cosine", random_state=42 ).fit_transform(embeddings)
# Crear marco de datos df =

pd.DataFrame(reduced_embeddings, columnas=["x", "y"]) df["title"] = títulos df["cluster"] = [str(c)
para c en clústeres]
# Seleccionar valores atípicos y no atípicos (clústeres) to_plot = df.loc[df.cluster !

= "1", :] outliers = df.loc[df.cluster == "1", :]
También creamos un marco de datos para nuestros clústeres (clusters_df) y para los
valores atípicos (outliers_df) por separado, ya que generalmente queremos centrarnos
en los clústeres y resaltarlos.
NOTA
El uso de cualquier técnica de reducción de dimensionalidad con fines de visualización
genera pérdida de información. Es simplemente una aproximación de cómo se ven nuestras
incrustaciones originales. Si bien es informativo, puede agrupar los clústeres y separarlos más de
lo que realmente están. ¡La evaluación humana, inspeccionando los clústeres nosotros mismos,
es por lo tanto un componente clave del análisis de clústeres!
Para generar un gráfico estático, utilizaremos la conocida biblioteca de gráficos,

matplotlib:
importar matplotlib.pyplot como plt
# Graficar valores atípicos y no atípicos por separado

plt.scatter(outliers_df.x, outliers_df.y, alpha=0.05, s=2, c="grey") plt.scatter( clusters_df.x,
clusters_df.y,
c=clusters_df.cluster.astype(int), alpha=0.6, s=2,

cmap="tab20b"
) plt.axis("desactivado")
Como podemos ver en la Figura 58, tiende a capturar bastante bien los principales grupos.
Observe cómo los grupos de puntos están coloreados del mismo color, lo que indica que
HDBSCAN los colocó en un grupo. Dado que tenemos una gran cantidad de grupos, la
biblioteca de gráficos alterna los colores entre los grupos, por lo que no piense que todos
los puntos verdes son un grupo, por ejemplo.
Figura 58. Los clústeres generados (en color) y los valores atípicos (en gris) se representan como una
visualización 2D.
Esto es visualmente atractivo, pero aún no nos permite ver lo que sucede dentro
de los clústeres. En cambio, podemos ampliar esta visualización pasando de la agrupación
de texto al modelado de temas.
De la agrupación de textos al modelado de temas

La agrupación de textos es una herramienta poderosa para encontrar la estructura
entre grandes colecciones de documentos. En nuestro ejemplo anterior, podríamos
inspeccionar manualmente cada grupo e identificarlos en función de su colección
de documentos. Por ejemplo, exploramos un grupo que contenía documentos sobre
lenguaje de señas. Podríamos decir que el tema de ese grupo es “lenguaje de señas”.
Esta idea de encontrar temas o tópicos latentes en una colección de datos textuales se
conoce a menudo como modelado de tópicos. Tradicionalmente, implica encontrar un conjunto de
palabras clave o frases que mejor representen y capturen el significado del tema, como
ilustramos en la Figura 59.
Figura 59. Tradicionalmente, los temas se representan mediante una serie de palabras clave, pero pueden adoptar otras formas.
En lugar de etiquetar un tema como “lenguaje de señas”, estas técnicas utilizan

palabras clave como “lenguaje de señas”, “lenguaje” y “traducción” para describir el
tema. De esta manera, no se le asigna una etiqueta única a un tema, sino que se
requiere que el usuario comprenda el significado del tema a través de esas palabras
clave.
Los enfoques clásicos, como la asignación latente de Dirichlet, suponen que cada tema se
caracteriza por una distribución de probabilidad de palabras en el vocabulario de un
5
corpus, que La figura 510 demuestra cómo se escribe cada palabra en un vocabulario.
se califica en función de su relevancia para cada tema.
Figura 510. Las palabras clave se extraen en función de su distribución en un único tema.
Estos enfoques generalmente utilizan una técnica de bolsa de palabras para las
características principales de los datos textuales, que no tiene en cuenta ni el contexto ni el
significado de las palabras y frases. Por el contrario, nuestro ejemplo de agrupamiento de
texto sí tiene en cuenta ambos, ya que se basa en incrustaciones basadas en Transformer
que están optimizadas para la similitud semántica y el significado contextual a través de la
atención.
En esta sección, ampliaremos la agrupación de texto al ámbito del modelado de

temas a través de un marco de modelado de temas y agrupación de texto altamente
modular, denominado BERTopic.
BERTopic: un marco de modelado de temas modular

BERTopic es una técnica de modelado de temas que aprovecha grupos de textos
semánticamente similares para extraer varios tipos de representaciones de temas.6 El
algoritmo subyacente puede considerarse en dos pasos.
En primer lugar, como se ilustra en la Figura 511, seguimos el mismo procedimiento que
usamos antes en nuestro ejemplo de agrupamiento de texto. Incorporamos documentos,
reducimos su dimensionalidad y, por último, agrupamos la incorporación reducida para crear
grupos de documentos semánticamente similares.
Figura 511. La primera parte del proceso de BERTopic consiste en crear grupos de documentos semánticamente
similares.
En segundo lugar, modela una distribución de las palabras del vocabulario del
corpus aprovechando un método clásico, el bagofwords. El bagofwords, como
analizamos brevemente en el Capítulo 1 e ilustramos en la Figura 512, hace
exactamente lo que su nombre implica: contar la cantidad de veces que aparece cada
palabra en un documento. La representación resultante se podría utilizar para
extraer las palabras más frecuentes dentro de un documento.
Figura 512. Una bolsa de palabras cuenta la cantidad de veces que aparece cada palabra dentro de un documento.
Sin embargo, hay dos salvedades. En primer lugar, se trata de una representación
a nivel de documento y nos interesa una perspectiva a nivel de clúster. Para
solucionar esto, la frecuencia de las palabras se calcula dentro de todo el clúster en lugar
de solo en el documento, como se ilustra en la Figura 513.
Figura 513. Generación de cTF contando la frecuencia de palabras por grupo en lugar de por documento.
En segundo lugar, las palabras vacías como “the” y “I” tienden a aparecer a menudo en
los documentos y aportan poco significado a los documentos en sí. BERTopic utiliza una
variante basada en clases de frecuencia de términosfrecuencia inversa de documentos (c
TFIDF) para dar más peso a las palabras que son más significativas para un grupo y dar
menos peso a las palabras que se utilizan en todos los grupos.
Cada palabra del conjunto de palabras, cTF en cTFIDF, se multiplica por el valor IDF
de cada palabra. Como se muestra en la Figura 514, el valor IDF se calcula
tomando el logaritmo de la frecuencia promedio de todas las palabras en todos los
grupos dividido por la frecuencia total de cada palabra.
Figura 514. Creación de un esquema de ponderación.
El resultado es un peso (“IDF”) para cada palabra que podemos multiplicar por su
frecuencia (“cTF”) para obtener los valores ponderados (“cTFIDF”).
Esta segunda parte del procedimiento, como se muestra en la Figura 515,

permite generar una distribución de palabras como hemos visto antes. Podemos
utilizar el CountVectorizer de scikitlearn para generar la representación de la bolsa
de palabras (o frecuencia de términos). Aquí, cada grupo se considera un tema que
tiene una clasificación específica del vocabulario del corpus.
Figura 515. La segunda parte del pipeline de BERTopic representa los temas: el cálculo del peso del término *x* en una
clase *c*.
La combinación de los dos pasos, la agrupación y la representación de los temas, da como

resultado el flujo de trabajo completo de BERTopic, como se ilustra en la Figura 516.
Con este flujo de trabajo, podemos agrupar documentos semánticamente similares y,
a partir de los grupos, generar temas representados por varias palabras clave. Cuanto
mayor sea el peso de una palabra en un tema, más representativa será de ese tema.
Figura 516. El proceso completo de BERTopic consta, en líneas generales, de dos pasos: agrupamiento y
representación de temas.
Una ventaja importante de este proceso es que los dos pasos, la agrupación y la representación
de temas, son en gran medida independientes entre sí. Por ejemplo, con cTFIDF, no
dependemos de los modelos utilizados para agrupar los documentos. Esto permite
una modularidad significativa en todos los componentes del proceso. Y, como
exploraremos más adelante en este capítulo, es un excelente punto de partida para ajustar
las representaciones de temas.
Como se ilustra en la Figura 517, aunque se utilizan los transformadores de oraciones como
modelo de incrustación predeterminado, podemos intercambiarlos por cualquier otra
técnica de incrustación. Lo mismo se aplica a todos los demás pasos. Si no desea que se
generen valores atípicos con HDBSCAN, puede utilizar kmeans en su lugar.
Figura 517. La modularidad de BERTopic es un componente clave que le permite crear su propio modelo de
temas de la forma que desee.
Puedes pensar en esta modularidad como si estuviéramos construyendo con bloques Lego; cada
parte de la cadena de montaje es completamente reemplazable por otro algoritmo similar.
Gracias a esta modularidad, los modelos recién lanzados se pueden integrar en su arquitectura.
A medida que crece el campo de la IA lingüística, también crece BERTopic.
LA MODULARIDAD DE BERTOPIC
La modularidad de BERTopic tiene otra ventaja: permite utilizarlo y adaptarlo a

distintos casos de uso utilizando el mismo modelo base. Por ejemplo, BERTopic admite
una amplia variedad de variantes algorítmicas:
Modelado de temas guiados
Modelado de temas (semi)supervisado
Modelado jerárquico de temas
Modelado dinámico de temas
Modelado de temas multimodales
Modelado de temas de múltiples aspectos
Modelado de temas en línea e incremental
Modelado de temas de disparo cero
Etc.
La modularidad y la flexibilidad algorítmica son la base del objetivo del autor de

hacer de BERTopic la solución única para el modelado de temas.
Puede encontrar una descripción completa de sus capacidades en la documentación. o
el repositorio.
Para ejecutar BERTopic con nuestro conjunto de datos ArXiv, podemos utilizar
nuestros modelos e incrustaciones previamente definidos (aunque no es obligatorio):
de bertopic importar BERTopic
# Entrena nuestro modelo con nuestros modelos previamente definidos

topic_model =
BERTopic( embedding_model=embedding_model,
umap_model=umap_model,
hdbscan_model=hdbscan_model,
verbose=True ).fit(resúmenes, incrustaciones)
Comencemos explorando los temas que se crearon. El

método get_topic_info() es útil para obtener una descripción rápida de los
temas que encontramos:
tema_modelo.obtener_información_del_tema()
Tema Contar Nombre
1 14520 1_el_de_y_a
0 2290 0_reconocimiento_de_voz_asr_fin
1 1403 1_pat_biomédico_clínico_médico
2 1156 2_revisión_del_análisis_del_aspecto_de_sentimiento
3 986 3_traducción_nmt_máquina_neuronal
... ... ...
150 54 150_coherencia_discurso_párrafo
151 54 151_optimización de avisos_de_avisos

Tema Contar Nombre
152 53 152_oraciones_sts_incrustaciones_sim
153 53 153_asesoramiento_en_salud_mental_la
154 50 154_ataques_de_puerta_trasera_ataque_activador
Cada uno de estos temas está representado por varias palabras clave, que son
concatenado con un “_” en la columna Nombre. Esta columna Nombre nos permite
para tener una idea rápida de lo que trata el tema, ya que muestra los cuatro
Palabras clave que mejor lo representan.
NOTA
También habrás notado que el primer tema está etiquetado como 1. Ese tema contiene todos los
documentos que no pudieron encajar en un tema y se consideran atípicos. Se trata de un
resultado del algoritmo de agrupamiento, HDBSCAN, que no obliga a que todos los puntos sean
agrupados. Para eliminar los valores atípicos, podríamos utilizar un algoritmo que no detecte valores atípicos, como kmeans.
o utilice la función reduce_outliers() de BERTopic para reasignar los valores atípicos a los temas.
Podemos inspeccionar temas individuales y explorar qué palabras clave representan mejor
con la función get_topic. Por ejemplo, el tema 0 contiene el
siguientes palabras clave:
tema_modelo.get_topic(0)
[('discurso', 0,028177697715245358), ('asr',

0,018971184497453525),
('reconocimiento', 0,013457745472471012), ('fin',
0,00980445092749381), ('acústico',
0,009452082794507863), ('altavoz',
0,0068822647060204885), ('audio',
0,006807649923681604), ('el',
0,0063343444687017645), ('error',
0,006320144717019838), ('automático',
0,006290216996043161)]
Por ejemplo, el tema 0 contiene las palabras clave “voz”, “asr” y “reconocimiento”.
Según estas palabras clave, parece que el tema trata sobre el reconocimiento automático
de voz (ASR).
Podemos utilizar la función find_topics() para buscar temas específicos en función de un

término de búsqueda. Busquemos un tema sobre modelado de temas:
topic_model.find_topics(" modelado de temas")
([22, 1, 1, 47, 32],

[0,95456535, 0,91173744, 0,9074769, 0,9067007, 0,90510106])
Esto indica que el tema 22 tiene una similitud relativamente alta (0,95) con nuestro término
de búsqueda. Si luego examinamos el tema, podemos ver que, en efecto, se trata de un tema
sobre modelado de temas:
tema_modelo.get_topic(22)
[('tema', 0,06634619076655907), ('temas',

0,035308535091932707), ('lda',
0,016386314730705634), ('latente',
0,013372311924864435), ('documento',
0,012973600191120576),
('documentos', 0,012383715497143821), ('modelado',

0,011978375291037142), ('dirichlet',
0,010078277589545706), ('palabra',
0,008505619415413312), ('asignación',
0,007930890698168108)]
Aunque sabemos que este tema trata sobre modelado de temas, veamos si
El resumen de BERTopic también está asignado a este tema:
topic_model.topics_[titles.index("BERTopic: Modelado de temas neuronales con un procedimiento

TFIDF basado en clases")]
22
¡Sí lo es! Estas funcionalidades nos permiten encontrar rápidamente los temas que nos
interesan.
CONSEJO
La modularidad de BERTopic le ofrece muchas opciones, lo que puede resultar abrumador.

Para tal fin, el autor creó una guía de mejores prácticas que pasa por prácticas comunes
para agilizar el entrenamiento, mejorar las representaciones y más.
Para facilitar un poco la exploración de los temas, podemos volver a nuestro ejemplo de
agrupación de texto. Allí, creamos una visualización estática para ver la estructura
general del tema creado. Con BERTopic, podemos crear una variante interactiva que nos
permita explorar rápidamente qué temas existen y qué documentos contienen.
Para ello, debemos utilizar las incrustaciones bidimensionales,

reduction_embeddings, que creamos con UMAP. Además, cuando pasemos el cursor sobre
los documentos, mostraremos el título en lugar del resumen para comprender rápidamente los
documentos de un tema:
# Visualizar temas y documentos

fig = topic_model.visualize_documents( títulos,
inclusiones_reducidas=incrustaciones_reducidas,
ancho=1200,
ocultar_anotaciones=True
)
# Actualizar las fuentes de la leyenda para una visualización más sencilla

fig.update_layout(font=dict(size=16))
Como podemos ver en la Figura 518, este gráfico interactivo nos da una idea rápida
de los temas creados. Puede hacer zoom para ver documentos individuales o
hacer doble clic en un tema del lado derecho para verlo únicamente.
Figura 518. El resultado cuando visualizamos documentos y temas.
En BERTopic hay una amplia gama de opciones de visualización. Hay tres que vale la
pena explorar para tener una idea de las relaciones entre los temas:
# Visualizar gráfico de barras con palabras clave clasificadas

tema_modelo.visualizar_gráfico_de_barras()
# Visualizar relaciones entre temas

topic_model.visualize_heatmap(n_clusters=30)
# Visualizar la estructura jerárquica potencial de los temas

topic_model.visualize_hierarchy()
Cómo añadir un bloque Lego especial

El pipeline en BERTopic que hemos explorado hasta ahora, aunque rápido y modular,
tiene una desventaja: todavía representa un tema a través de una bolsa de palabras
sin tener en cuenta las estructuras semánticas.
La solución es aprovechar la fortaleza de la representación de la bolsa de palabras, que es

su velocidad para generar una representación significativa. Podemos usar esta primera
representación significativa y modificarla utilizando técnicas más potentes pero más lentas,
como la incorporación de modelos. Como se muestra en la Figura 519, podemos
reordenar la distribución inicial de palabras para mejorar la representación
resultante. Tenga en cuenta que esta idea de reordenar un conjunto inicial de resultados
es un elemento básico en la búsqueda neuronal, un tema que abordamos en el Capítulo 8.
Figura 519. Ajuste las representaciones de los temas reordenando las distribuciones cTFIDF originales.
Como resultado, podemos diseñar un nuevo bloque Lego, como se muestra en la Figura
520, que toma esta primera representación del tema y genera una
representación mejorada.
En BERTopic, estos modelos de reclasificación se denominan modelos de

representación. Una de las principales ventajas de este enfoque es que la
optimización de las representaciones de temas solo debe realizarse tantas veces
como temas tengamos. Por ejemplo, si tenemos millones de documentos y
cien temas, el bloque de representación solo debe aplicarse una vez para cada
tema en lugar de para cada documento.
Como se muestra en la Figura 521, se ha diseñado una amplia variedad de bloques

de representación para BERTopic que permiten ajustar las representaciones. El
bloque de representación puede incluso apilarse varias veces para ajustar
las representaciones utilizando diferentes metodologías.
Figura 520. El bloque de reranking (representación) se ubica sobre la representación cTFIDF.

Figura 521. Después de aplicar la ponderación cTFIDF, los temas se pueden ajustar con una amplia variedad de modelos
de representación, muchos de los cuales son modelos de lenguaje de gran tamaño.
Antes de explorar cómo podemos usar estos bloques de representación, primero debemos
hacer dos cosas. Primero, vamos a guardar nuestras representaciones de temas
originales para que sea mucho más fácil compararlas con y sin modelos de representación:
# Guardar representaciones originales de

la copia import deepcopy
original_topics = deepcopy(topic_model.topic_representations_)
En segundo lugar, vamos a crear un contenedor corto que podamos usar para visualizar
rápidamente las diferencias en las palabras del tema para comparar con y sin modelos
de representación:
def diferencias_de_temas(modelo, temas_originales, nr_temas=5):

"""Mostrar las diferencias en las representaciones de temas entre dos modelos"""
df = pd.DataFrame(columns=["Tema", "Original", "Actualizado"]) para el tema en el rango (nr_topics):
# Extraer las 5 palabras principales por tema por modelo og_words =

" | ".join(list(zip(*original_topics[topic])) [0][:5]) new_words = [0][:5]) df.loc[len(df)] = [topic,
og_words,
new_words] " | ".join(list(zip(*model.get_topic(tema)))
devolver df
Inspirado en KeyBERT
El primer bloque de representación que vamos a explorar es

KeyBERTInspired. KeyBERTInspired es, como habrás adivinado, un método
7
inspirado en el paquete de extracción de palabras clave KeyBERT. ClaveBERT
extrae palabras clave de textos comparando incrustaciones de palabras
y documentos a través de la similitud de coseno.
BERTopic utiliza un enfoque similar. KeyBERTInspired utiliza cTFIDF para

extraer los documentos más representativos por tema calculando la similitud
entre los valores cTFIDF de un documento y los del tema al que corresponden.
Como se muestra en la Figura 522, se calcula la incrustación promedio de
documentos por tema y se compara con las incrustaciones de palabras clave
candidatas para reclasificar las palabras clave.
Figura 522. Procedimiento del modelo de representación inspirado en KeyBERT.
Debido a la naturaleza modular de BERTopic, podemos actualizar nuestras

representaciones de temas iniciales con KeyBERTInspired sin necesidad de realizar
los pasos de reducción de dimensionalidad y agrupamiento:
Desde bertopic.representation importar KeyBERTInspired
# Actualizar nuestras representaciones de temas usando KeyBERTInspired

representation_model = KeyBERTInspired()
topic_model.update_topics(abstracts,
representation_model=representation_model)
# Mostrar diferencias de temas

topic_differences(topic_model, original_topics)
Tema Original Actualizado
0 habla | asr | habla | codificador |

reconocimiento | fin | fonético | lenguaje |
acústica trans...
1 médico | clínico | pnl | ehr | clínica |

biomédico | paciente | biomédica | lenguaje
él...
2 sentimiento | aspecto aspecto | sentimiento

| análisis | reseñas | | aspectos | sentimientos
opinión | cl...
3 traducción | nmt | traducción | traduciendo |

máquina | neuronal | azul traducir | tradu...
4 resumen | resumen |
resúmenes | resumen | resumidores |
abstracto... resúmenes | suma...
El modelo actualizado muestra que los temas son más fáciles de leer en comparación con
el modelo original. También demuestra la desventaja de utilizar técnicas basadas en
incrustaciones. Las palabras del modelo original, como nmt (tema 3), que significa
traducción automática neuronal, se eliminan porque el modelo no podía representar
adecuadamente la entidad. Para los expertos en el dominio, estas abreviaturas son muy
informativas.
Relevancia marginal máxima
Con cTFIDF y las técnicas KeyBERTInspired mostradas anteriormente, aún tenemos una
redundancia significativa en las representaciones de temas resultantes. Por ejemplo, tener
las palabras “resúmenes” y “resumen” en una representación de tema introduce
redundancia ya que son bastante similares.
Podemos utilizar la relevancia marginal máxima (MMR) para diversificar nuestras

representaciones de temas. El algoritmo intenta encontrar un conjunto de palabras clave
que sean diversas entre sí, pero que aún estén relacionadas con los documentos con los que
se comparan. Lo hace incorporando un conjunto de palabras clave candidatas y
calculando iterativamente la siguiente mejor palabra clave para agregar. Para ello, es
necesario establecer un parámetro de diversidad, que indica cuán diversas deben ser las palabras clave.
En BERTopic, utilizamos MMR para pasar de un conjunto de palabras clave iniciales,

digamos 30, a un conjunto de palabras clave más pequeño pero más diverso, digamos 10.
Filtra las palabras redundantes y solo conserva las palabras que aportan algo nuevo a la
representación del tema.
Hacerlo es bastante sencillo:
de bertopic.representation importa MaximalMarginalRelevance
# Actualizar nuestras representaciones de temas a MaximalMarginalRelevance

representation_model = MaximalMarginalRelevance(diversity=0.2)
topic_model.update_topics(abstracts,

0 habla | asr | reconocimiento | discurso | asr | error |

fin | acústica modelo | entrenamiento
1 médico | clínico | clínico | biomédico |

biomédico | paciente | paciente | atención sanitaria |...
él...
2 sentimiento | aspecto sentimiento | análisis |

| análisis | reseñas | reseñas | absa | polaridad
opinión
3 traducción | nmt | traducción | nmt | azul |

máquina | neuronal | azul paralelo | multilin...
4 resumen | resumen |
resúmenes | resumen | documento | extractivo |
abstracto... rojo...
Los temas resultantes muestran una mayor diversidad en sus representaciones. Por
ejemplo, el tema 4 solo muestra una palabra que parece un “resumen” y, en su lugar,
agrega otras palabras que podrían contribuir más a la representación general.
CONSEJO
Tanto KeyBERTInspired como MMR son técnicas sorprendentes para mejorar el primer conjunto
de representaciones de temas. KeyBERTInspired tiende especialmente a eliminar casi todas
las palabras vacías, ya que se centra en las relaciones semánticas entre palabras y documentos.
El bloque Lego de la generación de texto

El bloque de representación de BERTopic ha actuado como un bloque de reordenación en
nuestros ejemplos anteriores. Sin embargo, como ya hemos explorado en el capítulo
anterior, los modelos generativos tienen un gran potencial para una amplia variedad de tareas.
Podemos utilizar modelos generativos en BERTopic de forma bastante eficiente siguiendo

una parte del procedimiento de reordenación. En lugar de utilizar un modelo generativo
para identificar el tema de todos los documentos, de los cuales potencialmente
puede haber millones, utilizaremos el modelo para generar una etiqueta para
nuestro tema. Como se ilustra en la Figura 523, en lugar de generar o reordenar palabras
clave, le pedimos al modelo que genere una etiqueta corta basada en palabras
clave que se generaron previamente y un pequeño conjunto de documentos representativos.
Figura 523. Utilice LLM generativos de texto e ingeniería de indicaciones para crear etiquetas para temas a partir de
palabras clave y documentos relacionados con cada tema.
El mensaje ilustrado consta de dos componentes. En primer lugar, los documentos que
se insertan mediante la etiqueta [DOCUMENTS] son un pequeño subconjunto de
documentos, normalmente cuatro, que representan mejor el tema. Se seleccionan los
documentos con la mayor similitud de coseno de sus valores cTFIDF con los del
tema. En segundo lugar, las palabras clave que componen un tema también se pasan
al mensaje y se hace referencia a ellas mediante la etiqueta [KEYWORDS].
Las palabras clave podrían generarse mediante cTFIDF o cualquiera de las otras
representaciones que hemos discutido hasta ahora.
Como resultado, solo necesitamos usar el modelo generativo una vez para cada tema, de los cuales
potencialmente podría haber cientos, en lugar de una vez para cada documento, de los cuales
potencialmente podría haber millones. Hay muchos modelos generativos entre los que podemos
elegir, tanto de código abierto como propietarios. Comencemos con un modelo que
hemos explorado en el capítulo anterior, el modelo FlanT5.
Creamos un mensaje que funciona bien con el modelo y lo usamos en BERTopic a través del
parámetro representation_model:
Desde transformers, importe pipeline desde

bertopic.representation , importe TextGeneration
prompt = """Tengo un tema que contiene los siguientes documentos:

[DOCUMENTOS]
El tema se describe mediante las siguientes palabras clave: '[PALABRAS CLAVE]'.
"En base a los documentos y palabras clave, ¿de qué trata este tema?"
# Actualizar nuestras representaciones de temas usando FlanT5

generator = pipeline("text2textgeneration", model="google/flant5small")
representation_model = TextGeneration(
generador, prompt=prompt, doc_length=50,
tokenizer="espacio en
blanco" ) topic_model.update_topics(resúmenes,

0 habla | asr | reconocimiento | De voz a descripción

fin | acústica
1 médico | clínico | Ciencia/Tecnología
biomédico | paciente |
él...
2 sentimiento | aspecto Revisar

| análisis | reseñas |
opinión
3 traducción | nmt | Traducción automática
máquina | neuronal | azul neuronal basada en la atención
4 resumen | Resumen
resúmenes | resumen |
abstracto...
Algunas de estas etiquetas, como “Resumen”, parecen lógicas si se las compara

con las representaciones originales. Sin embargo, otras, como “Ciencia/Tecnología”,
parecen bastante amplias y no le hacen justicia al tema original.
Exploremos en cambio cómo funcionaría GPT3.5 de OpenAI considerando que el
modelo no solo es más grande sino que se espera que tenga más
capacidades lingüísticas:
importar openai
desde bertopic.representación importar OpenAI
"""
aviso =
Tengo un tema que contiene los siguientes documentos:
[DOCUMENTOS]
El tema se describe mediante las siguientes palabras clave: [PALABRAS CLAVE]
Con base en la información anterior, extraiga una etiqueta de tema corta en el

siguiente formato: tema:
<etiqueta de tema corta>
"""
# Actualizar nuestras representaciones de temas usando GPT3.5

client = openai.OpenAI(api_key="YOUR_KEY_HERE")
representation_model = OpenAI(
cliente, modelo="gpt3.5turbo", exponential_backoff=True, chat=True,
prompt=prompt )
tema_modelo.update_topics(resúmenes,
modelo_de_representación=modelo_de_representación)

0 habla | asr | Aprovechamiento de

reconocimiento | fin | datos externos para
acústica mejorar la resolución...
1 médico | clínico | Aprendizaje

biomédico | paciente | de representación mejorado para
él... aplicaciones biomédicas
2 sentimiento | aspecto Avances en el

| análisis | reseñas | análisis de sentimientos
opinión basado en aspectos...
3 traducción | nmt | Máquina neuronal

máquina | neuronal | azul Traducción
Mejoras
4 resumen | Documento
resúmenes | resumen | Resumen
abstracto... Técnicas
Las etiquetas resultantes son bastante impresionantes. Ni siquiera estamos usando

GPT4 y las etiquetas resultantes parecen ser más informativas que nuestro ejemplo anterior.
Tenga en cuenta que BERTopic no se limita únicamente a utilizar la oferta de OpenAI, sino que
también tiene backends locales.
CONSEJO
Aunque parezca que ya no necesitamos las palabras clave, siguen siendo

representativas de los documentos de entrada. Ningún modelo es perfecto y, por lo general, se
recomienda generar múltiples representaciones de temas. BERTopic permite que todos los temas
se representen mediante diferentes representaciones. Por ejemplo, puede utilizar KeyBERTInspired,
MMR y GPT3.5 en paralelo para obtener diferentes perspectivas sobre el mismo tema.
Con estas etiquetas generadas por GPT3.5, podemos crear hermosas

ilustraciones utilizando el paquete datamapplot (Figura 524):
# Visualizar temas y documentos fig =

topic_model.visualize_document_datamap( títulos, temas=lista(rango(20)),
incrustaciones_reducidas=incrustaciones_reducidas,
ancho=1200,
tamaño_de_fuente_de_etiqueta=11,
ancho_de_ajuste_de_etiqueta=20,
use_medoids=True,
)
Figura 524. Los 20 temas principales visualizados.
Resumen
En este capítulo, exploramos cómo se pueden utilizar los métodos de aprendizaje directo, tanto
generativos como representativos, en el ámbito del aprendizaje no supervisado. A pesar de
que los métodos supervisados, como la clasificación, han prevalecido en los últimos años, los
enfoques no supervisados, como la agrupación de textos, tienen un potencial inmenso
debido a su capacidad para agrupar textos en función del contenido semántico sin etiquetado previo.
Hemos cubierto un proceso común para agrupar documentos de texto que comienza con
la conversión del texto de entrada en representaciones numéricas, a las que llamamos
incrustaciones. Luego, se aplica una reducción de dimensionalidad a estas incrustaciones
para simplificar los datos de alta dimensión y obtener mejores resultados de agrupamiento.
Por último, se aplica un algoritmo de agrupamiento en las incrustaciones de
dimensionalidad reducida para agrupar el texto de entrada. La inspección
manual de los grupos nos ayudó a comprender qué documentos contenían y cómo
interpretarlos.
Para dejar de lado esta inspección manual, exploramos cómo BERTopic

extiende este proceso de agrupamiento de texto con un método para
representar automáticamente los grupos. Esta metodología se conoce a menudo como
modelado de temas, que intenta descubrir temas dentro de grandes cantidades
de documentos. BERTopic genera estas representaciones de temas a través de un
enfoque de bolsa de palabras mejorado con cTFIDF, que pondera las palabras en
función de su relevancia y frecuencia en todos los grupos.
Una de las principales ventajas de BERTopic es su naturaleza modular. En BERTopic,

puede elegir cualquier modelo en el flujo de trabajo, lo que permite
representaciones adicionales de temas que crean múltiples perspectivas del mismo tema.
Exploramos la relevancia marginal máxima y KeyBERTInspired como metodologías
para afinar las representaciones de temas generadas con cTFIDF. Además, utilizamos
los mismos LLM generativos que en el capítulo anterior (FlanT5 y GPT3.5) para
mejorar aún más la interpretabilidad de los temas mediante la generación de etiquetas
altamente interpretables.
En el próximo capítulo, cambiamos el enfoque y exploramos un método común

para mejorar el resultado de los modelos generativos, concretamente la ingeniería rápida.
1
Harold Hotelling. “Análisis de un complejo de variables estadísticas en componentes principales”.
Revista de Psicología Educacional 24.6 (1933): 417.
2
Leland McInnes, John Healy y James Melville. “UMAP: aproximación y proyección
de variedades uniformes para reducción de dimensión”. Preimpresión arXiv arXiv:1802.03426
(2018).
3
Leland McInnes, John Healy y Steve Astels. “hdbscan: densidad jerárquica basada
agrupamiento”. J. Software de código abierto. 2.11 (2017): 205.
4
Martin Ester et al. “Un algoritmo basado en la densidad para descubrir cúmulos en grandes áreas espaciales”
bases de datos con ruido”. KDD'96, agosto de 1996: 226–231.
5
David M. Blei, Andrew Y. Ng y Michael I. Jordan. "Asignación latente de Dirichlet". Diario de
Investigación en aprendizaje automático 3 de enero (2003): 993–1022.
6
Maarten Grootendorst. “BERTopic: Modelado de temas neuronales con un TFIDF basado en clases
procedimiento.” preimpresión arXiv arXiv:2203.05794 (2022).
7
Maarten Grootendorst. "KeyBERT: extracción mínima de palabras clave con BERT". (2020).
OceanofPDF.com
Capítulo 6. Ingeniería de avisos
En los primeros capítulos de este libro, dimos nuestros primeros pasos en el mundo de los
grandes modelos lingüísticos (LLM). Profundizamos en diversas aplicaciones, como la
clasificación supervisada y no supervisada, empleando modelos que se centran en la
representación de texto, como BERT y sus derivados.
A medida que avanzamos, utilizamos modelos entrenados principalmente para la

generación de texto, modelos que a menudo se denominan transformadores generativos
preentrenados (GPT). Estos modelos tienen la notable capacidad de generar texto
en respuesta a las indicaciones del usuario. A través de la ingeniería de indicaciones,
podemos diseñar estas indicaciones de una manera que mejore la calidad del texto generado.
texto.
En este capítulo, exploraremos estos modelos generativos con más detalle y nos sumergiremos
en el ámbito de la ingeniería rápida, el razonamiento con modelos generativos, la
verificación e incluso la evaluación de sus resultados.
Uso de modelos de generación de texto

Antes de comenzar con los fundamentos de la ingeniería de mensajes, es esencial explorar
los conceptos básicos de la utilización de un modelo de generación de texto. ¿Cómo
seleccionamos el modelo que vamos a utilizar? ¿Utilizamos un modelo propietario o de código
abierto? ¿Cómo podemos controlar el resultado generado? Estas preguntas nos servirán como
puntos de partida para utilizar modelos de generación de texto.
Elección de un modelo de generación de texto
La elección de un modelo de generación de texto comienza con la elección entre modelos

propietarios o modelos de código abierto. Aunque los modelos propietarios suelen tener un
mejor rendimiento, en este libro nos centraremos más en los modelos de código abierto,
ya que ofrecen más flexibilidad y son de uso gratuito.
La Figura 61 muestra una pequeña selección de modelos de base de gran impacto, LLM
que han sido entrenados previamente en grandes cantidades de datos de texto y a menudo
ajustados para aplicaciones específicas.
Figura 61. Los modelos de base suelen lanzarse en varios tamaños diferentes.
A partir de esos modelos básicos, se han perfeccionado cientos, si no miles, de modelos,

unos más adecuados que otros para determinadas tareas. ¡Elegir el modelo que se va a
utilizar puede ser una tarea abrumadora!
Te recomendamos empezar con un modelo de base pequeño. Así que sigamos usando
Phi3mini, que tiene 3.8 mil millones de parámetros. Esto lo hace adecuado para
ejecutarse con dispositivos de hasta 8 GB de VRAM. En general, ampliar a modelos más
grandes tiende a ser una experiencia más agradable que reducir. Los modelos más
pequeños brindan una excelente introducción y sientan una base sólida para avanzar a
modelos más grandes.
Cargando un modelo de generación de texto
El método más sencillo para cargar un modelo, como lo hemos hecho en capítulos
anteriores, es aprovechar la biblioteca de transformadores:
importar antorcha
desde transformadores importar AutoModelForCausalLM, AutoTokenizer, pipeline

mapa_de_dispositivo="cuda",
tipo_de_d_antorcha="automático",
código_remoto_de_confianza=Verdadero,
# Crear una tubería pipe =

pipeline( "generación
detexto", model=model,
max_new_tokens=500,
do_sample=False,
En comparación con los capítulos anteriores, analizaremos más de cerca el desarrollo

y el uso de la plantilla de indicaciones.
Para ilustrarlo, volvamos al ejemplo del Capítulo 1 donde preguntamos a los

LLM para hacer un chiste sobre los pollos:
# Mensajes
de aviso = [
{"role": "user", "content": "Crea una broma divertida sobre
pollos."} ]
# Generar la salida salida =

pipe(messages) print(output[0]
["generated_text"])
¿Por qué a las gallinas no les gusta ir al gimnasio? ¡Porque no pueden soportar la
resistencia del gimnasio!
En primer lugar, transformers.pipeline convierte nuestros mensajes en una plantilla de

mensaje específica. Podemos explorar este proceso accediendo al tokenizador
subyacente:
# Aplicar plantilla de aviso

prompt = pipe.tokenizer.apply_chat_template(messages, tokenize=False)
print(prompt)
<s><|user|>
Crea un chiste divertido sobre gallinas.<|end|> <|assistant|>
Es posible que reconozca los tokens especiales <|user|> y <|assistant|> del Capítulo 2.
Esta plantilla de mensaje, ilustrada con más detalle en la Figura 62, se utilizó durante el
entrenamiento del modelo. No solo proporciona información sobre quién dijo qué, sino
que también se utiliza para indicar cuándo el modelo debe dejar de generar texto
(consulte el token <|end|>). Este mensaje se pasa directamente al LLM y se
procesa de una sola vez.
En el próximo capítulo, personalizaremos partes de esta plantilla nosotros mismos.

A lo largo de este capítulo, podemos usar transformers.pipeline para manejar el
procesamiento de plantillas de chat por nosotros. A continuación, exploremos cómo
podemos controlar la salida del modelo.
Figura 62. La plantilla que Phi3 espera al interactuar con el modelo.

Control de la salida del modelo

Además de la ingeniería rápida, podemos controlar el tipo de resultado que queremos
ajustando los parámetros del modelo. En nuestro ejemplo anterior, es posible que
hayas notado que usamos varios parámetros en la función de tubería, incluidos
la temperatura y top_p.
Estos parámetros controlan la aleatoriedad del resultado. Una parte de lo que

hace que la tecnología LLM sea tan interesante es que puede generar diferentes
respuestas para exactamente la misma indicación. Cada vez que un LLM necesita
generar un token, asigna un número de probabilidad a cada token posible.
Como se ilustra en la Figura 63, en la oración “Estoy conduciendo un…” la

probabilidad de que esa oración sea seguida por tokens como “auto” o “camión” es
generalmente mayor que la de un token como “elefante”. Sin embargo, todavía
existe la posibilidad de que se genere “elefante”, pero es mucho menor.
Figura 63. El modelo elige el siguiente token a generar en función de sus puntuaciones de probabilidad.
Cuando cargamos nuestro modelo, configuramos deliberadamente do_sample=False

para asegurarnos de que la salida sea algo consistente. Esto significa que no se
realizará ningún muestreo y solo se seleccionará el siguiente token más probable. Sin
embargo, para usar los parámetros temperature y top_p, configuraremos
do_sample=True para poder usarlos.
Temperatura La
temperatura controla la aleatoriedad o creatividad del texto generado. Define la

probabilidad de elegir tokens menos probables.
La idea subyacente es que una temperatura de 0 genera el mismo
respuesta cada vez porque siempre elige la palabra más probable. Como se ilustra en la
Figura 64, un valor más alto permite que se generen palabras menos probables.
Figura 64. Una temperatura más alta aumenta la probabilidad de que se generen tokens
menos probables y viceversa.
Como resultado, una temperatura más alta (por ejemplo, 0,8) generalmente da como resultado
una salida más diversa, mientras que una temperatura más baja (por ejemplo, 0,2) crea una
salida más determinista.
Puede utilizar la temperatura en su tubería de la siguiente manera:
# Usando una salida de alta temperatura

= pipe(messages, do_sample=True, temperature=1) print(output[0]
["generated_text"])
¿Por qué a las gallinas no les gusta subirse a la montaña rusa? ¡Porque tienen miedo
de convertirse de repente en sopa de pollo!
Tenga en cuenta que cada vez que vuelva a ejecutar este fragmento de código, ¡la salida
cambiará! La temperatura introduce un comportamiento estocástico ya que el modelo
ahora selecciona tokens aleatoriamente.
arriba_p
top_p, también conocido como muestreo de núcleo, es una técnica de muestreo que
controla qué subconjunto de tokens (el núcleo) puede considerar el LLM. Considerará tokens
hasta que alcance su probabilidad acumulada. Si establecemos
Si configuramos top_p en 0,1, se considerarán los tokens hasta alcanzar ese valor. Si
configuramos top_p en 1, se considerarán todos los tokens.
Como se muestra en la Figura 65, al reducir el valor, se considerarán menos tokens y, en general,
se obtendrá un resultado menos “creativo”, mientras que al aumentar el valor, el LLM podrá elegir
entre más tokens.
Figura 65. Un top_p más alto aumenta la cantidad de tokens que se pueden seleccionar para generar y viceversa.
viceversa.
De manera similar, el parámetro top_k controla exactamente cuántos tokens puede

considerar el LLM. Si cambia su valor a 100, el LLM solo considerará los 100 tokens más
probables.
Puede utilizar top_p en su canalización de la siguiente manera:
# Usando un top_p alto output =

pipe(messages, do_sample=True, top_p=1) print(output[0]["generated_text"])
¿Por qué las gallinas no son buenos comediantes? ¡Porque sus "chistes" siempre "desmaquillan" la
verdad!
Como se muestra en la Tabla 61, estos parámetros permiten al usuario tener una escala móvil
entre ser creativo (temperatura alta y top_p) y ser predecible (temperatura más baja y top_p).
Tabla 61. Ejemplos de casos de uso al seleccionar valores para la temperatura y

páginas.
Ejemplo de uso
caso Temperatura arriba_p Descripción
Reunión creativa Alto Alto Alta aleatoriedad

sesión con gran piscina de
tokens potenciales. El
Los resultados serán
muy diversa, a menudo

conduciendo a muy
creativo y
Resultados inesperados.
Correo electrónico Bajo Bajo Salida determinista

generación con alta probabilidad
tokens predichos.
Esto da como resultado
predecible, centrado,
y conservador
Salidas.
Creativo Alto Bajo Alta aleatoriedad

escribiendo con una pequeña piscina de
tokens potenciales.
Esta combinación
produce creatividad
salidas pero aún así
permanece coherente.
Traducción Bajo Alto Salida determinista

con alta probabilidad
tokens predichos.
Produce coherente
salida con una más amplia

Ejemplo de uso
caso Temperatura arriba_p Descripción
gama de vocabulario,
dando lugar a resultados
con variedad
lingüística.
Introducción a la ingeniería de avisos

Una parte esencial del trabajo con modelos de aprendizaje profundo que generan texto
es la ingeniería de indicaciones. Si diseñamos cuidadosamente nuestras indicaciones, podemos
guiar al modelo de aprendizaje profundo para que genere las respuestas deseadas. Ya sean
preguntas, afirmaciones o instrucciones, el objetivo principal de la ingeniería de indicaciones
es obtener una respuesta útil del modelo.
La ingeniería de avisos es más que diseñar avisos efectivos. Puede utilizarse como herramienta para
evaluar el resultado de un modelo, así como para diseñar salvaguardas y métodos de mitigación
de la seguridad. Se trata de un proceso iterativo de optimización de avisos y requiere
experimentación. No existe y es poco probable que exista un diseño de aviso perfecto.
En esta sección, repasaremos métodos comunes para la ingeniería de indicaciones

y pequeños consejos y trucos para entender cuál es el efecto de ciertas indicaciones. Estas
habilidades nos permiten comprender las capacidades de los LLM y son la base para
interactuar con este tipo de modelos.
Comenzamos respondiendo a la pregunta: ¿qué debe contener un mensaje?
Los ingredientes básicos de un mensaje

Un LLM es una máquina de predicción. Basándose en una determinada entrada, el mensaje,
intenta predecir las palabras que podrían seguirle. En esencia (ilustrado en la Figura 66), el
mensaje no necesita tener más que unas pocas palabras para obtener una respuesta del LLM.
Figura 66. Ejemplo básico de una instrucción. No se dan instrucciones, por lo que el estudiante de maestría en derecho simplemente
intentará completar la oración.
Sin embargo, aunque la ilustración funciona como un ejemplo básico, no logra

completar una tarea específica. En cambio, generalmente abordamos la
ingeniería de indicaciones planteando una pregunta o tarea específica que el LLM debe completar.
Para obtener la respuesta deseada necesitamos un estímulo más estructurado.
Por ejemplo, y como se muestra en la Figura 67, podríamos pedirle al LLM que clasifique
una oración en función de si tiene un sentimiento positivo o negativo. Esto amplía la
instrucción más básica a una que consta de dos componentes: la instrucción
en sí y los datos relacionados con la instrucción.
Figura 67. Dos componentes de una instrucción básica: la instrucción en sí y los datos a los que hace referencia
a.
Los casos de uso más complejos pueden requerir más componentes en un mensaje.
Por ejemplo, para asegurarnos de que el modelo solo genere “negativo” o “positivo”,
podemos introducir indicadores de salida que ayuden a guiar el modelo. En la Figura
68, anteponemos la oración con “Texto:” y agregamos “Sentimento:” para evitar que
el modelo genere una oración completa. En cambio, esta estructura indica que
esperamos “negativo” o “positivo”. Aunque es posible que el modelo no haya sido
entrenado con estos componentes directamente, se le proporcionaron
suficientes instrucciones para poder generalizar a esta estructura.
Figura 68. Ampliación del mensaje con un indicador de salida que permite una salida específica.
Podemos seguir añadiendo o actualizando los elementos de un mensaje hasta obtener la

respuesta que buscamos. Podríamos añadir ejemplos adicionales, describir el
caso de uso con más detalle, proporcionar contexto adicional, etc. Estos componentes
son meros ejemplos y no un conjunto limitado de posibilidades. La creatividad que
conlleva el diseño de estos componentes es clave.
Aunque una indicación es un fragmento de texto único, resulta de gran ayuda pensar
en las indicaciones como piezas de un rompecabezas más grande. ¿He descrito el
contexto de mi pregunta? ¿La indicación incluye un ejemplo del resultado?
Instrucciones basadas en indicaciones

Aunque las indicaciones se dan de muchas formas, desde hablar de filosofía con el
LLM hasta hacer juegos de rol con tu superhéroe favorito, las indicaciones se utilizan
a menudo para que el LLM responda una pregunta específica o resuelva una tarea
determinada. Esto se conoce como indicaciones basadas en instrucciones.
La figura 69 ilustra varios casos de uso en los que la indicación basada en
instrucciones desempeña un papel importante. Ya hemos utilizado uno de ellos en
el ejemplo anterior, concretamente la clasificación supervisada.
Figura 69. Casos de uso de indicaciones basadas en instrucciones.
Cada una de estas tareas requiere distintos formatos de indicaciones y, más

específicamente, plantear distintas preguntas al LLM. Pedirle al LLM que resuma un
fragmento de texto no dará como resultado de repente una clasificación. Para ilustrar
esto, se pueden encontrar ejemplos de indicaciones para algunos de estos casos de uso
en la Figura 610.
Figura 610. Ejemplos de casos de uso comunes. Observe cómo, dentro de un caso de uso, se puede
cambiar la estructura y la ubicación de la instrucción.
Aunque estas tareas requieren instrucciones diferentes, en realidad hay mucha superposición
en las técnicas de estimulación utilizadas para mejorar la calidad del resultado. Una
lista no exhaustiva de estas técnicas incluye:
Especificidad
Describe con precisión lo que quieres lograr. En lugar de preguntar a los demás,
LLM para “Escribir una descripción de un producto” le pide que “Escriba una
Descripción de un producto en menos de dos oraciones y utilice un tono formal.

tono."
Alucinación
Los LLM pueden generar información incorrecta con confianza, lo que se conoce como
alucinación. Para reducir su impacto, podemos pedirle al LLM que solo
genera una respuesta si conoce la respuesta. Si no la conoce
respuesta, puede responder con “no sé”.
Orden
Comience o finalice su mensaje con la instrucción. Especialmente con mensajes
largos, la información que se encuentra en el medio suele olvidarse.1 Los LLM tienden
a centrarse en la información que se encuentra al principio de un mensaje (efecto
de primacía) o al final de un mensaje (efecto de actualidad).
En este caso, la especificidad es posiblemente el aspecto más importante. Al restringir y

especificar lo que el modelo debe generar, hay menos posibilidades de que genere
algo que no esté relacionado con el caso de uso. Por ejemplo, si omitiéramos la
instrucción “en dos o tres oraciones”, podría generar párrafos completos. Al igual que las
conversaciones humanas, sin instrucciones específicas ni contexto adicional, es
difícil deducir cuál es realmente la tarea en cuestión.
Ingeniería avanzada de avisos

A primera vista, crear un buen mensaje puede parecer sencillo. Haga una pregunta
específica, sea preciso, agregue algunos ejemplos y ¡listo!
Sin embargo, la motivación puede volverse compleja muy rápidamente y, como resultado, es un
componente a menudo subestimado en el aprovechamiento de los LLM.
Aquí repasaremos varias técnicas avanzadas para desarrollar sus indicaciones, comenzando
con el flujo de trabajo iterativo de creación de indicaciones complejas hasta el uso de
LLM de forma secuencial para obtener mejores resultados.
Con el tiempo, incluso llegaremos a desarrollar técnicas de razonamiento avanzadas.
La complejidad potencial de un mensaje

Como exploramos en la introducción a la ingeniería de indicaciones, una indicación
generalmente consta de varios componentes. En nuestro primer ejemplo, nuestra
indicación constaba de instrucciones, datos e indicadores de salida. Como mencionamos
antes, ninguna indicación se limita a estos tres componentes y puedes desarrollarla para
que sea tan compleja como quieras.
Estos componentes avanzados pueden hacer que un mensaje se vuelva bastante complejo rápidamente.
Algunos componentes comunes son:
Persona
Describa qué papel debe asumir el LLM. Por ejemplo, utilice “Usted es
un experto en astrofísica” si quieres hacer una pregunta sobre
astrofísica.
Instrucción
La tarea en sí. Asegúrate de que sea lo más específica posible. No queremos
dejar mucho espacio para la interpretación.
Contexto
Información adicional que describe el contexto del problema o tarea.
responde preguntas como "¿Cuál es el motivo de la instrucción?"
Formato
El formato que debe utilizar el LLM para generar el texto. Sin él,
El LLM elaborará su propio formato, lo cual es problemático.

sistemas automatizados.
Audiencia
El objetivo del texto generado. También describe el nivel del resultado generado. Para fines
educativos, suele ser útil utilizar ELI5 (“Explícalo como si tuviera 5 años”).
Tono
El tono de voz que el LLM debe utilizar en el texto generado. Si está escribiendo un correo
electrónico formal a su jefe, es posible que no desee utilizar un tono de voz
tono de voz informal.
Datos
Los datos principales relacionados con la tarea en sí.
Para ilustrarlo, ampliemos la instrucción de clasificación que teníamos antes y usemos todos los
componentes anteriores. Esto se muestra en la Figura 611.
Este mensaje complejo demuestra la naturaleza modular de los mensajes. Podemos agregar y
quitar componentes libremente y juzgar su efecto en el resultado.
Como se ilustra en la Figura 612, podemos desarrollar lentamente nuestro mensaje y explorar
el efecto de cada cambio.
Los cambios no se limitan simplemente a introducir o eliminar componentes.

Su orden, como vimos antes con los efectos de actualidad y primacía, puede afectar la calidad
del resultado del LLM. En otras palabras, la experimentación es vital para encontrar el mejor estímulo
para su caso de uso. Con el estímulo, esencialmente nos encontramos en un ciclo iterativo de
experimentación.
Figura 611. Ejemplo de un mensaje complejo con muchos componentes.
Figura 612. La iteración sobre componentes modulares es una parte vital de la ingeniería rápida.
¡Pruébelo usted mismo! Utilice el mensaje complejo para agregar o quitar

partes y observar su impacto en el resultado generado. Notará rápidamente cuándo
Vale la pena conservar las piezas del rompecabezas. Puedes utilizar tus propios
datos añadiéndolos a la variable de datos:
# Componentes del mensaje

persona = "Usted es un experto en modelos de lenguaje extenso. Se destaca en descomponer documentos
complejos en resúmenes digeribles.\n" instruction = "Resuma los hallazgos clave del documento
proporcionado.\n" context = "Su resumen debe extraer los puntos más cruciales que puedan
ayudar a los
investigadores a comprender rápidamente la información más vital del documento.\n" data_format = "Cree
un resumen con viñetas que describa el método. Continúe con un párrafo conciso que resuma los
resultados principales.\n" audience = "El
resumen está diseñado para investigadores ocupados que necesitan comprender rápidamente las
tendencias más nuevas en modelos de lenguaje extenso.\n" tone = "El tono debe ser profesional y claro.\n" text
= "MI TEXTO PARA RESUMIR"
data = f"Texto para resumir: {text}"
# El mensaje completo: elimine y agregue piezas para ver su impacto en la consulta de salida generada =
persona + instrucción + contexto
+ formato_datos + audiencia + tono + datos
CONSEJO
Hay todo tipo de componentes que podríamos agregar y componentes creativos como el uso
de estímulos emocionales (por ejemplo, “Esto es muy importante para mi carrera”2 ). Parte de la
diversión en la ingeniería de indicaciones es que puedes ser lo más creativo posible para
descubrir qué combinación de componentes de indicaciones contribuye a tu caso de uso.
Hay pocas limitaciones para desarrollar un formato que funcione para ti.
En cierto modo, se trata de un intento de aplicar ingeniería inversa a lo que el modelo ha aprendido y cómo
responde a determinadas indicaciones. Sin embargo, tenga en cuenta que algunas indicaciones funcionan
mejor para determinados modelos que para otros, ya que sus datos de entrenamiento pueden ser diferentes o
se los entrena para distintos fines.
Aprendizaje en contexto: proporcionar ejemplos

En las secciones anteriores, intentamos describir con precisión lo que debe hacer
el LLM. Si bien las descripciones precisas y específicas ayudan al LLM a comprender
el caso de uso, podemos ir un paso más allá. En lugar de describir la tarea, ¿por qué
no mostramos simplemente la tarea?
Podemos proporcionar al LLM ejemplos de exactamente lo que queremos lograr. Esto se

conoce como aprendizaje en contexto, en el que proporcionamos al modelo ejemplos
correctos.3
Como se ilustra en la Figura 613, esto se presenta en varias formas según la cantidad de
ejemplos que muestre al LLM. Los estímulos de cero ejemplos no aprovechan los
ejemplos, los estímulos de un solo ejemplo utilizan un solo ejemplo y los estímulos de
pocos ejemplos utilizan dos o más ejemplos.
Figura 613. Ejemplo de un mensaje complejo con muchos componentes.
Retomando la frase original, creemos que “un ejemplo vale más que mil palabras”.
Estos ejemplos proporcionan un ejemplo directo de qué y cómo debe lograr el LLM.
Podemos ilustrar este método con un ejemplo simple tomado del artículo original que
describe este método.4 El objetivo del mensaje es generar una
Oración con una palabra inventada. Para mejorar la calidad de la oración

resultante, podemos mostrarle al modelo generativo un ejemplo de cómo sería
una oración adecuada con una palabra inventada.
Para ello, tendremos que diferenciar entre nuestra pregunta (usuario) y las
respuestas que nos proporcionó el modelo (asistente). Además,
mostramos cómo se procesa esta interacción mediante la plantilla:
# Utilice un solo ejemplo del uso de la palabra inventada en una oración one_shot_prompt = [ {
"role": "user", "content":

"Un 'Gigamuru' es un tipo de instrumento musical japonés. Un ejemplo de una oración que
utiliza la palabra Gigamuru es:" }, {
"role": "assistant", "content":

"Tengo un Gigamuru que me regaló mi tío. Me encanta jugarlo en casa".
},
{
"role": "user", "content":
"'Screeg' algo es blandir una espada contra
Un ejemplo de una oración que utiliza la palabra screeg es: "
}
] imprimir(tokenizer.apply_chat_template(one_shot_prompt, tokenize=False))
<s><|user|> Un
'Gigamuru' es un tipo de instrumento musical japonés. Un ejemplo de una oración que utiliza la
palabra Gigamuru es:<|end|> <|assistant|> Tengo un Gigamuru que me regaló mi tío. Me encanta
tocarlo en casa.<|end|
> <|user|> 'Screeg' algo es blandir una espada contra él. Un ejemplo de una oración que utiliza la
palabra screeg es:<|end|> <|assistant|>
El mensaje ilustra la necesidad de diferenciar entre el usuario y el asistente. Si no lo hiciéramos,

parecería como si estuviéramos hablando con nosotros mismos.
Usando estas interacciones, podemos generar resultados como los siguientes:
# Generar la salida salidas

= pipe(one_shot_prompt) print(salidas[0]
["generated_text"])
Durante el intenso duelo, el caballero golpeó hábilmente el escudo de su

oponente, obligándolo a defenderse.
¡Generó la respuesta correctamente!
Al igual que con todos los componentes de indicaciones, la indicación de una o varias veces no es la
clave de la ingeniería de indicaciones. Podemos utilizarla como una pieza del rompecabezas para
mejorar aún más las descripciones que le dimos. El modelo aún puede “elegir”, mediante un
muestreo aleatorio, ignorar las instrucciones.
Impulso en cadena: desmembrando el problema

En ejemplos anteriores, analizamos la posibilidad de dividir los mensajes en componentes
modulares para mejorar el rendimiento de los LLM. Si bien esto funciona bien para muchos casos
de uso, puede que no sea factible para mensajes o casos de uso muy complejos.
En lugar de dividir el problema dentro de una indicación, podemos hacerlo entre indicaciones.
Básicamente, tomamos el resultado de una indicación y lo usamos como entrada para la siguiente,
creando así una cadena continua de interacciones que resuelve nuestro problema.
Para ilustrarlo, digamos que queremos utilizar un LLM para crear un nombre de producto, un
eslogan y un discurso de ventas para nosotros basados en una serie de características del producto.
Aunque podemos pedirle al LLM que haga esto de una sola vez, podemos dividir el problema en partes.
Como resultado, y como se ilustra en la Figura 614, obtenemos una tubería secuencial que primero
crea el nombre del producto, lo usa con las características del producto como
entrada para crear el eslogan y, finalmente, utiliza las características, el nombre del producto y el
eslogan para crear el discurso de venta.
Figura 614. Utilizando una descripción de las características de un producto, se crean pautas en cadena para crear un nombre, un eslogan
y un discurso de venta adecuados.
Esta técnica de encadenar indicaciones permite al LLM dedicar más tiempo a cada pregunta
individual en lugar de abordar el problema en su conjunto. Ilustremos esto con un pequeño
ejemplo. Primero creamos un nombre y un eslogan para un chatbot:
# Crear nombre y eslogan para un producto

product_prompt =
[ {"role": "user", "content": "Crear un nombre y eslogan para un producto
chatbot que aprovecha los LLM."} ]
outputs = pipe(product_prompt)
product_description = outputs[0]["generated_text"]
print(product_description)
Nombre: 'MindMeld Messenger'

Eslogan: “Dando rienda suelta a conversaciones inteligentes, una respuesta a la vez”
Luego, podemos utilizar la salida generada como entrada para que el LLM genere un discurso
de ventas:
# Basado en un nombre y eslogan para un producto, genere un discurso de venta sales_prompt =

[ {"role":
"user", "content": f"Genere
un discurso de venta muy breve
propuesta para el siguiente producto: '{product_description}'"} ] outputs = pipe(sales_prompt)
propuesta_de_ventas = outputs[0]
["generated_text"] print(sales_pitch)
Presentamos MindMeld Messenger, ¡tu mejor aliado en materia de comunicación! Da rienda suelta a
conversaciones inteligentes con nuestra innovadora plataforma de mensajería impulsada por IA. Con
MindMeld Messenger, cada respuesta es reflexiva, personalizada y oportuna. Dile adiós a las respuestas
genéricas y dale la bienvenida a las interacciones significativas.
Mejore su comunicación con MindMeld Messenger, donde cada mensaje es un paso hacia conversaciones
más inteligentes. ¡Pruébelo ahora y experimente el futuro de la mensajería!
Aunque necesitamos dos llamadas al modelo, una ventaja importante es que podemos darle
a cada llamada parámetros diferentes. Por ejemplo, la cantidad de tokens creados fue
relativamente pequeña para el nombre y el eslogan, mientras que el discurso puede ser mucho
más extenso.
Esto se puede utilizar para una variedad de casos de uso, incluidos:
Validación de respuesta
Pídale al LLM que vuelva a verificar los resultados generados previamente.
Indicaciones paralelas
Crea múltiples indicaciones en paralelo y haz una pasada final para fusionarlas.
Por ejemplo, pedir a varios LLM que generen múltiples recetas en paralelo
y utilizar el resultado combinado para crear una lista de compras.
Escribiendo historias
Aproveche el LLM para escribir libros o historias desglosando el problema en componentes.
Por ejemplo, primero escriba un resumen, desarrolle personajes y cree los elementos de la
historia antes de sumergirse en el tema.
creando el diálogo.
En el próximo capítulo, automatizaremos este proceso e iremos más allá del encadenamiento de LLM.
Encadenaremos otras piezas de tecnología, como la memoria, el uso de herramientas y más. Antes de
eso, esta idea del encadenamiento de indicaciones se explorará más a fondo en las siguientes
secciones, que describen métodos de encadenamiento de indicaciones más complejos, como la
autoconsistencia, la cadena de pensamiento y el árbol de pensamiento.
Razonamiento con modelos generativos

En las secciones anteriores, nos centramos principalmente en el componente modular de los mensajes,
construyéndolos mediante iteraciones. Estas técnicas avanzadas de ingeniería de mensajes,
como el encadenamiento de mensajes, demostraron ser el primer paso para permitir el razonamiento
complejo con modelos generativos.
El razonamiento es un componente central de la inteligencia humana y a menudo se lo

compara con el comportamiento emergente de los LLM, que a menudo se asemeja al
razonamiento. Resaltamos “se asemejan” porque, al momento de escribir este artículo, se considera que
estos modelos demuestran este comportamiento a través de la memorización de datos
de entrenamiento y la comparación de patrones.
Sin embargo, el resultado que muestran puede demostrar un comportamiento complejo y, aunque puede
que no sea un razonamiento “verdadero”, se lo sigue llamando capacidades de razonamiento. En
otras palabras, trabajamos junto con el LLM a través de ingeniería rápida para poder imitar los
procesos de razonamiento con el fin de mejorar el resultado del LLM.
Para que este razonamiento sea posible, es un buen momento para dar un paso atrás y
explorar qué implica el razonamiento en el comportamiento humano. Para simplificar, nuestros
métodos de razonamiento pueden dividirse en procesos de pensamiento de los sistemas 1 y 2.
El pensamiento del sistema 1 representa un proceso automático, intuitivo y casi instantáneo.

Comparte similitudes con los modelos generativos que generan tokens automáticamente
sin ningún comportamiento autorreflexivo. En cambio, el pensamiento del sistema 2 es un
proceso consciente, lento y lógico, similar a la lluvia de ideas y la autorreflexión.5
Si pudiéramos darle a un modelo generativo la capacidad de imitar una forma de

autorreflexión, esencialmente estaríamos emulando la forma de pensar del sistema 2, que tiende
a producir respuestas más reflexivas que el pensamiento del sistema 1.
En esta sección, exploraremos varias técnicas que intentan imitar este tipo de procesos de
pensamiento de los razonadores humanos con el objetivo de mejorar el resultado del
modelo.
Cadena de pensamiento: piensa antes de responder

El primer y principal paso hacia el razonamiento complejo en los modelos generativos se dio
a través de un método llamado cadena de pensamiento, cuyo objetivo es que el modelo
generativo “piense” primero en lugar de responder la pregunta directamente sin razonamiento
alguno.
6
Como se ilustra en la Figura 615, proporciona ejemplos en una indicación que

demuestran el razonamiento que el modelo debe realizar antes de generar su respuesta.
Estos procesos de razonamiento se denominan "pensamientos". Esto ayuda enormemente
en tareas que implican un mayor grado de complejidad, como las preguntas matemáticas.
Agregar este paso de razonamiento permite que el modelo distribuya más cómputo a lo largo del
proceso de razonamiento. En lugar de calcular la solución completa en función de unos pocos
tokens, cada token adicional en este proceso de razonamiento permite que el LLM
estabilice su salida.
Figura 615. La estimulación mediante cadenas de pensamiento utiliza ejemplos de razonamiento para persuadir al modelo generativo a
utilizar el razonamiento en su respuesta.
Utilizamos el ejemplo que los autores utilizaron en su artículo para demostrar

este fenómeno:
# Responder con cadena de pensamientos

cot_prompt =
[ {"role": "user", "content": "Roger tiene 5 pelotas de tenis. Compra 2 latas
más de pelotas de tenis. Cada lata tiene 3 pelotas de tenis.
¿Cuántas pelotas de tenis tiene ahora?"
{"role": "assistant", "content": "Roger empezó con 5 pelotas. 2 latas de 3 pelotas de tenis cada una son
6 pelotas de tenis. 5 + 6 = 11. La respuesta es 11."}, {"role": "user", "content": "La cafetería tenía 23 manzanas.
Si usaron 20 para preparar
el almuerzo y compraron 6 más, ¿cuántas manzanas tienen?"} ]
# Generar la salida
salidas = pipe(cot_prompt)
print(salidas[0]["texto_generado"])
La cafetería empezó con 23 manzanas. Usaron 20 manzanas, por lo que les

quedaron 23 20 = 3 manzanas. Luego compraron 6 manzanas más, por lo
que ahora tienen 3 + 6 = 9 manzanas. La respuesta es 9.
Observe cómo el modelo no solo genera la respuesta, sino que también proporciona
una explicación antes de hacerlo. De este modo, puede aprovechar el conocimiento que
ha generado hasta el momento para calcular la respuesta final.
Aunque la cadena de pensamiento es un método excelente para mejorar el resultado de

un modelo generativo, requiere uno o más ejemplos de razonamiento en la instrucción, a
los que el usuario podría no tener acceso. En lugar de proporcionar ejemplos,
podemos simplemente pedirle al modelo generativo que proporcione el razonamiento
(cadena de pensamiento de cero disparos). Hay muchas formas diferentes que funcionan,
pero un método común y eficaz es usar la frase “Pensemos paso a paso”, que se ilustra
en la Figura 616. 7
Figura 616. Instrucción de cadena de pensamiento sin utilizar ejemplos. En su lugar, utiliza la frase “Pensemos
paso a paso” para impulsar el razonamiento en su respuesta.
Usando el ejemplo que usamos antes, podemos simplemente agregar esa frase al mensaje
para permitir un razonamiento tipo cadena de pensamientos:
# Cadena de pensamiento de disparo

cero zeroshot_cot_prompt = [
{"role": "user", "content": "En la cafetería había 23 manzanas. Si usaron 20 para
preparar el almuerzo y compraron 6 más, ¿cuántas manzanas tienen? Pensemos paso
a paso."} ]
# Generar la salida
salidas = pipe(zeroshot_cot_prompt) print(salidas[0]

["texto_generado"])
Paso 1: Comience con el número inicial de manzanas, que es 23.

Paso 2: Resta la cantidad de manzanas utilizadas para preparar el almuerzo, que es 20.
Entonces, 23 20 = 3 manzanas restantes.
Paso 3: Suma el número de manzanas compradas, que es 6. Entonces, 3 + 6 = 9 manzanas.
La cafetería ahora tiene 9 manzanas.
Sin necesidad de proporcionar ejemplos, volvimos a obtener el mismo

comportamiento de razonamiento. Por eso es tan importante “mostrar tu trabajo”
al hacer cálculos. Al abordar el proceso de razonamiento, el LLM puede usar la
información generada previamente como guía para generar el resultado final.
respuesta.
CONSEJO
Aunque la consigna “Pensemos paso a paso” puede mejorar el resultado, no estás

limitado a esta formulación exacta. Existen alternativas como “Respira profundamente
y piensa paso a paso” y “Resolvamos este problema paso a paso”.8
Autoconsistencia: resultados de muestreo

Usar el mismo mensaje varias veces puede generar resultados diferentes si
permitimos un cierto grado de creatividad a través de parámetros como la
temperatura y top_p. Como resultado, la calidad del resultado puede mejorar o
empeorar según la selección aleatoria de tokens. En otras palabras, ¡suerte!
Para contrarrestar este grado de aleatoriedad y mejorar el rendimiento de los modelos generativos, se introdujo la
autoconsistencia. Este método plantea al modelo generativo la misma pregunta varias veces y toma el resultado de
la mayoría 9 como respuesta final.
Durante este proceso, cada respuesta puede verse

afectada por diferentes valores de temperatura y top_p para aumentar la diversidad
del muestreo.
Como se ilustra en la Figura 617, este método se puede mejorar aún más
agregando una secuencia de pensamientos para mejorar su razonamiento mientras
se usa solo la respuesta para el procedimiento de votación.
Figura 617. Al tomar muestras de múltiples caminos de razonamiento, podemos utilizar la votación por mayoría para extraer la
respuesta más probable.
Sin embargo, esto requiere que se haga una misma pregunta varias veces. Como
resultado, aunque el método puede mejorar el rendimiento, se vuelve n veces más lento,
donde n es el número de muestras de salida.
Árbol del pensamiento: exploración de los pasos intermedios

Las ideas de cadena de pensamiento y de autoconsistencia tienen como objetivo
permitir un razonamiento más complejo. Al tomar muestras de múltiples
“pensamientos” y hacerlos más reflexivos, pretendemos mejorar el resultado de los
modelos generativos.
Estas técnicas son apenas una pequeña muestra de lo que se está haciendo actualmente
para imitar el razonamiento complejo. Una mejora de estos enfoques se puede
encontrar en el árbol de pensamiento, que permite una exploración en profundidad
de varias ideas.
El método funciona de la siguiente manera: cuando se enfrenta un problema que

requiere múltiples pasos de razonamiento, suele ser útil dividirlo en partes. En cada paso,
y como se ilustra en la Figura 618, se le pide al modelo generativo que explore diferentes
soluciones al problema en cuestión. Luego vota por la mejor solución y continúa con el
siguiente paso.10
Figura 618. Al aprovechar una estructura basada en árboles, los modelos generativos pueden generar pensamientos intermedios
para su clasificación. Se conservan los pensamientos más prometedores y se eliminan los menos prometedores.
Este método es tremendamente útil cuando se necesita considerar múltiples

caminos, como cuando se escribe una historia o se tienen ideas creativas.
Una desventaja de este método es que requiere muchas llamadas a los modelos
generativos, lo que ralentiza significativamente la aplicación. Afortunadamente, existe
Ha sido un intento exitoso de convertir el marco del árbol del pensamiento en una
técnica de estímulo simple.11
En lugar de llamar al modelo generativo varias veces, le pedimos al modelo que imite
ese comportamiento emulando una conversación entre múltiples expertos.
Estos expertos se interrogarán entre sí hasta llegar a un consenso. Un ejemplo de
un árbol de ideas es el siguiente:
# Árbol de pensamiento de disparo cero

zeroshot_tot_prompt = [
{"role": "user", "content": "Imagina que tres expertos diferentes están respondiendo a esta pregunta.
Todos los expertos escribirán un paso de su razonamiento y luego lo compartirán con el grupo. Luego,
todos los expertos pasarán al siguiente paso, etc. Si algún experto se da cuenta de que está equivocado en
algún momento, se marcha. La pregunta es: "La cafetería tenía 23 manzanas. Si usaron 20 para preparar el
almuerzo y compraron 6 más, ¿cuántas manzanas tienen?" Asegúrate de discutir los
resultados."} ]
Podemos utilizar este mensaje para explorar cómo un LLM podría responder a preguntas
complejas:
# Generar la salida salidas =

pipe(zeroshot_tot_prompt) print(outputs[0]["generated_text"])
Experto 1: Paso 1 – Comience con el número inicial de manzanas: 23 manzanas.
Experto 2: Paso 1 – Resta las manzanas utilizadas para el almuerzo: 23 – 20 = 3 manzanas restantes.
Experto 3: Paso 1 – Agregue las manzanas recién compradas: 3 + 6 = 9 manzanas.
Experto 1: Paso 2 – Confirmar el recuento final: La cafetería tiene 9 manzanas.
Experto 2: Paso 2 Revise los cálculos: 23 20 = 3, luego 3 + 6 = 9. Los cálculos son correctos.
Experto 3: Paso 2 – Acepte el resultado: La cafetería efectivamente tiene 9

manzanas.
Todos los expertos coinciden en el recuento final: en la cafetería hay 9

manzanas.
Nuevamente obtenemos la respuesta correcta, pero en lugar de ello, mediante una “discusión
entre expertos”. Es interesante ver este tipo de conversación entre “expertos” que demuestra
la creatividad que conlleva la ingeniería rápida.
Verificación de salida
Los sistemas y aplicaciones creados con modelos generativos pueden acabar en producción.
Cuando eso sucede, es importante que verifiquemos y controlemos el resultado del modelo
para evitar que la aplicación se estropee y crear una aplicación de IA generativa sólida.
Las razones para validar la salida podrían incluir:
Salida estructurada
De manera predeterminada, la mayoría de los modelos generativos crean texto de forma
libre sin adherirse a estructuras específicas distintas de las definidas por los modelos naturales.
lenguaje. Algunos casos de uso requieren que su salida esté estructurada de cierta manera.
formatos, como JSON.
Salida válida
Incluso si permitimos que el modelo genere una salida estructurada, aún tiene la
capacidad de generar libremente su contenido. Por ejemplo, cuando se le pide a un
modelo que genere una de dos opciones, no debería generar una
tercero.
Ética
Algunos modelos generativos de código abierto no tienen límites y generarán
resultados que no tienen en cuenta consideraciones éticas ni de seguridad.
Por ejemplo, los casos de uso pueden requerir que el resultado esté libre de blasfemias,
información de identificación personal (PII), prejuicios, estereotipos culturales, etc.
Exactitud
Muchos casos de uso requieren que la salida cumpla con ciertos estándares o
rendimiento. El objetivo es comprobar si la información generada es
objetivamente exacta, coherente o libre de alucinaciones.
Controlar la salida de un modelo generativo, como hemos visto con parámetros

como top_p y temperatura, no es una tarea fácil. Estos modelos requieren ayuda para
generar una salida consistente que cumpla con ciertas pautas.
Generalmente, hay tres formas de controlar la salida de un modelo generativo:
Ejemplos
Proporcione una serie de ejemplos del resultado esperado.
Gramática
Controlar el proceso de selección de tokens.
Sintonia FINA
Ajuste un modelo con datos que contengan el resultado esperado.
En esta sección, repasaremos los dos primeros métodos. El tercero, el ajuste fino de un
modelo, se deja para el Capítulo 12 , donde profundizaremos en los métodos de ajuste
fino.
Proporcionar ejemplos
Un método simple y directo para corregir el resultado es proporcionar al
modelo generativo ejemplos de cómo debería verse el resultado. Como hemos
explorado antes, el aprendizaje de pocos intentos es una técnica útil que
guía el resultado del modelo generativo. Este método se puede generalizar para
guiar también la estructura del resultado.
Por ejemplo, consideremos un ejemplo en el que queremos que el modelo

generativo cree un perfil de personaje para un juego de rol. Empezamos sin
usar ejemplos:
# Aprendizaje de disparo cero: no se proporcionan ejemplos

zeroshot_prompt = [ {"role":
"user", "content": "Crear un perfil de personaje para
un juego de rol en formato JSON."} ]
# Generar la salida salidas =

pipe(zeroshot_prompt) print(outputs[0]
["generated_text"])
``json {
"characterProfile": { "name": "Eldrin

Stormbringer", "class": "Warlock", "race": "HalfElf",
"age": 27, "gender": "Masculino",
"alignment": "Caótico Bueno",
"background":
"Rogue",
},
"atributos": {
"fuerza": 10, "destreza":
17, "constitución": 12,
"inteligencia": 12, "sabiduría":
10, "carisma"
La salida truncada anterior no es JSON válida, ya que el modelo dejó de generar

tokens después de iniciar el atributo “carisma”. Además, es posible que no
queramos determinados atributos. En su lugar, podemos proporcionar al modelo una
serie de ejemplos que indiquen el formato esperado:
# Aprendizaje de una sola vez: proporcionar un ejemplo de la estructura de salida

one_shot_template = """Crea un perfil de personaje breve para un juego de rol.
Asegúrate de usar solo este formato:
{
"description": "UNA BREVE DESCRIPCIÓN", "name": "EL
NOMBRE DEL PERSONAJE", "armor": "UNA
PIEZA DE ARMADURA", "weapon": "UNA O
MÁS ARMAS"
}
"""
one_shot_prompt =
[ {"rol": "usuario", "contenido": plantilla_one_shot}
]
# Generar la salida salidas

= pipe(one_shot_prompt) print(salidas[0]
["generated_text"])
{
"description": "Un pícaro astuto con un pasado misterioso,
experta en sigilo y engaño.", "name": "Lysandra
Shadowstep", "armor": "Capa de cuero
de la noche", "weapon": "Daga de los susurros,
cuchillos arrojadizos"
}
El modelo siguió a la perfección el ejemplo que le dimos, lo que permite un

comportamiento más consistente. Esto también demuestra la importancia de
aprovechar el aprendizaje basado en pocos intentos para mejorar la estructura del
resultado y no solo su contenido.
Es importante tener en cuenta que el modelo seguirá o no el formato sugerido.

Algunos modelos siguen las instrucciones mejor que otros.
Gramática: Muestreo restringido

El aprendizaje de pocos intentos tiene una gran desventaja: no podemos impedir
explícitamente que se generen determinados resultados. Aunque guiamos al modelo y le
damos instrucciones, es posible que no las siga en su totalidad.
En cambio, se han desarrollado rápidamente paquetes para restringir y validar la salida de

modelos generativos, como Guidance, Barandillas, y LMQL. En parte, utilizan modelos
generativos para validar su propio resultado, como se ilustra en la Figura 619. Los
modelos generativos recuperan el resultado como nuevos mensajes e intentan validarlo
en función de una serie de parámetros predefinidos.
Figura 619. Utilice un LLM para comprobar si el resultado sigue correctamente nuestras reglas.
De manera similar, como se ilustra en la Figura 620, este proceso de validación

también se puede utilizar para controlar el formato de la salida generando partes de su
formato nosotros mismos, ya que ya sabemos cómo debe estructurarse.
Figura 620. Utilice un LLM para generar únicamente la información que no conocemos de antemano.
Este proceso se puede llevar un paso más allá y, en lugar de validar la salida, podemos realizar
la validación durante el proceso de muestreo de tokens. Al muestrear tokens, podemos
definir una serie de gramáticas o reglas que el LLM debe respetar al elegir su próximo token. Por
ejemplo, si le pedimos al modelo que devuelva “positivo”, “negativo” o “neutral” al realizar la
clasificación de sentimientos, es posible que devuelva algo diferente. Como se ilustra en la
Figura 621, al restringir el proceso de muestreo, podemos hacer que el LLM solo muestre lo
que nos interesa. Tenga en cuenta que esto aún se ve afectado por parámetros como top_p y
temperatura.
Figura 621. Restrinja la selección de tokens a solo tres tokens posibles: “positivo”, “neutral” y
“negativo”.
Ilustremos este fenómeno con llamacpppython, una biblioteca similar a transformers que podemos
usar para cargar en nuestro modelo de lenguaje.
Generalmente se utiliza para cargar y utilizar de manera eficiente modelos comprimidos (a través de
la cuantificación; consulte el Capítulo 12), pero también podemos usarlo para aplicar una
gramática JSON.
Cargamos el mismo modelo que usamos a lo largo de este capítulo, pero usamos un formato diferente,
concretamente GGUF. llamacpppython espera este formato, que generalmente se usa para modelos
comprimidos (cuantificados).
Dado que estamos cargando un nuevo modelo, se recomienda reiniciar la notebook. Esto borrará todos
los modelos anteriores y vaciará la VRAM. También puede ejecutar lo siguiente para vaciar la VRAM:
importar gc
importar antorcha
del modelo, tokenizador, tubería
# Vaciar la memoria
gc.collect()
antorcha.cuda.empty_cache()
Ahora que hemos limpiado la memoria, podemos cargar Phi3. Establecemos

n_gpu_layers en 1 para indicar que queremos que todas las capas del modelo se
ejecuten desde la GPU. n_ctx hace referencia al tamaño del contexto del modelo.
El repo_id y el nombre del archivo hacen referencia al repositorio Hugging Face donde
reside el modelo:
de llama_cpp.llama importar Llama
# Cargar Phi3 llm =

Llama.from_pretrained( repo_id="microsoft/
Phi3mini4kinstructgguf", nombre_archivo="*fp16.gguf", n_gpu_layers=1,
n_ctx=2048, verbose=False
Para generar la salida utilizando la gramática JSON interna, solo necesitamos especificar
response_format como un objeto JSON. En segundo plano, se aplicará una gramática
JSON para asegurarse de que la salida se ajuste a ese formato.
Para ilustrarlo, pidamos al modelo que cree un personaje de RPG en formato JSON para
usarlo en una sesión de Dungeons & Dragons:
# Generar salida output =

llm.create_chat_completion( messages=[ {"role": "user",
"content": "Crea
un guerrero para un RPG en formato JSON."}, ], response_format={"type": "json_object"},
temperatura=0, )
['opciones'][0]['mensaje']["contenido"]
Para comprobar si la salida es realmente JSON, podemos intentar procesarla de esta

manera:
importar json
# Formato como json

json_output = json.dumps(json.loads(output), indent=4) print(json_output)
{
"nombre": "Eldrin Portador de Tormentas", "clase":
"Guerrero", "nivel": 10,
"atributos":
{ "fuerza": 18, "destreza":
12, "constitución": 16,
"inteligencia": 9, "sabiduría":
14, "carisma": 10
},
"habilidades":
{ "combate cuerpo a
cuerpo": { "dominio de armas":
20, "clase de armadura":
18, "puntos de golpe": 35
},
"defensa":
{ "habilidad_de_escudo":
17, "posibilidad_de_bloqueo": 90
},
"resistencia":
{ "regeneración_de_salud": 2, "resistencia":
30
}
},
"equipo": [ {
"nombre": "Armadura de hierro", "tipo":

"Armadura",
"bonificación_defensa": 15
},
{
"nombre": "Espada magna de acero", "tipo":
"Arma", "daño": 8,
"probabilidad_crítica":
20
}
],
"background": "Eldrin creció en un pequeño pueblo en las afueras de una tierra devastada por
la guerra. Al ser testigo de la brutalidad y el sufrimiento causados por el conflicto, dedicó su vida a
convertirse en un guerrero formidable que pudiera proteger a aquellos que no podían defenderse por sí
mismos". }
El resultado tiene el formato JSON correcto. Esto nos permite usar modelos
generativos con más confianza en aplicaciones en las que esperamos que el
resultado se ajuste a determinados formatos.
Resumen
En este capítulo, exploramos los conceptos básicos del uso de modelos generativos a
través de la ingeniería de indicaciones y la verificación de resultados. Nos centramos
en la creatividad y la complejidad potencial que conlleva la ingeniería de
indicaciones. Estos componentes de una indicación son clave para generar y
optimizar resultados adecuados para diferentes casos de uso.
Exploramos más a fondo técnicas avanzadas de ingeniería de indicaciones, como el

aprendizaje en contexto y la cadena de pensamiento. Estos métodos implican guiar
a los modelos generativos para que razonen sobre problemas complejos
proporcionando ejemplos o frases que fomenten el pensamiento paso a paso,
imitando así los procesos de razonamiento humanos.
En general, este capítulo demostró que la ingeniería rápida es un aspecto crucial del
trabajo con LLM, ya que nos permite comunicar de manera eficaz nuestras necesidades
y preferencias al modelo. Al dominar las técnicas de ingeniería rápida, podemos liberar
parte del potencial de los LLM y generar respuestas de alta calidad que cumplan con
nuestros requisitos.
El próximo capítulo se basará en estos conceptos explorando más

Técnicas avanzadas para aprovechar los modelos generativos. Iremos más allá
Ingeniería rápida y explorar cómo los LLM pueden usar memoria externa y
herramientas.
1
Nelson F. Liu et al. “Perdidos en el medio: cómo los modelos de lenguaje utilizan contextos largos”. arXiv
2
Cheng Li et al. “EmotionPrompt: Aprovechamiento de la psicología para grandes modelos lingüísticos”
Mejora a través del estímulo emocional”. preimpresión arXiv arXiv:2307.11760 (2023).
3
Tom Brown et al. “Los modelos de lenguaje son aprendices de pocas oportunidades”. Avances en la información neuronal
Sistemas de procesamiento 33 (2020): 1877–1901.
4
Ibídem.
5
Daniel Kahneman. Pensar rápido, pensar despacio. Macmillan (2011).
6
Jason Wei et al. “La inducción de cadenas de pensamiento genera razonamiento en modelos lingüísticos amplios”.
Avances en sistemas de procesamiento de información neuronal 35 (2022): 24824–24837.
7
Takeshi Kojima et al. “Los modelos de lenguaje grandes son razonadores de cero disparos”. Avances en el análisis neuronal
Sistemas de procesamiento de información 35 (2022): 22199–22213.
8
Chengrun Yang et al. “Grandes modelos lingüísticos como optimizadores”. Preimpresión de arXiv
arXiv:2309.03409 (2023).
9
Xuezhi Wang et al. “La autoconsistencia mejora el razonamiento en cadena de pensamiento en el lenguaje
modelos.” preimpresión arXiv arXiv:2203.11171 (2022).
10
Shunyu Yao et al. “Árbol de pensamientos: resolución deliberada de problemas con modelos de lenguaje de gran tamaño”.
11
“Uso de la estimulación del árbol de pensamiento para potenciar el razonamiento de ChatGPT”. Disponible en
https://oreil.ly/a_Nos.
OceanofPDF.com
Capítulo 7. Técnicas y herramientas

avanzadas de generación de texto
En el capítulo anterior, vimos cómo la ingeniería de indicaciones puede hacer maravillas

en la precisión de su modelo de lenguaje grande (LLM) de generación de texto. Con solo
unos pequeños ajustes, estos LLM se orientan hacia respuestas más precisas y con
un propósito más definido. Esto demostró cuánto se puede ganar utilizando
técnicas que no afinan el LLM sino que lo utilizan de manera más eficiente, como la
ingeniería de indicaciones relativamente sencilla.
En este capítulo, continuaremos con esta línea de pensamiento. ¿Qué podemos hacer
para mejorar aún más la experiencia y los resultados que obtenemos del LLM sin
necesidad de ajustar el modelo en sí?
Afortunadamente, existen muchos métodos y técnicas que nos permiten mejorar

aún más lo que comenzamos en el capítulo anterior. Estas técnicas más avanzadas son
la base de numerosos sistemas enfocados en el LLM y, posiblemente, una de las primeras
cosas que los usuarios implementan al diseñar dichos sistemas.
En este capítulo, exploraremos varios de estos métodos y conceptos para mejorar

la calidad del texto generado:
Modelo de E/S
Cargar y trabajar con LLM
Memoria
Ayudando a los LLM a recordar
Agentes
Combinando comportamiento complejo con herramientas externas
Cadenas
Conexión de métodos y módulos
Todos estos métodos están integrados con el marco LangChain que nos ayudarán a utilizar
fácilmente estas técnicas avanzadas a lo largo de este capítulo.
LangChain es uno de los primeros marcos que simplifican el trabajo con LLM mediante
abstracciones útiles. Entre los marcos más recientes que cabe destacar se encuentran DSPy y
pajar. Algunas de estas abstracciones se ilustran en la Figura 71. Tenga en cuenta que la recuperación
se analizará en el próximo capítulo.
Figura 71. LangChain es un marco completo para utilizar LLM. Tiene componentes modulares que se
pueden encadenar para permitir sistemas LLM complejos.
Cada una de estas técnicas tiene ventajas significativas por sí sola, pero su verdadero valor no
existe de forma aislada. Es cuando se combinan todas estas técnicas que se obtiene un sistema
basado en LLM con un rendimiento increíble.
La culminación de estas técnicas es realmente donde los LLM brillan.
Modelo de E/S: Carga de modelos cuantificados con

Cadena Lang
Antes de poder utilizar las características de LangChain para ampliar las capacidades de los LLM,
debemos comenzar cargando nuestro LLM. Como en los capítulos anteriores, utilizaremos Phi3 pero
con un cambio: utilizaremos una variante del modelo GGUF. Un modelo GGUF representa una
versión comprimida de su modelo original.
contraparte a través de un método llamado cuantificación, que reduce el número

de bits necesarios para representar los parámetros de un LLM.
Los bits, una serie de 0 y 1, representan valores al codificarlos en formato binario.

Cuantos más bits haya, mayor será el rango de valores, pero se requiere más memoria
para almacenarlos, como se muestra en la Figura 72.
Figura 72. Intentando representar pi con representaciones de 32 bits y 16 bits en coma flotante. Observe la
precisión reducida cuando reducimos a la mitad el número de bits.
La cuantificación reduce la cantidad de bits necesarios para representar los

parámetros de un LLM, al tiempo que intenta mantener la mayor parte de la
información original. Esto conlleva cierta pérdida de precisión, pero a menudo la
compensa, ya que el modelo es mucho más rápido de ejecutar, requiere menos
VRAM y, a menudo, es casi tan preciso como el original.
Para ilustrar la cuantificación, considere esta analogía. Si le preguntaran qué hora es,
podría decir “14:16”, lo cual es correcto pero no es una respuesta totalmente precisa.
Podría haber dicho “14:16 y 12 segundos”, lo cual habría sido más preciso. Sin
embargo, mencionar segundos rara vez es útil y, a menudo, simplemente los ponemos
en números discretos, es decir, minutos completos.
La cuantificación es un proceso similar que reduce la precisión de un valor (por ejemplo,
eliminando segundos) sin eliminar información vital (por ejemplo, conservando horas y
minutos).
En el Capítulo 12, analizaremos más a fondo cómo funciona la cuantificación .

También puede ver una guía visual completa sobre la cuantificación en “A Visual
Guide to Quantization” de Maarten Grootendorst. Por ahora, es importante
saber que utilizaremos una variante de 8 bits de Phi3 en comparación con la variante
original de 16 bits, reduciendo los requisitos de memoria casi a la mitad.
CONSEJO
Como regla general, busque modelos cuantificados de al menos 4 bits. Estos modelos
tienen un buen equilibrio entre compresión y precisión. Aunque es posible utilizar modelos
cuantificados de 3 bits o incluso de 2 bits, la degradación del rendimiento se hace notoria
y sería preferible elegir un modelo más pequeño con una mayor precisión.
Primero necesitaremos descargar el modelo. Tenga en cuenta que el enlace

contiene varios archivos con distintas variantes de bits. FP16, el modelo que
elegimos, representa la variante de 16 bits:
!wget https://huggingface.co/microsoft/Phi3mini4kinstructgguf/resolve/main/Phi3
mini4kinstructfp16.gguf
Usamos llamacpppython junto con LangChain para cargar el archivo GGUF:
Desde langchain, importe LlamaCpp
# ¡Asegúrese de que la ruta del modelo sea correcta para su sistema! llm =
LlamaCpp( model_path="Phi3mini4kinstructfp16.gguf", n_gpu_layers=1,

max_tokens=500,
n_ctx=2048, seed=42,
verbose=Falso
)
En LangChain, utilizamos la función de invocación para generar salida:

llm.invoke("Hola! Mi nombre es Maarten. ¿Cuánto es 1 + 1?")
"
Lamentablemente, no obtenemos ningún resultado. Como hemos visto en capítulos anteriores,

Phi3 requiere una plantilla de solicitud específica. En comparación con nuestros
ejemplos con transformadores, necesitaremos usar una plantilla explícitamente.
En lugar de copiar y pegar esta plantilla cada vez que usamos Phi3 en LangChain, podemos
usar una de las funcionalidades principales de LangChain, concretamente las “cadenas”.
CONSEJO
Todos los ejemplos de este capítulo se pueden ejecutar con cualquier LLM. Esto significa que puede
elegir si desea utilizar Phi3, ChatGPT, Llama 3 o cualquier otro cuando revise los ejemplos.
Usaremos Phi3 como predeterminado en todo momento, pero el estado del arte cambia
rápidamente, así que considere usar un modelo más nuevo en su lugar. Puede utilizar el
Open LLM Leaderboard (una clasificación de LLM de código abierto) para elegir el que funcione mejor para usted .
caso de uso.
Si no tiene acceso a un dispositivo que pueda ejecutar LLM localmente, considere usar
ChatGPT en su lugar:
desde langchain.chat_models importar ChatOpenAI
# Crear un LLM basado en chat

chat_model = ChatOpenAI(openai_api_key="MY_KEY")
Cadenas: Ampliando las capacidades de los LLM

LangChain recibe su nombre de uno de sus métodos principales, las cadenas. Aunque
podemos ejecutar LLM de forma aislada, su potencia se demuestra cuando se utilizan con
componentes adicionales o incluso cuando se utilizan en conjunto. Las cadenas no solo
permiten ampliar las capacidades de los LLM, sino que también permiten conectar varias
cadenas entre sí.
La forma más básica de una cadena en LangChain es una cadena simple. Aunque una
cadena puede adoptar muchas formas, cada una con una complejidad diferente,
generalmente conecta un LLM con alguna herramienta, solicitud o característica adicional.
Esta idea de conectar un componente a un LLM se ilustra en la Figura 73.
Figura 73. Una sola cadena conecta algún componente modular, como una plantilla de solicitud o una
memoria externa, al LLM.
En la práctica, las cadenas pueden volverse complejas con bastante rapidez. Podemos
ampliar la plantilla de indicaciones como queramos e incluso podemos combinar
varias cadenas separadas para crear sistemas intrincados. Para comprender a fondo
lo que sucede en una cadena, exploremos cómo podemos agregar la plantilla de
indicaciones de Phi3 al LLM.
Un solo eslabón en la cadena: plantilla de propuesta

Comenzamos creando nuestra primera cadena, es decir, la plantilla de mensaje que
Phi3 espera. En el capítulo anterior, exploramos cómo
transformers.pipeline aplica la plantilla de chat automáticamente.
Este no siempre es el caso con otros paquetes y es posible que necesiten que la
plantilla de solicitud se defina explícitamente. Con LangChain, utilizaremos cadenas
para crear y utilizar una plantilla de solicitud predeterminada. También sirve como una
buena experiencia práctica con el uso de plantillas de solicitud.
La idea, como se ilustra en la Figura 74, es que encadenemos la plantilla de solicitud

junto con el LLM para obtener el resultado que buscamos. En lugar de tener que
copiar y pegar la plantilla de solicitud cada vez que usemos el LLM, solo tendríamos
que definir las solicitudes de usuario y del sistema.
Figura 74. Al encadenar una plantilla de solicitud con un LLM, solo necesitamos definir las solicitudes de entrada.
La plantilla se construirá para usted.
La plantilla para Phi3 se compone de cuatro componentes principales:
<s> para indicar cuándo comienza el mensaje
<|usuario|> para indicar el inicio del mensaje del usuario
<|assistant|> para indicar el inicio de la salida del modelo
<|end|> para indicar el final del mensaje o de la salida del modelo
Estos se ilustran con más detalle en la Figura 75 con un ejemplo.
Figura 75. La plantilla de solicitud que Phi3 espera.

Para generar nuestra cadena simple, primero debemos crear una plantilla de solicitud que
se ajuste a la plantilla esperada de Phi3. Con esta plantilla, el modelo incorpora un
system_prompt, que generalmente describe lo que esperamos del LLM. Luego,
podemos usar el input_prompt para hacerle preguntas específicas al LLM:
desde langchain importar PromptTemplate
# Crea una plantilla de solicitud con la variable "input_prompt" template = """<s><|user|> {input_prompt}
<|end|> <|assistant|>""" prompt =
PromptTemplate( template=template,
input_variables=["input_prompt"]
Para crear nuestra primera cadena, podemos utilizar tanto el mensaje que creamos como el
LLM y encadenarlos juntos:
cadena_básica = mensaje | llm
Para usar la cadena, necesitamos usar la función de invocación y asegurarnos de usar

input_prompt para insertar nuestra pregunta:
# Utilice la cadena
basic_chain.invoke( {
"input_prompt": "Hola, me llamo Maarten. ¿Cuánto es 1 + 1?"

}
)
La respuesta a 1 + 1 es 2. Es una operación aritmética básica en la que se suma una unidad a otra,
dando como resultado dos unidades en total.
El resultado nos da la respuesta sin tokens innecesarios. Ahora que hemos creado esta
cadena, no tenemos que crear la plantilla de solicitud desde cero cada vez que
usamos el LLM. Tenga en cuenta que no desactivamos el muestreo como antes,
por lo que su resultado puede ser diferente. Para que esta secuencia sea más
transparente, la Figura 76 ilustra la conexión entre una plantilla de solicitud y el LLM
usando una sola cadena.
Figura 76. Ejemplo de una cadena simple que utiliza la plantilla de Phi3.
NOTA
El ejemplo supone que el LLM necesita una plantilla específica. Esto no siempre es así. Con
GPT3.5 de OpenAI, su API maneja la plantilla subyacente.
También puede utilizar una plantilla de preguntas para definir otras variables que podrían cambiar
en sus preguntas. Por ejemplo, si queremos crear nombres divertidos para empresas, volver a
escribir esa pregunta una y otra vez para distintos productos puede llevar mucho tiempo.
En lugar de ello, podemos crear un mensaje que sea reutilizable:
# Crea una cadena que cree el nombre de nuestro negocio template = "Crea un
nombre divertido para un negocio que vende {producto}." name_prompt =
input_variables=["product"]
Agregar una plantilla de solicitud a la cadena es solo el primer paso que necesita para
mejorar las capacidades de su LLM. A lo largo de este capítulo, veremos
Hay muchas formas en las que podemos añadir componentes modulares adicionales a las cadenas
existentes, empezando por la memoria.
Una cadena con múltiples indicaciones

En nuestro ejemplo anterior, creamos una cadena única que consta de una plantilla de solicitud y
un LLM. Dado que nuestro ejemplo era bastante sencillo, el LLM no tuvo problemas para
gestionar la solicitud. Sin embargo, algunas aplicaciones son más complejas y requieren
solicitudes extensas o complejas para generar una respuesta que capture esos detalles
intrincados.
En lugar de ello, podríamos dividir este mensaje complejo en subtareas más pequeñas que se
puedan ejecutar de forma secuencial. Esto requeriría múltiples llamadas al LLM, pero con mensajes
más pequeños y resultados intermedios, como se muestra en la Figura 77.
Figura 77. En las cadenas secuenciales, la salida de un mensaje se utiliza como entrada para el mensaje siguiente.
Este proceso de uso de múltiples indicaciones es una extensión de nuestro ejemplo anterior.
En lugar de utilizar una sola cadena, enlazamos cadenas en las que cada enlace se ocupa de
una subtarea específica.
Por ejemplo, pensemos en el proceso de generar una historia. Podríamos pedirle al LLM que
genere una historia junto con detalles complejos como el título, un resumen, una
descripción de los personajes, etc. En lugar de intentar poner todos los
esa información en un solo mensaje, podríamos dividir ese mensaje en tareas más pequeñas
y manejables.
Ilustremos esto con un ejemplo. Supongamos que queremos generar una historia que tiene tres
componentes:
Un titulo
Una descripción del personaje principal.
Un resumen de la historia
En lugar de generar todo de una sola vez, creamos una cadena que solo requiere una única
entrada por parte del usuario y luego genera secuencialmente los tres componentes. Este proceso
se ilustra en la Figura 78.
Figura 78. La salida del mensaje del título se utiliza como entrada del mensaje del personaje. Para generar la
historia, se utiliza la salida de todos los mensajes anteriores.
Para generar esa historia, utilizamos LangChain para describir el primer componente, es decir,
el título. Este primer vínculo es el único componente que requiere alguna entrada del usuario.
Definimos la plantilla y utilizamos la variable "summary" como variable de entrada y "title"
como variable de salida.
Pedimos al LLM que “cree un título para una historia sobre {summary}” donde “{summary}”
será nuestro aporte:
Desde langchain, importe LLMChain

# Crea una cadena para el título de nuestra historia template = """<s><|

user|> Crea un título para una historia
sobre {summary}. Solo devuelve el título. <|end|> <|assistant|>""" title_prompt = PromptTemplate(template=template,
input_variables=
["summary"]) title = LLMChain(llm=llm, prompt=title_prompt, output_key="title")
Ejecutemos un ejemplo para mostrar estas variables:
título.invoke({"summary": "una niña que perdió a su madre"})
{'summary': 'una niña que perdió a su madre',

'title': '"Susurros de pérdida: un viaje a través del duelo"'}
¡Esto ya nos da un título genial para la historia! Tenga en cuenta que podemos
ver tanto la entrada ("resumen") como la salida ("título").
Generemos el siguiente componente, es decir la descripción del personaje.

Generamos este componente utilizando tanto el resumen como el título
generado anteriormente. Asegurándonos de que la cadena utiliza
esos componentes, creamos un nuevo mensaje con las etiquetas {summary} y
{title}:
# Crea una cadena para la descripción del personaje usando la plantilla de resumen y título = """<s><|user|>
Describe al
personaje principal de una historia sobre
{summary} con el título {title}. Usa solo dos oraciones.<|end|> <|assistant|>""" character_prompt =
PromptTemplate( template=template, input_variables=["summary", "title"]
) carácter = LLMChain(llm=llm, prompt=carácter_prompt, clave_salida="carácter")

Aunque ahora podríamos usar la variable de carácter para generar nuestra descripción
de personaje manualmente, se utilizará como parte de la cadena automatizada.
Creemos el componente final, que utiliza el resumen, el título y la descripción del

personaje para generar una breve descripción de la historia:
# Crea una cadena para la historia usando la plantilla de resumen, título y descripción
del personaje = """<s><|user|
> Crea una historia sobre
{summary} con el título {title}. El personaje principal es: {character}. Solo devuelve la
historia y no puede tener más de un párrafo. <|end|> <|assistant|>""" story_prompt =
PromptTemplate(
plantilla=plantilla, variables_de_entrada=["resumen", "título", "personaje"] )

historia =
LLMChain(llm=llm, mensaje=mensaje_de_historia,
clave_de_salida="historia")
Ahora que hemos generado los tres componentes, podemos vincularlos para
crear nuestra cadena completa:
# Combina los tres componentes para crear la cadena completa llm_chain =

título | personaje | historia
Podemos ejecutar esta cadena recién creada usando el mismo ejemplo que
usamos antes:
llm_chain.invoke("una niña que perdió a su madre")
{'summary': 'una niña que perdió a su madre', 'title': ' "En

memoria de un ser querido: un viaje a través del duelo"', 'character': 'La
protagonista, Emily, es una joven resiliente que lucha por hacer frente a su
abrumador dolor tras perder a su amada y cariñosa madre a una edad temprana. A
medida que se embarca en un viaje de autodescubrimiento y sanación, aprende
valiosas lecciones de vida a partir de los recuerdos y la sabiduría que comparten
quienes la rodean.',
'historia': " En memoria amorosa: un viaje a través del duelo gira en torno a
Emily, una joven resiliente que pierde a su amada madre a una edad temprana,
lucha por sobrellevar un dolor abrumador y emprende un viaje de autodescubrimiento
y sanación, sacando fuerzas de los preciados recuerdos y la sabiduría que comparten
quienes la rodean. A través de este proceso transformador, Emily aprende valiosas
lecciones de vida sobre la resiliencia, el amor y el poder de la conexión humana, y
finalmente encuentra consuelo al honrar el legado de su madre mientras abraza una
nueva sensación de paz interior en medio de la dolorosa pérdida.
Al ejecutar esta cadena, obtenemos los tres componentes. Para ello, solo necesitamos introducir
un único mensaje breve: el resumen. Otra ventaja de dividir el problema en tareas más pequeñas
es que ahora tenemos acceso a estos componentes individuales. Podemos extraer
fácilmente el título; ese no habría sido el caso si hubiéramos utilizado un único mensaje.
Memoria: Cómo ayudar a los estudiantes de maestría en derecho a recordar

Conversaciones
Cuando utilizamos LLM de forma predeterminada, no recuerdan lo que se dijo en una conversación.
Puedes compartir tu nombre en una solicitud, pero lo habrá olvidado en la siguiente solicitud.
Ilustremos este fenómeno con un ejemplo utilizando la cadena básica que creamos antes. Primero,
le decimos nuestro nombre al LLM:
# Vamos a darle al LLM nuestro nombre

basic_chain.invoke({"input_prompt": "Hola! Mi nombre es Maarten. ¿Cuánto es 1 + 1?"})
¡Hola Maarten! La respuesta a 1 + 1 es 2.
A continuación le pedimos que reproduzca el nombre que le hemos dado:
# A continuación, le pedimos al LLM que reproduzca el nombre

basic_chain.invoke({"input_prompt": "¿Cuál es mi nombre?"})
Lo siento, pero como modelo de lenguaje, no tengo la capacidad de conocer información

personal sobre individuos. Puedes proporcionar el nombre sobre el que te gustaría
saber más y puedo ayudarte con información o consultas generales relacionadas con
él.
Lamentablemente, el LLM no conoce el nombre que le asignamos. La razón de este

comportamiento olvidadizo es que estos modelos no tienen estado, es decir, no tienen
memoria de ninguna conversación anterior.
Como se ilustra en la Figura 79, conversar con un LLM que no tiene memoria no es la mejor
experiencia.
Para que estos modelos tengan estado, podemos agregar tipos específicos de memoria a la
cadena que creamos anteriormente. En esta sección, repasaremos dos métodos
comunes para ayudar a los LLM a recordar las conservaciones:
Buffer de conversación
Resumen de la conversación
Figura 79. Ejemplo de conversación entre un LLM con memoria y un LLM sin memoria.
Buffer de conversación
Una de las formas más intuitivas de brindarles memoria a los LLM es
simplemente recordarles exactamente lo que sucedió en el pasado. Como se
ilustra en la Figura 710, podemos lograr esto copiando el historial completo de la
conversación y pegándolo en nuestro mensaje.
Figura 710. Podemos recordarle a un LLM lo que sucedió anteriormente simplemente agregando el historial de
conversación completo al mensaje de entrada.
En LangChain, esta forma de memoria se denomina

ConversationBufferMemory. Su implementación requiere que actualicemos
nuestro mensaje anterior para guardar el historial del chat.
Comenzaremos creando este mensaje:
# Crear una plantilla de aviso actualizada para incluir una plantilla de historial de
chat = """<s><|user|> Conversación actual:{chat_history}
{input_prompt}<|fin|> <|
asistente|>"""
prompt =
PromptTemplate( plantilla=plantilla, variables_de_entrada=["indicación_de_entrada", "historial_de_c

)
Tenga en cuenta que hemos añadido una variable de entrada

adicional, llamada chat_history. Aquí se proporcionará el historial de conversaciones
antes de que le hagamos nuestra pregunta al LLM.
A continuación, podemos crear ConversationBufferMemory de LangChain y asignarlo a

la variable de entrada chat_history.
ConversationBufferMemory almacenará todas las conversaciones que hemos tenido con
el LLM hasta el momento.
Juntamos todo y encadenamos la plantilla LLM, de memoria y de indicaciones:
desde langchain.memory importar ConversationBufferMemory
# Definimos el tipo de memoria que usaremos memory =

ConversationBufferMemory(memory_key="chat_history")
# Encadenar el LLM, el indicador y la memoria juntos llm_chain =

LLMChain( prompt=prompt, llm=llm,
memory=memory
Para explorar si lo hicimos correctamente, creemos un historial de conversación con el

LLM haciéndole una pregunta simple:
# Generar una conversación y hacer una pregunta básica

llm_chain.invoke({"input_prompt": "Hola! Mi nombre es Maarten. ¿Cuánto es 1 + 1?"})
{'input_prompt': '¡Hola! Mi nombre es Maarten. ¿Cuánto es 1 + 1?', 'chat_history': ', 'text': "Hola
Maarten! La respuesta a 1 +
1 es 2. Espero que estés
¡Que tengas un gran día!"}
Puedes encontrar el texto generado en la clave 'text', el mensaje de entrada en

'input_prompt' y el historial de chat en 'chat_history'. Nota
que como es la primera vez que usamos esta cadena específica, no hay historial de chat.
A continuación, sigamos preguntando al LLM si recuerda el nombre que usamos:
# ¿El LLM recuerda el nombre que le dimos?

llm_chain.invoke({"input_prompt": "¿Cuál es mi nombre?"})
{'input_prompt': '¿Cuál es mi nombre?',

'chat_history': "Humano: ¡Hola! Mi nombre es Maarten. ¿Cuánto es 1 + 1?
\nAI: Hola Maarten! La respuesta a 1 + 1 es 2. Espero que tengas un gran día!", 'text': '
Tu nombre es Maarten.
Al ampliar la cadena con memoria, el LLM pudo usar el historial de chat para encontrar el
nombre que le habíamos asignado anteriormente. Esta cadena más compleja se ilustra en la
Figura 711 para brindar una descripción general de esta funcionalidad
adicional.
Figura 711. Extendemos la cadena LLM con memoria agregando todo el historial de conversaciones al
mensaje de entrada.
Buffer de conversación en ventana

En nuestro ejemplo anterior, creamos básicamente un chatbot. Puedes hablar con él y este
recordará la conversación que tuviste hasta el momento. Sin embargo, a medida que aumenta
el tamaño de la conversación, también lo hace el tamaño del mensaje de entrada hasta
que excede el límite de tokens.
Un método para minimizar la ventana de contexto es utilizar las últimas k

conversaciones en lugar de mantener el historial de chat completo. En LangChain,
Puede utilizar ConversationBufferWindowMemory para decidir cuántas conversaciones

se pasan al mensaje de entrada:
desde langchain.memory importar ConversationBufferWindowMemory
# Conservar solo las últimas 2 conversaciones en la memoria memory =

ConversationBufferWindowMemory(k=2, memory_key="chat_history")

memory=memory
Utilizando esta memoria, podemos probar una secuencia de preguntas para ilustrar lo que
se recordará. Empezamos con dos conversaciones:
# Haz dos preguntas y genera dos conversaciones en su memoria llm_chain.predict(input_prompt="¡Hola! Mi

nombre es Maarten y tengo 33 años. ¿Cuánto es 1 + 1?") llm_chain.predict(input_prompt="¿Cuánto es 3 +
3?")
{'input_prompt': '¿Cuánto es 3 + 3?', 'chat_history':

"Humano: ¡Hola! Mi nombre es Maarten y tengo 33 años. ¿Cuánto es 1 + 1?\nAI: ¡Hola Maarten!
Es un placer conocerte. Con respecto a tu pregunta, 1 + 1 es igual a 2. Si tienes alguna otra pregunta o
necesitas más ayuda, ¡no dudes en preguntar!\n\n(Nota: Esta respuesta responde a la consulta
matemática proporcionada manteniendo la cortesía y la apertura a consultas adicionales)",
'text': "Hola Maarten! Es un placer conocerte también.
En cuanto a tu nueva pregunta, 3 + 3 es igual a 6. Si necesitas ayuda con algo más o tienes
más preguntas, ¡estoy aquí para ayudarte!"}
La interacción que hemos tenido hasta ahora se muestra en "chat_history". Tenga en

cuenta que, en esencia, LangChain la guarda como una interacción entre
usted (indicada con Human) y el LLM (indicada con AI).
A continuación, podemos comprobar si el modelo realmente conoce el nombre que le hemos dado:
# Verifica si conoce el nombre que le dimos

llm_chain.invoke({"input_prompt":"¿Cuál es mi nombre?"})
{'input_prompt': '¿Cuál es mi nombre?', 'chat_history':

matemática proporcionada manteniendo la cortesía y la apertura para consultas adicionales).
\nHumano: ¿Cuánto es 3 + 3?\nAI: ¡Hola Maarten! Es un placer conocerte también. Con respecto a tu
nueva pregunta, 3 + 3 es igual a 6. Si hay algo más con lo que necesites ayuda o tienes más preguntas,
¡estoy aquí para ti!", 'text': '
Tu nombre es Maarten, como mencionamos al principio de nuestra conversación. ¿Hay

algo más que te gustaría saber o comentar?
Según la salida en 'texto' recuerda correctamente el nombre que le dimos. Tenga en cuenta que
el historial de chat se actualiza con la pregunta anterior.
Ahora que hemos añadido otra conversación, ya tenemos tres conversaciones.

Teniendo en cuenta que la memoria solo conserva las dos últimas conversaciones,
no recordamos nuestra primera pregunta.
Dado que proporcionamos una edad en nuestra primera interacción, verificamos si la

LLM en realidad ya no sabe la edad:
# Verifica si sabe la edad que le dimos llm_chain.invoke({"input_prompt":"¿Cuál

es mi edad?"})
{'input_prompt': '¿Cuál es mi edad?', 'chat_history':

"Humano: ¿Cuánto es 3 + 3?\nAI: ¡Hola de nuevo! 3 + 3 es igual a 6. Si hay algo más en lo que pueda
ayudarte, ¡házmelo saber!\nHumano: ¿Cuál es mi nombre?\nAI: Tu nombre es Maarten.", 'text': "No
puedo determinar tu edad ya que no tengo acceso a información personal. La edad no es algo
que se pueda
determinar
A continuación, podemos comprobar si el modelo realmente conoce el nombre que le hemos dado:
# Verifica si conoce el nombre que le dimos

llm_chain.invoke({"input_prompt":"¿Cuál es mi nombre?"})
{'input_prompt': '¿Cuál es mi nombre?', 'chat_history':

matemática proporcionada manteniendo la cortesía y la apertura para consultas adicionales).
\nHumano: ¿Cuánto es 3 + 3?\nAI: ¡Hola Maarten! Es un placer conocerte también. Con respecto a tu
nueva pregunta, 3 + 3 es igual a 6. Si hay algo más con lo que necesites ayuda o tienes más preguntas,
¡estoy aquí para ti!", 'text': '
Tu nombre es Maarten, como mencionamos al principio de nuestra conversación. ¿Hay

algo más que te gustaría saber o comentar?
Según la salida en 'texto' recuerda correctamente el nombre que le dimos. Tenga en cuenta que
el historial de chat se actualiza con la pregunta anterior.
Ahora que hemos añadido otra conversación, ya tenemos tres conversaciones.

Teniendo en cuenta que la memoria solo conserva las dos últimas conversaciones,
no recordamos nuestra primera pregunta.
Dado que proporcionamos una edad en nuestra primera interacción, verificamos si la

LLM en realidad ya no sabe la edad:
# Verifica si sabe la edad que le dimos llm_chain.invoke({"input_prompt":"¿Cuál

es mi edad?"})
{'input_prompt': '¿Cuál es mi edad?', 'chat_history':

"Humano: ¿Cuánto es 3 + 3?\nAI: ¡Hola de nuevo! 3 + 3 es igual a 6. Si hay algo más en lo que pueda
ayudarte, ¡házmelo saber!\nHumano: ¿Cuál es mi nombre?\nAI: Tu nombre es Maarten.", 'text': "No
puedo determinar tu edad ya que no tengo acceso a información personal. La edad no es algo
que se pueda
determinar
¿Qué puedo deducir de nuestra conversación actual, a menos que decida

compartirlo conmigo? ¿En qué más puedo ayudarlo hoy?"}
De hecho, el LLM no tiene acceso a nuestra edad ya que ésta no quedó registrada en el
historial del chat.
Aunque este método reduce el tamaño del historial de chat, solo puede conservar las
últimas conversaciones, lo que no es ideal para conversaciones largas.
Exploremos cómo podemos resumir el historial de chat.
Resumen de la conversación
Como hemos comentado anteriormente, es fundamental que tu LLM tenga la capacidad de
recordar conversaciones para disfrutar de una buena experiencia interactiva. Sin
embargo, al utilizar ConversationBufferMemory, la conversación comienza a
aumentar de tamaño y se acerca lentamente al límite de tokens. Aunque
ConversationBufferWindowMemory resuelve el problema de los límites de tokens hasta
cierto punto, solo se conservan las últimas k conversaciones.
Aunque una solución sería utilizar un LLM con una ventana de contexto más grande, estos
tokens aún deben procesarse antes de generar tokens, lo que puede aumentar el tiempo
de procesamiento. En su lugar, veamos una técnica más sofisticada,
ConversationSummaryMemory. Como su nombre lo indica, esta técnica resume todo el
historial de una conversación para descomponerlo en los puntos principales.
Este proceso de resumen se habilita mediante otro LLM al que se le proporciona el

historial de la conversación como entrada y se le pide que cree un resumen conciso. Una
ventaja interesante de utilizar un LLM externo es que no estamos limitados a utilizar el
mismo LLM durante la conversación. El proceso de resumen se ilustra en la Figura 712.
Figura 712. En lugar de pasar el historial de la conversación directamente al mensaje, usamos otro LLM
para resumirlo primero.
Esto significa que cada vez que le hacemos una pregunta al LLM, hay dos llamadas:
El mensaje de aviso al usuario
El mensaje de resumen
Para usar esto en LangChain, primero debemos preparar una plantilla de

resumen que usaremos como solicitud de resumen:
# Crear una plantilla de mensaje de resumen

summary_prompt_template = """<s><|user|>Resume las conversaciones y actualízalas con
las nuevas líneas.
Resumen actual: {summary}
Nuevas líneas de conversación: {new_lines}
Nuevo resumen:<|fin|> <|asistente|

>""" summary_prompt =
PromptTemplate( input_variables=["new_lines",
"summary"], template=summary_prompt_template
)
El uso de ConversationSummaryMemory en LangChain es similar a lo que hicimos

con los ejemplos anteriores. La principal diferencia es que, además,
debemos proporcionarle un LLM que realice la tarea de resumen. Aunque
utilizamos el mismo LLM tanto para el resumen como para las indicaciones
del usuario, podría utilizar un LLM más pequeño para la tarea de resumen
para acelerar el cálculo:
de langchain.memory importar ConversationSummaryMemory
# Definimos el tipo de memoria que usaremos memory =

ConversationSummaryMemory( llm=llm,
memory_key="chat_history",
prompt=summary_prompt
)
memory=memory
Una vez creada nuestra cadena, podemos probar sus capacidades de resumen
creando una conversación corta:
# Generar una conversación y preguntar por el nombre

llm_chain.invoke({"input_prompt": "Hola! Mi nombre es Maarten. ¿Cuánto es 1 + 1?"})
llm_chain.invoke({"input_prompt": "¿Cuál es mi nombre?"})
{'input_prompt': '¿Cuál es mi nombre?', 'chat_history': '

Resumen: Un humano, identificado como Maarten, preguntó a la IA sobre
la suma de 1 + 1, que fue respondida correctamente por la IA como 2 y ofreció ayuda adicional si era
necesario.
En este contexto, se hizo referencia a su nombre como "Maarten". Sin
embargo, dado que nuestra interacción no conserva datos personales más allá de una única
sesión por razones de privacidad, no tengo acceso a esa información. ¿Cómo puedo ayudarlo más
hoy?
Después de cada paso, la cadena resumirá la conversación hasta ese momento.

Observe cómo se resumió la primera conversación en 'chat_history'
creando una descripción de la conversación.
Podemos continuar la conversación y en cada paso se resumirá la conversación y se

agregará nueva información según sea necesario:
# Comprueba si ha resumido todo hasta ahora llm_chain.invoke({"input_prompt": "¿Cuál

fue la primera pregunta que hice?"})
{'input_prompt': '¿Cuál fue la primera pregunta que hice?', 'chat_history': '

Resumen: El humano, identificado como Maarten en el contexto de esta
conversación, primero preguntó sobre la suma de 1 + 1 y recibió una respuesta de 2 de la IA. Luego,
Maarten preguntó sobre su nombre, pero la IA aclaró que los datos personales no se conservan
más allá de una sola sesión por razones de privacidad. La IA ofreció más ayuda si era necesario.',
'text': 'La primera pregunta que hiciste fue "¿cuánto es 1 + 1?"'}
Después de hacer otra pregunta, el LLM actualizó el resumen para incluir la conversación
anterior e infirió correctamente la pregunta original.
Para obtener el resumen más reciente, podemos acceder a la variable de memoria que
creamos anteriormente:
# Verifica cuál es el resumen hasta el momento

memory.load_memory_variables({})
{'historial_de_chat': ' Maarten, identificado en esta conversación, inicialmente preguntó

sobre la suma de 1+1, lo que dio como resultado que la IA respondiera 2. Posteriormente, pidió
una aclaración sobre su nombre, pero la IA le informó que no se conservan datos
personales más allá de una sola sesión por razones de privacidad. La IA luego ofreció más ayuda
si era necesario. Más tarde, Maarten recordó y preguntó sobre la primera pregunta que hizo,
que fue "¿cuánto es 1+1?"
Esta cadena más compleja se ilustra en la Figura 713 para brindar una descripción general
de esta funcionalidad adicional.
Figura 713. Extendemos la cadena LLM con memoria resumiendo todo el historial de conversaciones antes
de entregárselo al mensaje de entrada.
Este resumen ayuda a mantener el historial de chat relativamente pequeño sin utilizar
demasiados tokens durante la inferencia. Sin embargo, dado que la pregunta original
no se guardó explícitamente en el historial de chat, el modelo tuvo que inferirla en función
del contexto. Esto es una desventaja si es necesario almacenar información específica en el
historial de chat. Además, se necesitan varias llamadas al mismo LLM, una para la solicitud
y otra para el resumen. Esto puede ralentizar el tiempo de procesamiento.
A menudo, se trata de un equilibrio entre velocidad, memoria y precisión. Mientras

que ConversationBufferMemory es instantánea pero acapara tokens,
ConversationSummaryMemory es lenta pero libera tokens para su uso.
En la Tabla 71 se describen ventajas y desventajas adicionales de los tipos de memoria
que hemos explorado hasta ahora .
Tabla 71. Ventajas y desventajas de los diferentes tipos de memoria.
Tipo de memoria Ventajas Contras
Conversación
Velocidad
Buffer
Implementación más sencilla de generación
más lenta a medida

Garantiza que no
que se necesitan
haya pérdida de
más tokens
información dentro de
la ventana de contexto Sólo apto para

contextos amplios
LLM (Máster en Derecho)
Los historiales
de chat más largos
dificultan la
recuperación
de información
Con ventana
Conversación Contexto amplio Solo captura las
No se necesitan últimas k
Buffer
LLM a menos que interacciones
el historial de chat
Sin compresión de las
sea extenso últimas k
No hay pérdida de interacciones
información en las
últimas k interacciones
Conversación
Captura la historia Es necesaria una
Resumen
completa llamada adicional para
cada
Permite
interacción.
conversaciones largas
Tipo de memoria Ventajas Contras
Reduce los tokens La calidad

necesarios para capturar depende de la
el historial completo
Capacidades de
resumen del LLM
Agentes: Creación de un sistema de LLM

Hasta ahora, hemos creado sistemas que siguen un conjunto de pasos definidos por el usuario. Uno de los
conceptos más prometedores de los LLM es su capacidad para determinar las acciones que pueden
realizar. Esta idea suele denominarse agentes, sistemas que aprovechan un modelo de lenguaje
para determinar qué acciones deben realizar y en qué orden.
Los agentes pueden hacer uso de todo lo que hemos visto hasta ahora, como el modelo
E/S, cadenas y memoria, y ampliarlo aún más con dos componentes vitales:
Herramientas que el agente puede utilizar para hacer cosas que no podría hacer por sí mismo
El tipo de agente, que planifica las acciones a realizar o las herramientas a utilizar.
A diferencia de las cadenas que hemos visto hasta ahora, los agentes son capaces de mostrar
comportamientos más avanzados como crear y autocorregir una hoja de ruta para alcanzar un objetivo.
Pueden interactuar con el mundo real mediante el uso de herramientas. Como resultado, estos agentes
pueden realizar una variedad de tareas que van más allá de lo que un LLM es capaz de hacer de forma
aislada.
Por ejemplo, los LLM son notoriamente malos en los problemas matemáticos y a menudo fallan en la
resolución de tareas matemáticas simples, pero podrían hacer mucho más si les proporcionamos acceso a
una calculadora. Como se ilustra en la Figura 714, la idea subyacente de los agentes es que utilizan
los LLM no solo para comprender nuestra consulta, sino también para decidir qué herramienta usar y cuándo.
Figura 714. Dar a los LLM la capacidad de elegir qué herramientas usar para un problema en particular da como
resultado un comportamiento más complejo y preciso.
En este ejemplo, esperaríamos que el LLM utilizara la calculadora cuando se enfrenta a

una tarea matemática. Ahora imaginemos que ampliamos esto con docenas de otras
herramientas, como un motor de búsqueda o una API meteorológica. De repente, las
capacidades de los LLM aumentan significativamente.
En otras palabras, los agentes que utilizan LLM pueden ser potentes solucionadores de
problemas generales. Si bien las herramientas que utilizan son importantes, la fuerza
impulsora de muchos sistemas basados en agentes es el uso de un marco llamado
Reasoning and Acting (ReAct1 ).
El poder impulsor de los agentes: paso a paso

Razonamiento
ReAct es un potente marco de trabajo que combina dos conceptos importantes del
comportamiento: razonamiento y acción. Los LLM son excepcionalmente potentes en lo que
respecta al razonamiento, como exploramos en detalle en el Capítulo 5.
La actuación es una historia un poco diferente. Los LLM no pueden actuar como tú y como
yo. Para darles la capacidad de actuar, podríamos decirles que pueden usar ciertas
herramientas, como una API de pronóstico del tiempo. Sin embargo, dado que los LLM
solo pueden generar texto, se les debería indicar que usen consultas específicas para activar
la API de pronóstico.
ReAct fusiona estos dos conceptos y permite que el razonamiento afecte a la acción y que las
acciones afecten al razonamiento. En la práctica, el marco consiste en seguir iterativamente
estos tres pasos:
Pensamiento
Acción
Observación
En la figura 715 se ilustra cómo se le pide al LLM que cree un “pensamiento” sobre la
indicación de entrada. Esto es similar a preguntarle al LLM qué cree que debería hacer a
continuación y por qué. Luego, en función del pensamiento, se desencadena una “acción”.
La acción generalmente es una herramienta externa, como una calculadora o un motor de búsqueda.
Finalmente, después de que los resultados de la “acción” se devuelven al
LLM, este “observa” la salida, que a menudo es un resumen del resultado
recuperado.
Para ilustrarlo con un ejemplo, imagina que estás de vacaciones en Estados Unidos y te
interesa comprar una MacBook Pro. No solo quieres saber el precio, sino que también
necesitas convertirlo a euros, ya que vives en Europa y te sientes más cómodo con esos
precios.
Como se ilustra en la Figura 716, el agente primero buscará en la web los precios actuales.
Puede encontrar uno o más precios según el motor de búsqueda.
Después de recuperar el precio, utilizará una calculadora para convertir USD a EUR
asumiendo que conocemos el tipo de cambio.
Figura 715. Ejemplo de una plantilla de mensaje de ReAct.

Figura 716. Un ejemplo de dos ciclos en una secuencia de ReAct.
Durante este proceso, el agente describe sus pensamientos (lo que debería hacer), sus
acciones (lo que hará) y sus observaciones (los resultados de la acción). Es un ciclo de
pensamientos, acciones y observaciones que da como resultado el resultado del agente.
ReAct en LangChain
Para ilustrar cómo funcionan los agentes en LangChain, vamos a crear una
canalización que pueda buscar respuestas en la web y realizar cálculos con una calculadora.
Estos procesos autónomos generalmente requieren un LLM que sea lo suficientemente
potente como para seguir correctamente instrucciones complejas.
El modelo LLM que hemos utilizado hasta ahora es relativamente pequeño y no es suficiente
para ejecutar estos ejemplos. En su lugar, utilizaremos el modelo GPT3.5 de OpenAI, ya
que sigue estas instrucciones complejas con mayor precisión:
importar
sistema operativo desde langchain_openai importar ChatOpenAI
# Cargar los LLM de OpenAI con LangChain

os.environ["OPENAI_API_KEY"] = "MY_KEY" openai_llm =
ChatOpenAI(model_name="gpt3.5turbo", temperature=0)
NOTA
Aunque el LLM que utilizamos a lo largo del capítulo es insuficiente para este ejemplo, no
significa que solo los LLM de OpenAI lo sean. Existen LLM más grandes y útiles, pero requieren
significativamente más computación y VRAM. Por ejemplo, los LLM locales suelen venir en
diferentes tamaños y dentro de una familia de modelos, aumentar el tamaño de un modelo
conduce a un mejor rendimiento. Para mantener la computación necesaria al mínimo, elegimos
un LLM más pequeño en todos los ejemplos de este capítulo.
Sin embargo, a medida que evoluciona el campo de los modelos generativos, también lo hacen estos
LLM más pequeños. No nos sorprendería en absoluto que, con el tiempo, LLM más pequeños, como el
que se utilizó en este capítulo, fueran capaces de ejecutar este ejemplo.
Después de hacer esto, definiremos la plantilla para nuestro agente. Como

hemos mostrado antes, describe los pasos de ReAct que debe seguir:
# Crea la plantilla ReAct react_template =

"""Responde las siguientes preguntas lo mejor que puedas. Tienes acceso a las siguientes herramientas:
{herramientas}
Utilice el siguiente formato:
Pregunta: la pregunta de entrada que debes responder Pensamiento:

siempre debes pensar en qué hacer Acción: la acción a tomar debe ser una de
[{tool_names}]
Entrada de acción: la entrada a la acción Observación: el
resultado de la acción... (este Pensamiento/Acción/Entrada de
acción/Observación puede repetirse N veces)
Pensamiento: Ahora sé la respuesta final Respuesta final: la

respuesta final a la pregunta de entrada original
¡Comenzar!
Pregunta: {entrada}
Pensamiento:{agent_scratchpad}"""
aviso = PromptTemplate(
plantilla=react_template,
variables_de_entrada=["herramientas", "nombres_de_herramientas",
"entrada",
"bloc_de_apuntes_del_agente"] )
Esta plantilla ilustra el proceso de comenzar con una pregunta y generar pensamientos,
acciones y observaciones intermedias.
Para que el LLM interactúe con el mundo exterior, describiremos las herramientas que puede
utilizar:
de langchain.agents importa load_tools, Herramienta de

langchain.tools importa DuckDuckGoSearchResults
# Puede crear la herramienta para pasar a un agente search =

DuckDuckGoSearchResults() search_tool =
Tool( name="duckduck",
description="Un motor
de búsqueda web. Use esto como una búsqueda
motor para consultas generales.",
func=search.run,
)
# Preparar herramientas
tools = load_tools (["llmmath"], llm=openai_llm) tools.append(search_tool)
Las herramientas incluyen DuckDuckGo motor de búsqueda y una herramienta matemática

que permite acceder a una calculadora básica.
Finalmente, creamos el agente ReAct y lo pasamos al AgentExecutor, que se encarga de

ejecutar los pasos:
desde langchain.agents importar AgentExecutor, create_react_agent

# Construya el agente ReAct agente =

create_react_agent (openai_llm, tools, prompt) agente_ejecutor =
AgentExecutor( agente=agente, tools=tools,
verbose=True, handle_parsing_errors=True )
Para comprobar si el agente funciona, utilizamos el ejemplo anterior, es decir,

encontrar el precio de un MacBook Pro:
# ¿Cuál es el precio de una MacBook Pro? agent_executor.invoke( {
"input": "¿Cuál es el precio actual de una MacBook Pro en dólares estadounidenses? ¿Cuánto
costaría en euros si el tipo de cambio es 0,85 euros por 1 dólar estadounidense? "
Durante la ejecución, el modelo genera múltiples pasos intermedios similares a los

pasos ilustrados en la Figura 717.
Figura 717. Un ejemplo del proceso ReAct en LangChain.
Estos pasos intermedios ilustran cómo el modelo procesa la plantilla de ReAct y

a qué herramientas accede. Esto nos permite depurar problemas y explorar si el
agente usa las herramientas correctamente.
Una vez terminado, el modelo nos da un resultado como este:
{'input': '¿Cuál es el precio actual de una MacBook Pro en USD?

¿Cuánto costaría en EUR si el tipo de cambio es 0,85 EUR por 1 USD?
'output': 'El precio actual de una MacBook Pro en USD es

2.249,00 dólares. Costaría aproximadamente 1.911,65 euros con un tipo de

cambio de 0,85 euros por 1 dólar estadounidense.
Teniendo en cuenta las herramientas limitadas que tiene el agente, ¡esto es bastante impresionante!
Con solo usar un motor de búsqueda y una calculadora, el agente podría darnos una respuesta.
Se debe tener en cuenta si esa respuesta es realmente correcta. Al crear este comportamiento
relativamente autónomo, no participamos en los pasos intermedios. Por lo tanto, no hay ningún
ser humano en el circuito que pueda juzgar la calidad del resultado o del proceso de
razonamiento.
Esta espada de doble filo requiere un diseño cuidadoso del sistema para mejorar su fiabilidad. Por
ejemplo, podríamos hacer que el agente devuelva la URL del sitio web donde encontró el precio de
la MacBook Pro o preguntar si el resultado es correcto en cada paso.
Resumen
En este capítulo, exploramos varias formas de ampliar las capacidades de los LLM mediante la
incorporación de componentes modulares. Comenzamos creando una cadena simple pero reutilizable
que conectaba el LLM con una plantilla de indicaciones. Luego, ampliamos este concepto agregando
memoria a la cadena, lo que permitió que el LLM recordara conversaciones. Exploramos tres métodos
diferentes para agregar memoria y analizamos sus fortalezas y debilidades.
Luego, nos adentramos en el mundo de los agentes que utilizan LLM para determinar sus acciones
y tomar decisiones. Exploramos el marco ReAct, que utiliza un marco de indicaciones intuitivo que
permite a los agentes razonar sobre sus pensamientos, tomar acciones y observar los resultados.
Esto nos llevó a crear un agente que puede usar libremente las herramientas a su disposición, como
buscar en la web y usar una calculadora, lo que demuestra el poder potencial de los agentes.
Con esta base establecida, ahora estamos preparados para explorar formas en las que los LLM
pueden usarse para mejorar los sistemas de búsqueda existentes e incluso convertirse en el núcleo
de sistemas de búsqueda nuevos y más poderosos, como se analiza en el próximo capítulo.
1
Shunyu Yao et al. “ReAct: Sinergia entre razonamiento y acción en modelos lingüísticos”. arXiv
OceanofPDF.com
Capítulo 8. Búsqueda y recuperación

semántica: generación aumentada
La búsqueda fue una de las primeras aplicaciones de modelos de lenguaje que

tuvo una amplia adopción en la industria. Meses después de la publicación del
artículo seminal “BERT: Pretraining of deep bidirectional transformers for language
understanding” (2018), Google anunció que lo estaba usando para impulsar la
Búsqueda de Google y que representaba “Uno de los mayores avances en la historia
de las búsquedas”. Para no quedarse atrás, Microsoft Bing también declaró que “A
partir de abril de este año, utilizamos modelos de transformadores de gran tamaño
para ofrecer las mayores mejoras de calidad a nuestros clientes de Bing en el último año”.
Este es un claro testimonio del poder y la utilidad de estos modelos. Su incorporación

mejora instantánea y drásticamente algunos de los sistemas más maduros y mejor
mantenidos de los que dependen miles de millones de personas en todo el planeta.
La capacidad que añaden se llama búsqueda semántica, que permite buscar por
significado y no simplemente por palabras clave.
Por otra parte, la rápida adopción de modelos de generación de texto llevó a muchos
usuarios a plantearles preguntas y esperar respuestas basadas en hechos. Y, si bien los
modelos podían responder con fluidez y seguridad, sus respuestas no siempre eran
correctas o actualizadas. Este problema llegó a conocerse como “alucinaciones”
de los modelos, y una de las principales formas de reducirlo es construir
sistemas que puedan recuperar información relevante y proporcionársela al LLM para
ayudarlo a generar respuestas más basadas en hechos. Este método, llamado RAG, es
una de las aplicaciones más populares de los LLM.
Descripción general de la búsqueda semántica y RAG

Hay muchas investigaciones sobre cómo utilizar mejor los modelos de lenguaje para la búsqueda.
Tres grandes categorías de estos modelos son la recuperación densa, la reclasificación y la RAG. A
continuación, se ofrece una descripción general de estas tres categorías que se explicarán con
más detalle en el resto del capítulo:
Recuperación densa
Los sistemas de recuperación densa se basan en el concepto de incrustaciones, el mismo

concepto que hemos encontrado en los capítulos anteriores, y convierten el problema de búsqueda
en la recuperación de los vecinos más cercanos de la consulta de búsqueda (después de que tanto
la consulta como los documentos se convierten en incrustaciones).
La figura 81 muestra cómo la recuperación densa toma una consulta de búsqueda, consulta su
archivo de textos y genera un conjunto de resultados relevantes.
Figura 81. La recuperación densa es uno de los tipos clave de búsqueda semántica, que se basa en la similitud
de incrustaciones de texto para recuperar resultados relevantes.
Reclasificación
Los sistemas de búsqueda suelen ser secuencias de varios pasos. Un modelo de lenguaje
de reclasificación es uno de estos pasos y su tarea es puntuar los resultados.
Relevancia de un subconjunto de resultados en relación con la consulta; luego, el orden de los resultados se
modifica en función de estas puntuaciones. La Figura 82 muestra en qué se diferencian los rerankers de la
recuperación densa en que toman una entrada adicional: un conjunto de resultados de búsqueda de un paso
anterior en el proceso de búsqueda.
Figura 82. Los rerankers, el segundo tipo clave de búsqueda semántica, toman una consulta de búsqueda y una
recopilación de resultados y reordenarlos por relevancia, lo que a menudo produce resultados enormemente mejorados.
TRAPO
La creciente capacidad de generación de texto de LLM dio lugar a un nuevo tipo de sistemas de búsqueda
que incluyen un modelo que genera una respuesta a una consulta. La figura 83 muestra un ejemplo
de un sistema de búsqueda generativo de este tipo.
La búsqueda generativa es un subconjunto de una categoría más amplia de sistemas, mejor conocidos como
sistemas RAG. Se trata de sistemas de generación de texto que incorporan capacidades de búsqueda
para reducir las alucinaciones, aumentar la veracidad y/o fundamentar el modelo de generación en
un conjunto de datos específico.

Figura 83. Un sistema RAG formula una respuesta a una pregunta y (preferiblemente) cita su información
fuentes.
El resto del capítulo cubre estos tres tipos de sistemas con más detalle.
Si bien estas son las categorías principales, no son las únicas aplicaciones
de LLM en el dominio de la búsqueda.
Búsqueda semántica con modelos de lenguaje

Ahora, analicemos con más detalle las principales categorías de sistemas que pueden
mejorar las capacidades de búsqueda de nuestros modelos de lenguaje. Comenzaremos
con la recuperación densa y luego pasaremos a la reclasificación y la RAG.
Recuperación densa
Recuerde que las incrustaciones convierten el texto en representaciones numéricas. Estas

pueden considerarse como puntos en el espacio, como podemos ver en la Figura 84.
Los puntos que están cerca entre sí significan que el texto que representan es
similar. Por lo tanto, en este ejemplo, el texto 1 y el texto 2 son más similares entre sí
(porque están cerca uno del otro) que el texto 3 (porque está más alejado).
Figura 84. La intuición de las incrustaciones: cada texto es un punto y los textos con significado similar están cerca unos
de otros.
Esta es la propiedad que se utiliza para crear sistemas de búsqueda. En este escenario,
cuando un usuario ingresa una consulta de búsqueda, incrustamos la consulta, proyectándola
así en el mismo espacio que nuestro archivo de texto. Luego, simplemente encontramos los
documentos más cercanos a la consulta en ese espacio, y esos serían los resultados de la
búsqueda (Figura 85).
Figura 85. La recuperación densa se basa en la propiedad de que las consultas de búsqueda estarán cerca de sus resultados
relevantes.
A juzgar por las distancias en la Figura 85, “texto 2” es el mejor resultado para esta consulta,
seguido de “texto 1”. Sin embargo, aquí podrían surgir dos preguntas:
¿Debería devolverse el texto 3 como resultado? Esa es una decisión que debe tomar
usted, el diseñador del sistema. A veces es conveniente tener un umbral máximo de

puntuación de similitud para filtrar los resultados irrelevantes (en caso de que el corpus
no tenga resultados relevantes para la consulta).
¿Una consulta y su mejor resultado son semánticamente similares? No siempre.

Por eso es necesario entrenar los modelos lingüísticos con pares pregunta
respuesta para mejorar su capacidad de recuperación. Este proceso se
explica con más detalle en el Capítulo 10.
La figura 86 muestra cómo dividimos un documento en fragmentos antes de proceder a incrustar
cada fragmento. Luego, esos vectores de incrustación se almacenan en la base de datos de vectores
y están listos para su recuperación.
Figura 86. Conversión de una base de conocimiento externa a una base de datos vectorial. A continuación, podemos consultar esta
base de datos vectorial para obtener información sobre la base de conocimiento.
Ejemplo de recuperación densa
Veamos un ejemplo de recuperación densa utilizando Cohere para buscar la película Interstellar
en la página de Wikipedia. En este ejemplo, haremos lo siguiente:
1. Obtenga el texto que queremos que se pueda buscar y aplique algo de luz.
procesando para dividirlo en oraciones.
2. Incruste las oraciones.
3. Construye el índice de búsqueda.
4. Busque y vea los resultados.
Obtén tu clave API de Cohere registrándote en https://oreil.ly/GxrQ1. Péguelo en el código

siguiente. No tendrá que pagar nada para ejecutar este ejemplo.
Importemos las bibliotecas que necesitaremos:
importar cohere
desde tqdm importar tqdm
# Pegue aquí su clave API. Recuerde no compartirla públicamente.

"
clave api =
# Crear y recuperar una clave API de Cohere desde os.cohere.ai

co = cohere.Cliente(clave_api)
Obtener el archivo de texto y dividirlo en fragmentos
Utilicemos la primera sección del artículo de Wikipedia sobre la película Interstellar.

Obtendremos el texto y luego lo dividiremos en oraciones:
"""
Interstellar
es una película épica de ciencia ficción de 2014 coescrita,
dirigida y producida por Christopher Nolan.
Está protagonizada por Matthew McConaughey, Anne Hathaway, Jessica Chastain,
Bill Irwin, Ellen Burstyn, Matt Damon y Michael Caine.
Ambientado en un futuro distópico donde la humanidad está luchando por...
Sobrevivir, la película sigue a un grupo de astronautas que viajan
a través de un agujero de gusano cerca de Saturno en busca de un nuevo hogar para
humanidad.
Los hermanos Christopher y Jonathan Nolan escribieron el guión,

que tuvo su origen en un guión que Jonathan desarrolló en 2007.
Físico teórico de Caltech y premio Nobel de Física en 2017
Física[4] Kip Thorne fue productor ejecutivo, actuó como
consultor científico y escribió un libro complementario, The Science of
Interestelar.
El director de fotografía Hoyte van Hoytema lo filmó en una película de 35 mm en
el formato anamórfico Panavision y IMAX 70 mm.
La fotografía principal comenzó a finales de 2013 y se llevó a cabo en
Alberta, Islandia y Los Ángeles.
Interstellar utiliza amplios efectos prácticos y en miniatura.
La empresa Double Negative creó efectos digitales adicionales.
Interstellar se estrenó el 26 de octubre de 2014 en Los Ángeles.

En Estados Unidos se estrenó por primera vez en formato película.
expandiéndose a lugares que utilizan proyectores digitales.
La película recaudó en todo el mundo más de 677 millones de dólares (y 773 millones de dólares en taquilla).
millones con relanzamientos posteriores), lo que lo convierte en el décimo más alto
Película más taquillera del 2014.
Recibió elogios por sus actuaciones, dirección, guión,
Banda sonora, efectos visuales, ambición, temas y emociones.
peso.
También ha recibido elogios de muchos astrónomos por su
Precisión científica y representación de la astrofísica teórica.
Desde su estreno, Interstellar ganó un seguimiento de culto,[5] y
Ahora es considerada por muchos expertos en ciencia ficción como una de las mejores películas
de ciencia ficción de todos los tiempos.
Interstellar fue nominada a cinco premios en la 87.ª edición de los Premios Óscar, ganó el premio a los mejores efectos
visuales y recibió numerosos otros galardones.
# Dividir en una lista de oraciones textos =

text.split('.')
# Limpiar para eliminar espacios vacíos y nuevas líneas texts = [t.strip('

\n') for t in texts]
Incorporación de fragmentos de texto
Incorporemos ahora los textos. Los enviaremos a la API de Cohere y obtendremos un vector para
cada texto:
# Obtener la respuesta de
incrustaciones =
co.embed( texts=texts,
input_type="search_document", ).embeddings
incrustaciones = np.array(respuesta)
print(incrustaciones.forma)
Esto genera (15, 4096), lo que indica que tenemos 15 vectores, cada uno de tamaño 4096.
Construyendo el índice de búsqueda
Antes de poder realizar una búsqueda, debemos crear un índice de búsqueda. Un índice
almacena las incrustaciones y está optimizado para recuperar rápidamente los puntos vecinos
más cercanos, incluso si tenemos una gran cantidad de puntos:
importar faiss dim

= embeds.shape[1] índice =
faiss.IndexFlatL2(dim) imprimir(índice.is_trained)
índice.add(np.float32(embeds))
Buscar en el índice
Ahora podemos buscar en el conjunto de datos utilizando cualquier consulta que queramos.
Simplemente incorporamos la consulta y presentamos su incorporación al índice, que
recuperará la oración más similar del artículo de Wikipedia.
Definamos nuestra función de búsqueda:
def búsqueda(consulta, numero_de_resultados=3):
# 1. Obtenga la incrustación de la consulta

query_embed = co.embed(texts=[query],
tipo_de_entrada="consulta_de_búsqueda",).incrustaciones[0]
# 2. Recuperar las distancias de los vecinos más cercanos

similar_item_ids =,
index.search(np.float32([query_embed]), number_of_results)
# 3. Formatear los resultados texts_np

= np.array(texts) # Convertir la lista de textos a numpy para
Resultados de indexación
más fáciles = pd.DataFrame(data={'texts':
texts_np[similar_item_ids[0]], 'distance':
distances[0]})
# 4. Imprimir y devolver los resultados
print(f"Consulta: '{consulta}'\nVecinos más cercanos :") devuelve resultados
¡Ahora estamos listos para escribir una consulta y buscar los textos!
consulta = "qué tan precisa fue la ciencia" resultados =

búsqueda(consulta) resultados
Esto produce el siguiente resultado:
Pregunta: ¿Qué tan precisa fue la ciencia?

Vecinos más cercanos:
textos distancia
0 También ha recibido elogios de muchos 10757.379883

astrónomos por su precisión
científica y su representación de la
astrofísica teórica.
1 Físico teórico de Caltech y 11566.131836

Premio Nobel 2017 en
Física[4] Kip Thorne fue productor
ejecutivo, actuó como consultor
científico y escribió un libro
complementario, The Science of
Interestelar
2 Interstellar utiliza una amplia gama de 11922.833008

Efectos prácticos y en miniatura de
la empresa Double
El negativo creó efectos digitales
adicionales
El primer resultado tiene la menor distancia y por tanto es el más similar a la consulta.
Al observarlo, responde perfectamente a la pregunta. Tenga en cuenta que esto no habría
sido posible si solo estuviéramos haciendo una búsqueda de palabras clave porque el
resultado principal no incluía las mismas palabras clave en la consulta.
De hecho, podemos comprobarlo definiendo una función de búsqueda de palabras

clave para comparar ambos. Utilizaremos el algoritmo BM25, que es uno de los
principales métodos de búsqueda léxica. Consulte este cuaderno Para la fuente de estos
fragmentos de código:
desde rank_bm25 importar BM25Okapi

desde sklearn.feature_extraction importar _stop_words importar
cadena
def bm25_tokenizer(texto):
tokenized_doc = [] para
token en texto.lower().split(): token =
token.strip(cadena.puntuación)
si len(token) > 0 y token no está en

_stop_words.ENGLISH_STOP_WORDS:
tokenized_doc.append(token)
devolver tokenizado_doc
tokenized_corpus = [] para el
pasaje en tqdm(textos):
tokenized_corpus.append(bm25_tokenizer(pasaje))
bm25 = BM25Okapi(corpus_tokenizado)
def keyword_search(consulta, top_k=3, num_candidates=15): print("Pregunta

de entrada:", consulta)
##### Búsqueda BM25 (búsqueda léxica) #####

bm25_scores = bm25.get_scores(bm25_tokenizer(query)) top_n =
np.argpartition(bm25_scores, num_candidates)[ num_candidates:] bm25_hits =
[{'corpus_id': idx,
'score': bm25_scores[idx]} para
idx en top_n]
bm25_hits = ordenado(bm25_hits, clave=lambda x: x['puntuación'],
reverso=Verdadero)
print(f"Los 3 principales resultados de búsqueda léxica

(BM25)") para el resultado en
bm25_hits[0:top_k]: print("\t{:.3f}\t{}".format(hit['score'],
textos[hit['corpus_id']].replace("\n", " ")))
Ahora, cuando buscamos la misma consulta, obtenemos un conjunto diferente de resultados

de la búsqueda de recuperación densa:
keyword_search(consulta = "qué tan precisa fue la ciencia")

Resultados:
Pregunta de entrada: ¿Qué tan precisa fue la búsqueda

léxica científica Top3 (BM25) llega a 1.789
Interstellar es una película épica de ciencia ficción de 2014
coescrito, dirigido y producido por Christopher Nolan 1.373 Físico teórico
de Caltech y Nobel 2017
Laureado en Física[4] Kip Thorne fue productor ejecutivo, actuó como consultor científico y escribió un
libro complementario, The Science of Interstellar 0.000. Está protagonizada por Matthew McConaughey,
Anne Hathaway, Jessica Chastain, Bill
Irwin, Ellen Burstyn, Matt Damon y Michael Caine.
Tenga en cuenta que el primer resultado no responde realmente a la pregunta a pesar de que comparte
la palabra "ciencia" con la consulta. En la siguiente sección, veremos cómo agregar un reranker puede
mejorar este sistema de búsqueda. Pero antes de eso, completemos nuestra descripción general de la
recuperación densa observando sus advertencias y repasando algunos métodos para dividir textos en
fragmentos.
Advertencias sobre la recuperación densa
Es útil conocer algunos de los inconvenientes de la recuperación densa y cómo abordarlos. ¿Qué sucede, por
ejemplo, si los textos no contienen la respuesta? Aún así, obtenemos los resultados y sus distancias. Por
ejemplo:
Consulta:'¿Cuál es la masa de la luna?'

Vecinos más cercanos:
textos distancia
0 La película recaudó en todo el mundo 1.298275

más de 677 millones de dólares (y
773 millones con los relanzamientos
posteriores), lo que la convirtió en la
décima película más taquillera de 2014.
1 También ha recibido elogios de 1.324389

muchos astrónomos por su
precisión científica y su representación
de la astrofísica teórica.
2 El director de fotografía Hoyte van 1.328375

Hoytema lo filmó en película de 35 mm
en Panavision.
formato anamórfico e IMAX 70
mm
En casos como este, una posible heurística es establecer un nivel de umbral (una
distancia máxima de relevancia, por ejemplo). Muchos sistemas de búsqueda presentan
al usuario la mejor información que pueden obtener y dejan que el usuario decida si es
relevante o no. Realizar un seguimiento de la información sobre si el usuario hizo clic en
un resultado (y quedó satisfecho con él) puede mejorar las versiones futuras del sistema de
búsqueda.
Otra advertencia de la recuperación densa es cuando un usuario quiere encontrar una coincidencia
exacta para una frase específica. Ese es un caso perfecto para la coincidencia de palabras
clave. Esa es una de las razones por las que se recomienda la búsqueda híbrida, que incluye
tanto la búsqueda semántica como la búsqueda de palabras clave, en lugar de confiar únicamente en la
recuperación densa.
Los sistemas de recuperación densa también tienen dificultades para funcionar

correctamente en dominios distintos de aquellos en los que fueron entrenados. Por ejemplo, si
Si entrenas un modelo de recuperación con datos de Internet y Wikipedia, y luego lo implementas

en textos legales (sin tener suficientes datos legales como parte del conjunto de entrenamiento),
el modelo no funcionará tan bien en ese dominio legal.
Lo último que nos gustaría señalar es que este es un caso en el que cada oración contenía
un fragmento de información y mostramos consultas que solicitaban específicamente esa
información. ¿Qué sucede con las preguntas cuyas respuestas abarcan varias oraciones? Esto
pone de relieve uno de los parámetros de diseño importantes de los sistemas de
recuperación densos: ¿cuál es la mejor manera de fragmentar textos largos? ¿Y por qué
necesitamos fragmentarlos en primer lugar?
Fragmentación de textos largos
Una limitación de los modelos de lenguaje Transformer es que están limitados en cuanto al
tamaño de los contextos, lo que significa que no podemos incluir textos muy largos que superen
la cantidad de palabras o tokens que admite el modelo. Entonces, ¿cómo integramos textos
largos?
Hay varias formas posibles, y dos enfoques posibles que se muestran en la Figura 87
incluyen la indexación de un vector por documento y la indexación de múltiples vectores por
documento.
Figura 87. Es posible crear un vector que represente un documento completo, pero es mejor dividir los
documentos más largos en fragmentos más pequeños que tengan sus propias incrustaciones.
Un vector por documento
En este enfoque, utilizamos un único vector para representar todo el documento.

Las posibilidades aquí incluyen:
Incrustar solo una parte representativa del documento e ignorar el resto del
texto. Esto puede significar incrustar solo el título o solo el comienzo del documento.
Esto es útil para comenzar rápidamente a crear una demostración, pero deja mucha
información sin indexar y, por lo tanto, no se puede buscar. Como enfoque,
puede funcionar mejor para documentos en los que el comienzo captura
los puntos principales de un documento (piense en un artículo de Wikipedia).
Pero realmente no es el mejor enfoque para un sistema real porque mucha información
quedaría fuera del índice y no sería posible buscarla.
Incorporar el documento en fragmentos, incorporar esos fragmentos y luego agregarlos

en un único vector. El método habitual de agregación aquí es promediar esos
vectores. Una desventaja de este enfoque es que da como resultado un vector altamente
comprimido que pierde gran parte de la información del documento.
Este enfoque puede satisfacer algunas necesidades de información, pero no otras. Muchas
veces, la búsqueda se centra en un fragmento de información específico contenido en un
artículo, que se capta mejor si el concepto tiene su propio vector.
Múltiples vectores por documento
En este enfoque, dividimos el documento en fragmentos más pequeños y los incrustamos.

Nuestro índice de búsqueda se convierte entonces en el de incrustaciones de fragmentos, no
en el de incrustaciones de documentos completos. La Figura 88 muestra una serie de posibles
enfoques de fragmentación de texto.
Figura 88. Varios métodos de fragmentación y sus efectos en el texto de entrada. La superposición de fragmentos puede
ser importante para evitar la ausencia de contexto.
El método de fragmentación es mejor porque cubre todo el texto y porque los vectores
tienden a capturar conceptos individuales dentro del texto. Esto genera un índice de
búsqueda más expresivo. La Figura 89 muestra varios métodos posibles.
Figura 89. Varias opciones posibles para dividir un documento en fragmentos para su incrustación.
La mejor manera de dividir un texto largo en fragmentos dependerá de los tipos de

textos y consultas que anticipe su sistema. Los enfoques incluyen:
Cada oración es un fragmento. El problema es que podría ser demasiado granular y
los vectores no captan una parte suficiente del contexto.
Cada párrafo es un fragmento. Esto es genial si el texto está formado por párrafos cortos.
De lo contrario, puede suceder que cada 3 a 8 oraciones sea un fragmento.
Algunos fragmentos obtienen gran parte de su significado del texto que los rodea, por lo
que podemos incorporar algo de contexto mediante:
Añadiendo el título del documento al fragmento.
Añadiendo parte del texto antes y después de ellos al fragmento. De esta

manera, los fragmentos pueden superponerse para incluir parte del texto
circundante que también aparece en fragmentos adyacentes. Esto es lo
que podemos ver en la Figura 810.
Es de esperar que surjan más estrategias de fragmentación a medida que el campo se desarrolle,
algunas de las cuales pueden incluso usar LLM para dividir dinámicamente un texto en fragmentos
significativos.
Figura 810. Dividir el texto en segmentos superpuestos es una estrategia para retener más contexto
en torno a los diferentes segmentos.
Búsqueda del vecino más cercano versus bases de datos vectoriales
Una vez que la consulta está incorporada, necesitamos encontrar los vectores más cercanos a ella en
nuestro archivo de texto, como podemos ver en la Figura 811. La forma más sencilla de encontrar los
vecinos más cercanos es calcular las distancias entre la consulta y el archivo. Esto se puede hacer
fácilmente con NumPy y es un enfoque razonable si tiene miles o decenas de miles de vectores en su
archivo.
Figura 811. Como vimos en el Capítulo 3, podemos comparar incrustaciones para encontrar rápidamente los documentos
más similares a una consulta.
A medida que se amplía la escala hasta los millones de vectores, un enfoque optimizado
para la recuperación es confiar en bibliotecas de búsqueda de vecinos más cercanos
aproximados como Annoy o FAISS. Estas le permiten recuperar resultados de índices
masivos en milisegundos y algunas de ellas pueden mejorar su rendimiento mediante
el uso de GPU y la escalabilidad a grupos de máquinas para brindar servicios a
índices muy grandes.
Otra clase de sistemas de recuperación de vectores son las bases de datos vectoriales como
Weaviate o Pinecone. Una base de datos vectorial permite agregar o eliminar vectores sin
tener que reconstruir el índice. También proporcionan formas de filtrar la búsqueda o
personalizarla de maneras que van más allá de las distancias vectoriales.
Ajuste fino de los modelos de incrustación para una recuperación densa
Tal como lo analizamos en el Capítulo 4 sobre la clasificación de texto, podemos mejorar el

rendimiento de un LLM en una tarea mediante el ajuste fino. En ese caso, la
recuperación debe optimizar las incrustaciones de texto y no simplemente las
incrustaciones de tokens. El proceso para este ajuste fino es obtener datos de
entrenamiento compuestos de consultas y resultados relevantes.
Veamos un ejemplo de nuestro conjunto de datos: la frase “Interstellar se estrenó el 26 de

octubre de 2014 en Los Ángeles”. Dos posibles consultas en las que este es un resultado relevante
son:
Consulta relevante 1: “Fecha de lanzamiento de Interstellar”
Pregunta relevante 2: “¿Cuándo se estrenó Interstellar?”
El proceso de ajuste fino tiene como objetivo hacer que las incrustaciones de estas consultas sean
cercanas a la incrustación de la oración resultante. También necesita ver ejemplos negativos de
consultas que no son relevantes para la oración, por ejemplo:
Consulta irrelevante: “Reparto interestelar”
Con estos ejemplos, ahora tenemos tres pares: dos pares positivos y un par negativo. Supongamos,
como podemos ver en la Figura 812, que antes del ajuste, las tres consultas tienen la misma
distancia del documento de resultados.
Eso no es descabellado porque todos hablan de Interstellar.
Figura 812. Antes de realizar el ajuste, las incrustaciones de consultas relevantes e irrelevantes pueden estar cerca
de un documento en particular.
El paso de ajuste fino sirve para acercar las consultas relevantes al documento y, al mismo
tiempo, alejar las consultas irrelevantes. Podemos ver este efecto en la Figura 813.
Figura 813. Después del proceso de ajuste, el modelo de incorporación de texto mejora en esta tarea de búsqueda al
incorporar la forma en que definimos la relevancia en nuestro conjunto de datos utilizando los ejemplos que
proporcionamos de documentos relevantes e irrelevantes.
Reclasificación
Muchas organizaciones ya han creado sistemas de búsqueda. Para ellas, una forma
más sencilla de incorporar modelos de lenguaje es como paso final dentro de su flujo de
búsqueda. Este paso tiene la tarea de cambiar el orden de los resultados de búsqueda en función
de la relevancia de la consulta de búsqueda. Este paso puede mejorar enormemente los
resultados de búsqueda y, de hecho, es lo que Microsoft Bing agregó para lograr las mejoras en los
resultados de búsqueda utilizando modelos similares a BERT.
La figura 814 muestra la estructura de un sistema de búsqueda de reranking que sirve como
segunda etapa en un sistema de búsqueda de dos etapas.
Figura 814. Los rerankers LLM funcionan como parte de un proceso de búsqueda con el objetivo de reordenar una
serie de resultados de búsqueda preseleccionados por relevancia.
Ejemplo de reranking Un reranker
toma la consulta de búsqueda y una cantidad de resultados de búsqueda, y devuelve el orden óptimo de estos
documentos para que los más relevantes para la consulta tengan un lugar más alto en la clasificación. Punto final
Rerank de Cohere es una forma sencilla de empezar a utilizar un primer reranker. Simplemente le pasamos la
consulta y los textos y obtenemos los resultados. No necesitamos entrenarlo ni ajustarlo:
consulta = "qué tan precisa fue la ciencia" resultados =

co.rerank(consulta=consulta, documentos=textos, top_n=3, return_documents=True)
resultados.resultados
Podemos imprimir estos resultados:
para idx, el resultado se enumera en enumerate(results.results): print(idx,

result.relevance_score , resultado.documento.texto)
Producción:
0 0.1698185 También ha recibido elogios de muchos astrónomos por su precisión científica y su

representación de la astrofísica teórica. 1 0.07004896 La película recaudó en todo el mundo
más de 677 millones
de dólares.
(y 773 millones de dólares con relanzamientos posteriores), lo que la convierte en la décima película
más taquillera de 2014 2 0,0043994132 Físico teórico de
Caltech y premio Nobel de Física de 2017[4] Kip Thorne fue productor ejecutivo, actuó como consultor
científico y escribió un libro complementario, The Science of Interstellar
Esto demuestra que el reranker tiene mucha más confianza en el primer resultado y le asigna una
puntuación de relevancia de 0,16, mientras que los demás resultados reciben una puntuación de
relevancia mucho menor.
En este ejemplo básico, pasamos a nuestro reranker todos nuestros 15 documentos.

Sin embargo, lo más frecuente es que nuestro índice tenga miles o millones de entradas y necesitemos
seleccionar, digamos, cien o mil resultados y luego presentárselos al rerankeador. Este paso de selección
se denomina primera etapa del proceso de búsqueda.
El recuperador de primera etapa puede ser una búsqueda por palabras clave, una recuperación densa o, mejor
aún, una búsqueda híbrida que utilice ambas. Podemos volver a nuestro ejemplo anterior para ver
cómo agregar un reranker después de un sistema de búsqueda por palabras clave mejora su
rendimiento.
Modifiquemos nuestra función de búsqueda de palabras clave para que recupere una lista de los 10 resultados
principales mediante la búsqueda de palabras clave y luego usemos rerank para elegir los 3 resultados
principales de esos 10:
def keyword_and_reranking_search(consulta, top_k=3, num_candidates=10):

print("Pregunta de entrada:",
consulta)
##### Búsqueda BM25 (búsqueda léxica) ##### bm25_scores =

bm25.get_scores(bm25_tokenizer(query)) top_n = np.argpartition(bm25_scores,
num_candidates)[ num_candidates:] bm25_hits = [{'corpus_id': idx, 'score': bm25_scores[idx]}
para
idx en top_n]
bm25_hits = ordenado(bm25_hits, clave=lambda x: x['puntaje'], reverso=Verdadero)
print(f"Los 3 resultados principales de la búsqueda léxica (BM25)")

para el hit en bm25_hits[0:top_k]: print("\t{:.3f}

\t{}".format(hit['score'],
textos[hit['corpus_id']].replace("\n", " ")))
#Agregar documentos de
reclasificación = [textos[hit['corpus_id']] para el hit en bm25_hits]
print(f"\nLos 3 mejores resultados por rankingAPI ({len(bm25_hits)} resultados de BM25 reclasificados)")
resultados = co.rerank(consulta=consulta, documentos=docs, top_n=top_k,

return_documents=True) #
imprimir(resultados.resultados) para el
resultado en resultados.resultados: #
imprimir(resultados)
print("\t{:.3f}\t{}".format(resultados.puntuación_de_relevancia,
resultados.documentos.texto.replace("\n", " ")))
Ahora podemos enviar nuestra consulta y verificar los resultados de la búsqueda de palabras clave y luego
el resultado de la búsqueda de palabras clave preseleccionando sus 10 resultados principales, para luego
pasarlos al reranker:
keyword_and_reranking_search(consulta = "qué tan precisa fue la ciencia")
Resultados:
Pregunta de entrada: ¿qué tan precisa fue la ciencia? La búsqueda léxica

Top3 (BM25) arroja resultados 1.789 Interstellar es
una película épica de ciencia ficción de 2014 coescrita, dirigida y producida por Christopher Nolan
1.373 Físico teórico de Caltech y premio Nobel de Física de 2017[4] Kip Thorne fue
productor ejecutivo, actuó como consultor científico y escribió un libro complementario, The Science of
Interstellar 0.000 Interstellar utiliza amplios efectos prácticos y en miniatura y la empresa Double
Negative creó efectos digitales adicionales.
Top3 de éxitos por rankingAPI (10 éxitos de BM25 reclasificados)

0.004 Físico teórico de Caltech y premio Nobel de Física 2017[4] Kip Thorne fue productor ejecutivo, actuó
como consultor científico y escribió un libro complementario, The Science of Interstellar 0.004
Ambientada en un futuro distópico donde la humanidad lucha por sobrevivir, la película sigue a un grupo
de astronautas que
viajan a través de un agujero de gusano cerca de Saturno en busca de un nuevo hogar para la humanidad
0.003 Los hermanos Christopher y Jonathan Nolan escribieron el guion, que tuvo su origen en un
guion que Jonathan desarrolló en 2007
Vemos que la búsqueda de palabras clave asigna puntuaciones solo a dos resultados que comparten
algunas de las palabras clave. En el segundo conjunto de resultados, el reranker eleva el segundo
resultado de manera apropiada como el resultado más relevante para la consulta. Este es un ejemplo de
juguete que nos da una idea del efecto, pero en la práctica, una canalización de este tipo mejora
significativamente la calidad de la búsqueda. En un punto de referencia multilingüe como MIRACL, un
reranker puede aumentar rendimiento de 36,5 a 62,8, medido como nDCG@10 (más sobre la
evaluación más adelante en este capítulo).
Recuperación y reordenamiento de código abierto con transformadores de oraciones
Si desea configurar localmente la recuperación y la reclasificación en su propia máquina, puede utilizar

la biblioteca Sentence Transformers. Consulte la documentación en https://oreil.ly/jJOhV
para realizar la configuración. Consulte la sección “Recuperación y reclasificación” para obtener
instrucciones y ejemplos de código sobre cómo realizar estos pasos en la biblioteca.
Cómo funcionan los modelos de reclasificación
Una forma popular de crear rerankers de búsqueda LLM es presentar la consulta y cada resultado a un
LLM que funciona como un codificador cruzado. Esto significa que una consulta y un posible resultado
se presentan al modelo al mismo tiempo, lo que permite que el modelo vea ambos textos antes
de asignar una puntuación de relevancia, como podemos ver en la Figura 815. Todos los documentos
se procesan simultáneamente como un lote, pero cada documento se evalúa en relación con la
consulta de forma independiente. Las puntuaciones determinan entonces el nuevo orden de los resultados.
Esto
El método se describe con más detalle en un artículo titulado “Clasificación de documentos

en múltiples etapas con BERT” y a veces se lo denomina monoBERT.
Figura 815. Un reranker asigna una puntuación de relevancia a cada documento observando el documento
y la consulta al mismo tiempo.
Esta formulación de la búsqueda como puntuación de relevancia se reduce básicamente

a ser un problema de clasificación. Con esos datos de entrada, el modelo genera una
puntuación de 0 a 1, donde 0 es irrelevante y 1 es muy relevante. Esto debería resultar familiar
a partir de los análisis de clasificación que hicimos en el Capítulo 4.
Para aprender más sobre el desarrollo del uso de LLM para búsqueda, " Transformadores
preentrenados para el tanking de texto: BERT y más allá" es una mirada muy recomendable
a los desarrollos de estos modelos hasta aproximadamente 2021.
Métricas de evaluación de recuperación
La búsqueda semántica se evalúa utilizando métricas del campo de recuperación de

información (IR). Analicemos una de estas métricas populares: la precisión media
promedio (MAP).
La evaluación de los sistemas de búsqueda necesita tres componentes principales: un

archivo de texto, un conjunto de consultas y juicios de relevancia que indican qué
documentos son relevantes para cada consulta. Vemos estos componentes en la Figura 816.
Figura 816. Para evaluar los sistemas de búsqueda, necesitamos un conjunto de pruebas que incluya consultas y
juicios de relevancia que indiquen qué documentos de nuestro archivo son relevantes para cada consulta.
Utilizando este conjunto de pruebas, podemos proceder a explorar la evaluación de los sistemas de búsqueda.
Comencemos con un ejemplo sencillo. Supongamos que pasamos la consulta 1 a dos sistemas de
búsqueda diferentes y obtenemos dos conjuntos de resultados. Digamos que limitamos la cantidad de
resultados a tres, como podemos ver en la Figura 817.

Figura 817. Para comparar dos sistemas de búsqueda, pasamos la misma consulta de nuestro conjunto de pruebas a ambos
sistemas y observamos sus resultados principales.
Para determinar cuál es el mejor sistema, recurrimos a los juicios de relevancia que
tenemos para la consulta. La Figura 818 muestra cuáles de los resultados obtenidos
son relevantes.
Figura 818. Si observamos los juicios de relevancia de nuestro conjunto de pruebas, podemos ver que el sistema 1 hizo un
mejor trabajo que el sistema 2.
Esto nos muestra un caso claro donde el sistema 1 es mejor que el sistema 2.
Intuitivamente, podemos contar cuántos resultados relevantes obtuvo cada
sistema. El sistema 1 obtuvo dos de tres resultados correctos y el sistema 2 solo uno
de tres. Pero ¿qué sucede en un caso como el de la Figura 819 , en el que ambos
sistemas solo obtienen un resultado relevante de tres, pero están en posiciones
diferentes?
Figura 819. Necesitamos un sistema de puntuación que recompense al sistema 1 por asignar una posición alta a un
resultado relevante, aun cuando ambos sistemas hayan obtenido solo un resultado relevante entre sus tres resultados principales.
En este caso, podemos intuir que el sistema 1 ha hecho un mejor trabajo que el sistema
2 porque el resultado en la primera posición (la más importante) es correcto. Pero, ¿cómo
podemos asignar un número o puntuación a cuánto mejor es ese resultado? La precisión media
promedio es una medida que permite cuantificar esta distinción.
Una forma común de asignar puntuaciones numéricas en este escenario es la precisión

promedio, que evalúa el resultado del sistema 1 para la consulta como 1 y el del sistema
2 como 0,3. Veamos cómo se calcula la precisión promedio para evaluar un conjunto de
resultados y luego cómo se agrega para evaluar un sistema en todas las consultas del
conjunto de pruebas.
Puntuación de una única consulta con precisión media
Para puntuar un sistema de búsqueda en esta consulta, podemos centrarnos en puntuar los
documentos relevantes. Empecemos por analizar una consulta que solo tiene un
documento relevante en el conjunto de pruebas.
El primero es fácil: el sistema de búsqueda coloca el resultado relevante (el único disponible
para esta consulta) en la parte superior. Esto le otorga al sistema la puntuación perfecta
de 1. La Figura 820 muestra este cálculo: si observamos la primera posición, tenemos un
resultado relevante que conduce a una precisión en la posición 1 de 1,0 (calculada
como la cantidad de resultados relevantes en la posición 1, dividida por la posición que
estamos observando en ese momento).
Figura 820. Para calcular la precisión media promedio, comenzamos calculando la precisión en cada posición,
comenzando con la posición 1.
Dado que solo estamos puntuando los documentos relevantes, podemos ignorar las
puntuaciones de los documentos no relevantes y detener nuestro cálculo aquí. Sin embargo,
¿qué sucedería si el sistema colocara el único resultado relevante en la tercera posición?
¿Cómo afectaría eso a la puntuación? La Figura 821 muestra cómo esto da como resultado una penalización.
Figura 821. Si el sistema coloca documentos no relevantes antes de un documento relevante, su puntuación de
precisión se ve penalizada.
Ahora veamos una consulta con más de un documento relevante. La Figura

822 muestra ese cálculo y cómo el promedio entra en escena.
Figura 822. La precisión promedio de un documento con múltiples documentos relevantes considera la
precisión en k resultados de todos los documentos relevantes.
Puntuación en múltiples consultas con precisión media promedio

Ahora que estamos familiarizados con la precisión en k y la precisión promedio, podemos extender
este conocimiento a una métrica que pueda calificar un sistema de búsqueda en relación con todas
las consultas en nuestro conjunto de pruebas. Esa métrica se denomina precisión promedio media.
La Figura 823 muestra cómo calcular esta métrica tomando la media de las
precisiones promedio de cada consulta.
Figura 823. La precisión media promedio tiene en cuenta la puntuación de precisión promedio de un sistema
para cada consulta en el conjunto de pruebas. Al promediarlas, se obtiene una única métrica que podemos
utilizar para comparar un sistema de búsqueda con otro.
Quizás te preguntes por qué la misma operación se llama “media” y “promedio”.

Es probable que sea una elección estética porque MAP suena mejor que la precisión
promedio.
Ahora tenemos una única métrica que podemos usar para comparar diferentes sistemas.
Si desea obtener más información sobre las métricas de evaluación, consulte el capítulo
“Evaluación en recuperación de información” de Introducción a la recuperación de
información (Cambridge University Press) de Christopher D. Manning, Prabhakar
Raghavan y Hinrich Schütze.
Además de la precisión promedio, otra métrica comúnmente utilizada para los sistemas
de búsqueda es la ganancia acumulada descontada normalizada (nDCG), que es más
matizada en el sentido de que la relevancia de los documentos no es binaria
(relevante versus no relevante) y un documento puede etiquetarse como más relevante
que otro en el conjunto de pruebas y el mecanismo de puntuación.
Generación aumentada por recuperación (RAG)

La adopción masiva de los LLM rápidamente llevó a que la gente les hiciera preguntas
y esperara respuestas objetivas. Si bien los modelos pueden responder
algunas preguntas correctamente, también responden con seguridad muchas
preguntas de forma incorrecta. El principal método al que recurrió la industria para
remediar este comportamiento es RAG, descrito en el artículo “Retrieval
Augmented Generation for KnowledgeIntensive NLP Tasks” (2020)1 e ilustrado en la Figura 824.
Figura 824. Una secuencia básica de RAG se compone de un paso de búsqueda seguido de un paso de
generación fundamentada donde se le formula al LLM la pregunta y se recupera la información del paso de búsqueda.
Los sistemas RAG incorporan capacidades de búsqueda además de capacidades

de generación. Pueden considerarse una mejora de los sistemas de generación
porque reducen sus alucinaciones y mejoran su veracidad. También permiten casos de
uso de “chatear con mis datos” que los consumidores y las empresas pueden utilizar para
fundamentar un LLM en datos internos de la empresa o en una fuente de datos
específica de interés (por ejemplo, chatear con un libro).
Esto también se aplica a los sistemas de búsqueda. Cada vez más motores de búsqueda
incorporan un LLM para resumir los resultados o responder a las preguntas enviadas al
motor de búsqueda. Algunos ejemplos son Perplexity, Microsoft Bing AI y Google
Gemini.
De la búsqueda a RAG
Ahora, transformemos nuestro sistema de búsqueda en un sistema RAG. Para ello,

agregamos un LLM al final del proceso de búsqueda. Presentamos la pregunta y los
documentos más importantes recuperados al LLM y le pedimos que responda la pregunta.
Dado el contexto proporcionado por los resultados de la búsqueda, podemos ver un ejemplo
en la Figura 825.
Este paso de generación se llama generación fundamentada porque la información relevante

recuperada que proporcionamos al LLM establece un cierto contexto que fundamenta al LLM
en el dominio que nos interesa. La Figura 826 muestra cómo la generación fundamentada se
ajusta después de la búsqueda si continuamos con nuestro ejemplo de búsqueda de
incrustaciones anterior.
Figura 825. La búsqueda generativa formula respuestas y resúmenes al final de un proceso de búsqueda
mientras cita sus fuentes (devueltas por los pasos anteriores en el sistema de búsqueda).
Figura 826. Encuentre la información más relevante para una solicitud de entrada comparando las similitudes
entre las incrustaciones. La información más relevante se agrega a la solicitud antes de entregársela al usuario.
Máster.
Ejemplo: Grounded Generation con una API LLM

Veamos cómo agregar un paso de generación fundamentada después de los resultados de
búsqueda para crear nuestro primer sistema RAG. Para este ejemplo, utilizaremos el
LLM administrado de Cohere, que se basa en los sistemas de búsqueda que hemos visto
anteriormente en el capítulo. Utilizaremos la búsqueda integrada para recuperar los documentos
principales y luego los pasaremos al punto final de co.chat junto con las preguntas para
proporcionar una respuesta fundamentada:
consulta = "ingresos generados"
# 1 Recuperación #
Usaremos la búsqueda integrada. Pero lo ideal sería que hiciéramos resultados híbridos =
búsqueda(consulta)
#2 Generación enraizada
docs_dict = [{'text': text} para el texto en resultados['texts']] respuesta = co.chat( mensaje =

consulta, documentos=docs_dict
imprimir(respuesta.texto)
Resultado:
La película generó una recaudación mundial de más de 677 millones de dólares, o

773 millones con relanzamientos posteriores.
Resaltamos parte del texto porque el modelo indicó que la fuente de estos fragmentos de
texto fue el primer documento que pasamos:
citas=[ChatCitation(start=21, end=36, text='recaudación bruta mundial',

document_ids=['doc_0']), ChatCitation(start=40, end=57, text='más de 677 millones
de dólares', document_ids=['doc_0']), ChatCitation(start=62,
end=103, text='773 millones de dólares con relanzamientos posteriores.',
document_ids=['doc_0'])]
documentos=[{'id': 'doc_0', 'text': 'La película recaudó más de 677 millones de

dólares a nivel mundial (y 773 millones con los relanzamientos posteriores), lo
que la convierte en la décima película más taquillera de 2014'}]
Ejemplo: RAG con modelos locales

Ahora vamos a replicar esta funcionalidad básica con modelos locales. Perderemos la
capacidad de hacer citas de intervalo y el modelo local más pequeño no funcionará tan
bien como el modelo administrado más grande, pero es útil para demostrar el flujo.
Comenzaremos descargando un modelo cuantificado.
Cargando el modelo de generación
Comenzamos descargando nuestro modelo:
!wget https://huggingface.co/microsoft/Phi3mini4kinstructgguf/resolve/main/
Phi3mini4kinstructfp16.gguf
Usando llama.cpp, llamacpppython y LangChain, cargamos el modelo de generación de

texto:
Desde langchain, importe LlamaCpp

# ¡Asegúrese de que la ruta del modelo sea correcta para su sistema! llm =
LlamaCpp( model_path="Phi3
mini4kinstructfp16.gguf", n_gpu_layers=1, max_tokens=500, n_ctx=2048,
seed=42,
verbose=Falso
)
Cargando el modelo de incrustación
Ahora carguemos un modelo de lenguaje de incrustación. En este ejemplo, elegiremos

el modelo BAAI/bgesmallenv1.5. En el momento de escribir este artículo, ocupa un lugar
destacado en la clasificación de MTEB. Para incrustar modelos y relativamente pequeños:
de langchain.embeddings.huggingface importar HuggingFaceEmbeddings
# Modelo de incrustación para convertir texto en representaciones numéricas

embedding_model =
HuggingFaceEmbeddings( model_name='thenlper/gtesmall'
Ahora podemos usar el modelo de incrustación para configurar nuestra base de datos vectorial:
desde langchain.vectorstores importar FAISS
# Crear una base de datos vectorial local db =

FAISS.from_texts(texts, embedding_model)
El mensaje RAG
Una plantilla de solicitud cumple una función vital en el proceso de RAG. Es el lugar
central donde comunicamos los documentos relevantes al LLM. Para ello, crearemos una
variable de entrada adicional denominada contexto que pueda proporcionar al LLM
los documentos recuperados:
desde langchain importar PromptTemplate
# Crear una plantilla de solicitud template =

"""<|user|>
Información relevante: {contexto}
Proporcione una respuesta concisa a la siguiente pregunta utilizando la información relevante

proporcionada anteriormente: {question}<|end|> <|assistant|
>""" prompt =
input_variables=["context",
"question"]
)
desde langchain.chains importar RetrievalQA
# Tubería RAG rag =

RetrievalQA.from_chain_type( llm=llm, chain_type='stuff',
retriever=db.as_retriever(),
chain_type_kwargs={ "prompt": mensaje
},
verbose=Verdadero
)
Ahora estamos listos para llamar al modelo y hacerle una pregunta:
rag.invoke('Ingresos generados')
Resultado:
Los ingresos generados por la película en 2014 fueron de más de 677 millones de dólares en todo el
mundo, lo que la convirtió en la décima película más taquillera de ese año. Sin embargo, cabe señalar que
esta cifra incluye tanto las ventas iniciales de entradas como los relanzamientos posteriores.
Con estos lanzamientos adicionales, las ganancias totales aumentaron a aproximadamente

$773 millones. El formato de lanzamiento cambió
De la proyección tradicional de películas en cines a los proyectores digitales una

vez que se expandió a varios lugares en los Estados Unidos. Este cambio podría
haber contribuido a un mayor alcance de audiencia y potencialmente a mayores
cifras de recaudación con el tiempo.
Sin embargo, en la información anterior no se proporcionan datos específicos
sobre cómo esto afectó las ganancias totales.
Como siempre, podemos ajustar el mensaje para controlar la generación del modelo (por ejemplo, la
longitud y el tono de la respuesta).
Técnicas avanzadas de RAG

Existen varias técnicas adicionales para mejorar el rendimiento de los sistemas RAG. Algunas de ellas
se describen aquí.
Reescritura de consultas
Si el sistema RAG es un chatbot, la implementación simple de RAG anterior probablemente tendría

problemas con el paso de búsqueda si una pregunta es demasiado detallada o para hacer referencia
al contexto en mensajes anteriores en la conversación. Por eso es una buena idea usar un LLM para
reescribir la consulta en una que ayude al paso de recuperación a obtener la información correcta. Un
ejemplo de esto es un mensaje como
como:
Pregunta del usuario: “Tenemos que entregar un ensayo mañana. Tenemos que escribir sobre
algún animal. Me encantan los pingüinos. Podría escribir sobre ellos. Pero también podría escribir
sobre los delfines. ¿Son animales? Tal vez. Hablemos de los delfines. ¿Dónde viven, por ejemplo?”
En realidad, esto debería reescribirse en una consulta como:
Consulta: “¿Dónde viven los delfines?”
Esta conducta de reescritura se puede realizar a través de un mensaje de solicitud (o mediante una
llamada a la API). La API de Cohere, por ejemplo, tiene un modo de reescritura de consultas dedicado
para co.chat.
RAG de múltiples consultas
La siguiente mejora que podemos introducir es ampliar la reescritura de consultas para poder buscar varias
consultas si se necesita más de una para responder a una pregunta específica. Tomemos como ejemplo:
Pregunta de usuario: “Compara los resultados financieros de Nvidia en 2020 con los
de 2023”
Es posible que encontremos un documento que contenga los resultados de ambos años, pero lo más
probable es que sea mejor realizar dos consultas de búsqueda:
Consulta 1: “Resultados financieros de Nvidia 2020”
Consulta 2: “Resultados financieros de Nvidia 2023”
Luego presentamos los resultados principales de ambas consultas al modelo para su generación
fundamentada. Una pequeña mejora adicional aquí es darle también al reescritor de consultas la opción de
determinar si no se requiere ninguna búsqueda y si puede generar directamente una respuesta segura sin
buscar.
RAG de múltiples saltos
Una pregunta más avanzada puede requerir una serie de consultas secuenciales. Tomemos como ejemplo
una pregunta como:
Pregunta de un usuario: “¿Quiénes son los mayores fabricantes de automóviles en 2023? ¿Todos
ellos fabricarán vehículos eléctricos o no?”
Para responder a esto, el sistema primero debe buscar:
Paso 1, Consulta 1: “los mayores fabricantes de automóviles en 2023”
Luego de obtener esta información (el resultado es Toyota, Volkswagen y

Hyundai), debería plantear preguntas de seguimiento:
Paso 2, Consulta 1: “Vehículos eléctricos de Toyota Motor Corporation”
Paso 2, Consulta 2: “Vehículos eléctricos de Volkswagen AG”
Paso 2, Consulta 3: “Vehículos eléctricos de Hyundai Motor Company”

Enrutamiento de consultas
Una mejora adicional es darle al modelo la capacidad de buscar en múltiples fuentes

de datos. Por ejemplo, podemos especificar que si se le plantea una pregunta sobre RR.
HH., busque en el sistema de información de RR. HH. de la empresa (por ejemplo, Notion),
pero si la pregunta es sobre datos de clientes, busque en el sistema de gestión de
relaciones con los clientes (CRM) (por ejemplo, Salesforce).
RAG agente
Ahora puede ver que la lista de mejoras anteriores delega lentamente cada vez más
responsabilidad al LLM para resolver problemas cada vez más complejos. Esto depende
de la capacidad del LLM para medir las necesidades de información requeridas,
así como de su capacidad para utilizar múltiples fuentes de datos. Esta nueva
naturaleza del LLM comienza a acercarse cada vez más a un agente que actúa sobre
el mundo. Las fuentes de datos también se pueden abstraer en herramientas. Vimos, por
ejemplo, que podemos buscar en Notion, pero, por la misma razón, también deberíamos
poder publicar en Notion.
No todos los LLM tendrán las capacidades RAG mencionadas aquí. Al momento de escribir
esto, es probable que solo los modelos administrados más grandes puedan intentar este
comportamiento. Afortunadamente, Command R+ de Cohere Se destaca en estas tareas y
está disponible como modelo de pesos abiertos. también.
Evaluación RAG
Todavía hay avances en curso sobre cómo evaluar los modelos RAG. Un buen artículo
para leer sobre este tema es “Evaluating verificability in generative search engine” (2023),
que realiza evaluaciones humanas en diferentes sistemas de búsqueda generativa.2
Evalúa los resultados en cuatro ejes:
Fluidez
Si el texto generado es fluido y cohesivo.

Utilidad percibida
Si la respuesta generada es útil e informativa.
Recordatorio de citación
La proporción de afirmaciones generadas sobre el mundo externo que están plenamente
respaldadas por sus citas.
Precisión de citación
La proporción de citas generadas que respaldan su asociación
declaraciones.
Si bien siempre se prefiere la evaluación humana, existen enfoques que intentan

automatizar estas evaluaciones haciendo que un LLM capaz actúe como juez
(llamado LLMcomojuez) y califique las diferentes generaciones a lo largo de los
diferentes ejes. Ragas es una biblioteca de software que hace exactamente esto.
También puntúa algunas métricas útiles adicionales como:
Fidelidad
Si la respuesta es consistente con el contexto proporcionado
Relevancia de la respuesta
¿Qué relevancia tiene la respuesta a la pregunta?
El sitio de documentación de Ragas Proporciona más detalles sobre las fórmulas para calcular
realmente estas métricas.
Resumen
En este capítulo, analizamos diferentes formas de utilizar modelos de lenguaje para mejorar los
sistemas de búsqueda existentes e incluso ser el núcleo de nuevos sistemas más avanzados.
Potentes sistemas de búsqueda, entre los que se incluyen:
Recuperación densa, que se basa en la similitud de las incrustaciones de texto.
Se trata de sistemas que incorporan una consulta de búsqueda y recuperan los
documentos con las incorporaciones más cercanas a la incorporación de la consulta.
Rerankers, sistemas (como monoBERT) que analizan una consulta y los

resultados de los candidatos y puntúan la relevancia de cada documento para esa
consulta. Estas puntuaciones de relevancia se utilizan luego para ordenar los

resultados preseleccionados según su relevancia para la consulta, lo que a menudo
produce una clasificación de resultados mejorada.
RAG, donde los sistemas de búsqueda tienen un LLM generativo al final del proceso para
formular una respuesta basada en los documentos recuperados mientras se citan las fuentes.
También analizamos uno de los posibles métodos para evaluar los sistemas de búsqueda.
La precisión media promedio nos permite puntuar los sistemas de búsqueda para poder compararlos
entre un conjunto de consultas de prueba y su relevancia conocida para las consultas de prueba. Sin
embargo, la evaluación de los sistemas RAG requiere múltiples ejes, como la fidelidad, la fluidez y otros
que pueden ser evaluados por humanos o por LLM como juez.
En el próximo capítulo, exploraremos cómo los modelos de lenguaje pueden hacerse multimodales y
razonar no sólo sobre texto sino también sobre imágenes.
1
Patrick Lewis et al. “Generación aumentada por recuperación para tareas de PNL con uso intensivo de conocimiento”.
Avances en sistemas de procesamiento de información neuronal 33 (2020): 9459–9474.
2
Nelson F. Liu, Tianyi Zhang y Percy Liang. “Evaluación de la verificabilidad en motores de búsqueda
generativos”. Preimpresión de arXiv arXiv:2304.09848 (2023).
OceanofPDF.com
Capítulo 9. Modelos lingüísticos

multimodales de gran tamaño
Cuando piensas en modelos lingüísticos grandes (LLM), la multimodalidad puede no ser lo primero que te
viene a la cabeza. Después de todo, ¡son modelos lingüísticos ! Pero podemos ver rápidamente
que los modelos pueden ser mucho más útiles si pueden manejar tipos de datos distintos del texto.
Es muy útil, por ejemplo, si un modelo lingüístico puede mirar una imagen y responder preguntas
sobre ella. Un modelo que puede manejar texto e imágenes (cada uno de los cuales se denomina
modalidad) se dice que es multimodal, como podemos ver en la Figura 91.
Figura 91. Los modelos que pueden manejar distintos tipos (o modalidades) de datos, como imágenes,
audio, video o sensores, se denominan multimodales. Es posible que un modelo acepte una modalidad
como entrada pero no pueda generar datos en esa modalidad.
Hemos visto todo tipo de comportamientos emergentes que surgen de los LLM, desde capacidades de
generalización y razonamiento hasta aritmética y lingüística. A medida que los modelos se hacen más
grandes y más inteligentes, también lo hacen sus conjuntos de habilidades.1
La capacidad de recibir y razonar con información multimodal podría aumentar aún más y ayudar
a que surjan capacidades que antes estaban bloqueadas.
En la práctica, el lenguaje no vive únicamente en el vacío. Por ejemplo, el lenguaje

corporal, las expresiones faciales, la entonación, etc. son métodos de comunicación
que mejoran la palabra hablada.
Lo mismo se aplica a los LLM: si podemos permitirles razonar sobre información

multimodal, sus capacidades podrían aumentar y podríamos utilizarlos para resolver
nuevos tipos de problemas.
En este capítulo, exploraremos una serie de LLM diferentes que tienen capacidades
multimodales y lo que eso significa para los casos de uso prácticos. Comenzaremos
explorando cómo se convierten las imágenes en representaciones numéricas utilizando
una adaptación de la técnica Transformer original. Luego, mostraremos cómo se pueden
ampliar los LLM para incluir tareas de visión utilizando este Transformer.
Transformadores para la visión

A lo largo de los capítulos de este libro, hemos visto el éxito del uso de modelos
basados en Transformer para una variedad de tareas de modelado de lenguaje, desde la
clasificación y el agrupamiento hasta la búsqueda y el modelado generativo. Por lo tanto,
no debería sorprender que los investigadores hayan estado buscando una forma de
generalizar parte del éxito de Transformer al campo de la visión por computadora.
El método que idearon se llama Vision Transformer (ViT), que ha demostrado tener
un rendimiento tremendamente bueno en tareas de reconocimiento de imágenes en
comparación con las redes neuronales convolucionales (CNN) predeterminadas
anteriormente.2 Al igual que el Transformer original, ViT se utiliza para transformar datos
no estructurados, una imagen, en representaciones que se pueden usar para una
variedad de tareas, como la clasificación, como se ilustra en la Figura 92.
ViT se basa en un componente importante de la arquitectura Transformer, es decir,

el codificador. Como vimos en el Capítulo 1, el codificador es responsable de convertir la
entrada textual en representaciones numéricas antes de pasarlas al decodificador. Sin
embargo, antes de que el codificador pueda realizar sus tareas, la entrada textual
debe ser tokenizada primero, como se ilustra en la Figura 93.
Figura 92. Tanto el Transformer original como el Vision Transformer toman datos no estructurados, los convierten
en representaciones numéricas y finalmente los utilizan para tareas como la clasificación.
Figura 93. El texto se pasa a uno o varios codificadores mediante su tokenización mediante un tokenizador.
Como una imagen no está formada por palabras, este proceso de tokenización no se
puede utilizar para datos visuales. En su lugar, los autores de ViT idearon un método
para tokenizar imágenes en “palabras”, lo que les permitió utilizar la estructura del
codificador original.
Imagina que tienes una imagen de un gato. Esta imagen está representada por un
número de píxeles, digamos 512 × 512 píxeles. Cada píxel individual no tiene
transmiten mucha información, pero cuando combinas parches de píxeles, lentamente

comienzas a ver más información.
ViT utiliza un principio muy similar a ese. En lugar de dividir el texto en fragmentos, convierte la
imagen original en fragmentos de imágenes. En otras palabras, corta la imagen en varias partes
de forma horizontal y vertical, como se ilustra en la Figura 94.
Figura 94. Proceso de “tokenización” de la entrada de imágenes. Convierte una imagen en parches de
subimágenes.
De la misma manera que convertimos texto en fragmentos de texto, convertimos una imagen
en fragmentos de imágenes. La entrada aplanada de fragmentos de imagen puede considerarse
como los fragmentos de un fragmento de texto. Sin embargo, a diferencia de los fragmentos,
no podemos simplemente asignar a cada fragmento un ID, ya que estos fragmentos rara vez se
encontrarán en otras imágenes, a diferencia del vocabulario de un texto.
En cambio, los parches se incrustan linealmente para crear representaciones

numéricas, es decir, incrustaciones. Estas pueden usarse como entrada de un modelo de
Transformer. De esa manera, los parches de imágenes se tratan de la misma manera que los
tokens. El proceso completo se ilustra en la Figura 95.
A modo de ejemplo, las imágenes de los ejemplos se combinaron en parches de 3 × 3, pero la

implementación original utilizó parches de 16 × 16. Después de todo, el artículo se llama “Una
imagen vale más que 16 x 16 palabras”.
Lo interesante de este enfoque es que, en el momento en que las incrustaciones se

pasan al codificador, se tratan como si fueran tokens textuales. A partir de ese momento,
no hay diferencia en cómo se entrena un texto o una imagen.
Debido a estas similitudes, el ViT se utiliza a menudo para hacer que todo tipo de
modelos de lenguaje sean multimodales. Una de las formas más sencillas de utilizar
Es durante el entrenamiento de modelos de incrustación.
Figura 95. El algoritmo principal detrás de ViT. Después de aplicar parches a las imágenes y proyectarlas
linealmente, las incrustaciones de parches se pasan al codificador y se tratan como si fueran tokens textuales.
Modelos de incrustación multimodal

En capítulos anteriores, utilizamos modelos de incrustación para capturar el contenido
semántico de representaciones textuales, como artículos y documentos. Vimos que
podíamos utilizar estas incrustaciones o representaciones numéricas para encontrar
documentos similares, aplicar tareas de clasificación e incluso realizar modelos de
temas.
Como hemos visto muchas veces antes, las incrustaciones suelen ser un factor importante
detrás de las aplicaciones LLM. Son un método eficiente para capturar
información a gran escala y búsqueda de la aguja en el pajar de información.
Dicho esto, hasta ahora hemos analizado modelos de incrustación de solo texto, que se
centran en generar incrustaciones para representaciones textuales. Aunque existen
modelos de incrustación solo para incrustar imágenes, analizaremos modelos de
incrustación que puedan capturar representaciones tanto textuales como visuales.
Lo ilustramos en la Figura 96.
Figura 96. Los modelos de incrustación multimodal pueden crear incrustaciones para múltiples modalidades en el
mismo espacio vectorial.
Una ventaja es que esto permite comparar representaciones multimodales ya que las
incrustaciones resultantes se encuentran en el mismo espacio vectorial (Figura 97).
Por ejemplo, si utilizamos un modelo de incrustación multimodal, podemos encontrar
imágenes a partir del texto de entrada. ¿Qué imágenes encontraríamos si buscáramos
imágenes similares a “fotos de un cachorro”? También sería posible que ocurriera lo contrario.
¿Qué documentos están mejor relacionados con esta pregunta?
Figura 97. A pesar de provenir de diferentes modalidades, las incrustaciones con significado similar estarán
próximas entre sí en el espacio vectorial.
Hay varios modelos de incrustación multimodal, pero el modelo más conocido y más utilizado
actualmente es el preentrenamiento de lenguajeimagen contrastivo (CLIP).
CLIP: Conexión de texto e imágenes

CLIP es un modelo de incrustación que puede calcular incrustaciones tanto de imágenes como de
textos. Las incrustaciones resultantes se encuentran en el mismo espacio vectorial, lo que
significa que las incrustaciones de imágenes se pueden comparar con las
incrustaciones de texto.3 Esta capacidad de comparación hace que CLIP y otros modelos similares
sean útiles para tareas como:
Clasificación de disparo cero
Podemos comparar la incrustación de una imagen con la de la descripción.
de sus posibles clases para encontrar qué clase es más similar.
Agrupamiento
Agrupe imágenes y una colección de palabras clave para encontrar qué palabras clave
pertenecen a qué conjuntos de imágenes.
Buscar
Entre miles de millones de textos o imágenes, podemos encontrar rápidamente lo que se relaciona
con un texto o imagen de entrada.
Generación
Utilice incrustaciones multimodales para impulsar la generación de imágenes (por ejemplo, difusión
estable4 ).
¿Cómo puede CLIP generar incrustaciones multimodales?

El procedimiento de CLIP es bastante sencillo. Imagina que tienes un conjunto de datos con millones de
imágenes y subtítulos, como se muestra en la Figura 98.
Figura 98. Tipo de datos necesarios para entrenar un modelo de incrustación multimodal.
Este conjunto de datos se puede utilizar para crear dos representaciones para cada par, la imagen y
su título. Para ello, CLIP utiliza un codificador de texto para incrustar texto y un codificador de imágenes para
incrustar imágenes. Como se muestra en la Figura 99, el resultado es una incrustación tanto de la imagen
como de su título correspondiente.

Figura 99. En el primer paso del entrenamiento de CLIP, se incorporan imágenes y texto utilizando un codificador de
imágenes y texto, respectivamente.
El par de incrustaciones que se generan se comparan a través de la similitud de

cosenos. Como vimos en el Capítulo 4, la similitud de cosenos es el coseno del
ángulo entre vectores, que se calcula a través del producto escalar de las
incrustaciones y dividido por el producto de sus longitudes.
Cuando comenzamos el entrenamiento, la similitud entre la incrustación de

imágenes y la incrustación de texto será baja, ya que aún no están optimizadas
para estar dentro del mismo espacio vectorial. Durante el entrenamiento, optimizamos
la similitud entre las incrustaciones y queremos maximizarlas para pares de imágenes/
títulos similares y minimizarlas para pares de imágenes/títulos diferentes (Figura 910).
Después de calcular su similitud, el modelo se actualiza y el proceso comienza

nuevamente con nuevos lotes de datos y representaciones actualizadas (Figura 911).
Este método se llama aprendizaje contrastivo y profundizaremos en él.
El funcionamiento interno se verá en el Capítulo 10 , donde crearemos nuestro propio modelo de

incrustación.
Figura 910. En el segundo paso del entrenamiento de CLIP, la similitud entre la oración y la imagen incorporada
se calcula utilizando la similitud del coseno.
Figura 911. En el tercer paso del entrenamiento de CLIP, los codificadores de texto e imagen se actualizan para
que coincidan con la similitud deseada. Esto actualiza las incrustaciones de modo que estén más cerca en el
espacio vectorial si las entradas son similares.
Al final, esperamos que la incorporación de una imagen de un gato sea similar a la incorporación de la
frase “una imagen de un gato”. Como veremos en
Capítulo 10: Para asegurarse de que las representaciones sean lo más precisas
posibles, también se deben incluir en el proceso de entrenamiento ejemplos negativos
de imágenes y leyendas que no estén relacionadas. Modelar la similitud no consiste solo
en saber qué hace que las cosas sean similares entre sí, sino también qué las
hace diferentes y disímiles.
Abrir CLIP
Para nuestro próximo ejemplo, utilizaremos modelos de la variante de código
abierto de CLIP, concretamente OpenCLIP. El uso de OpenCLIP, o cualquier modelo
CLIP, se reduce a dos cosas: procesar las entradas de texto e imágenes antes de
pasarlas al modelo principal.
Antes de hacerlo, echemos un vistazo a un pequeño ejemplo en el que utilizaremos una

de las imágenes que hemos visto antes, es decir, una imagen generada por IA (a
través de difusión estable) de un cachorro jugando en la nieve, como se ilustra en
Figura 912:
desde urllib.request importar urlopen desde

PIL importar Imagen
# Cargue una imagen generada por IA de un cachorro jugando en la nieve

puppy_path = "https://raw.githubusercontent.com/HandsOnLLM/HandsOnLarge
LanguageModels/main/chapter09/images/puppy.png" image =
Image.open(urlopen(puppy_path)).convert("RGB")
caption = "un cachorro jugando en la nieve"

Figura 912. Imagen generada por IA de un cachorro jugando en la nieve.
Como tenemos un título para esta imagen, podemos usar OpenCLIP para generar
incrustaciones para ambas.
Para ello cargamos tres modelos:
Un tokenizador para tokenizar la entrada textual
Un preprocesador para preprocesar y redimensionar la imagen.
El modelo principal que convierte las salidas anteriores en incrustaciones
Desde los transformadores, importe CLIPTokenizerFast, CLIPProcessor, CLIPModel
modelo_id = "openai/clipvitbasepatch32"
# Cargar un tokenizador para preprocesar el texto

clip_tokenizer = CLIPTokenizerFast.from_pretrained(model_id)
# Cargar un procesador para preprocesar las imágenes

clip_processor = CLIPProcessor.from_pretrained(model_id)
# Modelo principal para generar incrustaciones de texto e imágenes model

= CLIPModel.from_pretrained(model_id)
Después de haber cargado los modelos, el preprocesamiento de nuestra

entrada es sencillo. Comencemos con el tokenizador y veamos qué sucede si
preprocesamos nuestra entrada:
# Tokenizar nuestras
entradas inputs = clip_tokenizer(caption, return_tensors="pt") inputs
Esto genera un diccionario que contiene los ID de la entrada:
{'input_ids': tensor([[49406, 320, 6829, 1629, 530, 518, 2583, 49407]]), 'attention_mask':
tensor([[1, 1, 1, 1, 1, 1, 1, 1]])}
Para ver qué representan esos ID, podemos convertirlos en tokens usando la función
convert_ids_to_tokens:
# Convierte nuestra entrada nuevamente en

tokens clip_tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
Esto nos da el siguiente resultado:
['<|startoftext|>', 'un</w>',
'cachorro</
w>', 'jugando</
w>', 'en</w>', 'el</
w>',
'nieve</w>', '<|
fin del texto|>']
Como ya hemos visto antes, el texto se divide en tokens. Además, ahora también vemos que
se indica el inicio y el final del texto para separarlo de una posible incrustación de imagen.
También puede notar que falta el token [CLS]. En CLIP, el token [CLS] se usa en realidad
para representar la incrustación de imagen.
Ahora que hemos preprocesado nuestro título, podemos crear la incrustación:
# Crear una incrustación de texto

text_embedding = model.get_text_features(**inputs)
text_embedding.shape
Esto da como resultado una incrustación que tiene 512 valores para esta única cadena:
antorcha.Tamaño([1, 512])
Antes de que podamos crear nuestra incrustación de imagen, al igual que la incrustación
de texto, necesitaremos preprocesarla ya que el modelo espera que la imagen de
entrada tenga ciertas características, como su tamaño y forma.
Para ello podemos utilizar el procesador que hemos creado anteriormente:
# Preprocesar imagen
processing_image = clip_processor(
texto=Ninguno, imágenes=imagen, return_tensors="pt" )
["pixel_values"]
forma de imagen procesada

La imagen original tenía 512 × 512 píxeles. Observe que el preprocesamiento de esta imagen
redujo su tamaño a 224 × 224 píxeles, ya que ese es el tamaño esperado:
antorcha.Tamaño([1, 3, 224, 224])
Visualicemos los resultados de este preprocesamiento como se muestra en la Figura 913:
importar
antorcha importar numpy
como np importar matplotlib.pyplot como plt
# Preparar la imagen para la visualización

img = processing_image.squeeze(0) img =
img.permute(*torch.arange(img.ndim 1, 1, 1)) img = np.einsum("ijk
>jik", img)
# Visualizar imagen preprocesada

plt.imshow(img)
plt.axis("off")
Figura 913. La imagen de entrada preprocesada por CLIP.

Para convertir esta imagen preprocesada en incrustaciones, podemos llamar al

modelo como lo hicimos antes y explorar qué forma devuelve:
# Crea la incrustación de la imagen

image_embedding = model.get_image_features(processed_image)
image_embedding.shape
Esto nos da la siguiente forma:
antorcha.Tamaño([1, 512])
Observe que la forma de la imagen incrustada resultante es la misma que la del

texto incrustado. Esto es importante porque nos permite comparar sus
incrustaciones y ver si son similares.
Podemos utilizar estas incrustaciones para calcular su similitud. Para ello,

normalizamos primero las incrustaciones antes de calcular el producto escalar
para obtener un puntaje de similitud:
# Normalizar las incrustaciones

text_embedding /= text_embedding.norm(dim=1, keepdim=True) image_embedding /
= image_embedding.norm(dim=1, keepdim=True)
# Calcular su similitud text_embedding =
text_embedding.detach().cpu().numpy() image_embedding = image_embedding.detach().cpu().numpy() puntuación =
np.dot(text_embedding, image_embedding.T) puntuación
Esto nos da la siguiente puntuación:
matriz([[0.33149648]], dtype=float32)
Obtenemos una puntuación de similitud de 0,33, lo cual es difícil de interpretar

considerando que no sabemos qué considera el modelo como una similitud baja o alta.
Puntuación. En lugar de ello, ampliemos el ejemplo con más imágenes y subtítulos, como
se ilustra en la Figura 914.
Figura 914. Matriz de similitud entre tres imágenes y tres subtítulos.
Parece que una puntuación de 0,33 es realmente alta teniendo en cuenta que las similitudes
con otras imágenes son bastante menores.
USO DE TRANSFORMADORES DE ORACIONES PARA CARGAR CLIP
sentencetransformers implementa algunos modelos basados en CLIP que facilitan

enormemente la creación de incrustaciones. Solo se necesitan unas pocas líneas de
código:
de sentence_transformers importar SentenceTransformer, util
# Cargar modelo CLIP compatible con

SBERT = SentenceTransformer("clipViTB32")
# Codificar las imágenes

image_embeddings = model.encode(images)
# Codificar los subtítulos

text_embeddings = model.encode(captions)
#Calcular similitudes de coseno

sim_matrix =
util.cos_sim( image_embeddings, text_embeddings
)
Cómo hacer que los modelos de generación de texto sean multimodales
Tradicionalmente, los modelos de generación de texto han sido, como es de

esperar, modelos que interpretan representaciones textuales. Modelos como Llama
2 y ChatGPT se destacan por razonar sobre información textual y responder con lenguaje
natural.
Sin embargo, están limitados a la modalidad en la que fueron entrenados, es decir,

el texto. Como hemos visto antes con los modelos de incrustación multimodal, la
incorporación de la visión puede mejorar las capacidades de un modelo.
En el caso de los modelos de generación de texto, nos gustaría que razonara sobre
ciertas imágenes de entrada. Por ejemplo, podríamos darle una imagen de una pizza y
preguntarle qué ingredientes contiene. Podríamos mostrarle una imagen de la Torre Eiffel.
Torre y preguntar cuándo se construyó o dónde está ubicada. Esta capacidad de conversación se
ilustra con más detalle en la Figura 915.
Figura 915. Un ejemplo de un modelo de generación de texto multimodal (BLIP2) que puede razonar sobre imágenes
de entrada.
Para salvar la brecha entre estos dos dominios, se han hecho intentos de introducir una forma de
multimodalidad en los modelos existentes. Uno de estos métodos se denomina BLIP2:
Bootstrapping LanguageImage Pretraining for Unified VisionLanguage Understanding and
Generation 2. BLIP2 es una técnica modular y fácil de usar que permite introducir capacidades
de visión en los modelos de lenguaje existentes.
BLIP2: Cerrando la brecha de modalidad

Para crear un modelo de lenguaje multimodal desde cero se necesita una gran cantidad de
potencia de procesamiento y de datos. Tendríamos que utilizar miles de millones de imágenes,
textos y pares de imágenes y textos para crear un modelo de este tipo. Como puedes imaginar,
¡no es algo fácil de lograr!
En lugar de construir la arquitectura desde cero, BLIP2 cierra la brecha entre la visión y el lenguaje
construyendo un puente, llamado Transformador de consultas (QFormer), que conecta un codificador
de imágenes preentrenado y un LLM preentrenado.5
Al aprovechar los modelos entrenados previamente, BLIP2 solo necesita entrenar el puente sin
necesidad de entrenar el codificador de imágenes y LLM desde cero. ¡Hace un gran uso de la tecnología y
los modelos que ya existen! Este puente se ilustra en la Figura 916.
Figura 916. El transformador de consultas es el puente entre la visión (ViT) y el texto (LLM), que es el
único componente entrenable del pipeline.
Para conectar los dos modelos entrenados previamente, QFormer imita sus arquitecturas.
Tiene dos módulos que comparten sus capas de atención:
Un Transformador de Imágenes para interactuar con la Visión congelada

Transformador para extracción de características
Un transformador de texto que puede interactuar con el LLM
El QFormer se entrena en dos etapas, una para cada modalidad, como se ilustra en la Figura 917.
En el paso 1, se utilizan pares de imágenes y documentos para entrenar al QFormer para que represente
tanto imágenes como texto. Estos pares son generalmente títulos de imágenes, como hemos visto antes
al entrenar a CLIP.
Las imágenes se introducen en el ViT congelado para extraer las incrustaciones de visión. Estas
incrustaciones se utilizan como entrada del ViT de QFormer. Los subtítulos se utilizan como entrada del
Text Transformer de QFormer.
Figura 917. En el paso 1, se aplica el aprendizaje de representaciones para aprender representaciones de la visión y
el lenguaje simultáneamente. En el paso 2, estas representaciones se convierten en indicaciones visuales suaves para
alimentar el LLM.
Con estos datos, el QFormer se entrena en tres tareas:
Aprendizaje contrastivo imagentexto
Esta tarea intenta alinear pares de incrustaciones de imágenes y texto de manera que
maximicen su información mutua.
Coincidencia de imagen y texto
Una tarea de clasificación para predecir si un par de imagen y texto es positivo
(coincidente) o negativo (no coincidente).
Generación de texto basada en imágenes
Entrena el modelo para generar texto basado en información extraída de la imagen de
entrada.
Estos tres objetivos se optimizan conjuntamente para mejorar las representaciones

visuales que se extraen del ViT congelado. En cierto modo, estamos tratando de inyectar
información textual en las incrustaciones del ViT congelado para que podamos usarlas en el LLM.
Este primer paso de BLIP2 se ilustra en la Figura 918.
Figura 918. En el paso 1, la salida del ViT congelado se utiliza junto con su título y se entrena en tres tareas
de tipo contrastivo para aprender representaciones de texto visual.
En el paso 2, las incrustaciones aprendibles derivadas del paso 1 ahora contienen

información visual en el mismo espacio dimensional que la información textual
correspondiente. Las incrustaciones aprendibles se pasan luego al LLM. En cierto
modo, estas incrustaciones sirven como indicaciones visuales suaves que condicionan al
LLM a las representaciones visuales extraídas por el QFormer.
También hay una capa lineal completamente conectada entre ellos para garantizar que
las incrustaciones que se pueden aprender tengan la misma forma que espera el LLM.
Este segundo paso de conversión de la visión en lenguaje se representa en la
Figura 919.
Figura 919. En el paso 2, las incrustaciones aprendidas del QFormer se pasan al LLM a través de una capa
de proyección. Las incrustaciones proyectadas sirven como un aviso visual suave.
Al combinar estos pasos, el formador Q puede aprender representaciones visuales y

textuales en el mismo espacio dimensional, lo que puede usarse como un
estímulo suave para el LLM. Como resultado, el LLM recibirá información sobre la
imagen de una manera similar al contexto que le proporcionaría al LLM al incitarlo. El
proceso completo y detallado se ilustra en la Figura 920.
Figura 920. Procedimiento BLIP2 completo.
Desde BLIP2, se han lanzado muchos otros LLM visuales que tienen
procesos similares, como LLaVA, un marco para hacer que los LLM textuales
sean multimodales6 o Idefics 2, un LLM visual eficiente basado en Mistral 7B
7 Máster. Ambos LLM visuales, aunque tienen arquitecturas diferentes, conectan
codificadores visuales preentrenados de tipo CLIP con LLM textuales. El objetivo de
estas arquitecturas es proyectar características visuales de las imágenes de entrada
a incrustaciones de lenguaje de modo que puedan usarse como entrada para un
LLM. De manera similar al QFormer, intentan cerrar la brecha entre imágenes y texto.
Preprocesamiento de entradas multimodales

Ahora que sabemos cómo se crea BLIP2, hay varios casos de uso interesantes para
dicho modelo, que no se limitan a subtitular imágenes, responder preguntas visuales
e incluso realizar indicaciones.
Antes de revisar algunos casos de uso, primero carguemos el modelo y exploremos

cómo puedes usarlo:
Desde transformadores , importe AutoProcessor, Blip2ForConditionalGeneration, importe

antorcha
# Procesador de carga y modelo principal

blip_processor = AutoProcessor.from_pretrained("Salesforce/blip2 opt2.7b") model =
Blip2ForConditionalGeneration.from_pretrained(
"Salesforce/blip2opt2.7b",
tipo_d_torch=torch.float16
)
# Envía el modelo a la GPU para acelerar la inferencia device =

"cuda" if Torch.cuda.is_available() else "cpu" model.to(device)
CONSEJO
Usando model.vision_model y model.language_model, podemos ver qué ViT y

modelo generativo se usan, respectivamente, en el modelo BLIP2 que cargamos.
Cargamos dos componentes que conforman nuestro pipeline completo: un procesador

y un modelo. El procesador se puede comparar con el tokenizador de los modelos
de lenguaje. Convierte la entrada no estructurada, como imágenes y texto,
en representaciones que el modelo generalmente espera.
Preprocesamiento de imágenes
Comencemos explorando lo que hace el procesador con las imágenes.

Comenzamos cargando la imagen de una imagen muy ancha para fines ilustrativos:
# Cargar imagen de un superdeportivo

car_path = "https://raw.githubusercontent.com/HandsOnLLM/HandsOnLargeLanguage
Models/main/chapter09/images/car.png" image =
Image.open(urlopen(car_path)).convert("RGB")
imagen
La imagen tiene 520 × 492 píxeles, lo que en general es un formato poco habitual.
Veamos qué hace nuestro procesador con ella:
# Preprocesar la imagen
entradas = blip_processor(image, return_tensors="pt").to(device, Torch.float16)
entradas["pixel_values"].shape
Esto nos da la siguiente forma:
antorcha.Tamaño([1, 3, 224, 224])
El resultado es una imagen de 224 × 224 píxeles. ¡Bastante más pequeña que la que teníamos
inicialmente! Esto también significa que todas las formas originales de la imagen se procesarán
en cuadrados. Por lo tanto, tenga cuidado al introducir imágenes muy anchas o altas, ya que
podrían distorsionarse.
Preprocesamiento de texto
Continuemos esta exploración del procesador con texto. Primero, podemos acceder al
tokenizador que se utiliza para convertir en token el texto de entrada:
Procesador blip.tokenizador
GPT2TokenizerFast(nombre_o_ruta='Salesforce/blip2opt2.7b',
tamaño_vocab=50265,
longitud_máxima_modelo=1000000000000000019884624838656, es_rápido=Verdadero,
lado_de_relleno='derecha', lado_de_truncamiento='derecha', tokens_especiales=
{'bos_token': '</s>', 'eos_token': '</s>', 'unk_token': '</s>', 'pad_token': '<pad>'},
limpieza_de_espacios_de_tokenización=Verdadero),
decodificador_de_tokens_agregados={ 1: AddedToken("<pad>",
rstrip=Falso, lstrip=Falso, palabra_única=Falso, normalizado=Verdadero,
especial=Verdadero), 2: AddedToken("</s>", rstrip=Falso,
lstrip=Falso, palabra_única=Falso, normalizado=Verdadero,
especial=Verdadero), }
El modelo BLIP2 utiliza un tokenizador GPT2. Como analizamos en el Capítulo 2, la

forma en que los tokenizadores manejan el texto de entrada puede variar enormemente.
Para explorar cómo funciona GPT2Tokenizer, podemos probarlo con una pequeña oración.
Comenzamos convirtiendo la oración en identificadores de token antes
convirtiéndolos nuevamente en tokens:
# Preprocesar el texto text

= "Su vocalización era notablemente melódica" token_ids =
blip_processor(image, text=text, return_tensors="pt") token_ids = token_ids.to(device, Torch.float16)
["input_ids"][0]
# Convierte los identificadores de entrada nuevamente en

tokens tokens
= blip_processor.tokenizer.convert_ids_to_tokens(token_ids) tokens
Esto nos da los siguientes tokens:
['</s>', 'Ella', 'Ġvocal', 'ización', 'Ġwas', 'Ġremarkably', 'Ġmel', 'ódico']
Cuando inspeccionamos los tokens, es posible que notes un símbolo extraño al

comienzo de algunos tokens, es decir, el símbolo Ġ. En realidad, se supone que es un
espacio. Sin embargo, una función interna toma caracteres en ciertos puntos de código y
los mueve 256 posiciones hacia arriba para que se puedan imprimir. Como resultado, el
espacio (punto de código 32) se convierte en Ġ (punto de código 288).
Los convertiremos en guiones bajos con fines ilustrativos:
# Reemplace el token de espacio con un guión bajo tokens = [token.replace("Ġ", "_")
for token in tokens] tokens
Esto nos da un resultado más atractivo:
['</s>', 'Ella', '_vocal', 'ización', '_era', '_notablemente', '_mel', 'ódico']

La salida muestra que el guión bajo indica el comienzo de una palabra.

De esta manera se pueden reconocer palabras que están formadas por múltiples tokens.
Caso de uso 1: subtítulos de imágenes

El uso más sencillo de un modelo como BLIP2 es crear títulos de imágenes que tienes en
tus datos. Puede que tengas una tienda que quiera crear descripciones de su ropa o
quizás seas un fotógrafo que no tiene tiempo para etiquetar manualmente las más de
1000 fotografías de una boda.
El proceso de subtitular una imagen sigue de cerca el procesamiento. Una imagen se

convierte en valores de píxeles que el modelo puede leer. Estos valores de píxeles se
pasan a BLIP2 para convertirlos en indicaciones visuales suaves que el LLM puede usar
para decidir cuál es el subtítulo adecuado.
Tomemos la imagen de un superdeportivo y usemos el procesador para derivar píxeles en

la forma esperada:
# Cargar una imagen generada por IA de un

superdeportivo image = Image.open(urlopen(car_path)).convert("RGB")
# Convertir una imagen en entradas y preprocesarla inputs =

blip_processor(image, return_tensors="pt").to(device, Torch.float16) image
El siguiente paso es convertir la imagen en identificadores de tokens utilizando el

modelo BLIP2. Después de hacerlo, podemos convertir los identificadores en texto (el
título generado):
# Generar identificadores de imágenes que se pasarán al decodificador

(LLM) generated_ids = model.generate(**inputs, max_new_tokens=20)
# Generar texto a partir de los identificadores

de imagen generated_text =
blip_processor.batch_decode( generated_ids, skip_special_tokens=True
) texto_generado = texto_generado[0].strip()
texto_generado
generated_text contiene el título:
Un superdeportivo naranja circulando por la carretera al atardecer
¡Esta parece una descripción perfecta para esta imagen!
Los subtítulos de imágenes son una excelente manera de aprender este modelo antes de
pasar a casos de uso más complejos. Pruébelo usted mismo con algunas imágenes y vea
dónde funciona bien y dónde funciona mal. Las imágenes específicas de un dominio,
como imágenes de personajes de dibujos animados específicos o creaciones imaginarias,
pueden fallar ya que el modelo se entrenó con datos en gran parte públicos.
Terminemos este caso de uso con un ejemplo divertido, concretamente una imagen
del test de Rorschach, que se ilustra en la Figura 921. Es parte de un antiguo
experimento psicológico que pone a prueba la percepción que tiene el individuo de las
manchas de tinta.8 Lo que alguien ve en una mancha de tinta de este tipo
supuestamente le dice algo sobre las características de personalidad de una persona. Es
una prueba bastante subjetiva, ¡pero eso la hace más divertida!
Figura 921. Imagen del test de Rorschach. ¿Qué ves en ella?
Tomemos la imagen ilustrada en la Figura 921 y usémosla como nuestra entrada:
# Cargar imagen de Rorschach url =

"https://
upload.wikimedia.org/wikipedia/commons/7/70/Rorschach_bl ot_01.jpg" image =
Image.open(urlopen(url)).convert("RGB")
# Generar subtítulos entradas

= blip_processor(image, return_tensors="pt").to(dispositivo, antorcha.float16) identificadores_generados
=
model.generate(**entradas, max_new_tokens=20) texto_generado =
blip_processor.batch_decode( identificadores_generados,
skip_special_tokens=True
) texto_generado = texto_generado[0].strip() texto_generado

Como antes, cuando inspeccionamos la variable generated_text, podemos echar un

vistazo al título:
Un dibujo en tinta en blanco y negro de un murciélago.
Definitivamente puedo entender por qué la modelo usaría esa descripción para describir
esta imagen. Dado que se trata de una prueba de Rorschach, ¿qué crees que dice sobre
la modelo?
Caso de uso 2: indicaciones basadas en chat multimodal

Aunque el subtitulado es una tarea importante, podemos extender su uso aún más. En
el ejemplo anterior, mostramos cómo pasar de una modalidad, visión (imagen), a
otra, texto (subtítulo).
En lugar de seguir esta estructura lineal, podemos intentar presentar ambas

modalidades simultáneamente mediante lo que se denomina respuesta visual a
preguntas. En este caso de uso particular, le damos al modelo una imagen junto con
una pregunta sobre esa imagen específica para que la responda. El modelo necesita
procesar tanto la imagen como la pregunta a la vez.
Para demostrarlo, comencemos con la imagen de un automóvil y pidamos a BLIP2

que describa la imagen. Para ello, primero debemos preprocesar la imagen como
hicimos algunas veces antes:
# Cargar una imagen generada por IA de un superdeportivo

image = Image.open(urlopen(car_path)).convert("RGB")
Para realizar nuestra respuesta visual a la pregunta, necesitamos darle a BLIP2 algo
más que la imagen, es decir, el mensaje. Sin él, el modelo generaría un título
como lo hizo antes. Le pediremos al modelo que describa la imagen que acabamos de
procesar:
# Respuesta visual a preguntas

prompt = "Pregunta: Escribe lo que ves en esta imagen.

Respuesta:"
# Procesar tanto la imagen como las entradas del mensaje =

blip_processor(image, text=prompt, return_tensors="pt").to(device,
Torch.float16)
# Generar texto
generated_ids = model.generate(**inputs, max_new_tokens=30) generated_text =
blip_processor.batch_decode( generated_ids, skip_special_tokens=True
Un coche deportivo circulando por la carretera al atardecer.
Describe correctamente la imagen. Sin embargo, se trata de un ejemplo bastante simple, ya

que nuestra pregunta básicamente le pide a la modelo que cree un título.
En lugar de ello, podemos hacer preguntas de seguimiento mediante un chat.
Para ello, podemos darle al modelo nuestra conversación anterior, incluida su respuesta a
nuestra pregunta. A continuación, le formulamos una pregunta de seguimiento:
# Pregunta tipo chat = "Pregunta:

Escribe lo que ves en esta imagen.
Respuesta: Un coche deportivo circulando por la carretera al atardecer. Pregunta: ¿Cuánto me costaría
conducir ese coche? Respuesta:"
# Generar entradas de salida

= blip_processor(image, text=prompt, return_tensors="pt").to(dispositivo,
antorcha.float16) identificadores_generados = model.generate(**entradas,
max_new_tokens=30) texto_generado = blip_processor.batch_decode( identificadores_generados,

Esto nos da la siguiente respuesta:
$1,000,000
¡1.000.000 es muy específico! Esto muestra un comportamiento más parecido al de un chat

por parte de BLIP2, lo que permite algunas conversaciones interesantes.
Por último, podemos hacer este proceso un poco más sencillo creando un chatbot interactivo
usando ipywidgets, una extensión para Jupyter notebooks que nos permite crear botones
interactivos, introducir texto, etc:
desde IPython.display importar HTML, display importar

ipywidgets como widgets
def text_eventhandler(*args): pregunta =

args[0]["nuevo"] si pregunta: args[0]
["propietario"].valor
""
=
# Crear mensaje si no es
memoria: mensaje =
de lo contrario: " Pregunta: " + pregunta + " Respuesta:"
plantilla = "Pregunta: {} Respuesta: {}." mensaje = "

".join( [
plantilla.formato(memoria[i][0], memoria[i][1]) para i en

rango(len(memoria))
]
)+ " Pregunta: " + pregunta + " Respuesta:"
# Generar entradas de texto

= blip_processor(image, text=prompt, return_tensors="pt") entradas =
entradas.a(dispositivo,
antorcha.float16) identificadores_generados = modelo.generate(**entradas,
max_new_tokens=100) texto_generado = blip_processor.batch_decode( identificadores_generados,
)
texto_generado = texto_generado[0].strip().split("Pregunta")
[0]
# Actualizar la
memoria memory.append((pregunta, texto_generado))
# Asignar a salida
output.append_display_data(HTML("USUARIO: " + pregunta))
output.append_display_data(HTML("BLIP2: " +
texto_generado))
output.append_display_data(HTML(" "))
# Preparar widgets
in_text = widgets.Text()
in_text.continuous_update = False
in_text.observe(text_eventhandler, "value") salida =
widgets.Output() memoria = []
# Mostrar el cuadro de
chat
display( widgets.VBox( children=[output,

in_text], layout=widgets.Layout(display="inlineflex",
flex_flow="columnainvertida"),
)
)
Parece que podemos continuar la conversación y hacer muchas preguntas.

Con este enfoque basado en el chat, ¡creamos básicamente un chatbot que puede
razonar sobre imágenes!
Resumen
En este capítulo, exploramos varios métodos para hacer que los LLM sean multimodales
al cerrar la brecha entre las representaciones textuales y visuales. Comenzamos
analizando los transformadores para la visión, que son modelos que convierten
imágenes en representaciones numéricas. Esto se logró mediante el uso de codificadores
de imágenes e incrustaciones de parches, que permiten que el modelo procese imágenes
a varias escalas.
Luego exploramos la creación de modelos de incrustación que pueden convertir

imágenes y texto en representaciones numéricas mediante CLIP. Vimos cómo CLIP utiliza
el aprendizaje contrastivo para alinear incrustaciones de imágenes y texto en un
espacio compartido, lo que permite tareas como la clasificación de disparo cero, la agrupación y
búsqueda. El capítulo también presentó OpenCLIP, una variante de código abierto de

CLIP fácil de usar para tareas de incrustación multimodal.
Finalmente, exploramos cómo los modelos de generación de texto podrían hacerse multimodales.
y se sumergió en el modelo BLIP2. La idea central de estos textos multimodales
Los modelos de generación implican la proyección de características visuales de imágenes de entrada a
Incorporaciones de texto que pueden ser utilizadas por los LLM. Vimos cómo este modelo podría
se puede utilizar para subtítulos de imágenes y mensajes basados en chat multimodal, donde
Ambas modalidades se combinan para generar respuestas. En general, este capítulo
destacó el poder de la multimodalidad en los LLM y demostró su
aplicaciones en diversas áreas, como subtítulos de imágenes, búsqueda e indicaciones basadas
en chat.
En la Parte III del libro, cubriremos técnicas de entrenamiento y ajuste.

Capítulo 10, exploraremos cómo crear y ajustar una incrustación de texto.
modelo, que es una tecnología central que impulsa muchos modelos de lenguaje
Aplicaciones. El siguiente capítulo sirve como introducción tanto a la formación
y perfeccionar los modelos lingüísticos.
1
Jason Wei et al. “Capacidades emergentes de modelos lingüísticos de gran tamaño”. Preimpresión de arXiv
arXiv:2206.07682 (2022).
2
Alexey Dosovitskiy et al. “Una imagen vale más que 16x16 palabras: Transformadores para la imagen”
reconocimiento a escala”. preimpresión arXiv arXiv:2010.11929 (2020).
3
Alec Radford et al. “Aprendizaje de modelos visuales transferibles a partir de la supervisión del lenguaje natural”.
Conferencia internacional sobre aprendizaje automático. PMLR, 2021.
4
Robin Rombach et al. “Síntesis de imágenes de alta resolución con modelos de difusión latente”.
Actas de la Conferencia IEEE/CVF sobre visión artificial y reconocimiento de patrones, 2022.
5
Junnan Li et al. “BLIP2: Arranque del preentrenamiento de imágenes de lenguaje con imágenes congeladas
codificadores y grandes modelos de lenguaje”. Conferencia Internacional sobre Aprendizaje Automático. PMLR,
2023.
6
Haotian Liu et al. “Ajuste de instrucciones visuales”. Avances en el procesamiento de información neuronal
Sistemas 36 (2024).
7
Hugo Laurençon et al. “¿Qué es importante a la hora de construir modelos de visión y lenguaje?”, preimpresión de arXiv
arXiv:2405.02246 (2024).
8
Roy Schafer. Interpretación psicoanalítica en el test de Rorschach: teoría y aplicación
(1954).
OceanofPDF.com
Parte III. Entrenamiento y ajuste de

modelos lingüísticos
OceanofPDF.com
Capítulo 10. Creación de modelos

de incrustación de texto
Los modelos de incrustación de texto son la base de muchas aplicaciones potentes

de procesamiento del lenguaje natural. Sientan las bases para potenciar tecnologías ya
impresionantes, como los modelos de generación de texto. Ya hemos utilizado modelos
de incrustación a lo largo de este libro en varias aplicaciones, como la clasificación
supervisada, la clasificación no supervisada, la búsqueda semántica e incluso para dotar
de memoria a modelos de generación de texto como ChatGPT.
Es casi imposible exagerar la importancia de los modelos de incrustación en el campo,

ya que son la fuerza impulsora detrás de tantas aplicaciones. Por ello, en este
capítulo, analizaremos diversas formas en las que podemos crear y ajustar un modelo
de incrustación para aumentar su poder representativo y semántico.
Comencemos por descubrir qué son los modelos de inserción y cómo funcionan
generalmente.
Incorporación de modelos
Las incrustaciones y los modelos de incrustación ya se han analizado en varios capítulos
(capítulos 4, 5 y 8), lo que demuestra su utilidad. Antes de comenzar a entrenar un
modelo de este tipo, repasemos lo que hemos aprendido sobre los modelos de
incrustación.
Los datos textuales no estructurados suelen ser difíciles de procesar por sí solos. No
son valores que podamos procesar, visualizar y crear resultados procesables
directamente. Primero tenemos que convertir estos datos textuales en algo que
podamos procesar fácilmente: representaciones numéricas. Este proceso se conoce a menudo como
incrustar los vectores utilizables de entrada a salida, es decir, incrustaciones, como

se muestra en la Figura 101.
Figura 101. Utilizamos un modelo de incrustación para convertir la entrada textual, como documentos, oraciones
y frases, en representaciones numéricas, llamadas incrustaciones.
Este proceso de incrustación de la entrada normalmente lo realiza un LLM, al que

llamamos modelo de incrustación. El objetivo principal de un modelo de este tipo es
representar los datos textuales como incrustación con la mayor precisión posible.
Sin embargo, ¿qué significa ser preciso en la representación? Normalmente, queremos

capturar la naturaleza semántica (el significado) de los documentos. Si podemos capturar
el núcleo de lo que comunica el documento, esperamos haber capturado de qué trata el
documento. En la práctica, esto significa que esperamos que los vectores de documentos
que son similares entre sí sean similares, mientras que las incrustaciones de documentos
que tratan cada uno de ellos de algo completamente diferente deberían ser diferentes. Hemos
visto esta idea de similitud semántica varias veces en este libro, y se visualiza en la
Figura 102. Esta figura es un ejemplo simplificado. Si bien la visualización bidimensional
ayuda a ilustrar la proximidad y similitud de las incrustaciones, estas suelen residir en
espacios de alta dimensión.
Figura 102. La idea de la similitud semántica es que esperamos que los datos textuales con significados
similares estén más cerca entre sí en un espacio ndimensional (aquí se ilustran dos dimensiones).
Sin embargo, un modelo de inserción se puede entrenar para diversos propósitos.

Por ejemplo, cuando construimos un clasificador de sentimientos, nos interesa más el
sentimiento de los textos que su similitud semántica. Como se ilustra en la Figura
103, podemos ajustar el modelo de modo que los documentos estén más cerca en un
espacio ndimensional en función de su sentimiento en lugar de su naturaleza semántica.
De cualquier manera, un modelo de incrustación tiene como objetivo aprender qué

hace que ciertos documentos sean similares entre sí y podemos guiar este proceso.
Al presentar al modelo suficientes ejemplos de documentos semánticamente
similares, podemos orientarlo hacia la semántica, mientras que el uso de ejemplos de
sentimiento lo orientaría en esa dirección.
Figura 103. Además de la similitud semántica, un modelo de incrustación se puede entrenar para que se centre en
la similitud de sentimientos. En esta figura, las reseñas negativas (en rojo) están cerca unas de otras y son diferentes a
las reseñas positivas (en verde).
Hay muchas maneras en las que podemos entrenar, ajustar y guiar modelos
de incrustación, pero una de las técnicas más sólidas y más utilizadas se
denomina aprendizaje contrastivo.
¿Qué es el aprendizaje contrastivo?

Una de las principales técnicas para entrenar y ajustar los modelos de incrustación
de texto se denomina aprendizaje contrastivo. El aprendizaje contrastivo es una técnica
que tiene como objetivo entrenar un modelo de incrustación de modo que los
documentos similares estén más cerca en el espacio vectorial mientras que los
documentos diferentes estén más alejados. Si esto le suena familiar, es porque es muy
similar al método word2vec del Capítulo 2. Hemos visto este concepto anteriormente en las Figuras 102 y 10
La idea subyacente del aprendizaje contrastivo es que la mejor manera de aprender y

modelar la similitud/diferencia entre documentos es alimentar un modelo con ejemplos
de pares similares y diferentes. Para capturar con precisión la naturaleza semántica de un
documento, a menudo es necesario contrastarlo con otro documento para que un modelo
aprenda qué lo hace diferente o similar.
El procedimiento de contraste es bastante potente y se relaciona con el contexto en el

que se escriben los documentos. Este procedimiento de alto nivel se muestra en
la Figura 104.
Figura 104. El aprendizaje contrastivo tiene como objetivo enseñar a un modelo de integración si los documentos
son similares o diferentes. Para ello, presenta grupos de documentos a un modelo que son similares o diferentes
en un cierto grado.
Otra forma de analizar el aprendizaje contrastivo es a través de la naturaleza de

las explicaciones. Un buen ejemplo de esto es la anécdota de un periodista que le
pregunta a un ladrón “¿Por qué robaste un banco?”, a lo que él responde: “Porque ahí es
donde está el dinero”. 1 Aunque la respuesta es factualmente correcta, la intención de la
pregunta no era por qué robaba bancos específicamente, sino por qué robaba en
absoluto. Esto se llama explicación contrastiva y se refiere a la comprensión de un
caso particular, “¿Por qué P?”, en contraste con las alternativas, “¿Por qué P y no Q?”. 2
En el ejemplo, la pregunta podría interpretarse de varias maneras y se podría modelar
mejor proporcionando una alternativa: “¿Por qué robaste un banco (P) en lugar de obedecer
la ley (Q)?”.
La importancia de las alternativas para la comprensión de una pregunta también se

aplica a la forma en que una incrustación aprende a través del aprendizaje
contrastivo. Al mostrarle a un modelo pares de documentos similares y diferentes, comienza
a aprender qué hace que algo sea similar o diferente y, lo que es más importante, por qué.
Por ejemplo, se puede enseñar a un modelo a entender qué es un perro dejándolo

que encuentre características como “cola”, “nariz”, “cuatro patas”, etc. Este proceso de
aprendizaje puede ser bastante difícil, ya que las características a menudo no están bien
definidas y se pueden interpretar de varias maneras. Un ser con “cola”, “nariz” y “cuatro
patas” también puede ser un gato. Para ayudar al modelo a orientarse hacia lo que nos
interesa, básicamente le preguntamos: “¿Por qué es un perro y no un gato?”. Al
proporcionar el contraste entre dos conceptos, comienza a aprender las características.
que definen el concepto, pero también las características que no están relacionadas.
Obtenemos más información cuando formulamos una pregunta como un contraste.
Ilustramos más este concepto de explicación contrastiva en la Figura 105.
Figura 105. Cuando introducimos distintos contrastes (grados de similitud) en un modelo de incrustación, este
comienza a aprender qué hace que las cosas sean diferentes entre sí y, por lo tanto, las características distintivas
de los conceptos.
NOTA
Uno de los primeros y más populares ejemplos de aprendizaje contrastivo en PNL es word2vec, como
analizamos en los capítulos 1 y 2. El modelo aprende representaciones de palabras mediante el
entrenamiento con palabras individuales en una oración. Una palabra cercana a una palabra
objetivo en una oración se construirá como un par positivo, mientras que las palabras
muestreadas aleatoriamente constituyen pares diferentes. En otras palabras, los ejemplos positivos
de palabras vecinas se contrastan con palabras seleccionadas aleatoriamente que no son vecinas.
Aunque no es muy conocido, es uno de los primeros avances importantes en PNL que aprovecha
el aprendizaje contrastivo con redes neuronales.
Hay muchas formas en las que podemos aplicar el aprendizaje contrastivo para
crear modelos de incrustación de texto, pero la técnica y el marco más conocidos son
los transformadores de oraciones.
SBERTO
Aunque existen muchas formas de aprendizaje contrastivo, un marco que ha popularizado
la técnica dentro de la comunidad de procesamiento del lenguaje natural son los
transformadores de oraciones. 3 Su enfoque soluciona un problema importante
Problema con la implementación original de BERT para crear incrustaciones de

oraciones, a saber, su sobrecarga computacional. Antes de los transformadores
de oraciones, las incrustaciones de oraciones solían utilizar una estructura
arquitectónica llamada codificadores cruzados con BERT.
Un codificador cruzado permite pasar dos oraciones a la red Transformer

simultáneamente para predecir hasta qué punto son similares. Lo hace añadiendo un
cabezal de clasificación a la arquitectura original que puede generar una puntuación de
similitud. Sin embargo, la cantidad de cálculos aumenta rápidamente cuando se desea
encontrar el par más alto en una colección de 10 000 oraciones. Eso requeriría
n∙(n−1)/2 = 49 995 000 cálculos de inferencia y, por lo tanto, genera una sobrecarga
significativa. Además, un codificador cruzado generalmente no genera incrustaciones,
como se muestra en la Figura 106. En cambio, genera una puntuación de
similitud entre la entrada
oraciones.
Una solución a esta sobrecarga es generar incrustaciones a partir de un modelo BERT

promediando su capa de salida o utilizando el token [CLS]. Sin embargo, se ha demostrado
que esto es peor que simplemente promediar vectores de palabras, como GloVe.4
Figura 106. Arquitectura de un codificador cruzado. Ambas oraciones se concatenan, se separan con un
token <SEP> y se envían al modelo simultáneamente.
En cambio, los autores de los transformadores de oraciones abordaron el problema

de manera diferente y buscaron un método que fuera rápido y que creara
incrustaciones que pudieran compararse semánticamente. El resultado es una
alternativa elegante a la arquitectura de codificador cruzado original. A diferencia
de un codificador cruzado, en los transformadores de oraciones se omite el
cabezal de clasificación y, en su lugar, se utiliza el agrupamiento de medias en la
capa de salida final para generar una incrustación. Esta capa de agrupamiento promedia
las incrustaciones de palabras y devuelve un vector de salida de dimensión fija. Esto
garantiza una incrustación de tamaño fijo.
El entrenamiento de los transformadores de oraciones utiliza una arquitectura

siamesa. En esta arquitectura, como se visualiza en la Figura 107, tenemos dos modelos
BERT idénticos que comparten los mismos pesos y la misma arquitectura neuronal.
Estos modelos se alimentan con las oraciones a partir de las cuales se generan las
incrustaciones mediante la agrupación de incrustaciones de tokens. Luego, los
modelos se optimizan mediante la similitud de las incrustaciones de oraciones. Dado
que los pesos son idénticos para ambos modelos BERT, podemos usar un solo modelo
y alimentarlo con las oraciones una tras otra.
Figura 107. Arquitectura del modelo original de transformadores de oraciones , que aprovecha una
red siamesa, también llamada bicodificador.
El proceso de optimización de estos pares de oraciones se realiza a través de

funciones de pérdida, que pueden tener un impacto importante en el rendimiento del modelo.
Durante el entrenamiento, las incrustaciones de cada oración se concatenan.
junto con la diferencia entre las incrustaciones. Luego, esta incrustación resultante se optimiza mediante un
clasificador softmax.
La arquitectura resultante también se conoce como bicodificador o SBERT (por el término inglés sentence
BERT). Si bien un bicodificador es bastante rápido y crea representaciones precisas de oraciones, los
codificadores cruzados generalmente logran un mejor rendimiento que un bicodificador, pero
no generan incrustaciones.
El bicodificador, al igual que un codificador cruzado, aprovecha el aprendizaje contrastivo; al optimizar
la (des)similitud entre pares de oraciones, el modelo eventualmente aprenderá las cosas que hacen que
las oraciones sean lo que son.
Para realizar el aprendizaje contrastivo, necesitamos dos cosas. En primer lugar, necesitamos datos que
constituyan pares similares/diferentes. En segundo lugar, tendremos que definir cómo el modelo define y
optimiza la similitud.
Creación de un modelo de incrustación

Existen muchos métodos a través de los cuales se puede crear un modelo de incrustación, pero
generalmente, nos inclinamos por el aprendizaje contrastivo. Este es un aspecto importante de
muchos modelos de incrustación, ya que el proceso les permite aprender representaciones semánticas
de manera eficiente.
Sin embargo, este no es un proceso gratuito. Necesitaremos entender cómo generar ejemplos
contrastivos, cómo entrenar el modelo y cómo evaluarlo adecuadamente.
Generando ejemplos contrastivos

Al entrenar previamente su modelo de incrustación, a menudo verá que se utilizan datos de conjuntos de
datos de inferencia de lenguaje natural (NLI). NLI se refiere a la tarea de investigar si, para una premisa dada,
implica la hipótesis (consecuencia), la contradice (contradicción) o no es ninguna de las dos (neutral).
Por ejemplo, cuando la premisa es “Está en el cine viendo Coco” y la hipótesis “Está viendo Frozen en casa”,
entonces estas afirmaciones son contradictorias. Por el contrario, cuando la premisa es “Está en el cine
viendo Coco” y la hipótesis “Está en casa viendo Frozen”, entonces estas afirmaciones son contradictorias .
Si se considera que el sujeto está viendo la película Coco de Disney y la hipótesis “En el cine
está viendo la película Coco de Disney”, entonces estas afirmaciones se consideran
implicación. Este principio se ilustra en la Figura 108.
Figura 108. Podemos aprovechar la estructura de los conjuntos de datos NLI para generar ejemplos
negativos (contradicciones) y ejemplos positivos (consecuencias) para el aprendizaje contrastivo.
Si observamos detenidamente la implicación y la contradicción, veremos que describen el

grado en que dos entradas son similares entre sí. Por lo tanto, podemos utilizar conjuntos
de datos NLI para generar ejemplos negativos (contradicciones) y ejemplos positivos
(implicaciones) para el aprendizaje contrastivo.
Los datos que vamos a utilizar durante la creación y el ajuste de los modelos de incrustación
se derivan del parámetro de evaluación de comprensión del lenguaje general (GLUE).
Este parámetro de GLUE consta de nueve tareas de comprensión del lenguaje para
evaluar y analizar el rendimiento del modelo.
Una de estas tareas es el corpus de inferencia de lenguaje natural multigénero (MNLI), que
es una colección de 392.702 pares de oraciones anotadas con implicación
(contradicción, neutralidad, implicación). Utilizaremos un subconjunto de los datos, 50.000
pares de oraciones anotadas, para crear un ejemplo mínimo que no necesite ser entrenado
durante horas y horas. Sin embargo, tenga en cuenta que cuanto más pequeño sea el
conjunto de datos, más inestable será el entrenamiento o el ajuste fino de un modelo de
incrustación. Si es posible, se prefieren conjuntos de datos más grandes suponiendo que
siguen siendo datos de calidad:
# Cargar el conjunto de datos MNLI desde GLUE

# 0 = implicación, 1 = neutral, 2 = contradicción train_dataset = load_dataset(
"pegamento", "mnli", dividir="tren"

).select(range(50_000))
conjunto_de_datos_de_tren = conjunto_de_datos_de_tren.remove_columns("idx")
A continuación, veamos un ejemplo:
conjunto de datos[2]
{'premise': 'Uno de los nuestros llevará a cabo sus instrucciones minuciosamente.', 'hypothesis': 'Un miembro
de mi equipo
ejecutará sus órdenes
con inmensa precisión.', 'label': 0}
Esto muestra un ejemplo de una vinculación entre la premisa y la hipótesis, ya que

están relacionadas positivamente y tienen significados casi idénticos.
Modelo de tren
Ahora que tenemos nuestro conjunto de datos con ejemplos de entrenamiento,
necesitaremos crear nuestro modelo de incrustación. Normalmente, elegimos un modelo
de transformadores de oraciones existente y lo ajustamos, pero en este ejemplo, vamos
a entrenar una incrustación desde cero.
Esto significa que tendremos que definir dos cosas. Primero, un modelo Transformer
preentrenado que sirva para incorporar palabras individuales. Usaremos el modelo base
BERT (sin mayúsculas ni minúsculas). ya que es un gran modelo de introducción.
Sin embargo, existen muchos otros que también se han evaluado utilizando
transformadores de oraciones. En particular, microsoft/mpnetbase suele dar buenos
resultados cuando se utiliza como modelo de incrustación de palabras.
# Utilice un modelo base

embedding_model = SentenceTransformer('bertbaseuncased')
NOTA
De forma predeterminada, todas las capas de un LLM en transformadores de oraciones son entrenables.
Si bien es posible congelar ciertas capas, generalmente no se recomienda ya que el

rendimiento suele ser mejor cuando se descongelan todas las capas.
A continuación, necesitaremos definir una función de pérdida sobre la cual optimizaremos el

modelo. Como se mencionó al comienzo de esta sección, uno de los primeros casos de
transformadores de oraciones usa pérdida softmax.
Con fines ilustrativos, lo usaremos por ahora, pero analizaremos pérdidas de mayor rendimiento
más adelante:
de sentence_transformers importa pérdidas
# Defina la función de pérdida. En la pérdida softmax, también necesitaremos establecer

explícitamente la cantidad de etiquetas. train_loss =
las pérdidas.SoftmaxLoss( model=embedding_model,
dimensión_de_incrustación_de_oración=modelo_de_incrustación.obtener_dimensión_de_incrustación_de_oración
(), num_etiquetas=3
Antes de entrenar nuestro modelo, definimos un evaluador para evaluar el rendimiento del
modelo durante el entrenamiento, que también determina el mejor modelo para guardar.
Podemos evaluar el rendimiento de nuestro modelo utilizando el Punto de Referencia de

Similitud Textual Semántica (STSB, por sus siglas en inglés). Se trata de una colección
de pares de oraciones etiquetadas por humanos, con puntuaciones de similitud entre 1 y 5.
Utilizamos este conjunto de datos para explorar el rendimiento de nuestro modelo en esta tarea
de similitud semántica. Además, procesamos los datos de STSB para asegurarnos de que todos
los valores estén entre 0 y 1:
de sentence_transformers.evaluation importar
EmbeddingSimilarityEvaluator
# Crear un evaluador de similitud de incrustación para STSB val_sts =

load_dataset("glue", "stsb", split="validation") evaluator =
EmbeddingSimilarityEvaluator( sentence1=val_sts["sentence1"],
sentence2=val_sts["sentence2"], scores=[score/
5 para el puntaje en val_sts["label"]],
main_similarity="cosine",
Ahora que tenemos nuestro evaluador, creamos
SentenceTransformerTrainingArguments, similar al entrenamiento con transformadores de caras
abrazadas (como exploraremos en el próximo capítulo):
de sentence_transformers.training_args importar
ArgumentosDeEntrenamientoDeSentenciaTransformer
# Defina los argumentos de entrenamiento

args =
SentenceTransformerTrainingArguments( output_dir="base_embedding_model", num_train_epochs=1, pe

)
Cabe destacar los siguientes argumentos:
num_train_epochs
Número de rondas de entrenamiento. Lo mantenemos en 1 para un entrenamiento más rápido, pero
generalmente se recomienda aumentar este valor.
tamaño de lote de tren por dispositivo
El número de muestras a procesar simultáneamente en cada dispositivo (por ejemplo,
GPU o CPU) durante la evaluación. Los valores más altos generalmente significan mayor velocidad.
capacitación.
per_device_eval_batch_size La cantidad de muestras
que se procesarán simultáneamente en cada dispositivo (por ejemplo, GPU o CPU) durante la
evaluación. Los valores más altos generalmente significan una evaluación más rápida.
evaluación.
pasos de calentamiento
El número de pasos durante los cuales la tasa de aprendizaje será lineal.
Aumentó de cero a la tasa de aprendizaje inicial definida para el proceso de entrenamiento.
Tenga en cuenta que no especificamos una tasa de aprendizaje personalizada para este
proceso de entrenamiento.
FP16
Al habilitar este parámetro permitimos un entrenamiento de precisión mixto,
donde los cálculos se realizan utilizando números de punto flotante de 16 bits (FP16) en lugar
de los 32 bits predeterminados (FP32). Esto reduce el uso de memoria y potencialmente aumenta
la velocidad de entrenamiento.
Ahora que hemos definido nuestros datos, el modelo de incrustación, la pérdida y el evaluador,
podemos comenzar a entrenar nuestro modelo. Podemos hacerlo
usando SentenceTransformerTrainer:
desde sentence_transformers.trainer importar SentenceTransformerTrainer
# Entrenar el modelo de incrustación

trainer = SentenceTransformerTrainer( model=embedding_model,
args=args, train_dataset=train_dataset,
loss=train_loss,
evaluator=evaluator
) entrenador.train()
Después de entrenar nuestro modelo, podemos usar el evaluador para obtener el

rendimiento en esta única tarea:
# Evaluar nuestro modelo entrenado

evaluador(embedding_model)
{'coseno_de_pearson': 0,5982288436666162,
'coseno_de_spearman': 0,6026682018489217,
'manhattan_de_pearson': 0,6100690915500567,
'manhattan_de_spearman': 0,617732600131989,
'euclidiano_de_pearson': 0,6079280934202278,
'euclidiano_de_spearman': 0,6158926913905742, 'punto_de_pearson':
0,38364924527804595, 'punto_de_spearman':
0,37008497926991796, 'pearson_max': 0,6100690915500567,
'spearman_max': 0,617732600131989}
Obtenemos varias medidas de distancia diferentes. La que más nos interesa es

'pearson_cosine', que es la similitud del coseno entre vectores centrados. Es un valor
entre 0 y 1, donde un valor más alto indica mayores grados de similitud. Obtenemos
un valor de 0,59, que consideramos como referencia a lo largo de este capítulo.
CONSEJO
Los tamaños de lote más grandes tienden a funcionar mejor con pérdida de clasificaciones negativas
múltiples (MNR), ya que un lote más grande dificulta la tarea. La razón de esto es que el modelo necesita
encontrar la oración que mejor coincida de un conjunto más grande de pares de oraciones potenciales.
Puede adaptar el código para probar diferentes tamaños de lote y tener una idea de sus efectos.
Evaluación en profundidad
Un buen modelo de incrustación es más que una buena puntuación en el benchmark

STSB. Como hemos observado anteriormente, el benchmark GLUE tiene una serie de tareas
para las que podemos evaluar nuestro modelo de incrustación. Sin embargo, existen muchos
más benchmarks que permiten la evaluación de modelos de incrustación.
Para unificar este procedimiento de evaluación, se ha desarrollado la técnica de incrustación masiva de texto.
Se desarrolló el modelo de referencia (MTEB).5 El MTEB abarca ocho tareas de integración que cubren
58 conjuntos de datos y 112 idiomas.
Para comparar públicamente los modelos de incrustación de última generación, se creó una tabla de
clasificación Se creó con las puntuaciones de cada modelo de incrustación en todas las tareas:
Desde mteb importar MTEB
# Elija la tarea de evaluación evaluation

= MTEB(tasks=["Banking77Classification"])
# Calcular resultados results =

evaluation.run(model)
{'Clasificación77Banca': {'mteb_version': '1.1.2',

'revisión del conjunto de datos':
'0fd18e25b25c072e09e0d92ab615fda904d66300',
'mteb_dataset_name': 'Clasificación bancaria77', 'prueba': {'precisión':
0,4926298701298701, 'f1': 0,49083335791288685, 'precisión_stderr':
0,010217785746224237, 'f1_stderr':
0,010265814957074591, 'puntuación_principal': 0,4926298701298701,
'tiempo_de_evaluación': 31,83}}}
Esto nos proporciona varias métricas de evaluación para esta tarea específica que podemos usar
para explorar su desempeño.
Lo bueno de este modelo de evaluación no es solo la diversidad de tareas e idiomas, sino que también
se ahorra tiempo de evaluación. Aunque existen muchos modelos de incrustación, normalmente queremos
aquellos que sean precisos y tengan baja latencia. Las tareas para las que se utilizan modelos
de incrustación, como la búsqueda semántica, suelen beneficiarse de una inferencia rápida y la
requieren.
Dado que probar su modelo en todo el MTEB puede llevar un par de horas dependiendo de su GPU,
utilizaremos el benchmark STSB a lo largo de este capítulo con fines ilustrativos.
CONSEJO
Cuando haya terminado de entrenar y evaluar su modelo, es importante reiniciar el notebook. Esto
limpiará su VRAM para los próximos ejemplos de entrenamiento a lo largo de este capítulo. Al
reiniciar el notebook, podemos estar seguros de que toda la VRAM se haya limpiado.
Funciones de pérdida
Entrenamos nuestro modelo utilizando la pérdida softmax para ilustrar cómo se entrenó uno
de los primeros modelos de transformadores de oraciones. Sin embargo, no solo hay una
gran variedad de funciones de pérdida para elegir, sino que la pérdida softmax generalmente
no se recomienda ya que existen pérdidas de mayor rendimiento.
En lugar de analizar cada una de las funciones de pérdida que existen, hay dos funciones de pérdida
que se utilizan habitualmente y que parecen funcionar generalmente bien, a saber:
Semejanza de coseno
Pérdida de clasificación de negativos múltiples (MNR)
NOTA
Hay muchas más funciones de pérdida para elegir que las que se analizan aquí. Por ejemplo, una
pérdida como MarginMSE funciona muy bien para entrenar o ajustar un codificador cruzado.
Hay una serie de funciones de pérdida interesantes implementadas en el marco de los
transformadores de oraciones.
Semejanza de coseno
La pérdida de similitud de coseno es una pérdida intuitiva y fácil de usar que funciona en muchos
casos de uso y conjuntos de datos diferentes. Se suele utilizar en tareas de similitud textual semántica.
En estas tareas, se asigna una puntuación de similitud a los pares de textos sobre los que
optimizamos el modelo.
En lugar de tener pares de oraciones estrictamente positivas o negativas, asumimos pares de oraciones
que son similares o diferentes hasta cierto grado.
Normalmente, este valor se encuentra entre 0 y 1 para indicar disimilitud y

similitud, respectivamente (Figura 109).
Figura 109. La pérdida de similitud de coseno tiene como objetivo minimizar la distancia del coseno entre
oraciones semánticamente similares y maximizar la distancia entre oraciones semánticamente diferentes.
La pérdida de similitud de coseno es sencilla: calcula la similitud de coseno entre las

dos incrustaciones de los dos textos y la compara con la puntuación de similitud
etiquetada. El modelo aprenderá a reconocer el grado de similitud entre oraciones.
La pérdida de similitud de coseno funciona intuitivamente mejor cuando se utilizan

datos en los que hay pares de oraciones y etiquetas que indican su similitud entre 0 y 1.
Para utilizar esta pérdida con nuestro conjunto de datos NLI, necesitamos convertir las
etiquetas de implicación (0), neutralidad (1) y contradicción (2) a valores entre 0 y 1.
La implicación representa una alta similitud entre las oraciones, por lo que le damos una
puntuación de similitud de 1. Por el contrario, dado que tanto la neutralidad como la
contradicción representan disimilitud, les damos a estas etiquetas una puntuación de similitud de 0:
desde conjuntos de datos importar conjunto de datos, cargar_conjunto de datos

"pegamento", "mnli",
dividir="tren" ).seleccionar(rango(50_000))
conjunto_de_datos_del_tren = conjunto_de_datos_del_tren.eliminar_columnas("idx")
# (neutral/contradicción)=0 y (consecuencia)=1 mapping = {2: 0, 1: 0, 0:1}

train_dataset = Dataset.from_dict({
"sentence1": train_dataset["premisa"], "sentence2":

train_dataset["hipótesis"], "label": [float(mapping[label]) para la
etiqueta en
conjunto_de_datos_del_tren["etiqueta"]] })
Como antes, creamos nuestro evaluador:
de sentence_transformers.evaluation importar EmbeddingSimilarityEvaluator
# Crear un evaluador de similitud de incrustación para stsb val_sts = load_dataset("glue",

"stsb", split="validation") evaluator = EmbeddingSimilarityEvaluator( sentence1=val_sts["sentence1"],
sentence2=val_sts["sentence2"], scores=[score/5 para el puntaje en
val_sts["label"]], main_similarity="cosine"
Luego, seguimos los mismos pasos que antes pero seleccionamos una pérdida diferente:
de sentence_transformers importar pérdidas, SentenceTransformer de sentence_transformers.trainer

importar
SentenceTransformerTrainer de
sentence_transformers.training_args importa SentenceTransformerTrainingArguments
# Definir modelo
embedding_model = SentenceTransformer("bertbaseuncased")
# Función de pérdida
train_loss = pérdidas.CosineSimilarityLoss(modelo=embedding_model)
# Defina los argumentos de entrenamiento args =

SentenceTransformerTrainingArguments( output_dir="cosineloss_embedding_model",
num_train_epochs=1, per_device_train_batch_size=32,
per_device_eval_batch_size=32,
warmup_steps=100, fp16=True, eval_steps=100,
logging_steps=100,
# Entrenar modelo
trainer = SentenceTransformerTrainer( modelo=modelo_incrustado,
args=args,
conjunto_de_datos_de_entrenamiento=conjunto_de_datos_de_entrenamiento, pérdida=pérdida_de_entrenamiento, evaluado
Evaluando el modelo después del entrenamiento nos da la siguiente puntuación:

'euclidiano_de_pearson': 0,7332716434966307,
'euclidiano_de_spearman': 0,7316999722750905, 'punto_de_pearson':
0,6624167554844425,
'pearson_max': 0,7338163436711481,
'spearman_max': 0,7323479193408869}
Una puntuación de coseno de Pearson de 0,72 es una gran mejora en comparación con el
ejemplo de pérdida de softmax, que obtuvo una puntuación de 0,59. Esto demuestra el impacto que
puede tener la función de pérdida en el rendimiento.
Asegúrese de reiniciar su computadora portátil para que podamos explorar una pérdida más común y de
mayor rendimiento, es decir, la pérdida de clasificación de múltiples negativos.
Pérdida de clasificación por múltiples negativos La
pérdida de clasificación por múltiples negativos (MNR),6 a menudo denominada InfoNCE7 o
NTXentLoss,8 es una pérdida que utiliza pares de oraciones positivas o tripletes que contienen un par de
oraciones positivas y una oración adicional no relacionada. Esta oración no relacionada se
denomina negativa y representa la disimilitud entre las oraciones positivas.
Por ejemplo, puede tener pares de pregunta/respuesta, imagen/título de imagen, título del
artículo/resumen del artículo, etc. Lo bueno de estos pares es que podemos estar seguros de que son
pares positivos sólidos. En la pérdida de MNR (Figura 1010), los pares negativos se
construyen mezclando un par positivo con otro par positivo. En el ejemplo de un título y resumen
de un artículo, generaría un par negativo combinando el título de un artículo con un resumen
completamente diferente. Estos negativos se denominan negativos en lote y también se pueden
utilizar para generar los tripletes.
Figura 1010. La pérdida de clasificación por múltiples negativos tiene como objetivo minimizar la distancia entre pares de
texto relacionados, como preguntas y respuestas, y maximizar la distancia entre pares de texto no relacionados, como
preguntas y respuestas no relacionadas.
Después de haber generado estos pares positivos y negativos, calculamos sus incrustaciones
y aplicamos la similitud de coseno. Estos puntajes de similitud se utilizan luego para
responder la pregunta: ¿estos pares son negativos o positivos? En otras palabras, se trata
como una tarea de clasificación y podemos usar la pérdida de entropía cruzada para optimizar el
modelo.
Para crear estos tripletes, comenzamos con una oración de referencia (es decir, etiquetada
como “premisa”), que se utiliza para comparar otras oraciones. Luego, utilizando el
conjunto de datos MNLI, solo seleccionamos pares de oraciones que sean positivas (es decir,
etiquetadas como “consecuencia”). Para agregar oraciones negativas, tomamos muestras
aleatorias de oraciones como “hipótesis”.
importar aleatorio
conjuntos de datos importar conjunto de datos, cargar_conjunto de datos
# # Cargar el conjunto de datos MNLI desde GLUE

mnli = load_dataset("glue", "mnli",
split="train").select(range(50_000)) mnli =
mnli.remove_columns("idx") mnli = mnli.filter(lambda x:
True if x["label"] == 0 else False)
# Preparar datos y agregar un negativo suave train_dataset =

{"anchor": [], "positive": [], "negative": []} soft_negatives = mnli["hypothesis"] random.shuffle(soft_negatives)
for row, soft_negative in tqdm(zip(mnli, soft_negatives)):
conjunto_de_datos_de_tren["ancla"].append(fila["premisa"])
conjunto_de_datos_de_tren["positivo"].append(fila["hipótesis"])
conjunto_de_datos_de_tren["negativo"].append(negativo_suave)
conjunto_de_datos_de_tren = Conjunto_de_datos.from_dict(conjunto_de_datos_de_tren)
Como sólo seleccionamos oraciones etiquetadas con “consecuencia”, el número de

filas se redujo bastante, de 50.000 a 16.875 filas.
Definamos al evaluador:
de sentence_transformers.evaluation import EmbeddingSimilarityEvaluator

# Crear un evaluador de similitud de incrustación
para stsb val_sts = load_dataset("glue", "stsb", split="validation") evaluator =
EmbeddingSimilarityEvaluator( sentence1=val_sts["sentence1"], sentence2=val_sts["sentence2"],
scores=[score/5 para el puntaje en val_sts["label"]],
main_similarity="cosine"
Luego entrenamos como antes pero con pérdida de MNR:

importar SentenceTransformerTrainer
de sentence_transformers.training_args importar
ArgumentosDeEntrenamientoDeSentenciaTransformer
# Definir modelo
embedding_model = SentenceTransformer('bertbaseuncased')
train_loss =
pérdidas.MultipleNegativesRankingLoss(model=embedding_model)

SentenceTransformerTrainingArguments( output_dir="mnrloss_embedding_model",
logging_steps=100,
# Entrenar modelo
args=args,
Veamos cómo se comparan este conjunto de datos y la función de pérdida con nuestros
ejemplos anteriores:

'euclidiana_de_pearson': 0,8210391407846718,
'euclidiana_de_spearman': 0,8166537141010816, 'punto_de_pearson':
0,7473360302629125,
Punto de Spearman: 0,7345184137194012, máximo de Pearson:

0,8215001523827565, máximo de Spearman:
0,8172161486524246
En comparación con nuestro modelo entrenado previamente con pérdida softmax (0,72),
¡nuestro modelo con pérdida MNR (0,80) parece ser mucho más preciso!
CONSEJO
Los tamaños de lote más grandes tienden a ser mejores con la pérdida de MNR, ya que un lote más
grande hace que la tarea sea más difícil. La razón de esto es que el modelo necesita encontrar la
oración que mejor coincida de un conjunto más grande de pares de oraciones potenciales. Puede adaptar el
código para probar diferentes tamaños de lote y tener una idea de los efectos.
Hay una desventaja en la forma en que usamos esta función de pérdida. Dado que los
negativos se toman de otros pares de preguntas/respuestas, estos negativos en
lote o "fáciles" que usamos podrían potencialmente no estar relacionados en absoluto
con la pregunta. Como resultado, la tarea del modelo de incrustación de encontrar la
respuesta correcta a una pregunta se vuelve bastante fácil. En cambio, nos gustaría
tener negativos que estén muy relacionados con la pregunta pero que no sean la respuesta correcta.
Estos negativos se denominan negativos duros. Dado que esto dificultaría la tarea del
modelo de incrustación, ya que debe aprender representaciones más matizadas, el
rendimiento del modelo de incrustación generalmente mejora bastante.
Un buen ejemplo de una negativa dura es el siguiente. Supongamos que tenemos la

siguiente pregunta: “¿Cuántas personas viven en Ámsterdam?” Una respuesta relacionada
con esta pregunta sería: “Casi un millón de personas viven en Ámsterdam”. Para
generar una buena negativa dura, lo ideal sería que la respuesta contenga algo sobre
Ámsterdam y la cantidad de personas que viven en esta ciudad. Por ejemplo: “Más de un
millón de personas viven en Utrecht, que es más que Ámsterdam”. Esta respuesta se
relaciona con la pregunta, pero no es la respuesta real, por lo que sería una buena
negativa dura. La Figura 1011 ilustra las diferencias entre las negativas fáciles y
duras.
Figura 1011. Una negativa fácil generalmente no está relacionada con la pregunta ni con la respuesta. Una negativa
semidura tiene algunas similitudes con el tema de la pregunta y la respuesta, pero no está relacionada en absoluto.
Una negativa dura es muy similar a la pregunta, pero generalmente es la respuesta incorrecta.
La recopilación de negativos se puede dividir aproximadamente en los tres siguientes:

procesos:
Negativos fáciles
A través de un muestreo aleatorio de documentos como hicimos antes.
Negativos semiduros
Usando un modelo de incrustación entrenado previamente, podemos aplicar la similitud de coseno en
todas las incrustaciones de oraciones para encontrar aquellas que están altamente relacionadas. Generalmente,
Esto no conduce a negaciones duras ya que este método simplemente encuentra oraciones
similares, no pares de pregunta/respuesta.
Negativos duros
A menudo es necesario etiquetarlos manualmente (por ejemplo, generando negaciones
semiduras) o puede usar un modelo generativo para juzgar o generar pares de oraciones.
Asegúrese de reiniciar su computadora portátil para que podamos explorar los diferentes métodos
para ajustar los modelos de incrustación.
Ajuste fino de un modelo de incrustación

En la sección anterior, repasamos los conceptos básicos del entrenamiento de un
modelo de incrustación desde cero y vimos cómo podríamos aprovechar las funciones de
pérdida para optimizar aún más su rendimiento. Este enfoque, aunque bastante potente, requiere la
creación de un modelo de incrustación desde cero. Este proceso puede ser bastante costoso y requerir
mucho tiempo.
En cambio, el marco de trabajo de los transformadores de oraciones permite que casi todos los
modelos de incrustación se utilicen como base para realizar ajustes. Podemos elegir un modelo de
incrustación que ya se haya entrenado con una gran cantidad de datos y ajustarlo para nuestros
datos o propósitos específicos.
Existen varias formas de ajustar el modelo, según la disponibilidad de datos y el dominio.

Analizaremos dos de estos métodos y demostraremos la eficacia de aprovechar los
modelos de incrustación entrenados previamente.
Supervisado
La forma más sencilla de ajustar un modelo de incrustación es repetir el proceso de entrenamiento de
nuestro modelo como lo hicimos antes, pero reemplazando el modelo 'bertbaseuncased' con un
modelo de transformadores de oraciones previamente entrenado. Hay muchos para elegir,
pero en general, el modelo allMiniLML6 v2 funciona bien en muchos casos de uso. y debido a su
pequeño tamaño es bastante rápido.
Usamos los mismos datos que usamos para entrenar nuestro modelo en el ejemplo de
pérdida de MNR, pero en su lugar usamos un modelo de incrustación entrenado previamente

para realizar ajustes. Como siempre, comencemos cargando los datos y creando el evaluador:
desde conjuntos de datos importar

load_dataset desde sentence_transformers.evaluation
importar EmbeddingSimilarityEvaluator

"pegamento", "mnli",
dividir="tren" ).seleccionar(rango(50_000)) conjunto_de_datos_del_tren = conjunto_de_datos_del_tren.eliminar_c

Los pasos de entrenamiento son similares a nuestros ejemplos anteriores, pero en lugar
de usar 'bertbaseuncased', podemos usar un modelo de incrustación entrenado
previamente:

importar SentenceTransformerTrainer de
sentence_transformers.training_args importar
SentenceTransformerTrainingArguments
# Definir modelo
embedding_model = SentenceTransformer('sentencetransformers/all
MiniLML6v2')
train_loss =
pérdidas.MultipleNegativesRankingLoss(model=embedding_model)

SentenceTransformerTrainingArguments( output_dir="finetuned_embedding_model",
pasos_de_registro=100,
)
# Entrenar modelo
args=args,
Evaluando este modelo obtenemos la siguiente puntuación:

0,8484676559567688, 'pearson_max': 0,8513115442079158,
'spearman_max': 0,8484676559567688}
Aunque la puntuación de 0,85 es la más alta que hemos visto hasta ahora, el modelo entrenado
previamente que utilizamos para el ajuste fino ya se había entrenado en el conjunto de datos
MNLI completo, mientras que nosotros solo utilizamos 50 000 ejemplos. Puede parecer
redundante, pero este ejemplo demuestra cómo ajustar un modelo de incrustación entrenado
previamente en sus propios datos.
CONSEJO
En lugar de utilizar un modelo BERT entrenado previamente como "bertbaseuncased" o un

posible modelo fuera del dominio como "allmpnetbasev2", también puede realizar un modelado de
lenguaje enmascarado en el modelo BERT entrenado previamente para adaptarlo primero a su
dominio. Luego, puede utilizar este modelo BERT ajustado como base para entrenar su modelo de
incrustación. Esta es una forma de adaptación del dominio. En el próximo capítulo, aplicaremos el
modelado de lenguaje enmascarado en un modelo entrenado previamente.
Tenga en cuenta que la principal dificultad de entrenar o ajustar su modelo es encontrar los datos
correctos. Con estos modelos, no solo queremos tener conjuntos de datos muy grandes,
sino que los datos en sí deben ser de alta calidad. Desarrollar pares positivos
generalmente es sencillo, pero agregar pares negativos estrictos aumenta significativamente
la dificultad de crear datos de calidad.
Como siempre, reinicie su computadora portátil para liberar VRAM para los siguientes
ejemplos.
SBERT aumentada
Una desventaja de entrenar o ajustar estos modelos de incrustación es que a menudo
requieren una cantidad sustancial de datos de entrenamiento. Muchos de estos modelos
se entrenan con más de mil millones de pares de oraciones. Por lo general, no es posible
extraer una cantidad tan alta de pares de oraciones para su caso de uso, ya que en muchos
casos solo hay un par de miles de puntos de datos etiquetados disponibles.
Afortunadamente, existe una forma de aumentar sus datos de modo que se pueda ajustar un
modelo de incorporación cuando solo hay unos pocos datos etiquetados disponibles.
9
Este procedimiento se denomina SBERT aumentado.
En este procedimiento, nuestro objetivo es aumentar la pequeña cantidad de datos etiquetados

de modo que se puedan utilizar para el entrenamiento regular. Se hace uso de la arquitectura de
codificador cruzado (BERT), más lenta y precisa, para aumentar y etiquetar un conjunto más
grande de pares de entrada. Estos pares recién etiquetados se utilizan luego para ajustar un
codificador bidireccional (SBERT).
Como se muestra en la Figura 1012, SBERT Aumentado implica los siguientes pasos:
1. Ajuste un codificador cruzado (BERT) utilizando un conjunto de datos pequeño y anotado (conjunto
de datos de oro).
2. Crea nuevos pares de oraciones.
3. Etiquete los nuevos pares de oraciones con el codificador cruzado afinado (plata)
conjunto de datos).
4. Entrene un bicodificador (SBERT) en el conjunto de datos extendido (oro + plata)
conjunto de datos).
En este caso, un conjunto de datos de oro es un conjunto de datos pequeño pero completamente anotado
que contiene la verdad fundamental. Un conjunto de datos de plata también está completamente anotado,
pero no es necesariamente la verdad fundamental, ya que se generó a través de predicciones del

codificador cruzado.
Figura 1012. La SBERT aumentada funciona mediante el entrenamiento de un codificador cruzado en un pequeño conjunto de datos de oro y
luego lo utiliza para etiquetar un conjunto de datos sin etiquetar para generar un conjunto de datos de plata más grande. Finalmente, tanto
los conjuntos de datos de oro como de plata se utilizan para entrenar el bicodificador.
Antes de pasar a los pasos anteriores, preparemos primero los datos. En lugar de los 50 000 documentos
originales, tomamos un subconjunto de 10 000 documentos para simular un entorno en el que tenemos datos
anotados limitados. Como hicimos en nuestro ejemplo con pérdida de similitud de coseno, le damos a la
implicación una puntuación de 1, mientras que a la neutralidad y la contradicción les damos una puntuación
de 0:


conjuntos de datos importar load_dataset, Conjunto de datos
desde sentence_transformers importar InputExample desde
sentence_transformers.datasets importar NoDuplicatesDataLoader
# Preparar un pequeño conjunto de 10000 documentos para el codificador cruzado dataset =

load_dataset("glue", "mnli", split="train").select(range(10_000))
mapping = {2: 0, 1: 0, 0:1}
# Cargador de datos
gold_examples = [
InputExample(textos=[fila["premisa"], fila["hipótesis"]],
etiqueta=mapping[fila["etiqueta"]]) para la fila
en tqdm(conjunto de datos)
] gold_dataloader = NoDuplicatesDataLoader(gold_examples, tamaño_lote=32)
# Pandas DataFrame para un manejo más sencillo de los datos gold =

pd.DataFrame( { "sentence1":
dataset["premise"], "sentence2": dataset["hypothesis"],

"label": [mapping[label] for label in dataset["label"]] }
Este es el conjunto de datos de oro, ya que está etiquetado y representa nuestra verdad fundamental.
Usando este conjunto de datos de oro, entrenamos nuestro codificador cruzado (paso 1):
desde sentence_transformers.cross_encoder importar CrossEncoder
# Entrena un codificador cruzado en el conjunto de datos de oro

cross_encoder = CrossEncoder("bertbaseuncased", num_labels=2)
cross_encoder.fit( train_dataloader=gold_dataloader, epochs=1,
show_progress_bar=True,
warmup_steps=100,
use_amp=False
)
Después de entrenar nuestro codificador cruzado, utilizamos los 400.000 pares de oraciones restantes
(de nuestro conjunto de datos original de 50.000 pares de oraciones) como nuestro conjunto de
datos de plata (paso 2):
# Prepare el conjunto de datos de plata prediciendo etiquetas con el codificador cruzado silver = load_dataset( "glue",
"mnli",
split="train"
).select(range(10_000, 50_000)) pares =

lista(zip(plata["premisa"], plata["hipótesis"]))
CONSEJO
Si no tiene pares de oraciones adicionales sin etiquetar, puede tomar una muestra aleatoria de ellos
de su conjunto de datos original. Para ilustrarlo, puede crear un nuevo par de oraciones tomando la
premisa de una fila y la hipótesis de otra. Esto le permite generar fácilmente 10 veces más pares de
oraciones que se pueden etiquetar con el codificador cruzado.
Esta estrategia, sin embargo, probablemente genere pares significativamente más diferentes que similares.
En cambio, podemos utilizar un modelo de incrustación entrenado previamente para incrustar todos los pares de
oraciones candidatas y recuperar las k oraciones principales para cada oración de entrada mediante una
búsqueda semántica. Este proceso de reordenamiento aproximado nos permite centrarnos en los pares de
oraciones que probablemente sean más similares. Aunque las oraciones se siguen eligiendo en función de una
aproximación, ya que el modelo de incrustación entrenado previamente no se entrenó con nuestros datos, es mucho
mejor que el muestreo aleatorio.
Tenga en cuenta que asumimos que estos pares de oraciones no están etiquetados en este ejemplo.
Utilizaremos nuestro codificador cruzado perfeccionado para etiquetar estos pares de oraciones (paso 3):
# Etiquete los pares de oraciones usando nuestro codificador cruzado ajustado output =
cross_encoder.predict( pairs, apply_softmax=True,
show_progress_bar=True ) silver =
pd.DataFrame(
{
"oración1": plata["premisa"], "oración2":
plata["hipótesis"], "etiqueta": np.argmax(salida, eje=1)
}
)
Ahora que tenemos un conjunto de datos de plata y oro, simplemente los combinamos y
entrenamos nuestro modelo de incorporación como lo hicimos antes:
# Combinar oro + plata datos =

pd.concat([oro, plata], ignore_index=True, axis=0) datos = datos.drop_duplicates(subconjunto=["oración1",
"oración2"], keep="first") conjunto_de_datos_entrenamiento = Dataset.from_pandas(datos,
preserve_index=False)
Como siempre, necesitamos definir nuestro evaluador:
de sentence_transformers.evaluation importar EmbeddingSimilarityEvaluator

Entrenamos el modelo igual que antes excepto que ahora usamos el conjunto de datos aumentado:

importar SentenceTransformerTrainer de
sentence_transformers.training_args importar
SentenceTransformerTrainingArguments
# Definir modelo
modelo_de_incrustación = Transformador_de_sentencia("bertbasesincasilla")
train_loss = pérdidas.CosineSimilarityLoss(modelo=embedding_model)

SentenceTransformerTrainingArguments( output_dir="augmented_embedding_model",
logging_steps=100,
# Entrenar modelo
args=args,
Finalmente evaluamos el modelo:
evaluador(modelo_incrustado)
0,6754486790570754, 'pearson_max': 0,7296749443525249,
'spearman_max': 0,7284184255293913}
El ejemplo original de pérdida de similitud de coseno tenía una puntuación de 0,72 con el conjunto
de datos completo. ¡Usando solo el 20 % de esos datos, logramos obtener una puntuación de 0,71!
Este método nos permite aumentar el tamaño de los conjuntos de datos que ya tiene disponibles sin
necesidad de etiquetar manualmente cientos de miles de pares de oraciones. Puede probar
la calidad de sus datos de plata entrenando también su modelo de incrustación solo en el conjunto
de datos de oro. La diferencia en el rendimiento indica cuánto puede agregar
potencialmente su conjunto de datos de plata a la calidad del modelo.
Puedes reiniciar tu notebook una última vez para el último ejemplo, es decir, el aprendizaje no
supervisado.
Aprendizaje no supervisado
Para crear un modelo de incrustación, normalmente necesitamos datos etiquetados. Sin embargo, no
todos los conjuntos de datos del mundo real vienen con un buen conjunto de etiquetas que podamos usar.
En cambio, buscamos técnicas para entrenar el modelo sin etiquetas

predeterminadas: aprendizaje no supervisado. Existen muchos enfoques, como el aprendizaje
contrastivo simple de incrustaciones de oraciones (SimCSE), Tensión Contrastiva (TC), 10

11 Eliminación automática de ruido secuencial basada en transformador
Codificador (TSDAE), 12 y PseudoEtiquetado Generativo (GPL). 13
En esta sección, nos centraremos en TSDAE, ya que ha demostrado un gran rendimiento en tareas
no supervisadas así como en adaptación de dominio.
Codificador automático de eliminación de ruido secuencial basado en transformador
TSDAE es un enfoque muy elegante para crear un modelo de incrustación con aprendizaje no
supervisado. El método supone que no tenemos datos etiquetados y no requiere que creemos
etiquetas de forma artificial.
La idea subyacente de TSDAE es que agregamos ruido a la oración de entrada eliminando un cierto
porcentaje de palabras de ella. Esta oración "dañada" se pasa a través de un codificador, con una
capa de agrupamiento encima, para asignarla a una incrustación de oración. A partir de esta
incrustación de oración, un decodificador intenta
Reconstruir la oración original a partir de la oración “dañada”, pero sin el ruido artificial.
El concepto principal aquí es que cuanto más precisa sea la inserción de la oración,
más precisa será la oración reconstruida.
Este método es muy similar al modelado de lenguaje enmascarado, en el que intentamos

reconstruir y aprender ciertas palabras enmascaradas. Aquí, en lugar de reconstruir
palabras enmascaradas, intentamos reconstruir la oración completa.
Después del entrenamiento, podemos usar el codificador para generar incrustaciones

a partir del texto, ya que el decodificador solo se utiliza para juzgar si las
incrustaciones pueden reconstruir con precisión la oración original (Figura 1013).
Figura 1013. TSDAE elimina aleatoriamente palabras de una oración de entrada que se pasa a través de un
codificador para generar una incrustación de oración. A partir de esta incrustación de oración, se reconstruye la
oración original.
Dado que solo necesitamos un conjunto de oraciones sin etiquetas, entrenar este modelo es
sencillo. Comenzamos descargando un tokenizador externo, que se utiliza para el procedimiento
de eliminación de ruido:
# Descargar tokenizador adicional import nltk

nltk.download("punkt")
Luego, creamos oraciones planas a partir de nuestros datos y eliminamos cualquier etiqueta que
tengamos para imitar una configuración no supervisada:

conjuntos de datos importar Conjunto de datos, cargar_conjunto
de datos desde sentence_transformers.datasets importar
DenoisingAutoEncoderDataset
# Crea una lista plana de oraciones mnli =

load_dataset("glue", "mnli", split="train").select(range(25_000))
flat_sentences = mnli["premise"] + mnli["hypothesis"]
# Agregar ruido a nuestros datos de entrada

damaged_data =
Conjunto de datos del codificador automático de eliminación de ruido (lista (conjunto (sentencias_planas)))
# Crear conjunto de datos

train_dataset = {"damaged_sentence": [], "original_sentence": []} para los datos en tqdm(damaged_data):
conjunto_de_datos_de_tren["oración_dañada"].append(datos.textos[0])
conjunto_de_datos_de_tren["oración_original"].append(datos.textos[1])
conjunto_de_datos_de_tren = Conjunto_de_datos.from_dict(conjunto_de_datos_de_tren)
Esto crea un conjunto de datos de 50.000 oraciones. Cuando examinamos los datos, observamos
que la primera oración es la oración dañada y la segunda la original:
conjunto_de_datos_del_tren[0]
{'damaged_sentence': 'Las mandíbulas sombrías son.',

'original_sentence': 'Los rostros sombríos y las mandíbulas endurecidas no son

amigable con la gente.'}
La primera oración muestra los datos “ruidosos”, mientras que la segunda muestra la
oración de entrada original. Después de crear nuestros datos, definimos nuestro evaluador
como antes:
de sentence_transformers.evaluation importar
EmbeddingSimilarityEvaluator
# Crear un evaluador de similitud de incrustación para stsb val_sts =

load_dataset("glue", "stsb", split="validation") evaluator =
EmbeddingSimilarityEvaluator( sentence1=val_sts["sentence1"],
sentence2=val_sts["sentence2"],
scores=[score/5 para el puntaje en
A continuación, ejecutamos el entrenamiento como antes, pero con el token [CLS] como
estrategia de agrupación en lugar de la agrupación media de las incrustaciones de
tokens. En el artículo de TSDAE, se demostró que esto era más eficaz, ya que la
agrupación media pierde la información de posición, lo que no sucede cuando se utiliza el
token [CLS]:
desde sentence_transformers importar modelos, SentenceTransformer
# Crea tu modelo de incrustación

word_embedding_model = models.Transformer("bertbaseuncased") pooling_model
=
models.Pooling(word_embedding_model.get_word_embedding_dimension( ), "cls")
embedding_model = SentenceTransformer(modules=
[word_embedding_model, pooling_model])
Usando nuestros pares de oraciones, necesitaremos una función de pérdida que

intente reconstruir la oración original usando la oración de ruido, a saber,
DenoisingAutoEncoderLoss. Al hacerlo, aprenderá cómo
Representar con precisión los datos. Es similar al enmascaramiento, pero sin saber dónde están las
máscaras reales.
Además, vinculamos los parámetros de ambos modelos. En lugar de tener pesos separados para la capa
de incrustación del codificador y la capa de salida del decodificador, comparten los mismos pesos. Esto
significa que cualquier actualización de los pesos en una capa se reflejará también en la otra capa:
de sentence_transformers importa pérdidas
# Utilice la pérdida del codificador automático de eliminación de

ruido train_loss = losts.DenoisingAutoEncoderLoss( embedding_model,
tie_encoder_decoder=True
) pérdida_de_tren.decodificador = pérdida_de_tren.decodificador.to("cuda")
Finalmente, el entrenamiento de nuestro modelo funciona de la misma manera que hemos visto varias
veces antes, pero reducimos el tamaño del lote a medida que aumenta la memoria con esta
función de pérdida:
de sentence_transformers.trainer importar SentenceTransformerTrainer

de sentence_transformers.training_args
importar SentenceTransformerTrainingArguments

SentenceTransformerTrainingArguments( output_dir="tsdae_embedding_model",
logging_steps=100,
# Entrenar modelo
trainer = SentenceTransformerTrainer( modelo=embedding_model,
args=args,
conjunto_de_datos_de_tren=conjunto_de_datos_de_tren,
pérdida=pérdida_de_tren,
evaluador=evaluador
Después del entrenamiento, evaluamos nuestro modelo para explorar qué tan bien funciona
esta técnica no supervisada:

0,5104025515225046, 'pearson_max': 0,7152343356643568,
'spearman_max': 0,7202291660769805}
Después de ajustar nuestro modelo, obtuvimos una puntuación de 0,70, lo cual es bastante
impresionante considerando que hicimos todo este entrenamiento con datos sin etiquetar.
Uso de TSDAE para la adaptación de dominios

Cuando se dispone de muy pocos datos etiquetados o ninguno, normalmente se utiliza el aprendizaje
no supervisado para crear el modelo de incrustación de texto. Sin embargo, las técnicas no
supervisadas suelen ser superadas por las técnicas supervisadas y tienen dificultades para
aprender conceptos específicos del dominio.
Aquí es donde entra en juego la adaptación de dominios . Su objetivo es actualizar los modelos de
incrustación existentes a un dominio textual específico que contiene diferentes temas del dominio
de origen. La Figura 1014 demuestra cómo los dominios pueden diferir en contenido. El dominio de
destino, o dominio externo, generalmente contiene palabras y temas que no se encontraron en el dominio
de origen o en el dominio interno.
Figura 1014. En la adaptación de dominios, el objetivo es crear y generalizar un modelo de incrustación de un

dominio a otro.
Un método para la adaptación de dominios se denomina preentrenamiento adaptativo. Se

comienza por preentrenar el corpus específico de un dominio utilizando una técnica
no supervisada, como la TSDAE o el modelado de lenguaje enmascarado que se analizaron
anteriormente. Luego, como se ilustra en la Figura 1015, se ajusta ese modelo utilizando
un conjunto de datos de entrenamiento que puede estar fuera o dentro del dominio de destino.
Aunque se prefieren los datos del dominio de destino, los datos fuera del dominio también
funcionan ya que comenzamos con entrenamiento no supervisado en el dominio de destino.
Figura 1015. La adaptación del dominio se puede realizar con preentrenamiento adaptativo y ajuste fino
adaptativo.
Con todo lo que aprendió en este capítulo, debería poder reproducir esta secuencia de
comandos. Primero, puede comenzar con TSDAE para entrenar un modelo de
incrustación en su dominio de destino y luego ajustarlo con entrenamiento supervisado
general o SBERT aumentado.
Resumen
En este capítulo, analizamos la creación y el ajuste de modelos de incrustación
mediante diversas tareas. Analizamos el concepto de incrustaciones y su función en la
representación de datos textuales en un formato numérico. Luego, exploramos la técnica
fundamental de muchos modelos de incrustación, a saber, el aprendizaje contrastivo,
que aprende principalmente de pares de documentos (diferentes).
Utilizando un marco de trabajo de incrustación popular, los transformadores de oraciones,

creamos modelos de incrustación utilizando un modelo BERT previamente entrenado
mientras explorábamos diferentes funciones de pérdida, como la pérdida de similitud de
coseno y la pérdida de MNR. Analizamos cómo la recopilación de pares o triples de
documentos (diferentes) es vital para el rendimiento del modelo resultante.
En las secciones siguientes, exploramos técnicas para ajustar los modelos de

incrustación. Se utilizaron técnicas supervisadas y no supervisadas.
Se discutieron métodos como SBERT aumentado y TSDAE para la adaptación del dominio.
En comparación con la creación de un modelo de incrustación, el ajuste fino generalmente requiere menos
datos y es una excelente manera de adaptar los modelos de integración existentes a su dominio.
En el siguiente capítulo se presentan métodos para ajustar las representaciones para

Se discutirán tanto los modelos BERT como los modelos de incrustación.
También hará su aparición una amplia gama de técnicas de ajuste.
1
Alan Garfinkel. Formas de explicación: replanteando las cuestiones en la teoría social. Universidad de Yale
Prensa Universitaria (1982).
2
Tim Miller. “Explicación contrastiva: un enfoque de modelo estructural”. The Knowledge
Revista de Ingeniería 36 (2021): e14.
3
4
Jeffrey Pennington, Richard Socher y Christopher D. Manning. “GloVe: Vectores globales para
Representación de palabras”. Actas de la Conferencia de 2014 sobre métodos empíricos en ciencias naturales
Procesamiento del lenguaje (EMNLP). 2014.
5
Niklas Muennighoff et al. “MTEB: Punto de referencia de incrustación de texto masivo”. Preimpresión de arXiv
arXiv:2210.07316 (2022).
6
Matthew Henderson et al. “Sugerencia de respuesta en lenguaje natural eficiente para una respuesta inteligente”.
7
Aaron van den Oord, Yazhe Li y Oriol Vinyals. “Aprendizaje de representación con contraste
codificación predictiva”. preimpresión arXiv arXiv:1807.03748 (2018).
8
Ting Chen et al. “Un marco simple para el aprendizaje contrastivo de representaciones visuales”.
Conferencia internacional sobre aprendizaje automático. PMLR, 2020.
9
Nandan Thakur et al. “SBERT aumentada: método de aumento de datos para mejorar los bicodificadores
para tareas de puntuación de oraciones por pares”. Preimpresión de arXiv arXiv:2010.08240 (2020).
10
Tianyu Gao, Xingcheng Yao y Danqi Chen. “SimCSE: aprendizaje contrastivo simple de
incrustaciones de oraciones”. preimpresión arXiv arXiv:2104.08821 (2021).
11
Fredrik Carlsson et al. “Reajuste semántico con tensión contrastiva”. Internacional
Conferencia sobre Representaciones del Aprendizaje, 2021. 2021.
12
Kexin Wang, Nils Reimers e Iryna Gurevych. “TSDAE: uso de transformadores basados en
Codificador automático de eliminación de ruido secuencial para el aprendizaje de incrustación de oraciones no supervisadas”. arXiv
13
Kexin Wang et al. “GPL: etiquetado pseudogenerativo para la adaptación de dominios no supervisados de
recuperación densa”. preimpresión arXiv arXiv:2112.07577 (2021).
OceanofPDF.com
Capítulo 11. Ajuste fino de los

modelos de representación para la
clasificación
En el capítulo 4, utilizamos modelos entrenados previamente para clasificar nuestro texto.

Mantuvimos los modelos entrenados previamente tal como estaban sin realizar ninguna
modificación. Esto puede hacer que te preguntes qué sucede si los afinamos.
Si tenemos suficientes datos, el ajuste fino tiende a dar lugar a algunos de los modelos
con mejor rendimiento posible. En este capítulo, repasaremos varios métodos y
aplicaciones para ajustar los modelos BERT. En “Clasificación supervisada” se muestra
el proceso general de ajuste fino de un modelo de clasificación. Luego, en
“Clasificación de pocos intentos”, analizamos SetFit, que es un método para ajustar de manera
eficiente un modelo de alto rendimiento utilizando una pequeña cantidad de ejemplos de
entrenamiento. En “Preentrenamiento continuo con modelado de lenguaje enmascarado”,
exploraremos cómo continuar entrenando un modelo preentrenado. Por último, en
“Reconocimiento de entidades con nombre”, se explora la clasificación a nivel de token.
Nos centraremos en tareas no generativas, ya que los modelos generativos se tratarán en el

Capítulo 12.
Clasificación supervisada
En el Capítulo 4, exploramos tareas de clasificación supervisada aprovechando modelos
de representación previamente entrenados que fueron entrenados para predecir
sentimientos (modelo específico de la tarea) o para generar incrustaciones (modelo de
incrustación), como se muestra en la Figura 111.
Figura 111. En el Capítulo 4, utilizamos modelos entrenados previamente para realizar la clasificación sin actualizar su
ponderación. Estos modelos se mantuvieron “congelados”.
Ambos modelos se mantuvieron congelados (no se pueden entrenar) para mostrar el potencial de
aprovechar los modelos entrenados previamente para las tareas de clasificación. El modelo de integración
utiliza un cabezal de clasificación (clasificador) que se puede entrenar por separado para predecir
el sentimiento de las críticas cinematográficas.
En esta sección, adoptaremos un enfoque similar, pero permitiremos que tanto el modelo como el
cabezal de clasificación se actualicen durante el entrenamiento. Como se muestra en la Figura
112, en lugar de utilizar un modelo de incrustación, ajustaremos un modelo BERT previamente
entrenado para crear un modelo específico de la tarea similar al que utilizamos en el Capítulo 2. En
comparación con el enfoque del modelo de incrustación, ajustaremos tanto el modelo de representación
como el cabezal de clasificación como una única arquitectura.
Figura 112. En comparación con la arquitectura “congelada”, en su lugar, entrenamos tanto el modelo BERT
preentrenado como el cabezal de clasificación. Un paso hacia atrás comenzará en el cabezal de clasificación y pasará
por BERT.
Para ello, en lugar de congelar el modelo, permitimos que se pueda entrenar y

actualizamos sus parámetros durante el entrenamiento. Como se ilustra en la Figura
113, utilizaremos un modelo BERT entrenado previamente y agregaremos una red
neuronal como cabezal de clasificación, ambos ajustados para la clasificación.
Figura 113. Arquitectura de un modelo específico para una tarea. Contiene un modelo de representación entrenado
previamente (por ejemplo, BERT) con un cabezal de clasificación adicional para la tarea específica.
En la práctica, esto significa que el modelo BERT previamente entrenado y el cabezal de
clasificación se actualizan de manera conjunta. En lugar de hacerlo de manera independiente, aprenden
uno del otro y permiten obtener representaciones más precisas.
Ajuste fino de un modelo BERT preentrenado

Utilizaremos el mismo conjunto de datos que usamos en el Capítulo 4 para ajustar nuestro modelo, es
decir, el conjunto de datos de Rotten Tomatoes, que contiene 5331 críticas de películas positivas y 5331
negativas de Rotten Tomatoes:
# Preparar datos y dividir tomates =

load_dataset("rotten_tomatoes") train_data, test_data = tomates["train"],
tomates["test"]
El primer paso en nuestra tarea de clasificación es seleccionar el modelo subyacente que queremos utilizar.
Utilizamos "bertbasecased", que fue entrenado previamente en la Wikipedia en inglés, así como en un gran
conjunto de datos compuesto por libros no publicados.1
Definimos de antemano la cantidad de etiquetas que queremos predecir. Esto es necesario para crear la red
neuronal de propagación hacia adelante que se aplica sobre nuestro modelo entrenado previamente:
desde los transformadores importan AutoTokenizer,

AutoModelo para clasificación de secuencias
# Cargar modelo y tokenizador model_id =

"bertbasecased" model =
AutoModelForSequenceClassification.from_pretrained( model_id, num_labels=2
) tokenizador = AutoTokenizer.from_pretrained(id_modelo)
A continuación, tokenizaremos nuestros datos:

Desde los transformadores, importe DataCollatorWithPadding
# Rellenar hasta la secuencia más larga del lote data_collator =

DataCollatorWithPadding(tokenizer=tokenizer)
def preprocess_function(ejemplos):
"""Tokenizar datos de entrada""" return
tokenizer(examples["text"], truncation=True)
# Tokenizar datos de tren/prueba

tokenized_train = train_data.map(preprocess_function, batched=True) tokenized_test =
test_data.map(preprocess_function, batched=True)
Antes de crear el Trainer, deberemos preparar un DataCollator

especial. Un DataCollator es una clase que nos ayuda a crear lotes de datos, pero
también nos permite aplicar la ampliación de datos.
Durante este proceso de tokenización, y como se muestra en el Capítulo 9,

agregaremos relleno al texto de entrada para crear representaciones de igual
tamaño. Para ello, utilizamos DataCollatorWithPadding.
Por supuesto, un ejemplo no estaría completo sin definir algunas métricas:

desde conjuntos de datos importar load_metric
def calculate_metrics(eval_pred): """Calcular

puntuación F1""" logits, etiquetas =
eval_pred predicciones = np.argmax(logits,
axis=1)
load_f1 = load_metric("f1") f1 =
load_f1.compute(predicciones=predicciones,
referencias=etiquetas)["f1"] devolver
{"f1": f1}
Con calculate_metrics podemos definir cualquier cantidad de métricas que nos

interesen y que se puedan imprimir o registrar durante el entrenamiento.
Es especialmente útil durante el entrenamiento ya que permite detectar comportamientos de

sobreajuste.
A continuación, instanciamos nuestro Entrenador:
de los transformadores importan TrainingArguments, Trainer
# Argumentos de entrenamiento para el ajuste de

parámetros training_args =
TrainingArguments( "model",
learning_rate=2e5,
per_device_train_batch_size=16,
num_train_epochs=1, weight_decay=0.01, save_strategy="epoch", report_to="none"
)
# Entrenador que ejecuta el proceso de entrenamiento trainer

= Trainer( model=model,
args=training_args,
train_dataset=tokenized_train,
eval_dataset=tokenized_test,
data_collator=data_collator,
calculate_metrics=compute_metrics,
La clase TrainingArguments define los hiperparámetros que queremos ajustar, como la tasa de
aprendizaje y la cantidad de épocas (rondas) que queremos entrenar. El Trainer se utiliza para ejecutar
el proceso de entrenamiento.
Finalmente podemos entrenar nuestro modelo y evaluarlo:
entrenador.evaluar()
{'eval_loss': 0,3663691282272339, 'eval_f1':

0,8492366412213741, 'eval_runtime':
4,5792,
'eval_samples_per_second': 232,791,
'eval_pasos_por_segundo': 14.631, 'época': 1.0}
Obtenemos una puntuación F1 de 0,85, que es bastante más alta que la del modelo específico de la tarea
que utilizamos en el Capítulo 4, que arrojó una puntuación F1 de 0,80. Esto demuestra que ajustar un
modelo por uno mismo puede ser más ventajoso que utilizar un modelo previamente entrenado. Solo
nos lleva un par de minutos entrenarlo.
Capas de congelación
Para demostrar aún más la importancia de entrenar toda la red, el siguiente ejemplo demostrará cómo
puedes usar Hugging Face Transformers para congelar ciertas capas de tu red.
Congelaremos el modelo BERT principal y permitiremos que solo las actualizaciones pasen por
el cabezal de clasificación. Esta será una gran comparación, ya que mantendremos todo igual, excepto
por el congelamiento de capas específicas.
Para comenzar, reinicialicemos nuestro modelo para que podamos comenzar desde cero:
# Cargar modelo y tokenizador model =

Nuestro modelo BERT preentrenado contiene muchas capas que podemos congelar. Inspeccionar estas
capas nos permite conocer la estructura de la red y lo que podríamos querer congelar:
# Imprimir nombres de capas

para nombre, parámetro en model.named_parameters():
imprimir(nombre)
bert.incrustaciones.incrustaciones_de_palabra.peso
bert.incrustaciones.incrustaciones_de_posición.peso
bert.incrustaciones.incrustaciones_de_tipo_de_token.peso
bert.incrustaciones.LayerNorm.peso
bert.embeddings.LayerNorm.bias
bert.encoder.layer.0.attention.self.query.weight
bert.encoder.layer.0.attention.self.query.bias
...
bert.encoder.layer.11.output.LayerNorm.weight
bert.encoder.layer.11.output.LayerNorm.bias bert.pooler.dense.weight
bert.pooler.dense.bias clasificador.weight
clasificador.bias
Hay 12 bloques de codificador (011) que consisten en cabezales de atención,

redes densas y normalización de capas. Ilustramos esta arquitectura con más
detalle en la Figura 114 para demostrar todo lo que podría congelarse. Además
de eso, tenemos nuestro cabezal de clasificación.
Figura 114. La arquitectura básica de BERT con el cabezal de clasificación adicional.

Podríamos optar por congelar solo ciertas capas para acelerar el cálculo, pero aún así
permitir que el modelo principal aprenda de la tarea de clasificación. En general,
queremos que las capas congeladas sean seguidas por capas entrenables.
Vamos a congelar todo excepto el cabezal de clasificación como hicimos en el Capítulo

2:
para el nombre, parámetro en model.named_parameters():
# Cabezal de clasificación entrenable

si nombre.comienza con("clasificador"):
param.requires_grad = True
# Congela todo lo demás

demás:
param.requires_grad = Falso
Como se muestra en la Figura 115, hemos congelado todo excepto la red

neuronal de avance, que es nuestro cabezal de clasificación.
Figura 115. Congelamos por completo todos los bloques codificadores y las capas de incrustación de modo que el modelo
BERT no aprenda nuevas representaciones durante el ajuste fino.
Ahora que hemos congelado con éxito todo excepto el cabezal de clasificación,
podemos pasar a entrenar nuestro modelo:
de los transformadores importan TrainingArguments, Trainer
# Entrenador que ejecuta el proceso de entrenamiento trainer

= Trainer( model=model,
args=training_args,
eval_dataset=tokenized_test,
data_collator=data_collator,
calculate_metrics=compute_metrics,
Es posible que notes que el entrenamiento se ha vuelto mucho más rápido. Esto se debe a
que solo estamos entrenando el cabezal de clasificación, que nos proporciona una
Aceleración significativa en comparación con el ajuste fino de todo el modelo:
entrenador.evaluar()
{'eval_loss': 0,6821751594543457, 'eval_f1':

0,6331058020477816, 'eval_runtime':
4,0175,
'eval_muestras_por_segundo': 265,337,
'eval_pasos_por_segundo': 16,677, 'época':
1,0}
Cuando evaluamos el modelo, solo obtenemos una puntuación F1 de 0,63, que es

bastante más baja en comparación con nuestra puntuación original de 0,85. En lugar de
congelar casi todas las capas, congelaremos todo hasta el bloque de codificador 10,
como se ilustra en la Figura 116, y veremos cómo afecta el rendimiento. Un beneficio
importante es que esto reduce el cálculo pero aún permite que las actualizaciones fluyan
a través de una parte del modelo entrenado previamente:
Figura 116. Congelamos los primeros 10 bloques codificadores de nuestro modelo BERT. Todo lo demás se puede entrenar
y se ajustará con precisión.
# Cargar modelo
model_id = "bertbasecased" model =
# El bloque del codificador 11 comienza en el índice 165 y # congelamos

todo antes de ese bloque para el índice, (nombre, parámetro) en
enumerate(model.named_parameters()):
si índice < 165:
param.requires_grad = Falso
# Entrenador que ejecuta el proceso de entrenamiento trainer =

Trainer( model=model,
args=training_args,
eval_dataset=prueba_tokenizada,
tokenizador=tokenizador,
recopilador_de_datos=recopilador_de_datos,
métricas_de_cómputo=métricas_de_cómputo,
Después del entrenamiento evaluamos los resultados:
entrenador.evaluate()
{'eval_loss': 0,40812647342681885, 'eval_f1':
0,8, 'eval_runtime':
3,7125, 'eval_samples_per_second':
287,137, 'eval_steps_per_second': 18,047,
'epoch': 1,0}
Obtuvimos una puntuación F1 de 0,8, que es mucho más alta que nuestra puntuación anterior de 0,63 al
congelar todas las capas. Esto demuestra que, si bien generalmente queremos entrenar tantas capas
como sea posible, se puede lograr un entrenamiento menor si no se cuenta con la potencia informática
necesaria.
Para ilustrar mejor este efecto, probamos el efecto de congelar iterativamente los bloques del
codificador y ajustarlos como lo hicimos hasta ahora. Como se muestra en la Figura 117,
entrenar solo los primeros cinco bloques del codificador (línea vertical roja) es suficiente para alcanzar
casi el rendimiento de entrenar todos los bloques del codificador.
Figura 117. Efecto de congelar ciertos bloques del codificador en el rendimiento del modelo. Entrenar
más bloques mejora el rendimiento, pero se estabiliza al principio.
NOTA
Cuando entrenas para varias épocas, la diferencia (en tiempo de entrenamiento
y recursos) entre congelar y no congelar suele ser mayor. Por lo tanto, se
recomienda jugar con un equilibrio que funcione para ti.
Clasificación de pocos disparos

La clasificación de pocos ejemplos es una técnica dentro de la clasificación
supervisada en la que un clasificador aprende las etiquetas de los objetivos basándose
solo en unos pocos ejemplos etiquetados. Esta técnica es excelente cuando se tiene una
tarea de clasificación pero no se tienen muchos puntos de datos etiquetados disponibles.
En otras palabras, este método permite etiquetar unos pocos puntos de datos de alta
calidad por clase con los que entrenar el modelo. Esta idea de usar unos pocos puntos
de datos etiquetados para entrenar el modelo se muestra en la Figura 118.
Figura 118. En la clasificación de pocos disparos, solo utilizamos unos pocos puntos de datos etiquetados para aprender.
SetFit: Ajuste fino eficaz con pocos ejemplos de entrenamiento

Para realizar una clasificación de texto de pocos disparos, utilizamos un marco eficiente 2 llamado SetFit.
Está construido sobre la arquitectura de la oración.
Transformadores para generar representaciones textuales de alta calidad que se actualizan durante el
entrenamiento. Solo se necesitan unos pocos ejemplos etiquetados para que este marco sea
competitivo con el ajuste fino de un modelo tipo BERT en un conjunto de datos etiquetado grande,
como exploramos en el ejemplo anterior.
El algoritmo subyacente de SetFit consta de tres pasos:
1. Muestreo de datos de entrenamiento
Basándose en la selección de datos etiquetados dentro y fuera de clase, genera pares de

oraciones positivas (similares) y negativas (diferentes).
2. Ajuste fino de las incrustaciones
Ajuste de un modelo de incrustación entrenado previamente en función de los datos de

entrenamiento generados previamente
3. Entrenamiento de un clasificador
Cree un cabezal de clasificación sobre el modelo de incrustación y entrénelo utilizando los datos de
entrenamiento generados previamente
Antes de ajustar un modelo de inserción, necesitamos generar datos de entrenamiento.

El modelo supone que los datos de entrenamiento son muestras de pares de oraciones positivas
(similares) y negativas (diferentes). Sin embargo, cuando se trata de una tarea de clasificación,
nuestros datos de entrada generalmente no están etiquetados como tales.
Digamos, por ejemplo, que tenemos el conjunto de datos de entrenamiento de la Figura 119
que clasifica el texto en dos categorías: texto sobre lenguajes de programación y texto sobre
mascotas.
Figura 119. Datos en dos clases: texto sobre lenguajes de programación y texto sobre mascotas.
En el paso 1, SetFit maneja este problema generando los datos necesarios en función de
la selección dentro y fuera de la clase, como ilustramos en la Figura 1110.
Por ejemplo, si tenemos 16 oraciones sobre deportes, podemos crear 16 * (16 – 1) / 2 = 120
pares que etiquetamos como pares positivos . Podemos utilizar este proceso para
generar pares negativos recopilando pares de diferentes clases.
Figura 1110. Paso 1: muestreo de datos de entrenamiento. Suponemos que las oraciones dentro de una clase son similares y
crean pares positivos, mientras que las oraciones en clases diferentes se convierten en pares negativos.
En el paso 2, podemos utilizar los pares de oraciones generados para ajustar

el modelo de incrustación. Esto aprovecha un método llamado aprendizaje contrastivo
para ajustar un modelo BERT previamente entrenado. Como revisamos en el
Capítulo 10, el aprendizaje contrastivo permite aprender incrustaciones de oraciones
precisas a partir de pares de oraciones similares (positivas) y diferentes (negativas).
Dado que generamos estos pares en el paso anterior, podemos usarlos para ajustar
un modelo de SentenceTransformers. Aunque ya hemos analizado el aprendizaje
contrastivo anteriormente, ilustramos nuevamente el método en la Figura 1111 a
modo de repaso.
Figura 1111. Paso 2: Ajuste fino de un modelo de SentenceTransformers . Mediante el aprendizaje contrastivo,
se aprenden las incrustaciones de pares de oraciones positivas y negativas.
El objetivo de perfeccionar este modelo de incrustación es que pueda crear

incrustaciones que se adapten a la tarea de clasificación. La relevancia de las clases y su
significado relativo se destilan en las incrustaciones mediante el perfeccionamiento
del modelo de incrustación.
En el paso 3, generamos incrustaciones para todas las oraciones y las usamos como
entrada de un clasificador. Podemos usar el modelo
SentenceTransformers perfeccionado para convertir nuestras oraciones en
Incrustaciones que podemos usar como características. El clasificador aprende de nuestras

incrustaciones perfeccionadas para predecir con precisión oraciones no vistas. Este último
paso se ilustra en la Figura 1112.
Figura 1112. Paso 3: Entrenamiento de un clasificador. El clasificador puede ser cualquier modelo de scikitlearn o un
cabezal de clasificación.
Cuando juntamos todos los pasos, obtenemos un flujo de trabajo eficiente y elegante para realizar la clasificación
cuando solo hay unas pocas etiquetas por clase. Hace uso inteligente de la idea de que hemos etiquetado los
datos, aunque no de la forma que nos gustaría. Los tres pasos juntos se ilustran en la Figura 1113 para brindar
una descripción general única de todo el procedimiento.
En primer lugar, se generan pares de oraciones según la selección dentro y fuera de la clase.
En segundo lugar, los pares de oraciones se utilizan para ajustar un modelo de
SentenceTransformer previamente entrenado. En tercer lugar, las oraciones se integran con el modelo ajustado en
el que se entrena un clasificador para predecir las clases.
Figura 1113. Los tres pasos principales de SetFit.
Ajuste fino para la clasificación de pocos disparos

Previamente nos entrenamos con un conjunto de datos que contenía aproximadamente 8.500 reseñas de películas.
Sin embargo, dado que se trata de una configuración de pocas tomas, solo tomaremos muestras de 16 ejemplos
por clase. Con dos clases, solo tendremos 32 documentos con los que entrenar, en comparación con las
8500 reseñas de películas que usábamos antes.
desde setfit importar sample_dataset
# Simulamos una configuración de pocos disparos muestreando 16 ejemplos por clase

datos_de_tren_muestreados = conjunto_de_datos_de_muestra(tomates["tren"],
num_muestras=16)
Después de muestrear los datos, elegimos un modelo

SentenceTransformer previamente entrenado para ajustarlo. La documentación oficial
Contiene una descripción general de los modelos SentenceTransformer entrenados

previamente De donde vamos a utilizar "sentencetransformers/
allmpnetbasev2". Es uno de los modelos con mejor rendimiento en la clasificación
de MTEB. que muestra el rendimiento de la incrustación de modelos en una
variedad de tareas:
desde setfit importar SetFitModel
# Cargar un modelo SentenceTransformer entrenado previamente model =

SetFitModel.from_pretrained("sentencetransformers/all mpnetbasev2")
Después de cargar el modelo SentenceTransformer previamente entrenado, podemos

comenzar a definir nuestro SetFitTrainer. De manera predeterminada, se elige un
modelo de regresión logística como clasificador para entrenar.
De manera similar a lo que hicimos con Hugging Face Transformers, podemos usar el
entrenador para definir y jugar con los parámetros relevantes. Por ejemplo, establecemos
num_epochs en 3 para que se realice el aprendizaje contrastivo para tres épocas:
desde setfit importa TrainingArguments como SetFitTrainingArguments desde setfit importa Trainer como
SetFitTrainer
# Definir argumentos de entrenamiento args =

SetFitTrainingArguments(
num_epochs=3, # La cantidad de épocas a utilizar para el aprendizaje contrastivo num_iterations=20
# La cantidad
de pares de texto a generar
) args.eval_strategy = args.estrategia_de_evaluacion
# Crear entrenador
entrenador = SetFitTrainer(
modelo=modelo,
argumentos=argumentos,
conjunto_de_datos_de_entrenamiento=datos_de_entrenamiento_muestreados, conjunto_de_datos_de_evaluación=datos_de_prueba, métrica="f1"
Solo necesitamos llamar a train para iniciar el ciclo de entrenamiento. Cuando lo hagamos,
deberíamos obtener el siguiente resultado:
# Bucle de entrenamiento
trainer.train()
***** Entrenamiento de carrera *****

Número de pares únicos = 1280
Tamaño del lote = 16
Número de épocas = 3
Total de pasos de optimización = 240
Tenga en cuenta que el resultado menciona que se generaron 1280 pares de oraciones para
ajustar el modelo SentenceTransformer. De manera predeterminada, se generan 20
combinaciones de pares de oraciones para cada muestra de nuestros datos, lo que sería
20 * 32 = 680 muestras. Tendremos que multiplicar este valor por 2 para cada par positivo y
negativo generado, 680 * 2 = 1280 pares de oraciones. ¡Generar 1280 pares de oraciones es
bastante impresionante considerando que solo teníamos 32 oraciones etiquetadas para
comenzar!
CONSEJO
Cuando no definimos específicamente un cabezal de clasificación, se utiliza de forma predeterminada

una regresión logística. Si deseamos especificar un cabezal de clasificación nosotros mismos,
podemos hacerlo especificando el siguiente modelo en SetFitTrainer:
# Cargue un modelo SetFit desde Hub model =

SetFitModel.from_pretrained( "sentencetransformers/all
mpnetbasev2", use_differentiable_head=True,
head_params={"out_features": num_classes},
# Crear entrenador
entrenador = SetFitTrainer( modelo=modelo,
...
)
Aquí, num_classes se refiere al número de clases que queremos predecir.
A continuación, evaluemos el modelo para tener una idea de su rendimiento:
# Evaluar el modelo en nuestros datos de prueba trainer.evaluate()
{'f1': 0,8363988383349468}
Con solo 32 documentos etiquetados, obtenemos una puntuación F1 de 0,85. Teniendo en

cuenta que el modelo se entrenó con un subconjunto minúsculo de los datos originales, ¡esto es
muy impresionante! Además, en el Capítulo 2, obtuvimos el mismo rendimiento pero, en su
lugar, entrenamos un modelo de regresión logística con las incrustaciones de los datos
completos. Por lo tanto, esta secuencia de comandos demuestra el potencial de tomarse el
tiempo para etiquetar solo algunas instancias.
CONSEJO
SetFit no solo puede realizar tareas de clasificación de pocos disparos, sino que también tiene soporte
para cuando no hay etiquetas en absoluto, también llamada clasificación de cero disparos. SetFit
genera ejemplos sintéticos a partir de los nombres de las etiquetas para que se asemejen a la tarea de
clasificación y luego entrena un modelo de SetFit con ellos. Por ejemplo, si las etiquetas de destino son
"feliz" y "triste", entonces los datos sintéticos podrían ser "El ejemplo es feliz" y "Este ejemplo es triste".
Continuó el preentrenamiento con máscara

En los ejemplos que hemos presentado hasta ahora, hemos aprovechado un modelo previamente
entrenado y lo hemos ajustado para realizar la clasificación. Este proceso describe un proceso
de dos pasos: primero, el preentrenamiento de un modelo (que ya se había realizado por nosotros)
y luego el ajuste para una tarea en particular. Ilustramos este proceso en la Figura 1114.
Figura 1114. Para ajustar el modelo a una tarea específica (por ejemplo, la clasificación), comenzamos con el
entrenamiento previo de un modelo BERT o usamos uno previamente entrenado.
Este enfoque de dos pasos se utiliza normalmente en muchas aplicaciones. Tiene sus
limitaciones cuando se trabaja con datos específicos del dominio. El modelo preentrenado
suele entrenarse con datos muy generales, como páginas de Wikipedia, y es posible
que no esté adaptado a las palabras específicas del dominio.
En lugar de adoptar este enfoque de dos pasos, podemos intercalar otro paso entre
ellos, es decir, continuar con el preentrenamiento de un modelo BERT ya preentrenado.
En otras palabras, podemos simplemente continuar con el entrenamiento del modelo
BERT utilizando el modelado de lenguaje enmascarado (MLM), pero en su lugar utilizar
datos de nuestro dominio. Es como pasar de un modelo BERT general a un modelo
BioBERT especializado para el dominio médico, y luego a un modelo BioBERT
perfeccionado para clasificar medicamentos.
Esto actualizará las representaciones de subpalabras para que estén más ajustadas
a las palabras que no habría visto antes. Este proceso se ilustra en la Figura
1115 y demuestra cómo este paso adicional actualiza una tarea de modelado de lenguaje
enmascarado. Se ha demostrado que continuar con el preentrenamiento en un modelo
BERT preentrenado mejora el rendimiento de los modelos en tareas de
clasificación y es una adición valiosa al proceso de ajuste fino.3
Figura 1115. En lugar de un enfoque de dos pasos, podemos agregar otro paso que continúe con el preentrenamiento
del modelo preentrenado antes de ajustarlo para la tarea objetivo. Observe cómo las máscaras se llenaron con
conceptos abstractos en 1, mientras que se llenaron con conceptos específicos de la película en 2.
En lugar de tener que entrenar previamente un modelo completo desde cero, podemos simplemente
continuar con el entrenamiento previo antes de ajustarlo para la clasificación. Esto también ayuda al
modelo a adaptarse a un dominio determinado o incluso a la jerga de una organización
específica. La genealogía de los modelos que una empresa podría querer adoptar se ilustra con más
detalle en la Figura 1116.
Figura 1116. El enfoque de tres pasos ilustrado para casos de uso específicos.
En este ejemplo, demostraremos cómo aplicar el paso 2 y continuar con el preentrenamiento de

un modelo BERT ya preentrenado. Usamos los mismos datos con los que comenzamos, es decir,
las reseñas de Rotten Tomatoes.
Comenzamos cargando el modelo "bertbasecased" que hemos utilizado hasta ahora y lo preparamos
para MLM:
Desde los transformadores , importe AutoTokenizer, AutoModelForMaskedLM
# Cargar modelo para modelado de lenguaje enmascarado

(MLM) model = AutoModelForMaskedLM.from_pretrained("bertbasecased") tokenizer
= AutoTokenizer.from_pretrained("bertbasecased")
Necesitamos convertir en tokens las oraciones sin procesar. También eliminaremos las etiquetas, ya
que no se trata de una tarea supervisada:
def preprocess_function(ejemplos):
devuelve tokenizador(ejemplos["texto"], truncamiento=Verdadero)
# Tokenizar datos
tokenized_train = train_data.map(preprocess_function, batched=True) tokenized_train =
tokenized_train.remove_columns("etiqueta") tokenized_test = test_data.map(preprocess_function,

batched=True) tokenized_test = tokenized_test.remove_columns("etiqueta")
Anteriormente, utilizamos DataCollatorWithPadding, que rellena dinámicamente la entrada que recibe.
En su lugar, tendremos un DataCollator que realizará el enmascaramiento de tokens por nosotros. Hay
dos métodos que se utilizan generalmente para esto: enmascaramiento de tokens y de palabras completas.
Con el enmascaramiento de tokens, enmascaramos aleatoriamente el 15 % de los tokens en una oración.
Puede suceder que se enmascare parte de una palabra.
Para permitir el enmascaramiento de toda la palabra, podríamos aplicar el enmascaramiento de palabra
completa, como se ilustra en la Figura 1117.
Figura 1117. Diferentes métodos para enmascarar tokens aleatoriamente.
En general, predecir palabras completas tiende a ser más complicado que predecir tokens, lo que
hace que el modelo funcione mejor, ya que necesita aprender representaciones más precisas y
exactas durante el entrenamiento. Sin embargo, tiende a llevar un poco más de tiempo converger. En
este ejemplo, utilizaremos el enmascaramiento de tokens utilizando DataCollatorForLanguageModeling
para lograr una convergencia más rápida.
convergencia. Sin embargo, podemos utilizar el enmascaramiento de palabras

completas reemplazando DataCollatorForLanguageModeling
por DataCollatorForWholeWordMask. Por último, establecemos la probabilidad de
que un token esté enmascarado en una oración dada en 15 % (mlm_probability):
Desde los transformadores, importe DataCollatorForLanguageModeling
# Tokens de
enmascaramiento data_collator = DataCollatorForLanguageModeling( tokenizer=tokenizer,
mlm=True, mlm_probability=0.15
A continuación, crearemos el Entrenador para ejecutar la tarea MLM y especificaremos

ciertos parámetros:
# Argumentos de entrenamiento para el ajuste de parámetros

training_args = TrainingArguments( "modelo",
tasa_de_aprendizaje=2e5,
tamaño_de_lote_de_entrenamiento_por_dispositivo=16,
tamaño_de_lote_de_evaluación_por_dispositivo=16,
num_train_epochs=10,
weight_decay=0.01,
save_strategy="época",
report_to="none"
)
# Inicializar Entrenador entrenador

= Entrenador ( modelo=modelo,
argumentos=argumentos_entrenamiento,
conjunto_de_datos_entrenamiento=tokenized_train,
conjunto_de_datos_evaluación=tokenized_test, tokenizador=tokenizador, recopilador_de_datos=data_collator

)
Vale la pena tener en cuenta varios parámetros. Entrenamos durante 20 épocas y mantenemos la tarea breve.
Puedes experimentar con la tasa de aprendizaje y la disminución del peso para determinar si ayudan a ajustar el
modelo.
Antes de comenzar nuestro ciclo de entrenamiento, primero guardaremos nuestro tokenizador previamente entrenado.
El tokenizador no se actualiza durante el entrenamiento, por lo que no es necesario guardarlo después del
entrenamiento. Sin embargo, guardaremos nuestro modelo después de continuar con el preentrenamiento:
# Guardar el tokenizador entrenado previamente

tokenizer.save_pretrained("mlm")
# Modelo de tren
trainer.train()
# Guardar el modelo actualizado

model.save_pretrained("mlm")
Esto nos proporciona un modelo actualizado en la carpeta mlm . Para evaluar su rendimiento,
normalmente afinamos el modelo en una variedad de tareas.
Sin embargo, para nuestros propósitos, podemos ejecutar algunas tareas de enmascaramiento para ver si ha
aprendido de su entrenamiento continuo.
Lo haremos cargando nuestro modelo entrenado previamente antes de continuar con el preentrenamiento.
Al usar la oración "¡Qué horrible [MÁSCARA]!", el modelo predecirá qué palabra estaría en lugar de "[MÁSCARA]":
# Cargar y crear predicciones mask_filler =

pipeline("fillmask", model="bertbasecased") preds = mask_filler("¡Qué [MÁSCARA] más horrible!")
# Imprimir resultados
para pred en preds:

print(f">>> {pred["sequence"]}")
>>> ¡Qué idea más horrible!

>>> ¡Qué sueño más horrible!
>>> ¡Qué cosa más horrible!

>>> ¡Qué día más horrible!
>>> ¡Qué pensamiento más horrible!
El resultado muestra conceptos como “idea”, “sueño” y “día”, que definitivamente tienen sentido. A
continuación, veamos qué predice nuestro modelo actualizado:
# Cargar y crear predicciones mask_filler =

pipeline("fillmask", model="mlm") preds = mask_filler("¡Qué [MÁSCARA] más
horrible!")
# Imprimir resultados
para pred en preds:

print(f">>> {pred["sequence"]}")
>>> ¡Qué película más horrible!

>>> ¡Qué película más horrible!
>>> ¡Qué desastre más horrible!
>>> ¡Qué comedia más horrible!
>>> ¡Qué historia más horrible!
Una película horrible, un filme, un desastre, etc. nos muestra claramente que el modelo está más
sesgado hacia los datos que le suministramos en comparación con el modelo entrenado previamente.
El siguiente paso sería ajustar este modelo en la tarea de clasificación que realizamos al principio de
este capítulo. Simplemente cargue el modelo de la siguiente manera y estará listo:
Desde los transformadores, importe AutoModelForSequenceClassification
# Ajuste fino para el modelo de clasificación =

AutoModelForSequenceClassification.from_pretrained("mlm", num_labels=2) tokenizador =
AutoTokenizer.from_pretrained("mlm")
Reconocimiento de entidades nombradas
En esta sección, profundizaremos en el proceso de ajuste de un modelo BERT

previamente entrenado específicamente para NER (reconocimiento de entidades con
nombre). En lugar de clasificar documentos completos, este procedimiento permite la
clasificación de tokens y/o palabras individuales, incluidas personas y ubicaciones.
Esto es especialmente útil para tareas de desidentificación y anonimización cuando hay
datos confidenciales.
NER comparte similitudes con el ejemplo de clasificación que exploramos al principio de

este capítulo. Sin embargo, una distinción clave radica en el preprocesamiento
y la clasificación de los datos. Dado que nos centramos en clasificar palabras
individuales en lugar de documentos completos, debemos preprocesar los
datos para tener en cuenta esta estructura granular. La Figura 1118 proporciona
una representación visual de este enfoque a nivel de palabra.
Figura 1118. El ajuste de un modelo BERT para NER permite la detección de entidades con nombre, como
personas o ubicaciones.
El ajuste fino del modelo BERT preentrenado sigue una arquitectura similar a la que
observamos con la clasificación de documentos. Sin embargo, hay un cambio
fundamental en el enfoque de clasificación. En lugar de depender de la agregación o
agrupación de incrustaciones de tokens, el modelo ahora hace predicciones
para tokens individuales en una secuencia. Es fundamental enfatizar que nuestra tarea
de clasificación a nivel de palabra no implica clasificar palabras enteras, sino más
bien los tokens que constituyen colectivamente esas palabras.
La figura 1119 proporciona una representación visual de esta clasificación

a nivel de token.
Figura 1119. Durante el proceso de ajuste fino de un modelo BERT, se clasifican tokens individuales en
lugar de palabras o documentos completos.
Preparación de datos para el reconocimiento de entidades nombradas
En este ejemplo, utilizaremos la versión en inglés del conjunto de datos

CoNLL2003, que contiene varios tipos diferentes de entidades con nombre (persona,
organización, ubicación, varios y ninguna entidad) y tiene aproximadamente 14
000 muestras de entrenamiento.4
# El conjunto de datos CoNLL2003 para NER dataset

= load_dataset("conll2003", trust_remote_code=True)
CONSEJO
Mientras investigábamos los conjuntos de datos que se utilizarían en este ejemplo, había
algunos más que queríamos compartir. wnut_17 es una tarea que se centra en entidades
emergentes y raras, aquellas que son más difíciles de detectar. Además, los conjuntos de
datos tner/mit_movie_trivia y tner/mit_restaurant son bastante
divertidos de usar. tner/mit_movie_trivia sirve para detectar entidades como actor, trama y
banda sonora, mientras que tner/mit_restaurant tiene como objetivo detectar entidades como
servicio, plato y cocina.5
Inspeccionemos la estructura de los datos con un ejemplo:
ejemplo = conjunto de datos["tren"][848]

ejemplo
{'id': '848', 'tokens':

['Dean', 'Palmer', 'hit',
'suyo',
'30.º',
'jonrón',
'para',
'los',
'Rangers',
'.'],
'pos_tags': [22, 22, 38, 29, 16, 21, 15, 12, 23, 7], 'chunk_tags': [11, 12,
21, 11, 12, 12, 13, 11, 12, 0], 'ner_tags': [1, 2, 0, 0, 0, 0, 0, 0, 3, 0]}
Este conjunto de datos nos proporciona etiquetas para cada palabra dada en una oración.
Estas etiquetas se pueden encontrar en la clave ner_tags, que hace referencia a las
siguientes entidades posibles:
etiqueta2id = {
"O": 0, "BPER": 1, "IPER": 2, "BORG": 3, "IORG": 4,
"BLOC": 5, "ILOC": 6, "BMISC": 7, "IMISC": 8
}
id2label = {índice: etiqueta para etiqueta, índice en label2id.items()} label2id
{'O': 0,
'BPER': 1,
'YoPER': 2,
'ORGB': 3,
'YoORG': 4,
'Localización B': 5,
'Localización I': 6,
'BMISC': 7,
'IMISC': 8}
Estas entidades corresponden a categorías específicas: una persona (PER),

una organización (ORG), una ubicación (LOC), entidades diversas (MISC) y ninguna entidad
(O). Tenga en cuenta que estas entidades tienen como prefijo una B (inicio) o una I (interior).
Si dos tokens que se suceden forman parte de la misma frase, el comienzo de esa frase
se indica con una B, seguida de una I para mostrar que pertenecen entre sí y no son
entidades independientes.
Este proceso se ilustra con más detalle en la Figura 1120. En la figura, dado que
“Dean” es el comienzo de la frase y “Palmer” es el final, sabemos que “Dean Palmer” es
una persona y que “Dean” y “Palmer” no son personas individuales.
Figura 1120. Al indicar el inicio y el final de la frase con la misma entidad, podemos reconocer
entidades de frases enteras.
Nuestros datos están preprocesados y divididos en palabras, pero aún no en tokens. Para
ello, los tokenizaremos aún más con el tokenizador del modelo preentrenado que usamos a lo
largo de este capítulo, es decir, bertbasecased:
Desde los transformadores, importe AutoModelForTokenClassification
# Cargar tokenizador
tokenizer = AutoTokenizer.from_pretrained("bertbasecased")
# Cargar modelo
model = AutoModelForTokenClassification.from_pretrained(
"bertbasecase",
num_labels=len(id2label), id2label=id2label,
label2id=label2id
Exploremos cómo el tokenizador procesaría nuestro ejemplo:
# Dividir tokens individuales en subtokens token_ids =

tokenizer(example["tokens"], is_split_into_words=True) ["input_ids"] sub_tokens =
tokenizer.convert_ids_to_tokens(token_ids) sub_tokens
['[CLS]',
'Dean',
'Palmer', 'hit',
'suyo',
'30th',
'home',
'##r',
'para',
'los',
'Rangers',
'.', '[SEP]']
El tokenizador agregó los tokens [CLS] y [SEP] como aprendimos en los Capítulos
2 y 3. Tenga en cuenta que la palabra "homer" se dividió en los tokens "home" y "##r".
Esto crea un pequeño problema para nosotros ya que hemos etiquetado los datos a nivel
de palabra pero no a nivel de token. Esto se puede
se resolvió alineando las etiquetas con sus contrapartes de subtoken durante la

tokenización.
Consideremos la palabra "Maarten", que tiene la etiqueta BPER para indicar que se
trata de una persona. Si pasamos esa palabra a través del tokenizador, se divide en los
tokens "Ma", "##arte" y "##n". No podemos usar la entidad BPER para todos los tokens,
ya que eso indicaría que los tres tokens son personas independientes. Siempre que una
entidad se divide en tokens, el primer token debe tener B (por inicio) y los siguientes
deben tener I (por interior).
Por lo tanto, 'Ma' obtendrá el BPER para señalar el comienzo de una frase, y
'##arte' y '##n' obtendrán el IPER para señalar que pertenecen a una frase.
Este proceso de alineación se ilustra en la Figura 1121.
Figura 1121. Proceso de alineación del etiquetado de la entrada tokenizada.
Creamos una función, align_labels, que tokenizará la entrada y alineará estos tokens
con sus etiquetas actualizadas durante la tokenización:
def align_labels(ejemplos): token_ids

= tokenizer( ejemplos["tokens"],
truncamiento=Verdadero,
se_divide_en_palabras=Verdadero
)
etiquetas = ejemplos["ner_tags"]
updated_labels = [] para índice,

etiqueta en enumerate(labels):
# Asignar tokens a su palabra respectiva word_ids =

token_ids.word_ids(batch_index=index) previous_word_idx = None label_ids = []
para word_idx en word_ids:
# El comienzo de una nueva palabra
si palabra_idx != palabra_anterior_idx:
previous_word_idx = word_idx updated_label

= 100 si word_idx es Ninguno
etiqueta[word_idx]
label_ids.append(etiqueta actualizada)
# El token especial es 100 elif

word_idx es Ninguno:
label_ids.append(100)
# Si la etiqueta es BXXX la cambiamos a IXXX

de lo
contrario: etiqueta_actualizada = etiqueta[idx_de_palabra]
si etiqueta_actualizada % 2 == 1:
etiqueta_actualizada += 1
ids_de_etiqueta.append(etiqueta_actualizada)
etiquetas_actualizadas.append(identificadores_de_etiqueta)
token_ids["etiquetas"] = etiquetas_actualizadas devuelve

token_ids
tokenizado = conjunto de datos.map(align_labels, batched=True)
Al observar nuestro ejemplo, observe que se agregaron etiquetas adicionales

(100) para los tokens [CLS] y [SEP]:
# Diferencia entre etiquetas originales y actualizadas

print(f"Original: {ejemplo["ner_tags"]}") print(f"Actualizado:

{tokenizado["train"][848]["labels"]}")
Original: [1, 2, 0, 0, 0, 0, 0, 0, 3, 0]
Actualizado: [100, 1, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 100]
Ahora que hemos tokenizado y alineado las etiquetas, podemos empezar a pensar en
definir nuestras métricas de evaluación. Esto también es diferente de lo que hemos
visto antes. En lugar de una única predicción por documento, ahora tenemos múltiples
predicciones por documento, es decir, por token.
Utilizaremos el paquete de evaluación de Hugging Face para crear una función

calculate_metrics que nos permita evaluar el rendimiento a nivel de token:
Importar evaluar
# Cargar evaluación secuencial seqeval =

evaluation.load("seqeval")
def calculate_metrics(eval_pred): # Crear

predicciones logits, etiquetas
= eval_pred predicciones =
np.argmax(logits, axis=2)
predicciones_verdaderas = []
etiquetas_verdaderas = []
# Iteración a nivel de documento

Para la predicción, etiqueta en zip(predicciones, etiquetas):
# Iteración a nivel de token

para token_prediction, token_label en zip(predicción, etiqueta):
# Ignoramos los tokens especiales si

token_label != 100:
predicciones_verdaderas.append([id2label[predicción_token]])
etiquetas_verdaderas.append([id2label[etiqueta_token]])
resultados =
seqeval.compute( predicciones=predicciones_verdaderas, referencias=etiquetas_verdaderas
)
devuelve {"f1": resultados["overall_f1"]}
Ajuste fino para el reconocimiento de entidades nombradas
Ya casi estamos listos. En lugar de DataCollatorWithPadding, necesitamos un intercalador

que trabaje con la clasificación a nivel de token, es decir,
DataCollatorForTokenClassification:
Desde los transformadores, importe DataCollatorForTokenClassification
# Clasificación de tokens DataCollator data_collator =
DataCollatorForTokenClassification(tokenizador=tokenizador)
Ahora que hemos cargado nuestro modelo, el resto de los pasos son similares a los
procedimientos de entrenamiento anteriores de este capítulo. Definimos un
entrenador con argumentos específicos que podemos ajustar y crear un entrenador:
# Argumentos de entrenamiento para el ajuste de parámetros

training_args = TrainingArguments( "model",
learning_rate=2e5,
num_train_epochs=1,
weight_decay=0.01,
save_strategy="epoch",
report_to="none"
)
# Inicializar Entrenador entrenador

= Entrenador ( modelo=modelo,
argumentos=argumentos_entrenamiento,
conjunto_de_datos_entrenamiento=tokenized["entrenar"],
conjunto_de_datos_eval=tokenized["prueba"],
tokenizador=tokenizador, recopilador_de_datos=collator_de_datos, métricas_de_cómputo=métricas_de_cómputo,
Luego evaluamos el modelo que creamos:
# Evaluar el modelo en nuestros datos de prueba

trainer.evaluate()
Por último, guardemos el modelo y utilicémoslo en una secuencia de comandos para la

inferencia. Esto nos permite verificar ciertos datos para poder inspeccionar manualmente lo
que sucede durante la inferencia y si estamos satisfechos con el resultado:
# Guarde nuestro entrenador de modelos

perfeccionado.save_model ("ner_model")
# Ejecutar inferencia en el modelo ajustado token_classifier =

pipeline( "tokenclassification", model="ner_model",
) token_classifier("Mi nombre es Maarten.")
[{'entidad': 'BPER',
'puntuación': 0,99534035, 'índice':
4, 'palabra': 'Ma',
'inicio': 11, 'fin': 13},
{'entidad': 'IPER',
'puntuación':
0,9928328, 'índice': 5, 'palabra':
'##arte', 'inicio': 13, 'fin': 17},
{'entidad': 'IPER',
'puntuación': 0,9954301,
'índice': 6, 'palabra':
'##n', 'inicio': 17,
'fin': 18}]
En la oración "Mi nombre es Maarten", ¡la palabra "Maarten" y sus subtokens fueron identificados
correctamente como una persona!
Resumen
En este capítulo, exploramos varias tareas para ajustar con precisión los modelos de
representación entrenados previamente en tareas de clasificación específicas.
Comenzamos demostrando cómo ajustar con precisión un modelo BERT entrenado previamente
y ampliamos los ejemplos congelando ciertas capas de sus arquitecturas.
Experimentamos con una técnica de clasificación de pocos disparos llamada SetFit, que
implica ajustar con precisión un modelo de incrustación previamente entrenado junto con un
cabezal de clasificación utilizando datos etiquetados limitados. Utilizando solo unos pocos puntos
de datos etiquetados, este modelo generó un rendimiento similar a los modelos que exploramos
en capítulos anteriores.
A continuación, profundizamos en el concepto de preentrenamiento continuo, en el que utilizamos

un modelo BERT preentrenado como punto de partida y continuamos entrenándolo con
diferentes datos. El proceso subyacente, el modelado de lenguaje enmascarado, no solo se
utiliza para crear un modelo de representación, sino que también se puede utilizar para
continuar con el preentrenamiento de modelos.
Por último, analizamos el reconocimiento de entidades nombradas, una tarea que

implica identificar entidades específicas como personas y lugares en texto no estructurado.
En comparación con los ejemplos anteriores, esta clasificación se realizó a nivel de palabras
y no a nivel de documento.
En el próximo capítulo, continuamos con el campo del ajuste fino de los modelos
lingüísticos, pero nos centraremos en los modelos generativos. Mediante un proceso de dos
pasos, exploraremos cómo ajustar un modelo generativo para que siga las instrucciones
correctamente y luego lo ajustaremos para que se ajuste a las preferencias humanas.
1
Jacob Devlin et al. “BERT: preentrenamiento de transformadores bidireccionales profundos para la
comprensión del lenguaje”. Preimpresión arXiv arXiv:1810.04805 (2018).
2
Lewis Tunstall et al. “Aprendizaje eficiente de pocos intentos sin indicaciones”. Preimpresión de arXiv
arXiv:2209.11055 (2022).
3
Chi Sun et al. “¿Cómo ajustar GERT para la clasificación de texto?”, Chinese Computational
Lingüística: 18.ª Conferencia Nacional de China, CCL 2019, Kunming, China, del 18 al 20 de octubre
2019, actas 18. Springer International Publishing, 2019.
4
Erik F. Sang y Fien De Meulder. “Introducción a la tarea compartida CoNLL2003: reconocimiento de
entidades nombradas independientes del lenguaje”. Preimpresión arXiv cs/0306050 (2003).
5
Jingjing Liu et al. “Asgard: una arquitectura portátil para sistemas de diálogo multilingües”. 2013
Conferencia internacional IEEE sobre acústica, habla y procesamiento de señales. IEEE, 2013.
OceanofPDF.com
Capítulo 12. Ajuste fino de los

modelos de generación
En este capítulo, tomaremos un modelo de generación de texto previamente entrenado y

repasaremos el proceso de ajuste fino . Este paso de ajuste fino es clave para producir modelos
de alta calidad y una herramienta importante en nuestra caja de herramientas para adaptar un
modelo a un comportamiento deseado específico. El ajuste fino nos permite adaptar un
modelo a un conjunto de datos o dominio específico.
A lo largo de este capítulo, le guiaremos entre los dos métodos más comunes para ajustar los
modelos de generación de texto: el ajuste supervisado y el ajuste de preferencias. Exploraremos el
potencial transformador del ajuste de los modelos de generación de texto entrenados
previamente para convertirlos en herramientas más eficaces para su aplicación.
Los tres pasos de la formación LLM: formación previa,

Ajuste fino supervisado y preferencia
Sintonización
Hay tres pasos comunes que conducen a la creación de un LLM de alta calidad:
1. Modelado del lenguaje
El primer paso para crear un LLM de alta calidad es entrenarlo previamente con uno o más
conjuntos de datos de texto masivos (Figura 121). Durante el entrenamiento, intenta predecir
el siguiente token para aprender con precisión las representaciones lingüísticas y
semánticas que se encuentran en el texto. Como vimos antes en los Capítulos 3 y 11, esto
se denomina modelado del lenguaje y es un método autosupervisado.
Esto produce un modelo base , también conocido comúnmente como modelo preentrenado o
modelo de base . Los modelos base son un elemento clave del entrenamiento.
proceso, pero son más difíciles de manejar para el usuario final. Por eso es importante el
siguiente paso.
Figura 121. Durante el modelado del lenguaje, el LLM tiene como objetivo predecir el siguiente token en función de un
Entrada. Este es un proceso sin etiquetas.
2. Ajuste fino 1 (ajuste fino supervisado)
Los modelos LLM son más útiles si responden bien a las instrucciones y tratan de
seguirlas. Cuando los humanos le piden al modelo que escriba un artículo,
esperan que el modelo genere el artículo y no que enumere otras instrucciones, por
ejemplo (que es lo que podría hacer un modelo base).
Con el ajuste fino supervisado (SFT), podemos adaptar el modelo base para que
siga instrucciones. Durante este proceso de ajuste fino, los parámetros del modelo
base se actualizan para que estén más en línea con nuestra tarea objetivo, como seguir
instrucciones. Al igual que un modelo preentrenado, se entrena utilizando la predicción
del siguiente token, pero en lugar de predecir únicamente el siguiente token, lo hace en
función de una entrada del usuario (Figura 122).
Figura 122. Durante el ajuste fino supervisado, el LLM tiene como objetivo predecir el próximo token en función de un
Entrada que tiene etiquetas adicionales. En cierto sentido, la etiqueta es la entrada del usuario.
SFT también se puede utilizar para otras tareas, como la clasificación, pero a
menudo se utiliza para pasar de un modelo generativo base a un modelo
generativo de instrucciones (o chat).
3. Ajuste fino 2 (ajuste de preferencias)
El paso final mejora aún más la calidad del modelo y lo hace más acorde con el
comportamiento esperado de la seguridad de la IA o las preferencias humanas.
Esto se llama ajuste de preferencias. El ajuste de preferencias es una forma de
ajuste fino y, como su nombre lo indica, alinea el resultado del modelo con nuestras
preferencias, que están definidas por los datos que le proporcionamos.
Al igual que SFT, puede mejorar el modelo original, pero tiene el beneficio adicional
de destilar la preferencia de salida en su proceso de entrenamiento. Estos tres pasos
se ilustran en la Figura 123 y demuestran el proceso de comenzar con una arquitectura
no entrenada y terminar con un LLM ajustado a las preferencias.
Figura 123. Los tres pasos para crear un LLM de alta calidad.
En este capítulo, utilizamos un modelo base que ya se entrenó con conjuntos de datos
masivos y exploramos cómo podemos ajustarlo con ambas estrategias de ajuste.
Para cada método, comenzamos con los fundamentos teóricos antes de usarlos en la
práctica.
Ajuste fino supervisado (SFT)

El objetivo de entrenar previamente un modelo con grandes conjuntos de datos es que
pueda reproducir el lenguaje y su significado. Durante este proceso, el modelo aprende a
completar frases de entrada, como se muestra en la Figura 124.
Figura 124. Se entrenó un LLM base o preentrenado para predecir la(s) siguiente(s) palabra(s).
Este ejemplo también ilustra que el modelo no fue entrenado para seguir instrucciones y en su
lugar intentará completar una pregunta en lugar de responderla (Figura 125).
Figura 125. Un LLM básico no seguirá instrucciones, sino que intentará predecir cada palabra siguiente.
Incluso podría generar nuevas preguntas.
Podemos utilizar este modelo base y adaptarlo a determinados casos de uso, como seguir
instrucciones, ajustándolo.
Ajuste fino completo

El proceso de ajuste fino más común es el ajuste fino completo. Al igual que el preentrenamiento de
un modelo de larga duración, este proceso implica actualizar todos los parámetros de un modelo para
que estén en línea con la tarea de destino. La principal diferencia es que ahora utilizamos un conjunto
de datos más pequeño pero etiquetado, mientras que el proceso de preentrenamiento se realizó
en un conjunto de datos grande sin etiquetas (Figura 126).
Figura 126. En comparación con el modelado del lenguaje (preentrenamiento), el ajuste fino completo utiliza un conjunto de datos más
pequeño pero etiquetado.
Puede utilizar cualquier dato etiquetado para realizar un ajuste fino completo, lo que lo convierte
también en una excelente técnica para aprender representaciones específicas del dominio. Para que
nuestro LLM siga instrucciones, necesitaremos datos de preguntas y respuestas. Estos datos,
como se muestra en la Figura 127, son consultas del usuario con las respuestas correspondientes.
Figura 127. Datos de instrucciones con instrucciones del usuario y sus respuestas correspondientes. Las
instrucciones pueden contener muchas tareas diferentes.
Durante el ajuste fino completo, el modelo toma la entrada (instrucciones) y aplica la predicción
del siguiente token en la salida (respuesta). A su vez, en lugar de generar nuevas
preguntas, seguirá las instrucciones.
Ajuste fino de parámetros eficiente (PEFT)

La actualización de todos los parámetros de un modelo tiene un gran potencial para
aumentar su rendimiento, pero conlleva varias desventajas. Es costoso entrenarlo, tiene
tiempos de entrenamiento lentos y requiere una cantidad significativa de almacenamiento.
Para resolver estos problemas, se ha prestado atención a las alternativas de ajuste fino con
eficiencia de parámetros (PEFT) que se centran en ajustar los modelos
preentrenados con una mayor eficiencia computacional.
Adaptadores
Los adaptadores son un componente central de muchas técnicas basadas en

PEFT. El método propone un conjunto de componentes modulares adicionales
dentro del Transformador que se pueden ajustar para mejorar el rendimiento del modelo
en una tarea específica sin tener que ajustar todos los pesos del modelo. Esto ahorra
mucho tiempo y cálculos.
Los adaptadores se describen en el artículo “Parameterefficient transfer learning for

NLP”, que mostró que ajustar con precisión el 3,6 % de los parámetros de BERT para
una tarea puede producir un rendimiento comparable al ajuste fino de todos los pesos
del modelo.1 En el punto de referencia GLUE, los autores muestran que alcanzan un
0,4 % del rendimiento del ajuste fino completo. En un solo bloque Transformer, la
arquitectura propuesta en el artículo coloca los adaptadores después de la capa de
atención y la red neuronal de avance, como se ilustra en la Figura 128.
Figura 128. Los adaptadores agregan una pequeña cantidad de pesos en ciertos lugares de la red que se pueden ajustar de
manera eficiente, mientras que la mayoría de los pesos del modelo permanecen inalterados.
Sin embargo, no basta con alterar sólo un bloque Transformador, sino que estos
componentes son parte de cada bloque del modelo, como muestra la Figura 129 .
Figura 129. Los componentes del adaptador abarcan los distintos bloques del transformador en el modelo.
Al ver todos los componentes del adaptador en el modelo de esta manera, podemos ver los
adaptadores individuales como se muestra en la Figura 1210, que es una colección de estos
componentes que abarcan todos los bloques del modelo. El adaptador 1 puede ser un
especialista en, por ejemplo, la clasificación de textos médicos, mientras que el adaptador 2 puede especializarse
en reconocimiento de entidades nombradas (NER). Puede descargar adaptadores

especializados desde https://oreil.ly/XraXg.
Figura 1210. Los adaptadores que se especializan en tareas específicas se pueden intercambiar en la misma
arquitectura (si comparten la misma arquitectura y pesos del modelo original).
El artículo “AdapterHub: un marco para adaptar transformadores” presentó el

concentrador adaptador como repositorio central para compartir adaptadores.2 Muchos de
estos primeros adaptadores estaban más centrados en arquitecturas BERT.
Más recientemente, el concepto se ha aplicado a los transformadores de generación de texto en artículos como “LLaMA
Adapter: Efficient finetuning of language models 3 con atención de inicio cero”.
Adaptación de bajo rango (LoRA)
Como alternativa a los adaptadores, se introdujo la adaptación de bajo rango (LoRA) y, al

momento de escribir este artículo, es una técnica ampliamente utilizada y efectiva para
PEFT. LoRA es una técnica que (al igual que los adaptadores) solo requiere actualizar
un pequeño conjunto de parámetros. Como se ilustra en la Figura 1211, crea un
pequeño subconjunto del modelo base para realizar ajustes en lugar de agregar capas al modelo.4
Figura 1211. LoRA solo requiere ajustar un pequeño conjunto de parámetros que pueden mantenerse
separados del LLM base.
Al igual que los adaptadores, este subconjunto permite un ajuste fino mucho más
rápido, ya que solo necesitamos actualizar una pequeña parte del modelo base. Creamos
este subconjunto de parámetros aproximando matrices grandes que acompañan al LLM
original con matrices más pequeñas. Luego podemos usar esas matrices más pequeñas
como reemplazo y ajustarlas en lugar de las matrices grandes originales. Tomemos como
ejemplo la matriz 10 × 10 que vemos en la Figura 1212.
Figura 1212. Un importante obstáculo de los LLM son sus enormes matrices de peso. Solo una de ellas puede tener
150 millones de parámetros y cada bloque Transformer tendría su versión de estos.
Podemos crear dos matrices más pequeñas que, al multiplicarlas, reconstruyen

una matriz de 10 × 10. Esto supone una importante mejora en la eficiencia, ya que en
lugar de utilizar 100 pesos (10 por 10), ahora solo tenemos 20 pesos (10 más 10),
como podemos ver en la Figura 1213.
Figura 1213. La descomposición de una matriz de peso grande en dos matrices más pequeñas produce una versión
comprimida y de bajo rango de la matriz que se puede ajustar con mayor eficiencia.
Durante el entrenamiento, solo necesitamos actualizar estas matrices más pequeñas en lugar
de los cambios de peso completos. Las matrices de cambio actualizadas (matrices más pequeñas)
se combinan luego con los pesos completos (congelados), como se ilustra en la Figura 1214.
Figura 1214. En comparación con el ajuste fino completo, LoRA tiene como objetivo actualizar una pequeña representación de
los pesos originales durante el entrenamiento.
Pero es posible que sospeche que el rendimiento disminuiría, y estaría en lo cierto. Pero
¿dónde tiene sentido esta compensación?
Artículos como “La dimensionalidad intrínseca explica la efectividad del ajuste fino del modelo
de lenguaje” demuestran que los modelos de lenguaje “tienen una dimensión intrínseca
muy baja”. 5 Esto significa que podemos encontrar rangos pequeños que se aproximan
incluso a las matrices masivas de un LLM. Un modelo 175B como GPT3, por ejemplo,
tendría una matriz de peso de 12,288 × 12,288 dentro de cada uno de sus 96 bloques
Transformer. Eso es 150 millones de parámetros. Si podemos adaptar con éxito esa matriz al
rango 8, eso solo requeriría dos matrices de 12,288 × 2 que resultan en 197K parámetros
por bloque. Estos son ahorros importantes en velocidad, almacenamiento y computación
como se explica más adelante en el artículo de LoRA mencionado anteriormente.
Esta representación más pequeña es bastante flexible, ya que permite seleccionar qué
partes del modelo base se van a ajustar. Por ejemplo, solo podemos ajustar las matrices de
ponderación de consulta y valor en cada capa del transformador.
Comprimir el modelo para un entrenamiento (más) eficiente
Podemos hacer que LoRA sea aún más eficiente reduciendo los requisitos de
memoria de los pesos originales del modelo antes de proyectarlos en matrices más
pequeñas. Los pesos de un LLM son valores numéricos con una precisión dada, que se
pueden expresar mediante la cantidad de bits, como float64 o float32. Como se ilustra
en la Figura 1215, si reducimos la cantidad de bits para representar un valor, obtenemos
un resultado menos preciso. Sin embargo, si reducimos la cantidad de bits, también
reducimos los requisitos de memoria de ese modelo.
Figura 1215. Intentando representar pi con representaciones de coma flotante de 32 bits y coma flotante de 16 bits. Observe la
precisión reducida cuando reducimos a la mitad el número de bits.
Con la cuantificación, buscamos reducir la cantidad de bits y, al mismo tiempo, representar con
precisión los valores de peso originales. Sin embargo, como se muestra en la Figura 1216,
al asignar directamente valores de precisión más altos a valores de precisión más
bajos, es posible que varios valores de precisión más altos terminen siendo representados por
los mismos valores de precisión más bajos.
Figura 1216. La cuantificación de pesos que están cerca unos de otros da como resultado los mismos pesos
reconstruidos, eliminando así cualquier factor diferenciador.
En cambio, los autores de QLoRA, una versión cuantificada de LoRA, encontraron una
forma de pasar de un mayor número de bits a un valor menor y viceversa sin diferenciarse
demasiado de los pesos originales.6
Utilizaron la cuantificación por bloques para asignar ciertos bloques de valores de mayor
precisión a valores de menor precisión. En lugar de asignar directamente valores
de mayor precisión a valores de menor precisión, se crean bloques adicionales que
permiten cuantificar pesos similares. Como se muestra en la Figura 1217, esto da
como resultado valores que se pueden representar con precisión con menor precisión.
Figura 1217. La cuantificación por bloques puede representar pesos con precisión menor a través de bloques
de cuantificación.
Una propiedad interesante de las redes neuronales es que sus valores generalmente
se distribuyen normalmente entre 1 y 1. Esta propiedad nos permite agrupar los pesos
originales en bits más bajos en función de su densidad relativa, como se ilustra en la Figura
1218. El mapeo entre pesos es más eficiente ya que tiene en cuenta la frecuencia relativa
de los pesos. Esto también reduce los problemas con los valores atípicos.
Figura 1218. Al utilizar bloques que tienen en cuenta la distribución, podemos evitar que valores cercanos entre
sí se representen con el mismo valor cuantificado.
Combinado con la cuantificación por bloques, este procedimiento de normalización permite

una representación precisa de valores de alta precisión mediante valores de baja precisión
con solo una pequeña disminución en el rendimiento del LLM. Como resultado, podemos
pasar de una representación de punto flotante de 16 bits a una miserable
representación de punto flotante normalizada de 4 bits. Una representación de 4 bits reduce
significativamente los requisitos de memoria del LLM durante el entrenamiento.
Tenga en cuenta que la cuantificación de los LLM en general también es útil para la
inferencia, ya que los LLM cuantificados son de menor tamaño y, por lo tanto, requieren menos VRAM.
Existen métodos más elegantes para optimizar esto aún más, como la cuantificación
doble y los optimizadores paginados, sobre los que puede leer más en
Artículo sobre QLoRA analizado anteriormente. Para obtener una guía completa y muy visual sobre
cuantificación, consulte esta publicación del blog.
Ajuste de instrucciones con QLoRA

Ahora que hemos explorado cómo funciona QLoRA, ¡pongamos en práctica ese conocimiento! En esta
sección, perfeccionaremos una versión completamente de código abierto y más pequeña de Llama,
TinyLlama. para seguir instrucciones utilizando el procedimiento QLoRA. Considere este modelo como
un modelo base o preentrenado, uno que fue entrenado con modelado de lenguaje pero que aún no puede
seguir instrucciones.
Datos de instrucciones de creación de plantillas
Para que el LLM siga las instrucciones, necesitaremos preparar datos de instrucciones que sigan una
plantilla de chat. Esta plantilla de chat, como se ilustra en la Figura 1219, diferencia entre lo que
ha generado el LLM y lo que ha generado el usuario.
Figura 1219. La plantilla de chat que utilizamos a lo largo de este capítulo.
Elegimos esta plantilla de chat para usar en todos los ejemplos, ya que la versión de chat de TinyLlama
utiliza el mismo formato. Los datos que estamos utilizando son un
7 pequeño subconjunto del conjunto de datos UltraChat. Este conjunto de datos es una versión filtrada
del conjunto de datos UltraChat original que contiene casi 200 000 conversaciones entre un usuario
y un LLM.
Creamos una función, format_prompt, para asegurarnos de que las conversaciones

sigan esta plantilla:
desde transformadores importar AutoTokenizer

desde conjuntos de datos importar load_dataset
# Cargue un tokenizador para usar su plantilla de chat

template_tokenizer = AutoTokenizer.from_pretrained( "TinyLlama/
TinyLlama1.1BChatv1.0"
)
def format_prompt(ejemplo):
"""Formatee el mensaje para utilizar la plantilla <|usuario|> que utiliza TinyLLama"""
# Formato de respuestas chat

= ejemplo["mensajes"] prompt =
plantilla_tokenizer.apply_chat_template(chat, tokenize=False)
devolver {"texto": mensaje instantáneo}
# Cargue y formatee los datos usando la plantilla que TinyLLama está usando dataset = (
cargar_conjunto_de_datos("HuggingFaceH4/ultrachat_200k",
dividir="prueba_sft")
.shuffle(semilla=42) .select(rango(3_000))
) conjunto de datos = conjunto de datos.map(format_prompt)
Seleccionamos un subconjunto de 3.000 documentos para reducir el tiempo de entrenamiento,

pero puedes aumentar este valor para obtener resultados más precisos.
Usando la columna "texto", podemos explorar estas indicaciones formateadas:
# Ejemplo de un mensaje con formato

print(dataset["text"][2576])
<|usuario|>
Dado el texto: Toc, toc. ¿Quién está ahí? Camina.
¿Puedes continuar el chiste basándote en el material de texto proporcionado?
"Toc, toc. ¿Quién es? ¡Camina!"</s> <|assistant|> ¡Claro! Toc,

toc. ¿Quién es?
¡Camina! ¿Quién camina? ¡Súbete los pantalones, hace frío afuera!</s> <|user|> ¿Puedes contarme otro
chiste de toctoc basado en el mismo material de
texto "Toc,
toc. ¿Quién es? ¡Camina!"</s> <|assistant|> ¡Por supuesto! Toc, toc. ¿Quién es? ¡Camina! ¿Quién camina?
¡Camina hasta aquí y salgamos a caminar!</s>
Cuantificación de modelos
Ahora que tenemos nuestros datos, podemos empezar a cargar nuestro modelo. Aquí
es donde aplicamos la Q en QLoRA, es decir, la cuantificación.
Usamos el paquete bitsandbytes para comprimir el modelo preentrenado a una
representación de 4 bits.
En BitsAndBytesConfig, puede definir el esquema de cuantificación. Seguimos los

pasos utilizados en el artículo original de QLoRA y cargamos el modelo en 4 bits
(load_in_4bit) con una representación de punto flotante normalizada
(bnb_4bit_quant_type) y cuantificación doble
(bnb_4bit_use_double_quant):
importar antorcha
desde transformers importar AutoModelForCausalLM, AutoTokenizer,
Configuración de bits y bytes
nombre_modelo = "TinyLlama/TinyLlama1.1Bpasointermedio1431k3T"
# Configuración de cuantificación de 4 bits Q en QLoRA bnb_config =

BitsAndBytesConfig( load_in_4bit=True, # Usar modelo
de precisión de 4 bits loading bnb_4bit_quant_type="nf4", # Tipo de cuantificación
bnb_4bit_compute_dtype="float16", # Calcular dtype
bnb_4bit_use_double_quant=True, # Aplicar cuantificación anidada
# Cargar el modelo a entrenar en la GPU

modelo = AutoModelForCausalLM.from_pretrained( nombre_modelo,
mapa_dispositivo="auto",
# Deje esto fuera para SFT regular

quantization_config=bnb_config,
) modelo.config.use_cache = Falso
modelo.config.pretraining_tp = 1
# Cargar el tokenizador LLaMA

tokenizer = AutoTokenizer.from_pretrained(nombre_del_modelo,
código_remoto_de_confianza=True)
tokenizer.pad_token = "<PAD>"
tokenizer.padding_side = "izquierda"
Este procedimiento de cuantificación nos permite reducir el tamaño del modelo original y, al
mismo tiempo, conservar la mayor parte de la precisión de los pesos originales. Ahora, cargar el
modelo solo utiliza aproximadamente 1 GB de VRAM en comparación con los aproximadamente
4 GB de VRAM que necesitaría sin cuantificación. Tenga en cuenta que, durante el ajuste
fino, será necesaria más VRAM para no alcanzar el límite de aproximadamente 1 GB de
VRAM necesario para cargar el modelo.
Configuración de LoRA
A continuación, necesitaremos definir nuestra configuración LoRA utilizando la biblioteca
peft , que representa hiperparámetros del proceso de ajuste fino:
desde peft , importe LoraConfig, prepare_model_for_kbit_training, obtenga_peft_model
# Preparar la configuración de LoRA peft_config

= LoraConfig( lora_alpha=32, #
Escalamiento de LoRA lora_dropout=0.1, #
Abandono para capas de LoRA r=64, # Sesgo de rango ="none",
task_type="CAUSAL_LM",
target_modules= # Capas a las que apuntar
["k_proj", "gate_proj", "v_proj", "up_proj", "q_proj", "o_proj", "down_proj"]
# Preparar el modelo para el

entrenamiento modelo = prepare_model_for_kbit_training(modelo)
modelo = get_peft_model(modelo, peft_config)
Hay varios parámetros que vale la pena mencionar:
Este es el rango de las matrices comprimidas (recuerde esto de la Figura 12
13) Aumentar este valor también aumentará los tamaños de las matrices
comprimidas, lo que dará lugar a una menor compresión y, por lo tanto, a una mejora.
Poder representativo. Los valores suelen oscilar entre 4 y 64.
lora_alpha Controla
la cantidad de cambio que se agrega a los pesos originales. En esencia, equilibra el
conocimiento del modelo original con el del modelo original.
Nueva tarea. Una regla general es elegir un valor que sea el doble del tamaño de r.
target_modules Controla
las capas a las que se apuntará. El procedimiento LoRA puede optar por ignorar
capas específicas, como capas de proyección específicas. Esto puede acelerar el
entrenamiento, pero reducir el rendimiento y viceversa.
Jugar con los parámetros es un experimento que vale la pena para obtener una comprensión
intuitiva de los valores que funcionan y los que no. Puede encontrar un recurso increíble con
consejos adicionales sobre el ajuste fino de LoRA en el boletín Ahead of AI de Sebastian
Raschka.
NOTA
Este ejemplo demuestra una forma eficiente de ajustar el modelo. Si, en cambio, desea
realizar un ajuste completo, puede eliminar el parámetro quantization_config al
cargar el modelo y omitir la creación de peft_config. Al eliminarlos, pasaríamos
de “Ajuste de instrucciones con QLoRA” a “Ajuste completo de instrucciones”.
Configuración de entrenamiento
Por último, necesitamos configurar nuestros parámetros de entrenamiento como lo hicimos en
Capítulo 11:
Desde los transformadores se importan TrainingArguments
directorio_de_salida = "./resultados"
# Argumentos de entrenamiento
training_arguments = TrainingArguments( output_dir=output_dir,
gradient_accumulation_steps=4,
optim="paged_adamw_32bit",
learning_rate=2e4,
lr_scheduler_type="cosine",
num_train_epochs=1, logging_steps=10,
fp16=True,
gradient_checkpointing=True
Hay varios parámetros que vale la pena mencionar:
num_train_epochs
Número total de rondas de entrenamiento. Los valores más altos tienden a degradar el
rendimiento, por lo que generalmente preferimos mantenerlo bajo.
tasa de aprendizaje
Determina el tamaño del paso en cada iteración de las actualizaciones de peso. Los autores de
QLoRA descubrieron que las tasas de aprendizaje más altas funcionan mejor para modelos más grandes
(>33B parámetros).
tipo de programador lr
Un programador basado en coseno para ajustar la tasa de aprendizaje de forma dinámica.
Aumentará linealmente la tasa de aprendizaje, comenzando desde cero, hasta que alcance el valor
establecido. Después de eso, la tasa de aprendizaje decae siguiendo los valores de
una función coseno.
optim Los
optimizadores paginados utilizados en el artículo original de QLoRA.
Optimizar estos parámetros es una tarea difícil y no existen pautas establecidas para
hacerlo. Es necesario experimentar para determinar qué funciona mejor para conjuntos de datos
específicos, tamaños de modelos y tareas objetivo.
NOTA
Aunque esta sección describe el ajuste de instrucciones, también podríamos usar QLoRA para
ajustar un modelo de instrucciones. Por ejemplo, podríamos ajustar un modelo de chat para generar
un código SQL específico o para crear una salida JSON que se ajuste a un formato específico. Siempre
que tenga los datos disponibles (con los elementos de consultarespuesta adecuados), QLoRA es una
excelente técnica para hacer que un modelo de chat existente sea más apropiado para su caso de uso.
Capacitación
Ahora que hemos preparado todos nuestros modelos y parámetros, podemos comenzar a ajustar
nuestro modelo. Cargamos SFTTrainer y simplemente ejecutamos trainer.train():
Desde trl importar SFTTrainer

# Establecer parámetros de ajuste fino supervisados trainer =

SFTTrainer( model=model,
train_dataset=dataset,
dataset_text_field="text",
tokenizer=tokenizer, args=training_arguments,
max_seq_length=512,
# Deje esto fuera para SFT regular peft_config=peft_config,
# Modelo de tren
trainer.train()
# Guardar pesas QLoRA

trainer.model.save_pretrained("TinyLlama1.1Bqlora")
Durante el entrenamiento, la pérdida se imprimirá cada 10 pasos según el parámetro

logging_steps. Si estás usando la GPU gratuita proporcionada por Google Colab, que
es la Tesla T4 en el momento de escribir esto, entonces el entrenamiento puede
demorar hasta una hora. ¡Un buen momento para tomar un descanso!
Fusionar pesos
Después de haber entrenado nuestros pesos QLoRA, todavía necesitamos combinarlos
con los pesos originales para usarlos. Recargamos el modelo en 16 bits, en lugar
de los 4 bits cuantificados, para fusionar los pesos. Aunque el tokenizador no se actualizó
durante el entrenamiento, lo guardamos en la misma carpeta que el modelo para facilitar
el acceso:
desde peft importar AutoPeftModelForCausalLM
modelo = AutoPeftModelForCausalLM.from_pretrained(
"TinyLlama1.1Bqlora",
uso_bajo_de_memoria_de_CPU=Verdadero,
mapa_de_dispositivo="automático",
)
# Fusionar LoRA y el modelo base

merged_model = model.merge_and_unload()
Después de fusionar el adaptador con el modelo base, podemos usarlo con la plantilla
de solicitud que definimos anteriormente:
# Utilice nuestra plantilla de solicitud predefinida prompt = """<|

user|> Cuénteme algo sobre los
modelos de lenguaje grandes.</s> <|assistant|>
"""
# Ejecuta nuestro modelo ajustado a instrucciones pipe

= pipeline(task="textgeneration", model=merged_model, tokenizer=tokenizer) print(pipe(prompt)[0]
["generated_text"])
Los modelos de lenguaje de gran tamaño (LLM) son modelos de inteligencia artificial (IA) que aprenden
el lenguaje y comprenden lo que significa decir cosas en un idioma en particular. Se entrenan con grandes
cantidades de texto…
El resultado agregado muestra que ahora el modelo sigue de cerca nuestras

instrucciones, lo que no es posible con el modelo base.
Evaluación de modelos generativos

La evaluación de modelos generativos plantea un desafío importante. Los modelos
generativos se utilizan en muchos casos de uso diferentes, por lo que resulta complicado
confiar en una única métrica para tomar decisiones. A diferencia de los modelos más
especializados, la capacidad de un modelo generativo para resolver cuestiones
matemáticas no garantiza el éxito en la resolución de cuestiones de codificación.
Al mismo tiempo, evaluar estos modelos es vital, en particular en entornos de

producción donde la coherencia es importante. Dada su naturaleza probabilística,
los modelos generativos no necesariamente generan resultados coherentes; es
necesario realizar una evaluación sólida.
En esta sección, exploraremos algunos métodos de evaluación comunes, pero queremos

enfatizar la falta actual de estándares de oro. Ninguna métrica es perfecta para todos los
casos de uso.
Métricas a nivel de palabra
Una categoría de métricas común para comparar modelos generativos es la evaluación a

nivel de palabra. Estas técnicas clásicas comparan un conjunto de datos de referencia con los
tokens generados a nivel de token(conjunto). Las métricas comunes a nivel de palabra8
perplejidad, ROUGE,9 BLEU ,10 y BERTScore.11 incluyen
Cabe destacar la perplejidad, que mide la capacidad de un modelo de lenguaje para predecir un
texto. Dado un texto de entrada, el modelo predice la probabilidad de que aparezca el siguiente
token. Con la perplejidad, asumimos que un modelo funciona mejor si le da al siguiente token
una alta probabilidad. En otras palabras, los modelos no deberían quedar “perplejos”
cuando se les presenta un documento bien escrito.
Como se ilustra en la Figura 1220, cuando se presenta la entrada “Cuando una medida
se convierte en a”, se le pregunta al modelo qué probabilidad hay de que la palabra “objetivo”
sea la siguiente palabra.
Figura 1220. La predicción de la siguiente palabra es una característica central de muchos LLM.
Aunque la perplejidad y otras métricas a nivel de palabras son métricas útiles para
comprender la confianza del modelo, no son una medida perfecta.
No tienen en cuenta la consistencia, la fluidez, la creatividad o incluso la corrección del texto
generado.
Puntos de referencia
Un método común para evaluar modelos generativos en tareas de generación y

comprensión del lenguaje se basa en puntos de referencia públicos y conocidos,
como MMLU,12 GLUE,13 TruthfulQA,14 GSM8k,15 y
HellaSwag.16 Estos puntos de referencia nos brindan información sobre la comprensión básica
del lenguaje, pero también respuestas analíticas complejas, como problemas de matemáticas.
Además de las tareas de lenguaje natural, algunos modelos se especializan en otros

dominios, como la programación. Estos modelos tienden a evaluarse en diferentes puntos de
referencia, como HumanEval,17 que consiste en tareas de programación desafiantes
que el modelo debe resolver. La Tabla 121 ofrece una descripción general de los puntos de
referencia públicos comunes para los modelos generativos.
Tabla 121. Puntos de referencia públicos comunes para modelos generativos
Descripción del punto de referencia Recursos
Universidad de Michigan El benchmark Massive https://oreil.ly/nrG_g

Multitask Language
Understanding (MMLU) prueba el
modelo en 57 tareas diferentes,
incluida la clasificación, la
respuesta a preguntas y el
análisis de sentimientos.
PEGAMENTO
El punto de referencia de https://oreil.ly/LV_fb
evaluación de la comprensión
del lenguaje general (GLUE) consiste
en tareas de comprensión del
lenguaje que cubren un amplio
grado de dificultad.
QA veraz TruthfulQA mide la veracidad https://oreil.ly/i2Brj

de un modelo.
texto generado
GSM8k El conjunto de datos GSM8k contiene https://oreil.ly/oOBXY

problemas matemáticos de
nivel primario. Es lingüísticamente
diverso y fue creado por redactores
de problemas humanos.
HellaSwag HellaSwag es un conjunto de https://oreil.ly/aDvBP

datos de desafío para
evaluar la inferencia de sentido
común. Consiste en preguntas de
opción múltiple que el modelo debe
responder. Puede seleccionar una de
Descripción del punto de referencia Recursos
cuatro opciones de respuesta para cada uno
pregunta.
Evaluación humana El punto de referencia HumanEval se https://oreil.ly/dlJIX

utiliza para evaluar el código generado
en función de 164
problemas de programación.
Los benchmarks son una excelente manera de obtener una idea básica sobre el rendimiento de un
modelo en una amplia variedad de tareas. Una desventaja de los benchmarks públicos es
que los modelos pueden sobreajustarse a estos benchmarks para generar las mejores
respuestas. Además, estos siguen siendo benchmarks amplios y podrían no cubrir casos de uso muy
específicos. Por último, otra desventaja es que algunos benchmarks requieren GPU potentes con un
tiempo de ejecución prolongado (más de horas) para realizar los cálculos, lo que dificulta la iteración.
Tablas de clasificación
Con tantos puntos de referencia diferentes, es difícil elegir el que mejor se adapta a tu modelo. Siempre
que se lanza un modelo, a menudo lo verás evaluado en varios puntos de referencia para mostrar su
rendimiento en general.
Por ello, se desarrollaron tablas de clasificación que contenían múltiples puntos de referencia. Una tabla
de clasificación común es la tabla de clasificación Open LLM. que, al momento de escribir este artículo,
incluye seis puntos de referencia, entre ellos HellaSwag, MMLU, TruthfulQA y GSM8k. Los
modelos que encabezan la clasificación, suponiendo que no se hayan sobreajustado a los datos,
generalmente se consideran los "mejores".
Sin embargo, dado que estas tablas de clasificación a menudo contienen puntos de referencia
disponibles públicamente, existe el riesgo de sobreajuste en la tabla de clasificación.
Evaluación automatizada
Parte de la evaluación de un resultado generativo es la calidad de su texto. Por ejemplo, incluso si dos modelos
dieran la misma respuesta correcta a una pregunta, la forma en que derivaron esa respuesta podría ser
diferente. A menudo, no se trata solo de la respuesta final, sino también de su construcción. De manera
similar, aunque dos resúmenes pueden ser similares, uno puede ser significativamente más corto que
otro, lo que a menudo es importante para un buen resumen.
Para evaluar la calidad del texto generado por encima de la exactitud de la respuesta final, se introdujo el
método LLM como juez.18 En esencia, se le pide a un LLM independiente que juzgue la calidad del LLM
que se va a evaluar. Una variante interesante de este método es la comparación por pares. Dos
LLM diferentes generarán una respuesta a una pregunta y un tercer LLM será el juez que declare cuál es
mejor.
Como resultado, esta metodología permite la evaluación automatizada de preguntas abiertas. Una
ventaja importante es que, a medida que los LLM mejoran, también lo hacen sus capacidades para evaluar
la calidad de los resultados. En otras palabras, esta metodología de evaluación crece con el campo.
Evaluación humana
Si bien los parámetros de referencia son importantes, generalmente se considera que el criterio de
excelencia para la evaluación es la evaluación humana. Incluso si un LLM obtiene una buena puntuación en
parámetros de referencia generales, es posible que no obtenga una buena puntuación en tareas específicas del dominio.
Además, los puntos de referencia no reflejan plenamente las preferencias humanas y todos los métodos
analizados anteriormente son simplemente indicadores de esas preferencias.
Un gran ejemplo de una técnica de evaluación basada en humanos es el Chatbot. 19 Arena.
Cuando accedes a esta tabla de clasificación, se muestran dos (anónimos)
LLM con los que puedes interactuar. Cualquier pregunta o sugerencia que hagas se enviará a ambos modelos y
recibirás su resultado. Luego, puedes decidir qué resultado prefieres. Este proceso permite que la comunidad
vote sobre qué modelos prefieren sin saber cuáles se presentan. Solo después de votar, verás qué modelo
generó qué texto.

Al momento de escribir este artículo, este método ha generado más de 800.000 votos
humanos que se utilizaron para calcular una tabla de clasificación. Estos votos se utilizan
para calcular el nivel de habilidad relativo de los LLM en función de sus tasas de victorias.
Por ejemplo, si un LLM de bajo rango vence a un LLM de alto rango, su clasificación
cambia significativamente. En ajedrez, esto se conoce como el sistema de clasificación Elo.
Por lo tanto, esta metodología utiliza votaciones colaborativas, lo que nos ayuda a
comprender la calidad del LLM. Sin embargo, sigue siendo la opinión agregada de una
amplia variedad de usuarios, que puede no estar relacionada con su caso de uso.
Como resultado, no existe un método perfecto para evaluar los LLM. Todas las
metodologías y los puntos de referencia mencionados brindan una perspectiva de evaluación
importante, aunque limitada. Nuestro consejo es que evalúe su LLM en función del caso de uso
previsto. Para la codificación, HumanEval sería más lógico que GSM8k.
Pero lo más importante es que creemos que usted es el mejor evaluador. La evaluación
humana sigue siendo el estándar de oro porque depende de usted decidir si el LLM
funciona para el caso de uso que desea. Al igual que con los ejemplos de este capítulo, le
recomendamos encarecidamente que también pruebe estos modelos y tal vez desarrolle algunas
preguntas usted mismo. Por ejemplo, los autores de este libro son árabes (Jay Alammar) y
holandeses (Maarten Grootendorst), y a menudo hacemos preguntas en nuestra lengua materna
cuando nos contactan con nuevos modelos.
Una nota final sobre este tema es una cita que apreciamos mucho:
Cuando una medida se convierte en un objetivo, deja de ser una buena medida.
—Ley de Goodhart20
En el contexto de los LLM, cuando utilizamos un parámetro específico, tendemos a

optimizarlo sin importar las consecuencias. Por ejemplo, si nos centramos exclusivamente en
optimizar para generar oraciones gramaticalmente correctas, el modelo podría aprender
a generar solo una oración: “Esta es una oración”. Es gramaticalmente correcta, pero no nos
dice nada sobre sus capacidades de comprensión del lenguaje. Por lo tanto, el modelo
puede sobresalir en un parámetro específico, pero potencialmente a expensas de otras
capacidades útiles.
Ajuste de preferencias / Alineación / RLHF

Aunque nuestro modelo ahora puede seguir instrucciones, podemos mejorar aún más su
comportamiento mediante una fase de entrenamiento final que lo alinee con la forma en que
esperamos que se comporte en diferentes escenarios. Por ejemplo, cuando nos preguntan “¿Qué
es un LLM?”, podríamos preferir una respuesta elaborada que describa los aspectos internos de
un LLM en comparación con la respuesta “Es un modelo de lenguaje grande” sin más
explicaciones. ¿Cómo alineamos exactamente nuestra preferencia (humana) por una
respuesta sobre la otra con el resultado de un LLM?
Para empezar, recuerde que un LLM toma un mensaje y genera una generación como se ilustra
en la Figura 1221.
Figura 1221. Un LLM toma una solicitud de entrada y genera una generación.
Podemos pedirle a una persona (evaluador de preferencias) que evalúe la calidad de la

generación de ese modelo. Digamos que le asigna una puntuación determinada, como 4 (ver
Figura 1222 ).
Figura 1222. Utilice un evaluador de preferencias (humano o de otro tipo) para evaluar la calidad de
la generación.
La figura 1223 muestra un paso de ajuste de preferencias que actualiza el modelo en función de
esa puntuación:
Si la puntuación es alta, el modelo se actualiza para incentivarlo a generar más

como este tipo de generación.
Si la puntuación es baja, el modelo se actualiza para desalentar dichas

generaciones.
Figura 1223. Los métodos de ajuste de preferencias actualizan el LLM en función de la puntuación de la evaluación.
Como siempre, necesitamos muchos ejemplos de entrenamiento. ¿Podemos automatizar la

evaluación de preferencias? Sí, podemos hacerlo entrenando un modelo diferente llamado modelo
de recompensa.
Automatizar la evaluación de preferencias mediante

Modelos de recompensa
Para automatizar la evaluación de preferencias, necesitamos un paso antes del paso de ajuste de
preferencias, es decir, entrenar un modelo de recompensa, como se muestra en la Figura 1224.
Figura 1224. Entrenamos un modelo de recompensa antes de ajustar el LLM.
La figura 1225 muestra que para crear un modelo de recompensa, tomamos una copia del
modelo ajustado a las instrucciones y lo modificamos ligeramente para que, en lugar de generar
texto, ahora genere una única puntuación.
Figura 1225. El LLM se convierte en un modelo de recompensa al reemplazar su cabezal de modelado de lenguaje por un
cabezal de clasificación de calidad.
Las entradas y salidas de un modelo de recompensa

La forma en que esperamos que funcione este modelo de recompensa es que le damos una
indicación y una generación, y genera un único número que indica la preferencia/
calidad de esa generación en respuesta a esa indicación. La Figura 1226 muestra el modelo
de recompensa que genera este único número.
Figura 1226. Utilice un modelo de recompensa entrenado en la preferencia humana para generar la calidad de finalización
puntaje.
Entrenando un modelo de recompensa
No podemos utilizar directamente el modelo de recompensas. Primero hay que entrenarlo para que
puntúe correctamente las generaciones. Por lo tanto, obtengamos un conjunto de datos de preferencias del
que el modelo pueda aprender.
Conjunto de datos de entrenamiento del modelo de recompensa
Una forma común para los conjuntos de datos de preferencias es que un ejemplo de entrenamiento
tenga un mensaje, con una generación aceptada y una generación rechazada.
(Matiz: no siempre se trata de una generación buena versus una mala; puede ser que las dos
generaciones sean buenas, pero que una sea mejor que la otra). La figura 1227 muestra un
ejemplo de conjunto de entrenamiento de preferencias con dos ejemplos de entrenamiento.
Figura 1227. Los conjuntos de datos de ajuste de preferencias a menudo se componen de indicaciones con generaciones
aceptadas y rechazadas.
Una forma de generar datos de preferencias es presentar una solicitud al LLM y pedirle que genere
dos generaciones diferentes. Como se muestra en la Figura 1228, podemos preguntar a los
etiquetadores humanos cuál de las dos prefieren.
Figura 1228. Imprima dos generaciones y pregúntele a un etiquetador humano cuál prefiere.
Paso de entrenamiento del modelo de recompensa
Ahora que tenemos el conjunto de datos de entrenamiento de preferencias, podemos proceder a entrenar
el modelo de recompensa.
Un paso sencillo es que utilicemos el modelo de recompensa para:
1. Califica la generación aceptada
2. Califica a la generación rechazada
La figura 1229 muestra el objetivo del entrenamiento: garantizar que la generación aceptada tenga
una puntuación más alta que la generación rechazada.

Figura 1229. El modelo de recompensa tiene como objetivo evaluar los puntajes de calidad de las generaciones en respuesta a una
indicación.
Cuando combinamos todo junto como se muestra en la Figura 1230, obtenemos las tres etapas para el ajuste de
preferencias:
1. Recopilar datos de preferencias
2. Entrena un modelo de recompensa

3. Utilice el modelo de recompensa para ajustar el LLM (que funciona como el

evaluador de preferencias)
Figura 1230. Las tres etapas del ajuste de preferencias: recopilación de datos de preferencias, entrenamiento de un modelo
de recompensa y, por último, ajuste fino del LLM.
Los modelos de recompensa son una idea excelente que se puede ampliar y desarrollar.
Llama 2, por ejemplo, entrena dos modelos de recompensa: uno que puntúa la utilidad y otro
que puntúa la seguridad (Figura 1231).
Figura 1231. Podemos utilizar múltiples modelos de recompensa para realizar la puntuación.
Un método común para ajustar el LLM con el modelo de recompensa entrenado es la
Optimización de Políticas Proximales (PPO). La PPO es una técnica de refuerzo popular

que optimiza el LLM ajustado a las instrucciones al asegurarse de que
LLM no se desvía demasiado de las recompensas esperadas.21 Incluso se utilizó para

entrenar el ChatGPT original. Lanzado en noviembre de 2022.
Modelo de entrenamiento sin recompensa
Una desventaja de PPO es que es un método complejo que necesita entrenar al menos
dos modelos, el modelo de recompensa y el LLM, lo que puede resultar más costoso de
lo necesario.
La optimización de preferencias directas (OPD) es una alternativa a la PPO y elimina

el procedimiento de aprendizaje basado en el refuerzo.22 En lugar de utilizar el modelo
de recompensa para juzgar la calidad de una generación, dejamos que el propio LLM lo
haga. Como se ilustra en la Figura 1232, utilizamos una copia del LLM como modelo
de referencia para juzgar el cambio entre el modelo de referencia y el modelo
entrenable en la calidad de la generación aceptada y la generación rechazada.
Figura 1232. Utilice el propio LLM como modelo de recompensa comparando el resultado de un modelo congelado
con el modelo entrenable.
Al calcular este cambio durante el entrenamiento, podemos optimizar la probabilidad de

generaciones aceptadas sobre las rechazadas mediante el seguimiento de la diferencia
entre el modelo de referencia y el modelo entrenable.
Para calcular este cambio y sus puntuaciones relacionadas, se extraen las probabilidades
logarítmicas de las generaciones rechazadas y aceptadas de ambos modelos. Como se
ilustra en la Figura 1233, este proceso se realiza a nivel de token, donde las probabilidades se
combinan para calcular el cambio entre los modelos de referencia y los modelos entrenables.
Figura 1233. Las puntuaciones se calculan tomando las probabilidades de generación a nivel de token.
Se optimiza el cambio de probabilidades entre el modelo de referencia y el modelo entrenable. La generación
aceptada sigue el mismo procedimiento.
Con estas puntuaciones, podemos optimizar los parámetros del modelo entrenable para tener
más confianza en la generación de las generaciones aceptadas y menos confianza en
la generación de las generaciones rechazadas. En comparación con PPO, los autores
descubrieron que DPO era más estable durante el entrenamiento y más preciso.
Debido a su estabilidad, lo usaremos como nuestro modelo principal para ajustar las preferencias
de nuestro modelo previamente ajustado por instrucciones.
Ajuste de preferencias con DPO

Cuando usamos la pila Hugging Face, el ajuste de preferencias es muy similar al ajuste de instrucciones que
vimos antes, con algunas pequeñas diferencias. Seguiremos usando TinyLlama, pero esta vez una versión
ajustada por instrucciones. que primero se entrenó utilizando un ajuste fino completo y luego se alineó aún
más con DPO.
En comparación con nuestro modelo inicial ajustado a las instrucciones, este LLM se entrenó en conjuntos
de datos mucho más grandes.
En esta sección, demostraremos cómo puede alinear aún más este modelo utilizando DPO con conjuntos
de datos basados en recompensas.
Datos de alineación de plantillas

Usaremos un conjunto de datos que para cada solicitud contiene una generación aceptada y una generación
rechazada. Este conjunto de datos Fue generado en parte por ChatGPT con puntuaciones sobre qué
salida debería aceptarse y cuál rechazarse:
def format_prompt(ejemplo):
"""Formatee el mensaje para utilizar la plantilla <|usuario|> que utiliza TinyLLama"""
# Formatear respuestas
sistema = "<|sistema|>\n" + ejemplo["sistema"] + "</s>\n" mensaje = "<|

"
usuario|>\n" + ejemplo["entrada"] +
</s>\n<|asistente|>\n"
elegido = ejemplo["elegido"] + "</s>\n" rechazado
= ejemplo["rechazado"] + "</s>\n"
return
{ "prompt": sistema + mensaje,
"chosen": elegido,
"rejected": rechazado,
}
# Aplicar formato al conjunto de datos y seleccionar relativamente corto

respuestas
dpo_dataset = cargar_conjuntodedatos(
"argilla/distilabelintelorcadpopairs", dividir="entrenar"
) dpo_dataset = dpo_dataset.filter(
lambda r:
r["status"] != "tie" y
r["chosen_score"] >= 8 y no
r["in_gsm8k_train"]
) dpo_dataset = dpo_dataset.map(
formato_de_aviso, eliminar_columnas=conjunto_de_datos_dpo.nombres_de_columnas
) conjunto de datos dpo
Tenga en cuenta que aplicamos un filtrado adicional para reducir aún más el tamaño de los
datos a aproximadamente 6.000 ejemplos de los 13.000 ejemplos originales.
Cuantificación de modelos
Cargamos nuestro modelo base y lo cargamos con el LoRA que creamos anteriormente.
Como antes, cuantificamos el modelo para reducir la VRAM necesaria para el
entrenamiento:
desde peft importa AutoPeftModelForCausalLM desde

transformers importa BitsAndBytesConfig, AutoTokenizer
# Configuración de cuantificación de 4 bits Q en QLoRA

bnb_config =
BitsAndBytesConfig( load_in_4bit=True, # Usar modelo de precisión de 4 bits
loading bnb_4bit_quant_type="nf4", # Tipo de cuantificación
bnb_4bit_compute_dtype="float16", # Calcular dtype
bnb_4bit_use_double_quant=True, # Aplicar cuantificación anidada
)

model = AutoPeftModelForCausalLM.from_pretrained(
uso_bajo_de_memoria_de_CPU=Verdadero, mapa_de_dispositivo="automático", configuración_de_cuantización=bnb_
) modelo_combinado = modelo.combinar_y_descargar()
# Cargar el tokenizador LLaMA

nombre_modelo = "TinyLlama/TinyLlama1.1Bpasointermedio1431k3T" tokenizador =
AutoTokenizer.from_pretrained(nombre_modelo, código_remoto_confiable=True)
tokenizador.pad_token = "<PAD>"
tokenizador.padding_side = "izquierda"
A continuación, utilizamos la misma configuración de LoRA que antes para realizar el entrenamiento
de DPO:
desde peft , importe LoraConfig, prepare_model_for_kbit_training, obtenga_peft_model
# Preparar la configuración de LoRA peft_config

= LoraConfig( lora_alpha=32, #
Escalamiento de LoRA lora_dropout=0.1, #
Abandono para capas de LoRA r=64, # Sesgo de rango ="none",
task_type="CAUSAL_LM",
target_modules= # Capas a las que apuntar
["k_proj", "gate_proj", "v_proj", "up_proj", "q_proj", "o_proj", "down_proj"] )
# preparar el modelo para el entrenamiento

modelo = prepare_model_for_kbit_training(modelo) modelo =
get_peft_model(modelo, peft_config)
Configuración de entrenamiento
Para simplificar, utilizaremos los mismos argumentos de entrenamiento que utilizamos antes con
una diferencia. En lugar de ejecutar durante una sola época (que puede llevar hasta dos horas),
ejecutamos durante 200 pasos con fines ilustrativos. Además, agregamos el parámetro
warmup_ratio, que aumenta la tasa de aprendizaje de 0 al valor learning_rate que configuramos
para el primer 10 % de los pasos. Al mantener una tasa de aprendizaje pequeña al comienzo (es decir,
período de calentamiento), permitimos que el modelo se ajuste a los datos antes de

aplicar tasas de aprendizaje mayores, evitando así divergencias perjudiciales:
desde trl importar DPOConfig
directorio_de_salida = "./resultados"
# Argumentos de entrenamiento
argumentos_de_entrenamiento =
DPOConfig( directorio_salida=directorio_salida,
tamaño_lote_entrenamiento_por_dispositivo=2,
pasos_acumulación_de_gradiente=4,
optim="paged_adamw_32bit",
tasa_de_aprendizaje=1e5,
tipo_programador_lr="coseno",
pasos_máximos=200, pasos_de_registro=10,
fp16=Verdadero, puntos_de_control_de_gradiente=Verdadero, índice_de_calentamiento=0.1
)
Capacitación
Ahora que hemos preparado todos nuestros modelos y parámetros, podemos comenzar
a ajustar nuestro modelo:
Desde trl importar DPOTrainer
# Crear entrenador de DPO

dpo_trainer = DPOTrainer( modelo,
args=argumentos_de_entrenamiento,
conjunto_de_datos_de_entrenamiento=conjunto_de_datos_de_dpo, tokenizer=tokenizer, peft_config=peft_config, beta=0.1, lo

)
# Ajuste el modelo con DPO

dpo_trainer.entrenar()
# Guardar adaptador
dpo_trainer.model.save_pretrained("TinyLlama1.1Bdpoqlora")
Hemos creado un segundo adaptador. Para fusionar ambos adaptadores, los fusionamos
iterativamente con el modelo base:
Desde peft importar PeftModel

model = AutoPeftModelForCausalLM.from_pretrained(
uso_bajo_de_memoria_de_CPU=Verdadero,
mapa_de_dispositivo="automático",
) sft_model = modelo.fusionar_y_descargar()
# Fusionar el modelo DPO LoRA y SFT

dpo_model = PeftModel.from_pretrained( sft_model,
"TinyLlama1.1Bdpoqlora",
device_map="auto",
) dpo_model = dpo_model.fusionar_y_descargar()
Esta combinación de SFT+DPO es una excelente manera de ajustar primero su modelo

para realizar un chat básico y luego alinear sus respuestas con las preferencias humanas.
Sin embargo, esto tiene un costo, ya que necesitamos realizar dos ciclos de
entrenamiento y potencialmente ajustar los parámetros en dos procesos.
Desde el lanzamiento de DPO, se han desarrollado nuevos métodos para alinear las
preferencias. Cabe destacar la Optimización de preferencias por razón de
probabilidades (ORPO), un proceso que combina SFT y DPO en un único proceso
de entrenamiento.23 Elimina la necesidad de realizar dos ciclos de
entrenamiento separados, lo que simplifica aún más el proceso de entrenamiento y permite el uso de QLoR
Resumen
En este capítulo, exploramos diferentes pasos para ajustar los LLM preentrenados.
Realizamos un ajuste fino mediante el uso de un ajuste fino eficiente en función de los parámetros
(PEFT) a través de la técnica de adaptación de bajo rango (LoRA). Explicamos cómo se puede
extender LoRA a través de la cuantificación, una técnica para reducir las restricciones de memoria al
representar los parámetros del modelo y los adaptadores.
El proceso de ajuste fino que exploramos consta de dos pasos. En el primer paso, realizamos un
ajuste fino supervisado utilizando datos de instrucciones en un LLM entrenado previamente, a
menudo denominado ajuste de instrucciones. Esto dio como resultado un modelo que tiene un
comportamiento similar al de un chat y que puede seguir las instrucciones de cerca.
En el segundo paso, mejoramos aún más el modelo ajustándolo con datos de alineación, datos
que representan qué tipo de respuestas se prefieren en comparación con otras. Este proceso, conocido
como ajuste de preferencias, destila la preferencia humana en el modelo ajustado previamente
con instrucciones.
En general, este capítulo ha mostrado los dos pasos principales para ajustar un LLM
previamente entrenado y cómo eso podría conducir a resultados más precisos e informativos.
1
Neil Houlsby et al. “Transferencia de aprendizaje eficiente en parámetros para NLP”. Conferencia internacional
sobre aprendizaje automático. PMLR, 2019.
2
Jonas Pfeiffer et al. “AdapterHub: un marco para adaptar transformadores”. Preimpresión de arXiv
arXiv:2007.07779 (2020).
3
Renrui Zhang et al. “Llamaadapter: ajuste fino eficiente de modelos de lenguaje con atención de inicio
cero”. Preimpresión de arXiv arXiv:2303.16199 (2023).
4
Edward J. Hu et al. “LoR: Adaptación de bajo rango de modelos de lenguaje grandes”. Preimpresión de
arXiv arXiv:2106.09685 (2021).
5
Armen Aghajanyan, Luke Zettlemoyer y Sonal Gupta. “La dimensionalidad intrínseca explica la eficacia
del ajuste fino del modelo lingüístico”. Preimpresión de arXiv arXiv:2012.13255 (2020).
6
Tim Dettmers et al. “QLoRA: ajuste fino eficiente de LLM cuantificados”. Preimpresión de arXiv
arXiv:2305.14314 (2023).
7
Ning Ding et al. “Mejorar los modelos de lenguaje de chat mediante la ampliación de la enseñanza de alta calidad”
conversaciones.” preimpresión arXiv arXiv:2305.14233 (2023).
8
Fred Jelinek et al. “Perplejidad: una medida de la dificultad de las tareas de reconocimiento de voz”.
Revista de la Sociedad Acústica de América 62.S1 (1977): S63.
9
ChinYew Lin. “ROUGE: Un paquete para la evaluación automática de resúmenes”. Texto
El resumen se ramifica, 74–81. 2004.
10
Kishore Papineni, et al. “Bleu: un método para la evaluación automática de la traducción automática”.
Actas de la 40ª Reunión Anual de la Asociación de Lingüística Computacional.
2002.
11
Tianyi Zhang et al. “BERTscore: evaluación de la generación de texto con BERT”. Preimpresión de arXiv
arXiv:1904.09675 (2019).
12
Dan Hendrycks et al. “Medición de la comprensión masiva del lenguaje en múltiples tareas”. Preimpresión de arXiv
arXiv:2009.03300 (2020).
13
Alex Wang et al. “GLUE: una plataforma de análisis y evaluación comparativa multitarea para lenguaje natural
comprensión.” preimpresión arXiv arXiv:1804.07461 (2018).
14
Stephanie Lin, Jacob Hilton y Owain Evans. “TruthfulQA: medición de cómo los modelos imitan
falsedades humanas”. preimpresión arXiv arXiv:2109.07958 (2021).
15
Karl Cobbe et al. “Entrenamiento de verificadores para resolver problemas matemáticos con palabras”. Preimpresión de arXiv
arXiv:2110.14168 (2021).
16
Roman Zellers et al. “HellaSwag: ¿Puede una máquina realmente terminar tu frase?”, preimpresión de arXiv
arXiv:1905.07830 (2019).
17
Mark Chen et al. “Evaluación de modelos de lenguaje de gran tamaño entrenados en código”. Preimpresión de arXiv
arXiv:2107.03374 (2021).
18
Lianmin Zheng et al. “Juzgar un LLM como juez con MTBench y Chatbot Arena”.
Avances en sistemas de procesamiento de información neuronal 36 (2024).
19
WeiLin Chiang et al. “Chatbot Arena: una plataforma abierta para evaluar LLM por parte de humanos”
preferencia.” preimpresión arXiv arXiv:2403.04132 (2024).
20
Mafilyn Strathern. “'Mejorando las calificaciones': auditoría en el sistema universitario británico” .
Revista 5.3 (1997): 305–321.
21
John Schulman et al. “Algoritmos de optimización de políticas proximales”. Preimpresión de arXiv
arXiv:1707.06347 (2017).
22
Rafael Rafailov, et al. “Optimización de preferencias directas: su modelo de lenguaje es secretamente un
modelo de recompensa”. preimpresión arXiv arXiv:2305.18290 (2023).
23
Jiwoo Hong, Noah Lee y James Thorne, “ORPO: optimización de preferencias monolíticas
sin modelo de referencia”. preimpresión arXiv arXiv:2403.07691 (2024).
OceanofPDF.com
Epílogo
Gracias a todos los que nos acompañaron en este fascinante viaje a través del
mundo de los grandes modelos lingüísticos. Agradecemos su dedicación para
aprender sobre estos poderosos modelos que han revolucionado el procesamiento
del lenguaje.
A lo largo de este libro, hemos visto cómo funcionan los LLM y cómo se pueden
utilizar para crear una amplia gama de aplicaciones, desde simples chatbots hasta
sistemas más complejos como los motores de búsqueda. También hemos
explorado varios métodos para ajustar los LLM previamente entrenados en
tareas específicas, incluidas la clasificación, la generación y la representación del
lenguaje. Al dominar estas técnicas, los lectores podrán descubrir el potencial de los
LLM y crear soluciones innovadoras que puedan beneficiarse de sus capacidades.
Este conocimiento les permitirá mantenerse a la vanguardia y adaptarse
a los nuevos avances en el campo.
A medida que nos acercamos al final de este libro, queremos enfatizar que
nuestra exploración de los LLM es solo el comienzo. Hay muchos más
desarrollos interesantes en el horizonte y lo alentamos a continuar siguiendo los
avances en el campo. Para ayudar con este proceso, esté atento al repositorio de
este libro a medida que continuamos agregando recursos.
Esperamos que al leer este libro usted obtenga una comprensión más profunda de
cómo se pueden utilizar los LLM en diversas aplicaciones y cómo tienen el
potencial de transformar industrias.
Con este libro como guía, creemos que usted estará bien equipado para navegar
por el apasionante panorama de los LLM y hacer contribuciones
significativas a este campo en rápido avance.
OceanofPDF.com
Índice
exactitud
Matrices de confusión, utilizando un modelo específico de tarea
verificación de salida, verificación de salida
Preentrenamiento adaptativo, uso de TSDAE para la adaptación del dominio
Agentes, Agentes: Creación de un sistema de LLMsReAct en LangChain
RAG agente, RAG agente
ReAct en LangChain, ReAct en LangChainReAct en LangChain
razonamiento paso a paso, El poder impulsor detrás de los agentes: razonamiento paso a
paso: El poder impulsor detrás de los agentes: razonamiento paso a paso
Razonamiento
IA (inteligencia artificial)
Desarrollo acelerado de, Introducción al lenguaje de gran formato

Modelos
definido, ¿Qué es la IA del lenguaje?
ALBERT, Selección de modelos
Función align_labels, Preparación de datos para el reconocimiento de entidades con nombre
Modelo allMiniLML6v2, Supervisado
Modelo allmpnetbasev2: ajuste fino para la clasificación de pocos disparos
Molestar, búsqueda del vecino más cercano versus bases de datos vectoriales
Claude Antrópico, Modelos Privados y Propietarios
API (interfaces de programación de aplicaciones), modelos propietarios y privados
Cohere, claves API, ejemplo de recuperación densa
externo, ChatGPT para clasificación
Generación de incrustaciones, Clasificación Supervisada
OpenAI, claves API, ChatGPT para clasificación
inteligencia artificial (ver IA)
ArXiv, artículos de ArXiv: computación y lenguaje
Atención, Codificación y Decodificación del Contexto con AtenciónLa Atención Lo Es Todo

Necesitas
Descripción general de, Codificación y decodificación del contexto con atención

Codificación y decodificación del contexto con atención
Arquitectura del transformador, la atención es todo lo que necesitasLa atención es todo

Necesitas
cálculo de la atención, Cómo se calcula la atenciónCómo se calcula la atención
capa de atención, Los componentes del pase hacia adelante, Dentro de la

Bloque Transformador, La capa de atención de un vistazo, Resumen
Atención relámpago, atención relámpago
Atención de consultas agrupadas, atención de consultas múltiples y consultas

agrupadas : optimización de la atención: de consultas múltiples a consultas múltiples y
consultas agrupadas
Atención local, Atención local/dispersa
Atención de consultas múltiples, Atención de consultas múltiples y consultas agrupadas

Optimización de la atención: de múltiples cabezales a múltiples consultas y consultas agrupadas
consulta
Optimizando la atención, Optimizando la atención: De multihead a multiquery a

consulta agrupada
Autoatención y puntuación de relevancia, Autoatención: Puntuación de relevancia

Autoatención: Combinación de información
Atención dispersa, Atención local/escasa
atención cabezas, Cómo se calcula la atenciónCómo se calcula la atención,
Resumen
audiencia, en indicaciones para la generación de texto, La complejidad potencial de una indicación
SBERT aumentada, SBERT aumentada SBERT aumentada
Arquitectura autorregresiva, contexto de codificación y decodificación con

Atención, atención es todo lo que necesitas, modelos generativos: solo decodificador
Modelos, entradas y salidas de un transformador entrenado LLM,
Atención local/dispersa
modelo de bolsa de palabras, Representar el lenguaje como una bolsa de palabras

Incrustaciones, tipos de incrustaciones
Modelado de temas, desde la agrupación de texto hasta el modelado de temas (BER) Tema: A
Marco de modelado de temas modulares: agregar un bloque Lego especial
puntos de referencia, en la evaluación de modelos generativos, puntos de referencia
BERT (Representaciones de codificadores bidireccionales a partir de transformadores),

Modelos de representación: Modelos de solo codificador Modelos generativos:
Modelos con decodificador únicamente
Adopción por los motores de búsqueda, Búsqueda y recuperación semántica

Generación aumentada
Modelos tipo BERT, Selección de modelos
En comparación con otros tokenizadores entrenados, modelo base BERT (sin carcasa)
(2018)
Ajuste fino de modelos BERT preentrenados, Ajuste fino de un BERT preentrenado

Modelado de lenguaje enmascarado, Supervisado
Bloques de transformadores versus atención local/dispersa
BERTopic, BERTopic: un marco de modelado de temas modularBERTopic:

Un marco de modelado de temas modular
Variantes algorítmicas, BERTopic: un modelado de temas modular

Estructura
Modularidad de BERTopic: un marco de modelado de temas modular
bloques de representación, Añadiendo un bloque Lego especial: el texto

Bloque Lego Generación
Inspirado en KeyBERTIn, inspirado en KeyBERTIn
máxima relevancia marginal, máxima relevancia marginal
Generación de texto, Bloque Lego de Generación de TextoEl Texto

BERTScore, métricas a nivel de palabra
Sesgo y equidad, desarrollo y uso responsable de LLM
Representaciones de codificadores bidireccionales a partir de transformadores (consulte BERT)
Paquete bitsandbytes, cuantificación de modelos

BLEU, Métricas a nivel de palabra
BLIP2 (Preentrenamiento de lenguajeimagen de arranque para visión unificada)
Comprensión y generación del lenguaje 2)
Solicitud basada en chat, caso de uso 2: Solicitud basada en chat multimodal
Caso de uso 2: Solicitud de sugerencias basada en chat multimodal
Subtítulos de imágenes, caso de uso 1: Subtítulos de imágenes
preprocesamiento de texto, preprocesamiento de texto
QFormer, BLIP2: Cerrando la brecha de modalidadBLIP2: Cerrando la brecha de modalidad
Brecha de modalidad
Algoritmo BM25, Buscar en el índice
BPE (codificación de pares de bytes), ¿Cómo descompone el texto el tokenizador?,

Métodos de tokenización
tokens de bytes, tokens de palabras, subpalabras, caracteres y bytes
do
cTFIDF, BERTopic: Un marco de modelado de temas modular,
KeyBERTInspired, el bloque Lego de la generación de texto
capitalización, parámetros del tokenizador
subtítulos, Caso de uso 1: subtítulos de imágenes Caso de uso 1: subtítulos de imágenes
Algoritmos basados en centroides, agrupamiento de incrustaciones reducidas
Cadenas, Incitación a la cadena: Romper el problema Incitación a la cadena:
Desmantelando el problema, las cadenas: ampliando las capacidades de los LLMA
Cadena con múltiples indicaciones
cadenadepensamiento, Cadenadepensamiento: PiensaantesderesponderCadena de
pensamiento: Piensaantesderesponder
encadenamiento de un único mensaje, Un único eslabón en la cadena: Plantilla de mensaje
Un solo eslabón en la cadena: plantilla de propuesta
encadenamiento secuencial de múltiples indicaciones, una cadena con múltiples indicaciones
Indicaciones: una cadena con múltiples indicaciones
Tokens de caracteres, palabra versus subpalabra versus carácter versus byte

Fichas
Fichas de chat, Phi3 (y Llama 2)
Solicitud basada en chat, caso de uso 2: Solicitud basada en chat multimodal: uso
Caso 2: Solicitud de ayuda multimodal basada en chat
Chatbot Arena, evaluación humana
ChatGPT, E/S de modelos: carga de modelos cuantificados con LangChain, creación de modelos
Modelos de generación de texto multimodal, paso de entrenamiento del modelo de recompensa,
Datos de alineación de plantillas
Lanzamiento de Introducción a los modelos de lenguaje de gran tamaño
Clasificación de texto, ChatGPT para ClasificaciónChatGPT para

Clasificación
Función chatgpt_generation, ChatGPT para clasificación
Variable de entrada chat_history, Buffer de conversación
informes de clasificación, Uso de un modelo específico de tarea Uso de un modelo específico de tarea
Modelo
Paso de clasificación, modelo de incrustación, clasificación supervisada
CLIP, CLIP: Conexión de texto e imágenes: ¿Cómo puede CLIP generar incrustaciones
multimodales?
Conexión de texto e imágenes, CLIP: Conexión de texto e imágenes

Generando incrustaciones multimodales, ¿Cómo puede CLIP generar incrustaciones
multimodales?¿Cómo puede CLIP generar incrustaciones multimodales?
OpenCLIP, OpenCLIPOpenCLIP
LLM de código cerrado, modelos propietarios y privados
[CLS] token, Modelos de representación: modelos solo de codificador, modelo base BERT (sin mayúsculas y
minúsculas) (2018), Creación de incrustaciones de palabras contextualizadas con
Modelos de lenguaje, OpenCLIP, SBERT, secuencial basado en transformadores
Codificador automático de eliminación de ruido: preparación de datos para el reconocimiento de entidades con nombre
modelo de clúster, Agrupar las incrustaciones reducidasAgrupar las incrustaciones reducidas
Incrustaciones
agrupamiento (ver texto agrupamiento)
CNN (redes neuronales convolucionales), transformadores para la visión
Cohere, ejemplo: generación fundamentada con una API LLM
Comando R+, modelos abiertos, Agentic RAG
Creación de cuentas, claves API, ejemplo de recuperación densa
reescritura de consultas, reescritura de consultas
Punto final de reclasificación, ejemplo de reclasificación
Modelos de finalización, modelos generativos: modelos solo decodificadores
Función calculate_metrics, Preparación de datos para el reconocimiento de entidades con nombre
Matrices de confusión, utilizando un modelo específico de tarea
Conjunto de datos CoNLL2003, Preparación de datos para el reconocimiento de entidades con nombre
Muestreo restringido, Gramática: Muestreo restringidoGramática:

Muestreo restringido
contexto
Atención y, La capa de atención de un vistazo
Ingeniería rápida, La complejidad potencial de una propuesta rápida
Conjuntos de datos de entrenamiento, el algoritmo Word2vec y el entrenamiento contrastivo
longitud del contexto
Modelos de finalización, modelos generativos: modelos solo decodificadores
Límites de procesamiento de tokens, procesamiento de tokens en paralelo y tamaño del contexto
ventana de contexto, en modelos de finalización, Modelos generativos: solo decodificador

Modelos
aprendizaje contrastivo
modelos de incrustación de texto, ¿Qué es el aprendizaje contrastivo? ¿Qué es el

aprendizaje contrastivo?, Generación de ejemplos contrastivos
Algoritmo Word2vec y, El algoritmo Word2vec y el algoritmo contrastivo

Entrenamiento: El algoritmo Word2vec y el entrenamiento contrastivo
Tensión contrastiva (CT), aprendizaje no supervisado
Memoria intermedia de conversación, Resumen de conversación
Descripción general de, Buffer de conversación Buffer de conversación
ventana, conversación en ventana BufferConversación en ventana

Buffer
Resumen de conversación de memoria, Resumen de conversación Conversación

Resumen
Función convert_ids_to_tokens, OpenCLIP

Redes neuronales convolucionales (CNN), transformadores para la visión
similitud de coseno, ¿Qué pasa si no tenemos datos etiquetados?, similitud de coseno similitud
de coseno
CountVectorizer, BERTopic: un marco de modelado de temas modular
Codificadores cruzados: cómo funcionan los modelos de reordenamiento
Pérdida de entropía cruzada, pérdida de clasificación de múltiples negativos
CT (Tensión contrastiva), aprendizaje no supervisado
Valores atípicos de datos, agrupación de incrustaciones reducidas
Clase DataCollator, Ajuste fino de un modelo BERT preentrenado (continuación)
Preentrenamiento con modelado de lenguaje enmascarado
Paquete datamapplot, el bloque Lego de generación de texto
DBSCAN (agrupamiento espacial basado en densidad), agrupamiento reducido
Incrustaciones
DeBERTa, creación de incrustaciones de palabras contextualizadas con lenguaje

Modelos, Selección de modelos
modelos de solo decodificador (ver modelos generativos)
Estrategia de decodificación, elección de un solo token de la probabilidad
Distribución (Muestreo/Decodificación): Elección de un solo token de la
Distribución de probabilidad (muestreo/decodificación), resumen
Recuperación densa, Descripción general de la búsqueda semántica y RAG, Recuperación densa
Ajuste fino de los modelos de incrustación para una recuperación densa
Ejemplo de recuperación densa : busque en el índice

Ajuste fino de modelos de incrustación para, Ajuste fino de modelos de incrustación para
recuperación densa
Búsqueda del vecino más cercano versus bases de datos vectoriales, Búsqueda del vecino
más cercano versus bases de datos vectoriales
Fragmentación de texto, Fragmentación de textos largos: múltiples vectores por documento
Algoritmos basados en densidad, agrupamiento de incrustaciones reducidas
Agrupamiento espacial basado en densidad (DBSCAN), agrupamiento reducido
Incrustaciones
modelo de reducción de dimensionalidad, Reducción de la dimensionalidad de
Incrustaciones: reducción de la dimensionalidad de las incrustaciones
DistilBERT, selección de modelos, uso de un modelo específico para cada tarea
Adaptación de dominios, uso de TSDAE para la adaptación de dominios
Parámetro do_sample, Generando su primer texto
DPO (Optimización de preferencia directa), modelo de entrenamiento sin recompensa
Capacitación
puesta a punto, Formación
cuantificación de modelos, cuantificación de modelos
datos de alineación de plantillas, datos de alineación de plantillas
configuración de entrenamiento, configuración de entrenamiento
DSPy, técnicas y herramientas avanzadas de generación de texto
mi
Negativos fáciles, Pérdida de clasificación por múltiples negativos
Sistema de calificación Elo, Evaluación Humana

incrustaciones, mejores representaciones con incrustaciones de vectores densos: tipos de incrustaciones,
tokens e incrustaciones, incrustaciones de tokens: entrenamiento
Modelo de incrustación de canciones
Recuperación: ajuste fino de modelos de incrustación para recuperación densa
Modelos de incrustación, definición, clasificación de texto con representación
Modelos, modelos de incrustación
multimodalidad, modelos de incrustación multimodal OpenCLIP
CLIP, CLIP: Conexión de texto e imágenes: ¿Cómo puede CLIP generar
incrustaciones multimodales?
Descripción general de Mejores representaciones con incrustaciones de vectores densos
Mejores representaciones con incrustaciones de vectores densos, incrustaciones
ModelosIncorporación de modelos
incrustaciones posicionales, incrustaciones posicionales (RoPE)posicionales
Incrustaciones (RoPE)
sistemas de recomendación, incrustaciones para sistemas de recomendación
Tareas de clasificación de texto que aprovechan las incrustaciones: ¿qué sucede si no
tenemos datos etiquetados?
clasificación supervisada, Clasificación SupervisadaSupervisada

Clasificación
Clasificación zeroshot, ¿Qué pasa si no tenemos datos etiquetados? ¿Qué

pasa si no tenemos datos etiquetados?
canalización de agrupamiento de texto, una canalización común para agrupamiento de texto

modelo de clúster, clúster de incrustaciones reducidas: clúster de

Incrustaciones reducidas

Modelo de incrustación, Incorporación de documentos
Inspección de clústeres, Inspección de los clústeresInspección de los clústeres

Clústeres
modelos de incrustación de texto, incrustaciones de texto (para oraciones y texto completo)

Documentos) Incrustaciones de texto (para oraciones y documentos completos),
Creación de modelos de incrustación de texto: resumen
aprendizaje contrastivo, ¿Qué es el aprendizaje contrastivo?¿Qué es el aprendizaje

contrastivo?
Creación, Creación de un modelo de incrustación: pérdida de clasificación de

múltiples negativos
Ajuste fino, Ajuste fino de un modelo de incrustación aumentado

SBERTO
SBERT, SBERTSBERT
aprendizaje no supervisado, aprendizaje no supervisado
Incrustaciones de tokens, Incrustaciones de tokens: creación de palabras contextualizadas

Incrustaciones con modelos de lenguaje
creando incrustaciones de palabras contextualizadas, creando

Incrustaciones de palabras contextualizadas con modelos de lenguaje
Creación de incrustaciones de palabras contextualizadas con lenguaje
Modelos
El vocabulario del tokenizador y un modelo de lenguaje

Incrustaciones para el vocabulario de su tokenizador
tipos de, Tipos de incrustaciones
Incrustaciones de palabras, incrustaciones de palabras más allá de los LLM: Word2vec

Algoritmo y entrenamiento contrastivo
preentrenado, Uso de incrustaciones de palabras preentrenadas
Algoritmo word2vec y entrenamiento contrastivo, El Word2vec

Algoritmo y entrenamiento contrastivo: Algoritmo Word2vec y entrenamiento contrastivo
Modelos de codificadordecodificador, Uso del transformador de transferencia de texto a texto
modelos de solo codificador (ver modelos de representación)
Ética, validación de resultados, verificación de resultados
retroceso exponencial, ChatGPT para clasificación
Puntuación F1, matrices de confusión, uso de un modelo específico de tarea
FAISS, búsqueda del vecino más próximo frente a bases de datos vectoriales
Falcon, Elección de un modelo de generación de texto
Paso de extracción de características, modelo de incrustación, clasificación supervisada
Capa de avance, dentro del bloque transformador
Redes neuronales de avance, La atención es todo lo que necesitas, La red neuronal de avance de un
vistazo, Resumen, Ajuste fino de un BERT preentrenado

Modelo
Clasificación de pocos disparos, Clasificación de pocos disparos: ajuste fino para la clasificación de pocos disparos
Clasificación
Ajuste fino para la clasificación, Ajuste fino para la clasificación de pocos disparos
Ajuste fino para la clasificación de pocos disparos
SetFit, SetFit: Ajuste fino eficiente con pocos ejemplos de entrenamiento

SetFit: Ajuste fino eficaz con pocos ejemplos de entrenamiento
Ejemplos de ejemplos en contexto: aprendizaje en contexto

Aprendizaje: Proporcionar ejemplos, proporcionar ejemplos, proporcionar ejemplos
Función find_topics(), BERTopic, BERTopic: un modelado modular de temas

Estructura
sintonia FINA
Modelos de incrustación para recuperación densa, Ajuste fino de modelos de incrustación

para recuperación densa
modelos generativos, verificación de salida, generación de ajuste fino

ModelosResumen
evaluación, Evaluación de modelos generativos Evaluación humana
Ajuste de preferencias, Los tres pasos de la formación LLM: preentrenamiento,

Ajuste fino supervisado y ajuste de preferencias, preferencias
Puesta a punto / Alineación / Entrenamiento RLHF
Ajuste fino supervisado, Los tres pasos de la formación LLM:

Preentrenamiento, ajuste fino supervisado y ajuste de preferencias
Fusionar pesos
Pasos de formación, Los tres pasos de formación LLM: Formación previa,

Ajuste fino supervisado y ajuste de preferencias: los tres LLM
Pasos de entrenamiento: preentrenamiento, ajuste fino supervisado y
Ajuste de preferencias
Descripción general del paradigma de entrenamiento de modelos de lenguaje grandes
modelos de representación, Ajuste fino de modelos de representación para

ClasificaciónResumen
Clasificación de pocos disparos, Clasificación de pocos disparos: ajuste fino para

Modelado de lenguaje enmascarado, preentrenamiento continuo con lenguaje enmascarado
Modelado del lenguaje : preentrenamiento continuo con enmascaramiento

reconocimiento de entidad nombrada, reconocimiento de entidad nombradafino

Ajuste para el reconocimiento de entidades nombradas
clasificación supervisada, congelación de clasificación supervisada

Capas
Modelo T5, uso del transformador de transferencia de texto a texto
Modelos de incrustación de texto, Ajuste fino de un modelo de incrustación

SBERT aumentada
supervisado, SupervisadoSupervisado
Modelo FlanT5, FlanT5 (2022), Uso de la transferencia de texto a texto

Transformador: Cómo utilizar el transformador de transferencia de texto a texto
Atención flash, Atención flash, Resumen
Pase hacia adelante, Resumen
componentes de, Los componentes del pase hacia adelanteEl

Componentes del pase hacia adelante
definido, Las entradas y salidas de un transformador entrenado LLM
Modelos de base, El año de la IA generativa
parámetro fp16, modelo de tren
Capas de congelación, Modelo de tren, Capas de congelación Capas de congelación
modelos congelados (no entrenables), clasificación de texto con representación

Modelos, Clasificación Supervisada, Clasificación Supervisada
GRAMO
Símbolo Ġ, preprocesamiento de texto
Galáctica, Galáctica
Punto de referencia de evaluación de la comprensión del lenguaje general (GLUE),

Generación de ejemplos contrastivos, evaluación en profundidad, adaptadores,
Variable generated_text, Caso de uso 1: Subtítulos de imágenes, Caso de uso 1: Imagen

Subtítulos
Variable generation_output, Descarga y ejecución de un LLM
modelos generativos, modelos generativos: modelos solo decodificadores modelos generativos

Modelos: Modelos con decodificador únicamente
evaluación automatizada, Evaluación Automatizada
puntos de referencia, puntos de referencia
evaluación humana, Evaluación Humana
tablas de clasificación, tablas de clasificación
Métricas a nivel de palabra, Métricas a nivel de palabra
Ajuste fino, Modelos de generación de ajuste fino Resumen


Fusionar pesos

razonamiento, Razonamiento con Modelos GenerativosÁrboldelPensamiento:

Explorando los pasos intermedios
autoconsistencia, autoconsistencia: resultados del muestreo
árbol del pensamiento, Árbol del pensamiento: Explorando los pasos intermedios
Modelos de representación versus modelos de representación: solo codificador

Modelos
Clasificación de textos, Clasificación de textos con modelos generativos

ChatGPT, ChatGPT para clasificaciónChatGPT para clasificación
T5, Uso del transformador de transferencia de texto a texto: Uso del transformador
de transferencia de texto a texto
Transformadores generativos preentrenados (ver GPT)
Pseudoetiquetado generativo (GPL), aprendizaje no supervisado
Biblioteca Gensim, uso de incrustaciones de palabras preentrenadas
Función get_topic, BERTopic: un marco de modelado de temas modular
Método get_topic_info(), BERTopic: un modelado de temas modular

Estructura
Modelo GGUF, Gramática: Muestreo restringido, Modelo E/S: Carga

Modelos cuantizados con LangChain
GitHub, uso de ejemplos de código

Guante, SBERT
Punto de referencia GLUE (Evaluación de la comprensión del lenguaje general),

Generación de ejemplos contrastivos, evaluación en profundidad, adaptadores,
Conjuntos de datos de oro, SBERT aumentado
Ley de Goodhart, Evaluación Humana
Google Colab, requisitos previos, requisitos de hardware y software,

Todo lo que necesitas son recursos limitados, genera tu primer texto, acelera
Generación ascendente mediante almacenamiento en caché de claves y valores, capacitación
Google Gemini, Generación Aumentada por Recuperación (RAG)
Búsqueda de Google, búsqueda semántica y recuperación: generación aumentada
GPL (pseudoetiquetado generativo), aprendizaje no supervisado
GPT2Tokenizer, preprocesamiento de texto
GPT (transformadores preentrenados generativos), modelos generativos: decodificador

Solo modelos, ingeniería inmediata
(ver también generación de texto)
GPT1, Modelos generativos: modelos solo decodificadores
GPT2, Introducción a los modelos de lenguaje generativo de gran tamaño

Modelos: Modelos de solo decodificador, modelos de palabras versus subpalabras versus modelos de palabras
Tokens de caracteres y de bytes, GPT2 (2019)
GPT3, Modelos generativos: modelos solo decodificadores, La red neuronal de propagación

hacia adelante de un vistazo, Atención local/dispersa, Bajo rango
Adaptación (LoRA)
GPT3.5, El año de la IA generativa, ChatGPT para clasificación, Un solo eslabón en la
cadena: plantilla de indicaciones, ReAct en LangChain

GPT4, El año de la IA generativa, Modelos privados y propietarios, Cómo

Los tokenizadores preparan las entradas al modelo de lenguaje, GPT4 (2023),
La red neuronal de propagación hacia adelante de un vistazo
GPU
Atención relámpago, atención relámpago
Requisitos, Requisitos de hardware y software, Limitado

Los recursos son todo lo que necesitas
SRAM y HBM, Atención Flash
Gramática, Verificación de salida, Gramática: Muestreo restringido Gramática:

decodificación codiciosa, elección de un solo token de la probabilidad

Distribución (Muestreo/Decodificación)
Generación fundamentada, de la búsqueda a RAG. Ejemplo: Generación fundamentada

con una API LLM
Atención de consultas agrupadas, Atención de consultas múltiples y agrupadas

Optimización de la atención: de múltiples cabezales a múltiples consultas y consultas agrupadas,
Resumen
GSM8k, puntos de referencia
Barandillas, gramática: muestreo restringido
Orientación, gramática: muestreo restringido
yo
alucinación
evitando en las indicaciones basadas en instrucciones, Instrucciones Basadas

Incitación
modelos de generación de texto, búsqueda semántica y recuperación aumentada

Generación
Negativos duros, Pérdida de clasificación por negativos múltiples
Contenido dañino, generación, Desarrollo y uso responsable de LLM
Haystack, técnicas y herramientas avanzadas de generación de texto
HBM (memoria de alto ancho de banda), Flash Atención
HDBSCAN (agrupamiento espacial basado en densidad jerárquica de aplicaciones con ruido),

agrupamiento de incrustaciones reducidas, BERTopic: un tema modular
Marco de modelado
HellaSwag, puntos de referencia
memoria de alto ancho de banda (HBM), Flash Atención
Abrazando la cara, generando tu primer texto, el sentimiento de la película

Reseñas
Creación de cuentas, claves API
evaluar paquete, preparación de datos para el reconocimiento de entidades nombradas
Tokenizadores, El dominio de los datos
Evaluación humana, Inspección de los clústeres, Evaluación humana
HumanEval, puntos de referencia
Búsqueda híbrida, advertencias sobre la recuperación densa, ejemplo de reclasificación
Idefics 2, BLIP2: Cerrando la brecha de modalidad
imágenes (ver multimodalidad)

aprendizaje en contexto, aprendizaje en contexto: proporcionar ejemplos en contexto
Aprendizaje: Dar ejemplos
índices, Construyendo el índice de búsqueda
InfoNCE, pérdida de posiciones en múltiples posiciones negativas
Variable input_ids, Descarga y ejecución de un LLM
indicaciones basadas en instrucciones, indicaciones basadas en instrucciones instrucción
Incitación basada en
Propiedad intelectual, Desarrollo y uso responsable de LLM
Filosofía de la intuición como primera opción, Una filosofía de la intuición como primera opción
Función de invocación, Un solo eslabón en la cadena: Plantilla de mensaje
Yo
Jupyter: acelera la generación mediante el almacenamiento en caché de claves y valores
Algoritmo kmeans, Agrupamiento de incrustaciones reducidas, BER Tema: A
Marco de modelado de temas modulares, BERTopic: un tema modular
Marco de modelado
KeyBERTInspired, KeyBERTInspired, Máxima relevancia marginal
Búsqueda por palabras clave
reranking, Ejemplo de reranking Ejemplo de reranking
verificar la búsqueda semántica con, Buscar en el índice
caché kv (claves y valores), aceleración de la generación mediante el almacenamiento en caché de claves y valores
Valores: cómo acelerar la generación mediante el almacenamiento en caché de claves y valores

yo
LangChain, técnicas y herramientas avanzadas de generación de texto
(ver también cadenas)
Carga de modelos cuantificados con, E/S de modelo: Carga de modelos cuantificados con
LangChain E/S de modelo: Carga de modelos cuantificados con
Cadena Lang
ReAct en, ReAct en LangChainReAct en LangChain
Inteligencia artificial del lenguaje (IA del lenguaje), una introducción a las grandes
Modelos de lenguaje: el año de la IA generativa
Definición: ¿Qué es la IA del lenguaje?
Historia reciente de, Una historia reciente de la IA del lenguaje: el año de

IA generativa
Atención, Codificación y Decodificación del Contexto con Atención

La atención es todo lo que necesitas
modelo de bolsa de palabras, Representar el lenguaje como una bolsa de palabras
Incrustaciones, mejores representaciones con vectores densos
Incrustaciones: tipos de incrustaciones
modelos generativos, Modelos generativos: modelos solo decodificadores
modelos de representación, Modelos de representación: solo codificador
ModelosModelos de representación: Modelos de solo codificador
Año de la IA generativa, El año de la IA generativaEl año de

IA generativa
modelado del lenguaje, Los tres pasos de la formación LLM: preentrenamiento,
Ajuste fino supervisado y ajuste de preferencias

Cabeza de modelado del lenguaje (cabeza LM), Los componentes del paso hacia adelante
grandes modelos lingüísticos (ver LLM)
Asignación latente de Dirichlet: de la agrupación de textos al modelado de temas
LayerNorm, el bloque transformador
Tablas de clasificación, en la evaluación de modelos generativos, Tablas de clasificación
parámetro learning_rate, configuración de entrenamiento
Llama, Elección de un modelo de generación de texto
Llama 2, claves API, recursos limitados son todo lo que necesitas, Phi3 (y
Llama 2), Atención de consultas múltiples y consultas agrupadas, Elección de un texto
Modelo de generación, haciendo que los modelos de generación de texto sean multimodales
Biblioteca llamacpppython, Gramática: Muestreo restringido
LLaVA, BLIP2: cerrando la brecha de modalidad
LLM como juez, evaluación RAG
LLM (modelos de lenguaje grande), una introducción a los modelos de lenguaje grande
ModelosResumen
Ejemplos de código y ejercicios, Uso de ejemplos de código
incrustaciones, tokens e incrustaciones, incrustaciones de tokens: entrenamiento
Modelo de incrustación de canciones
Sistemas de recomendación, incrustaciones para recomendaciones
Sistemas: Entrenamiento de un modelo de incrustación de canciones
incrustaciones de texto, incrustaciones de texto (para oraciones y texto completo)
Documentos) Incrustaciones de texto (para oraciones y textos completos)
Documentos)
incrustaciones de tokens, incrustaciones de tokens: creación contextualizada
Incrustaciones de palabras con modelos de lenguaje
incrustaciones de palabras, incrustaciones de palabras más allá de los LLM: el
Algoritmo Word2vec y entrenamiento contrastivo
Ajuste fino de modelos generativos, Modelos generativos de ajuste fino
Resumen
Fusionar pesos
Modelos de representación de ajuste fino, Modelos de representación de ajuste fino para clasificación
Resumen



Capas
Generar texto, Generar tu primer textoGenerar tu primer texto
modelos generativos, Modelos generativos: modelos solo decodificadores

Requisitos de hardware y software, Hardware y software

Requisitos, recursos limitados son todo lo que necesitas
Vista de alto nivel, Cómo los tokenizadores preparan las entradas al lenguaje
Modelo
Historia de la IA del lenguaje, una historia reciente de la IA del lenguaje: el año de

IA generativa
Interfaz con, Interfaz con modelos de lenguaje grandesabierto

Marcos de origen
modelos de código cerrado, modelos propietarios, modelos privados
modelos abiertos, modelos abiertos marcos de código abierto
Filosofía de la intuición como primera opción, Una filosofía de la intuición como primera opción
Definición conmovedora de, La definición conmovedora de un “gran lenguaje”

Modelo"
multimodalidad, Modelos de lenguaje multimodales de gran tamaño : resumen
modelos de incrustación, modelos de incrustación multimodal OpenCLIP
modelos de generación de texto, creación de modelos de generación de texto

Caso de uso multimodal 2: indicaciones basadas en chat multimodal
Transformador de visión, Transformadores para visiónTransformadores para

Visión
Ingeniería rápida, Ingeniería rápidaResumen

Impulso en cadena, Impulso en cadena: descomponiendo el problema

Impulso en cadena: desmembrando el problema

Aprendizaje contextual: proporcionar ejemplos
indicaciones basadas en instrucciones, indicaciones basadas en instrucciones

Instrucciones basadas en indicaciones
Verificación de salida, Verificación de salidaGramática: Restringida

Muestreo
complejidad potencial de las indicaciones, La complejidad potencial de una

Indicación: La complejidad potencial de una indicación
Componentes del mensaje, Los ingredientes básicos de un mensaje

Ingredientes básicos de un mensaje
razonamiento con modelos generativos, razonamiento con modelos generativos

Modelosárboldelpensamiento: Explorando los pasos intermedios
Modelos de generación de texto, Uso de modelos de generación de texto top_p
modelos de representación, Modelos de representación: Modelos de solo codificador

Desarrollo y uso responsable de, LLM Responsable

Desarrollo y uso
Generación aumentada de recuperación, Descripción general de la búsqueda semántica y

RAG, Generación Aumentada por Recuperación (RAG) Evaluación RAG
Conversión del sistema de búsqueda a, De Search a RAG
evaluación de resultados, Evaluación RAG
Generación enraizada, Ejemplo: Generación enraizada con una

API de LLM
RAG multisalto, RAG multisalto
RAG de múltiples consultas, RAG de múltiples consultas
enrutamiento de consultas, enrutamiento de consultas
con modelos locales, Ejemplo: RAG con modelos locales, El mensaje RAG
Búsqueda semántica, Búsqueda y recuperación semántica aumentada
Puntuación de generación en múltiples consultas con precisión promedio
reranking, Descripción general de la búsqueda semántica y RAG, Reranking
Cómo funcionan los modelos de reclasificación
Métricas de evaluación de recuperación, Métricas de evaluación de recuperación : puntuación en
múltiples consultas con precisión promedio media
Clasificación de textos, Resumen de la clasificación de textos
con modelos generativos, Clasificación de texto con modelos generativos

ModelosChatGPT para Clasificación
Reseñas de películas, El sentimiento de las reseñas de películas, El sentimiento de las reseñas de

películas
con modelos de representación, Clasificación de texto con modelos de
representación: ¿Qué pasa si no tenemos datos etiquetados?
Agrupamiento de texto, Agrupamiento de texto y modelado de temas: inspección de la

Clústeres
Modelos de incrustación de texto, Creación de modelos de incrustación de texto Resumen

aprendizaje contrastivo, ¿Qué es el aprendizaje contrastivo?¿Qué es el aprendizaje
contrastivo?
Creación, Creación de un modelo de incrustación: pérdida de clasificación de
múltiples negativos
Ajuste fino, Ajuste fino de un modelo de incrustación aumentado

SBERTO
SBERT, SBERTSBERT
Generación de texto, técnicas y herramientas avanzadas de generación de texto.
Resumen
Cadenas, Cadenas: Ampliación de las capacidades de los LLM: una cadena con
Múltiples indicaciones
Memoria de conversaciones, Memoria: ayudar a los estudiantes de maestría en derecho a recordar
Conversaciones Resumen de la conversación
Modelo de E/S, Modelo de E/S: Carga de modelos cuantificados con
LangChainModel I/O: Carga de modelos cuantificados con
Cadena Lang
Tokens y tokenizadores, Tokens e incrustaciones: creación
Comparación de tokenizadores entrenados, Comparación de LLM entrenados
TokenizadoresPhi3 (y Llama 2)
Descargar y ejecutar LLM, Descargar y ejecutar un LLM
LLM Descarga y ejecución de un LLM
Preparación de entrada, Cómo los tokenizadores preparan las entradas para la
Modelo de lenguaje
Desglose de texto, ¿Cómo desglosa el texto el tokenizador?
incrustaciones de tokens, incrustaciones de tokens: creación contextualizada
Incrustaciones de palabras con modelos de lenguaje
Esquemas de tokenización, palabra versus subpalabra versus carácter
Tokens de bytes versus palabras versus subpalabras versus caracteres
Tokens versus bytes
Propiedades del tokenizador, Propiedades del tokenizador: el dominio de los datos
Modelado de temas, Agrupamiento de texto y modelado de temas, Desde texto
Agrupamiento para modelado de temas: el bloque Lego de generación de texto
Paradigma de entrenamiento de, El Paradigma de Entrenamiento de Lenguas Grandes
Modelos: El paradigma de entrenamiento de los modelos de lenguaje de gran tamaño
Arquitectura de transformadores: una mirada al interior de grandes modelos de lenguaje
Resumen
Distribución (Muestreo/Decodificación): Elección de un solo token de la distribución de
probabilidad (Muestreo/Decodificación)
Componentes del pase hacia adelante, Los componentes del pase hacia adelante
Entradas y salidas de, Las entradas y salidas de un entrenador
Transformador LLMLas entradas y salidas de un transformador capacitado

LLM en Transformadores
caché de claves y valores, acelerar la generación mediante el almacenamiento en caché de
claves y valores: acelerar la generación mediante el almacenamiento en caché de claves y valores
Procesamiento de tokens paralelos y tamaño de contexto, token paralelo
Procesamiento y tamaño de contexto: procesamiento de tokens paralelos y

Tamaño del contexto
mejoras recientes a, Mejoras recientes al Transformador

ArquitecturaOtros experimentos y mejoras arquitectónicas
Bloques transformadores, Dentro del bloque transformadorAutoatención:
Combinando información
Utilidad de las aplicaciones de modelos de lenguaje de gran tamaño: ¿qué las hace
tan útiles?
Cabeza LM (cabeza de modelado del lenguaje), Los componentes del paso hacia adelante
LMQL, Gramática: Muestreo restringido
Atención local, Atención local/dispersa
LoRA (adaptación de bajo rango), Adaptación de bajo rango (LoRA)Bajo rango

Adaptación (LoRA), cuantificación de modelos
(ver también QLoRA)
Parámetro lora_alpha, configuración de LoRA
Funciones de pérdida, Funciones de pérdida : Clasificación de pérdidas por múltiples negativos
pérdida de similitud de coseno, similitud de coseno similitud de coseno
pérdida de clasificación por múltiples negativos, pérdida de clasificación por múltiples negativos
Pérdida de ranking por múltiples motivos negativos
Parámetro lr_scheduler_type, configuración de entrenamiento
METRO
Mamba, el año de la IA generativa
MAP (precisión media promedio), Métricas de evaluación de recuperación : Puntuación en

múltiples consultas con precisión media promedio
Pérdida de MarginMSE, Funciones de pérdida

Modelado de lenguaje enmascarado (MLM), preentrenamiento continuo con lenguaje enmascarado
Modelado del lenguaje : preentrenamiento continuo con lenguaje enmascarado
Modelado
mask_token [MASK], modelo base BERT (sin mayúsculas ni minúsculas) (2018)
Punto de referencia de incrustación de texto masivo (MTEB), selección de modelos,
Incorporación de documentos, carga del modelo de incorporación, en profundidad

Evaluación
Biblioteca matplotlib, Inspección de los clústeres
relevancia marginal máxima (MMR), relevancia marginal máxima
Parámetro max_new_tokens, Generando su primer texto
McCarthy, John, ¿Qué es la IA del lenguaje?
precisión media promedio (MAP)
Buffer de conversación, Buffer de conversación Buffer de conversación
Resumen de conversación, Resumen de conversación Conversación
Resumen
Buffer de conversación en ventana, Buffer de conversación en ventana

Modelo Meta Llama, Modelos Abiertos
Microsoft Bing, búsqueda semántica y recuperación: generación aumentada,
Reclasificación
Microsoft Bing AI, Generación aumentada de recuperación (RAG)
Modelo Phi de Microsoft, modelos abiertos
modelo microsoft/mpnetbase, modelo de entrenamiento

Parámetro min_cluster_size: agrupa las incrustaciones reducidas
Parámetro min_dist, Reducción de la dimensionalidad de las incrustaciones
MIRACL, Ejemplo de reranking
Mistral, Modelos abiertos, Elección de un modelo de generación de texto, BLIP2:
Reducir la brecha modal
MLM (modelado de lenguaje enmascarado), preentrenamiento continuo con lenguaje enmascarado
Modelado del lenguaje : preentrenamiento continuo con lenguaje enmascarado
Modelado
MMLU, puntos de referencia, tablas de clasificación
MMR (relevancia marginal máxima), relevancia marginal máxima
Corpus MNLI (Inferencia de lenguaje natural multigénero), Generando
Ejemplos contrastantes, pérdida de clasificación por múltiples negativos
Pérdida de MNR (clasificación de múltiples negativos), pérdida de clasificación de múltiples negativos
Modelo de E/S, Modelo de E/S: Carga de modelos cuantificados con LangChainModel
E/S: Carga de modelos cuantificados con LangChain
monoBERT, Cómo funcionan los modelos de reclasificación
MTEB (referencia de incrustación de texto masivo), selección de modelos,
Incorporación de documentos, carga del modelo de incorporación, en profundidad

Evaluación
Corpus de inferencia de lenguaje natural multigénero (MNLI), generación
Ejemplos contrastantes, pérdida de clasificación por múltiples negativos
Atención de consultas múltiples, Atención de consultas múltiples y consultas agrupadas : Optimización de la
atención: de consultas múltiples a consultas múltiples y consultas agrupadas

Perceptrones multinivel, Los componentes del pase hacia adelante
(ver también redes neuronales de propagación hacia adelante)
multimodalidad, Modelos de lenguaje multimodales de gran tamaño : resumen
definidos, modelos lingüísticos multimodales de gran tamaño
modelos de incrustación, modelos de incrustación multimodal OpenCLIP
CLIP, CLIP: Conexión de texto e imágenes: ¿Cómo puede CLIP generar incrustaciones
multimodales?
modelos de generación de texto, Hacer que los modelos de generación de texto sean multimodales
Caso de uso 2: indicaciones basadas en chat multimodal
BLIP2, BLIP2: Cerrando la brecha de modalidadBLIP2: Cerrando la brecha de modalidad
subtítulos de imágenes, caso de uso 1: subtítulos de imágenes, caso de uso 1:
Subtítulos de imágenes
preprocesamiento de imágenes, preprocesamiento de imágenes
Transformador de visión, Transformadores para visiónTransformadores para visión
pérdida de clasificación de múltiples negativos (MNR), pérdida de clasificación de múltiples negativos
norte
Reconocimiento de entidades nombradas (ver NER)

Inferencia del lenguaje natural (NLI), Generación de ejemplos contrastivos
procesamiento del lenguaje natural (PLN), ¿Qué es la IA del lenguaje?, ¿Qué es el aprendizaje
contrastivo?
nDCG (ganancia acumulada descontada normalizada), ejemplo de reordenamiento
búsqueda del vecino más cercano
Incrustaciones de palabras preentrenadas, Uso de incrustaciones de palabras preentrenadas
Incorporaciones de sistemas de recomendación, Recomendar canciones por
Incrustaciones
Bases de datos vectoriales versus, Búsqueda del vecino más cercano versus bases de
datos vectoriales
Muestreo negativo, el algoritmo Word2vec y el entrenamiento contrastivo
NER (reconocimiento de entidades con nombre), Reconocimiento de entidades con nombre : ajuste fino para el
reconocimiento de entidades con nombre, adaptadores
Ajuste fino para el reconocimiento de entidades nombradas
preparación de datos para, Preparación de datos para el reconocimiento de entidades nombradas
Preparación de datos para el reconocimiento de entidades nombradas
Redes neuronales, mejores representaciones con incrustaciones de vectores densos
NLI (inferencia de lenguaje natural), generación de ejemplos contrastivos
PNL (procesamiento del lenguaje natural), ¿Qué es la IA del lenguaje?, ¿Qué es el aprendizaje
contrastivo?
Estimación contrastiva de ruido, el algoritmo Word2vec y la estimación contrastiva
Capacitación
Personajes no jugables (NPC), ¿Qué es la IA del lenguaje?

Modelos no entrenables (congelados), clasificación de texto con representación

Modelos, Clasificación Supervisada, Clasificación Supervisada
Normalización, Bloque Transformador, El Bloque Transformador
Ganancia acumulada descontada normalizada (nDCG), ejemplo de reordenamiento

PNJ (personajes no jugables), ¿Qué es la IA del lenguaje?
NTXentLoss, pérdida de posiciones por múltiples motivos negativos
muestreo de núcleo, top_p
NumPy, búsqueda del vecino más cercano versus bases de datos vectoriales
Parámetro num_train_epochs, Modelo de entrenamiento, Configuración de entrenamiento
GPU NVIDIA, requisitos de hardware y software, generación de su

Primer texto
Parámetro n_components, Reducción de la dimensionalidad de las incrustaciones
Oh
Optimización de preferencias de razones de probabilidades (ORPO), capacitación
Instrucción en un solo paso, aprendizaje en contexto: proporcionar ejemplos
Cadena de pensamiento versus Cadena de pensamiento: piensa antes de responder
aprendizaje en contexto, aprendizaje en contexto: proporcionar ejemplos
Tabla de clasificación de Open LLM, E/S de modelos: carga de modelos cuantificados con
LangChain, Tablas de clasificación
LLM de código abierto, modelos abiertos, marcos de código abierto
OpenAI, ChatGPT para clasificación
(ver también ChatGPT; GPTs)

Creación de cuentas, claves API, ChatGPT para clasificación
Parámetros optimos, configuración de entrenamiento
ORPO (Optimización de preferencias de razón de probabilidades), capacitación
Verificación de salida, Verificación de salidaGramática: Muestreo restringido
Muestreo restringido, Gramática: Muestreo restringidoGramática:
Proporcionar ejemplos, Proporcionar ejemplos
PAG
pad_token [PAD], modelo base BERT (sin mayúsculas ni minúsculas) (2018)
Procesamiento paralelo, La atención es todo lo que necesitas, Resumen
Indicaciones paralelas, Indicaciones en cadena: descomponer el problema
PCA (Análisis de componentes principales), reducción de la dimensionalidad de
Incrustaciones
PEFT (ajuste fino de parámetros eficiente), ajuste fino de parámetros eficiente
(PEFT) Comprimiendo el modelo para un entrenamiento (más) eficiente
adaptadores, AdaptadoresAdaptadores
Compresión, Comprimiendo el modelo para un entrenamiento (más) eficiente
Comprimir el modelo para un entrenamiento (más) eficiente
LoRA, Adaptación de bajo rango (LoRA)Adaptación de bajo rango (LoRA)
Biblioteca Peft, configuración de LoRA
Parámetro peft_config, configuración de LoRA

Perplejidad, recuperación y generación aumentada (RAG)
Persona, en indicaciones para la generación de texto, La complejidad potencial de una indicación
argumento per_device_eval_batch_size, Entrenar modelo
argumento per_device_train_batch_size, modelo de entrenamiento
Fi3
en comparación con otros tokenizadores entrenados, Phi3 (y Llama 2)
Pase hacia adelante, Los componentes del pase hacia adelante
Carga de modelos cuantificados, E/S de modelos: Carga de modelos cuantificados con
Cadena Lang
Plantilla de mensaje, Un solo eslabón en la cadena: Plantilla de mensaje
cuantificación, E/S de modelos: carga de modelos cuantificados con LangChain
Phi3mini, Generación de su primer texto, Elección de un modelo de generación de texto
Pinecone, búsqueda del vecino más cercano versus bases de datos vectoriales
PPO (optimización de políticas proximales), paso de entrenamiento del modelo de recompensa
Predicciones de precisión, matrices de confusión, uso de un modelo específico de tarea
Predicciones, modelo específico de la tarea, uso de un modelo específico de la tarea
Ajuste de preferencias, ChatGPT para clasificación, Los tres cursos de formación LLM
Pasos: preentrenamiento, ajuste fino supervisado y ajuste de preferencias.
Ajuste de preferencias / Alineación / Entrenamiento RLHF
Optimización de preferencias directas, entrenamiento sin modelo de recompensa

datos de alineación de plantillas, datos de alineación de plantillas
Modelos de recompensa, automatización de la evaluación de preferencias mediante recompensas
Modelos Paso de entrenamiento del modelo de recompensa
Entradas y salidas de, Las entradas y salidas de un modelo de recompensa
Entrenamiento, Entrenamiento de un modelo de recompensaPaso de entrenamiento del modelo de recompensa
preentrenamiento, definido, El paradigma de entrenamiento de los modelos de lenguaje grandes
efecto de primacía, estímulo basado en instrucciones
Análisis de componentes principales (PCA), reducción de la dimensionalidad de
Incrustaciones
Matrices de proyección, Cómo se calcula la atención
Ingeniería rápida, Clasificación de textos con modelos generativos, Prompt
IngenieríaResumen
Impulso en cadena, Impulso en cadena: romper la cadena de problemas
Sugerencia: Descomponer el problema
Aprendizaje contextual: proporcionar ejemplos
indicaciones basadas en instrucciones, indicaciones basadas en instrucciones instrucción
Incitación basada en
Verificación de salida, Verificación de salidaGramática: Restringida
Muestreo
Muestreo restringido, Gramática: Muestreo restringido
Gramática: Muestreo restringido
Proporcionar ejemplos, Proporcionar ejemplos

complejidad potencial de las indicaciones, La complejidad potencial de una
Indicación: La complejidad potencial de una indicación
componentes del mensaje, Los ingredientes básicos de un mensaje: los componentes básicos
Ingredientes de un Prompt
razonamiento con modelos generativos, razonamiento con modelos generativos
Modelos de generación de texto, Uso de modelos de generación de texto top_p
Elección, Elección de un modelo de generación de texto
Control de salida, Control de salida del modelotop_p
Cargando, Cargando un modelo de generación de textoCargando un texto

Modelo de Generación
Optimización de política proximal (PPO), paso de entrenamiento del modelo de recompensa
Python, aprendizaje, requisitos previos
QFormer (Transformador de consultas), BLIP2: cerrando la brecha de modalidad
Modelo Q8, E/S de modelo: carga de modelos cuantificados con LangChain
QLoRA (adaptación cuantificada de bajo rango), ajuste de instrucciones con QLoRA
Fusionar pesos
Configuración de LoRA, Configuración de LoRA
fusionar pesos, Fusionar pesos
datos de instrucciones de creación de plantillas, datos de instrucciones de creación de plantillas

cuantificación, E/S de modelos: carga de modelos cuantificados con LangChain,

Cómo comprimir el modelo para un entrenamiento (más) eficiente Cómo comprimir el
modelo para un entrenamiento (más) eficiente
parámetro quantization_config, configuración de LoRA
Adaptación cuantificada de bajo rango (ver QLoRA)
Transformador de consultas (QFormer), BLIP2: Cómo cerrar la brecha de modalidad

parámetro r, configuración de LoRA
RAG (generación aumentada por recuperación), incrustaciones de tokens, texto

Incrustaciones (para oraciones y documentos completos), descripción general de la semántica
Búsqueda y RAG, RecuperaciónGeneración Aumentada (RAG)RAG
Evaluación
canalización básica, recuperacióngeneración aumentada (RAG)
Conversión del sistema de búsqueda a, De Search a RAG
evaluación de resultados, Evaluación RAG
Generación fundamentada, Ejemplo: Generación fundamentada con un LLM

API
con modelos locales, Ejemplo: RAG con modelos locales: el mensaje RAG

enrutamiento de consultas, enrutamiento de consultas
Ragas, Evaluación RAG
parámetro random_state, Reducción de la dimensionalidad de las incrustaciones
errores de límite de velocidad, ChatGPT para clasificación
Reaccionar
en LangChain, ReAct en LangChainReAct en LangChain
razonamiento paso a paso, El poder impulsor detrás de los agentes: razonamiento paso a paso
razonamiento
con modelos generativos, Razonamiento con modelos generativosÁrbol de
Pensamiento: Explorando pasos intermedios
cadena de pensamiento, Cadena de pensamiento: Piensa antes de responder
Cadena de pensamiento: piensa antes de responder
árbol del pensamiento, Árbol del pensamiento: Explorando los pasos intermedios
Paso a paso, El poder impulsor detrás de los agentes: paso a paso
El razonamiento, motor de los agentes: paso a paso
Razonamiento
predicciones de recuperación, matrices de confusión, uso de un modelo específico de tarea
efecto de actualidad, indicaciones basadas en instrucciones
sistemas de recomendación, incrustaciones para sistemas de recomendación

Redes neuronales recurrentes (RNN), contexto de codificación y decodificación con

Atención
Función reduce_outliers(), BERTopic: Un modelado de temas modular

Estructura
Regulación, desarrollo y uso responsable de LLM
Puntuación de relevancia, La atención es todo lo que necesitas, Cómo se calcula la atención

Autoatención: Puntuación de relevancia, incrustaciones posicionales (RoPE)
Repositorio, Requisitos de hardware y software
modelos de representación, Modelos de representación: Modelos de solo codificador

definido, Representando el lenguaje como una bolsa de palabras
Ajuste fino para la clasificación, modelos de representación de ajuste fino para

ClasificaciónResumen




Capas
Modelos generativos versus modelos de representación: solo codificadores

Modelos
Clasificación de textos, Clasificación de textos con modelos de representación:

¿Qué pasa si no tenemos datos etiquetados?
Tareas de clasificación que aprovechan las incrustaciones, Tareas de clasificación

que aprovechan las incrustaciones: ¿qué pasa si no tenemos datos
etiquetados?
Selección de modelo, Selección de modelo Selección de modelo
Modelos específicos de tareas, Uso de un modelo específico de tareas
parámetro representation_model, El bloque Lego de generación de texto
reranking, descripción general de la búsqueda semántica y RAG, reranking: cómo funcionan los
modelos de reranking
BERTopic: Cómo añadir un bloque Lego especial
ejemplo de, ejemplo de reranking ejemplo de reranking
Función de los modelos de reordenamiento, Cómo funcionan los modelos de reordenamiento
Transformadores de oraciones, recuperación y reclasificación de código abierto con

transformadores de oraciones
validación de respuesta, incitación en cadena, incitación en cadena: rompiendo la

Problema
Métricas de evaluación de recuperación, Métricas de evaluación de recuperación : puntuación en múltiples
consultas con precisión promedio media
Puntuación de múltiples consultas con precisión media promedio, Puntuación en múltiples consultas
con precisión media promedio
Puntuación de consultas individuales con precisión media, Puntuación de una consulta individual con
precisión media
Generación aumentada por recuperación (ver RAG)
parámetro return_full_text, Generando su primer texto
modelos de recompensa, automatización de la evaluación de preferencias mediante modelos de recompensa
Paso de entrenamiento del modelo de recompensa

Entradas y salidas de, Las entradas y salidas de un modelo de recompensa
Entrenamiento, Entrenamiento de un modelo de recompensaPaso de entrenamiento del modelo de recompensa
RMSNorm, el bloque transformador
RNN (redes neuronales recurrentes), contexto de codificación y decodificación con

Atención
RoBERTa, tokens de palabra versus subpalabra versus carácter versus tokens de bytes,
Selección de modelo
RoPE (incrustaciones posicionales rotatorias), incrustaciones posicionales (RoPE)
Incrustaciones posicionales (RoPE)
Prueba de Rorschach, caso de uso 1: subtítulos de imágenes
Conjunto de datos de Rotten Tomatoes, el sentimiento de las críticas cinematográficas, cómo ajustar una
Modelo BERT preentrenado
ROUGE, Métricas a nivel de palabra
RWKV, el año de la IA generativa
SBERT, SBERTSBERT, SBERT aumentado SBERT aumentado
autoatención, La atención es todo lo que necesitas, Autoatención: Puntuación de relevancia
Autoatención: Combinando información
Búsqueda semántica, Búsqueda y recuperación semánticaGeneración aumentada
definido, Búsqueda y recuperación semánticaGeneración aumentada

Ejemplo de recuperación densa : busque en el índice
Ajuste fino de modelos de incrustación para, Ajuste fino de modelos de incrustación

para recuperación densa
Búsqueda del vecino más cercano versus bases de datos vectoriales, Búsqueda del vecino
más cercano versus bases de datos vectoriales
Fragmentación de texto, Fragmentación de textos largos: múltiples vectores por

documento
reranking, descripción general de la búsqueda semántica y RAG, reranking: cómo funcionan los
modelos de reranking
ejemplo de, ejemplo de reranking ejemplo de reranking
Función de los modelos de reordenamiento, Cómo funcionan los modelos de reordenamiento
Transformadores de oraciones, recuperación y reclasificación de código abierto con

transformadores de oraciones
Métricas de evaluación de recuperación, Métricas de evaluación de recuperación : puntuación
en múltiples consultas con precisión promedio media
Puntuación de múltiples consultas con precisión media promedio, Puntuación en múltiples
consultas con precisión media promedio
Puntuación de consultas individuales con precisión media, Puntuación de una consulta
individual con precisión media
Punto de referencia de similitud textual semántica (STSB), modelo de tren
Negativos semiduros, Pérdida de clasificación por negativos múltiples
Transformadores de oraciones, incrustaciones de texto (para oraciones y textos completos)
Documentos), Clasificación Supervisada, BERTopic: Un Tema Modular
Marco de modelado, recuperación y reclasificación de código abierto con oraciones

transformadores, OpenCLIP, SBERTSBERT, Supervisado, SetFit: Eficiente
Ajuste fino con algunos ejemplos de entrenamiento
Frase corta, FlanT5 (2022)
[SEP] token, modelo base BERT (sin carcasa) (2018), Creación de contexto
Incrustaciones de palabras con modelos de lenguaje, preparación de datos para nombres
Reconocimiento de entidades
modelos secuencia a secuencia, Clasificación de texto con modelos generativos,
Uso del transformador de transferencia de texto a texto
SetFit, Ajuste fino de modelos de representación para clasificación, SetFit:
Ajuste fino eficiente con pocos ejemplos de entrenamiento: SetFit: ajuste fino eficiente
Puesta a punto con algunos ejemplos de entrenamiento
SFT (ajuste fino supervisado), Los tres pasos de la formación LLM: preentrenamiento,
Ajuste fino supervisado y ajuste de preferencias: combinación de pesos
Ajuste fino completo, Ajuste fino completo
Ajuste fino de parámetros eficientes, Ajuste fino de parámetros eficientes
(PEFT) Comprimiendo el modelo para un entrenamiento (más) eficiente
adaptadores, AdaptadoresAdaptadores
Compresión, Comprimiendo el modelo para un entrenamiento (más) eficiente
Comprimiendo el modelo para un entrenamiento (más) eficiente
LoRA, Adaptación de bajo rango (LoRA)Adaptación de bajo rango
(LoRA)
QLoRA, ajuste de instrucciones con QLoRAMerge Weights
Configuración de LoRA, Configuración de LoRA
fusionar pesos, Fusionar pesos

datos de instrucciones de creación de plantillas, datos de instrucciones de creación de plantillas
memoria compartida (SRAM), Flash Atención
ejemplo de preselección y reclasificación
Conjuntos de datos de plata, SBERT aumentado
SimCSE (Aprendizaje contrastivo simple de incrustaciones de oraciones),
Aprendizaje no supervisado
skipgram, el algoritmo Word2vec y el entrenamiento contrastivo
Función de pérdida Softmax, Funciones de pérdida
Sistemas de recomendación de canciones, incrustaciones para sistemas de recomendación
Atención dispersa, Atención local/escasa
tokens especiales, comparación de tokenizadores LLM entrenados, parámetros del tokenizador
especificidad, en indicaciones basadas en instrucciones, indicaciones basadas en instrucciones
SRAM (memoria compartida), Flash Atención
StableLM, Elección de un modelo de generación de texto
StarCoder2, StarCoder2 (2024)
razonamiento paso a paso, El poder impulsor detrás de los agentes: paso a paso
Razonamiento: El poder impulsor de los agentes: razonamiento paso a paso
Salida estructurada, validación, verificación de salida
STSB (Punto de referencia de similitud textual semántica), modelo de tren
tokens de subpalabras, palabra versus subpalabra versus carácter versus byte

Fichas
clasificación supervisada, Clasificación SupervisadaSupervisada

Clasificación
Ajuste fino de modelos de representación para la clasificación supervisada.
Capas de congelación
capas congelantes, Capas congelantes Capas congelantes
Modelos BERT preentrenados, Ajuste fino de un modelo BERT preentrenado
Ajuste fino supervisado (ver SFT)
Procesos de pensamiento de los sistemas 1 y 2, Razonamiento con modelos generativos
yo
T5 (Transformador de transferencia de texto a texto), uso del transformador de transferencia de texto a texto
parámetro target_modules, configuración de LoRA
Modelos específicos de tareas, Clasificación de texto con modelos de representación
parámetro de temperatura, Temperaturatop_p, Autoconsistencia: Muestreo
Salidas
Tesla T4, Formación
Pruebas divididas, El sentimiento de las críticas cinematográficas, Utilizando un modelo específico de tareas
Fragmentación de texto, obtención del archivo de texto y fragmentación del mismo, fragmentación de
textos largos: varios vectores por documento
Enfoques para, Múltiples vectores por documento
Múltiples vectores por documento Múltiples vectores por documento
un vector por documento, Un vector por documento
Clasificación de textos, Resumen de la clasificación de textos

con modelos generativos, Clasificación de texto con modelos generativos

ChatGPT, ChatGPT para clasificaciónChatGPT para clasificación
T5, Uso del transformador de transferencia de texto a texto: Uso del transformador de
transferencia de texto a texto
Reseñas de películas, El sentimiento de las reseñas de películas: El sentimiento de

Reseñas de películas
con modelos de representación, Clasificación de texto con modelos de representación: ¿Qué

pasa si no tenemos datos etiquetados?
Tareas de clasificación que aprovechan las incrustaciones, Tareas de clasificación

que aprovechan las incrustaciones: ¿qué pasa si no tenemos datos
etiquetados?
Selección de modelo, Selección de modelo Selección de modelo
modelos específicos de tareas, Uso de un modelo específico de tareas Uso de un modelo específico de tareas
Modelo específico
Agrupamiento de texto, Agrupamiento de texto y modelado de temas: inspección de los clústeres
Modelo de incrustación CLIP y CLIP: Conexión de texto e imágenes
canalización común para, una canalización común para agrupamiento de texto

modelo de clúster, clúster de incrustaciones reducidas: clúster de

Incrustaciones reducidas

Modelo de incrustación, Incorporación de documentos
Inspección de clústeres, Inspección de los clústeresInspección de los clústeres

Clústeres
modelos de incrustación de texto, incrustaciones de texto (para oraciones y texto completo)

Documentos) Incrustaciones de texto (para oraciones y documentos completos),
Creación de modelos de incrustación de texto: resumen
aprendizaje contrastivo, ¿Qué es el aprendizaje contrastivo?¿Qué es el

aprendizaje contrastivo?
Creación, Creación de un modelo de incrustación: pérdida de clasificación de múltiples

negativos
evaluando, Evaluación en profundidad
Generando ejemplos contrastivos, Generando ejemplos contrastivos

Ejemplos
Funciones de pérdida, Funciones de pérdida : Clasificación de pérdidas por múltiples negativos
entrenamiento, Modelo de tren Modelo de tren
Ajuste fino, Ajuste fino de un modelo de incrustación
supervisado, SupervisadoSupervisado
SBERT, SBERTSBERT
Generación de texto, Generando tu primer textoGenerando tu primer texto,

Técnicas y herramientas avanzadas de generación de textos Resumen
ReAct en LangChain, ReAct en LangChainReAct en LangChain
razonamiento paso a paso, El poder impulsor detrás de los agentes: razonamiento paso
a pasoEl poder impulsor detrás de los agentes: razonamiento paso a paso
Cadenas, Cadenas: Ampliación de las capacidades de los LLM: una cadena con
Múltiples indicaciones
encadenamiento de un único mensaje, Un único eslabón en la cadena: Mensaje
Plantilla: Un solo eslabón en la cadena: Plantilla de mensaje
encadenamiento secuencial de múltiples indicaciones, una cadena con múltiples indicaciones
Indicaciones: una cadena con múltiples indicaciones
Buffer de conversación, Buffer de conversación Buffer de conversación
Resumen de conversación, Resumen de conversación Conversación
Resumen
Buffer de conversación en ventana, Buffer de conversación en ventana

Modelo de E/S, Modelo de E/S: Carga de modelos cuantificados con LangChain
E/S de modelos: carga de modelos cuantificados con LangChain
multimodalidad, Creación de modelos de generación de texto multimodales: caso de uso
2: Indicaciones multimodales basadas en chat
BLIP2, BLIP2: Cerrando la brecha de modalidadBLIP2: Cerrando la brecha de modalidad
subtítulos de imágenes, caso de uso 1: subtítulos de imágenes, caso de uso 1:
Subtítulos de imágenes
preprocesamiento de imágenes, preprocesamiento de imágenes
Ingeniería de textos, uso de modelos de generación de textostop_p

Elección de modelos, Elección de un modelo de generación de texto
Control de salida, Control de salida del modelotop_p
Carga de modelos, Carga de un modelo de generación de texto: Carga de un modelo

Modelo de generación de texto
Modelado de temas, La generación de texto Bloque LegoLa generación de texto
Bloque Lego
Modelo de texto dentro de texto fuera, las entradas y salidas de un transformador entrenado
Máster en Derecho
Transformador de transferencia de texto a texto (T5), uso del transformador de transferencia de texto a texto
Modelo thenlper/gtesmall, Incorporación de documentos
Comando mágico %%timeit, acelerando la generación mediante el almacenamiento en caché de claves y

Valores
TinyLlama, ajuste de instrucciones con QLoRA, ajuste de preferencias con DPO
codificación sin tokenización, palabras versus subpalabras versus caracteres versus
Fichas de bytes
Tokens y tokenizadores, Generando su primer texto, Tokens e incrustaciones
Creación de incrustaciones de palabras contextualizadas con modelos de lenguaje
modelo de bolsa de palabras, Representación del lenguaje como una bolsa de palabras
Comparación de tokenizadores entrenados, Comparación de tokenizadores LLM entrenados
Phi3 (y Llama 2)
Modelo base BERT (en caja), modelo base BERT (en caja) (2018)
Modelo base BERT (sin carcasa), modelo base BERT (sin carcasa) (2018)
FlanT5, FlanT5 (2022)
Galáctica, Galáctica
GPT2, GPT2 (2019)
GPT4, GPT4 (2023)
Phi3 y Llama 2, Phi3 (y Llama 2)
StarCoder2, StarCoder2 (2024)

Distribución de probabilidad (muestreo/decodificación)
Descarga y ejecución de LLM, Descarga y ejecución de un LLM

Descargar y ejecutar un LLM
Pase hacia adelante, Los componentes del pase hacia adelanteLos componentes del
pase hacia adelante
Preparación de entrada, Cómo los tokenizadores preparan las entradas al lenguaje

Modelo
Modelado de lenguaje enmascarado, uso de la transferencia de texto a texto

Transformador
Procesamiento de tokens en paralelo y tamaño del contexto, Procesamiento de tokens en
paralelo y tamaño del contextoProcesamiento de tokens en paralelo y tamaño del contexto
tokens especiales, Comparación de tokenizadores LLM entrenados
Modelo de representación específico de la tarea, Uso de un modelo específico de la tarea, Texto

Clasificación con modelos generativos
Desglose de texto, ¿Cómo desglosa el texto el tokenizador?
Modelos centrados en texto versus modelos centrados en código, El dominio de los datos
Incrustaciones de tokens, Incrustaciones de tokens: creación de palabras contextualizadas

Incrustaciones con modelos de lenguaje, los componentes del avance
Pase, Resumen
creando incrustaciones de palabras contextualizadas, creando

Creación de incrustaciones de palabras contextualizadas con lenguaje
Modelos
El vocabulario del tokenizador y un modelo de lenguaje

Incrustaciones para el vocabulario de su tokenizador
Intervalos de tokens, uso del transformador de transferencia de texto a texto
esquemas de tokenización, palabra versus subpalabra versus carácter versus
Tokens de bytes: palabras , subpalabras, caracteres y bytes

Fichas
tokens de bytes, palabra versus subpalabra versus carácter versus byte

Fichas
tokens de caracteres, Palabra versus Subpalabra versus Carácter versus
Fichas de bytes
tokens de subpalabras, Palabra versus Subpalabra versus Carácter versus
Fichas de bytes
tokens de palabras, palabra versus subpalabra versus carácter versus byte

Fichas
Propiedades del tokenizador, Propiedades del tokenizador: el dominio de los datos
conjuntos de datos, El dominio de los datos
métodos, métodos de tokenización
parámetros, parámetros del tokenizador
caracteres de espacio en blanco, GPT2 (2019)
tono de voz, en indicaciones de generación de texto, La complejidad potencial de un

Inmediato
Modelado de temas, agrupamiento de texto y modelado de temas, del agrupamiento de texto al modelado
de temas: el bloque Lego de generación de texto
BERTopic, BERTopic: un marco de modelado de temas modular
BERTopic: un marco de modelado de temas modular
bloques de representación, Añadiendo un bloque Lego especial: el texto
parámetro top_k, top_p
parámetro top_p, top_p, Autoconsistencia: resultados de muestreo
El tren se parte, El sentimiento de las críticas cinematográficas
Clase TrainingArguments: Ajuste fino de un modelo BERT entrenado previamente
Aprendizaje por transferencia, modelos de representación: modelos de solo codificador
Arquitectura del transformador, la atención es todo lo que necesitas: la atención es todo lo que necesitas
Necesidad de mirar dentro de los grandes modelos lingüísticos : resumen
capa de atención, Los componentes del pase hacia adelante, Dentro de la

Bloque transformador
Distribución de probabilidad (muestreo/decodificación)
Capa de avance, dentro del bloque transformador
Componentes del pase hacia adelante, Los componentes del pase hacia adelanteEl
Componentes del pase hacia adelante
Entradas y salidas de, Las entradas y salidas de un entrenador
Transformador LLM: Las entradas y salidas de un transformador entrenado

Máster en Derecho
caché de claves y valores, aceleración de la generación mediante el almacenamiento en caché de claves y valores
Valores: cómo acelerar la generación mediante el almacenamiento en caché de claves y valores

Optimizando la atención, Optimizando la atención: De multihead a multiquery a consulta
agrupada
Procesamiento de tokens en paralelo y tamaño del contexto, Procesamiento de tokens en
paralelo y tamaño del contextoProcesamiento de tokens en paralelo y tamaño del contexto
mejoras recientes a, Mejoras recientes al Transformador
ArquitecturaOtros experimentos y mejoras arquitectónicas
Atención más eficiente, Atención más eficiente Atención flash
Bloques transformadores, El bloque transformador
Bloques transformadores, Dentro del bloque transformadorAutoatención:
Combinando información
cálculo de la atención, Cómo se calcula la atenciónCómo se calcula la atención
Capa de atención, La capa de atención de un vistazo
mecanismo de atención, La atención es todo lo que necesitasLa atención es todo lo
que necesitas
Redes neuronales de propagación hacia adelante, La red neuronal de propagación hacia adelante
de un vistazo
Autoatención y puntuación de relevancia, Autoatención: Puntuación de relevancia
Autoatención: Combinación de información
Transformador de visión, Transformadores para visiónTransformadores para visión
Transparencia y rendición de cuentas, Desarrollo y uso responsable de LLM
árbol del pensamiento, Árbol del pensamiento: Explorando los pasos intermediosÁrbol del pensamiento
Pensamiento: Explorando pasos intermedios

TruthfulQA, puntos de referencia y tablas de clasificación
TSDAE (codificador automático de eliminación de ruido secuencial basado en transformador)
para la adaptación del dominio, utilizando TSDAE para la adaptación del dominio
Descripción general de, Autocodificador de eliminación de ruido secuencial basado en transformador
Codificador automático de eliminación de ruido secuencial basado en transformador
tú
Conjunto de datos de UltraChat, datos de instrucciones de creación de plantillas
UMAP (Aproximación y proyección de variedad uniforme), reducción de la
Dimensionalidad de las incrustaciones
modelo de lenguaje unigrama, FlanT5 (2022)
unk_token [UNK], modelo base BERT (sin mayúsculas ni minúsculas) (2018)
parámetro use_cache, aceleración de la generación mediante el almacenamiento en caché de claves y valores
salida válida, verificando, Verificación de salida
La validación se divide, El sentimiento de las críticas cinematográficas
bases de datos vectoriales
recuperación densa, Recuperación Densa
Búsqueda del vecino más cercano versus, Búsqueda del vecino más cercano versus bases de
datos vectoriales
Generación aumentada por recuperación, Carga del modelo de incrustación
Memoria de acceso aleatorio de vídeo (VRAM), hardware y software
visualización
BERTopic, BERTopic: un marco de modelado de temas modular
Análisis de conglomerados, Inspección de los conglomerados
Reducción de la dimensionalidad e inspección de los clústeres
ViT (Transformador de visión), Transformadores para visiónTransformadores para visión,
vocabulario, de tokenizadores, parámetros de tokenizadores, un modelo de lenguaje se cumple
Incrustaciones para el vocabulario de su tokenizador, los componentes del
Pase hacia adelante, resumen
VRAM (memoria de acceso aleatorio de vídeo), hardware y software
Yo
parámetro warmup_ratio, configuración de entrenamiento
argumento warmup_steps, Entrenar modelo
Weaviate, búsqueda del vecino más cercano versus bases de datos vectoriales
caracteres de espacio en blanco, GPT2 (2019)
memoria de búfer de conversación en ventana, búfer de conversación en ventana
Buffer de conversación en ventana, resumen de conversación
Incrustaciones de palabras, incrustaciones de palabras más allá de los LLM: Word2vec
Algoritmo y entrenamiento contrastivo
preentrenado, Uso de incrustaciones de palabras preentrenadas
Algoritmo Word2vec y entrenamiento contrastivo, El algoritmo Word2vec y el entrenamiento
contrastivoEl algoritmo Word2vec y el entrenamiento contrastivo
Capacitación
tokens de palabras, tokens de palabras, tokens de subpalabras, tokens de caracteres y tokens de bytes
Métricas a nivel de palabra, en la evaluación de modelos generativos, Métricas a nivel de palabra
Algoritmo word2vec: mejores representaciones con vectores densos

Incrustaciones, tipos de incrustaciones: codificación y decodificación del contexto con
Atención
entrenamiento contrastivo y, El algoritmo Word2vec y el entrenamiento contrastivoEl

algoritmo Word2vec y el entrenamiento contrastivo, ¿Qué es el aprendizaje contrastivo?
Incorporación de canciones, Recomendar canciones mediante incrustaciones
WordPiece, ¿Cómo descompone el tokenizador el texto?
Modelo base BERT encapsulado, modelo base BERT (encapsulado) (2018)
Modelo base BERT sin carcasa, modelo base BERT (sin carcasa) (2018)
Ficha <trabajo>, Galactica
Año de la IA generativa, El año de la IA generativaEl año de la IA generativa

AI
Clasificación zeroshot, ¿Qué pasa si no tenemos datos etiquetados?¿Qué pasa si no tenemos

datos etiquetados?
CLIP, CLIP: Conectando texto e imágenes
SetFit, ajuste fino para la clasificación de pocos disparos
Incitación a disparar cero
Cadena de pensamiento : piensa antes de responder
aprendizaje en contexto, aprendizaje en contexto: proporcionar ejemplos

OceanofPDF.com
Acerca de los autores
Jay Alammar es director y miembro del equipo de ingeniería de Cohere (proveedor

pionero de modelos de lenguaje de gran tamaño como API). En esta función, asesora y
capacita a las empresas y a la comunidad de desarrolladores sobre el uso de
modelos de lenguaje para casos prácticos. A través de su popular blog sobre IA y ML,
Jay ha ayudado a millones de investigadores e ingenieros a comprender visualmente
las herramientas y los conceptos de aprendizaje automático, desde los más básicos (que
terminan en la documentación de paquetes como NumPy y pandas) hasta los más
avanzados (Transformers, BERT, GPT3, Stable Diffusion). Jay también es
cocreador de cursos populares sobre aprendizaje automático y
procesamiento del lenguaje natural en Deeplearning.ai y Udacity.
Maarten Grootendorst es un científico de datos clínicos sénior en IKNL

(Organización Holandesa de Lucha contra el Cáncer). Tiene títulos de maestría en
psicología organizacional, psicología clínica y ciencia de datos, que aprovecha para
comunicar conceptos complejos de aprendizaje automático a una amplia audiencia. Con
sus populares blogs, Ha llegado a millones de lectores explicando los fundamentos de la
inteligencia artificial, a menudo desde un punto de vista psicológico. Es autor y
mantenedor de varios paquetes de código abierto que se basan en la solidez de los modelos
de lenguaje de gran tamaño, como BERTopic, PolyFuzz y KeyBERT. Sus paquetes se
descargan millones de veces y son utilizados por profesionales y organizaciones
de datos de todo el mundo.
OceanofPDF.com
Colofón
El animal que aparece en la portada de HandsOn Large Language Models es un

canguro rojo (Osphranter rufus). Es el canguro más grande de todos, con una longitud
corporal que puede llegar a poco más de 1,50 metros y una cola de hasta 90 centímetros.
Son muy rápidos y pueden alcanzar velocidades de más de 56 kilómetros por hora. Pueden
saltar 1,80 metros de altura y recorrer una distancia de 7,60 metros de un solo salto.
La posición de sus ojos les permite ver hasta 300 grados.
Los canguros rojos reciben su nombre por el color de su pelaje. Si bien el nombre tiene
sentido para los machos (tienen un pelaje corto de color marrón rojizo), las hembras suelen
tener un color más gris azulado con un matiz marrón en toda su extensión. El color rojo de
su pelaje proviene de un aceite rojo que segregan las glándulas de su piel.
Debido a su color, los australianos llaman a los canguros rojos machos “grandes rojos”.
Sin embargo, como las hembras son más rápidas que los machos, a menudo se las llama
“voladores azules”.
Los canguros rojos prefieren áreas abiertas y secas con algunos árboles para dar sombra y
se encuentran en todo el territorio continental de Australia, excepto en las regiones
del norte superior, suroeste inferior y costa este del país. Las condiciones
ambientales circundantes pueden afectar la reproducción. Debido a esto, las hembras
pueden pausar o posponer el embarazo o el parto hasta que las condiciones mejoren. A
menudo usan esta capacidad para retrasar el nacimiento de una nueva cría (joey) hasta
que la anterior haya salido de su bolsa.
La ilustración de la portada es de Karen Montgomery, basada en un antiguo grabado de

Cassell's Popular Natural History. El diseño de la serie es de Edie Freedman, Ellie
Volckhausen y Karen Montgomery. Las fuentes de la portada son Gilroy Semibold y
Guardian Sans. La fuente del texto es Adobe Minion Pro; la fuente del encabezado
es Adobe Myriad Condensed; y la fuente del código es Ubuntu Mono de Dalton Maag.
OceanofPDF.com

Hands-On Large Language Models (Traducido)

Cargado por

Copyright:

Formatos disponibles

Hands-On Large Language Models (Traducido)

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Hands-On Large Language Models (Traducido)

Cargado por

Copyright:

Formatos disponibles

Machine Translated by Google

Machine Translated by Google

Elogios para los modelos de lenguaje grandes y prácticos

Jay y Maarten han continuado su tradición de brindar descripciones ilustradas y

—Andrew Ng, fundador de DeepLearning.AI

Este libro es de lectura obligada para cualquier persona interesada en el campo de

En el corazón de la revolución GenAI, esta guía indispensable equilibra magistralmente

Lectura oportuna para obtener experiencia práctica con modelos de lenguaje.

—Prof. DDr. Roman Egger, director ejecutivo de Smartvisions.at y de

Lenguaje amplio y práctico

Jay Alammar y Maarten Grootendorst

Modelos de lenguaje prácticos de gran tamaño

por Jay Alammar y Maarten Grootendorst

Impreso en los Estados Unidos de América.

Los libros de O'Reilly se pueden comprar con fines educativos, comerciales o

Editora de adquisiciones: Nicole Butterfield

Editor de desarrollo: Michele Cronin

Editor de producción: Ashley Stussy

Redactor: Charles Roumeliotis

Corrector de pruebas: Kim Cofer

Indexador: BIM Creatives, LLC

Diseñador de interiores: David Futato

Diseñador de la portada: Karen Montgomery

Ilustrador: Kate Dullea

Septiembre de 2024: Primera edición

Historial de revisiones de la primera edición

10­09­2024: Primer lanzamiento

Consulte http://oreilly.com/catalog/errata.csp?isbn=9781098150969 para detalles del

Con su combinación única de desarrollo de la intuición, aplicaciones y estilo ilustrativo,

Una filosofía que prioriza la intuición

Estructura del libro

Parte I: Comprensión de los modelos lingüísticos

Figura P­1. Todas las partes y capítulos del libro.

Parte II: Uso de modelos de lenguaje preentrenados

Aprenderá a utilizar modelos de lenguaje para la clasificación supervisada (ver Capítulo

El aprendizaje de estas capacidades de modelos de lenguaje individuales le brindará el

Parte III: Entrenamiento y ajuste de modelos lingüísticos

Requisitos de hardware y software

puede seguir esta configuración para crear su entorno:

conda create ­n thellmbook python=3.10

conda activa el libro electrónico

Puede instalar todas las dependencias necesarias bifurcando o clonando el repositorio y

pip install ­r requisitos.txt

Vaya a “Claves API” para crear una clave secreta.

una clave secreta.

Luego, en “Configuración” ve a “Tokens de acceso” para crear un token que puedas

Úselo para descargar ciertos LLM.

Convenciones utilizadas en este libro

Indica nuevos términos, URL, direcciones de correo electrónico, nombres de archivos y

Ancho constante en negrita

Muestra comandos u otro texto que el usuario debe escribir literalmente.

Cursiva de ancho constante

Este elemento significa un consejo o sugerencia.

Usando ejemplos de código

Si tiene una pregunta técnica o un problema al utilizar los ejemplos de código,

Agradecemos la atribución, pero por lo general no la exigimos. Una atribución suele

anteriormente, no dude en contactarnos a permissions@oreilly.com.

Aprendizaje en línea de O'Reilly

Nuestra red única de expertos e innovadores comparte sus conocimientos y

O'Reilly Media, Inc.

10092024: Primer lanzamiento

Figura P1. Todas las partes y capítulos del libro.

conda create n thellmbook python=3.10

pip install r requisitos.txt

8008898969 (en Estados Unidos o Canadá)

7078277019 (internacional o local)

Encuéntrenos en LinkedIn: https://linkedin.com/company/oreillymedia.

Figura 11. Un vistazo a la historia de la inteligencia artificial del lenguaje.

como se ilustra en la Figura 13.

Por ejemplo, Bagofwords crea incrustaciones a nivel de documento, ya que representa el

Figura 110. Se pueden crear incrustaciones para diferentes tipos de entrada.

Figura 117. Un bloque codificador gira en torno a la autoatención para generar

Como se muestra en la Figura 120, la capa de autoatención del decodificador

El modelo Transformer original es una arquitectura de codificadordescodificador que

Figura 121. Arquitectura de un modelo base BERT con 12 codificadores.

GPT3.5 no fue el único modelo que tuvo impacto en el Año de la IA