Una historia sobre IA · 04
¿Qué son los pesos de un modelo?
Cómo aprende una máquina mediante números
Dentro de los números que aprenden: de una neurona artificial a miles de millones de pesos.
Publicado por AI Model Green Zone
Continuar leyendo →Los términos subrayados abren el glosario. Pasa el cursor o usa el teclado para una explicación breve.
Sobre este artículo
Los pesos de un modelo son parámetros numéricos que se ajustan durante el entrenamiento y determinan cómo procesa la información una inteligencia artificial. Cuando haces una pregunta, el texto se convierte primero en una representación numérica y después atraviesa las numerosas capas de una red neuronal. Puedes imaginar esas capas como una sucesión de filtros: cada uno destaca distintas relaciones y características, refuerza algunas señales y atenúa otras. Pero estos «filtros» no se limitan a descartar información: también la transforman y la transmiten a la siguiente capa. Los pesos determinan cómo se realizan esas transformaciones.
Durante el entrenamiento, el modelo hace predicciones, las compara con las continuaciones correctas y ajusta poco a poco sus pesos para reducir los errores. Así, los patrones del lenguaje, las relaciones entre hechos y las formas de resolver problemas quedan codificados en numerosos parámetros numéricos interconectados. Cuando conversas con un modelo ya entrenado, sus pesos normalmente no cambian: al atravesar las capas, la información de tu consulta ayuda al modelo a calcular las probabilidades del siguiente fragmento de su respuesta. El proceso se repite y la respuesta se construye paso a paso. Si quieres entender cómo esos ajustes convierten simples números en un sistema capaz de mantener una conversación, sigue leyendo: el artículo recorre ese camino con ejemplos fáciles de seguir.
Un modelo de IA moderno puede escribir Python, reconocer un perro, traducir japonés, resumir un contrato, imitar a Shakespeare y, de vez en cuando, decirte algo completamente falso con la seguridad de un hombre al que jamás se le ha ocurrido comprobar nada en Google.
Debajo de toda esta sofisticación hay algo sorprendentemente corriente:
números.
Miles de millones.
Cuando ves un modelo descrito como 8B, 30B o 70B, la B significa miles de millones de parámetros.
Esos parámetros son valores numéricos aprendidos dentro de la red neuronal. La mayoría se encuentran en enormes estructuras matemáticas llamadas matrices de pesos.
A estos números suele referirse la gente cuando habla de los pesos de un modelo.
No son pequeñas frases almacenadas en algún lugar del ordenador.
No hay una fila oculta que diga:
Francia → París
No hay una carpeta llamada:
Cosas que sé sobre los perros
Y ningún peso individual tiene un cargo como:
Vicepresidente sénior de Sarcasmo.
El conocimiento de una red neuronal se distribuye entre enormes patrones de números.
Suena misterioso.
La idea básica no lo es.
De hecho, la historia comienza hace más de ochenta años.
Antes de que la IA estuviera de moda… o fuera siquiera electrónica
En 1943, el neurofisiólogo Warren McCulloch y el matemático Walter Pitts publicaron un influyente modelo matemático de una neurona artificial.
Fue antes de la IA moderna.
Antes de las GPU.
Antes de Python.
Antes incluso de que se inventara el transistor.
Su pregunta era audazmente sencilla:
¿Podría algo inspirado en una neurona biológica representarse matemáticamente como una unidad de cálculo?
Su neurona artificial era extremadamente primitiva según los estándares actuales. Recibía entradas y producía una salida siguiendo reglas matemáticas.
Pero había aparecido una idea importante:
quizá un comportamiento complejo pudiera surgir de un gran número de unidades de cálculo sencillas conectadas entre sí.
Las redes neuronales modernas son muchísimo más sofisticadas.
Pero debajo de ellas aún se reconoce aquella idea ancestral.
Empecemos con una neurona artificial
Olvidemos por un momento los ocho mil millones de parámetros.
Construyamos una diminuta neurona artificial.
Supongamos que recibe tres entradas numéricas:
La letra simplemente significa entrada.
Esas entradas podrían representar, en última instancia, casi cualquier cosa: números de un conjunto de datos financieros, fragmentos de una imagen o representaciones numéricas internas del lenguaje.
Cada entrada se multiplica por otro número:
La letra representa el peso.
Un peso determina cuánto contribuye esa entrada concreta al cálculo de la neurona.
La neurona combina los valores así:
La fórmula parece más intimidante que la operación.
En palabras corrientes dice:
Multiplica cada entrada por su peso, suma los resultados y añade otro número ajustable llamado sesgo.
El sesgo es:
Permite que la neurona desplace su resultado hacia arriba o hacia abajo independientemente de los valores de entrada.
Después de calcular la suma ponderada, una red neuronal normalmente pasa el resultado por una función no lineal:
Aquí simplemente significa:
Aplica otra transformación matemática al resultado.
¿Para qué molestarse?
Porque, sin funciones no lineales, apilar muchas capas seguiría comportándose matemáticamente como una única transformación lineal gigantesca.
La no linealidad permite que la red represente relaciones mucho más complejas.
Así que el recorrido básico es:
entradas → pesos → suma ponderada → transformación no lineal → siguiente capa
Una neurona artificial no escribirá tu informe trimestral.
Miles de millones de parámetros aprendidos, organizados en capas sofisticadas, resultan bastante más interesantes.
Llega el perceptrón… y también el entusiasmo desmedido por la IA
A finales de los años cincuenta, el psicólogo Frank Rosenblatt desarrolló el perceptrón, uno de los primeros sistemas de redes neuronales entrenables.
La palabra importante es entrenable.
En vez de que un programador eligiera explícitamente cada valor interno útil, la máquina podía ajustar la intensidad de sus conexiones a partir de ejemplos.
Esas intensidades de conexión eran pesos.
La idea básica sonaba sorprendentemente moderna:
Haz una predicción.
Averigua si era incorrecta.
Ajusta los números.
Inténtalo de nuevo.
Los periódicos se entusiasmaron muchísimo.
Lo cual demuestra que las redes sociales no inventaron la exageración en torno a la IA.
Los ordenadores eran algo menos cómodos.
Hoy puedes ejecutar modelos con miles de millones de parámetros en un equipo situado debajo de una mesa.
Rosenblatt trabajaba en una época en la que los ordenadores podían ocupar una buena parte de una habitación y hacer mucho menos que tu teléfono.
El progreso a veces es cruel con el hardware antiguo.
La gigantesca mesa de mezclas
Una forma útil de imaginar los pesos es una enorme mesa de mezclas de audio.
Entra una señal.
Un control refuerza una parte.
Otro debilita algo.
Otro modifica cómo se combinan varias señales.
Ahora imagina que no hay veinte controles.
Ni veinte mil.
Miles de millones.
El comportamiento final depende de sus ajustes combinados.
Pero esta analogía tiene una advertencia importante.
Un peso concreto no suele corresponder limpiamente a un concepto humano.
No puedes abrir un modelo 8B, encontrar el parámetro número 4.827.112.391 y anunciar:
«Excelente. Hemos encontrado la oreja izquierda del perro».
Las redes neuronales modernas utilizan representaciones distribuidas.
Un concepto como perro, ironía, JavaScript, gravedad o una forma educada de decirle a un cliente que su diseño es espantoso puede depender de patrones que involucran enormes cantidades de parámetros y estados internos temporales.
El significado está distribuido.
La inteligencia está en el patrón.
No en un mando mágico.
Antes del entrenamiento: un idiota muy caro
Cuando se inicializa una red neuronal, sus pesos suelen comenzar como pequeños valores numéricos elegidos según un método de inicialización.
En ese momento, la red tiene arquitectura.
Tiene miles de millones de lugares donde algún día podría representarse conocimiento.
Pero todavía no ha aprendido relaciones útiles.
Podrías construir un modelo enorme y aun así tener algo prácticamente inútil.
Conviene recordarlo cuando la cantidad de parámetros hipnotiza a la gente.
Un almacén con diez mil millones de cuadernos en blanco no contiene automáticamente más conocimiento que una biblioteca.
Hay que escribir algo en los cuadernos.
El entrenamiento es el proceso que cambia los números.
No escribiendo frases en ellos.
Sino creando relaciones numéricas útiles.
Dejemos que una neurona se equivoque
Veamos ahora un pequeño ejemplo de entrenamiento con números lo bastante sencillos como para seguirlos a mano.
Supongamos que nuestra neurona recibe dos entradas.
La primera entrada es:
La segunda es:
Así que la primera señal tiene un valor numérico de uno y la segunda de un medio.
El primer peso actual es:
El segundo es:
Y el sesgo es:
Ahora usamos el cálculo de la suma ponderada:
En vez de quedarnos mirando la fórmula, descompongámosla.
La primera entrada aporta:
La segunda entrada aporta:
Y el sesgo añade:
Sumamos las tres partes:
Así que nuestra neurona produce:
El pequeño sombrero sobre significa:
la predicción del modelo
Ahora supongamos que el objetivo correcto de este ejemplo de entrenamiento es:
El modelo predijo:
El resultado correcto era:
Así que a la predicción le faltan:
La neurona se equivoca.
Es una noticia excelente.
Los errores son, básicamente, el sistema educativo de las redes neuronales.
Sin un error, el proceso de entrenamiento no tiene una señal que indique qué necesita mejorar.
Pérdida: un medidor matemático de vergüenza
El sistema de entrenamiento necesita ahora una forma formal de responder:
¿Hasta qué punto era incorrecta esa predicción?
Ese es el trabajo de una función de pérdida.
Para nuestro ejemplo de juguete podemos usar una pérdida sencilla de error cuadrático:
Traduzcamos cada símbolo.
significa pérdida.
significa la predicción del modelo.
significa el objetivo correcto.
Así que la fórmula dice:
Resta la respuesta correcta de la predicción y eleva la diferencia al cuadrado.
Nuestra predicción es:
El objetivo es:
Restamos:
Ahora elevamos ese resultado al cuadrado:
Así que nuestra pérdida es:
¿Por qué elevar el error al cuadrado?
Entre otras razones, no queremos que los errores en direcciones opuestas se anulen entre sí.
Quedarse 0.30 por debajo sigue siendo un error.
El cuadrado nos da una cantidad positiva que la optimización puede intentar reducir.
Piensa en la pérdida como un medidor matemático de vergüenza.
Pérdida alta:
Eso salió mal.
Pérdida menor:
Menos vergonzoso.
Un modelo de lenguaje moderno suele usar otra función de pérdida para predecir el siguiente token, normalmente una forma de pérdida de entropía cruzada.
La conoceremos más adelante.
Por ahora, la idea esencial es:
predicción → medir el error
La siguiente pregunta es más difícil.
Nuestro pequeño ejemplo tiene solo dos pesos.
Un modelo real puede tener miles de millones.
¿Qué pesos fueron responsables del error?
¿Y en qué dirección deberían moverse?
1986: las matemáticas aprenden a repartir culpas
Una de las herramientas fundamentales para responder es la retropropagación.
Las ideas matemáticas que la sustentan tienen una historia más larga, pero un influyente trabajo de David Rumelhart, Geoffrey Hinton y Ronald Williams en 1986 ayudó a situarla en el centro del entrenamiento de las redes neuronales modernas.
El problema es sencillo de plantear.
La salida era incorrecta.
Pero muchas capas y muchos parámetros participaron en producirla.
¿Cómo determinamos qué cambios mejorarían la salida?
La retropropagación recorre la red hacia atrás y calcula lo sensible que es el error final a cada parámetro entrenable.
Puedes imaginarla como un departamento de contabilidad extraordinariamente eficiente.
Ha ocurrido un error.
Ahora se calcula la contribución de todos.
Nadie puede decir:
«Estoy bastante seguro de que fue la capa 17».
El cálculo tiene los recibos.
Retropropagación: ¿qué significa la fórmula?
Una de las expresiones que encontrarás es:
Si estudiaste cálculo hace veinte años y has logrado evitarlo desde entonces, la notación puede provocarte un daño emocional innecesario.
La idea es bastante más sencilla que el símbolo.
Pregunta:
Si cambiara este peso concreto una cantidad diminuta, ¿cómo cambiaría la pérdida?
Ese valor forma parte de lo que llamamos gradiente.
Supongamos que aumentar ligeramente un peso aumenta el error.
Información útil.
Supongamos que aumentarlo reduce el error.
También útil.
La derivada informa al optimizador tanto sobre la dirección como sobre la sensibilidad.
La retropropagación utiliza la regla de la cadena del cálculo para calcular estas relaciones de forma eficiente a través de muchas capas.
La red no está pensando:
«Confundí al perro con un gato porque me fijé demasiado en el pelaje».
No sucede nada tan literario.
Está calculando cómo los cambios en unos números afectan a otros.
Muchísimos números.
Descenso del gradiente: ahora bajemos la pendiente
Una vez que la retropropagación ha calculado los gradientes, el optimizador tiene algo con lo que actuar.
Una actualización simplificada de un peso tiene este aspecto:
De nuevo, traduzcamos antes de utilizarla.
es el peso que tenemos ahora.
es el peso después del paso de entrenamiento.
El gradiente:
nos dice cómo cambia la pérdida cuando cambia ese peso.
Y la letra griega:
pronunciada eta, es la tasa de aprendizaje.
La tasa de aprendizaje determina el tamaño del paso que debe dar el optimizador.
Así que la fórmula completa significa:
Empieza con el peso actual.
Determina qué dirección aumenta el error.
Avanza una distancia controlada en la dirección opuesta.
¿Por qué la dirección opuesta?
Porque el objetivo es que la pérdida baje.
Imagina que estás en una montaña rodeado de niebla espesa.
No ves el valle.
Pero puedes determinar en qué dirección sube la pendiente.
Si quieres descender, camina hacia el otro lado.
Esa es la intuición básica del descenso del gradiente.
El paisaje real de optimización de una red neuronal moderna puede tener miles de millones de dimensiones.
Eso dificulta un poco dibujar la montaña en una servilleta.
Si puedes visualizar cómodamente un paisaje de setenta mil millones de dimensiones, quizá tengas otros problemas.
El entrenamiento moderno suele utilizar optimizadores más sofisticados, como Adam o AdamW, que registran información adicional y ajustan inteligentemente el proceso de actualización.
Pero la idea central sigue siendo:
calcular cómo afectan los parámetros al error y moverlos en una dirección que se espera que lo reduzca.
Ahora hagámoslo de verdad.
Una actualización diminuta, con las cuentas reales
Nuestra neurona de juguete había recibido:
y:
Sus pesos eran:
y:
El sesgo era:
La neurona predijo:
El resultado deseado era:
Para esta demostración usaremos directamente la suma ponderada como predicción, de modo que todas las operaciones queden a la vista. Una red real también puede contener una función de activación cuya derivada forme parte de la retropropagación.
Nuestro error de predicción con signo es:
El signo negativo nos dice:
La predicción del modelo está por debajo del objetivo.
Nuestra pérdida de error cuadrático era:
por tanto:
Ahora calculamos cómo responde esta pérdida a cada peso.
Encontrar el gradiente del primer peso
Para esta neurona sencilla, el gradiente de la pérdida respecto al primer peso es:
Parece técnico.
Pero ya conocemos todos los valores.
El error es:
La primera entrada es:
Sustituimos esos valores:
Los multiplicamos:
¿Qué significa menos 0.60?
Nos dice que, en este punto, aumentar debería reducir la pérdida.
El gradiente apunta hacia el aumento del error.
El descenso del gradiente avanza en la dirección opuesta.
Encontrar el gradiente del segundo peso
Ahora hacemos lo mismo con el segundo peso:
El error sigue siendo:
Pero la segunda entrada es solo:
Sustituimos:
lo que da:
Observa algo útil.
La magnitud del segundo gradiente es la mitad de la del primero.
¿Por qué?
Porque la segunda entrada:
es la mitad de la primera:
En este pequeño ejemplo, cambiar el primer peso afecta más al resultado final.
Estas son exactamente las dependencias que la retropropagación calcula automáticamente.
Elegir una tasa de aprendizaje
Ya conocemos la dirección.
Todavía tenemos que decidir el tamaño del paso.
Para nuestra demostración, elegimos:
Eso significa que, en este paso simplificado, el optimizador avanzará una décima parte de la magnitud del gradiente.
Es un número redondo cómodo para enseñar.
Los sistemas de entrenamiento reales eligen y programan sus tasas de aprendizaje con mucho más cuidado.
Si es demasiado pequeña, el aprendizaje puede volverse dolorosamente lento.
Si es demasiado grande, el optimizador puede saltarse soluciones buenas y empezar a rebotar por el paisaje como alguien que intenta bajar una montaña con botas de esquí.
Actualizar el primer peso
La regla de actualización es:
Para el primer peso:
Primero multiplicamos la tasa de aprendizaje por el gradiente:
Así que:
Restar un número negativo significa sumar:
Y ahora sabemos exactamente de dónde salió 0.26.
Nadie lo eligió porque quedara bonito.
Ningún ingeniero escribió:
Probemos con 0.26.
Lo produjeron el gradiente y la tasa de aprendizaje.
Actualizar el segundo peso
Ahora repetimos exactamente el mismo proceso para :
Multiplicamos:
Así que:
lo que da:
De ahí salió 0.43.
En este ejemplo didáctico dejaremos el sesgo sin cambios en:
En una red real, un sesgo entrenable normalmente tendría su propio gradiente y podría actualizarse mediante el mismo proceso general.
Ejecutar de nuevo la neurona
Las entradas no han cambiado.
La primera sigue siendo:
Pero su peso ahora es:
Por tanto, su contribución es:
La segunda entrada sigue siendo:
Su nuevo peso es:
Así que su contribución pasa a ser:
El sesgo sigue siendo:
Sumamos todo:
La nueva predicción de la neurona es:
Antes del paso de entrenamiento predijo:
Ahora predice:
El objetivo sigue siendo:
Todavía se equivoca.
Pero observa lo que ha ocurrido.
Antes de la actualización, la distancia al objetivo era:
Después de la actualización:
El error se redujo.
También podemos calcular la nueva pérdida cuadrática:
Primero:
Luego lo elevamos al cuadrado:
Así que la pérdida ha bajado de:
a:
En este ejemplo deliberadamente sencillo, un paso de descenso del gradiente redujo considerablemente la pérdida.
Eso no significa que un gran modelo de lenguaje real mejore en ese mismo porcentaje en cada paso de entrenamiento.
La optimización real es ruidosa, compleja y tiene muchísimas más dimensiones.
Pero nuestro pequeño ejemplo ya ha mostrado un paso completo de aprendizaje sin ocultar nada:
En palabras:
La neurona hizo una predicción.
La pérdida midió el error.
El cálculo determinó cómo contribuyeron los pesos al error.
El optimizador cambió los pesos.
La nueva predicción se acercó al objetivo.
La pérdida se redujo.
No ocurrió nada mágico.
Las matemáticas cambiaron los números.
Luego el sistema lo hace de nuevo.
Y de nuevo.
Y de nuevo.
Nuestro ejemplo usa dos pesos porque dos pesos todavía caben cómodamente en una página.
Una red neuronal real puede ajustar millones o miles de millones de parámetros entrenables.
Ahí entra en la historia la computación a escala industrial.
¿Cómo aprende un modelo de lenguaje a partir de esto?
Un gran modelo de lenguaje no suele entrenarse recibiendo una tabla gigantesca de reglas explícitas como:
París = capital de Francia
Perro = mamífero
Python = la sangría importa
En cambio, buena parte del preentrenamiento moderno de modelos de lenguaje utiliza un objetivo engañosamente sencillo:
Predecir el siguiente token.
Sigamos entonces con París y recorramos todo el ejemplo.
Supongamos que el texto de entrenamiento contiene:
La capital de Francia es París.
En un momento del entrenamiento, el modelo recibe:
La capital de Francia es
y debe predecir el siguiente token.
Para simplificar, supongamos que París se representa con un solo token. La tokenización real puede dividir algunas palabras en varios tokens, pero ese detalle no cambia el principio.
Al principio del entrenamiento, el modelo podría producir probabilidades como estas:
Londres — 18%
París — 5%
Lyon — 4%
Roma — 3%
Berlín — 2%
La probabilidad restante se reparte entre miles de otros tokens posibles.
Pero el texto de entrenamiento nos dice que el verdadero siguiente token es:
París
Por tanto, el modelo hizo una mala predicción.
Solo dio a París un cinco por ciento de probabilidad, favoreciendo a Londres.
Ahora el entrenamiento necesita medir lo mala que fue esa predicción.
Entropía cruzada: la pérdida del modelo de lenguaje
Para predecir el siguiente token, los modelos de lenguaje suelen utilizar una forma de pérdida de entropía cruzada.
Para un único token correcto, la expresión simplificada puede escribirse así:
De nuevo, traduzcamos antes de calcular.
significa:
la probabilidad que el modelo asignó al token que realmente venía después
En nuestro ejemplo:
Cinco por ciento escrito como decimal es:
Lo sustituimos:
El resultado es aproximadamente:
No necesitas recordar 2.996.
Lo importante es lo que consigue el logaritmo.
Una probabilidad baja para la respuesta correcta produce una pérdida relativamente alta.
Ahora supongamos que, mucho más adelante en el entrenamiento, el mismo tipo de contexto da a París un setenta por ciento de probabilidad:
Entonces:
que es aproximadamente:
Así que:
París al 5% → pérdida relativamente alta
París al 70% → pérdida mucho menor
La función de pérdida no sabe qué es París.
No sabe qué es Francia.
No entiende el concepto político de capital.
Simplemente dice:
La probabilidad asignada al token correcto debería haber sido mayor.
Esa señal numérica basta.
La retropropagación ya puede hacer el mismo tipo de trabajo que vimos en nuestra neurona de juguete.
¿Cómo llega realmente «París» a los pesos?
La predicción no salió de un solo peso.
Las palabras:
La capital de Francia es
se convirtieron primero en representaciones numéricas de tokens.
Esas representaciones atravesaron muchas capas Transformer.
Dentro de ellas, los mecanismos de atención y las redes de propagación hacia delante transformaron repetidamente los números usando matrices de pesos aprendidas.
Finalmente, el modelo produjo puntuaciones brutas para los posibles siguientes tokens.
Estas puntuaciones se llaman logits.
Imagina una versión drásticamente simplificada:
Todavía no son probabilidades.
Son puntuaciones brutas de preferencia.
Una operación matemática llamada softmax convierte los logits en una distribución de probabilidades cuyos valores suman el cien por ciento.
Quizá después de softmax obtengamos:
Londres — 18%
París — 5%
Lyon — 4%
Roma — 3%
Los datos de entrenamiento nos dicen:
París debería haber ganado.
La entropía cruzada nos da la pérdida.
Después, la retropropagación recorre la red hacia atrás, calculando cómo afectarían a esa pérdida pequeños cambios en los parámetros participantes.
El optimizador los actualiza.
No un cambio gigantesco.
Enormes cantidades de cambios microscópicos.
Luego llega otro fragmento de texto.
Una frase no enseña geografía
El modelo no ve:
La capital de Francia es París.
una vez y anuncia inmediatamente:
«Geografía completada».
Sus datos de entrenamiento también pueden contener:
París es la capital de Francia.
La ciudad capital de Francia es París.
El Gobierno francés tiene su sede en París.
París es una gran ciudad europea.
Francia es un país de Europa occidental.
El Sena atraviesa París.
Y enormes cantidades de otros contextos sobre Francia, París, ciudades, gobiernos, países, idiomas, viajes, historia y geografía.
Cada ejemplo produce predicciones.
Cada predicción produce una pérdida.
Cada pérdida genera gradientes.
Cada paso de entrenamiento modifica ligeramente los parámetros.
Con el tiempo, las relaciones superpuestas se van tejiendo en la red.
Esa palabra, tejiendo, es útil.
El hecho no se coloca en una caja marcada:
Francia → París
Pasa a formar parte de un tejido matemático distribuido.
Después de suficiente entrenamiento
Con el tiempo, el modelo ve:
La capital de Francia es
y quizá su distribución de salida se parezca ahora más a esto:
París — 92%
Lyon — 1.2%
Marsella — 0.7%
Londres — 0.3%
París gana ahora fácilmente.
Entonces, ¿dónde está almacenado el hecho?
No en un peso.
No en una neurona.
No en un registro de texto oculto.
La relación está distribuida por la red.
Y por eso el modelo también puede responder:
¿Qué ciudad ejerce de capital de Francia?
o:
¿Cuál es la ciudad capital de Francia?
La frase exacta ha cambiado.
Pero las relaciones subyacentes entre los conceptos siguen siendo útiles.
El modelo no se limita a buscar la frase exacta del entrenamiento.
Calcula a través de una red aprendida de relaciones numéricas.
Por eso también la tarea aparentemente sencilla de predecir el siguiente token puede generar un comportamiento sorprendentemente rico.
Para predecir bien el lenguaje, ayuda aprender gramática.
Significado.
Hechos.
Relaciones.
Estilo.
Estructura.
Patrones de razonamiento.
El objetivo es sencillo:
Predecir lo que viene después.
Lo que el modelo debe aprender para hacerlo excepcionalmente bien no lo es.
Y, en última instancia, esas relaciones aprendidas se reflejan en sus pesos.
Perros, gatos y por qué la «importancia de las características» puede engañarte
Una explicación habitual de los pesos de una red neuronal utiliza la clasificación de imágenes.
Supongamos que se entrena un modelo para distinguir perros de gatos.
Puede descubrir que ciertos patrones visuales de la forma del hocico, las orejas, la estructura de la cara o la forma del cuerpo son más útiles que otros.
Es una intuición útil.
Pero no debe tomarse al pie de la letra.
Una red moderna normalmente no contiene:
Peso de las orejas = 0.84
Peso del color del pelaje = 0.17
Las primeras capas pueden volverse sensibles a patrones relativamente sencillos, como los bordes.
Las posteriores pueden combinarlos en texturas y formas.
Representaciones aún posteriores pueden responder a estructuras cada vez más complejas.
La clasificación final surge de las interacciones entre muchas capas y muchos parámetros.
Así que, cuando decimos:
el modelo aprendió que la forma de las orejas importa
estamos traduciendo al lenguaje humano un proceso numérico distribuido y complejo.
No hay un mando etiquetado OREJA.
2012: la GPU entra en la historia
Las redes neuronales existían desde hacía décadas.
¿Por qué se aceleraron de repente sus capacidades?
Una razón importante fue el hardware.
En 2012, Alex Krizhevsky, Ilya Sutskever y Geoffrey Hinton presentaron lo que se conocería como AlexNet, una red profunda de reconocimiento de imágenes con unos sesenta millones de parámetros.
Un ingrediente crucial fue el uso de unidades de procesamiento gráfico, o GPU.
Las GPU habían evolucionado en gran medida porque los gráficos por ordenador requieren que enormes cantidades de operaciones matemáticas similares ocurran en paralelo.
Los videojuegos necesitaban procesar rápidamente píxeles, triángulos, iluminación y texturas.
Las redes neuronales miraron ese hardware y, en la práctica, dijeron:
«Esa máquina de multiplicar parece útil».
La industria del videojuego había pasado años ayudando accidentalmente a desarrollar infraestructura para el aprendizaje automático.
En algún lugar, un dragón virtual merece parte del mérito de la IA moderna.
De pesos individuales a tensores
Nuestra diminuta neurona utilizaba valores individuales como:
y:
Una red real no puede gestionar cómodamente miles de millones de parámetros así.
En su lugar, los números se organizan en estructuras llamadas tensores.
Una lista sencilla de números puede considerarse un tensor unidimensional.
Una tabla rectangular de números es un tensor bidimensional, normalmente llamado matriz.
Las colecciones de más dimensiones también son tensores.
Gran parte del cálculo de una red neuronal puede expresarse de forma compacta, por ejemplo:
Traduzcamos también esta.
representa una colección de números de entrada.
representa una matriz de pesos aprendidos.
Multiplicar:
significa combinar muchos valores de entrada con muchos pesos aprendidos según las reglas de la multiplicación de matrices.
El resultado:
es una nueva colección de valores numéricos transformados.
La notación parece diminuta.
El cálculo real puede contener millones o miles de millones de operaciones individuales de multiplicación y suma.
Por eso las GPU son tan valiosas.
Pueden realizar enormes cantidades de estas operaciones en paralelo.
Mientras la IA parece conversar tranquilamente sobre Dostoievski, la GPU está multiplicando a escala industrial.
La conversación parece intelectual.
El hardware ve aritmética.
2017: la atención cambia la arquitectura
En 2017, el artículo «Attention Is All You Need» presentó la arquitectura Transformer.
Los Transformers se convirtieron en la base de la mayoría de los grandes modelos de lenguaje modernos.
La arquitectura introdujo una potente forma de interacción entre distintas partes de una secuencia mediante la atención.
Pero la llegada de la atención no abolió los pesos.
Todo lo contrario.
Los Transformers contienen grandes matrices aprendidas en toda su arquitectura.
La atención utiliza matrices de proyección aprendidas.
Las capas de propagación hacia delante utilizan matrices aprendidas.
Los sistemas de embeddings contienen parámetros aprendidos.
La arquitectura se volvió muchísimo más sofisticada.
La moneda básica siguió siendo los números.
2020: 175 mil millones se convierten en un titular
Entonces llegó la escala.
En 2020 se presentó GPT-3 con:
175 mil millones de parámetros.
Compáralos con los aproximadamente sesenta millones de AlexNet solo ocho años antes.
El sector había pasado de millones de valores aprendidos a cientos de miles de millones.
La idea fundamental seguía siendo reconocible:
Aprender parámetros numéricos útiles a partir de datos.
Los investigadores mejoraron la arquitectura.
Los métodos de entrenamiento mejoraron.
Los conjuntos de datos crecieron.
Los clústeres de GPU se hicieron enormes.
Después, como suele ocurrir en informática, añadimos una cantidad absurda de ceros.
¿Qué contiene físicamente un modelo 8B?
Ahora la cantidad de parámetros deja de ser abstracta.
Se convierte en un problema físico de almacenamiento.
Supongamos que un modelo contiene:
parámetros.
Eso significa unos ocho mil millones de valores numéricos aprendidos.
Supongamos que cada parámetro se almacena con dieciséis bits.
Dieciséis bits equivalen a:
Así que el almacenamiento aproximado de los parámetros en bruto es:
lo que da:
o, aproximadamente:
¿De dónde salieron esos dieciséis gigabytes?
No hay misterio.
Tenemos ocho mil millones de números.
Cada uno necesita dos bytes.
Ocho mil millones por dos da aproximadamente dieciséis mil millones de bytes.
Ahora considera un modelo de setenta mil millones de parámetros con la misma precisión.
El cálculo es:
lo que da aproximadamente:
solo para almacenar los parámetros en bruto.
De pronto:
«Modelo 70B»
ya no es simplemente un nombre de modelo.
Es un problema de hardware.
Tu GPU empieza a interesarse.
La RAM del sistema puede empezar a interesarse.
Al final se interesa tu cartera.
Cuantización: ¿qué estamos reduciendo realmente?
Supongamos que dieciséis bits por parámetro requieren demasiada memoria.
¿Podemos representar los mismos valores aprendidos con menos bits?
Esa es la idea básica de la cuantización.
Tomemos nuestro hipotético modelo 8B.
Con dieciséis bits por parámetro, el almacenamiento idealizado de los parámetros en bruto es aproximadamente:
Ahora supongamos que representamos muchos pesos con unos cuatro bits.
Cuatro bits son medio byte:
Así que:
da aproximadamente:
Lo importante es lo que no ha ocurrido.
No hemos convertido un modelo de ocho mil millones de parámetros en uno de dos mil millones.
El modelo sigue teniendo aproximadamente la misma cantidad de parámetros.
Hemos cambiado la precisión numérica con la que se representan.
Una intuición sencilla es el redondeo numérico.
Podrías almacenar:
o:
El segundo número tiene menos precisión.
La cuantización real de redes neuronales es bastante más sofisticada que redondear decimales. Los métodos prácticos usan factores de escala, grupos, codificaciones especializadas y otras técnicas destinadas a conservar un comportamiento útil reduciendo la memoria.
Pero el intercambio físico central sigue siendo:
menos bits por peso → menos memoria
Por eso los usuarios de IA local pasan una sorprendente parte de su vida debatiendo Q4, Q5, Q6 y Q8.
Desde lejos parece que hablan de aceite de motor.
Normalmente se trata de encajar miles de millones de números en una tarjeta gráfica.
Los pesos no son activaciones
Otra distinción importa muchísimo al hablar de hardware.
Los pesos son persistentes.
Se almacenan como parte del modelo.
Apaga el ordenador.
Carga mañana el mismo modelo.
Los pesos aprendidos permanecen.
Las activaciones son temporales.
Cuando una entrada recorre la red, cada capa produce estados numéricos intermedios.
Esos valores dependen de la entrada actual.
Cambia el prompt y cambiarán las activaciones.
Piensa en una fábrica.
Los pesos son la maquinaria instalada.
Las activaciones son el material que atraviesa esa maquinaria en este momento.
Esto explica por qué cargar los pesos en la memoria de la GPU no cubre toda la memoria necesaria.
El cálculo también necesita espacio de trabajo.
Los modelos de lenguaje pueden utilizar además bastante memoria para una caché de claves y valores, o KV cache, que almacena información intermedia útil de los tokens ya procesados.
A medida que crece el contexto, esa caché también puede crecer.
Por tanto:
Los pesos caben en la VRAM
no significa automáticamente:
El modelo puede trabajar cómodamente en esa VRAM.
El sofá puede pasar por la puerta del piso.
Pero seguirás queriendo un sitio donde ponerte de pie.
¿Cambian los pesos mientras conversas con el modelo?
Normalmente:
No.
Cuando un modelo entrenado responde a un prompt, realiza inferencia.
Inferencia significa:
Utilizar los parámetros ya aprendidos para calcular una salida.
Los pesos se leen.
Normalmente no se reescriben porque hayas hecho una pregunta.
Por suerte.
De lo contrario, una conversación suficientemente extraña podría remodelar la red para siempre.
Una conversación crea un estado temporal: contexto, activaciones, caché KV, resultados de herramientas y otra información de trabajo.
Son distintos de los parámetros entrenados persistentes.
El resumen más sencillo es:
El entrenamiento cambia los pesos. La inferencia utiliza los pesos.
Esa frase explica muchísimo sobre la IA.
Ajuste fino: volver a cambiar los números
Un modelo preentrenado puede recibir más entrenamiento posteriormente.
Ese proceso se llama ajuste fino.
Imagina un modelo general que ya entiende el lenguaje.
Podrías ajustarlo con:
material jurídico,
terminología médica,
ejemplos de programación,
conversaciones de atención al cliente,
análisis financiero,
u otro ámbito especializado.
El entrenamiento vuelve a modificar parámetros para adaptar mejor el modelo a la nueva tarea.
El ajuste fino completo puede actualizar enormes cantidades de parámetros y necesitar importantes recursos de cálculo.
Otros métodos, como la adaptación de bajo rango, o LoRA, entrenan estructuras adicionales de parámetros mucho más pequeñas y dejan intacta la mayor parte del modelo original.
La distinción práctica es importante.
Dar un PDF al modelo durante una conversación normalmente cambia su contexto.
El ajuste fino cambia parámetros aprendidos.
Una cosa aporta información temporal.
La otra cambia el modelo entrenado.
El modelo no es todo el sistema
Supongamos que dos personas descargan exactamente el mismo modelo.
Mismo punto de control.
Mismos pesos.
Misma cuantización.
Una construye un excelente sistema de investigación.
La otra obtiene respuestas poco fiables con un formato precioso.
¿Cómo puede pasar?
Porque el modelo es solo un componente.
A su alrededor puede haber prompts, sistemas de recuperación, bases de datos, memoria, herramientas, navegadores, enrutamiento, permisos, validación y código de aplicación.
Este software circundante se llama a veces harness o entorno de agentes.
El harness normalmente no reescribe los pesos del modelo cada vez que llega una solicitud.
Controla qué información recibe el modelo, qué herramientas puede utilizar y qué ocurre con el resultado.
Mismos pesos.
Distinto entorno.
Distinto comportamiento.
El motor puede ser idéntico.
El vehículo no tiene por qué serlo.
¿Qué es un modelo de pesos abiertos?
Durante el entrenamiento, los parámetros cambian constantemente.
En momentos útiles, los desarrolladores guardan su estado actual.
Ese estado guardado se llama punto de control o checkpoint.
Un punto de control es, esencialmente, una instantánea del estado numérico aprendido del modelo en un momento determinado.
Si esos archivos de parámetros entrenados se ponen a disposición de otros para descargarlos, suele hablarse de un modelo de pesos abiertos.
Según la licencia, se puede ejecutar localmente, cuantizar, ajustar, estudiar, integrar en productos o redistribuir versiones derivadas.
Pero hay una distinción terminológica importante.
Pesos abiertos no significa automáticamente código abierto.
Un desarrollador puede publicar los pesos y mantener privados el conjunto de datos, partes del código de entrenamiento, la receta completa de entrenamiento u otros componentes.
Las licencias también pueden imponer restricciones.
Así que estas son dos preguntas distintas:
¿Puedo descargar los pesos entrenados?
y:
¿Está abierto todo el proceso de desarrollo del modelo?
Las respuestas pueden no coincidir.
Las palabras importan.
Especialmente cuando llegan los abogados.
Por qué los pesos abiertos cambiaron las reglas del juego
Entrenar desde cero un potente modelo fundacional puede requerir recursos enormes:
datos, clústeres de GPU, electricidad, ingeniería, tiempo y dinero.
Descargar los pesos entrenados permite que otra persona empiece después de que ese costoso entrenamiento ya haya ocurrido.
Recibes el estado numérico aprendido.
No reproduces toda la educación.
A los investigadores les permite estudiar.
A los desarrolladores les permite desplegar localmente y experimentar.
A las organizaciones les puede dar más control.
Y para los aficionados y usuarios con curiosidad técnica crea algo que no hace mucho habría sonado extraordinario:
Un modelo entrenado con infraestructura a escala industrial puede acabar convertido en archivos en un ordenador de tu casa.
El clúster de entrenamiento puede ocupar un centro de datos.
El punto de control terminado puede acabar en un SSD debajo de tu mesa, junto a tres cables USB que nadie recuerda haber comprado.
Todo un viaje para un tensor.
Lo que los pesos no son
Después de todo esto, es más fácil despejar varias ideas equivocadas.
Los pesos no son una base de datos.
No hay una fila que contenga:
capital_of_france = Paris
Un peso individual no suele ser un concepto legible para una persona.
Encontrar:
dentro de un tensor no te dice casi nada por sí solo.
Los pesos normalmente no cambian durante la inferencia ordinaria.
El entrenamiento los modifica.
La inferencia los utiliza.
Un peso no equivale normalmente a una característica.
El significado se distribuye entre muchos parámetros y capas.
La cantidad de parámetros no equivale a inteligencia.
La arquitectura importa.
Los datos de entrenamiento importan.
La optimización importa.
El entrenamiento posterior importa.
La gestión del contexto importa.
El entorno importa.
Un idiota de ochenta mil millones de parámetros seguiría siendo un idiota.
Simplemente necesitaría una GPU más cara.
Pesos frente a parámetros
La gente suele utilizar las palabras peso y parámetro casi indistintamente.
En una conversación corriente, suele estar bien.
Técnicamente, parámetro es el término más amplio.
Los pesos son parámetros.
Los sesgos, los valores de normalización y otros valores entrenables también pueden ser parámetros.
Así que, cuando alguien dice:
«Este es un modelo 70B»,
el significado más preciso es:
El modelo contiene aproximadamente setenta mil millones de parámetros aprendidos.
La mayoría están en grandes matrices aprendidas.
La gente seguirá llamándolos pesos.
Probablemente la civilización sobreviva.
¿Qué significa decir que un modelo «sabe» algo?
Ahora las matemáticas empiezan a rozar la filosofía.
Un modelo de lenguaje no contiene un bibliotecario en miniatura buscando hechos en estanterías.
No hay una diminuta base de datos SQL escondida dentro del Transformer.
En cambio, el entrenamiento moldea miles de millones de relaciones numéricas para que ciertos patrones de entrada tiendan a producir patrones útiles de salida.
Pregunta:
La capital de Francia es…
y la red aprendida favorece claramente:
París.
Pide código Python y aparecerá otro patrón de actividad interna.
Pregunta por la historia medieval y aparecerá otro.
Los mismos pesos persistentes participan en todos esos comportamientos.
Así que, cuando decimos que un modelo sabe algo, matemáticamente queremos decir algo más cercano a:
Sus parámetros aprendidos han llegado a una configuración que produce un comportamiento coherente con haber aprendido esa información o capacidad.
Si eso merece la misma palabra conocimiento que usamos para los seres humanos es una cuestión filosófica mucho mayor.
Probablemente sea mejor abordarla después de cenar.
Toda la historia en dos diagramas
Para quien quiera el esqueleto técnico sin repetir todo el recorrido, la inferencia puede resumirse así:
En lenguaje corriente:
Da una entrada a la red entrenada.
Pásala por capas que contienen pesos aprendidos.
Genera estados internos temporales.
Produce una salida.
El entrenamiento añade un segundo ciclo:
En lenguaje corriente:
Haz una predicción.
Mide cuánto se equivocó.
Calcula qué cambios en los parámetros deberían reducir el error.
Actualiza esos parámetros.
Luego repite.
Y repite.
Y repite.
O, en la versión más corta que sigue siendo técnicamente útil:
La inferencia utiliza los números. El entrenamiento cambia los números.
Todo lo demás es arquitectura, datos, optimización, hardware y escala.
Hay que reconocer que esos cuatro temas han dado trabajo a bastantes investigadores.
Por qué debería importarte aunque nunca entrenes nada
La mayoría de las personas que ejecutan IA local nunca calcularán un gradiente a mano.
No pasa nada.
La mayoría de quienes conducen tampoco mecanizan sus propios cigüeñales.
Pero entender los pesos explica muchas cosas con las que acaba encontrándose un usuario de IA con curiosidad técnica.
¿Por qué un modelo 8B ocupa varios gigabytes?
Porque hay que almacenar físicamente miles de millones de parámetros numéricos aprendidos.
¿Por qué Q4 requiere mucha menos memoria que la precisión de dieciséis bits?
Porque se utilizan menos bits para representar muchos de esos parámetros.
¿Por qué la cuantización puede cambiar ligeramente el comportamiento?
Porque cambió la precisión numérica.
¿Por qué el ajuste fino puede cambiar un modelo?
Porque el entrenamiento adicional cambia parámetros.
¿Por qué subir un PDF no enseña al modelo de forma permanente?
Porque el PDF cambia el contexto actual, no los pesos persistentes.
¿Por qué dos sistemas con los mismos pesos de modelo pueden comportarse de forma muy distinta?
Porque el modelo es solo una parte del entorno que lo rodea.
¿Y por qué es posible descargar un modelo de IA entrenado?
Porque buena parte de lo que produjo el entrenamiento puede conservarse como enormes colecciones de parámetros numéricos aprendidos.
La idea comenzó con diminutas neuronas matemáticas.
Luego llegaron los perceptrones entrenables.
La retropropagación hizo práctico el aprendizaje multicapa.
Las GPU aportaron cantidades extraordinarias de aritmética en paralelo.
Los Transformers reorganizaron el procesamiento del lenguaje.
La cantidad de parámetros pasó de millones a miles de millones y más allá.
La escala cambió casi hasta hacerse irreconocible.
El ciclo central siguió siendo sorprendentemente reconocible:
Haz una predicción.
Mide el error.
Calcula qué debería cambiar.
Cambia un poco los números.
Inténtalo de nuevo.
Hazlo suficientes veces, con suficientes datos, matemáticas, hardware y electricidad…
y, al final, los números empiezan a contestar.
Fuentes y lecturas
Compartir y republicar
Publicado por AI Model Green Zone.
Puedes republicar este artículo únicamente completo y sin modificaciones, mencionando a AI Model Green Zone e incluyendo un enlace activo y claramente visible al artículo original en nuestro sitio web.
Las traducciones, las versiones abreviadas y las adaptaciones requieren autorización específica.
Estas condiciones no limitan los usos permitidos por la ley.
El enlace público estará disponible cuando se configure la dirección pública del sitio.