claudient 0.1.0

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

@@ -0,0 +1,147 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../pandas-polars.md).
+
+# Pandas / Polars Skill
+
+## Wanneer te activeren
+- Tabelgegevens opschonen, transformeren of aggregeren in Python
+- DataFrames samenvoegen, joinen of hervormen
+- Datavalidatie of kwaliteitscontroles schrijven
+- Converteren tussen formaten (CSV, Parquet, JSON, Excel)
+- Een nieuw dataset profileren of verkennen
+- Trage Pandas-code optimaliseren voor grote datasets
+- Pandas-code migreren naar Polars voor betere prestaties
+
+## Wanneer NIET te gebruiken
+- SQL in een database (push transformaties naar de database als data er al is)
+- Spark/gedistribueerd computing (gebruik PySpark skill voor datasets > beschikbaar RAM)
+- dbt-modellen (SQL-gebaseerde transformaties in een warehouse)
+- NumPy array-operaties op niet-tabelgegevens
+
+## Instructies
+
+### Pandas — prestatieregels
+```python
+import pandas as pd
+import numpy as np
+
+# Gebruik nooit iterrows() — vectoriseer in plaats daarvan
+# Slecht:
+for idx, row in df.iterrows():
+    df.at[idx, 'tax'] = row['price'] * 0.2
+
+# Goed:
+df['tax'] = df['price'] * 0.2
+
+# Gebruik .loc voor labelgebaseerde toegang, .iloc voor positiegebaseerde
+# Ketting nooit zonder toewijzing — veroorzaakt SettingWithCopyWarning
+df.loc[df['status'] == 'active', 'flag'] = True
+
+# Categorisch dtype voor lage-cardinaliteit string-kolommen (enorm geheugenvoordeel)
+df['country'] = df['country'].astype('category')
+
+# Numerieke typen downcasten om geheugen te verminderen
+df['quantity'] = pd.to_numeric(df['quantity'], downcast='integer')
+df['price'] = pd.to_numeric(df['price'], downcast='float')
+```
+
+### Pandas — aggregatie en groupby
+```python
+# Groupby met meerdere aggregaties
+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 — samenvoegen
+```python
+# Geef altijd expliciet how= aan — vertrouw nooit op de standaard (inner)
+result = pd.merge(
+    orders,
+    customers,
+    on='customer_id',
+    how='left',      # expliciet
+    validate='m:1',  # valideert kardinaliteit — geeft fout als geschonden
+    suffixes=('_order', '_customer')
+)
+```
+
+### Polars — wanneer te gebruiken in plaats van Pandas
+Gebruik Polars wanneer:
+- Dataset > 1M rijen (Polars is 5–100x sneller voor veel operaties)
+- Je luie evaluatie nodig hebt (query-optimalisatie vóór uitvoering)
+- Parallellisme belangrijk is (Polars gebruikt standaard alle CPU-kernen)
+
+```python
+import polars as pl
+
+# Lazy API — queries worden geoptimaliseerd vóór uitvoering
+result = (
+    pl.scan_parquet("orders.parquet")   # Luie scan — nog geen data geladen
+    .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()   # Nu uitvoeren
+)
+```
+
+### Polars — expressies (geen geketend indexeren)
+```python
+# Polars: geen SettingWithCopyWarning, geen geketend indexeren
+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"),
+])
+```
+
+### Datavalidatiepatroon
+```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"
+```
+
+### Formaatconversie
+```python
+# Lezen
+df = pd.read_parquet("data.parquet", columns=['id', 'name', 'amount'])  # Kolomselectie bij leestijd
+df = pd.read_csv("data.csv", dtype={'id': str}, parse_dates=['created_at'])
+
+# Schrijven — gebruik altijd Parquet boven CSV voor grote datasets
+df.to_parquet("output.parquet", index=False, compression='snappy')
+```
+
+## Voorbeeld
+
+**Gebruiker:** Schoon een ruwe orders-CSV op: herstel dtypes, verwijder duplicaten, behandel nulls, voeg afgeleide kolommen toe (revenue_after_tax, order_size_bucket) en output een gevalideerd Parquet-bestand.
+
+**Verwachte output:**
+- Lezen met expliciet `dtype=` en `parse_dates=`
+- Verwijder dubbele `order_id`-rijen (behoud laatste)
+- Vul nulls: `quantity` → 0, `discount` → 0.0, verwijder rijen waar `customer_id` null is
+- Afgeleid: `revenue_after_tax = price * quantity * (1 - discount) * 0.8`
+- Bucket: `order_size_bucket` = 'small'/<100, 'medium'/100–1000, 'large'/>1000
+- Valideer met assertions vóór schrijven
+- Schrijf naar Parquet met snappy-compressie
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. Datapipelines of AI-dataproducten bouwen? [uitbreiden.com](https://uitbreiden.com/)

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

@@ -0,0 +1,171 @@
+> 🇳🇱 Dit is de Nederlandse vertaling. [Engelse versie](../pytorch-tensorflow.md).
+
+# PyTorch / TensorFlow Skill
+
+## Wanneer te activeren
+- Neurale netwerk-trainingslussen schrijven in PyTorch
+- Keras/TensorFlow-modellen bouwen en trainen
+- Aangepaste verliesfuncties of modelarchitecturen implementeren
+- GPU-training instellen met apparaatbeheer
+- Dataloaders en preprocessing-pipelines schrijven voor modeltraining
+- Modelevaluatie, checkpointing en vroeg stoppen implementeren
+- NaN-verliezen, exploderende gradiënten of trainingsinstabiliteit debuggen
+- Modellen porteren tussen PyTorch en TensorFlow
+
+## Wanneer NIET te gebruiken
+- scikit-learn-taken (classificatie, regressie, clustering op tabelgegevens) — geen deep learning
+- Pandas/Polars-gegevensmanipulatie vóór de modelleerstap
+- Hugging Face fine-tuning met trainer API (andere workflow)
+- Inference-only deployments zonder trainingscode
+
+## Instructies
+
+### PyTorch trainingslus — standaardstructuur
+```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()
+
+            # Gradiëntclipping — altijd voor stabiliteit
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+
+            optimizer.step()
+            train_loss += loss.item()
+
+        # Validatie
+        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 beste model
+        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}")
+```
+
+### Apparaatbeheer
+```python
+# Altijd expliciete apparaatselectie
+device = torch.device('cuda' if torch.cuda.is_available() else
+                       'mps' if torch.backends.mps.is_available() else
+                       'cpu')
+model = model.to(device)
+```
+Codeer nooit `'cuda'` hard — controleer altijd beschikbaarheid.
+
+### Aangepaste modelstructuur
+```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)
+```
+Geef de voorkeur aan `nn.Sequential` voor eenvoudige feedforward; gebruik `forward()`-overschrijving voor complexe vertakkingen.
+
+### Trainingsinstabiliteit debuggen
+1. **NaN-verlies** → controleer op log(0) in verlies, exploderende invoer of deling door nul in preprocessing
+2. **Exploderende gradiënten** → voeg `clip_grad_norm_` toe (al aanwezig in bovenstaande sjabloon)
+3. **Verdwijnende gradiënten** → controleer activeringsfuncties (vermijd sigmoid/tanh in diepe netwerken), gebruik residuele verbindingen
+4. **Verlies daalt niet** → verklein LR 10x, controleer shuffling van dataloader, controleer of labels correct zijn
+5. **GPU OOM** → verklein batchgrootte, gebruik gradiëntcheckpointing, gebruik gemengde precisie
+
+### Training met gemengde precisie (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 — standaardstructuur
+```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
+)
+```
+
+## Voorbeeld
+
+**Gebruiker:** Bouw een PyTorch-tekstclassificator voor sentimentanalyse (binair) met embedding, LSTM en dropout.
+
+**Verwachte output:**
+- `SentimentLSTM(nn.Module)` — embeddinglaag, LSTM, dropout, lineair hoofd
+- `forward()` — behandelt verpakte sequenties of gevulde invoer
+- Trainingslus met gradiëntclipping, validatie per epoch, beste model checkpoint
+- `device` automatisch gedetecteerd (CUDA/MPS/CPU)
+- Train/val-splitsing via `DataLoader` met shuffling alleen op train
+
+---
+
+> **Werk met ons:** Claudient wordt ondersteund door [Uitbreiden](https://uitbreiden.com/) — we bouwen AI-producten en B2B-oplossingen met ontwikkelaarsgemeenschappen. ML-modellen of AI-aangedreven producten bouwen? [uitbreiden.com](https://uitbreiden.com/)

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

@@ -0,0 +1,145 @@
+# Pandas / Polars Skill
+
+## When to activate
+- Cleaning, transforming, or aggregating tabular data in Python
+- Merging, joining, or reshaping DataFrames
+- Writing data validation or quality checks
+- Converting between formats (CSV, Parquet, JSON, Excel)
+- Profiling or exploring a new dataset
+- Optimizing slow Pandas code for large datasets
+- Migrating Pandas code to Polars for performance
+
+## When NOT to use
+- SQL in a database (push transformations to the database when data is already there)
+- Spark/distributed computing (use PySpark skill for datasets > available RAM)
+- dbt models (SQL-based transformations in a warehouse)
+- NumPy array operations on non-tabular data
+
+## Instructions
+
+### Pandas — performance rules
+```python
+import pandas as pd
+import numpy as np
+
+# Never use iterrows() — vectorize instead
+# Bad:
+for idx, row in df.iterrows():
+    df.at[idx, 'tax'] = row['price'] * 0.2
+
+# Good:
+df['tax'] = df['price'] * 0.2
+
+# Use .loc for label-based access, .iloc for position-based
+# Never chain without assignment — causes SettingWithCopyWarning
+df.loc[df['status'] == 'active', 'flag'] = True
+
+# Categorical dtype for low-cardinality string columns (massive memory saving)
+df['country'] = df['country'].astype('category')
+
+# Downcasting numeric types to reduce memory
+df['quantity'] = pd.to_numeric(df['quantity'], downcast='integer')
+df['price'] = pd.to_numeric(df['price'], downcast='float')
+```
+
+### Pandas — aggregation and groupby
+```python
+# Groupby with multiple aggregations
+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
+# Always specify how= explicitly — never rely on default (inner)
+result = pd.merge(
+    orders,
+    customers,
+    on='customer_id',
+    how='left',      # explicit
+    validate='m:1',  # validates cardinality — raises if violated
+    suffixes=('_order', '_customer')
+)
+```
+
+### Polars — when to use instead of Pandas
+Use Polars when:
+- Dataset > 1M rows (Polars is 5–100x faster for many operations)
+- You need lazy evaluation (query optimization before execution)
+- Parallelism matters (Polars uses all CPU cores by default)
+
+```python
+import polars as pl
+
+# Lazy API — queries are optimized before execution
+result = (
+    pl.scan_parquet("orders.parquet")   # Lazy scan — no data loaded yet
+    .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()   # Execute now
+)
+```
+
+### Polars — expressions (no chained indexing)
+```python
+# Polars: no SettingWithCopyWarning, no chained indexing
+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"),
+])
+```
+
+### Data validation pattern
+```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"
+```
+
+### Format conversion
+```python
+# Read
+df = pd.read_parquet("data.parquet", columns=['id', 'name', 'amount'])  # Column selection at read time
+df = pd.read_csv("data.csv", dtype={'id': str}, parse_dates=['created_at'])
+
+# Write — always use Parquet over CSV for large datasets
+df.to_parquet("output.parquet", index=False, compression='snappy')
+```
+
+## Example
+
+**User:** Clean a raw orders CSV: fix dtypes, remove duplicates, handle nulls, add derived columns (revenue_after_tax, order_size_bucket), and output a validated Parquet file.
+
+**Expected output:**
+- Read with explicit `dtype=` and `parse_dates=`
+- Drop duplicate `order_id` rows (keep last)
+- Fill nulls: `quantity` → 0, `discount` → 0.0, drop rows where `customer_id` is null
+- Derive: `revenue_after_tax = price * quantity * (1 - discount) * 0.8`
+- Bucket: `order_size_bucket` = 'small'/<100, 'medium'/100–1000, 'large'/>1000
+- Validate with assertions before write
+- Write to Parquet with snappy compression
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. Building data pipelines or AI data products? [uitbreiden.com](https://uitbreiden.com/)

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

@@ -0,0 +1,169 @@
+# PyTorch / TensorFlow Skill
+
+## When to activate
+- Writing neural network training loops in PyTorch
+- Building and training Keras/TensorFlow models
+- Implementing custom loss functions or model architectures
+- Setting up GPU training with device management
+- Writing data loaders and preprocessing pipelines for model training
+- Implementing model evaluation, checkpointing, and early stopping
+- Debugging NaN losses, exploding gradients, or training instability
+- Porting models between PyTorch and TensorFlow
+
+## When NOT to use
+- scikit-learn tasks (classification, regression, clustering on tabular data) — not deep learning
+- Pandas/Polars data manipulation before the modeling step
+- Hugging Face fine-tuning with trainer API (different workflow)
+- Inference-only deployments without training code
+
+## Instructions
+
+### PyTorch training loop — standard structure
+```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()
+
+            # Gradient clipping — always for stability
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+
+            optimizer.step()
+            train_loss += loss.item()
+
+        # Validation
+        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 best model
+        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}")
+```
+
+### Device management
+```python
+# Always explicit device selection
+device = torch.device('cuda' if torch.cuda.is_available() else
+                       'mps' if torch.backends.mps.is_available() else
+                       'cpu')
+model = model.to(device)
+```
+Never hardcode `'cuda'` — always check availability.
+
+### Custom model structure
+```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)
+```
+Prefer `nn.Sequential` for simple feedforward; use `forward()` override for complex branching.
+
+### Debugging training instability
+1. **NaN loss** → check for log(0) in loss, exploding inputs, or division by zero in preprocessing
+2. **Exploding gradients** → add `clip_grad_norm_` (already in template above)
+3. **Vanishing gradients** → check activation functions (avoid sigmoid/tanh in deep networks), use residual connections
+4. **Loss not decreasing** → reduce LR 10x, check data loader shuffling, verify labels are correct
+5. **GPU OOM** → reduce batch size, use gradient checkpointing, use mixed precision
+
+### 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 — standard structure
+```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
+)
+```
+
+## Example
+
+**User:** Build a PyTorch text classifier for sentiment analysis (binary) with embedding, LSTM, and dropout.
+
+**Expected output:**
+- `SentimentLSTM(nn.Module)` — embedding layer, LSTM, dropout, linear head
+- `forward()` — handles packed sequences or padded input
+- Training loop with gradient clipping, validation per epoch, best model checkpoint
+- `device` auto-detected (CUDA/MPS/CPU)
+- Train/val split via `DataLoader` with shuffling on train only
+
+---
+
+> **Work with us:** Claudient is backed by [Uitbreiden](https://uitbreiden.com/) — we build AI products and B2B solutions with developer communities. Building ML models or AI-powered products? [uitbreiden.com](https://uitbreiden.com/)