@hazeljs/ml 0.2.0-beta.69 → 0.2.0-beta.71

package/README.md

@@ -107,6 +107,89 @@ export class MLController {
 }
 ```
 
+## ML Decorators
+
+The package uses three decorators to declare ML models and their behaviour. The registry and services discover them via reflection—no manual wiring needed.
+
+### `@Model` (class)
+
+Marks a class as an ML model and attaches **registry metadata**. Required so the model can be registered and looked up by name/version.
+
+| Property      | Type     | Required | Description |
+|---------------|----------|----------|-------------|
+| `name`        | string   | Yes      | Unique model id (e.g. `'sentiment-classifier'`). |
+| `version`     | string   | Yes      | Semver (e.g. `'1.0.0'`). |
+| `framework`   | string   | Yes      | `'tensorflow'` \| `'onnx'` \| `'custom'`. |
+| `description` | string   | No       | Human-readable description. |
+| `tags`        | string[] | No       | Tags for filtering (default: `[]`). |
+
+**Example:** One model per class; use `@Injectable()` so the app can construct it.
+
+```typescript
+@Model({
+  name: 'spam-classifier',
+  version: '1.0.0',
+  framework: 'custom',
+  description: 'Binary spam/ham classifier',
+  tags: ['nlp', 'moderation'],
+})
+@Injectable()
+export class SpamClassifier {
+  // ...
+}
+```
+
+---
+
+### `@Train` (method)
+
+Marks the **single method** that trains this model. `TrainerService.train(modelName, data)` will call it. Optional config is for documentation or pipeline wiring.
+
+| Option      | Type   | Default   | Description |
+|-------------|--------|-----------|-------------|
+| `pipeline`  | string | `'default'` | Name of a registered `PipelineService` pipeline to run before training. |
+| `batchSize` | number | `32`     | Hint for batching (your logic can ignore it). |
+| `epochs`    | number | `10`     | Hint for epochs (your logic can ignore it). |
+
+**Example:** Exactly one `@Train()` method per model; it receives training data and can return metrics.
+
+```typescript
+@Train({ pipeline: 'sentiment-preprocessing', epochs: 5 })
+async train(data: { samples: Array<{ text: string; label: string }> }): Promise<TrainingResult> {
+  // Your training logic
+  return { accuracy: 0.95, loss: 0.05 };
+}
+```
+
+---
+
+### `@Predict` (method)
+
+Marks the **single method** that runs inference. `PredictorService.predict(modelName, input)` will call it.
+
+| Option    | Type    | Default    | Description |
+|-----------|---------|------------|-------------|
+| `batch`   | boolean | `false`    | Hint that the method supports batch input (semantic only). |
+| `endpoint`| string  | `'/predict'` | Hint for route naming (semantic only). |
+
+**Example:** Exactly one `@Predict()` method per model; it receives one input and returns a prediction object.
+
+```typescript
+@Predict({ batch: true, endpoint: '/predict' })
+async predict(input: { text: string }): Promise<{ label: string; confidence: number }> {
+  // Your inference logic
+  return { label: 'ham', confidence: 0.92 };
+}
+```
+
+---
+
+### Rules
+
+- **One model class** = one `@Model`, one `@Train` method, one `@Predict` method.
+- **Order:** Put `@Model` on the class, then `@Train` and `@Predict` on the methods. Use `@Injectable()` from `@hazeljs/core` so the app can instantiate the model.
+- **Discovery:** When you pass model classes to `MLModule.forRoot({ models: [...] })`, the bootstrap finds the `@Train` and `@Predict` methods and registers them with the registry.
+
 ## Model registration
 
 Models are registered when passed to `MLModule.forRoot({ models: [...] })`. The bootstrap discovers `@Train` and `@Predict` methods via reflection.
@@ -134,11 +217,16 @@ import { PipelineService } from '@hazeljs/ml';
 
 const pipeline = new PipelineService();
 const steps = [
-  { name: 'normalize', fn: (d: { text: string }) => ({ ...d, text: d.text.toLowerCase() }) },
-  { name: 'filter', fn: (d: { text: string }) => d.text.length > 0 },
+  { name: 'normalize', transform: (d: unknown) => ({ ...(d as object), text: (d as { text: string }).text?.toLowerCase() }) },
+  { name: 'filter', transform: (d: unknown) => (d as { text: string }).text?.length > 0 ? d : null },
 ];
+// Inline steps (no registration required)
 const processed = await pipeline.run(data, steps);
 await model.train(processed);
+
+// Or register a named pipeline
+pipeline.registerPipeline('default', steps);
+const processed2 = await pipeline.run('default', data);
 ```
 
 ## Batch predictions
