Tokenización y embeddings en LLMs

Contenido del curso

Fundamentos de los LLMs

Componentes Avanzandos de los LLMs

Personalización y Optimización

Evaluación de Modelos

20
Benchmarks para evaluar y comparar modelos LLM
12:53 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:0019:12

Tokenización y embeddings en LLMs

Curso de Fundamentos de LLMs

Clase 4 de 20

Clase 4 / 20

king_token_id = tokenizer.convert_tokens_to_ids(["king"])[0]
king_embedding = model.embeddings.word_embeddings(torch.tensor([king_token_id]))

man_token_id = tokenizer.convert_tokens_to_ids(["man"])[0]
man_embedding = model.embeddings.word_embeddings(torch.tensor([man_token_id]))

woman_token_id = tokenizer.convert_tokens_to_ids(["woman"])[0]
woman_embedding = model.embeddings.word_embeddings(torch.tensor([woman_token_id]))

queen_token_id = tokenizer.convert_tokens_to_ids(["queen"])[0]
queen_embedding = model.embeddings.word_embeddings(torch.tensor([queen_token_id]))

# =========================
# 1) Imports
# =========================
from sklearn.decomposition import PCA
from sklearn.metrics.pairwise import cosine_similarity
import matplotlib.pyplot as plt
import numpy as np

# (Opcional, para heatmap bonito)
try:
    import seaborn as sns
    HAS_SNS = True
except:
    HAS_SNS = False


# =========================
# 2) Lista de animales (puedes editar)
# =========================
animals = [
    "dog", "cat", "gorilla",
    "lion", "tiger", "wolf", "fox",
    "horse", "cow", "pig",
    "elephant", "giraffe", "zebra",
    "monkey", "chimpanzee",
    "bear", "rabbit", "mouse",
    "eagle", "shark", "dolphin"
]

# Si quieres probar plural/sinónimos típicos:
# animals += ["dogs", "cats", "canine", "feline"]


# =========================
# 3) Helpers
# =========================
def cos(a, b):
    return cosine_similarity([a], [b])[0, 0]

def get_vectors(words, model):
    """Devuelve (valid_words, vectors) filtrando los que no existen en el modelo."""
    valid_words = []
    vectors = []
    for w in words:
        if w in model:
            valid_words.append(w)
            vectors.append(model[w])
        else:
            print(f"⚠️ Omitido (no está en el vocab): {w}")
    return valid_words, np.array(vectors)

def cosine_matrix(vectors):
    return cosine_similarity(vectors)

def print_top_similarities(words, vectors, target, topn=8):
    if target not in words:
        print(f"'{target}' no está disponible (no está en vocab o no está en la lista).")
        return
    idx = words.index(target)
    sims = cosine_similarity([vectors[idx]], vectors)[0]
    pairs = [(words[i], float(sims[i])) for i in range(len(words)) if i != idx]
    pairs.sort(key=lambda x: x[1], reverse=True)
    print(f"\nTop {topn} más similares a '{target}':")
    for w, s in pairs[:topn]:
        print(f"  {w:12s}  sim={s:.3f}")


# =========================
# 4) Cargar vectores (model debe existir)
# =========================
# Asumo que YA tienes cargado tu modelo, como en tu ejemplo:
# model = KeyedVectors.load_word2vec_format(...)

valid_animals, vectors = get_vectors(animals, model)

print(f"\n✅ Animales válidos: {len(valid_animals)}/{len(animals)}")
print(valid_animals)


# =========================
# 5) Similitudes: heatmap + top similares
# =========================
sim_mat = cosine_matrix(vectors)

# Heatmap
plt.figure(figsize=(12, 10))
if HAS_SNS:
    sns.heatmap(sim_mat, xticklabels=valid_animals, yticklabels=valid_animals, cmap="viridis")
else:
    plt.imshow(sim_mat, aspect="auto")
    plt.colorbar()
    plt.xticks(range(len(valid_animals)), valid_animals, rotation=90)
    plt.yticks(range(len(valid_animals)), valid_animals)
plt.title("Cosine Similarity Heatmap — Animals")
plt.tight_layout()
plt.show()

