@hazeljs/ml 0.2.0-alpha.1

package/dist/decorators/model.decorator.test.js

@@ -0,0 +1,128 @@
+"use strict";
+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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+require("reflect-metadata");
+const model_decorator_1 = require("./model.decorator");
+const train_decorator_1 = require("./train.decorator");
+const predict_decorator_1 = require("./predict.decorator");
+describe('Model decorator', () => {
+    it('applies metadata to class', () => {
+        let TestModel = class TestModel {
+        };
+        TestModel = __decorate([
+            (0, model_decorator_1.Model)({ name: 'test-model', version: '1.0.0', framework: 'tensorflow' })
+        ], TestModel);
+        const meta = (0, model_decorator_1.getModelMetadata)(TestModel);
+        expect(meta).toEqual({
+            name: 'test-model',
+            version: '1.0.0',
+            framework: 'tensorflow',
+            description: '',
+            tags: [],
+        });
+        expect((0, model_decorator_1.hasModelMetadata)(TestModel)).toBe(true);
+    });
+    it('merges optional fields', () => {
+        let CustomModel = class CustomModel {
+        };
+        CustomModel = __decorate([
+            (0, model_decorator_1.Model)({
+                name: 'custom',
+                version: '2.0.0',
+                framework: 'onnx',
+                description: 'A model',
+                tags: ['production'],
+            })
+        ], CustomModel);
+        const meta = (0, model_decorator_1.getModelMetadata)(CustomModel);
+        expect(meta?.description).toBe('A model');
+        expect(meta?.tags).toEqual(['production']);
+    });
+    it('hasModelMetadata returns false for undecorated class', () => {
+        class PlainClass {
+        }
+        expect((0, model_decorator_1.hasModelMetadata)(PlainClass)).toBe(false);
+        expect((0, model_decorator_1.getModelMetadata)(PlainClass)).toBeUndefined();
+    });
+});
+describe('Train decorator', () => {
+    it('applies metadata to method', () => {
+        class TestClass {
+            train() { }
+        }
+        __decorate([
+            (0, train_decorator_1.Train)({ pipeline: 'default', epochs: 5 }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "train", null);
+        const meta = (0, train_decorator_1.getTrainMetadata)(TestClass.prototype, 'train');
+        expect(meta).toEqual({
+            pipeline: 'default',
+            batchSize: 32,
+            epochs: 5,
+        });
+        expect((0, train_decorator_1.hasTrainMetadata)(TestClass.prototype, 'train')).toBe(true);
+    });
+    it('uses defaults when no options', () => {
+        class TestClass {
+            train() { }
+        }
+        __decorate([
+            (0, train_decorator_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "train", null);
+        const meta = (0, train_decorator_1.getTrainMetadata)(TestClass.prototype, 'train');
+        expect(meta?.batchSize).toBe(32);
+        expect(meta?.epochs).toBe(10);
+    });
+    it('hasTrainMetadata returns false for undecorated method', () => {
+        class TestClass {
+            train() { }
+        }
+        expect((0, train_decorator_1.hasTrainMetadata)(TestClass.prototype, 'train')).toBe(false);
+    });
+});
+describe('Predict decorator', () => {
+    it('applies metadata to method', () => {
+        class TestClass {
+            predict() { }
+        }
+        __decorate([
+            (0, predict_decorator_1.Predict)({ endpoint: '/predict', batch: true }),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "predict", null);
+        const meta = (0, predict_decorator_1.getPredictMetadata)(TestClass.prototype, 'predict');
+        expect(meta).toEqual({
+            batch: true,
+            endpoint: '/predict',
+        });
+        expect((0, predict_decorator_1.hasPredictMetadata)(TestClass.prototype, 'predict')).toBe(true);
+    });
+    it('uses defaults when no options', () => {
+        class TestClass {
+            predict() { }
+        }
+        __decorate([
+            (0, predict_decorator_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], TestClass.prototype, "predict", null);
+        const meta = (0, predict_decorator_1.getPredictMetadata)(TestClass.prototype, 'predict');
+        expect(meta?.batch).toBe(false);
+        expect(meta?.endpoint).toBe('/predict');
+    });
+});

package/dist/decorators/predict.decorator.d.ts

@@ -0,0 +1,20 @@
+import 'reflect-metadata';
+export interface PredictOptions {
+    batch?: boolean;
+    endpoint?: string;
+}
+/**
+ * @Predict decorator - Mark a method as the inference endpoint
+ *
+ * @example
+ * ```typescript
+ * @Predict({ endpoint: '/predict' })
+ * async predict(text: string) {
+ *   return { sentiment: 'positive', confidence: 0.92 };
+ * }
+ * ```
+ */
+export declare function Predict(options?: PredictOptions): MethodDecorator;
+export declare function getPredictMetadata(target: object, propertyKey: string | symbol): PredictOptions | undefined;
+export declare function hasPredictMetadata(target: object, propertyKey: string | symbol): boolean;
+//# sourceMappingURL=predict.decorator.d.ts.map

package/dist/decorators/predict.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"predict.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/predict.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAK1B,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,OAAO,GAAE,cAAmB,GAAG,eAAe,CAarE;AAED,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,cAAc,GAAG,SAAS,CAE5B;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAExF"}

package/dist/decorators/predict.decorator.js

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Predict = Predict;
+exports.getPredictMetadata = getPredictMetadata;
+exports.hasPredictMetadata = hasPredictMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const PREDICT_METADATA_KEY = 'hazel:ml:predict';
+/**
+ * @Predict decorator - Mark a method as the inference endpoint
+ *
+ * @example
+ * ```typescript
+ * @Predict({ endpoint: '/predict' })
+ * async predict(text: string) {
+ *   return { sentiment: 'positive', confidence: 0.92 };
+ * }
+ * ```
+ */
+function Predict(options = {}) {
+    return (target, propertyKey, descriptor) => {
+        const metadata = {
+            batch: false,
+            endpoint: '/predict',
+            ...options,
+        };
+        Reflect.defineMetadata(PREDICT_METADATA_KEY, metadata, target, propertyKey);
+        core_1.default.debug(`Predict decorator applied to ${target.constructor.name}.${String(propertyKey)}`);
+        return descriptor;
+    };
+}
+function getPredictMetadata(target, propertyKey) {
+    return Reflect.getMetadata(PREDICT_METADATA_KEY, target, propertyKey);
+}
+function hasPredictMetadata(target, propertyKey) {
+    return Reflect.hasMetadata(PREDICT_METADATA_KEY, target, propertyKey);
+}

package/dist/decorators/train.decorator.d.ts

@@ -0,0 +1,21 @@
+import 'reflect-metadata';
+export interface TrainOptions {
+    pipeline?: string;
+    batchSize?: number;
+    epochs?: number;
+}
+/**
+ * @Train decorator - Mark a method as the training pipeline
+ *
+ * @example
+ * ```typescript
+ * @Train({ pipeline: 'default', epochs: 10 })
+ * async train(data: TrainingData) {
+ *   return { accuracy: 0.95, loss: 0.05 };
+ * }
+ * ```
+ */
+export declare function Train(options?: TrainOptions): MethodDecorator;
+export declare function getTrainMetadata(target: object, propertyKey: string | symbol): TrainOptions | undefined;
+export declare function hasTrainMetadata(target: object, propertyKey: string | symbol): boolean;
+//# sourceMappingURL=train.decorator.d.ts.map

package/dist/decorators/train.decorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"train.decorator.d.ts","sourceRoot":"","sources":["../../src/decorators/train.decorator.ts"],"names":[],"mappings":"AAAA,OAAO,kBAAkB,CAAC;AAK1B,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,OAAO,GAAE,YAAiB,GAAG,eAAe,CAcjE;AAED,wBAAgB,gBAAgB,CAC9B,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,GAAG,MAAM,GAC3B,YAAY,GAAG,SAAS,CAE1B;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAEtF"}

package/dist/decorators/train.decorator.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Train = Train;
+exports.getTrainMetadata = getTrainMetadata;
+exports.hasTrainMetadata = hasTrainMetadata;
+require("reflect-metadata");
+const core_1 = __importDefault(require("@hazeljs/core"));
+const TRAIN_METADATA_KEY = 'hazel:ml:train';
+/**
+ * @Train decorator - Mark a method as the training pipeline
+ *
+ * @example
+ * ```typescript
+ * @Train({ pipeline: 'default', epochs: 10 })
+ * async train(data: TrainingData) {
+ *   return { accuracy: 0.95, loss: 0.05 };
+ * }
+ * ```
+ */
+function Train(options = {}) {
+    return (target, propertyKey, descriptor) => {
+        const metadata = {
+            pipeline: 'default',
+            batchSize: 32,
+            epochs: 10,
+            ...options,
+        };
+        Reflect.defineMetadata(TRAIN_METADATA_KEY, metadata, target, propertyKey);
+        core_1.default.debug(`Train decorator applied to ${target.constructor.name}.${String(propertyKey)}`);
+        return descriptor;
+    };
+}
+function getTrainMetadata(target, propertyKey) {
+    return Reflect.getMetadata(TRAIN_METADATA_KEY, target, propertyKey);
+}
+function hasTrainMetadata(target, propertyKey) {
+    return Reflect.hasMetadata(TRAIN_METADATA_KEY, target, propertyKey);
+}

package/dist/evaluation/metrics.service.d.ts

@@ -0,0 +1,54 @@
+import { ModelRegistry } from '../registry/model.registry';
+import { PredictorService } from '../inference/predictor.service';
+export interface ModelMetrics {
+    accuracy?: number;
+    precision?: number;
+    recall?: number;
+    f1Score?: number;
+    loss?: number;
+    [key: string]: number | undefined;
+}
+export interface EvaluationResult {
+    modelName: string;
+    version: string;
+    metrics: ModelMetrics;
+    evaluatedAt: Date;
+}
+export type EvaluateMetric = 'accuracy' | 'f1' | 'precision' | 'recall';
+export interface EvaluateOptions {
+    metrics?: EvaluateMetric[];
+    labelKey?: string;
+    predictionKey?: string;
+    version?: string;
+}
+/**
+ * Metrics Service - Model evaluation and metrics
+ * Tracks model performance for A/B testing and monitoring
+ */
+export declare class MetricsService {
+    private readonly modelRegistry?;
+    private readonly predictorService?;
+    constructor(modelRegistry?: ModelRegistry | undefined, predictorService?: PredictorService | undefined);
+    private metrics;
+    recordEvaluation(result: EvaluationResult): void;
+    getMetrics(modelName: string, version?: string): EvaluationResult | undefined;
+    getHistory(modelName: string): EvaluationResult[];
+    compareVersions(modelName: string, versionA: string, versionB: string): {
+        a: EvaluationResult | undefined;
+        b: EvaluationResult | undefined;
+        winner?: string;
+    };
+    /**
+     * Evaluate model on test data by running predictions and computing metrics.
+     * Requires PredictorService to be injected.
+     *
+     * @param modelName - Registered model name
+     * @param testData - Array of samples. Each sample must contain the model input and a label key.
+     * @param options - labelKey (default: 'label'), predictionKey (tries 'label'|'sentiment'|'class'), metrics, version
+     */
+    evaluate(modelName: string, testData: Record<string, unknown>[], options?: EvaluateOptions): Promise<EvaluationResult>;
+    private extractPredictedLabel;
+    private computeAccuracy;
+    private computePrecisionRecallF1;
+}
+//# sourceMappingURL=metrics.service.d.ts.map

package/dist/evaluation/metrics.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.service.d.ts","sourceRoot":"","sources":["../../src/evaluation/metrics.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gCAAgC,CAAC;AAIlE,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;CACnC;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,YAAY,CAAC;IACtB,WAAW,EAAE,IAAI,CAAC;CACnB;AAED,MAAM,MAAM,cAAc,GAAG,UAAU,GAAG,IAAI,GAAG,WAAW,GAAG,QAAQ,CAAC;AAExE,MAAM,WAAW,eAAe;IAC9B,OAAO,CAAC,EAAE,cAAc,EAAE,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,qBACa,cAAc;IAEvB,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAC;IAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC;gBADjB,aAAa,CAAC,EAAE,aAAa,YAAA,EAC7B,gBAAgB,CAAC,EAAE,gBAAgB,YAAA;IAGtD,OAAO,CAAC,OAAO,CAA8C;IAE7D,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI;IAQhD,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAQ7E,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,gBAAgB,EAAE;IAIjD,eAAe,CACb,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,GACf;QACD,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;QAChC,CAAC,EAAE,gBAAgB,GAAG,SAAS,CAAC;QAChC,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB;IAaD;;;;;;;OAOG;IACG,QAAQ,CACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,EACnC,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,gBAAgB,CAAC;IA2D5B,OAAO,CAAC,qBAAqB;IAW7B,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,wBAAwB;CAmCjC"}

package/dist/evaluation/metrics.service.js

@@ -0,0 +1,163 @@
+"use strict";
+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.MetricsService = void 0;
+const core_1 = require("@hazeljs/core");
+const model_registry_1 = require("../registry/model.registry");
+const predictor_service_1 = require("../inference/predictor.service");
+const core_2 = __importDefault(require("@hazeljs/core"));
+/**
+ * Metrics Service - Model evaluation and metrics
+ * Tracks model performance for A/B testing and monitoring
+ */
+let MetricsService = class MetricsService {
+    constructor(modelRegistry, predictorService) {
+        this.modelRegistry = modelRegistry;
+        this.predictorService = predictorService;
+        this.metrics = new Map();
+    }
+    recordEvaluation(result) {
+        const key = result.modelName;
+        const existing = this.metrics.get(key) || [];
+        existing.push(result);
+        this.metrics.set(key, existing);
+        core_2.default.debug(`Recorded evaluation for ${key}@${result.version}`);
+    }
+    getMetrics(modelName, version) {
+        const results = this.metrics.get(modelName) || [];
+        if (version) {
+            return results.find((r) => r.version === version);
+        }
+        return results[results.length - 1];
+    }
+    getHistory(modelName) {
+        return this.metrics.get(modelName) || [];
+    }
+    compareVersions(modelName, versionA, versionB) {
+        const results = this.metrics.get(modelName) || [];
+        const a = results.find((r) => r.version === versionA);
+        const b = results.find((r) => r.version === versionB);
+        let winner;
+        if (a?.metrics.accuracy !== undefined && b?.metrics.accuracy !== undefined) {
+            winner = a.metrics.accuracy >= b.metrics.accuracy ? versionA : versionB;
+        }
+        return { a, b, winner };
+    }
+    /**
+     * Evaluate model on test data by running predictions and computing metrics.
+     * Requires PredictorService to be injected.
+     *
+     * @param modelName - Registered model name
+     * @param testData - Array of samples. Each sample must contain the model input and a label key.
+     * @param options - labelKey (default: 'label'), predictionKey (tries 'label'|'sentiment'|'class'), metrics, version
+     */
+    async evaluate(modelName, testData, options = {}) {
+        if (!this.predictorService) {
+            throw new Error('MetricsService.evaluate() requires PredictorService. Ensure MLModule is configured with PredictorService.');
+        }
+        const { metrics: requestedMetrics = ['accuracy', 'f1', 'precision', 'recall'], labelKey = 'label', predictionKey, version, } = options;
+        if (testData.length === 0) {
+            throw new Error('testData cannot be empty');
+        }
+        const predictions = [];
+        for (const sample of testData) {
+            const { [labelKey]: _label, ...input } = sample;
+            const pred = await this.predictorService.predict(modelName, input, version);
+            predictions.push(pred);
+        }
+        const labels = testData.map((s) => String(s[labelKey] ?? ''));
+        const predictedLabels = predictions.map((p) => this.extractPredictedLabel(p, predictionKey));
+        const computed = {};
+        if (requestedMetrics.includes('accuracy')) {
+            computed.accuracy = this.computeAccuracy(labels, predictedLabels);
+        }
+        if (requestedMetrics.includes('precision') ||
+            requestedMetrics.includes('recall') ||
+            requestedMetrics.includes('f1')) {
+            const { precision, recall, f1Score } = this.computePrecisionRecallF1(labels, predictedLabels);
+            if (requestedMetrics.includes('precision'))
+                computed.precision = precision;
+            if (requestedMetrics.includes('recall'))
+                computed.recall = recall;
+            if (requestedMetrics.includes('f1'))
+                computed.f1Score = f1Score;
+        }
+        const model = this.modelRegistry?.get(modelName, version);
+        const modelVersion = model?.metadata.version ?? version ?? 'unknown';
+        const result = {
+            modelName,
+            version: modelVersion,
+            metrics: computed,
+            evaluatedAt: new Date(),
+        };
+        this.recordEvaluation(result);
+        core_2.default.debug(`Evaluated ${modelName}@${modelVersion}`, computed);
+        return result;
+    }
+    extractPredictedLabel(prediction, key) {
+        if (key && prediction[key] !== undefined) {
+            return String(prediction[key]);
+        }
+        for (const k of ['label', 'sentiment', 'class', 'prediction']) {
+            if (prediction[k] !== undefined)
+                return String(prediction[k]);
+        }
+        const first = Object.values(prediction)[0];
+        return first !== undefined ? String(first) : '';
+    }
+    computeAccuracy(labels, predicted) {
+        let correct = 0;
+        for (let i = 0; i < labels.length; i++) {
+            if (labels[i] === predicted[i])
+                correct++;
+        }
+        return labels.length > 0 ? correct / labels.length : 0;
+    }
+    computePrecisionRecallF1(labels, predicted) {
+        const classes = [...new Set([...labels, ...predicted])].filter(Boolean);
+        if (classes.length === 0)
+            return { precision: 0, recall: 0, f1Score: 0 };
+        let totalPrecision = 0;
+        let totalRecall = 0;
+        let count = 0;
+        for (const cls of classes) {
+            let tp = 0, fp = 0, fn = 0;
+            for (let i = 0; i < labels.length; i++) {
+                const isPred = predicted[i] === cls;
+                const isActual = labels[i] === cls;
+                if (isPred && isActual)
+                    tp++;
+                if (isPred && !isActual)
+                    fp++;
+                if (!isPred && isActual)
+                    fn++;
+            }
+            const precision = tp + fp > 0 ? tp / (tp + fp) : 0;
+            const recall = tp + fn > 0 ? tp / (tp + fn) : 0;
+            totalPrecision += precision;
+            totalRecall += recall;
+            count++;
+        }
+        const precision = count > 0 ? totalPrecision / count : 0;
+        const recall = count > 0 ? totalRecall / count : 0;
+        const f1Score = precision + recall > 0 ? (2 * precision * recall) / (precision + recall) : 0;
+        return { precision, recall, f1Score };
+    }
+};
+exports.MetricsService = MetricsService;
+exports.MetricsService = MetricsService = __decorate([
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [model_registry_1.ModelRegistry,
+        predictor_service_1.PredictorService])
+], MetricsService);

package/dist/evaluation/metrics.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=metrics.service.test.d.ts.map

package/dist/evaluation/metrics.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"metrics.service.test.d.ts","sourceRoot":"","sources":["../../src/evaluation/metrics.service.test.ts"],"names":[],"mappings":""}