omgkit 2.20.0 → 2.21.0

package/plugin/skills/ml-systems/edge-deployment/SKILL.md

@@ -0,0 +1,366 @@
+---
+name: edge-deployment
+description: Edge deployment strategies including mobile optimization, embedded systems, TFLite, Core ML, and resource-constrained inference.
+---
+
+# Edge Deployment
+
+Deploying ML models to edge devices.
+
+## Edge Deployment Landscape
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                   EDGE DEPLOYMENT TARGETS                    │
+├─────────────────────────────────────────────────────────────┤
+│                                                              │
+│  MOBILE              EMBEDDED           IOT/SENSORS         │
+│  ──────              ────────           ───────────         │
+│  iOS (Core ML)       Raspberry Pi       Arduino/ESP32       │
+│  Android (TFLite)    NVIDIA Jetson      Microcontrollers    │
+│  React Native        Google Coral       FPGA boards         │
+│                                                              │
+│  CONSTRAINTS:                                                │
+│  ├── Memory: 256MB - 8GB                                    │
+│  ├── Compute: CPU/GPU/NPU                                   │
+│  ├── Power: Battery/USB/Wall                                │
+│  ├── Connectivity: Always/Sometimes/Never                   │
+│  └── Latency: 1ms - 100ms                                   │
+│                                                              │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## TensorFlow Lite
+
+### Model Conversion
+```python
+import tensorflow as tf
+
+# Basic conversion
+converter = tf.lite.TFLiteConverter.from_saved_model('saved_model/')
+tflite_model = converter.convert()
+
+# With optimizations
+converter.optimizations = [tf.lite.Optimize.DEFAULT]
+
+# Float16 quantization
+converter.target_spec.supported_types = [tf.float16]
+
+# Full integer quantization
+def representative_dataset():
+    for data in calibration_data:
+        yield [data.astype(np.float32)]
+
+converter.representative_dataset = representative_dataset
+converter.target_spec.supported_ops = [tf.lite.OpsSet.TFLITE_BUILTINS_INT8]
+converter.inference_input_type = tf.int8
+converter.inference_output_type = tf.int8
+
+# Save model
+with open('model.tflite', 'wb') as f:
+    f.write(converter.convert())
+```
+
+### TFLite Inference
+```python
+import numpy as np
+import tensorflow as tf
+
+# Load model
+interpreter = tf.lite.Interpreter(model_path='model.tflite')
+interpreter.allocate_tensors()
+
+# Get input/output details
+input_details = interpreter.get_input_details()
+output_details = interpreter.get_output_details()
+
+# Inference
+def predict(input_data):
+    interpreter.set_tensor(input_details[0]['index'], input_data)
+    interpreter.invoke()
+    return interpreter.get_tensor(output_details[0]['index'])
+
+# With delegate (GPU acceleration)
+delegate = tf.lite.experimental.load_delegate('libedgetpu.so.1')
+interpreter = tf.lite.Interpreter(
+    model_path='model_edgetpu.tflite',
+    experimental_delegates=[delegate]
+)
+```
+
+## Core ML (iOS)
+
+### PyTorch to Core ML
+```python
+import coremltools as ct
+import torch
+
+# Export to Core ML
+model.eval()
+example_input = torch.rand(1, 3, 224, 224)
+traced_model = torch.jit.trace(model, example_input)
+
+mlmodel = ct.convert(
+    traced_model,
+    inputs=[ct.TensorType(shape=example_input.shape, name="image")],
+    outputs=[ct.TensorType(name="predictions")],
+    compute_precision=ct.precision.FLOAT16,
+    minimum_deployment_target=ct.target.iOS15
+)
+
+# Add metadata
+mlmodel.author = "Your Name"
+mlmodel.short_description = "Image classifier"
+mlmodel.input_description["image"] = "Input image"
+mlmodel.output_description["predictions"] = "Class probabilities"
+
+mlmodel.save("Model.mlpackage")
+```
+
+### Swift Integration
+```swift
+import CoreML
+import Vision
+
+class ModelInference {
+    let model: VNCoreMLModel
+
+    init() throws {
+        let config = MLModelConfiguration()
+        config.computeUnits = .all  // Use Neural Engine
+        let mlModel = try MyModel(configuration: config)
+        self.model = try VNCoreMLModel(for: mlModel.model)
+    }
+
+    func predict(image: CGImage, completion: @escaping ([String: Double]) -> Void) {
+        let request = VNCoreMLRequest(model: model) { request, error in
+            guard let results = request.results as? [VNClassificationObservation] else { return }
+            let predictions = Dictionary(
+                uniqueKeysWithValues: results.prefix(5).map { ($0.identifier, Double($0.confidence)) }
+            )
+            completion(predictions)
+        }
+
+        let handler = VNImageRequestHandler(cgImage: image)
+        try? handler.perform([request])
+    }
+}
+```
+
+## NVIDIA Jetson
+
+### TensorRT Optimization
+```python
+import tensorrt as trt
+
+def build_engine(onnx_path, engine_path, precision='fp16'):
+    logger = trt.Logger(trt.Logger.INFO)
+    builder = trt.Builder(logger)
+    network = builder.create_network(
+        1 << int(trt.NetworkDefinitionCreationFlag.EXPLICIT_BATCH)
+    )
+    parser = trt.OnnxParser(network, logger)
+
+    # Parse ONNX
+    with open(onnx_path, 'rb') as f:
+        parser.parse(f.read())
+
+    # Build config
+    config = builder.create_builder_config()
+    config.max_workspace_size = 1 << 30  # 1GB
+
+    if precision == 'fp16':
+        config.set_flag(trt.BuilderFlag.FP16)
+    elif precision == 'int8':
+        config.set_flag(trt.BuilderFlag.INT8)
+        config.int8_calibrator = EntropyCalibrator(calibration_data)
+
+    # Build engine
+    engine = builder.build_engine(network, config)
+
+    with open(engine_path, 'wb') as f:
+        f.write(engine.serialize())
+
+    return engine
+
+# Inference with TensorRT
+class TRTInference:
+    def __init__(self, engine_path):
+        logger = trt.Logger(trt.Logger.WARNING)
+        with open(engine_path, 'rb') as f:
+            self.engine = trt.Runtime(logger).deserialize_cuda_engine(f.read())
+        self.context = self.engine.create_execution_context()
+
+    def infer(self, input_data):
+        # Allocate buffers and run inference
+        pass
+```
+
+### DeepStream Pipeline
+```python
+# DeepStream config for video inference
+# config_infer_primary.txt
+"""
+[property]
+gpu-id=0
+net-scale-factor=0.0039215697906911373
+model-file=resnet18.onnx
+model-engine-file=resnet18.engine
+labelfile-path=labels.txt
+batch-size=4
+network-mode=2  # FP16
+num-detected-classes=80
+interval=0
+gie-unique-id=1
+process-mode=1
+network-type=0
+cluster-mode=2
+maintain-aspect-ratio=1
+symmetric-padding=1
+"""
+
+# Python pipeline
+import gi
+gi.require_version('Gst', '1.0')
+from gi.repository import Gst
+
+Gst.init(None)
+pipeline = Gst.parse_launch("""
+    filesrc location=video.mp4 !
+    decodebin !
+    nvvideoconvert !
+    nvinfer config-file-path=config.txt !
+    nvdsosd !
+    nvegltransform !
+    nveglglessink
+""")
+pipeline.set_state(Gst.State.PLAYING)
+```
+
+## Microcontroller Deployment
+
+### TensorFlow Lite Micro
+```cpp
+#include "tensorflow/lite/micro/all_ops_resolver.h"
+#include "tensorflow/lite/micro/micro_interpreter.h"
+#include "model_data.h"
+
+// Allocate tensor arena
+constexpr int kTensorArenaSize = 10 * 1024;
+uint8_t tensor_arena[kTensorArenaSize];
+
+void setup() {
+    // Set up model
+    const tflite::Model* model = tflite::GetModel(model_data);
+
+    // Set up resolver
+    tflite::AllOpsResolver resolver;
+
+    // Build interpreter
+    tflite::MicroInterpreter interpreter(
+        model, resolver, tensor_arena, kTensorArenaSize
+    );
+    interpreter.AllocateTensors();
+
+    // Get input tensor
+    TfLiteTensor* input = interpreter.input(0);
+
+    // Fill input and invoke
+    // input->data.f[0] = sensor_value;
+    interpreter.Invoke();
+
+    // Get output
+    TfLiteTensor* output = interpreter.output(0);
+    float prediction = output->data.f[0];
+}
+```
+
+## Model Optimization for Edge
+
+```python
+def optimize_for_edge(model, target_size_mb=10, target_latency_ms=50):
+    """Optimize model for edge deployment."""
+    optimizations = []
+
+    # 1. Quantization
+    quantized = quantize_dynamic(model, {nn.Linear, nn.Conv2d}, dtype=torch.qint8)
+    if get_size_mb(quantized) <= target_size_mb:
+        optimizations.append(('quantization', quantized))
+
+    # 2. Pruning
+    pruned = prune_model(model, amount=0.5)
+    if get_size_mb(pruned) <= target_size_mb:
+        optimizations.append(('pruning', pruned))
+
+    # 3. Knowledge distillation
+    student = create_smaller_model(model)
+    distilled = distill(teacher=model, student=student)
+    if get_size_mb(distilled) <= target_size_mb:
+        optimizations.append(('distillation', distilled))
+
+    # Evaluate each
+    results = []
+    for name, opt_model in optimizations:
+        latency = measure_latency(opt_model)
+        accuracy = evaluate(opt_model)
+        if latency <= target_latency_ms:
+            results.append({
+                'method': name,
+                'latency': latency,
+                'accuracy': accuracy,
+                'size_mb': get_size_mb(opt_model)
+            })
+
+    return sorted(results, key=lambda x: x['accuracy'], reverse=True)
+```
+
+## Offline Inference
+
+```python
+class OfflineInferenceManager:
+    def __init__(self, model_path, cache_dir='./cache'):
+        self.model = load_model(model_path)
+        self.cache_dir = cache_dir
+        self.pending_queue = []
+
+    def predict(self, input_data, priority='normal'):
+        """Run inference locally."""
+        return self.model(input_data)
+
+    def predict_with_fallback(self, input_data, cloud_endpoint=None):
+        """Try cloud first, fall back to local."""
+        try:
+            if self._is_online() and cloud_endpoint:
+                return self._cloud_predict(input_data, cloud_endpoint)
+        except Exception:
+            pass
+
+        return self.predict(input_data)
+
+    def queue_for_sync(self, input_data, result):
+        """Queue predictions for later sync."""
+        self.pending_queue.append({
+            'input': input_data,
+            'result': result,
+            'timestamp': time.time()
+        })
+
+    def sync_when_online(self, endpoint):
+        """Sync queued predictions when connectivity restored."""
+        while self.pending_queue and self._is_online():
+            item = self.pending_queue.pop(0)
+            requests.post(endpoint, json=item)
+```
+
+## Commands
+- `/omgdeploy:edge` - Edge deployment
+- `/omgoptim:quantize` - Quantization
+- `/omgdeploy:package` - Package for target
+
+## Best Practices
+
+1. Profile on target device early
+2. Use hardware-specific frameworks
+3. Quantize to int8 when possible
+4. Implement offline fallbacks
+5. Monitor battery and thermal impact