# Top similares de algunos targets
for target in ["dog", "cat", "gorilla"]:
    print_top_similarities(valid_animals, vectors, target, topn=10)


# =========================
# 6) PCA 3D (como tu ejemplo)
# =========================
pca = PCA(n_components=3)
reduced = pca.fit_transform(vectors)

coords = {word: reduced[i] for i, word in enumerate(valid_animals)}

fig = plt.figure(figsize=(11, 9))
ax = fig.add_subplot(111, projection="3d")

# puntos
for word, vec in coords.items():
    ax.scatter(vec[0], vec[1], vec[2])
    ax.text(vec[0], vec[1], vec[2], word, fontsize=9)

# Conecta dog-cat-gorilla si existen
def connect(a, b, color="red"):
    if a in coords and b in coords:
        va, vb = coords[a], coords[b]
        ax.plot([va[0], vb[0]], [va[1], vb[1]], [va[2], vb[2]], color=color)
        mid = (va + vb) / 2.0
        # similitud real en el espacio original (no PCA)
        ax.text(mid[0], mid[1], mid[2],
                f"sim={cos(model[a], model[b]):.2f}", color=color)

connect("dog", "cat", color="red")
connect("dog", "gorilla", color="blue")
connect("cat", "gorilla", color="green")

ax.set_title("3D PCA — Animal Word Embeddings")
ax.set_xlabel("PCA 1"); ax.set_ylabel("PCA 2"); ax.set_zlabel("PCA 3")
plt.show()


# =========================
# 7) (Bonus) Analogías tipo "king-man+woman"
# =========================
# Ejemplo: dog - puppy + kitten ≈ cat (si existen)
def analogy(a, b, c, topn=5):
    """
    Devuelve palabras similares a: a - b + c
    """
    for w in [a,b,c]:
        if w not in model:
            print(f"⚠️ No existe en vocab: {w}")
            return
    v = model[a] - model[b] + model[c]
    # topn+1 por si sale el mismo término
    sims = model.similar_by_vector(v, topn=topn+3)
    # filtra a,b,c si aparecen
    filtered = [(w,s) for (w,s) in sims if w not in [a,b,c]]
    print(f"\nAnalogía: {a} - {b} + {c} ≈ ?")
    for w,s in filtered[:topn]:
        print(f"  {w:12s}  sim={s:.3f}")

analogy("dog", "puppy", "kitten", topn=8)
analogy("cat", "kitten", "puppy", topn=8)

Resumen

Los modelos de lenguaje no leen palabras como tú y yo. Las traducen a números, las ubican en un espacio matemático y operan sobre ellas. Entender ese viaje (de tokenización, vectorización y embedding) es la base para trabajar con cualquier LLM como GPT, Claude o Gemini.

Así como un computador convierte cada letra en un número binario, un LLM convierte cada palabra en un vector dentro de un espacio de cientos o miles de dimensiones. Y ahí ocurre la magia.

¿Qué es la tokenización en un LLM y cómo funciona?

La tokenización es el primer paso: partir el texto en unidades mínimas llamadas tokens. Toma la frase Hola, ¿cómo estás?. Con tokenización por palabra, obtienes tres tokens: hola, cómo y estás [0:50].

Existen otros métodos, como la tokenización por subpalabras, y cada modelo elige el suyo. Por eso, la misma frase puede tener distinto número de tokens según el proveedor.

¿Por qué un mismo texto tiene distinto número de tokens en cada LLM? Porque cada modelo usa su propio tokenizer. Hola, ¿cómo estás? da 3 tokens en GPT, Gemini y Grok, pero 12 en Claude [13:30].

¿Cómo se ven los tokens en herramientas reales?

Una forma práctica de visualizarlo es con GPT For Work, un tokenizer que muestra cómo cada modelo separa el texto y asigna un Token ID único a cada pieza [13:00]. Ese ID es el puente entre la palabra y su representación numérica.

¿Qué es la vectorización y por qué importa en los LLM?

Después de tokenizar, cada token recibe un vector inicial, casi siempre aleatorio. Para el ejemplo, hola podría ser (1,2), cómo (1,3) y estás (3,4) [1:45].

