claudient 0.1.0

package/skills/data-ml/de/pytorch-tensorflow.md

@@ -0,0 +1,171 @@
+> 🇩🇪 Dies ist die deutsche Übersetzung. [Englische Version](../pytorch-tensorflow.md).
+
+# PyTorch / TensorFlow Skill
+
+## Wann aktivieren
+- Neuronale Netzwerk-Trainingsschleifen in PyTorch schreiben
+- Keras/TensorFlow-Modelle bauen und trainieren
+- Benutzerdefinierte Verlustfunktionen oder Modellarchitekturen implementieren
+- GPU-Training mit Geräteverwaltung einrichten
+- Datenlader und Vorverarbeitungs-Pipelines für das Modelltraining schreiben
+- Modellauswertung, Checkpointing und Early Stopping implementieren
+- NaN-Verluste, explodierende Gradienten oder Trainingsinstabilität debuggen
+- Modelle zwischen PyTorch und TensorFlow portieren
+
+## Wann NICHT verwenden
+- scikit-learn-Aufgaben (Klassifikation, Regression, Clustering auf tabellarischen Daten) — kein Deep Learning
+- Pandas/Polars-Datenmanipulation vor dem Modellierungsschritt
+- Hugging Face Fine-Tuning mit Trainer API (anderer Workflow)
+- Nur-Inferenz-Deployments ohne Trainingscode
+
+## Anweisungen
+
+### PyTorch-Trainingsschleife — Standardstruktur
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+def train(model, train_loader, val_loader, epochs, lr, device):
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-2)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
+    criterion = nn.CrossEntropyLoss()
+
+    best_val_loss = float('inf')
+
+    for epoch in range(epochs):
+        # Training
+        model.train()
+        train_loss = 0.0
+        for batch in train_loader:
+            inputs, targets = batch
+            inputs, targets = inputs.to(device), targets.to(device)
+
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+
+            # Gradientenclipping — immer für Stabilität
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+
+            optimizer.step()
+            train_loss += loss.item()
+
+        # Validierung
+        model.eval()
+        val_loss = 0.0
+        with torch.no_grad():
+            for batch in val_loader:
+                inputs, targets = batch
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                val_loss += criterion(outputs, targets).item()
+
+        scheduler.step()
+
+        # Bestes Modell speichern
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            torch.save(model.state_dict(), 'best_model.pt')
+
+        print(f"Epoch {epoch+1}/{epochs} | Train: {train_loss/len(train_loader):.4f} | Val: {val_loss/len(val_loader):.4f}")
+```
+
+### Geräteverwaltung
+```python
+# Immer explizite Geräteauswahl
+device = torch.device('cuda' if torch.cuda.is_available() else
+                       'mps' if torch.backends.mps.is_available() else
+                       'cpu')
+model = model.to(device)
+```
+Niemals `'cuda'` hardcoden — immer Verfügbarkeit prüfen.
+
+### Benutzerdefinierte Modellstruktur
+```python
+class MyModel(nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim, dropout=0.3):
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, output_dim)
+        )
+
+    def forward(self, x):
+        return self.network(x)
+```
+`nn.Sequential` für einfache Feedforward-Netze bevorzugen; `forward()`-Überschreibung für komplexe Verzweigungen verwenden.
+
+### Trainingsinstabilität debuggen
+1. **NaN-Verlust** → auf log(0) im Verlust, explodierende Eingaben oder Division durch Null bei der Vorverarbeitung prüfen
+2. **Explodierende Gradienten** → `clip_grad_norm_` hinzufügen (bereits in obiger Vorlage)
+3. **Verschwindende Gradienten** → Aktivierungsfunktionen prüfen (sigmoid/tanh in tiefen Netzwerken vermeiden), Residualverbindungen verwenden
+4. **Verlust sinkt nicht** → LR um Faktor 10 reduzieren, DataLoader-Shuffling prüfen, Labels verifizieren
+5. **GPU OOM** → Batch-Größe reduzieren, Gradient Checkpointing verwenden, Mixed Precision verwenden
+
+### Mixed Precision Training (PyTorch)
+```python
+from torch.cuda.amp import autocast, GradScaler
+
+scaler = GradScaler()
+
+for batch in train_loader:
+    optimizer.zero_grad()
+    with autocast():
+        outputs = model(inputs)
+        loss = criterion(outputs, targets)
+    scaler.scale(loss).backward()
+    scaler.unscale_(optimizer)
+    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+    scaler.step(optimizer)
+    scaler.update()
+```
+
+### TensorFlow/Keras — Standardstruktur
+```python
+import tensorflow as tf
+
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(256, activation='relu'),
+    tf.keras.layers.Dropout(0.3),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+model.compile(
+    optimizer=tf.keras.optimizers.AdamW(learning_rate=1e-3, weight_decay=1e-2),
+    loss='sparse_categorical_crossentropy',
+    metrics=['accuracy']
+)
+
+callbacks = [
+    tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
+    tf.keras.callbacks.ModelCheckpoint('best_model.keras', save_best_only=True),
+    tf.keras.callbacks.ReduceLROnPlateau(patience=3, factor=0.5)
+]
+
+history = model.fit(
+    train_dataset,
+    validation_data=val_dataset,
+    epochs=100,
+    callbacks=callbacks
+)
+```
+
+## Beispiel
+
+**Benutzer:** Einen PyTorch-Textklassifikator für Sentiment-Analyse (binär) mit Embedding, LSTM und Dropout bauen.
+
+**Erwartete Ausgabe:**
+- `SentimentLSTM(nn.Module)` — Embedding-Layer, LSTM, Dropout, linearer Kopf
+- `forward()` — verarbeitet gepackte Sequenzen oder aufgefüllte Eingaben
+- Trainingsschleife mit Gradientenclipping, Validierung pro Epoche, bestes Modell-Checkpoint
+- `device` automatisch erkannt (CUDA/MPS/CPU)
+- Train/Val-Aufteilung via `DataLoader` mit Shuffling nur beim Training
+
+---
+
+> **Mit uns arbeiten:** Claudient wird von [Uitbreiden](https://uitbreiden.com/) unterstützt — wir bauen KI-Produkte und B2B-Lösungen mit Entwickler-Communities. ML-Modelle oder KI-gestützte Produkte bauen? [uitbreiden.com](https://uitbreiden.com/)

package/skills/data-ml/es/dbt-data-pipelines.md

@@ -0,0 +1,157 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../dbt-data-pipelines.md).
+
+# Skill de dbt Data Pipelines
+
+## Cuándo activar
+- Escribir modelos dbt (capas staging, intermediate, mart)
+- Configurar fuentes, refs y dependencias de dbt
+- Escribir tests de dbt (tests de esquema, tests singulares, tests genéricos personalizados)
+- Configurar la estructura del proyecto dbt para un nuevo data warehouse
+- Escribir macros dbt para lógica SQL reutilizable
+- Configurar documentación dbt y verificaciones de frescura
+- Depurar errores de compilación de dbt o ejecuciones de modelos fallidas
+- Configurar dbt con BigQuery, Snowflake, Redshift o DuckDB
+
+## Cuándo NO usar
+- Pipelines ETL sin un warehouse (usar Airflow, Prefect o Dagster en su lugar)
+- Datos de streaming en tiempo real (dbt es solo batch)
+- Transformaciones en memoria con Pandas/Polars (usar el skill de pandas-polars)
+- Ingesta de datos (dbt transforma, no ingiere)
+
+## Instrucciones
+
+### Arquitectura de capas del proyecto
+Siempre separa los modelos en tres capas:
+```
+models/
+├── staging/          ← 1:1 con tablas fuente. Solo limpieza ligera. Sin joins.
+│   ├── stg_orders.sql
+│   └── stg_customers.sql
+├── intermediate/     ← Lógica de negocio. Se permiten joins. No expuesto a herramientas de BI.
+│   └── int_orders_with_customers.sql
+└── marts/            ← Entidades de negocio finales. Expuesto a BI. Las agregaciones viven aquí.
+    ├── finance/
+    │   └── fct_revenue.sql
+    └── marketing/
+        └── dim_customers.sql
+```
+
+**Reglas de Staging:**
+- Renombrar columnas a las convenciones del proyecto (snake_case)
+- Castear tipos explícitamente
+- Sin lógica de negocio — sin joins, sin agregaciones
+- Prefijo `stg_`
+
+**Reglas de Mart:**
+- Prefijo `fct_` para tablas de hechos (eventos, transacciones)
+- Prefijo `dim_` para tablas de dimensiones (clientes, productos)
+- Siempre documentar en schema.yml
+
+### Configuración de modelos
+```sql
+-- models/marts/finance/fct_revenue.sql
+{{
+  config(
+    materialized='incremental',
+    unique_key='order_id',
+    on_schema_change='fail'
+  )
+}}
+
+with orders as (
+    select * from {{ ref('int_orders_with_customers') }}
+    {% if is_incremental() %}
+    where created_at > (select max(created_at) from {{ this }})
+    {% endif %}
+)
+
+select
+    order_id,
+    customer_id,
+    amount,
+    created_at
+from orders
+```
+
+**Opciones de materialización:**
+- `view`: por defecto — bueno para modelos de staging e intermediate
+- `table`: para consultas costosas consultadas con frecuencia
+- `incremental`: para tablas de hechos grandes que crecen con el tiempo
+- `ephemeral`: CTEs, no materializadas — usar para transformaciones simples llamadas una vez
+
+### Testing — requerido en cada modelo mart
+```yaml
+# models/marts/finance/schema.yml
+version: 2
+
+models:
+  - name: fct_revenue
+    description: "Una fila por pedido completado"
+    columns:
+      - name: order_id
+        description: "Clave primaria"
+        tests:
+          - unique
+          - not_null
+      - name: customer_id
+        tests:
+          - not_null
+          - relationships:
+              to: ref('dim_customers')
+              field: customer_id
+      - name: amount
+        tests:
+          - not_null
+          - dbt_utils.accepted_range:
+              min_value: 0
+```
+
+Tests mínimos en cada modelo mart: `unique` + `not_null` en la clave primaria, `not_null` en las claves foráneas críticas.
+
+### Configuración de fuentes
+```yaml
+# models/staging/sources.yml
+version: 2
+
+sources:
+  - name: raw_stripe
+    database: raw
+    schema: stripe
+    freshness:
+      warn_after: {count: 12, period: hour}
+      error_after: {count: 24, period: hour}
+    loaded_at_field: _ingested_at
+    tables:
+      - name: charges
+        description: "Cargos de Stripe sin procesar de Fivetran"
+```
+
+Siempre establece `freshness` en las fuentes — los datos de fuente obsoletos son un fallo silencioso.
+
+### Macros para lógica reutilizable
+```sql
+-- macros/cents_to_dollars.sql
+{% macro cents_to_dollars(column_name) %}
+    ({{ column_name }} / 100.0)::numeric(10, 2)
+{% endmacro %}
+
+-- Uso en el modelo
+select
+    {{ cents_to_dollars('amount_cents') }} as amount_dollars
+from orders
+```
+
+## Ejemplo
+
+**Usuario:** Crear modelos de staging y mart para datos de pagos de Stripe (cargos, reembolsos) con tests y verificaciones de frescura.
+
+**Salida esperada:**
+- `models/staging/stripe/sources.yml` — fuente con verificación de frescura en `_ingested_at`
+- `models/staging/stripe/stg_stripe_charges.sql` — renombrar, castear, sin joins
+- `models/staging/stripe/stg_stripe_refunds.sql` — mismo patrón
+- `models/marts/finance/fct_payments.sql` — join de cargos + reembolsos, importe neto, materialización incremental
+- `models/marts/finance/schema.yml` — `unique` + `not_null` en `charge_id`, test de relación en `customer_id`
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. ¿Construyendo pipelines de datos para IA o productos de analítica? [uitbreiden.com](https://uitbreiden.com/)

package/skills/data-ml/es/pandas-polars.md

@@ -0,0 +1,147 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../pandas-polars.md).
+
+# Skill de Pandas / Polars
+
+## Cuándo activar
+- Limpiar, transformar o agregar datos tabulares en Python
+- Hacer merge, join o reshape de DataFrames
+- Escribir validaciones de datos o verificaciones de calidad
+- Convertir entre formatos (CSV, Parquet, JSON, Excel)
+- Perfilar o explorar un nuevo conjunto de datos
+- Optimizar código lento de Pandas para grandes conjuntos de datos
+- Migrar código de Pandas a Polars por rendimiento
+
+## Cuándo NO usar
+- SQL en una base de datos (empujar las transformaciones a la base de datos cuando los datos ya están allí)
+- Spark/computación distribuida (usar el skill de PySpark para conjuntos de datos > RAM disponible)
+- Modelos dbt (transformaciones basadas en SQL en un warehouse)
+- Operaciones de arrays NumPy sobre datos no tabulares
+
+## Instrucciones
+
+### Pandas — reglas de rendimiento
+```python
+import pandas as pd
+import numpy as np
+
+# Nunca uses iterrows() — vectoriza en su lugar
+# Malo:
+for idx, row in df.iterrows():
+    df.at[idx, 'tax'] = row['price'] * 0.2
+
+# Bueno:
+df['tax'] = df['price'] * 0.2
+
+# Usa .loc para acceso basado en etiquetas, .iloc para acceso basado en posición
+# Nunca encadenes sin asignación — causa SettingWithCopyWarning
+df.loc[df['status'] == 'active', 'flag'] = True
+
+# Dtype categórico para columnas de cadenas de baja cardinalidad (ahorro masivo de memoria)
+df['country'] = df['country'].astype('category')
+
+# Reducir tipos numéricos para reducir memoria
+df['quantity'] = pd.to_numeric(df['quantity'], downcast='integer')
+df['price'] = pd.to_numeric(df['price'], downcast='float')
+```
+
+### Pandas — agregación y groupby
+```python
+# Groupby con múltiples agregaciones
+summary = (
+    df.groupby(['region', 'category'])
+    .agg(
+        total_revenue=('revenue', 'sum'),
+        order_count=('order_id', 'nunique'),
+        avg_order_value=('revenue', 'mean'),
+    )
+    .reset_index()
+    .sort_values('total_revenue', ascending=False)
+)
+```
+
+### Pandas — merging
+```python
+# Siempre especifica how= explícitamente — nunca confíes en el valor por defecto (inner)
+result = pd.merge(
+    orders,
+    customers,
+    on='customer_id',
+    how='left',      # explícito
+    validate='m:1',  # valida la cardinalidad — lanza excepción si se viola
+    suffixes=('_order', '_customer')
+)
+```
+
+### Polars — cuándo usar en lugar de Pandas
+Usa Polars cuando:
+- El conjunto de datos tiene > 1M filas (Polars es 5–100x más rápido para muchas operaciones)
+- Necesitas evaluación lazy (optimización de consultas antes de la ejecución)
+- El paralelismo importa (Polars usa todos los núcleos de CPU por defecto)
+
+```python
+import polars as pl
+
+# API Lazy — las consultas se optimizan antes de ejecutarse
+result = (
+    pl.scan_parquet("orders.parquet")   # Escaneo lazy — no se cargan datos aún
+    .filter(pl.col("status") == "completed")
+    .group_by(["region", "category"])
+    .agg([
+        pl.col("revenue").sum().alias("total_revenue"),
+        pl.col("order_id").n_unique().alias("order_count"),
+        pl.col("revenue").mean().alias("avg_order_value"),
+    ])
+    .sort("total_revenue", descending=True)
+    .collect()   # Ejecutar ahora
+)
+```
+
+### Polars — expresiones (sin indexación encadenada)
+```python
+# Polars: sin SettingWithCopyWarning, sin indexación encadenada
+df = df.with_columns([
+    (pl.col("price") * 0.2).alias("tax"),
+    pl.col("name").str.to_uppercase().alias("name_upper"),
+    pl.when(pl.col("quantity") > 10)
+      .then(pl.lit("bulk"))
+      .otherwise(pl.lit("standard"))
+      .alias("order_type"),
+])
+```
+
+### Patrón de validación de datos
+```python
+def validate_orders(df: pd.DataFrame) -> None:
+    assert df['order_id'].notna().all(), "order_id has nulls"
+    assert df['order_id'].is_unique, "order_id has duplicates"
+    assert (df['amount'] >= 0).all(), "amount has negative values"
+    assert df['status'].isin(['pending', 'completed', 'cancelled']).all(), "invalid status values"
+    assert pd.to_datetime(df['created_at'], errors='coerce').notna().all(), "created_at has invalid dates"
+```
+
+### Conversión de formatos
+```python
+# Leer
+df = pd.read_parquet("data.parquet", columns=['id', 'name', 'amount'])  # Selección de columnas al leer
+df = pd.read_csv("data.csv", dtype={'id': str}, parse_dates=['created_at'])
+
+# Escribir — siempre usa Parquet sobre CSV para grandes conjuntos de datos
+df.to_parquet("output.parquet", index=False, compression='snappy')
+```
+
+## Ejemplo
+
+**Usuario:** Limpiar un CSV de pedidos sin procesar: corregir dtypes, eliminar duplicados, manejar nulos, agregar columnas derivadas (revenue_after_tax, order_size_bucket) y generar un archivo Parquet validado.
+
+**Salida esperada:**
+- Leer con `dtype=` explícito y `parse_dates=`
+- Eliminar filas duplicadas de `order_id` (mantener el último)
+- Rellenar nulos: `quantity` → 0, `discount` → 0.0, eliminar filas donde `customer_id` es nulo
+- Derivar: `revenue_after_tax = price * quantity * (1 - discount) * 0.8`
+- Bucket: `order_size_bucket` = 'small'/<100, 'medium'/100–1000, 'large'/>1000
+- Validar con aserciones antes de escribir
+- Escribir en Parquet con compresión snappy
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. ¿Construyendo pipelines de datos o productos de datos con IA? [uitbreiden.com](https://uitbreiden.com/)

package/skills/data-ml/es/pytorch-tensorflow.md

@@ -0,0 +1,171 @@
+> 🇪🇸 Esta es la traducción en español. [Versión en inglés](../pytorch-tensorflow.md).
+
+# Skill de PyTorch / TensorFlow
+
+## Cuándo activar
+- Escribir bucles de entrenamiento de redes neuronales en PyTorch
+- Construir y entrenar modelos Keras/TensorFlow
+- Implementar funciones de pérdida personalizadas o arquitecturas de modelos
+- Configurar entrenamiento en GPU con gestión de dispositivos
+- Escribir cargadores de datos y pipelines de preprocesamiento para entrenamiento de modelos
+- Implementar evaluación de modelos, checkpointing y early stopping
+- Depurar pérdidas NaN, gradientes explosivos o inestabilidad de entrenamiento
+- Portar modelos entre PyTorch y TensorFlow
+
+## Cuándo NO usar
+- Tareas de scikit-learn (clasificación, regresión, clustering en datos tabulares) — no es deep learning
+- Manipulación de datos con Pandas/Polars antes del paso de modelado
+- Fine-tuning con la API trainer de Hugging Face (flujo de trabajo diferente)
+- Despliegues solo de inferencia sin código de entrenamiento
+
+## Instrucciones
+
+### Bucle de entrenamiento de PyTorch — estructura estándar
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+def train(model, train_loader, val_loader, epochs, lr, device):
+    optimizer = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-2)
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
+    criterion = nn.CrossEntropyLoss()
+
+    best_val_loss = float('inf')
+
+    for epoch in range(epochs):
+        # Entrenamiento
+        model.train()
+        train_loss = 0.0
+        for batch in train_loader:
+            inputs, targets = batch
+            inputs, targets = inputs.to(device), targets.to(device)
+
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+
+            # Recorte de gradientes — siempre para estabilidad
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+
+            optimizer.step()
+            train_loss += loss.item()
+
+        # Validación
+        model.eval()
+        val_loss = 0.0
+        with torch.no_grad():
+            for batch in val_loader:
+                inputs, targets = batch
+                inputs, targets = inputs.to(device), targets.to(device)
+                outputs = model(inputs)
+                val_loss += criterion(outputs, targets).item()
+
+        scheduler.step()
+
+        # Checkpoint del mejor modelo
+        if val_loss < best_val_loss:
+            best_val_loss = val_loss
+            torch.save(model.state_dict(), 'best_model.pt')
+
+        print(f"Epoch {epoch+1}/{epochs} | Train: {train_loss/len(train_loader):.4f} | Val: {val_loss/len(val_loader):.4f}")
+```
+
+### Gestión de dispositivos
+```python
+# Siempre selección explícita del dispositivo
+device = torch.device('cuda' if torch.cuda.is_available() else
+                       'mps' if torch.backends.mps.is_available() else
+                       'cpu')
+model = model.to(device)
+```
+Nunca hardcodees `'cuda'` — siempre verifica la disponibilidad.
+
+### Estructura del modelo personalizado
+```python
+class MyModel(nn.Module):
+    def __init__(self, input_dim, hidden_dim, output_dim, dropout=0.3):
+        super().__init__()
+        self.network = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.LayerNorm(hidden_dim),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden_dim, output_dim)
+        )
+
+    def forward(self, x):
+        return self.network(x)
+```
+Prefiere `nn.Sequential` para feedforward simple; usa la sobreescritura de `forward()` para ramificaciones complejas.
+
+### Depuración de inestabilidad de entrenamiento
+1. **Pérdida NaN** → verifica log(0) en la pérdida, entradas explosivas o división por cero en el preprocesamiento
+2. **Gradientes explosivos** → agrega `clip_grad_norm_` (ya en la plantilla anterior)
+3. **Gradientes que desaparecen** → verifica las funciones de activación (evita sigmoid/tanh en redes profundas), usa conexiones residuales
+4. **La pérdida no disminuye** → reduce LR 10x, verifica el shuffling del data loader, verifica que las etiquetas son correctas
+5. **OOM en GPU** → reduce el tamaño del batch, usa gradient checkpointing, usa precisión mixta
+
+### Entrenamiento con precisión mixta (PyTorch)
+```python
+from torch.cuda.amp import autocast, GradScaler
+
+scaler = GradScaler()
+
+for batch in train_loader:
+    optimizer.zero_grad()
+    with autocast():
+        outputs = model(inputs)
+        loss = criterion(outputs, targets)
+    scaler.scale(loss).backward()
+    scaler.unscale_(optimizer)
+    torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+    scaler.step(optimizer)
+    scaler.update()
+```
+
+### TensorFlow/Keras — estructura estándar
+```python
+import tensorflow as tf
+
+model = tf.keras.Sequential([
+    tf.keras.layers.Dense(256, activation='relu'),
+    tf.keras.layers.Dropout(0.3),
+    tf.keras.layers.Dense(10, activation='softmax')
+])
+
+model.compile(
+    optimizer=tf.keras.optimizers.AdamW(learning_rate=1e-3, weight_decay=1e-2),
+    loss='sparse_categorical_crossentropy',
+    metrics=['accuracy']
+)
+
+callbacks = [
+    tf.keras.callbacks.EarlyStopping(patience=5, restore_best_weights=True),
+    tf.keras.callbacks.ModelCheckpoint('best_model.keras', save_best_only=True),
+    tf.keras.callbacks.ReduceLROnPlateau(patience=3, factor=0.5)
+]
+
+history = model.fit(
+    train_dataset,
+    validation_data=val_dataset,
+    epochs=100,
+    callbacks=callbacks
+)
+```
+
+## Ejemplo
+
+**Usuario:** Construir un clasificador de texto en PyTorch para análisis de sentimientos (binario) con embedding, LSTM y dropout.
+
+**Salida esperada:**
+- `SentimentLSTM(nn.Module)` — capa de embedding, LSTM, dropout, cabeza lineal
+- `forward()` — maneja secuencias empaquetadas o entrada con padding
+- Bucle de entrenamiento con recorte de gradientes, validación por época, checkpoint del mejor modelo
+- `device` auto-detectado (CUDA/MPS/CPU)
+- División train/val mediante `DataLoader` con shuffling solo en train
+
+---
+
+> **Trabaja con nosotros:** Claudient está respaldado por [Uitbreiden](https://uitbreiden.com/) — construimos productos de IA y soluciones B2B con comunidades de desarrolladores. ¿Construyendo modelos ML o productos impulsados por IA? [uitbreiden.com](https://uitbreiden.com/)