Large Language Models (LLMs)

# ═══════════════════════════════════════════════════
# Fine-tuning BERT para clasificación de sentimiento
# ═══════════════════════════════════════════════════
from transformers import BertTokenizer, BertForSequenceClassification
from transformers import Trainer, TrainingArguments
from datasets import load_dataset

# 1. Cargar modelo pre-entrenado
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForSequenceClassification.from_pretrained(
    'bert-base-uncased',
    num_labels=2  # positivo / negativo
)

# 2. Dataset
dataset = load_dataset('imdb')

def tokenize(batch):
    return tokenizer(batch['text'], padding='max_length',
                     truncation=True, max_length=512)

tokenized = dataset.map(tokenize, batched=True)

# 3. Training
args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=3,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    learning_rate=2e-5,        # LR bajo, típico de fine-tuning
    weight_decay=0.01,
    evaluation_strategy='epoch',
    warmup_steps=500,
    fp16=True,                 # Mixed precision
)

trainer = Trainer(
    model=model,
    args=args,
    train_dataset=tokenized['train'],
    eval_dataset=tokenized['test'],
)

trainer.train()  # ~93% accuracy en IMDb

import tiktoken

# GPT-4 tokenizer
enc = tiktoken.get_encoding("cl100k_base")

text = "Los Large Language Models procesan tokens, no palabras."
tokens = enc.encode(text)
print(f"Texto: {text}")
print(f"Tokens: {tokens}")
print(f"Nº tokens: {len(tokens)}")
print(f"Decodificado: {[enc.decode([t]) for t in tokens]}")

# Output:
# Texto: Los Large Language Models procesan tokens, no palabras.
# Tokens: [30832, 20902, 11688, 27972, 62853, 11, 912, 84113, 13]
# Nº tokens: 9
# Decodificado: ['Los', ' Large', ' Language', ' Models', ' procesan', ' tokens', ',', ' no', ' palabras', '.']

# Formato típico de datos SFT (chat template)
data = [
    {
        "messages": [
            {"role": "system", "content": "Eres un asistente experto en ML."},
            {"role": "user", "content": "¿Qué es el dropout?"},
            {"role": "assistant", "content": "El dropout es una técnica de regularización..."}
        ]
    },
    {
        "messages": [
            {"role": "user", "content": "Escribe una función que ordene una lista en Python."},
            {"role": "assistant", "content": "def sort_list(lst):\n    return sorted(lst)"}
        ]
    }
]
# La loss se calcula SOLO sobre los tokens del assistant (no user/system)

# ═══════════════════════════════════════════════════
# Fine-tuning con LoRA (PEFT library)
# ═══════════════════════════════════════════════════
from transformers import AutoModelForCausalLM, AutoTokenizer, TrainingArguments
from peft import LoraConfig, get_peft_model, TaskType
from trl import SFTTrainer
from datasets import load_dataset

# 1. Modelo base
model_name = "meta-llama/Llama-2-7b-hf"
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained(model_name)
tokenizer.pad_token = tokenizer.eos_token

# 2. Configurar LoRA
lora_config = LoraConfig(
    task_type=TaskType.CAUSAL_LM,
    r=16,                      # Rango de la descomposición
    lora_alpha=32,             # Scaling factor
    lora_dropout=0.05,
    target_modules=[           # Capas donde aplicar LoRA
        "q_proj", "k_proj", "v_proj", "o_proj",
        "gate_proj", "up_proj", "down_proj",
    ],
    bias="none",
)

model = get_peft_model(model, lora_config)
model.print_trainable_parameters()
# Output: trainable params: 13,631,488 || all params: 6,751,367,168 || 0.20%

# 3. Dataset
dataset = load_dataset("mlabonne/guanaco-llama2-1k")

# 4. Training
training_args = TrainingArguments(
    output_dir="./llama2-lora",
    num_train_epochs=3,
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=2e-4,
    fp16=True,
    logging_steps=10,
    save_strategy="epoch",
)

trainer = SFTTrainer(
    model=model,
    args=training_args,
    train_dataset=dataset["train"],
    dataset_text_field="text",
    max_seq_length=1024,
)

trainer.train()

# ═══════════════════════════════════════════════════
# DPO Training con TRL (Transformer Reinforcement Learning)
# ═══════════════════════════════════════════════════
from transformers import AutoModelForCausalLM, AutoTokenizer
from trl import DPOTrainer, DPOConfig
from datasets import load_dataset
from peft import LoraConfig

# 1. Modelo (SFT ya hecho)
model = AutoModelForCausalLM.from_pretrained(
    "my-sft-model",
    torch_dtype="auto",
    device_map="auto",
)
tokenizer = AutoTokenizer.from_pretrained("my-sft-model")

# 2. Dataset de preferencias
# Cada ejemplo: { "prompt": ..., "chosen": ..., "rejected": ... }
dataset = load_dataset("argilla/ultrafeedback-binarized-preferences")

# 3. LoRA para eficiencia
peft_config = LoraConfig(
    r=16, lora_alpha=32, lora_dropout=0.05,
    target_modules=["q_proj","k_proj","v_proj","o_proj"],
)

# 4. DPO Training
dpo_config = DPOConfig(
    output_dir="./dpo-model",
    beta=0.1,                    # Temperatura (controla desviación de ref)
    per_device_train_batch_size=4,
    gradient_accumulation_steps=4,
    learning_rate=5e-7,          # LR muy bajo para alignment
    num_train_epochs=1,
    fp16=True,
)

trainer = DPOTrainer(
    model=model,
    ref_model=None,              # None → usa modelo inicial como referencia
    args=dpo_config,
    train_dataset=dataset["train"],
    tokenizer=tokenizer,
    peft_config=peft_config,
)

