¿Qué modelos se usan en esta fase?

• Attention Mechanism: El modelo asigna «pesos» a cada token para saber cuáles son más importantes. «mejor» recibe más atención que «el».
• Transformers (BERT, RoBERTa): Analizan la relación entre todas las palabras simultáneamente (no secuencialmente).
• Intent Classification Models: Modelos fine-tuned específicamente para clasificar intenciones (informativa, transaccional, comparativa, navegacional).

Ejemplo con Hugging Face (BERT fine-tuned para intenciones):

from transformers import pipeline
classifier = pipeline("text-classification", model="nickmuchi/intent-classification")
result = classifier("El mejor contenido de SEO para tu web")
print(result)  # → [{'label': 'COMPARATIVE', 'score': 0.87}]

Limitación del tokenizador de NLTK (word_tokenize): Solo divide por espacios y puntuación. No maneja palabras desconocidas.

Solución: Subword Tokenization (usado por GPT, BERT)

En lugar de dividir solo por palabras, divide en fragmentos de palabras (subwords). Ejemplo con «tokenización»:

"tokenización" → ["token", "ización"]

Ejemplo con Byte Pair Encoding (BPE):

from tokenizers import Tokenizer
from tokenizers.models import BPE

# Entrenar tokenizador BPE
tokenizer = Tokenizer(BPE())
# (código de entrenamiento simplificado)

# Tokenizar frase
frase = "El mejor contenido de SEO para tu web"
tokens_bpe = tokenizer.encode(frase).tokens
print("Tokens BPE:", tokens_bpe)

Ventajas del subword tokenization:

• ✅ Maneja palabras desconocidas (out-of-vocabulary)
• ✅ Reduce tamaño del vocabulario
• ✅ Mejor para idiomas con muchas variaciones (español, alemán)
• ✅ Usado por GPT-4, BERT, Llama, Gemini

Word2Vec (Mikolov et al., 2013) – usado por spaCy

• Arquitectura: Skip-gram con negative sampling
• Dimensiones: 300
• Entrenamiento: Common Crawl (800M+ tokens)
• Limitación: Cada palabra tiene UN vector fijo (no captura polisemia: «banco» (entidad) vs «banco» (asiento))

BERT (Devlin et al., 2018) – Embeddings contextuales

from sentence_transformers import SentenceTransformer

# Modelo multilingüe (incluye español)
model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

# Obtener embedding contextual
embedding = model.encode("El mejor contenido de SEO para tu web")
print(f"Dimensionalidad del embedding BERT: {embedding.shape}")
# Resultado: (384,)

Ventajas de BERT sobre Word2Vec:

• ✅ Contextual: «banco» tiene vector diferente en «banco de la plaza» vs «banco de inversión»
• ✅ Bidireccional: considera palabras antes y después simultáneamente
• ✅ Fine-tuneable para tareas específicas

¿Qué es Self-Attention? Es el mecanismo que permite a la IA «prestar atención» a diferentes palabras de la frase simultáneamente.

Visualización de atención (BERT):

# Ejemplo con BERT (usando transformers library)
from transformers import BertTokenizer, BertModel
import torch

tokenizer = BertTokenizer.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased')
model = BertModel.from_pretrained('dccuchile/bert-base-spanish-wwm-uncased')

frase = "El mejor contenido de SEO para tu web"
inputs = tokenizer(frase, return_tensors="pt")
outputs = model(**inputs)

# Las matrices de atención (12 capas × 12 cabezas)
attention = outputs.attentions  # (num_layers, batch, num_heads, seq_len, seq_len)
print(f"Número de capas de atención: {len(attention)}")
print(f"Número de cabezas por capa: {attention[0].shape[1]}")

¿Qué hace esto? BERT tiene 12 capas de atención, cada una con 12 cabezas. Cada cabeza aprende a «prestar atención» a diferentes relaciones semánticas.

• Algunas cabezas atienden a relaciones sujeto-verbo
• Otras atienden a modificadores (adjetivos como «mejor»)
• Otras atienden a relaciones semánticas distantes

Zero-shot classification (sin ejemplos de entrenamiento):

from transformers import pipeline

classifier = pipeline("zero-shot-classification", 
                      model="facebook/bart-large-mnli")

frase = "El mejor contenido de SEO para tu web"
candidatos = ["informativa", "comparativa", "transaccional", "navegacional"]

resultado = classifier(frase, candidate_labels=candidatos)
print(resultado['labels'][0])  # 'comparativa'
print(resultado['scores'][0])  # 0.87

Fine-tuning para tu dominio específico:

# Entrenar un clasificador de intenciones para tu nicho
# 1. Recopila 1000+ consultas de tu sector etiquetadas por intención
# 2. Fine-tune un modelo BERT multilingüe
# 3. Evalúa con métricas (precisión, recall, F1)

from transformers import AutoModelForSequenceClassification, Trainer

model = AutoModelForSequenceClassification.from_pretrained(
    "dccuchile/bert-base-spanish-wwm-uncased",
    num_labels=4  # 4 intenciones
)
# ... código de fine-tuning

¿Qué es RAG? Es la técnica que usan ChatGPT, Gemini y Perplexity para buscar información actualizada en tiempo real.

Flujo RAG:

1. Consulta del usuario → "El mejor contenido de SEO para tu web"
2. Generar embedding de la consulta → (vector de 384 dimensiones)
3. Buscar en Vector Database (Pinecone, Weaviate, Chroma) los documentos más cercanos
4. Recuperar chunks de documentos relevantes
5. Inyectarlos en el prompt del LLM
6. Generar respuesta con contexto actualizado