Los vectores no son solo coordenadas decorativas. Permiten medir distancias, hacer restas y sumas, y comparar qué tan parecidas son dos palabras. Esa propiedad es la que abre la puerta al siguiente paso.

¿Qué es un embedding y cómo aprende a representar palabras?

Un embedding es el resultado de entrenar un modelo pequeño que reorganiza esos vectores en el espacio. Su objetivo: agrupar palabras con significados parecidos en zonas cercanas [2:50].

Las palabras de saludo terminan juntas. Los nombres de monarcas también. Y aquí viene lo interesante: como ahora son vectores en un espacio matemático, puedes operar con ellos.

El ejemplo clásico: rey, hombre, mujer y reina

Si restas el vector de hombre al de rey y sumas el de mujer, obtienes un vector muy cercano a reina [3:30]. En el Colab del reto, esa operación da una similitud por coseno de 0.73 con queen, mientras que king y queen tienen 0.65. El resultado queda más cerca de reina que el propio rey.

¿Por qué no es exacto? Porque los embeddings tienen 300 dimensiones (o más) y la operación solo modifica una característica, el género del regente. Las otras 299 siguen ahí.

¿Qué es la similitud por coseno? Es una métrica que mide qué tan cerca están dos vectores en el espacio n dimensional. Cuanto más cerca de 1, más parecidas son las palabras [9:30].

¿Cuántas dimensiones tiene un embedding y por qué tantas?

El lenguaje humano es complejo: español, inglés, mandarín, japonés, jergas, contextos. Reducirlo a dos o tres dimensiones es imposible. Por eso los embeddings reales usan entre 500 y 1000 dimensiones [6:10].

El dataset Word2Vec Google News 300 trabaja con 300 dimensiones y existe una versión con 71000 palabras que pesa varios gigabytes [16:50]. Para visualizarlos, herramientas como TensorFlow Projector proyectan ese espacio n dimensional a tres dimensiones usando PCA (Principal Component Analysis), una técnica de sklearn que reduce dimensionalidad conservando la información más relevante [15:30].

¿Qué muestra TensorFlow Projector con palabras como king o queen?

Al seleccionar king en el dataset Word2Vec de 10000 palabras, los vecinos más cercanos son hijo, reina, trono, emperador, Henry, príncipe y los ordinales tercero, sexto y séptimo [9:00]. Para queen, aparecen Elizabeth, Ana, María, Victoria y rey [10:30].

Las palabras viven en barrios semánticos. Y cada modelo construye sus propios barrios.

¿Por qué los embeddings de OpenAI, Gemini y Claude no son intercambiables?

Cada compañía entrena con técnicas y datasets distintos. Eso significa que el espacio vectorial de OpenAI no coincide con el de Gemini o Claude [12:00]. No puedes mezclar embeddings entre proveedores.

Piénsalo así: cada LLM es un cerebro único que organizó el lenguaje a su manera durante el entrenamiento.

Cada modelo tiene su propio tokenizer.
Cada modelo tiene su propio espacio de embeddings.
Las distancias entre palabras varían según el dataset y la técnica.

¿Cómo replicar embeddings en código con Python y Gensim?

En el Colab del reto, el flujo es directo. Instalas Gensim, cargas el dataset Word2Vec Google News 300 y consultas el embedding de cualquier palabra como un diccionario: model['apple'] devuelve un vector de 300 dimensiones [15:00].

Luego con sklearn.decomposition aplicas PCA para bajar a tres dimensiones, calculas la similitud por coseno y graficas con matplotlib y Axes3D. La función most_similar te devuelve las palabras más cercanas a un vector dado [19:00].

Al probar con el resultado de king - man + woman, las 10 palabras más similares incluyen king, queen, monarca, princesa, sultanes y el consorte de la reina. Te quedas en la misma vecindad semántica aunque hayas hecho una operación matemática.

Ahora te toca a ti: usa el Colab, cambia las palabras y busca qué animales se parecen más al gato o al perro. Cuéntanos en los comentarios qué vecindad descubriste.

Comentarios (122)122 comentarios

David Stiwen Rugeles Cano

Hace un año

Conceptos clave:

Tokenizador: algoritmo que parte las palabras en subpalabras o silabas y a su vez forma un vector con estas