trainer.train()

# Zero-shot: solo instrucción
prompt = """Clasifica el siguiente texto como positivo, negativo o neutral.

Texto: "La película fue entretenida pero el final me decepcionó."
Clasificación:"""

# → "Neutral" o "Mixto"

# Few-shot: 3 ejemplos + query
prompt = """Clasifica el sentimiento del texto.

Texto: "Me encanta este restaurante, la comida es increíble."
Sentimiento: Positivo

Texto: "El servicio fue pésimo y tardaron una hora."
Sentimiento: Negativo

Texto: "El lugar está bien, nada especial."
Sentimiento: Neutral

Texto: "La película fue entretenida pero el final me decepcionó."
Sentimiento:"""

# → "Mixto" o "Neutral"

# ❌ Sin CoT (directo) — falla en problemas complejos
prompt_directo = """Si tengo 3 manzanas y le doy la mitad a Juan,
luego compro 5 más y le doy 2 a María, ¿cuántas tengo?
Respuesta:"""
# → A veces responde mal

# ✅ Con CoT — resuelve correctamente
prompt_cot = """Si tengo 3 manzanas y le doy la mitad a Juan,
luego compro 5 más y le doy 2 a María, ¿cuántas tengo?

Pensemos paso a paso:
1. Empiezo con 3 manzanas
2. Le doy la mitad a Juan: 3/2 = 1.5, pero como son manzanas enteras,
   le doy 1 (me quedo con 2) o redondeamos (1.5)
3. Compro 5 más: 1.5 + 5 = 6.5
4. Le doy 2 a María: 6.5 - 2 = 4.5
Respuesta: 4.5 manzanas

(O con enteros: 2 + 5 - 2 = 5 manzanas)"""

# ✅ Zero-shot CoT — más simple
prompt_zero_cot = """Si tengo 3 manzanas y le doy la mitad a Juan,
luego compro 5 más y le doy 2 a María, ¿cuántas tengo?

Let's think step by step."""

# ═══════════════════════════════════════════════════
# Inferencia multimodal con LLaVA
# ═══════════════════════════════════════════════════
from transformers import LlavaNextProcessor, LlavaNextForConditionalGeneration
from PIL import Image
import torch

# 1. Cargar modelo
processor = LlavaNextProcessor.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf")
model = LlavaNextForConditionalGeneration.from_pretrained(
    "llava-hf/llava-v1.6-mistral-7b-hf",
    torch_dtype=torch.float16,
    device_map="auto",
)

# 2. Preparar input multimodal
image = Image.open("mi_imagen.jpg")
prompt = "[INST] \nDescribe esta imagen en detalle. ¿Qué objetos ves y qué relaciones hay entre ellos? [/INST]"

inputs = processor(prompt, image, return_tensors="pt").to("cuda")

# 3. Generar
output = model.generate(**inputs, max_new_tokens=300, do_sample=True, temperature=0.7)
print(processor.decode(output[0], skip_special_tokens=True))

# ═══════════════════════════════════════════════════
# Function Calling con OpenAI API
# ═══════════════════════════════════════════════════
from openai import OpenAI
import json

client = OpenAI()

# 1. Definir herramientas (schema JSON)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Obtener el clima actual de una ciudad",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {"type": "string", "description": "Nombre de la ciudad"},
                    "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}
                },
                "required": ["city"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search_web",
            "description": "Buscar información en internet",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string", "description": "Consulta de búsqueda"}
                },
                "required": ["query"]
            }
        }
    }
]

# 2. Llamar al LLM
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "¿Qué tiempo hace en Madrid?"}],
    tools=tools,
    tool_choice="auto",  # El modelo decide si usar herramienta
)

# 3. El modelo genera una llamada a función (no ejecuta)
tool_call = response.choices[0].message.tool_calls[0]
print(f"Función: {tool_call.function.name}")
print(f"Args: {tool_call.function.arguments}")
# → Función: get_weather
# → Args: {"city": "Madrid", "unit": "celsius"}

# 4. TÚ ejecutas la función y devuelves el resultado
result = get_weather(city="Madrid", unit="celsius")  # Tu implementación
messages.append({"role": "tool", "content": json.dumps(result),
                 "tool_call_id": tool_call.id})

# 5. El LLM genera la respuesta final con el resultado
final = client.chat.completions.create(
    model="gpt-4o", messages=messages
)
print(final.choices[0].message.content)
# → "En Madrid hace 22°C con cielo despejado."

# ═══════════════════════════════════════════════════
# Agente ReAct con LangGraph
# ═══════════════════════════════════════════════════
from langchain_openai import ChatOpenAI
from langchain_core.tools import tool
from langgraph.prebuilt import create_react_agent

# 1. Definir herramientas
@tool
def calculate(expression: str) -> str:
    """Evalúa una expresión matemática."""
    return str(eval(expression))

@tool
def search(query: str) -> str:
    """Busca información en una base de conocimiento."""
    # Tu implementación de búsqueda
    return f"Resultado para: {query}"

# 2. Crear agente ReAct
llm = ChatOpenAI(model="gpt-4o", temperature=0)
agent = create_react_agent(llm, tools=[calculate, search])

# 3. Ejecutar
result = agent.invoke({
    "messages": [("user", "¿Cuánto es el PIB de España dividido por su población?")]
})

# El agente internamente:
# Thought: Necesito buscar el PIB y la población de España
# Action: search("PIB España 2024")
# Observation: "El PIB de España en 2024 es ~1.5T EUR"
# Action: search("población España 2024")
# Observation: "La población de España es ~48M"
# Action: calculate("1500000000000 / 48000000")
# Observation: "31250.0"
# Answer: "El PIB per cápita de España es ~31,250 EUR"