On Device Model Training

Skill Profile

(Select at least one profile to enable specific modules)

[ ] DevOps
[x] Backend
[ ] Frontend
[ ] AI-RAG
[ ] Security Critical

Overview

On-Device Model Training enables training and updating machine learning models directly on edge devices without transferring raw data to the cloud. This approach is essential for privacy-sensitive applications, reduces bandwidth costs, enables personalized models, and provides continuous learning capabilities even in offline environments.

Why This Matters

Data Privacy: Raw data never leaves the device, ensuring compliance with privacy regulations
Bandwidth Efficiency: Only model updates (gradients) are transmitted, reducing bandwidth costs by 95-99%
Personalization: Models adapt to individual user patterns, improving user experience
Offline Learning: Continuous improvement without connectivity, enabling edge AI in remote locations
Regulatory Compliance: Meets GDPR, HIPAA, and other data protection requirements by design

Core Concepts & Rules

1. Core Principles

Follow established patterns and conventions
Maintain consistency across codebase
Document decisions and trade-offs

2. Implementation Guidelines

Start with the simplest viable solution
Iterate based on feedback and requirements
Test thoroughly before deployment

Inputs / Outputs / Contracts

Inputs:
- Initial global model (PyTorch/TensorFlow)
- Client configuration (server URL, training parameters)
- Local data on client devices
- Privacy parameters (epsilon, delta, noise scale)
Entry Conditions:
- Server deployed and accessible
- Initial global model trained and available
- Client devices have sufficient compute/memory for local training
- Network connectivity between clients and server
- Privacy parameters configured and documented
Outputs:
- Updated global model (aggregated from client updates)
- Model version tracking
- Training metrics (accuracy, loss, client participation)
- Privacy budget tracking
Artifacts Required (Deliverables):
- Federated learning server implementation
- Client training implementation
- Privacy protection modules
- Configuration files (server, client)
- Monitoring and logging infrastructure
Acceptance Evidence:
- Global model converges to target accuracy (> 90% of centralized)
- Privacy budget respected (epsilon < 5% per round)
- Client participation rate > 70%
- Round completion time < 5 minutes
- Update success rate > 95%
Success Criteria:
- Model accuracy within 90-95% of centralized training
- Privacy guarantees maintained (differential privacy, secure aggregation)
- Bandwidth reduction > 95% vs data upload
- Client participation > 70% of active clients
- Round completion < 5 minutes
- Update success rate > 95%

Skill Composition

Depends on: tinyml-microcontroller-ai (Edge inference), edge-model-compression (Model optimization)
Compatible with: hybrid-inference-architecture, edge-ai-development-workflow
Conflicts with: None
Related Skills: drift-detection-retraining, model-registry-versioning

Quick Start / Implementation Example

Review requirements and constraints
Set up development environment
Implement core functionality following patterns
Write tests for critical paths
Run tests and fix issues
Document any deviations or decisions

# Example implementation following best practices
def example_function():
    # Your implementation here
    pass

Assumptions / Constraints / Non-goals

Assumptions:
- Development environment is properly configured
- Required dependencies are available
- Team has basic understanding of domain
Constraints:
- Must follow existing codebase conventions
- Time and resource limitations
- Compatibility requirements
Non-goals:
- This skill does not cover edge cases outside scope
- Not a replacement for formal training

Compatibility & Prerequisites

Supported Versions:
- Python 3.8+
- Node.js 16+
- Modern browsers (Chrome, Firefox, Safari, Edge)
Required AI Tools:
- Code editor (VS Code recommended)
- Testing framework appropriate for language
- Version control (Git)
Dependencies:
- Language-specific package manager
- Build tools
- Testing libraries
Environment Setup:
- .env.example keys: API_KEY, DATABASE_URL (no values)

Test Scenario Matrix (QA Strategy)

Technical Guardrails & Security Threat Model

1. Security & Privacy (Threat Model)

Top Threats: Injection attacks, authentication bypass, data exposure

[ ] Data Handling: Sanitize all user inputs to prevent Injection attacks. Never log raw PII
[ ] Secrets Management: No hardcoded API keys. Use Env Vars/Secrets Manager
[ ] Authorization: Validate user permissions before state changes

2. Performance & Resources

[ ] Execution Efficiency: Consider time complexity for algorithms
[ ] Memory Management: Use streams/pagination for large data
[ ] Resource Cleanup: Close DB connections/file handlers in finally blocks

3. Architecture & Scalability

[ ] Design Pattern: Follow SOLID principles, use Dependency Injection
[ ] Modularity: Decouple logic from UI/Frameworks

4. Observability & Reliability

[ ] Logging Standards: Structured JSON, include trace IDs request_id
[ ] Metrics: Track error_rate, latency, queue_depth
[ ] Error Handling: Standardized error codes, no bare except
[ ] Observability Artifacts:
- Log Fields: timestamp, level, message, request_id
- Metrics: request_count, error_count, response_time
- Dashboards/Alerts: High Error Rate > 5%

Agent Directives & Error Recovery

(ข้อกำหนดสำหรับ AI Agent ในการคิดและแก้ปัญหาเมื่อเกิดข้อผิดพลาด)

Thinking Process: Analyze root cause before fixing. Do not brute-force.
Fallback Strategy: Stop after 3 failed test attempts. Output root cause and ask for human intervention/clarification.
Self-Review: Check against Guardrails & Anti-patterns before finalizing.
Output Constraints: Output ONLY the modified code block. Do not explain unless asked.

Definition of Done (DoD) Checklist

[ ] Tests passed + coverage met
[ ] Lint/Typecheck passed
[ ] Logging/Metrics/Trace implemented
[ ] Security checks passed
[ ] Documentation/Changelog updated
[ ] Accessibility/Performance requirements met (if frontend)

Anti-patterns / Pitfalls

⛔ Don't: Log PII, catch-all exception, N+1 queries
⚠️ Watch out for: Common symptoms and quick fixes
💡 Instead: Use proper error handling, pagination, and logging

Reference Links & Examples

Internal documentation and examples
Official documentation and best practices
Community resources and discussions

Versioning & Changelog

Version: 1.0.0
Changelog:
- 2026-02-22: Initial version with complete template structure