embedding: el resultado de pasar los tokens por una red neuronal ya pre-entrenada en categorizar tokens por su significado o atributos en un espacio de N dimensiones

si en un caldo los tokens son todas las verduras picadas, los embeddings serian el sabor que identifica ese trozo o cucharada (grupos de conceptos), de esa forma una papa sabe "parecido" a una yuca (tokens semánticamente próximos en el espacio vectorial), pero muy distinto a un trozo de cebolla, esa analogía me sirvió

si quieren verlo de forma más visual, word2beck fue uno de los primeros generadores de embedings, el que se ve en la clase es bert pero es casi la misma idea

Luis Carlos Parra Raffán

Esto está increíble !

Carmen Lucia Tovar Castro

el ejemplo con el caldo fue mucho más facil para entender buen apunte

Rolando Osorio

se los dejo resumido y más fácil de entender:

Esteban Vasquez Valencia

Hace 2 meses

Gracias por compartir. Qué buena manera de explicarlo. Me ha servido mucho para interiorizar los conceptos.

Jhon Maldonado

Los conceptos más importantes de la clase incluyen:

Tokenización: Proceso de dividir texto en partes más pequeñas (tokens), como palabras o subpalabras, para su análisis.
Vectorización: Asignación de vectores a cada token, permitiendo que las palabras se representen numéricamente.
Embeddings: Técnica que organiza los vectores en un espacio vectorial, capturando relaciones semánticas. Permite realizar operaciones matemáticas entre palabras, como sumar o restar vectores.
Transformers: Arquitectura utilizada en los LLMs que facilita el procesamiento de texto mediante atención y paralelismo.

Estos conceptos son fundamentales para comprender cómo funcionan los modelos de lenguaje.

Juan Felipe Ángel Martínez Bernal

Es interesante ir viendo como se relacionan las palabras:

Marco Enrique Cotera Muñoz

eL Vector COMO esta mal graficado, lo graficastes como [2,1] eso no importoa?

Diego Rebolledo

Mario David Alvarez Vallejo

Venía a comentar lo mismo.

Gabriel Obregón

🧠 Cómo Entienden los LLMs (como ChatGPT) el Lenguaje Humano

🔹 1. Procesos Clave

Los LLMs comprenden el lenguaje mediante tres pasos fundamentales:

Tokenización: dividir el texto en unidades manejables.
Vectorización: convertir cada token en un conjunto de números.
Embeddings: organizar esos números para reflejar significados.

🔹 2. ¿Qué es la Tokenización?

📌 Definición: Separar un texto en partes más pequeñas llamadas tokens.

🧩 Ejemplo: "hola ¿cómo estás?" →

Token 1: "hola"
Token 2: "cómo"
Token 3: "estás"

🔍 Puede hacerse por:

Palabras
Subpalabras
Fragmentos

🔹 3. ¿Qué es la Vectorización?

📌 Definición: Asignar un vector numérico a cada token.

🧮 Ejemplo:

"hola" → (1, 2)
"cómo" → (1, 3)
"estás" → (3, 4)

📈 Visualización: Se puede representar en un plano para ver las relaciones entre palabras.

🔹 4. ¿Qué es un Embedding?

📌 Definición: Optimizar la posición de los vectores para reflejar similitud de significados.

🔁 Ejemplo vectorial: Rey - Hombre + Mujer = Reina

🎯 Esto permite al modelo "entender" relaciones abstractas entre conceptos.

🔹 5. Aplicación Práctica en Python

🧰 Librerías necesarias

transformers (Hugging Face)
torch (PyTorch)

✂️ Tokenización

from transformers import BertTokenizer

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

tokens = tokenizer.tokenize("hola, ¿cómo estás?")

🔗 Embeddings

from transformers import BertModel

import torch

model = BertModel.from_pretrained('bert-base-uncased')

king = model.embeddings.word_embeddings(torch.tensor(tokenizer.convert_tokens_to_ids(["king"])))

queen = model.embeddings.word_embeddings(torch.tensor(tokenizer.convert_tokens_to_ids(["queen"])))

🔍 Medir Similitud

cosine_similarity = torch.nn.CosineSimilarity(dim=0)

