Tipos de IA#

• IA General (AGI): Capaz de realizar cualquier tarea cognitiva que un ser humano pueda hacer. Aún no existe.

Sam Altman; fundador de OpenAI; ha estado hablando de que la IA General es el objetivo final de su empresa, pero actualmente estamos lejos de conseguirla a pesar de los trillones de dólares invertidos en la empresa.

• IA Especializada (Narrow AI): Diseñada para realizar tareas específicas con alto nivel de eficiencia. Es lo que usamos hoy.
• IA Supervisada: Aprende de datos etiquetados para predecir resultados específicos.
• IA No Supervisada: Aprende de datos no etiquetados para encontrar patrones ocultos.

Aplicaciones Actuales#

• Asistentes Virtuales: ChatGPT, Claude, Gemini - Chatbots que responden preguntas y realizan tareas complejas.
• Sistemas de Recomendación: Netflix, Spotify, Amazon - Sugieren contenido personalizado.
• Análisis de Datos: IA que procesa grandes volúmenes de información para extraer insights valiosos.
• Generación de Código: GitHub Copilot, CodeLlama, Claude Code, DeepSeek Code - Asisten en programación, son los llamados “agentes de programación IA”.

Cómo Funciona GPT#

1
def self_attention(query, key, value):
2
    """
3
    query: Lo que buscamos
4
    key: Contra qué comparamos
5
    value: Lo que obtenemos
6
    """
7
    attention_scores = query @ key.T  # Producto punto
8
    attention_weights = softmax(attention_scores)  # Normalizar
9
    output = attention_weights @ value  # Weighted sum
10
    return output

Ejemplo: Procesamiento de Texto con GPT#

1
def process_with_gpt(input_text):
2
    # 1. Tokenización
3
    tokens = tokenize(input_text)  # ["¿Qué", "es", "la", "IA", "?"]
4

5
    # 2. Embeddings + Posición
6
    embeddings = token_to_embedding(tokens)
7
    positional_encoding = add_position_info(embeddings)
8

9
    # 3. Múltiples capas Transformer
10
    x = positional_encoding
11
    for layer in transformer_layers:
12
        x = layer.self_attention(x)
13
        x = layer.feed_forward(x)
14

15
    # 4. Generación
16
    next_token_probs = predict_next_token(x)
17
    return next_token_probs

Flujo visual:

1
Pipeline de GPT:
2
  Entrada: "¿Qué es la IA?"
3
    ↓
4
  Tokenización: ["¿Qué", "es", "la", "IA", "?"]
5
    ↓
6
  Embeddings + Posición
7
    ↓
8
  Capas Transformer (x12 o más)
9
    ↓
10
  Predicción: "La inteligencia artificial es..."

Concepto Fundamental#

Imagina un hospital con especialistas:

• Un cardiólogo para problemas del corazón
• Un neurólogo para problemas cerebrales
• Un traumatólogo para lesiones

En MoE, un “gating network” (red de enrutamiento) decide qué expertos consultar según la entrada.

Arquitectura MoE#

1
Input → Gating Network → Expert #1 (Activado)
2
                      → Expert #2 (Inactivo)
3
                      → Expert #3 (Activado)
4
                      → Expert #4 (Inactivo)
5
                      → ...
6
                      → Expert #N (Inactivo)
7

8
Solo 2-4 expertos activos de N totales

Ventajas de MoE#

1. Activación Dispersa (Sparse Activation)

   • Solo 3-6% de los parámetros se activan por token
   • Ahorro masivo de computación y energía
   • Reducción del 95.3% en consumo energético vs modelos densos

2. Escalabilidad Lineal

   • Puedes añadir más expertos sin crecimiento cuadrático en costo
   • Ejemplo: Escalando de 16 a 128 expertos
     • Capacidad: 8x aumento
     • Costo: Solo 2.1x aumento
   • Retorno: 3.8x mejor eficiencia

3. Especialización por Dominio

   • Cada experto se especializa en dominios específicos
   • Mayor precisión en tareas nicho
   • Precisión tareas especializadas: 94.7% (MoE) vs 89.2% (dense)

