Así funciona Speculative Decoding. Acelera los modelos de lenguaje «adivinando» su respuesta.

En este post, vamos a explorar una fascinante técnica para mejorar el rendimiento de los modelos de lenguaje llamada speculative decoding. Esta estrategia se basa en la idea de «adivinar» las respuestas antes de tiempo, tal como lo haría un oráculo.

Vamos a sumergirnos en los detalles para comprender cómo funciona esta técnica y cómo nos permite acelerar los tiempos de procesamiento.

Puedes ver la versión en vídeo en YouTube (https://youtu.be/qV0deLwEOhk):

Haz click para ver el vídeo en YouTube

¿Cómo Funciona Speculative Decoding?

La técnica de speculative decoding se basa en un proceso que busca acelerar la generación de texto de los modelos de lenguaje mediante predicciones previas. Esto se logra a través de la combinación de un modelo principal y un oráculo, el cual tiene la tarea de anticipar las respuestas posibles para reducir el tiempo de procesamiento.

Para entender mejor cómo funciona, imaginemos un ejemplo: supongamos que queremos completar la frase «El perro ladra». Antes de que el modelo principal comience a generar una respuesta, le pedimos al oráculo que intente predecir lo que va a decir. Supongamos que el oráculo predice: «El perro ladra a la luna llena».

Con esta predicción inicial, tenemos tanto la frase original como la posible continuación del oráculo. Aquí es donde entra el verdadero potencial de speculative decoding: los modelos de lenguaje pueden procesar varios «prompts» en paralelo. Es decir, en lugar de esperar a que el modelo genere cada token uno por uno, se reutilizan cálculos previos y se aceleran los resultados generando varios tokens a la vez.

Usamos estos prompts en paralelo para evaluar la predicción del oráculo añadiendo un token en cada prompt:

Al evaluar los prompts se genera el siguiente token:

Ahora evaluamos en que caso el token sugerido por el oráculo y el predicho coincide:

Cada token acertado lo damos como predicho correctamente por el oraculo.

En nuestro ejemplo con una sola iteración el sistema ha predicho 3 tokens: «a la gata«

En este caso cada iteración es más costosa que calcular un solo token sin speculative decoding, ya que hay que sumar el tiempo de ejecutar los múltiples prompts en paralelo (hay que recordar que se reaprovechan muchos cálculos) y de generar la predicción oráculo.

Si el oráculo acierta, se puede ahorrar una cantidad significativa de tiempo generando varios tokens de una sola vez. Este proceso tiene, sin embargo, ciertos riesgos y limitaciones. Cuando el oráculo se equivoca, se produce una penalización en términos de eficiencia, ya que se pierde el beneficio del procesamiento paralelo. Por ello, el rendimiento de speculative decoding está directamente relacionado con la precisión del oráculo.

¿Qué es el Oráculo?

El «oráculo» no es más que una manera de generar predicciones preliminares para acelerar el proceso de decodificación. A continuación, se presentan algunas de las diferentes alternativas que existen para un oráculo:

  1. Modelo más pequeño y rápido: Utiliza un modelo de lenguaje más pequeño para generar una versión preliminar de la respuesta.
  2. N-gramas: Consiste en el uso de patrones comunes de palabras que se encuentran en documentos similares. Esta técnica es efectiva cuando se trabaja con temas específicos, ya que aprovecha asociaciones típicas de palabras.
  3. Reglas heurísticas: Estas reglas permiten predecir cuál es la siguiente palabra basándose en patrones lógicos. Se han usado durante décadas en los entornos de desarrollo como sistemas de sugerencias.
  4. Uso del prompt: En tareas de resumen, es común que conceptos presentes en el prompt aparezcan también en la respuesta. Esta técnica aprovecha dicha redundancia para hacer predicciones más acertadas.
  5. Modelos Multi-Head: Estos modelos utilizan múltiples cabezas para predecir varios tokens a la vez, lo cual permite generar varias alternativas de predicción simultáneamente. Esto puede aumentar la eficiencia en comparación con modelos que predicen un solo token por vez.

Ventajas y Desafíos

La mayor ventaja de speculative decoding es la velocidad. Cuando el oráculo acierta, podemos generar varios tokens en el tiempo que normalmente tomaría generar uno. Sin embargo, esto está condicionado por la calidad de las predicciones del oráculo. Si falla con frecuencia, los beneficios desaparecen.

Para evaluar si merece la pena usar speculative decoding, podemos comparar el tiempo que toma generar un token con el método convencional frente al tiempo y la penalización que introduce el oráculo. Si la velocidad total resulta mejor, entonces vale la pena implementarlo.

¡Prueba Speculative Decoding!

Si estás interesado en probar esta técnica, puedes echar un vistazo al proyecto Llama.cpp, que incluye varios ejemplos y diferentes implementaciones de speculative decoding. En el directorio «examples/speculative», «examples/lookahead» y «examples/lookup» encontrarás las implementaciones que puedes usar para experimentar y explorar distintas opciones de speculative decoding.

Usar ControlNet desde Fooocus

Fooocus es una de las herramientas más sencillas para usar Stable Diffusion. Tiene un gran equilibrio entre complejidad y capacidades. En mi modesta opinión una de sus mayores carencias es la falta de ControlNet. Una herramienta que permite usar distintas características de la imagen para influir en el resultado. De tal forma que no solo podemos usar el prompt para describir la imagen que deseamos.

Es cierto que de forma nativa Fooocus soporta Canny (contornos), pero hay muchos más casos. A mi me interesa especialmente los esqueletos de OpenPose que permiten indicar deforma muy sencilla la posición de las personas en la imagen generada.

Los principales motivos para no soportar ControlNet son:

  • Falta de un buen ControlNet para SDXL, que es la versión de Stable Diffusion que usar Fooocus.
  • Necesidad de cargar varios ControlNet para cada tipo de imagen de referencia.
  • Añadir un preprocesador diferente para cada tipo de imagen de referencia que queramos extraer.

Por suerte desde la aparición de controlnet-union-sdxl-1.0, que permite usar un único modelo para múltiples ControlNet y que soporta SDXL, los dos primeros problemas han sido resueltos.

El tercer punto no queda más remedio que afrontarlo usando programas externos para generar las imágenes de referencia.

En el siguiente vídeo se explican los pasos para lograr integrar este modelo en Fooocus, sin tocar una sola linea de código:

El resumen de los pasos:

  1. Descargar controlnet-union-sdxl: diffusion_pytorch_model.safetensors
  2. Copiarlo en la carpeta Fooocus/models/controlnet
  3. Renombrarlo a (recomendable guardar el fichero anterior) a: control-lora-canny-rank128_old.safetensors
  4. Lanzar Fooocus
  5. En Advanced – Control – Marcar Skip Preprocessor para desactivar el preprocesador de ControlNet (solo sirve para Canny)
  6. Usar Image Prompt con PyraCanny activado
  7. Cargar como Image Prompt la imagen de referencia para ControlNet

Usar IA generativa para comprimir datos

Cada día aprendemos más trucos que puede realizar la IA generativa. Vamos a ver como usar un modelo de lenguaje para comprimir textos.

Una técnica habitual en los programas de compresión es crear una nuevo vocabulario donde las secuencias de bits más repetidas, o lo que es lo mismo las más frecuentes, son reemplazadas por secuencias de bits más cortas. Como nada sale gratis en esta vida a cambio hay cadenas de bits cortas pero poco frecuentes que son reemplazadas por otras con más bits. Todos estos reemplazos se guardan en un diccionario que puede ir adjunto en el archivo comprimido si el diccionario es propio para cada fichero y generado a partir del contenido del propio fichero.

Hay otra opción, que el diccionario sea único para todos los ficheros que se compriman. En ese caso no es necesario incluirlo en el fichero. Lo cual ahorra espacio pero a cambio suelen ser sistemas especializados solo para un tipo de ficheros.

Ahora paremos a pensar una cosa: ¿Cómo surgieron los modelos de lenguaje? Originalmente eran sistemas para completar texto. Es decir, saben predecir cuál es la palabra (en realidad el token) más probable para continuar un texto. De hecho no solo saben cuál es la más probable, saben cómo de probable es cada una de las palabras (tokens) que conocen.

Dado un texto un modelo de lenguaje nos devuelve un listado ordenado de lo probable que es cada palabra.

Si un modelo es lo suficientemente bueno podríamos darle el comienzo de un texto y el modelo generaría el resto. Desgraciadamente no funcionan tan bien. Por lo que podemos añadir una corrección cada vez que la predicación sea incorrecta. Al final podemos guardar solo esas desviaciones respecto a las predicciones del modelo.

Obviamente este sistema comprime tan bien como lo bueno que sea el modelo prediciendo el texto. Para textos aleatorios será malo, para textos literarios será bueno.

Si quieres saber más de cómo funciona puedes ver el siguiente vídeo en YouTube:

Haz click para ver el vídeo en mi canal e YouTube

Marcas de agua, textos radiactivos y modelos de lenguaje.

Unas de las principales quejas que hay hoy en día con la IA generativa, es la incapacidad de poder determinar que textos ha creado un humano y cuál una IA.

Hay muchos sitios que prometen ser capaces de detectar los textos creados por una IA. Aunque los pocos que he probado caen pronto cuando le podés a la IA que escriba de otra manera. Además con la gran cantidad de diferentes IA que se pueden usar cada vez es más difícil detectarlos

Y si le damos un giro a la situación y en lugar de  detectar el texto a posteriori lo escribimos a priori para que sea fácil reconocerlos. Para ello se pueden esconder marcas de agua dentro de un mensaje.

En imágenes, videos y audios hay mucho «sitio» donde esconder una marca que indique que el mensaje lo generó una IA sin afectar al mismo, de hecho hay gran cantidad de técnicas. Pero los textos son diferentes, hay pocos datos y muy estructurados. Eso significa que esconder nada en ellos es muy difícil. Todo cambio que hagas en el texto afecta negativamente a la calidad de este. Una sola letra puede transformar una palabra en un galimatias.

El truco está en modificar la distribución estadística de las palabras del texto que genera el modelo de lenguaje. Para ello se usan n palabras (tokens) anteriores para generar dos grupos pseudoaleatorios de palabras (tokens); rojas, prohibidas y verdes, permitidas. Por lo tanto un texto generado por una IA será completamente verde.

Peroooo nada es perfecto y hay un problema. Puede ser que en el grupo de las palabras verdes no exista ninguna muy apropiada para continuar el texto. Esto afecta a la calidad del texto,  lo que hace que sea necesario permitir alguna palabra prohibida (roja) de vez en cuando.

Si quieres saber más sobre este tema, más detalles de cómo funciona, sus fortalezas y debilidades, cómo atacarlo, …. Puedes hacer click para ver el siguiente video:

Haz click para ver el vídeo

Manipula la respuesta de un chatbot

¿No estáis hartos de los modelos de lenguaje se nieguen a seguir ciertas ordenes? ¿Y si hubiera alguna forma de «sugerirle» que respuesta debe de dar?

Haz click para ver el vídeo en Youtube

Estamos acostumbrados a interaccionar con los chatbots a través de una interfaces de este estilo:

Sin embargo realmente el texto que se pasa al modelo de lenguaje tiene este aspecto (si usamos Llama 3, dependiendo del LLM se usan formatos diferentes):

Se puede ver que hay etiquetas que indican donde termina el texto del usuario y donde empieza su respuesta.

El modelo de lenguaje comienza a rellenar la respuesta token a token (si no sabes que es un token puede cambiar el termino «token» por «palabra», no es una explicación exacta pero sirve para entender el texto). Para generar cada token lo que hace es analizar todo el texto completo. Es decir, analiza el texto, genera el primer token. Analiza todo el texto junto con ese primer token y genera el segundo. Ahora analiza otra vez el texto junto con los nuevos token para generar el tercero….así hasta llegar al final del texto que genera que lo indicara con <|eot_id|>.
Tras eso el sistema que ejecuta la IA esperará la siguiente texto que introduzca el usuario y al que añadirá delante una etiqueta de usuario (<|start_header_id|>user<|end_header_id|>, en nuestro ejemplo) y al final una etiqueta de asistente (<|start_header_id|>assistant<|end_header_id|>) para que el modelo pueda seguir completando a partir de ahí.

Pero si trabajamos con el modelo de lenguaje desde una API, en lugar de desde la interface gráfica, nada nos impide «engañarle» manipulando su respuesta. Podemos añadir nosotros la etiqueta de asistente y poner lo que queramos detrás de ella:

Y el modelo de lenguaje se verá «obligado» a continuar esa respuesta:

Este truco es útil cuando necesitas que el modelo se pliegue a alguna condición que por algún motivo se niega cumplir. Por ejemplo a mi me pasa con algunos modelos que les pides que creen solo código y se empeñan en añadir texto delante. En el vídeo podéis ver un ejemplo en mayor detalle.

Temperatura = 0. Desactivar la creatividad de los modelos de lenguaje para obtener mejores respuestas.

Los modelos de lenguaje pueden tener muchos parámetros diferentes, sin embargo hay uno que todos comparten. La temperatura.

Sin usar matemáticas podríamos definir la temperatura como un indicador de lo «creativo» que es un modelo a la hora de responder. A mayor temperatura mayor creatividad. Generalmente se mantiene en valores entre 0 y 1 ya que valores superiores hacen que las respuestas pierdan coherencia y sentido.

Desde un punto de vista más técnico y matemático, un modelo de lenguaje no genera palabras, sino una especie de pesos asignados a cada token (si no sabes que es un token piénsalo como si fuera una palabra). A mayor peso más adecuado es ese token para completar la frase. Pero ahora hay que pasar esos tokens a probabilidades y elegir uno en base a estas probabilidades. Para convertir estos «pesos» a probabilidad se usa la función softmax con temperatura.

Al aumentar la temperatura las probabilidades entre diferentes tokens se reparten de forma más uniforme y se reduce la distancia entre ellas. Esto hace que sea más probable que se elijan otros tokens. Cuando la temperatura se reduce los tokens de mayor peso concentran mayor probabilidades. Sin embargo cuando la temperatura es 0 el token de mayor peso acumula el 100% de la probabilidades.

Sin embargo, no siempre queremos esta creatividad. En mi caso, encontré problemas con la generación de código por parte de un modelo de lenguaje, a veces le daba por improvisar y usar nombres «muy creativos» para variables o funciones. Y si, es cierto que programar es una actividad creativa…pero no precisamente en su sintaxis. Al contrario suele ser muy estricta siguiendo normas muy claras. Eso te ahorra tiempo y esfuerzo de buscar como se llama cierta función. Si quiere recuperar el valor de la variable limite llama a la función getLimite. Si, usando su creatividad, la IA la ha llamado getLim voy a tener problemas y confusiones. Para resolver esto baje la temperatura a 0 y aumentó la fiabilidad del código generado.

Y es que nos hemos acostumbrado a usar los modelos de lenguaje para «conversar» con ellos, sin embargo, hay casos como la generación de código o de textos con sintaxis o estructuras muy estrictas donde la creatividad puede ser un problema.

Puedes ver una explicación más completa en el siguiente vídeo de mi canal:

Haz click para ver en Youtube

Comparamos el nuevo tokenizador de Llama 3 con el antiguo de Llama 1 y 2

Una de las novedades de Llama 3 ha Sido un enorme tokenizador con 128k tokens. Un tokenizador tan grande aporta dos ventajas. Soporta textos mayores usando el mismo número de tokens. El tamaño del contexto es el mismo pero «caben» textos más grandes.

Para comprobar si es tan bueno cómo prometen vamos a compararlo con el anterior tokenizador usado por Llama 1 y 2.

Cómo el número de tokens depende del tipo de texto también. Vamos a probar varios tipos de textos: inglés, español, código en C, Python y TypeScript.

Para estas pruebas he usado dos aplicaciones web que permiten comprobar como funcionan ambos tokenizadores:

Tokenizador llama 1-2: https://belladoreai.github.io/llama-tokenizer-js/example-demo/build/
Tokenizador llama 3: https://belladoreai.github.io/llama3-tokenizer-js/example-demo/build/

Texto:

Llama Llama 31 – (Llama 3 / Llama)
Ingles1172995910,18
Español648356590,12

Textos usados:
Texto (en): https://en.wikipedia.org/wiki/Llama
Texto (es): https://es.wikipedia.org/wiki/Lama_glama

Código:

Llama Llama 31 – (Llama 3 / Llama)
C1234293000,24
Python23569171320,27
TypeScript487438270,21

Textos Usados:
Código C: https://raw.githubusercontent.com/ggerganov/llama.cpp/master/sgemm.cpp
Código Python: https://raw.githubusercontent.com/abetlen/llama-cpp-python/main/llama_cpp/llama.py
Código TypeScript: https://raw.githubusercontent.com/ngxson/wllama/master/src/wllama.ts

Puedes ver el vídeo en Youtube sobre esta entrada pulsando en la imagen:

Un test sencillo y rápido para probar un sistema RAG

La aparición de la técnica RAG ha permitido usar nuestros propios documentos en las consultas a un modelo de lenguaje. Realmente la técnica es cómo un truco de magia. Lo que te da la sensación de que estás viendo no es realmente lo que ocurre.

Pero RAG no es una solución perfecta. Ni única , hay muchas formas de implementarlo y muchos modelos de lenguaje con el que usarlo. Poder hacer alguna prueba rápida que nos muestre que tal se comporta un RAG puede ser útil para descartar candidatos. En esta entrada vamos a ver una forma sencilla e informal de probar que tal funciona RAG.

El funcionamiento de un RAG se basa en dos modelos de lenguaje. Uno especializado en buscar textos relacionados y otro especializado en conversar con el usuario.

Cuando haces una pregunta / tarea el modelo de lenguaje especializado en buscar, busca textos relacionados en la documentación que le has pasado y le pasa estos textos al modelo especializado en conversar como parte del prompt.

¿Por qué no pasar todos los documentos al segundo modelo y olvidarnos del primero? Por el tamaño del contexto, el modelo solo es capaz de «recordar» un tamaño maximo de tokens (si no sabes lo que es un token sustituyelo por «palabra», no es exactamente lo mismo pero te permite hacerte una idea sin entrar en detalles técnicos). Todo lo que supere ese número de tokens es ignorado por el modelo de lenguaje.

Ahora hay modelos que permiten contextos muy grandes, el problema es que requieren enormes cantidades de RAM y potencia de cómputo.

Sin embargo no todo son ventajas y felicidad en el uso de RAG, algunos de los problemas son:

  • Si hay muchos bloques que coincidan se pueden perder datos ya que no todos se pueden añadir al prompt.
  • Se puede perder datos, por ejemplo en bloques muy largos puede quedar parte de la información en un bloque que no coincide con la query y por tanto no se añade.
  • El rag pierde la secuencia temporal. En un bloque se puede hablar de una cosa y en el siguiente modificarla. Al recuperar ambos bloques no tienen por qué conservar el orden.
  • El modelo puede no hacer caso a la info añadida al prompt. Este caso ocurre cuando el modelo tiene datos propios «aprendidos» sobre algo que los documentos contradicen. En casos así puede ser que el modelo ignore lo que dice el prompt (y por tanto los documentos) para responder con lo que su aprendizaje indica como correcto.
  • Coincidencias erróneas, por frases muy parecidas pero de significado contrario o el uso de ironía / sarcasmo.
  • Un documento puede mezclar tipos de datos diferentes que deberían de ser segmentados de forma diferente. Por ejemplo código y texto.
  • Se pueden usar los documentos para hacer «inyección de prompts»
  • Los datos de los documentos pueden filtrarse

Para detectar estos problemas en un RAG nos centraremos en cinco pruebas:

  • Una aguja en un pajar: prueba que muestra lo bueno que es detectando una pequeña cantidad de información en los documentos.
  • Aprendizaje vs documentos: los datos de los documentos contradicen datos aprendidos por el modelo. ¿Qué fuente prevalece?
  • Inyección de prompts: la parte recuperada de los documento contiene instrucciones ocultas para modificar el prompt
  • Alucinaciones: la documentación incluye información que el modelo desconoce (más que nada porque nos la hemos inventado). Al preguntarle sobre ella hay que verificar que no se inventa datos.
  • Conservar la secuencia de tiempo: Cuando se recuperan varios bloques de texto es posible que el orden de los mismos se pierda.

En el siguiente vídeo puedes ver como funcionan las pruebas:

Haz click para ver el vídeo en mi canal de Youtube

Control Vectors. Controla de forma fácil el estilo y «ánimo» de un modelo de lenguaje

Los control vectors son una sorprendente herramienta para controlar el estilo del texto que genera un modelo de lenguaje.

Para entender lo que son los control vectors empezaremos por lo que es una neurona artificial. sin entrar en mucho detalle básicamente se compone de un conjunto de datos de entrada (un vector) que se multiplica por un conjunto de pesos (vamos a ignorar el bias, el simbolito ese raro que hay en el dibujo). Cada valor se multiplica con su peso correspondiente y luego esos resultados se suman todos y se pasan a una función conocida como función de activación. El resultado es la salida de la neurona.

Una red neuronal no es nada más que un conjunto de estas neuronas que se agrupan formando capas.

Las operaciones del vector de valores de entrada con cada una de estas capas puede hacerse como multiplicar este vector por una matriz formada por los pesos de todas las neuronas. El resultado es otro vector cada uno de los elementos de este vector se pasa a la función de activación generando el vector output de esa capa. Que será el vector input de la siguiente capa.

El funcionamiento de control vectors es sencillo, se calcula un vector por cada capa que se suma al vector input y que hace que el modelo se comporte de una manera predefinida. 

¿Cómo calculamos los control vectors?

Es muy sencillo, usamos dos prompts para hacer que el modelo se comporte de la forma deseada y de la contraria. Por ejemplo:

«Responde como una persona muy educada. [Tarea]»
«Responde como una persona muy maleducada. [Tarea]»

Siendo tarea un conjunto de tareas que completaran el prompt. 

Por ahora vamos a centrarnos en una sola tarea:

«Responde como una persona muy educada. ¿Cúal es la capital de Francia?»
«Responde como una persona muy maleducada. ¿Cúal es la capital de Francia?»

Al procesar cada uno de los prompts irá generando dos vectores output por cada capa. Uno para el prompt positivo y otro para el negativo. Restando ambos tendremos un único vector por capa.

Repitiendo este proceso para cada tarea tendremos para cada capa un grupo de vectores formados por la resta de los vectores positivos y negativos de cada tarea.

Este grupo lo reducimos a un solo vector usando PCA y así obtenemos un control vector para cada capa. El grupo de todos los vectores para cada capa es lo que se denomina control vectors

Cuando se aplica a un input, el  control vector se multiplica por un valor (generalmente entre 2 y -2) que determina con qué fuerza se aplicará. Si es positivo reforzará el comportamiento positivo, si es negativo reforzará el contrario.

Cómo usar los control vectors

Actualmente son soportados por llama.cpp cuya aplicación «main» ofrece tres parámetros para usarlos:

–control-vector happy.gguf Indica que fichero de control vectors usar (en este caso happy.gguf)
–control-vector-scaled honest.gguf -1.5 Indica el fichero y el peso que se aplica a los control vectors
–control-vector-layer-range 14 26 Indica a que capas de la red neuronal se aplica

Tenéis más información de su uso en esta pull request de llama.cpp

Cómo entrenar tus propios control vectors

Por suerte es bastante sencillo, existe un notebook de Google Colab que permite entrenar nuestros control vectors de forma simple

Puedes ver el siguiente vídeo explicando este articulo y con un ejemplo de como se usa el notebook de Goolge Colab:

Haz click en la imagen para ver el vídeo en Youtube

Control Vectors vs Prompt

Control vector no puede conseguir nada que el prompt no consiga. ¿Por qué usarlo? El primer motivo es que permite personalizar el comportamiento del modelo independientemente del prompt, lo cual facilita redactar prompts sin pensar en esa parte. Se pueden aplicar distintos control vectors al mismo prompt y viceversa, lo cual facilita realizar pruebas. Por último los control vectors se tienen más en cuenta que los prompts ya que modifican los prompts en cada capa de la red neuronal. Gracias a esto pueden ser una herramienta útil contra el jailbreaking.

Control Vectors vs Fine-tuning y LoRA

El fine-tuning consiste en reentrenar el modelo con datos propios. Permite personalizar el modelo y hacer cosas mucho más complejas: añadir nuevos datos, nuevos formatos de respuesta, darle nuevas capacidades (como function calling). A cambio el coste en tiempo y recursos es mucho mayor. El resultado es un modelo completamente nuevo.

LoRA consiste en entrenar solo una parte de los pesos de un modelo para obtener resultados cercanos al fine-tuning. Se obtiene un conjunto de pesos que puede ser «añadido» de forma dinámica, se pueden llegar a combinar varios LoRA (aunque nadie te promete que funcione). Cuesta entrenarlo menos que el fine-tuning pero aun así es exigente en tiempo y recursos. El resultado ocupa solo una parte de lo que ocupa el modelo, aunque es necesario tener ambos para que funcione.

Control Vectors no permite añadir nada al modelo, solo modificar su comportamiento dentro de los límites que el prompt permite. A cambio se entrena realmente rápido (de hecho es un 2×1 ya que entrenas el comportamiento deseado y el contrario). El resultado pesa muy poco.  

La instrucción que la IA no puede seguir

Estamos acostumbrados a que las IA generativas traten de seguir nuestras instrucciones con mayor menor acierto. ¿Pero hay alguna instrucción que les sea imposible seguir? Y con ello me refiero a instrucciones dentro de sus capacidades, no a cosas imposibles. Es decir, una instrucción que esté a su alcance seguir pero sea imposible que lo hagan…

Puedes hallar la respuesta en este video o si no quieres verlo en el párrafo debajo suyo:

«No respondas». Es es la instrucción que los modelos de lenguaje actualmente no pueden seguir. No porque no sean capaces de hacerlo. Por lo general pueden devolver un token que indica «fin de la respuesta» pero han sido entrenadas para completar frases, no pueden evitar tratar de completar el texto, aunque sea contradiciendo la orden que se les ha dado.

Un ejemplo :


No respondas
ChatGPT
Entendido, no responderé. Si tienes alguna otra consulta o necesitas ayuda, no dudes en decírmelo.