package/plugin/skills/ml-systems/efficient-ai/SKILL.md

@@ -0,0 +1,316 @@
+---
+name: efficient-ai
+description: Efficient AI techniques including model compression, quantization, pruning, knowledge distillation, and hardware-aware optimization for production systems.
+---
+
+# Efficient AI
+
+Techniques for building resource-efficient ML systems.
+
+## Model Compression Overview
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                 MODEL COMPRESSION TECHNIQUES                 │
+├─────────────────────────────────────────────────────────────┤
+│                                                              │
+│  QUANTIZATION         PRUNING            DISTILLATION       │
+│  ─────────────        ──────────         ────────────       │
+│  FP32 → INT8          Remove weights     Teacher→Student    │
+│  2-4x smaller         50-90% sparse      10-100x smaller    │
+│  1.5-3x faster        2-4x faster        Same accuracy      │
+│                                                              │
+│  ARCHITECTURE         LOW-RANK           NEURAL ARCH        │
+│  ─────────────        ──────────         ────────────       │
+│  MobileNet            Matrix decomp      AutoML search      │
+│  EfficientNet         LoRA adapters      Hardware-aware     │
+│  Depth-separable      Rank reduction     Latency targets    │
+│                                                              │
+└─────────────────────────────────────────────────────────────┘
+```
+
+## Quantization
+
+### Post-Training Quantization
+```python
+import torch
+from torch.quantization import quantize_dynamic, quantize_static
+
+# Dynamic quantization (weights only)
+model_dynamic = quantize_dynamic(
+    model,
+    {torch.nn.Linear, torch.nn.LSTM},
+    dtype=torch.qint8
+)
+
+# Static quantization (weights + activations)
+model.qconfig = torch.quantization.get_default_qconfig('fbgemm')
+model_prepared = torch.quantization.prepare(model)
+
+# Calibrate with representative data
+with torch.no_grad():
+    for batch in calibration_loader:
+        model_prepared(batch)
+
+model_static = torch.quantization.convert(model_prepared)
+```
+
+### Quantization-Aware Training
+```python
+import torch.quantization as quant
+
+class QuantizedModel(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.quant = quant.QuantStub()
+        self.dequant = quant.DeQuantStub()
+        self.layers = nn.Sequential(
+            nn.Linear(784, 256),
+            nn.ReLU(),
+            nn.Linear(256, 10)
+        )
+
+    def forward(self, x):
+        x = self.quant(x)
+        x = self.layers(x)
+        x = self.dequant(x)
+        return x
+
+# Enable QAT
+model.qconfig = quant.get_default_qat_qconfig('fbgemm')
+model = quant.prepare_qat(model)
+
+# Train normally
+for epoch in range(epochs):
+    train(model, train_loader)
+
+# Convert to quantized
+model = quant.convert(model)
+```
+
+## Pruning
+
+### Magnitude Pruning
+```python
+import torch.nn.utils.prune as prune
+
+# Unstructured pruning (individual weights)
+prune.l1_unstructured(model.layer1, name='weight', amount=0.3)
+
+# Structured pruning (entire channels)
+prune.ln_structured(
+    model.conv1, name='weight', amount=0.5,
+    n=2, dim=0  # Prune 50% of output channels
+)
+
+# Global pruning (across layers)
+parameters_to_prune = [
+    (model.layer1, 'weight'),
+    (model.layer2, 'weight'),
+]
+prune.global_unstructured(
+    parameters_to_prune,
+    pruning_method=prune.L1Unstructured,
+    amount=0.4
+)
+
+# Make pruning permanent
+for module, name in parameters_to_prune:
+    prune.remove(module, name)
+```
+
+### Iterative Pruning with Fine-tuning
+```python
+def iterative_pruning(model, train_loader, target_sparsity=0.9):
+    current_sparsity = 0
+    sparsity_schedule = [0.5, 0.75, 0.9]
+
+    for target in sparsity_schedule:
+        # Prune
+        for name, module in model.named_modules():
+            if isinstance(module, nn.Linear):
+                prune.l1_unstructured(module, 'weight', amount=target)
+
+        # Fine-tune
+        for epoch in range(fine_tune_epochs):
+            train_epoch(model, train_loader)
+
+        # Measure sparsity
+        total_zeros = sum((p == 0).sum().item() for p in model.parameters())
+        total_params = sum(p.numel() for p in model.parameters())
+        current_sparsity = total_zeros / total_params
+        print(f"Sparsity: {current_sparsity:.2%}")
+
+    return model
+```
+
+## Knowledge Distillation
+
+```python
+class DistillationLoss(nn.Module):
+    def __init__(self, temperature=4.0, alpha=0.5):
+        super().__init__()
+        self.temperature = temperature
+        self.alpha = alpha
+        self.ce_loss = nn.CrossEntropyLoss()
+        self.kl_loss = nn.KLDivLoss(reduction='batchmean')
+
+    def forward(self, student_logits, teacher_logits, labels):
+        # Hard label loss
+        hard_loss = self.ce_loss(student_logits, labels)
+
+        # Soft label loss (distillation)
+        soft_student = F.log_softmax(student_logits / self.temperature, dim=1)
+        soft_teacher = F.softmax(teacher_logits / self.temperature, dim=1)
+        soft_loss = self.kl_loss(soft_student, soft_teacher) * (self.temperature ** 2)
+
+        return self.alpha * hard_loss + (1 - self.alpha) * soft_loss
+
+# Training loop
+teacher.eval()
+for batch in train_loader:
+    x, y = batch
+    with torch.no_grad():
+        teacher_logits = teacher(x)
+    student_logits = student(x)
+    loss = distill_loss(student_logits, teacher_logits, y)
+    loss.backward()
+    optimizer.step()
+```
+
+## Efficient Architectures
+
+### Depth-Separable Convolutions
+```python
+class DepthSeparableConv(nn.Module):
+    def __init__(self, in_channels, out_channels, kernel_size=3):
+        super().__init__()
+        self.depthwise = nn.Conv2d(
+            in_channels, in_channels, kernel_size,
+            padding=kernel_size//2, groups=in_channels
+        )
+        self.pointwise = nn.Conv2d(in_channels, out_channels, 1)
+
+    def forward(self, x):
+        x = self.depthwise(x)
+        x = self.pointwise(x)
+        return x
+
+# Compare params: Regular 3x3 conv with C_in=64, C_out=128
+# Regular: 64 * 128 * 3 * 3 = 73,728 params
+# DepthSep: 64 * 3 * 3 + 64 * 128 = 576 + 8,192 = 8,768 params (8.4x fewer)
+```
+
+### MobileNet Inverted Residual Block
+```python
+class InvertedResidual(nn.Module):
+    def __init__(self, in_ch, out_ch, stride, expand_ratio):
+        super().__init__()
+        hidden_dim = in_ch * expand_ratio
+        self.use_residual = stride == 1 and in_ch == out_ch
+
+        self.conv = nn.Sequential(
+            # Expand
+            nn.Conv2d(in_ch, hidden_dim, 1, bias=False),
+            nn.BatchNorm2d(hidden_dim),
+            nn.ReLU6(inplace=True),
+            # Depthwise
+            nn.Conv2d(hidden_dim, hidden_dim, 3, stride, 1, groups=hidden_dim, bias=False),
+            nn.BatchNorm2d(hidden_dim),
+            nn.ReLU6(inplace=True),
+            # Project
+            nn.Conv2d(hidden_dim, out_ch, 1, bias=False),
+            nn.BatchNorm2d(out_ch),
+        )
+
+    def forward(self, x):
+        if self.use_residual:
+            return x + self.conv(x)
+        return self.conv(x)
+```
+
+## Low-Rank Factorization
+
+```python
+import torch.nn.utils.parametrize as parametrize
+
+class LowRankLinear(nn.Module):
+    def __init__(self, in_features, out_features, rank):
+        super().__init__()
+        self.A = nn.Linear(in_features, rank, bias=False)
+        self.B = nn.Linear(rank, out_features, bias=True)
+
+    def forward(self, x):
+        return self.B(self.A(x))
+
+# LoRA-style adaptation
+class LoRALayer(nn.Module):
+    def __init__(self, original_layer, rank=8, alpha=16):
+        super().__init__()
+        self.original = original_layer
+        self.lora_A = nn.Linear(original_layer.in_features, rank, bias=False)
+        self.lora_B = nn.Linear(rank, original_layer.out_features, bias=False)
+        self.scaling = alpha / rank
+
+        nn.init.kaiming_uniform_(self.lora_A.weight)
+        nn.init.zeros_(self.lora_B.weight)
+
+    def forward(self, x):
+        return self.original(x) + self.scaling * self.lora_B(self.lora_A(x))
+```
+
+## Efficiency Metrics
+
+```python
+def measure_efficiency(model, input_shape, device='cuda'):
+    import time
+
+    model = model.to(device)
+    model.eval()
+
+    # Model size
+    param_size = sum(p.numel() * p.element_size() for p in model.parameters())
+    buffer_size = sum(b.numel() * b.element_size() for b in model.buffers())
+    size_mb = (param_size + buffer_size) / 1024 / 1024
+
+    # FLOPs (using thop)
+    from thop import profile
+    dummy_input = torch.randn(1, *input_shape).to(device)
+    flops, params = profile(model, inputs=(dummy_input,))
+
+    # Latency
+    warmup = 10
+    iterations = 100
+
+    for _ in range(warmup):
+        model(dummy_input)
+
+    torch.cuda.synchronize()
+    start = time.time()
+    for _ in range(iterations):
+        model(dummy_input)
+    torch.cuda.synchronize()
+    latency_ms = (time.time() - start) / iterations * 1000
+
+    return {
+        "size_mb": size_mb,
+        "params": params,
+        "flops": flops,
+        "latency_ms": latency_ms,
+        "throughput": 1000 / latency_ms
+    }
+```
+
+## Commands
+- `/omgoptim:quantize` - Apply quantization
+- `/omgoptim:prune` - Apply pruning
+- `/omgoptim:distill` - Knowledge distillation
+- `/omgoptim:profile` - Profile efficiency
+
+## Best Practices
+
+1. Start with the largest model that works
+2. Quantize first (usually free accuracy)
+3. Prune iteratively with fine-tuning
+4. Use distillation for maximum compression
+5. Profile on target hardware