@hazeljs/ml 0.2.3 → 0.3.0

package/dist/monitoring/monitor.service.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * Monitor Service - Ongoing model monitoring and alerting
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MonitorService = void 0;
+const core_1 = require("@hazeljs/core");
+const core_2 = __importDefault(require("@hazeljs/core"));
+const drift_service_1 = require("./drift.service");
+let MonitorService = class MonitorService {
+    constructor(driftService) {
+        this.monitors = new Map();
+        this.alertHandlers = [];
+        this.checkIntervals = new Map();
+        this.accuracyHistory = new Map();
+        this.driftService = driftService;
+    }
+    /**
+     * Register a model for monitoring
+     */
+    registerModel(config) {
+        const key = this.getMonitorKey(config.modelName, config.modelVersion);
+        this.monitors.set(key, config);
+        // Set up periodic checks if interval specified
+        if (config.checkIntervalMinutes && config.checkIntervalMinutes > 0) {
+            const intervalMs = config.checkIntervalMinutes * 60 * 1000;
+            const interval = setInterval(() => {
+                this.checkModel(config.modelName, config.modelVersion);
+            }, intervalMs);
+            // Clean up old interval if exists
+            const oldInterval = this.checkIntervals.get(key);
+            if (oldInterval) {
+                clearInterval(oldInterval);
+            }
+            this.checkIntervals.set(key, interval);
+        }
+        core_2.default.debug(`Registered monitor for ${config.modelName}@${config.modelVersion ?? 'latest'}`);
+    }
+    /**
+     * Unregister a model from monitoring
+     */
+    unregisterModel(modelName, modelVersion) {
+        const key = this.getMonitorKey(modelName, modelVersion);
+        this.monitors.delete(key);
+        const interval = this.checkIntervals.get(key);
+        if (interval) {
+            clearInterval(interval);
+            this.checkIntervals.delete(key);
+        }
+        core_2.default.debug(`Unregistered monitor for ${modelName}@${modelVersion ?? 'latest'}`);
+    }
+    /**
+     * Add an alert handler
+     */
+    onAlert(handler) {
+        this.alertHandlers.push(handler);
+    }
+    /**
+     * Remove an alert handler
+     */
+    offAlert(handler) {
+        const idx = this.alertHandlers.indexOf(handler);
+        if (idx >= 0) {
+            this.alertHandlers.splice(idx, 1);
+        }
+    }
+    /**
+     * Record prediction for drift monitoring
+     */
+    recordPrediction(modelName, features, prediction) {
+        // This would store predictions for batch drift detection
+        // In a real implementation, this would write to a time-series DB
+        core_2.default.debug(`Recorded prediction for ${modelName}`, { features, prediction });
+    }
+    /**
+     * Record accuracy metric for accuracy monitoring
+     */
+    recordAccuracy(modelName, accuracy, modelVersion) {
+        const key = this.getMonitorKey(modelName, modelVersion);
+        const history = this.accuracyHistory.get(key) ?? [];
+        history.push({ timestamp: new Date(), accuracy });
+        this.accuracyHistory.set(key, history);
+        // Check if accuracy dropped below threshold
+        const config = this.monitors.get(key);
+        if (config?.accuracyMonitor) {
+            const { threshold, windowSize } = config.accuracyMonitor;
+            const recent = history.slice(-windowSize);
+            const avgAccuracy = recent.reduce((sum, h) => sum + h.accuracy, 0) / recent.length;
+            if (avgAccuracy < threshold) {
+                this.emitAlert({
+                    timestamp: new Date(),
+                    modelName,
+                    modelVersion,
+                    alertType: 'accuracy',
+                    severity: 'critical',
+                    message: `Average accuracy ${avgAccuracy.toFixed(4)} below threshold ${threshold} over last ${windowSize} checks`,
+                    details: { avgAccuracy, threshold, windowSize, recentHistory: recent },
+                });
+            }
+        }
+    }
+    /**
+     * Check a model for drift and other issues
+     */
+    async checkModel(modelName, modelVersion) {
+        const key = this.getMonitorKey(modelName, modelVersion);
+        const config = this.monitors.get(key);
+        if (!config) {
+            throw new Error(`No monitor registered for ${modelName}@${modelVersion ?? 'latest'}`);
+        }
+        const results = [];
+        // Note: In a real implementation, this would fetch recent feature data
+        // from the feature store or prediction logs
+        // For now, this is a placeholder for the check structure
+        if (config.featureDrift) {
+            // This would be populated from actual feature data
+            const dummyFeatures = {};
+            try {
+                const report = this.driftService.detectDriftReport(dummyFeatures, config.featureDrift);
+                results.push(...report.results);
+                for (const result of report.results) {
+                    if (result.driftDetected) {
+                        this.emitAlert({
+                            timestamp: new Date(),
+                            modelName,
+                            modelVersion,
+                            alertType: 'drift',
+                            severity: 'warning',
+                            message: result.message,
+                            details: { feature: result.feature, score: result.score, method: result.method },
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                core_2.default.warn(`Failed to check drift for ${modelName}:`, error);
+            }
+        }
+        return results;
+    }
+    /**
+     * Get monitoring status for all registered models
+     */
+    getStatus() {
+        return Array.from(this.monitors.values()).map((config) => ({
+            modelName: config.modelName,
+            modelVersion: config.modelVersion,
+            isActive: this.checkIntervals.has(this.getMonitorKey(config.modelName, config.modelVersion)),
+            checkInterval: config.checkIntervalMinutes,
+        }));
+    }
+    /**
+     * Stop all monitoring
+     */
+    stop() {
+        for (const [key, interval] of this.checkIntervals) {
+            clearInterval(interval);
+            this.checkIntervals.delete(key);
+        }
+        core_2.default.debug('Stopped all monitoring');
+    }
+    getMonitorKey(modelName, modelVersion) {
+        return modelVersion ? `${modelName}:${modelVersion}` : modelName;
+    }
+    async emitAlert(alert) {
+        for (const handler of this.alertHandlers) {
+            try {
+                await handler(alert);
+            }
+            catch (error) {
+                core_2.default.error('Alert handler failed:', error);
+            }
+        }
+    }
+};
+exports.MonitorService = MonitorService;
+exports.MonitorService = MonitorService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [drift_service_1.DriftService])
+], MonitorService);

package/dist/training/trainer.service.test.js

@@ -96,4 +96,109 @@ describe('TrainerService', () => {
         });
         await expect(trainer.train('broken-train', {})).rejects.toThrow('Training method train not found on model');
     });
