@defai.digital/automatosx 12.8.7 → 13.1.3

package/examples/pytorch_resnet50_training.py

@@ -1,289 +0,0 @@
-"""
-Mixed precision ResNet-50 training loop for image classification.
-
-Author: Mira — "From architecture to inference - I build models that ship."
-
-This script focuses on the core PyTorch 2.x training primitives:
-- ImageFolder-based DataLoader with realistic augmentations
-- Transfer learning from torchvision's pretrained ResNet-50
-- Mixed precision training via torch.amp.autocast + GradScaler
-- torch.compile() to squeeze extra throughput from the forward pass
-
-Expected directory structure for the dataset:
-data_root/
-  train/
-    class_a/*.jpg
-    class_b/*.jpg
-  val/
-    class_a/*.jpg
-    class_b/*.jpg
-
-Run:
-  python examples/pytorch_resnet50_training.py --data-root /path/to/data
-"""
-
-from __future__ import annotations
-
-import argparse
-import random
-import time
-from dataclasses import dataclass
-from pathlib import Path
-from typing import Tuple
-
-import torch
-from torch import nn
-from torch.amp import GradScaler, autocast
-from torch.optim import Optimizer
-from torch.optim.lr_scheduler import CosineAnnealingLR
-from torch.utils.data import DataLoader
-from torchvision import datasets, transforms
-from torchvision.models import ResNet50_Weights, resnet50
-from tqdm import tqdm
-
-
-@dataclass
-class TrainConfig:
-  data_root: Path
-  batch_size: int = 64
-  num_workers: int = 8
-  epochs: int = 20
-  learning_rate: float = 5e-4
-  weight_decay: float = 0.01
-  seed: int = 17
-  output_dir: Path = Path("artifacts/checkpoints")
-  log_every: int = 25
-  num_classes: int | None = None
-
-
-def set_seed(seed: int) -> None:
-  random.seed(seed)
-  torch.manual_seed(seed)
-  torch.cuda.manual_seed_all(seed)
-  torch.backends.cudnn.deterministic = False
-  torch.backends.cudnn.benchmark = True
-
-
-def build_dataloaders(cfg: TrainConfig) -> Tuple[DataLoader, DataLoader, int]:
-  """Construct train/val DataLoaders and infer class count."""
-  train_dir = cfg.data_root / "train"
-  val_dir = cfg.data_root / "val"
-
-  if not train_dir.is_dir() or not val_dir.is_dir():
-    raise FileNotFoundError(
-        f"Expecting 'train' and 'val' subdirectories under {cfg.data_root}"
-    )
-
-  train_tfms = transforms.Compose(
-      [
-          transforms.RandomResizedCrop(224, scale=(0.6, 1.0)),
-          transforms.RandomHorizontalFlip(),
-          transforms.ColorJitter(0.2, 0.2, 0.2, 0.1),
-          transforms.RandomApply(
-              [transforms.GaussianBlur(kernel_size=3, sigma=(0.1, 2.0))], p=0.3
-          ),
-          transforms.ToTensor(),
-          transforms.Normalize(
-              mean=ResNet50_Weights.IMAGENET1K_V2.meta["mean"],
-              std=ResNet50_Weights.IMAGENET1K_V2.meta["std"],
-          ),
-      ]
-  )
-
-  eval_tfms = transforms.Compose(
-      [
-          transforms.Resize(256),
-          transforms.CenterCrop(224),
-          transforms.ToTensor(),
-          transforms.Normalize(
-              mean=ResNet50_Weights.IMAGENET1K_V2.meta["mean"],
-              std=ResNet50_Weights.IMAGENET1K_V2.meta["std"],
-          ),
-      ]
-  )
-
-  train_dataset = datasets.ImageFolder(train_dir, transform=train_tfms)
-  val_dataset = datasets.ImageFolder(val_dir, transform=eval_tfms)
-  num_classes = len(train_dataset.classes)
-
-  loader_kwargs = dict(
-      batch_size=cfg.batch_size,
-      num_workers=cfg.num_workers,
-      pin_memory=True,
-      persistent_workers=cfg.num_workers > 0,
-  )
-
-  train_loader = DataLoader(train_dataset, shuffle=True, drop_last=True, **loader_kwargs)
-  val_loader = DataLoader(val_dataset, shuffle=False, drop_last=False, **loader_kwargs)
-
-  return train_loader, val_loader, num_classes
-
-
-def build_model(num_classes: int) -> nn.Module:
-  """Load pretrained ResNet-50 and replace the classification head."""
-  base_model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)
-  in_features = base_model.fc.in_features
-  base_model.fc = nn.Sequential(
-      nn.Dropout(p=0.2),
-      nn.Linear(in_features, num_classes),
-  )
-  return base_model
-
-
-def accuracy(output: torch.Tensor, target: torch.Tensor) -> torch.Tensor:
-  preds = output.argmax(dim=1)
-  return (preds == target).float().mean()
-
-
-def train_one_epoch(
-    model: nn.Module,
-    loader: DataLoader,
-    optimizer: Optimizer,
-    scaler: GradScaler,
-    device: torch.device,
-    epoch: int,
-    cfg: TrainConfig,
-) -> Tuple[float, float]:
-  model.train()
-  running_loss = 0.0
-  running_acc = 0.0
-
-  for step, (images, labels) in enumerate(tqdm(loader, desc=f"Epoch {epoch} [train]")):
-    images = images.to(device, non_blocking=True)
-    labels = labels.to(device, non_blocking=True)
-
-    optimizer.zero_grad(set_to_none=True)
-
-    with autocast(device_type=device.type, dtype=torch.float16 if device.type == "cuda" else torch.bfloat16):
-      logits = model(images)
-      loss = nn.functional.cross_entropy(logits, labels)
-
-    scaler.scale(loss).backward()
-    scaler.unscale_(optimizer)
-    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
-    scaler.step(optimizer)
-    scaler.update()
-
-    with torch.no_grad():
-      running_loss += loss.item()
-      running_acc += accuracy(logits, labels).item()
-
-    if step % cfg.log_every == 0:
-      current_lr = optimizer.param_groups[0]["lr"]
-      print(
-          f"Epoch {epoch} | step {step:04d} | lr {current_lr:.2e} | "
-          f"loss {loss.item():.4f}"
-      )
-
-  steps = len(loader)
-  return running_loss / steps, running_acc / steps
-
-
-@torch.no_grad()
-def evaluate(
-    model: nn.Module,
-    loader: DataLoader,
-    device: torch.device,
-) -> Tuple[float, float]:
-  model.eval()
-  total_loss = 0.0
-  total_acc = 0.0
-
-  for images, labels in tqdm(loader, desc="Validation"):
-    images = images.to(device, non_blocking=True)
-    labels = labels.to(device, non_blocking=True)
-
-    logits = model(images)
-    total_loss += nn.functional.cross_entropy(logits, labels).item()
-    total_acc += accuracy(logits, labels).item()
-
-  steps = len(loader)
-  return total_loss / steps, total_acc / steps
-
-
-def save_checkpoint(
-    model: nn.Module,
-    optimizer: Optimizer,
-    epoch: int,
-    cfg: TrainConfig,
-    metric: float,
-) -> None:
-  cfg.output_dir.mkdir(parents=True, exist_ok=True)
-  ckpt = {
-      "epoch": epoch,
-      "state_dict": model.state_dict(),
-      "optimizer_state": optimizer.state_dict(),
-      "val_top1": metric,
-  }
-  torch.save(ckpt, cfg.output_dir / f"resnet50_epoch{epoch:03d}_acc{metric:.3f}.pt")
-
-
-def train_model(cfg: TrainConfig) -> None:
-  set_seed(cfg.seed)
-
-  train_loader, val_loader, inferred_classes = build_dataloaders(cfg)
-  num_classes = cfg.num_classes or inferred_classes
-
-  device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-  print(f"Using device: {device}")
-
-  torch.set_float32_matmul_precision("high")
-  model = build_model(num_classes).to(device)
-  model = torch.compile(model)  # PyTorch 2.x graph capture for extra throughput
-
-  optimizer = torch.optim.AdamW(
-      model.parameters(), lr=cfg.learning_rate, weight_decay=cfg.weight_decay
-  )
-  scheduler = CosineAnnealingLR(optimizer, T_max=cfg.epochs)
-  scaler = GradScaler(device.type if device.type == "cuda" else "cpu")
-
-  best_acc = 0.0
-
-  for epoch in range(1, cfg.epochs + 1):
-    epoch_start = time.time()
-
-    train_loss, train_acc = train_one_epoch(
-        model, train_loader, optimizer, scaler, device, epoch, cfg
-    )
-    val_loss, val_acc = evaluate(model, val_loader, device)
-    scheduler.step()
-
-    elapsed = time.time() - epoch_start
-    print(
-        f"Epoch {epoch:02d} finished in {elapsed:.1f}s | "
-        f"train loss {train_loss:.4f}, train acc {train_acc*100:.2f}% | "
-        f"val loss {val_loss:.4f}, val acc {val_acc*100:.2f}%"
-    )
-
-    if val_acc > best_acc:
-      best_acc = val_acc
-      save_checkpoint(model, optimizer, epoch, cfg, metric=val_acc)
-
-
-def parse_args() -> TrainConfig:
-  parser = argparse.ArgumentParser(description="ResNet-50 mixed precision training")
-  parser.add_argument("--data-root", type=Path, required=True, help="Dataset root path")
-  parser.add_argument("--epochs", type=int, default=20)
-  parser.add_argument("--batch-size", type=int, default=64)
-  parser.add_argument("--num-workers", type=int, default=8)
-  parser.add_argument("--lr", type=float, default=5e-4)
-  parser.add_argument("--weight-decay", type=float, default=0.01)
-  parser.add_argument("--seed", type=int, default=17)
-  parser.add_argument("--output-dir", type=Path, default=Path("artifacts/checkpoints"))
-  args = parser.parse_args()
-
-  return TrainConfig(
-      data_root=args.data_root,
-      epochs=args.epochs,
-      batch_size=args.batch_size,
-      num_workers=args.num_workers,
-      learning_rate=args.lr,
-      weight_decay=args.weight_decay,
-      seed=args.seed,
-      output_dir=args.output_dir,
-  )
-
-
-if __name__ == "__main__":
-  config = parse_args()
-  train_model(config)