# Ejemplo con ChromaDB
import chromadb
from sentence_transformers import SentenceTransformer

client = chromadb.Client()
collection = client.create_collection("articulos_seo")

model = SentenceTransformer('paraphrase-multilingual-MiniLM-L12-v2')

# Indexar documentos
collection.add(
    embeddings=[model.encode(doc['titulo']).tolist() for doc in documentos],
    documents=[doc['titulo'] for doc in documentos],
    metadatas=documentos
)

# Buscar
query_embedding = model.encode("El mejor contenido de SEO para tu web").tolist()
results = collection.query(query_embeddings=[query_embedding], n_results=3)

Limitación de la similitud coseno (bi-encoder): Calcula relevancia de cada documento por separado, pierde interacción entre consulta y documento.

Solución: Cross-encoders (re-ranking)

from sentence_transformers import CrossEncoder

# Modelo cross-encoder para re-ranking
model = CrossEncoder('cross-encoder/ms-marco-MiniLM-L-6-v2')

# Consulta y documentos candidatos
query = "El mejor contenido de SEO para tu web"
candidates = [
    "Guía de SEO para principiantes",
    "Cómo crear contenido que posiciona",
    "Receta de paella valenciana"
]

# Calcular puntuaciones (consulta + documento juntos)
scores = model.predict([(query, doc) for doc in candidates])

print("Puntuaciones cross-encoder:")
for doc, score in zip(candidates, scores):
    print(f"  {doc}: {score:.4f}")
# Resultado esperado: el documento relevante recibe ~8, el irrelevante ~-5

Ventajas del cross-encoder:

• ✅ Captura interacciones complejas consulta-documento
• ✅ Mayor precisión que similitud coseno
• ✅ Usado en sistemas de búsqueda avanzados (Google, Bing, Perplexity)
• ❌ Más lento (requiere re-ranking de top-k candidatos)

¿Cómo infiere realmente un LLM (GPT-4, Llama)?

Un LLM es un modelo autorregresivo que predice la siguiente palabra (token) basándose en las anteriores.

import torch
from transformers import AutoModelForCausalLM, AutoTokenizer

modelo = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-chat-hf")
tokenizer = AutoTokenizer.from_pretrained("meta-llama/Llama-2-7b-chat-hf")

prompt = "El mejor contenido de SEO para tu web debe tener"
inputs = tokenizer(prompt, return_tensors="pt")

# Generación (inferencia) - predice siguiente token
with torch.no_grad():
    outputs = modelo.generate(**inputs, max_new_tokens=50)

respuesta = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(respuesta)

Probabilidad de cada token:

# Ver la probabilidad de los siguientes posibles tokens
with torch.no_grad():
    logits = modelo(**inputs).logits[0, -1, :]
    probs = torch.softmax(logits, dim=-1)
    top_tokens = torch.topk(probs, 5)

print("Top 5 siguientes palabras posibles:")
for i in range(5):
    token = tokenizer.decode([top_tokens.indices[i].item()])
    prob = top_tokens.values[i].item()
    print(f"  '{token}' con probabilidad {prob:.2%}")

¿Qué significa esto? La IA no «piensa», sino que calcula la palabra más probable estadísticamente.

¿Cómo controlar la creatividad vs determinismo de la IA?

from transformers import pipeline

generator = pipeline('text-generation', model='meta-llama/Llama-2-7b-chat-hf')

prompt = "El mejor contenido de SEO para tu web"

# Temperature baja (0.2) → más determinista, repetitivo
respuesta_determinista = generator(prompt, max_length=100, temperature=0.2, do_sample=True)

# Temperature alta (1.5) → más creativo, variado
respuesta_creativa = generator(prompt, max_length=100, temperature=1.5, do_sample=True)

# Top-p (nucleus sampling): solo considera tokens que suman 90% de probabilidad
respuesta_top_p = generator(prompt, max_length=100, top_p=0.9, do_sample=True)

# Top-k: solo considera los k tokens más probables
respuesta_top_k = generator(prompt, max_length=100, top_k=50, do_sample=True)

Parámetros de decodificación:

• Temperature: Controla la aleatoriedad (baja = predecible, alta = creativo)
• Top-k: Solo considera los k tokens más probables
• Top-p (nucleus sampling): Solo considera tokens hasta alcanzar p% de probabilidad acumulada
• Repetition penalty: Penaliza repetición de tokens (evita bucles)

Más allá del texto: Respuestas multimodales

Modelos como GPT-4o, Gemini, Claude pueden generar:

• 📊 Tablas (HTML, Markdown, CSV)
• 📈 Gráficos (código Python para visualización)
• 🖼️ Imágenes (DALL-E, Imagen integrados)
• 🎵 Audio (respuestas habladas)
• 💻 Código ejecutable (HTML, Python, SQL)

# Ejemplo: Generar tabla en formato HTML
tabla_html = """

  
Factor SEO
Importancia
  
Intención de búsqueda
Alta
  
Estructura H1-H2-H3
Media-Alta
  
Palabras clave
Media

"""

# Ejemplo: Generar código para visualización
codigo_grafico = """
import matplotlib.pyplot as plt
import numpy as np

factores = ['Intención', 'Estructura', 'Keywords', 'Autoridad']
importancia = [9, 8, 7, 9]

plt.bar(factores, importancia)
plt.title('Factores SEO para contenido de calidad')
plt.show()
"""