@@ -149,7 +237,9 @@ import { BatchService } from '@hazeljs/ml';
 const batchService = new BatchService(predictorService);
 const results = await batchService.predictBatch('sentiment-classifier', items, {
   batchSize: 32,
+  concurrency: 4,
 });
+// Results are returned in the same order as inputs
 ```
 
 ## Metrics and evaluation
@@ -157,9 +247,32 @@ const results = await batchService.predictBatch('sentiment-classifier', items, {
 ```typescript
 import { MetricsService } from '@hazeljs/ml';
 
-const metricsService = new MetricsService();
-const evaluation = await metricsService.evaluate(modelName, testData, {
-  metrics: ['accuracy', 'f1', 'precision', 'recall'],
+// Evaluate model on test data (inject MetricsService via MLModule - it receives PredictorService)
+@Injectable()
+class EvaluationService {
+  constructor(private metricsService: MetricsService) {}
+
+  async runEvaluation() {
+    const testData = [
+      { text: 'great product', label: 'positive' },
+      { text: 'terrible', label: 'negative' },
+    ];
+    const evaluation = await this.metricsService.evaluate('sentiment-classifier', testData, {
+      metrics: ['accuracy', 'f1', 'precision', 'recall'],
+      labelKey: 'label',           // key in test sample for ground truth
+      predictionKey: 'sentiment',   // key in prediction result (auto-detect: label, sentiment, class)
+    });
+    // evaluation.metrics: { accuracy, precision, recall, f1Score }
+    // Result is automatically recorded via recordEvaluation()
+  }
+}
+
+// Manual recording
+metricsService.recordEvaluation({
+  modelName: 'my-model',
+  version: '1.0.0',
+  metrics: { accuracy: 0.95, loss: 0.05 },
+  evaluatedAt: new Date(),
 });
 ```
 
@@ -174,9 +287,10 @@ const evaluation = await metricsService.evaluate(modelName, testData, {
 | `BatchService` | Batch prediction with configurable batch size |
 | `MetricsService` | Model evaluation and metrics tracking |
 
-## Example
+## Examples
 
-See [hazeljs-ml-starter](../../../hazeljs-ml-starter) for a full example with sentiment, spam, intent classifiers, REST API, training pipeline, and metrics.
+- **[hazeljs-ml-starter](../../../hazeljs-ml-starter)** – Full app: sentiment, spam, intent classifiers, REST API, training pipeline, and metrics.
+- **[example/src/ml](../../example/src/ml)** – Minimal runnable example of the three decorators (`npm run ml:decorators` from the example repo).
 
 ## Links
 

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

@@ -1,3 +1,5 @@
+import { ModelRegistry } from '../registry/model.registry';
+import { PredictorService } from '../inference/predictor.service';
 export interface ModelMetrics {
     accuracy?: number;
     precision?: number;
@@ -12,11 +14,21 @@ export interface EvaluationResult {
     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;
@@ -26,5 +38,17 @@ export declare class MetricsService {
         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

@@ -1 +1 @@
-{"version":3,"file":"metrics.service.d.ts","sourceRoot":"","sources":["../../src/evaluation/metrics.service.ts"],"names":[],"mappings":"AAGA,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;;;GAGG;AACH,qBACa,cAAc;IACzB,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;CAYF"}
+{"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

@@ -5,19 +5,26 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     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() {
+    constructor(modelRegistry, predictorService) {
+        this.modelRegistry = modelRegistry;
+        this.predictorService = predictorService;
         this.metrics = new Map();
     }
     recordEvaluation(result) {
@@ -47,8 +54,110 @@ let MetricsService = class MetricsService {
         }
         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)()
+    (0, core_1.Service)(),
+    __metadata("design:paramtypes", [model_registry_1.ModelRegistry,
+        predictor_service_1.PredictorService])
 ], MetricsService);

package/dist/evaluation/metrics.service.test.js

@@ -1,6 +1,18 @@
 "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 });
+const model_registry_1 = require("../registry/model.registry");
+const predictor_service_1 = require("../inference/predictor.service");
 const metrics_service_1 = require("./metrics.service");
+const decorators_1 = require("../decorators");
 describe('MetricsService', () => {
     let service;
     beforeEach(() => {
@@ -76,4 +88,166 @@ describe('MetricsService', () => {
         const { winner } = service.compareVersions('m', 'a', 'b');
         expect(winner).toBeUndefined();
     });
+    describe('evaluate', () => {
+        let EvalModel = class EvalModel {
+            train() { }
+            async predict(input) {
+                const sentiment = input.text.includes('good') ? 'positive' : 'negative';
+                return { sentiment };
+            }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], EvalModel.prototype, "train", null);
+        __decorate([
+            (0, decorators_1.Predict)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", [Object]),
+            __metadata("design:returntype", Promise)
+        ], EvalModel.prototype, "predict", null);
+        EvalModel = __decorate([
+            (0, decorators_1.Model)({ name: 'eval-model', version: '1.0.0', framework: 'custom' })
+        ], EvalModel);
+        it('throws when PredictorService not injected', async () => {
+            const svc = new metrics_service_1.MetricsService();
+            await expect(svc.evaluate('any', [{ text: 'hello', label: 'neutral' }])).rejects.toThrow('MetricsService.evaluate() requires PredictorService');
+        });
+        it('throws when testData is empty', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            await expect(svc.evaluate('eval-model', [])).rejects.toThrow('testData cannot be empty');
+        });
+        it('computes accuracy, precision, recall, f1 from test data', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const testData = [
+                { text: 'good day', label: 'positive' },
+                { text: 'bad day', label: 'negative' },
+                { text: 'good weather', label: 'positive' },
+                { text: 'bad weather', label: 'negative' },
+            ];
+            const result = await svc.evaluate('eval-model', testData);
+            expect(result.modelName).toBe('eval-model');
+            expect(result.version).toBe('1.0.0');
+            expect(result.metrics.accuracy).toBe(1);
+            expect(result.metrics.precision).toBe(1);
+            expect(result.metrics.recall).toBe(1);
+            expect(result.metrics.f1Score).toBe(1);
+        });
+        it('supports custom labelKey and predictionKey', async () => {
+            let CustomModel = class CustomModel {
+                train() { }
+                async predict(input) {
+                    return { outcome: input.x === 'a' ? 'yes' : 'no' };
+                }
+            };
+            __decorate([
+                (0, decorators_1.Train)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], CustomModel.prototype, "train", null);
+            __decorate([
+                (0, decorators_1.Predict)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", [Object]),
+                __metadata("design:returntype", Promise)
+            ], CustomModel.prototype, "predict", null);
+            CustomModel = __decorate([
+                (0, decorators_1.Model)({ name: 'custom-model', version: '1.0.0', framework: 'custom' })
+            ], CustomModel);
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'custom-model', version: '1.0.0', framework: 'custom' },
+                instance: new CustomModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const result = await svc.evaluate('custom-model', [
+                { x: 'a', outcome: 'yes' },
+                { x: 'b', outcome: 'no' },
+            ], { labelKey: 'outcome', predictionKey: 'outcome' });
+            expect(result.metrics.accuracy).toBe(1);
+        });
+        it('extractPredictedLabel uses first value when no known key', async () => {
+            let FallbackModel = class FallbackModel {
+                train() { }
+                async predict() {
+                    return { customKey: 'positive' };
+                }
+            };
+            __decorate([
+                (0, decorators_1.Train)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", void 0)
+            ], FallbackModel.prototype, "train", null);
+            __decorate([
+                (0, decorators_1.Predict)(),
+                __metadata("design:type", Function),
+                __metadata("design:paramtypes", []),
+                __metadata("design:returntype", Promise)
+            ], FallbackModel.prototype, "predict", null);
+            FallbackModel = __decorate([
+                (0, decorators_1.Model)({ name: 'fallback-model', version: '1.0.0', framework: 'custom' })
+            ], FallbackModel);
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'fallback-model', version: '1.0.0', framework: 'custom' },
+                instance: new FallbackModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const result = await svc.evaluate('fallback-model', [{ text: 'x', label: 'positive' }], {
+                metrics: ['accuracy'],
+            });
+            expect(result.metrics.accuracy).toBe(1);
+        });
+        it('evaluate with only accuracy metric skips precision/recall/f1', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(registry, predictor);
+            const result = await svc.evaluate('eval-model', [{ text: 'good', label: 'positive' }], {
+                metrics: ['accuracy'],
+            });
+            expect(result.metrics.accuracy).toBeDefined();
+            expect(result.metrics.precision).toBeUndefined();
+            expect(result.metrics.recall).toBeUndefined();
+            expect(result.metrics.f1Score).toBeUndefined();
+        });
+        it('evaluate when modelRegistry is undefined uses version unknown', async () => {
+            const registry = new model_registry_1.ModelRegistry();
+            registry.register({
+                metadata: { name: 'eval-model', version: '1.0.0', framework: 'custom' },
+                instance: new EvalModel(),
+                predictMethod: 'predict',
+            });
+            const predictor = new predictor_service_1.PredictorService(registry);
+            const svc = new metrics_service_1.MetricsService(undefined, predictor);
+            const result = await svc.evaluate('eval-model', [{ text: 'good', label: 'positive' }]);
+            expect(result.version).toBeDefined();
+        });
+    });
 });

package/dist/index.d.ts

@@ -9,7 +9,7 @@ export { TrainerService } from './training/trainer.service';
 export { PipelineService, type PipelineStep } from './training/pipeline.service';
 export { PredictorService } from './inference/predictor.service';
 export { BatchService, type BatchPredictionOptions } from './inference/batch.service';
-export { MetricsService, type ModelMetrics, type EvaluationResult, } from './evaluation/metrics.service';
+export { MetricsService, type ModelMetrics, type EvaluationResult, type EvaluateOptions, type EvaluateMetric, } from './evaluation/metrics.service';
 export { registerMLModel } from './ml-model.base';
 export { Injectable } from '@hazeljs/core';
 export type { MLFramework, ModelMetadata, TrainingData, TrainingResult, PredictionResult, ModelVersion, } from './ml.types';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,kBAAkB,CAAC;AAG1B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAGxE,OAAO,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAGhF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,KAAK,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,EACL,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,gBAAgB,GACtB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,YAAY,EACV,WAAW,EACX,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,kBAAkB,CAAC;AAG1B,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAGxE,OAAO,EACL,KAAK,EACL,KAAK,EACL,OAAO,EACP,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAClB,KAAK,YAAY,EACjB,KAAK,cAAc,GACpB,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,aAAa,EAAE,KAAK,eAAe,EAAE,MAAM,2BAA2B,CAAC;AAGhF,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,KAAK,YAAY,EAAE,MAAM,6BAA6B,CAAC;AACjF,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EAAE,YAAY,EAAE,KAAK,sBAAsB,EAAE,MAAM,2BAA2B,CAAC;AACtF,OAAO,EACL,cAAc,EACd,KAAK,YAAY,EACjB,KAAK,gBAAgB,EACrB,KAAK,eAAe,EACpB,KAAK,cAAc,GACpB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAG3C,YAAY,EACV,WAAW,EACX,aAAa,EACb,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/inference/batch.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"batch.service.d.ts","sourceRoot":"","sources":["../../src/inference/batch.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,qBACa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBAAhB,gBAAgB,EAAE,gBAAgB;IAEzD,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,EAAE,EACjB,OAAO,GAAE,sBAA2B,EACpC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;CAwBlC"}
+{"version":3,"file":"batch.service.d.ts","sourceRoot":"","sources":["../../src/inference/batch.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG/C,MAAM,WAAW,sBAAsB;IACrC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED;;;GAGG;AACH,qBACa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,gBAAgB;gBAAhB,gBAAgB,EAAE,gBAAgB;IAEzD,YAAY,CAAC,CAAC,GAAG,OAAO,EAC5B,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,OAAO,EAAE,EACjB,OAAO,GAAE,sBAA2B,EACpC,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC;CA+BlC"}

package/dist/inference/batch.service.js

@@ -27,15 +27,20 @@ let BatchService = class BatchService {
     async predictBatch(modelName, inputs, options = {}, version) {
         const { batchSize = 32, concurrency = 4 } = options;
         core_2.default.debug(`Batch prediction: ${inputs.length} inputs, batchSize=${batchSize}`);
-        const results = [];
+        const results = new Array(inputs.length);
         const batches = [];
         for (let i = 0; i < inputs.length; i += batchSize) {
-            batches.push(inputs.slice(i, i + batchSize));
+            const batch = inputs.slice(i, i + batchSize).map((input, j) => ({ input, idx: i + j }));
+            batches.push(batch);
         }
         for (let i = 0; i < batches.length; i += concurrency) {
             const batchGroup = batches.slice(i, i + concurrency);
-            const batchResults = await Promise.all(batchGroup.flatMap((batch) => batch.map((input) => this.predictorService.predict(modelName, input, version))));
-            results.push(...batchResults);
+            const batchResults = await Promise.all(batchGroup.flatMap((batch) => batch.map(({ input, idx }) => this.predictorService
+                .predict(modelName, input, version)
+                .then((r) => ({ idx, r })))));
+            for (const { idx, r } of batchResults) {
+                results[idx] = r;
+            }
         }
         return results;
     }

package/dist/inference/batch.service.test.js

@@ -55,7 +55,32 @@ describe('BatchService', () => {
         });
         expect(results).toHaveLength(5);
     });
+    it('preserves result order matching input order', async () => {
+        const inputs = [10, 20, 30, 40, 50];
+        const results = await batchService.predictBatch('batch-model', inputs, {
+            batchSize: 2,
+            concurrency: 2,
+        });
+        expect(results).toEqual([
+            { value: 20 },
+            { value: 40 },
+            { value: 60 },
+            { value: 80 },
+            { value: 100 },
+        ]);
+    });
     it('throws when model not found', async () => {
         await expect(batchService.predictBatch('unknown', [1])).rejects.toThrow('Model not found: unknown');
     });
+    it('uses default batchSize and concurrency when options empty', async () => {
+        const results = await batchService.predictBatch('batch-model', [1, 2], {});
+        expect(results).toHaveLength(2);
+        expect(results).toEqual([{ value: 2 }, { value: 4 }]);
+    });
+    it('uses custom concurrency with default batchSize', async () => {
+        const results = await batchService.predictBatch('batch-model', [1, 2, 3], {
+            concurrency: 1,
+        });
+        expect(results).toEqual([{ value: 2 }, { value: 4 }, { value: 6 }]);
+    });
 });

package/dist/inference/predictor.service.test.js

@@ -83,4 +83,33 @@ describe('PredictorService', () => {
         const instance = new TestModel();
         expect(predictor.discoverPredictMethod(instance)).toBe('predict');
     });
+    it('throws when predict method is not a function', async () => {
+        const fakeInstance = {
+            predict: 'not-a-function',
+        };
+        registry.register({
+            metadata: { name: 'broken-model', version: '1.0.0', framework: 'custom' },
+            instance: fakeInstance,
+            trainMethod: undefined,
+            predictMethod: 'predict',
+        });
+        await expect(predictor.predict('broken-model', {})).rejects.toThrow('Prediction method predict not found on model');
+    });
+    it('discoverPredictMethod returns undefined when no @Predict method', () => {
+        let NoPredictClass = class NoPredictClass {
+            train() { }
+            someMethod() { }
+        };
+        __decorate([
+            (0, decorators_1.Train)(),
+            __metadata("design:type", Function),
+            __metadata("design:paramtypes", []),
+            __metadata("design:returntype", void 0)
+        ], NoPredictClass.prototype, "train", null);
+        NoPredictClass = __decorate([
+            (0, decorators_1.Model)({ name: 'no-predict-method', version: '1.0.0', framework: 'custom' })
+        ], NoPredictClass);
+        const instance = new NoPredictClass();
+        expect(predictor.discoverPredictMethod(instance)).toBeUndefined();
+    });
 });

package/dist/registry/model.registry.test.js

@@ -49,6 +49,9 @@ describe('ModelRegistry', () => {
         expect(list.map((m) => m.name)).toContain('a');
         expect(list.map((m) => m.name)).toContain('b');
     });
+    it('getVersions returns empty array for unknown model', () => {
+        expect(registry.getVersions('unknown')).toEqual([]);
+    });
     it('getVersions returns version history', () => {
         registry.register({
             metadata: { name: 'model', version: '1.0.0', framework: 'tensorflow' },
@@ -73,4 +76,18 @@ describe('ModelRegistry', () => {
         expect(registry.get('model', '1.0.0')).toBeUndefined();
         expect(registry.unregister('model', '1.0.0')).toBe(false);
     });
+    it('unregister updates versions list when deleting', () => {
+        registry.register({
+            metadata: { name: 'm', version: '1.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.register({
+            metadata: { name: 'm', version: '2.0.0', framework: 'tensorflow' },
+            instance: {},
+        });
+        registry.unregister('m', '1.0.0');
+        const versions = registry.getVersions('m');
+        expect(versions).toHaveLength(1);
+        expect(versions[0].version).toBe('2.0.0');
+    });
 });

package/dist/training/pipeline.service.d.ts

@@ -10,7 +10,15 @@ export interface PipelineStep {
 export declare class PipelineService {
     private pipelines;
     registerPipeline(name: string, steps: PipelineStep[]): void;
+    /**
+     * Run a registered pipeline by name.
+     */
     run(name: string, data: TrainingData): Promise<TrainingData>;
+    /**
+     * Run an ad-hoc pipeline with inline steps (no registration required).
+     */
+    run(data: TrainingData, steps: PipelineStep[]): Promise<TrainingData>;
+    private executeSteps;
     getPipeline(name: string): PipelineStep[] | undefined;
     listPipelines(): string[];
 }

package/dist/training/pipeline.service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pipeline.service.d.ts","sourceRoot":"","sources":["../../src/training/pipeline.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC1D;AAED;;;GAGG;AACH,qBACa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAA0C;IAE3D,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAKrD,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAelE,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,GAAG,SAAS;IAIrD,aAAa,IAAI,MAAM,EAAE;CAG1B"}
+{"version":3,"file":"pipeline.service.d.ts","sourceRoot":"","sources":["../../src/training/pipeline.service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAG3C,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC;CAC1D;AAED;;;GAGG;AACH,qBACa,eAAe;IAC1B,OAAO,CAAC,SAAS,CAA0C;IAE3D,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,IAAI;IAK3D;;OAEG;IACG,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAElE;;OAEG;IACG,GAAG,CAAC,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC;YA2B7D,YAAY;IAa1B,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,GAAG,SAAS;IAIrD,aAAa,IAAI,MAAM,EAAE;CAG1B"}

package/dist/training/pipeline.service.js

@@ -24,14 +24,30 @@ let PipelineService = class PipelineService {
         this.pipelines.set(name, steps);
         core_2.default.debug(`Registered pipeline: ${name} with ${steps.length} steps`);
     }
-    async run(name, data) {
-        const steps = this.pipelines.get(name);
-        if (!steps) {
-            throw new Error(`Pipeline not found: ${name}`);
+    async run(nameOrData, dataOrSteps) {
+        let data;
+        let steps;
+        let label;
+        if (typeof nameOrData === 'string') {
+            label = nameOrData;
+            data = dataOrSteps;
+            const registered = this.pipelines.get(nameOrData);
+            if (!registered) {
+                throw new Error(`Pipeline not found: ${nameOrData}`);
+            }
+            steps = registered;
         }
+        else {
+            label = 'inline';
+            data = nameOrData;
+            steps = dataOrSteps;
+        }
+        return this.executeSteps(data, steps, label);
+    }
+    async executeSteps(data, steps, label) {
         let result = data;
         for (const step of steps) {
-            core_2.default.debug(`Pipeline ${name}: executing step ${step.name}`);
+            core_2.default.debug(`Pipeline ${label}: executing step ${step.name}`);
             result = await Promise.resolve(step.transform(result));
         }
         return result;

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

@@ -35,4 +35,18 @@ describe('PipelineService', () => {
         service.registerPipeline('b', []);
         expect(service.listPipelines()).toEqual(['a', 'b']);
     });
+    it('run with inline steps (no registration)', async () => {
+        const steps = [
+            {
+                name: 'lower',
+                transform: (d) => ({
+                    ...d,
+                    x: d.x?.toLowerCase() ?? '',
+                }),
+            },
+            { name: 'add', transform: (d) => ({ ...d, y: 1 }) },
+        ];
+        const result = await service.run({ x: 'HELLO' }, steps);
+        expect(result).toEqual({ x: 'hello', y: 1 });
+    });
 });

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

@@ -86,4 +86,14 @@ describe('TrainerService', () => {
         }
         expect(trainer.discoverTrainMethod(new PlainClass())).toBeUndefined();
     });
+    it('throws when train method is not a function', async () => {
+        const fakeInstance = { train: 'not-a-function' };
+        registry.register({
+            metadata: { name: 'broken-train', version: '1.0.0', framework: 'custom' },
+            instance: fakeInstance,
+            trainMethod: 'train',
+            predictMethod: undefined,
+        });
+        await expect(trainer.train('broken-train', {})).rejects.toThrow('Training method train not found on model');
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/ml",
-  "version": "0.2.0-beta.69",
+  "version": "0.2.0-beta.71",
   "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.com",
-  "gitHead": "a0aa75c1e4607c4e362f907163d248066d567517"
+  "gitHead": "7bdf3c29736ca224aaaa46963a67dc28ec65fd2a"
 }