package/examples/specs/automatosx-release.ax.yaml

@@ -1,380 +0,0 @@
-version: "1.0"
-
-metadata:
-  id: automatosx-release
-  name: AutomatosX Release Workflow
-  description: |
-    Complete release orchestration for AutomatosX using Spec-Kit.
-    Demonstrates "dogfooding" - using AutomatosX to manage its own releases.
-
-    This spec covers the entire release process:
-    - Pre-flight validation
-    - Version bumping and synchronization
-    - CHANGELOG updates
-    - Building and testing
-    - Git operations (commit, tag, push)
-    - GitHub release creation
-    - CI/CD monitoring
-
-  tags:
-    - release
-    - ci-cd
-    - automation
-    - dogfooding
-  author: AutomatosX Team
-  created: "2025-11-01"
-
-# Policy: Use most reliable providers for release automation
-policy:
-  goal: reliability
-  constraints:
-    latency:
-      p95: 5000  # 5s max latency
-    reliability:
-      minAvailability: 0.99  # 99% availability required
-      maxErrorRate: 0.01     # 1% max error rate
-
-# Actors: Specialized agents for each release stage
-actors:
-  - id: validator
-    agent: quality
-    description: Validates release readiness (tests, build, git status)
-    delegation:
-      maxDepth: 1
-
-  - id: version-manager
-    agent: backend
-    description: Handles version bumping and synchronization
-    delegation:
-      maxDepth: 1
-
-  - id: changelog-writer
-    agent: documentation
-    description: Updates and validates CHANGELOG entries
-    delegation:
-      maxDepth: 1
-
-  - id: builder
-    agent: backend
-    description: Builds and tests the project
-    delegation:
-      maxDepth: 1
-
-  - id: git-operator
-    agent: devops
-    description: Handles git operations (commit, tag, push)
-    delegation:
-      maxDepth: 1
-
-  - id: release-publisher
-    agent: devops
-    description: Creates GitHub releases and monitors CI/CD
-    delegation:
-      maxDepth: 2
-
-# Execution stages
-stages:
-  # Stage 1: Pre-flight validation
-  - id: preflight
-    actor: validator
-    description: "Pre-flight validation checks"
-    prompt: |
-      Run comprehensive pre-flight validation checks for AutomatosX release:
-
-      CHECKS REQUIRED:
-      1. Git status is clean (no uncommitted changes)
-      2. On main branch
-      3. All tests pass (npm test)
-      4. TypeScript compiles (npm run typecheck)
-      5. Build succeeds (npm run build)
-      6. No npm audit vulnerabilities (moderate+)
-      7. package.json has required fields
-
-      Use the existing tools/check-release.js script to perform validation.
-
-      OUTPUT FORMAT:
-      - List each check with ✓ (pass) or ✗ (fail)
-      - If any checks fail, provide detailed error messages
-      - Recommend fixes for failed checks
-      - Return READY or NOT_READY status
-    timeout: 300000  # 5 minutes
-    saveToMemory: true
-    dependencies: []
-
-  # Stage 2: Version determination
-  - id: version-bump
-    actor: version-manager
-    description: "Determine and apply version bump"
-    prompt: |
-      Determine version bump type and update package.json:
-
-      CURRENT VERSION: ${preflight.currentVersion}
-
-      BUMP TYPE RULES:
-      - patch: Bug fixes, minor improvements (x.x.X)
-      - minor: New features, backwards compatible (x.X.0)
-      - major: Breaking changes (X.0.0)
-
-      TASKS:
-      1. Analyze recent commits to suggest bump type
-      2. Apply version bump using npm version
-      3. Run tools/sync-all-versions.js to update all references
-      4. Verify version sync in README.md and CLAUDE.md
-
-      OUTPUT:
-      - Current version
-      - New version
-      - Bump type
-      - Files updated
-    timeout: 120000  # 2 minutes
-    saveToMemory: true
-    dependencies: [preflight]
-
-  # Stage 3: CHANGELOG update
-  - id: changelog
-    actor: changelog-writer
-    description: "Validate or generate CHANGELOG entry"
-    prompt: |
-      Validate CHANGELOG.md has entry for new version:
-
-      NEW VERSION: ${version-bump.newVersion}
-
-      TASKS:
-      1. Check if CHANGELOG.md contains ## [${version-bump.newVersion}]
-      2. If missing, extract recent changes from git commits
-      3. Generate CHANGELOG entry following existing format
-      4. Include:
-         - Features (feat: commits)
-         - Bug fixes (fix: commits)
-         - Breaking changes (BREAKING CHANGE)
-         - Documentation updates (docs: commits)
-      5. Add proper date and version header
-
-      CHANGELOG FORMAT:
-      ```markdown
-      ## [X.Y.Z] - YYYY-MM-DD
-
-      ### Features
-      - Description of feature
-
-      ### Bug Fixes
-      - Description of fix
-
-      ### Documentation
-      - Description of doc update
-      ```
-
-      OUTPUT:
-      - CHANGELOG status (exists/created)
-      - Entry preview
-    timeout: 180000  # 3 minutes
-    saveToMemory: true
-    dependencies: [version-bump]
-
-  # Stage 4: Build and test
-  - id: build-test
-    actor: builder
-    description: "Build and test with new version"
-    prompt: |
-      Build and test the project with new version:
-
-      VERSION: ${version-bump.newVersion}
-
-      TASKS:
-      1. Run npm run build
-      2. Verify build output in dist/
-      3. Run full test suite (npm test)
-      4. Verify all tests pass
-      5. Check for any warnings or errors
-
-      VALIDATION:
-      - Build must succeed (exit code 0)
-      - All tests must pass (exit code 0)
-      - No TypeScript errors
-      - No critical warnings
-
-      OUTPUT:
-      - Build status
-      - Test results summary
-      - Any warnings/errors
-    timeout: 600000  # 10 minutes
-    saveToMemory: true
-    dependencies: [changelog]
-
-  # Stage 5: Git commit and tag
-  - id: git-commit
-    actor: git-operator
-    description: "Commit changes and create git tag"
-    prompt: |
-      Commit release changes and create git tag:
-
-      VERSION: ${version-bump.newVersion}
-
-      TASKS:
-      1. Stage changes:
-         - package.json
-         - README.md
-         - CHANGELOG.md
-         - CLAUDE.md
-      2. Create commit with message:
-         "chore: Release v${version-bump.newVersion}"
-      3. Create annotated git tag: v${version-bump.newVersion}
-      4. Verify commit and tag created
-
-      GIT COMMIT MESSAGE FORMAT:
-      ```
-      chore: Release v${version-bump.newVersion}
-
-      Auto-generated release commit
-
-      - Updated package.json to v${version-bump.newVersion}
-      - Updated CHANGELOG.md
-      - Synced version references
-      - Verified build and tests passing
-      ```
-
-      OUTPUT:
-      - Commit SHA
-      - Tag name
-      - Staged files
-    timeout: 60000  # 1 minute
-    saveToMemory: true
-    dependencies: [build-test]
-
-  # Stage 6: Push to GitHub
-  - id: git-push
-    actor: git-operator
-    description: "Push commit and tags to GitHub"
-    prompt: |
-      Push release commit and tag to GitHub:
-
-      VERSION: ${version-bump.newVersion}
-      COMMIT: ${git-commit.commitSHA}
-
-      TASKS:
-      1. Push main branch: git push origin main
-      2. Push tag: git push origin v${version-bump.newVersion}
-      3. Verify push succeeded
-      4. Get remote commit SHA for verification
-
-      SAFETY CHECKS:
-      - Verify we're on main branch
-      - Verify remote is correct (origin -> github.com/defai-digital/automatosx)
-      - Confirm push to main branch (interactive confirmation)
-
-      OUTPUT:
-      - Push status
-      - Remote commit SHA
-      - Tag on remote
-    timeout: 120000  # 2 minutes
-    saveToMemory: true
-    dependencies: [git-commit]
-
-  # Stage 7: Create GitHub release
-  - id: github-release
-    actor: release-publisher
-    description: "Create GitHub release with notes"
-    prompt: |
-      Create GitHub release using gh CLI:
-
-      VERSION: ${version-bump.newVersion}
-      TAG: v${version-bump.newVersion}
-
-      TASKS:
-      1. Extract release notes from CHANGELOG.md for v${version-bump.newVersion}
-      2. Create GitHub release using gh CLI:
-         gh release create v${version-bump.newVersion} \
-           --title "v${version-bump.newVersion}" \
-           --notes <extracted-notes>
-      3. Verify release created successfully
-      4. Get release URL
-
-      RELEASE NOTES FORMAT:
-      - Extract section from CHANGELOG.md between version headers
-      - Include Features, Bug Fixes, Documentation sections
-      - Format as markdown
-      - Add installation instructions
-
-      OUTPUT:
-      - Release URL
-      - Release status
-      - Release notes preview
-    timeout: 180000  # 3 minutes
-    saveToMemory: true
-    dependencies: [git-push]
-
-  # Stage 8: Monitor CI/CD
-  - id: cicd-monitor
-    actor: release-publisher
-    description: "Monitor GitHub Actions workflow"
-    prompt: |
-      Monitor GitHub Actions workflow for release:
-
-      VERSION: ${version-bump.newVersion}
-      RELEASE: ${github-release.releaseURL}
-
-      TASKS:
-      1. Wait for GitHub Actions workflow to start (10-15 seconds)
-      2. Get latest workflow run ID: gh run list --limit 1
-      3. Monitor workflow status: gh run view <run-id>
-      4. Wait for workflow completion or timeout (15 minutes)
-      5. Report final status
-
-      EXPECTED WORKFLOW:
-      - Build and test
-      - Publish to npm
-      - Create npm release
-
-      OUTPUT:
-      - Workflow status (pending/running/completed/failed)
-      - Workflow URL
-      - npm publish status
-      - Any errors or warnings
-    timeout: 1200000  # 20 minutes
-    saveToMemory: true
-    dependencies: [github-release]
-
-# Observability
-observability:
-  metrics:
-    enabled: true
-    labels:
-      project: automatosx
-      workflow: release
-      type: automation
-
-  audit:
-    enabled: true
-    retention: 90  # 90 days
-
-  tracing:
-    enabled: true
-    samplingRate: 1.0  # Capture all release executions
-
-# Retry and error handling
-execution:
-  parallel: false  # Sequential execution
-  continueOnError: false  # Stop on first error
-
-  retry:
-    enabled: true
-    maxRetries: 2
-    backoffMs: 5000
-
-# Expected outputs
-outputs:
-  version:
-    description: "Released version number"
-    from: version-bump.newVersion
-
-  releaseURL:
-    description: "GitHub release URL"
-    from: github-release.releaseURL
-
-  npmURL:
-    description: "npm package URL"
-    value: "https://www.npmjs.com/package/@defai.digital/automatosx"
-
-  status:
-    description: "Overall release status"
-    from: cicd-monitor.workflowStatus