javi-forge 0.1.0

package/ai-config/skills/data-ai/powerbi/SKILL.md

@@ -0,0 +1,352 @@
+---
+name: powerbi
+description: >
+  Power BI business intelligence with DAX measures, Power Query transformations, and dashboard design patterns.
+  Trigger: powerbi, dax, business intelligence, dashboard, analytics, reporting, power query
+tools:
+  - Read
+  - Write
+  - Bash
+metadata:
+  author: plataforma-industrial
+  version: "2.0"
+  tags: [powerbi, dax, analytics, dashboards]
+  updated: "2026-02"
+---
+
+# Power BI Business Intelligence
+
+## Data Architecture
+
+```
+SOURCES                     DATAFLOW                    REPORTS
++---------------+          +---------------+          +---------------+
+| PostgreSQL    |          | ETL           |          | Executive     |
+| API REST      |   --->   | Dimensional   |   --->   | Dashboard     |
+| Excel/CSV     |          | Model         |          | Analysis      |
++---------------+          +---------------+          +---------------+
+```
+
+## Star Schema Model
+
+```
+                    DimSensor
+                        |
+DimPlant     FactReadings     DimDate
+    |              |              |
+    +------+-------+-------+------+
+           |               |
+      FactAlerts       DimTime
+           |
+    DimAlertType
+```
+
+## Power Query (M)
+
+### PostgreSQL Connection
+
+```m
+// Query: Sensors
+let
+    Source = PostgreSQL.Database("server", "database"),
+    sensors = Source{[Schema="public", Item="sensors"]}[Data],
+
+    // Filter and rename
+    FilteredRows = Table.SelectRows(sensors, each [status] = "active"),
+    RenamedColumns = Table.RenameColumns(FilteredRows, {
+        {"id", "SensorID"},
+        {"name", "SensorName"}
+    }),
+
+    // Add key
+    AddedKey = Table.AddIndexColumn(RenamedColumns, "SensorKey", 1, 1, Int64.Type)
+in
+    AddedKey
+```
+
+### REST API Connection
+
+```m
+// Query: Metrics
+let
+    BaseUrl = "https://api.example.com/v1",
+    Token = GetSecret("API_TOKEN"),
+
+    GetPage = (page as number) as table =>
+        let
+            Response = Web.Contents(
+                BaseUrl & "/metrics",
+                [
+                    Headers = [Authorization = "Bearer " & Token],
+                    Query = [page = Text.From(page), limit = "1000"]
+                ]
+            ),
+            Json = Json.Document(Response),
+            AsTable = Table.FromRecords(Json[data])
+        in
+            AsTable,
+
+    // Paginate
+    AllPages = List.Generate(
+        () => [Page = 1, Data = GetPage(1)],
+        each Table.RowCount([Data]) > 0,
+        each [Page = [Page] + 1, Data = GetPage([Page] + 1)],
+        each [Data]
+    ),
+
+    Combined = Table.Combine(AllPages)
+in
+    Combined
+```
+
+### Date Dimension
+
+```m
+// Query: DimDate
+let
+    StartDate = #date(2020, 1, 1),
+    EndDate = Date.AddYears(DateTime.Date(DateTime.LocalNow()), 1),
+
+    DateList = List.Dates(StartDate, Duration.Days(EndDate - StartDate), #duration(1,0,0,0)),
+    DateTable = Table.FromList(DateList, Splitter.SplitByNothing(), {"Date"}),
+
+    AddYear = Table.AddColumn(DateTable, "Year", each Date.Year([Date]), Int64.Type),
+    AddMonth = Table.AddColumn(AddYear, "Month", each Date.Month([Date]), Int64.Type),
+    AddMonthName = Table.AddColumn(AddMonth, "MonthName", each Date.MonthName([Date])),
+    AddWeek = Table.AddColumn(AddMonthName, "Week", each Date.WeekOfYear([Date]), Int64.Type),
+    AddIsWeekend = Table.AddColumn(AddWeek, "IsWeekend", each Date.DayOfWeek([Date]) >= 5),
+
+    AddKey = Table.AddColumn(AddIsWeekend, "DateKey",
+        each Date.Year([Date]) * 10000 + Date.Month([Date]) * 100 + Date.Day([Date]),
+        Int64.Type
+    )
+in
+    AddKey
+```
+
+### Time Dimension
+
+```m
+// Query: DimTime
+let
+    Minutes = List.Generate(() => 0, each _ < 1440, each _ + 1),
+    ToTable = Table.FromList(Minutes, Splitter.SplitByNothing(), {"MinuteOfDay"}),
+
+    AddHour = Table.AddColumn(ToTable, "Hour", each Number.IntegerDivide([MinuteOfDay], 60)),
+    AddMinute = Table.AddColumn(AddHour, "Minute", each Number.Mod([MinuteOfDay], 60)),
+
+    AddShift = Table.AddColumn(AddMinute, "Shift", each
+        if [Hour] >= 6 and [Hour] < 14 then "Morning"
+        else if [Hour] >= 14 and [Hour] < 22 then "Afternoon"
+        else "Night"
+    ),
+
+    AddKey = Table.AddColumn(AddShift, "TimeKey", each [Hour] * 100 + [Minute], Int64.Type)
+in
+    AddKey
+```
+
+## DAX Measures
+
+### Basic Metrics
+
+```dax
+// Average
+Avg Reading = AVERAGE(FactReadings[Value])
+
+// Current (latest)
+Current Reading =
+CALCULATE(
+    MAX(FactReadings[Value]),
+    FILTER(ALL(DimDate), DimDate[DateKey] = MAX(DimDate[DateKey]))
+)
+
+// Percentage change
+Reading Change % =
+VAR CurrentValue = [Avg Reading]
+VAR PreviousValue = CALCULATE([Avg Reading], DATEADD(DimDate[Date], -1, DAY))
+RETURN
+    IF(ISBLANK(PreviousValue), BLANK(),
+       DIVIDE(CurrentValue - PreviousValue, PreviousValue))
+
+// In range percentage
+In Range % =
+VAR InRange = CALCULATE(COUNTROWS(FactReadings),
+    FactReadings[Value] >= RELATED(DimSensor[MinValue]),
+    FactReadings[Value] <= RELATED(DimSensor[MaxValue])
+)
+VAR Total = COUNTROWS(FactReadings)
+RETURN DIVIDE(InRange, Total)
+```
+
+### Alert Metrics
+
+```dax
+// Active alerts
+Active Alerts = CALCULATE(COUNTROWS(FactAlerts), FactAlerts[Status] = "active")
+
+// Critical alerts
+Critical Alerts = CALCULATE(COUNTROWS(FactAlerts),
+    RELATED(DimAlertType[Severity]) = "critical")
+
+// MTTR (Mean Time To Resolve)
+MTTR Hours = AVERAGEX(
+    FILTER(FactAlerts, FactAlerts[ResolvedAt] <> BLANK()),
+    DATEDIFF(FactAlerts[TriggeredAt], FactAlerts[ResolvedAt], HOUR)
+)
+
+// Acknowledgement rate
+Ack Rate % =
+VAR Acked = CALCULATE(COUNTROWS(FactAlerts), FactAlerts[AckedAt] <> BLANK())
+VAR Total = COUNTROWS(FactAlerts)
+RETURN DIVIDE(Acked, Total)
+```
+
+### Time Intelligence
+
+```dax
+// Year to Date
+Production YTD = CALCULATE([Total Production], DATESYTD(DimDate[Date]))
+
+// Month to Date
+Production MTD = CALCULATE([Total Production], DATESMTD(DimDate[Date]))
+
+// Same Period Last Year
+Production SPLY = CALCULATE([Total Production], SAMEPERIODLASTYEAR(DimDate[Date]))
+
+// Year over Year growth
+YoY Growth % =
+VAR Current = [Total Production]
+VAR LastYear = [Production SPLY]
+RETURN DIVIDE(Current - LastYear, LastYear)
+
+// 7-day Moving Average
+Production MA7 =
+CALCULATE(
+    [Total Production],
+    DATESINPERIOD(DimDate[Date], MAX(DimDate[Date]), -7, DAY)
+) / 7
+```
+
+### Using Variables
+
+```dax
+// Good: Use variables
+Margin % =
+VAR Revenue = SUM(Sales[Amount])
+VAR Cost = SUM(Sales[Cost])
+RETURN DIVIDE(Revenue - Cost, Revenue)
+
+// Bad: Calculates twice
+Margin % = DIVIDE(
+    SUM(Sales[Amount]) - SUM(Sales[Cost]),
+    SUM(Sales[Amount])
+)
+```
+
+## Dashboard Layout
+
+### Executive Dashboard
+
+```
++----------------------------------------------------------+
+|                    EXECUTIVE DASHBOARD                     |
++----------+----------+----------+----------+---------------+
+|  KPI 1   |  KPI 2   |  KPI 3   |  KPI 4   |   Trend       |
+|   Card   |   Card   |   Card   |   Card   |   Indicator   |
++----------+----------+----------+----------+---------------+
+|                                                           |
+|              MAIN CHART (Time Series)                     |
+|                                                           |
++--------------------------+--------------------------------+
+|                          |                                |
+|  BREAKDOWN               |  TOP 5 TABLE                   |
+|  (Bar Chart)             |  (Conditional Formatting)      |
+|                          |                                |
++--------------------------+--------------------------------+
+```
+
+## Visualizations Guide
+
+| Metric Type | Visual | Configuration |
+|-------------|--------|---------------|
+| Single KPI | Card | Value + Trend + Indicator |
+| Progress | Gauge | Color thresholds |
+| Time comparison | Line Chart | With area for ranges |
+| Distribution | Donut Chart | Max 5 categories |
+| Ranking | Bar Chart | Horizontal, sorted |
+| Correlation | Scatter Plot | With trendline |
+| Location | Map | Bubbles by size |
+| Detail | Table/Matrix | Conditional formatting |
+
+## Color Standards
+
+```
+// Status colors
+Green (OK):     #2DD36F
+Yellow (Warn):  #FFC409
+Red (Error):    #EB445A
+Gray (Offline): #92949C
+
+// Trend colors
+Positive: #2DD36F
+Negative: #EB445A
+Neutral:  #3DC2FF
+
+// Brand
+Primary:   #0969FF
+Secondary: #3DC2FF
+```
+
+## Row-Level Security
+
+### By Tenant
+
+```dax
+// Role: TenantAccess
+// Table: DimPlant
+[TenantID] = USERPRINCIPALNAME()
+```
+
+### By Plant
+
+```dax
+// Role: PlantManager
+// Table: DimPlant
+[PlantID] IN
+    SELECTCOLUMNS(
+        FILTER(UserPlantAccess,
+            UserPlantAccess[UserEmail] = USERPRINCIPALNAME()),
+        "PlantID", UserPlantAccess[PlantID]
+    )
+```
+
+## Refresh Configuration
+
+```yaml
+Type: Incremental Refresh
+
+Policy:
+  - Last 7 days: Full refresh every 1 hour
+  - Last 30 days: Daily refresh at 6:00 AM
+  - Historical (>30 days): Initial load only
+
+Dataflow:
+  - Refresh: Every 4 hours
+  - Timeout: 2 hours
+  - Retry: 3 attempts
+```
+
+## Best Practices
+
+1. **Star Schema** - Dimensional model with fact and dimension tables
+2. **Measures over Calculated Columns** - For aggregations, use measures
+3. **Avoid unnecessary CALCULATE** - Simple aggregations don't need it
+4. **Use Variables** - More readable and efficient
+5. **Incremental Refresh** - For large datasets
+
+## Related Skills
+
+- `duckdb-analytics`: Data preprocessing
+- `timescaledb`: Time-series data source
+- `technical-docs`: Report documentation