similitud = cosine_similarity(king, queen)

📊 Resultado:

Cerca de 1 → alta similitud
Cerca de -1 → baja similitud

Luis Fernando Bustos Ramírez

No pude acceder al colab que comparto el profe, pero aproveche para intentar hacerlo a la par del profe para entenderle mejor a cada linea de código, si alguien mas tiene este problema con el documento les comparto el mio por si les es de utilidad

Sebastián Corzo Salcedo

Gracias Luis! Gran aporte!

Miguel Angel Reyes Moreno

Me llamó mucho la atención que se usara la 'similitud del coseno', me estaba preguntando porqué coseno y no seno. La respuesta está en la geometría y es algo un poco largo y complicado.

Les comparto el prompt que usé con deepseek y me dio una respuesta interesante: "Estoy analizando un script de jupyter notebooks para analizar la similitud entre palabras, que es una función 'core' de los grandes modelos de lenguajes (o LLMs en inglés). Me llamó la atención que usan una función de pytorch llamada CosineSimilarity

¿Por qué se usa el coseno aquí? ¿Por qué no se usa el seno?"

En resumen, el coseno mide orientación y dirección (lo que nos importa cuando buscamos similitud), pero el seno mide altura y dirección (no es útil en este caso).

Guillermo Vidal Astudillo

Hace 3 meses

Hola, muy buena reflexión. Me hiciste pensar en lo siguiente: creo que estás mezclando la aplicación de la trigonometría en la física con su uso en el álgebra lineal.

En física tus ideas son correctas, pero en álgebra lineal la perspectiva cambia cuando se trabaja con alta dimensionalidad (a diferencia de la física clásica, que suele usar solo 2 dimensiones, como por ejemplo en el lanzamiento de proyectiles).

En los LLMs, el coseno mide la alineación, es decir, la similitud. Si dos vectores apuntan en el mismo sentido, tienen 0 grados entre sí, y el coseno de 0 es 1. En el caso de 180 grados, el resultado sería -1, indicando una menor similitud.

Por otro lado, aplicando el álgebra lineal, el seno mide la ortogonalidad (la desconexión). Si dos palabras tienen el mismo vector, tendrían 0 grados; como el seno de 0 grados es 0, el sistema interpretaría que la similitud es nula. El seno alcanza su valor máximo en 90 grados, o sea, cuando los vectores son perpendiculares. Por lo tanto, si se ocupara el seno, el modelo priorizaría a las palabras que tienen menos sentido o relación entre sí.

William Cortés

Hace 10 meses

El link del colab:

Nahun Fernando Oseguera Villalobos

Hace 4 meses

gracias, que tomen nota en platzi.

Gustavo Navarro

Hace 6 meses

yo sé que solo es un ejemplo, pero el primer vector quedó mal dibujado con respecto a los demás. Se supone que es [1, 2] donde es 1 en X y 2 en Y, pero está trucado. @platzi

Héctor Salinas

Hace 5 meses•editado

Estaba escribiendo justo lo mismo, pero a modo de ejemplo se entendió el concepto que quiso decir. Aunque me parece muy raro que no haya editores eficientes en la revisión de los videos

Daniel Dobles

Hace 5 meses

Era un ejemplo bro ni siquiera tiene el grafico la cuadricula dimencional. Es un ejemplo para que entiendas el conceptos se supone que las bases de algebra lineal ya las debes de dominar. Lo importante era el concepto entender el core de ese concepto es la clave más que la "matemáticas" detrás. Una cosa es "saber" matemáticas y otra "saber usarlas". La idea del ejemplo era la segunda.

Las 300 dimensiones del modelo word2vec-google-news-300 no tienen exactamente una interpretación humana, es decir: una dimensión no significa género. Cada dimensión es abstracta para el humano pero no para una máquina.

Cristian Salinas

Creo que hay un error aqui, en la linea 4 man_embedding deberia usar man_token_id y esta usando king_token_id.

DANIEL VILLALOBOS

de verdad que si creo que deberia ser asi pero igual lo corregi y el resultado fue el mismo tensor(0.6469, grad_fn=<SelectBackward0>)

Juan Sebastian Gelves Badillo

Yo también lo corregí y da el mismo resultado.