+    it('should train with specific version', async () => {
+        let VersionedModel = class VersionedModel {
+            async train(data) {
+                return { version: '2.0.0', data };
+            }
+            predict() { }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], VersionedModel.prototype, "train", null);
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], VersionedModel.prototype, "predict", null);
+        VersionedModel = __decorate([
+            (0, decorators_1.Model)({ name: 'versioned-model', version: '2.0.0', framework: 'custom' })
+        ], VersionedModel);
+        const instance = new VersionedModel();
+        registry.register({
+            metadata: { name: 'versioned-model', version: '2.0.0', framework: 'custom' },
+            instance,
+            trainMethod: 'train',
+            predictMethod: 'predict',
+        });
+        const result = await trainer.train('versioned-model', { test: true }, '2.0.0');
+        expect(result.version).toBe('2.0.0');
+    });
+    it('should handle training errors gracefully', async () => {
+        let ErrorModel = class ErrorModel {
+            async train() {
+                throw new Error('Training failed');
+            }
+            predict() { }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", Promise)
+        ], ErrorModel.prototype, "train", null);
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], ErrorModel.prototype, "predict", null);
+        ErrorModel = __decorate([
+            (0, decorators_1.Model)({ name: 'error-model', version: '1.0.0', framework: 'custom' })
+        ], ErrorModel);
+        const instance = new ErrorModel();
+        registry.register({
+            metadata: { name: 'error-model', version: '1.0.0', framework: 'custom' },
+            instance,
+            trainMethod: 'train',
+            predictMethod: 'predict',
+        });
+        await expect(trainer.train('error-model', {})).rejects.toThrow('Training failed');
+    });
+    it('should discover train method from decorated class', () => {
+        let DiscoverModel = class DiscoverModel {
+            customTrainMethod() { }
+            predict() { }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], DiscoverModel.prototype, "customTrainMethod", null);
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], DiscoverModel.prototype, "predict", null);
+        DiscoverModel = __decorate([
+            (0, decorators_1.Model)({ name: 'discover-model', version: '1.0.0', framework: 'custom' })
+        ], DiscoverModel);
+        const instance = new DiscoverModel();
+        const method = trainer.discoverTrainMethod(instance);
+        expect(method).toBe('customTrainMethod');
+    });
+    it('should return undefined when no train method decorated', () => {
+        let NoDecoratorModel = class NoDecoratorModel {
+            train() { }
+            predict() { }
+        };
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], NoDecoratorModel.prototype, "predict", null);
+        NoDecoratorModel = __decorate([
+            (0, decorators_1.Model)({ name: 'no-decorator', version: '1.0.0', framework: 'custom' })
+        ], NoDecoratorModel);
+        const instance = new NoDecoratorModel();
+        const method = trainer.discoverTrainMethod(instance);
+        expect(method).toBeUndefined();
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/ml",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Machine Learning & Model Management for HazelJS framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -48,5 +48,5 @@
     "url": "https://github.com/hazeljs/hazel-js/issues"
   },
   "homepage": "https://hazeljs.ai",
-  "gitHead": "23464d4bf09c22e092b31b2a037bec062f2353da"
+  "gitHead": "14c91213d93aa7eb907cb71b1d7104ddc4556327"
 }