DeepSeek-V3 (2024)#

Especificaciones:

• Total de parámetros: 671 mil millones (671B)
• Parámetros activos por token: 37 mil millones (37B)
• Porcentaje de activación: ~5.5%
• Ahorro de energía: 95.3% vs modelos densos equivalentes

¿Cómo Funciona DeepSeek?#

1. Segmentación Fina de Expertos

   • Divide a los expertos en subredes muy especializadas
   • Permite combinaciones flexibles de activación

2. Expertos Compartidos

   • Algunos expertos están siempre activos (conocimiento común)
   • Otros expertos se activan dinámicamente según la tarea

3. Multi-head Latent Attention (MLA)

   • Reduce cuellos de botella en memoria
   • Mejora la inferencia y eficiencia

Comparación de Rendimiento#

Ejemplo: Routing en DeepSeek#

1
class DeepSeekMoE:
2
    def __init__(self, num_experts=128):
3
        self.experts = [Expert(i) for i in range(num_experts)]
4
        self.gating_network = GatingNetwork()
5

6
    def forward(self, input_token):
7
        # 1. Routing: decidir qué expertos usar
8
        expert_scores = self.gating_network(input_token)
9

10
        # 2. Seleccionar top-k expertos (típicamente 2-4)
11
        top_k_indices = expert_scores.topk(k=2)
12

13
        # 3. Procesar SOLO con expertos seleccionados
14
        outputs = []
15
        for idx in top_k_indices:
16
            expert_output = self.experts[idx](input_token)
17
            outputs.append(expert_output)
18

19
        # 4. Combinar resultados ponderados
20
        final_output = weighted_sum(outputs, expert_scores[top_k_indices])
21
        return final_output

Chatbot Simple#

1
import random
2

3
def chatbot_simple():
4
    """Chatbot básico con respuestas predefinidas"""
5
    responses = [
6
        "¡Hola! ¿En qué puedo ayudarte?",
7
        "Interesante pregunta, déjame pensar...",
8
        "¿Podrías darme más detalles?",
9
    ]
10
    return random.choice(responses)
11

12
# Uso
13
print(chatbot_simple())

Análisis de Datos con IA#

1
import pandas as pd
2
import numpy as np
3

4
def analyze_data(data):
5
    """Análisis estadístico básico de datos"""
6
    df = pd.DataFrame(data)
7

8
    stats = {
9
        'descripcion': df.describe(),
10
        'correlacion': df.corr(),
11
        'outliers': detect_outliers(df)
12
    }
13

14
    return stats
15

16
def detect_outliers(df):
17
    """Detecta valores atípicos usando el método IQR"""
18
    Q1 = df.quantile(0.25)
19
    Q3 = df.quantile(0.75)
20
    IQR = Q3 - Q1
21
    outliers = ((df < (Q1 - 1.5 * IQR)) | (df > (Q3 + 1.5 * IQR)))
22
    return outliers.sum()
23

24
# Ejemplo de uso
25
data = {
26
    "edad": [25, 30, 35, 40, 45, 100],  # 100 es outlier
27
    "salario": [50000, 60000, 70000, 80000, 90000, 95000],
28
}
29

30
resultados = analyze_data(data)
31
print(resultados['descripcion'])
32
print(f"\nOutliers detectados: {resultados['outliers']}")

El Futuro#

• Modelos más eficientes: MoE seguirá evolucionando
• Multimodalidad: IA que procesa texto, imagen, audio simultáneamente
• Especialización extrema: Expertos ultra-específicos para tareas nicho
• IA en el edge: Modelos pequeños y eficientes para dispositivos móviles

La IA ya está transformando cómo interactuamos con la tecnología, y su uso seguirá expandiéndose en los próximos años.

[!NOTA] ¿Te interesa cómo el sistema educativo está manejando la IA? Lee mi artículo de opinión: IA en Educación: Una Crítica Necesaria

¿Quieres aprender más sobre estos temas? Sígueme para más artículos técnicos sobre IA e infraestructura. 📬