Claudia Iliana Padilla Magaña

Hace un mes

Tokenizer and token counter (GPT, Claude, Gemini, Grok) | GPT for Work

FERNANDO OROZCO

probablemente no vas a encotrar el colab del profesor, simplemente crea uno logueandote en drive y entrando a , limpias toda pantalla y empizas a agregar codigo.

O tambien puedes descargar el archivo "Tokenization" en los recursos, abrirlo con VS Code e instalar al extention de Colab en VS CODE.

Yovanny Moreno Mena

Perfecto y en el paso donde pone model['apple']

el modelo se carga en la variable gensim_model

Entonces a mi me funciuona con el vector de la palabra 'apple', así: gensim_model['apple'] y carga el embedding.

Ricardo Garcia

Hace 9 meses

Resumen de la lección:

Tokenización: Proceso de dividir el texto en unidades básicas (tokens)
Vectorización: Conversión de cada token en un vector numérico con un identificador único.
Embedding: Proceso de entrenamiento que posiciona los vectores en el espacio para que palabra con significados similares queden cerca.
Dimensionalidad: Los embeddings reales tienen cientos o miles de dimensiones para capturar la complejidad del lenguaje.
Operaciones vectoriales: Permiten realizar operaciones matemáticas con conceptos (ej: Rey - Hombre + Mujer = Reina).
Similitud por coseno: Métrica para medir cercanía entre vectores; valores cercanos a 1 indican mayor similitud.
Reducción de dimensionalidad: Técnicas como PCA permiten visualizar espacios de alta dimensionalidad en 2D o 3D.

Emilio Jesus Nuñez Pineda

Hace 8 meses

To compare many animals

Sebastian Fernandez

Yo hice la prueba entre 20 animales y mas o menos me dio esto.

Omar Blanco

Hace 7 meses

Hola Sebastian Como lograste esta grafica que utilizaste?

David Rangel

Dejaré esto por aquí:

Juan Manuel Tejada Fajardo

gracias

Jorge Arias Argüelles

El "embedding" es un proceso en el que las palabras o conceptos se representan como vectores en un espacio multidimensional. Este procedimiento permite que los modelos de lenguaje, como los LLMs, comprendan relaciones semánticas entre palabras. Por ejemplo, palabras con significados similares estarán más cerca unas de otras en este espacio vectorial. Los embeddings son fundamentales para mejorar la capacidad del modelo para realizar operaciones matemáticas y optimizar su rendimiento en tareas de procesamiento de lenguaje natural.

Irving Daniel Reyes Elizondo

¿Alguien más no pudo acceder al Google Colab?

Eloy Chávez Dev

Acabo de acceder sin problema con el link de las lecturas recomendadas el último.

El archivo de colab que dejaron en esta clase tiene el mismo título pero es un código completamente diferente

Fundamentos de los LLMs

Funcionamiento interno de los grandes modelos de lenguaje

Qué construirás al terminar el curso de LLMs

Historia de la inteligencia artificial desde Turing hasta GPT-4

Tokenización y embeddings en LLMs

Qué es y cómo aprende un MLP

Cómo funciona la atención en GPT-2

Fundamentos de PyTorch para modelos de machine learning

Componentes Avanzandos de los LLMs

Construye GPT-2 desde cero con PyTorch

Qué es RoPE y cómo mejora GPT

Integración de Rope en GPT-2 con PyTorch

Leyes de escalado y modelos multimodales en inteligencia artificial

Cómo se entrena un LLM paso a paso

Mixture of Experts: cómo funciona MoE

RAM y VRAM para ejecutar LLMs en local

Instalación de Olama y configuración de clúster local con ExoLabs

Personalización y Optimización

Fine tuning de GPT-4o con datos propios

Fine Tuning con LoRA en Colab gratis

Despliegue de modelos fine-tuned con Hugging Face Endpoints

Cómo funciona la cuantización de LLMs

Evaluación de Modelos

Benchmarks para evaluar y comparar modelos LLM

Tokenización y embeddings en LLMs

Progreso del curso

Fundamentos de los LLMs

Componentes Avanzandos de los LLMs

Personalización y Optimización

Evaluación de Modelos

Recursos