291 lines
8.3 KiB
TypeScript
291 lines
8.3 KiB
TypeScript
/**
|
|
* IoT Sensor Networks: Distributed Anomaly Detection
|
|
*
|
|
* Use Case: Real-time anomaly detection in IoT sensor networks
|
|
* with limited compute resources.
|
|
*
|
|
* Optimization Priority: POWER EFFICIENCY + LATENCY
|
|
*/
|
|
|
|
import { UnifiedMetrics } from '../../types';
|
|
|
|
export const IOT_ATTENTION_CONFIG = {
|
|
heads: 4, // Lightweight for edge devices
|
|
forwardPassTargetMs: 5, // 5ms for real-time monitoring
|
|
batchSize: 1, // Single-sensor processing
|
|
precision: 'int8' as const, // Quantized for edge (NVIDIA TensorRT, TFLite)
|
|
edgeOptimized: true, // ESP32, Raspberry Pi, Coral TPU
|
|
powerBudgetMw: 500, // 500mW power budget
|
|
|
|
// Hypergraph for multi-sensor correlations
|
|
hypergraph: {
|
|
enabled: true,
|
|
maxHyperedgeSize: 5, // 5-sensor correlations
|
|
compressionRatio: 3.7, // 3.7x edge compression validated
|
|
distributedProcessing: true // Process across sensor network
|
|
},
|
|
|
|
// Dynamic-k based on anomaly severity
|
|
dynamicK: {
|
|
min: 3, // Minimum candidates (normal operation)
|
|
max: 15, // Maximum candidates (anomaly detected)
|
|
adaptationStrategy: 'anomaly-severity' as const
|
|
},
|
|
|
|
// Self-healing for autonomous operation
|
|
selfHealing: {
|
|
enabled: true,
|
|
adaptationIntervalMs: 1000, // 1s monitoring
|
|
degradationThreshold: 0.10, // 10% tolerance (edge constraints)
|
|
networkResilience: true // Handle node failures
|
|
}
|
|
};
|
|
|
|
// IoT-specific metrics
|
|
export interface IoTMetrics extends UnifiedMetrics {
|
|
anomalyDetectionRate: number; // True positive anomaly detection
|
|
falseAlarmRate: number; // False positive rate (minimize network traffic)
|
|
powerConsumptionMw: number; // Power consumption (battery life critical)
|
|
networkLatencyMs: number; // Multi-hop network latency
|
|
sensorCoverage: number; // Sensor network coverage
|
|
}
|
|
|
|
// Sensor interface
|
|
export interface Sensor {
|
|
id: string;
|
|
reading: Float32Array;
|
|
timestamp: number;
|
|
batteryPercent: number;
|
|
}
|
|
|
|
// Anomaly alert interface
|
|
export interface AnomalyAlert {
|
|
sensorId: string;
|
|
anomalyScore: number;
|
|
severity: 'warning' | 'critical';
|
|
correlatedSensors: string[];
|
|
timestamp: number;
|
|
latencyMs: number;
|
|
}
|
|
|
|
// Example: Distributed anomaly detection
|
|
export async function detectAnomalies(
|
|
sensorReading: Float32Array & { id: string },
|
|
normalPatterns: any, // HNSWGraph type
|
|
neighborSensors: Sensor[],
|
|
applyAttention: (data: Float32Array, config: any) => Promise<Float32Array>,
|
|
createHyperedge: (readings: Float32Array[]) => Promise<Float32Array>,
|
|
severityThreshold: number = 0.8
|
|
): Promise<AnomalyAlert[]> {
|
|
const startTime = Date.now();
|
|
const config = IOT_ATTENTION_CONFIG;
|
|
|
|
// 4-head attention for lightweight processing
|
|
const enhanced = await applyAttention(sensorReading, config);
|
|
|
|
// Hypergraph: Correlate with neighbor sensors (multi-sensor patterns)
|
|
const hyperedge = await createHyperedge([
|
|
sensorReading,
|
|
...neighborSensors.map(s => s.reading)
|
|
]);
|
|
|
|
// Search for normal patterns
|
|
const matches = await normalPatterns.search(enhanced, 10);
|
|
|
|
// Anomaly = low similarity to normal patterns
|
|
const anomalyScore = 1 - matches[0].score;
|
|
|
|
if (anomalyScore > severityThreshold) {
|
|
// Dynamic-k: Get more candidates for anomaly analysis
|
|
const k = Math.round(3 + anomalyScore * 12); // 3-15 range
|
|
const detailedMatches = await normalPatterns.search(enhanced, k);
|
|
|
|
return [{
|
|
sensorId: sensorReading.id,
|
|
anomalyScore,
|
|
severity: anomalyScore > 0.9 ? 'critical' : 'warning',
|
|
correlatedSensors: neighborSensors.map(s => s.id),
|
|
timestamp: Date.now(),
|
|
latencyMs: Date.now() - startTime
|
|
}];
|
|
}
|
|
|
|
return [];
|
|
}
|
|
|
|
// Performance targets for IoT
|
|
export const IOT_PERFORMANCE_TARGETS = {
|
|
p50LatencyMs: 5, // 5ms median (real-time monitoring)
|
|
anomalyDetectionRate: 0.95, // 95% true positive rate
|
|
falseAlarmRate: 0.05, // 5% false positive rate
|
|
powerConsumptionMw: 500, // 500mW max (battery life)
|
|
uptimePercent: 99.9 // 99.9% uptime (3 nines, edge resilience)
|
|
};
|
|
|
|
// IoT platform-specific configurations
|
|
export const IOT_CONFIG_VARIATIONS = {
|
|
// ESP32 (very constrained, WiFi)
|
|
esp32: {
|
|
...IOT_ATTENTION_CONFIG,
|
|
heads: 2, // Minimal heads
|
|
precision: 'int8' as const,
|
|
powerBudgetMw: 200,
|
|
forwardPassTargetMs: 10,
|
|
batchSize: 1
|
|
},
|
|
|
|
// Raspberry Pi (more capable, still battery)
|
|
raspberryPi: {
|
|
...IOT_ATTENTION_CONFIG,
|
|
heads: 4,
|
|
precision: 'float16' as const,
|
|
powerBudgetMw: 1000, // 1W budget
|
|
forwardPassTargetMs: 5
|
|
},
|
|
|
|
// NVIDIA Jetson Nano (edge AI, powered)
|
|
jetsonNano: {
|
|
...IOT_ATTENTION_CONFIG,
|
|
heads: 8, // More capable
|
|
precision: 'float16' as const,
|
|
powerBudgetMw: 5000, // 5W budget
|
|
forwardPassTargetMs: 3,
|
|
batchSize: 4
|
|
},
|
|
|
|
// Google Coral TPU (ML accelerator)
|
|
coralTPU: {
|
|
...IOT_ATTENTION_CONFIG,
|
|
heads: 6,
|
|
precision: 'int8' as const, // TPU optimized
|
|
powerBudgetMw: 2000, // 2W budget
|
|
forwardPassTargetMs: 2,
|
|
batchSize: 8
|
|
}
|
|
};
|
|
|
|
// Deployment environment adaptations
|
|
export function adaptConfigToDeployment(
|
|
baseConfig: typeof IOT_ATTENTION_CONFIG,
|
|
environment: 'urban' | 'industrial' | 'agricultural' | 'remote'
|
|
): typeof IOT_ATTENTION_CONFIG {
|
|
switch (environment) {
|
|
case 'urban':
|
|
return {
|
|
...baseConfig,
|
|
heads: 6, // More sensors, more complex
|
|
hypergraph: {
|
|
...baseConfig.hypergraph,
|
|
maxHyperedgeSize: 8 // Dense sensor network
|
|
}
|
|
};
|
|
case 'industrial':
|
|
return {
|
|
...baseConfig,
|
|
heads: 8, // High reliability needed
|
|
forwardPassTargetMs: 3,
|
|
powerBudgetMw: 2000 // Powered sensors
|
|
};
|
|
case 'agricultural':
|
|
return {
|
|
...baseConfig,
|
|
heads: 4,
|
|
powerBudgetMw: 300, // Solar-powered, battery constrained
|
|
selfHealing: {
|
|
...baseConfig.selfHealing,
|
|
networkResilience: true // Sparse network
|
|
}
|
|
};
|
|
case 'remote':
|
|
return {
|
|
...baseConfig,
|
|
heads: 2, // Minimal computation
|
|
precision: 'int8' as const,
|
|
powerBudgetMw: 100, // Extreme battery constraint
|
|
forwardPassTargetMs: 20 // Slower acceptable
|
|
};
|
|
}
|
|
}
|
|
|
|
// Battery-aware configuration
|
|
export function adaptConfigToBattery(
|
|
baseConfig: typeof IOT_ATTENTION_CONFIG,
|
|
batteryPercent: number,
|
|
chargingStatus: 'charging' | 'discharging' | 'solar'
|
|
): typeof IOT_ATTENTION_CONFIG {
|
|
if (chargingStatus === 'charging') {
|
|
return {
|
|
...baseConfig,
|
|
heads: 8 // Use more resources when charging
|
|
// Note: Precision optimization coming in future release
|
|
};
|
|
}
|
|
|
|
if (batteryPercent < 10) {
|
|
// Critical battery
|
|
return {
|
|
...baseConfig,
|
|
heads: 2,
|
|
precision: 'int8' as const,
|
|
powerBudgetMw: 100,
|
|
batchSize: 1
|
|
};
|
|
} else if (batteryPercent < 30) {
|
|
// Low battery
|
|
return {
|
|
...baseConfig,
|
|
heads: 3,
|
|
precision: 'int8' as const,
|
|
powerBudgetMw: 300
|
|
};
|
|
} else if (chargingStatus === 'solar') {
|
|
// Solar powered - adaptive
|
|
return {
|
|
...baseConfig,
|
|
heads: 5,
|
|
powerBudgetMw: 600
|
|
};
|
|
}
|
|
|
|
return baseConfig;
|
|
}
|
|
|
|
// Network topology adaptations
|
|
export interface NetworkTopology {
|
|
nodeCount: number;
|
|
averageDegree: number;
|
|
meshDensity: number;
|
|
gatewayDistance: number;
|
|
}
|
|
|
|
export function adaptConfigToTopology(
|
|
baseConfig: typeof IOT_ATTENTION_CONFIG,
|
|
topology: NetworkTopology
|
|
): typeof IOT_ATTENTION_CONFIG {
|
|
if (topology.meshDensity > 0.7) {
|
|
// Dense mesh - can use more correlations
|
|
return {
|
|
...baseConfig,
|
|
hypergraph: {
|
|
...baseConfig.hypergraph,
|
|
maxHyperedgeSize: 8
|
|
}
|
|
};
|
|
} else if (topology.meshDensity < 0.3) {
|
|
// Sparse mesh - limited correlations
|
|
return {
|
|
...baseConfig,
|
|
hypergraph: {
|
|
...baseConfig.hypergraph,
|
|
maxHyperedgeSize: 3
|
|
},
|
|
selfHealing: {
|
|
...baseConfig.selfHealing,
|
|
networkResilience: true
|
|
}
|
|
};
|
|
}
|
|
|
|
return baseConfig;
|
|
}
|