package/ai-config/skills/data-ai/pytorch/SKILL.md

@@ -0,0 +1,274 @@
+---
+name: pytorch
+description: >
+  Deep learning with PyTorch and Lightning for anomaly detection and time series forecasting.
+  Trigger: pytorch, deep learning, neural network, lightning, anomaly detection, forecasting
+tools:
+  - Read
+  - Write
+  - Bash
+  - Grep
+metadata:
+  author: plataforma-industrial
+  version: "2.0"
+  tags: [pytorch, deep-learning, lightning, ml, forecasting]
+  updated: "2026-02"
+---
+
+# PyTorch Skill
+
+Deep learning with PyTorch Lightning for anomaly detection and time series forecasting.
+
+## Stack
+
+```yaml
+torch: 2.2+
+lightning: 2.2+
+torchmetrics: 1.3+
+einops: 0.7+
+wandb: 0.16+  # logging
+```
+
+## Project Structure
+
+```
+src/ml/
+├── models/
+│   ├── autoencoder.py
+│   ├── transformer.py
+│   └── lstm.py
+├── data/
+│   ├── dataset.py
+│   └── preprocessing.py
+├── training/
+│   └── trainer.py
+└── inference/
+    └── predictor.py
+```
+
+## Autoencoder for Anomaly Detection
+
+```python
+import torch
+import torch.nn as nn
+import lightning as L
+from torchmetrics import F1Score, Precision, Recall
+
+class SensorAutoencoder(nn.Module):
+    def __init__(self, input_dim: int = 5, hidden_dims: list = [64, 32, 16], latent_dim: int = 8):
+        super().__init__()
+        # Encoder
+        encoder_layers = []
+        prev_dim = input_dim
+        for dim in hidden_dims:
+            encoder_layers.extend([
+                nn.Linear(prev_dim, dim), nn.BatchNorm1d(dim), nn.ReLU(), nn.Dropout(0.1)
+            ])
+            prev_dim = dim
+        encoder_layers.append(nn.Linear(prev_dim, latent_dim))
+        self.encoder = nn.Sequential(*encoder_layers)
+
+        # Decoder (mirror)
+        decoder_layers = []
+        prev_dim = latent_dim
+        for dim in reversed(hidden_dims):
+            decoder_layers.extend([
+                nn.Linear(prev_dim, dim), nn.BatchNorm1d(dim), nn.ReLU(), nn.Dropout(0.1)
+            ])
+            prev_dim = dim
+        decoder_layers.append(nn.Linear(prev_dim, input_dim))
+        self.decoder = nn.Sequential(*decoder_layers)
+
+    def forward(self, x):
+        z = self.encoder(x)
+        return self.decoder(z), z
+
+class AnomalyDetectorModule(L.LightningModule):
+    def __init__(self, input_dim: int = 5, learning_rate: float = 1e-3, threshold_percentile: float = 95):
+        super().__init__()
+        self.save_hyperparameters()
+        self.model = SensorAutoencoder(input_dim=input_dim)
+        self.threshold = None
+        self.f1 = F1Score(task="binary")
+
+    def forward(self, x):
+        return self.model(x)
+
+    def training_step(self, batch, batch_idx):
+        x, _ = batch
+        x_recon, _ = self(x)
+        loss = nn.functional.mse_loss(x_recon, x)
+        self.log("train_loss", loss, prog_bar=True)
+        return loss
+
+    def validation_step(self, batch, batch_idx):
+        x, labels = batch
+        x_recon, _ = self(x)
+        loss = nn.functional.mse_loss(x_recon, x)
+        recon_error = torch.mean((x - x_recon) ** 2, dim=1)
+        self.log("val_loss", loss, prog_bar=True)
+        return {"recon_error": recon_error, "labels": labels}
+
+    def configure_optimizers(self):
+        optimizer = torch.optim.AdamW(self.parameters(), lr=self.hparams.learning_rate, weight_decay=1e-5)
+        scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=100, eta_min=1e-6)
+        return {"optimizer": optimizer, "lr_scheduler": {"scheduler": scheduler, "monitor": "val_loss"}}
+```
+
+## Time Series Transformer
+
+```python
+import torch.nn as nn
+import math
+from einops import rearrange
+
+class PositionalEncoding(nn.Module):
+    def __init__(self, d_model: int, max_len: int = 5000):
+        super().__init__()
+        position = torch.arange(max_len).unsqueeze(1)
+        div_term = torch.exp(torch.arange(0, d_model, 2) * (-math.log(10000.0) / d_model))
+        pe = torch.zeros(max_len, 1, d_model)
+        pe[:, 0, 0::2] = torch.sin(position * div_term)
+        pe[:, 0, 1::2] = torch.cos(position * div_term)
+        self.register_buffer('pe', pe)
+
+    def forward(self, x):
+        return x + self.pe[:x.size(0)]
+
+class SensorTransformer(nn.Module):
+    def __init__(self, input_dim: int = 5, d_model: int = 64, nhead: int = 4,
+                 num_layers: int = 3, prediction_horizon: int = 12):
+        super().__init__()
+        self.prediction_horizon = prediction_horizon
+        self.input_projection = nn.Linear(input_dim, d_model)
+        self.pos_encoder = PositionalEncoding(d_model)
+        encoder_layer = nn.TransformerEncoderLayer(d_model=d_model, nhead=nhead,
+                                                    dim_feedforward=256, dropout=0.1, batch_first=False)
+        self.transformer_encoder = nn.TransformerEncoder(encoder_layer, num_layers=num_layers)
+        self.output_projection = nn.Linear(d_model, input_dim * prediction_horizon)
+
+    def forward(self, src):
+        src = rearrange(src, 'b s d -> s b d')
+        src = self.pos_encoder(self.input_projection(src))
+        output = self.transformer_encoder(src)
+        predictions = self.output_projection(output[-1])
+        return rearrange(predictions, 'b (h d) -> b h d', h=self.prediction_horizon)
+```
+
+## Dataset & DataModule
+
+```python
+from torch.utils.data import Dataset, DataLoader
+import numpy as np
+
+class SensorDataset(Dataset):
+    def __init__(self, data: np.ndarray, labels: np.ndarray = None,
+                 sequence_length: int = 100, prediction_horizon: int = 12, normalize: bool = True):
+        self.sequence_length = sequence_length
+        self.prediction_horizon = prediction_horizon
+        self.labels = labels
+
+        if normalize:
+            self.mean, self.std = np.mean(data, axis=0), np.std(data, axis=0) + 1e-8
+            self.data = (data - self.mean) / self.std
+        else:
+            self.data = data
+
+    def __len__(self):
+        return len(self.data) - self.sequence_length - self.prediction_horizon + 1
+
+    def __getitem__(self, idx):
+        x = torch.tensor(self.data[idx:idx + self.sequence_length], dtype=torch.float32)
+        y = torch.tensor(self.data[idx + self.sequence_length:idx + self.sequence_length + self.prediction_horizon], dtype=torch.float32)
+        if self.labels is not None:
+            return x, torch.tensor(self.labels[idx + self.sequence_length - 1], dtype=torch.long)
+        return x, y
+
+class SensorDataModule(L.LightningDataModule):
+    def __init__(self, data_path: str, batch_size: int = 32, num_workers: int = 4):
+        super().__init__()
+        self.data_path = data_path
+        self.batch_size = batch_size
+        self.num_workers = num_workers
+
+    def setup(self, stage=None):
+        data = np.load(self.data_path)
+        readings, labels = data['readings'], data.get('labels', None)
+        n = len(readings)
+        train_end, val_end = int(n * 0.7), int(n * 0.85)
+
+        self.train_dataset = SensorDataset(readings[:train_end], labels[:train_end] if labels else None)
+        self.val_dataset = SensorDataset(readings[train_end:val_end], labels[train_end:val_end] if labels else None)
+        self.test_dataset = SensorDataset(readings[val_end:], labels[val_end:] if labels else None)
+
+    def train_dataloader(self):
+        return DataLoader(self.train_dataset, batch_size=self.batch_size, shuffle=True, num_workers=self.num_workers, pin_memory=True)
+
+    def val_dataloader(self):
+        return DataLoader(self.val_dataset, batch_size=self.batch_size, num_workers=self.num_workers, pin_memory=True)
+```
+
+## Training Script
+
+```python
+import lightning as L
+from lightning.pytorch.callbacks import ModelCheckpoint, EarlyStopping, LearningRateMonitor
+from lightning.pytorch.loggers import WandbLogger
+
+def train(data_path: str, max_epochs: int = 100):
+    datamodule = SensorDataModule(data_path=data_path, batch_size=32)
+    model = AnomalyDetectorModule(input_dim=5, learning_rate=1e-3)
+
+    callbacks = [
+        ModelCheckpoint(dirpath="checkpoints", filename="{epoch:02d}-{val_loss:.4f}",
+                       monitor="val_loss", mode="min", save_top_k=3),
+        EarlyStopping(monitor="val_loss", patience=10, mode="min"),
+        LearningRateMonitor(logging_interval="epoch"),
+    ]
+
+    trainer = L.Trainer(
+        max_epochs=max_epochs,
+        accelerator="auto",
+        callbacks=callbacks,
+        logger=WandbLogger(project="ml-training"),
+        precision="16-mixed",
+        gradient_clip_val=1.0,
+    )
+
+    trainer.fit(model, datamodule)
+    trainer.test(model, datamodule)
+    return model
+```
+
+## Inference
+
+```python
+class Predictor:
+    def __init__(self, model_path: str, threshold: float, device: str = "cuda"):
+        self.device = torch.device(device if torch.cuda.is_available() else "cpu")
+        self.model = AnomalyDetectorModule.load_from_checkpoint(model_path)
+        self.model.to(self.device).eval()
+        self.threshold = threshold
+
+    @torch.no_grad()
+    def predict(self, readings: np.ndarray):
+        x = torch.tensor(readings, dtype=torch.float32).unsqueeze(0).to(self.device)
+        x_recon, _ = self.model(x)
+        error = torch.mean((x - x_recon) ** 2, dim=-1).squeeze().cpu().numpy()
+        return error, error > self.threshold
+```
+
+## Best Practices
+
+1. **Mixed precision** - `precision="16-mixed"` for faster training
+2. **Gradient clipping** - Prevent exploding gradients with `gradient_clip_val=1.0`
+3. **LR scheduling** - CosineAnnealingLR or ReduceLROnPlateau
+4. **Save normalization params** - Include mean/std in checkpoint
+5. **torch.compile** - Use for inference: `model = torch.compile(model, mode="reduce-overhead")`
+
+## Related Skills
+
+- `onnx-inference`: Model export and deployment
+- `mlflow`: Experiment tracking
+- `scikit-learn`: Classical ML comparison
+- `ai-ml`: Full training pipelines