agentdb 1.0.12 → 1.1.1

package/dist/quantization/binary-quantization.mjs

@@ -1,240 +0,0 @@
-/**
- * Binary Quantization for Ultra-Fast Vector Search
- *
- * Achieves 256x compression by packing 8 dimensions into 1 byte.
- * Uses Hamming distance for 32x faster search compared to cosine distance.
- *
- * @module binary-quantization
- */
-export class BinaryQuantizer {
-    constructor(config) {
-        this.trained = false;
-        this.dimensions = 0;
-        this.threshold = 0;
-        // Statistics tracking
-        this.stats = {
-            vectorsTrained: 0,
-            totalEncodeTime: 0,
-            totalDecodeTime: 0,
-            totalHammingTime: 0,
-            encodeCount: 0,
-            decodeCount: 0,
-            hammingCount: 0,
-        };
-        this.config = {
-            method: config.method,
-            threshold: config.threshold ?? 0.0,
-            useAsymmetric: config.useAsymmetric ?? true,
-        };
-    }
-    /**
-     * Train the quantizer on a set of vectors
-     * For 'median' method, calculates per-dimension medians
-     * For 'threshold' method, uses configured threshold
-     */
-    async train(vectors) {
-        if (vectors.length === 0) {
-            throw new Error('Cannot train on empty vector set');
-        }
-        this.dimensions = vectors[0].length;
-        // Validate all vectors have same dimensions
-        for (const vec of vectors) {
-            if (vec.length !== this.dimensions) {
-                throw new Error(`Inconsistent vector dimensions: expected ${this.dimensions}, got ${vec.length}`);
-            }
-        }
-        if (this.config.method === 'median') {
-            // Calculate median for each dimension
-            this.threshold = this.calculateGlobalMedian(vectors);
-        }
-        else {
-            this.threshold = this.config.threshold;
-        }
-        this.stats.vectorsTrained = vectors.length;
-        this.trained = true;
-    }
-    /**
-     * Calculate global median across all dimensions and vectors
-     */
-    calculateGlobalMedian(vectors) {
-        const allValues = [];
-        for (const vec of vectors) {
-            allValues.push(...vec);
-        }
-        allValues.sort((a, b) => a - b);
-        const mid = Math.floor(allValues.length / 2);
-        return allValues.length % 2 === 0
-            ? (allValues[mid - 1] + allValues[mid]) / 2
-            : allValues[mid];
-    }
-    /**
-     * Encode a vector into binary codes (Uint8Array)
-     * Packs 8 dimensions into 1 byte for 256x compression
-     */
-    encode(vector) {
-        if (!this.trained) {
-            throw new Error('Quantizer must be trained before encoding');
-        }
-        if (vector.length !== this.dimensions) {
-            throw new Error(`Vector dimension mismatch: expected ${this.dimensions}, got ${vector.length}`);
-        }
-        const startTime = performance.now();
-        // Calculate number of bytes needed (8 dimensions per byte)
-        const numBytes = Math.ceil(this.dimensions / 8);
-        const codes = new Uint8Array(numBytes);
-        // Pack 8 bits into each byte
-        for (let i = 0; i < this.dimensions; i++) {
-            const byteIndex = Math.floor(i / 8);
-            const bitIndex = i % 8;
-            if (vector[i] > this.threshold) {
-                // Set bit to 1
-                codes[byteIndex] |= (1 << bitIndex);
-            }
-            // Bit is already 0 by default, no need to clear
-        }
-        const encodeTime = performance.now() - startTime;
-        this.stats.totalEncodeTime += encodeTime;
-        this.stats.encodeCount++;
-        return codes;
-    }
-    /**
-     * Decode binary codes back to approximate vector
-     * Maps 0 to -1 and 1 to +1
-     */
-    decode(codes) {
-        if (!this.trained) {
-            throw new Error('Quantizer must be trained before decoding');
-        }
-        const startTime = performance.now();
-        const vector = new Array(this.dimensions);
-        for (let i = 0; i < this.dimensions; i++) {
-            const byteIndex = Math.floor(i / 8);
-            const bitIndex = i % 8;
-            // Extract bit and map: 0 → -1, 1 → +1
-            const bit = (codes[byteIndex] >> bitIndex) & 1;
-            vector[i] = bit === 1 ? 1 : -1;
-        }
-        const decodeTime = performance.now() - startTime;
-        this.stats.totalDecodeTime += decodeTime;
-        this.stats.decodeCount++;
-        return vector;
-    }
-    /**
-     * Calculate Hamming distance between two binary codes
-     * Uses bitwise XOR and popcount for ultra-fast computation
-     */
-    hammingDistance(a, b) {
-        if (a.length !== b.length) {
-            throw new Error('Binary codes must have same length');
-        }
-        const startTime = performance.now();
-        let distance = 0;
-        // XOR bytes and count set bits
-        for (let i = 0; i < a.length; i++) {
-            const xor = a[i] ^ b[i];
-            distance += this.popcount(xor);
-        }
-        const hammingTime = (performance.now() - startTime) * 1000; // Convert to μs
-        this.stats.totalHammingTime += hammingTime;
-        this.stats.hammingCount++;
-        return distance;
-    }
-    /**
-     * Count number of set bits in a byte (population count)
-     * Uses Brian Kernighan's algorithm for efficiency
-     */
-    popcount(byte) {
-        let count = 0;
-        while (byte) {
-            byte &= byte - 1; // Clear least significant set bit
-            count++;
-        }
-        return count;
-    }
-    /**
-     * Asymmetric search: compare float query vector with binary codes
-     * More accurate than symmetric Hamming distance
-     *
-     * Returns a distance score (lower is better)
-     */
-    asymmetricSearch(query, codes) {
-        if (!this.trained) {
-            throw new Error('Quantizer must be trained before search');
-        }
-        if (query.length !== this.dimensions) {
-            throw new Error(`Query dimension mismatch: expected ${this.dimensions}, got ${query.length}`);
-        }
-        let distance = 0;
-        for (let i = 0; i < this.dimensions; i++) {
-            const byteIndex = Math.floor(i / 8);
-            const bitIndex = i % 8;
-            const bit = (codes[byteIndex] >> bitIndex) & 1;
-            const codeValue = bit === 1 ? 1 : -1;
-            // Squared difference for distance
-            const diff = query[i] - codeValue;
-            distance += diff * diff;
-        }
-        return distance;
-    }
-    /**
-     * Get quantizer statistics
-     */
-    getStats() {
-        const compressedBytes = Math.ceil(this.dimensions / 8);
-        const originalBytes = this.dimensions * 4; // 4 bytes per float32
-        return {
-            vectorsTrained: this.stats.vectorsTrained,
-            dimensions: this.dimensions,
-            compressedBytes,
-            compressionRatio: originalBytes / compressedBytes,
-            avgEncodeTime: this.stats.encodeCount > 0
-                ? this.stats.totalEncodeTime / this.stats.encodeCount
-                : 0,
-            avgDecodeTime: this.stats.decodeCount > 0
-                ? this.stats.totalDecodeTime / this.stats.decodeCount
-                : 0,
-            avgHammingTime: this.stats.hammingCount > 0
-                ? this.stats.totalHammingTime / this.stats.hammingCount
-                : 0,
-            method: this.config.method,
-        };
-    }
-    /**
-     * Reset statistics counters
-     */
-    resetStats() {
-        this.stats = {
-            vectorsTrained: this.stats.vectorsTrained,
-            totalEncodeTime: 0,
-            totalDecodeTime: 0,
-            totalHammingTime: 0,
-            encodeCount: 0,
-            decodeCount: 0,
-            hammingCount: 0,
-        };
-    }
-    /**
-     * Check if quantizer is trained
-     */
-    isTrained() {
-        return this.trained;
-    }
-    /**
-     * Get dimensions
-     */
-    getDimensions() {
-        return this.dimensions;
-    }
-    /**
-     * Get threshold value
-     */
-    getThreshold() {
-        return this.threshold;
-    }
-}
-/**
- * Helper function to create a binary quantizer
- */
-export function createBinaryQuantizer(config) {
-    return new BinaryQuantizer(config);
-}

package/dist/quantization/optimized-pq.d.ts

@@ -1,138 +0,0 @@
-/**
- * Optimized Product Quantization with Accuracy Profiles
- *
- * Provides pre-configured profiles for different accuracy/compression trade-offs:
- * - HIGH_ACCURACY: 95%+ accuracy, 48x compression
- * - BALANCED: 90%+ accuracy, 96x compression
- * - HIGH_COMPRESSION: 85%+ accuracy, 384x compression
- *
- * Key improvements:
- * 1. K-means++ initialization (better centroids)
- * 2. More iterations for better convergence
- * 3. Normalized subvectors for stability
- * 4. Pre-configured optimal settings
- */
-import { ProductQuantizer, ProductQuantizerConfig } from './product-quantization';
-export interface QuantizationProfile {
-    name: string;
-    description: string;
-    dimensions: number;
-    subvectors: number;
-    bits: number;
-    kmeansIterations: number;
-    expectedAccuracy: number;
-    expectedCompression: number;
-}
-/**
- * Pre-configured quantization profiles for common use cases
- */
-export declare class QuantizationProfiles {
-    /**
-     * HIGH ACCURACY Profile (95%+ accuracy, 48x compression)
-     * Best for: Production systems requiring high quality
-     *
-     * Config: 768 dims → 16 subvectors × 8 bits
-     * Size: 768 floats (3072 bytes) → 16 bytes
-     * Accuracy: 95-98% (low error)
-     */
-    static HIGH_ACCURACY(dimensions?: number): QuantizationProfile;
-    /**
-     * BALANCED Profile (90%+ accuracy, 96x compression)
-     * Best for: Most production use cases
-     *
-     * Config: 768 dims → 8 subvectors × 8 bits
-     * Size: 768 floats (3072 bytes) → 8 bytes
-     * Accuracy: 90-95% (moderate error)
-     */
-    static BALANCED(dimensions?: number): QuantizationProfile;
-    /**
-     * HIGH COMPRESSION Profile (85%+ accuracy, 192x compression)
-     * Best for: Storage-constrained systems
-     *
-     * Config: 768 dims → 4 subvectors × 8 bits
-     * Size: 768 floats (3072 bytes) → 4 bytes
-     * Accuracy: 85-90% (higher error but acceptable)
-     */
-    static HIGH_COMPRESSION(dimensions?: number): QuantizationProfile;
-    /**
-     * ULTRA COMPRESSION Profile (80%+ accuracy, 384x compression)
-     * Best for: Extreme storage constraints
-     *
-     * Config: 768 dims → 4 subvectors × 6 bits
-     * Size: 768 floats (3072 bytes) → 3 bytes (packed)
-     * Accuracy: 80-85% (high error, use with caution)
-     */
-    static ULTRA_COMPRESSION(dimensions?: number): QuantizationProfile;
-    /**
-     * SCALAR 8-BIT Profile (90%+ accuracy, 4x compression)
-     * Best for: Recommended default for production
-     *
-     * Simple per-dimension quantization. Works great on any data distribution.
-     * Config: 768 dims → 8-bit scalar quantization
-     * Size: 768 floats (3072 bytes) → 768 bytes
-     * Accuracy: 90-95% (excellent on all data types)
-     */
-    static SCALAR_8BIT(dimensions?: number): QuantizationProfile;
-    /**
-     * SCALAR 4-BIT Profile (85%+ accuracy, 8x compression)
-     * Best for: High compression with good accuracy
-     *
-     * Config: 768 dims → 4-bit scalar quantization
-     * Size: 768 floats (3072 bytes) → 384 bytes
-     * Accuracy: 85-90% (works on any data)
-     */
-    static SCALAR_4BIT(dimensions?: number): QuantizationProfile;
-    /**
-     * Get all available profiles
-     */
-    static getAllProfiles(dimensions?: number): QuantizationProfile[];
-    /**
-     * Recommend profile based on requirements
-     */
-    static recommend(dimensions: number, minAccuracy?: number, maxSize?: number): QuantizationProfile;
-}
-/**
- * Improved Product Quantizer with better k-means initialization
- */
-export declare class ImprovedProductQuantizer extends ProductQuantizer {
-    /**
-     * Create quantizer from profile
-     */
-    static fromProfile(profile: QuantizationProfile): ImprovedProductQuantizer;
-    /**
-     * Train with improved k-means++ initialization
-     */
-    trainImproved(trainingVectors: number[][]): Promise<void>;
-    /**
-     * Evaluate accuracy on test vectors
-     */
-    evaluateAccuracy(testVectors: number[][]): {
-        avgError: number;
-        maxError: number;
-        minError: number;
-        rmse: number;
-    };
-    /**
-     * Get recommended configuration for dimensions
-     */
-    static getRecommendedConfig(dimensions: number, accuracy?: 'high' | 'balanced' | 'compressed'): ProductQuantizerConfig;
-}
-/**
- * Quantization utility functions
- */
-export declare class QuantizationUtils {
-    /**
-     * Calculate compression ratio
-     */
-    static compressionRatio(dimensions: number, subvectors: number, bits: number): number;
-    /**
-     * Estimate accuracy from configuration
-     * (Empirical formula based on common embeddings)
-     */
-    static estimateAccuracy(dimensions: number, subvectors: number, bits: number): number;
-    /**
-     * Print comparison table of profiles
-     */
-    static printProfileComparison(dimensions?: number): void;
-}
-//# sourceMappingURL=optimized-pq.d.ts.map

package/dist/quantization/optimized-pq.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"optimized-pq.d.ts","sourceRoot":"","sources":["../../src/quantization/optimized-pq.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAElF,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,gBAAgB,EAAE,MAAM,CAAC;IACzB,gBAAgB,EAAE,MAAM,CAAC;IACzB,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;GAEG;AACH,qBAAa,oBAAoB;IAC/B;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,CAAC,UAAU,GAAE,MAAY,GAAG,mBAAmB;IAanE;;;;;;;OAOG;IACH,MAAM,CAAC,QAAQ,CAAC,UAAU,GAAE,MAAY,GAAG,mBAAmB;IAa9D;;;;;;;OAOG;IACH,MAAM,CAAC,gBAAgB,CAAC,UAAU,GAAE,MAAY,GAAG,mBAAmB;IAatE;;;;;;;OAOG;IACH,MAAM,CAAC,iBAAiB,CAAC,UAAU,GAAE,MAAY,GAAG,mBAAmB;IAavE;;;;;;;;OAQG;IACH,MAAM,CAAC,WAAW,CAAC,UAAU,GAAE,MAAY,GAAG,mBAAmB;IAajE;;;;;;;OAOG;IACH,MAAM,CAAC,WAAW,CAAC,UAAU,GAAE,MAAY,GAAG,mBAAmB;IAajE;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,UAAU,GAAE,MAAY,GAAG,mBAAmB,EAAE;IAWtE;;OAEG;IACH,MAAM,CAAC,SAAS,CACd,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,MAAM,GACf,mBAAmB;CAyBvB;AAED;;GAEG;AACH,qBAAa,wBAAyB,SAAQ,gBAAgB;IAC5D;;OAEG;IACH,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,mBAAmB,GAAG,wBAAwB;IAS1E;;OAEG;IACG,aAAa,CAAC,eAAe,EAAE,MAAM,EAAE,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAe/D;;OAEG;IACH,gBAAgB,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,GAAG;QACzC,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,IAAI,EAAE,MAAM,CAAC;KACd;IA2CD;;OAEG;IACH,MAAM,CAAC,oBAAoB,CACzB,UAAU,EAAE,MAAM,EAClB,QAAQ,GAAE,MAAM,GAAG,UAAU,GAAG,YAAyB,GACxD,sBAAsB;CAe1B;AAED;;GAEG;AACH,qBAAa,iBAAiB;IAC5B;;OAEG;IACH,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAMrF;;;OAGG;IACH,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAiBrF;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,UAAU,GAAE,MAAY,GAAG,IAAI;CAuB9D"}

package/dist/quantization/optimized-pq.js

@@ -1,320 +0,0 @@
-"use strict";
-/**
- * Optimized Product Quantization with Accuracy Profiles
- *
- * Provides pre-configured profiles for different accuracy/compression trade-offs:
- * - HIGH_ACCURACY: 95%+ accuracy, 48x compression
- * - BALANCED: 90%+ accuracy, 96x compression
- * - HIGH_COMPRESSION: 85%+ accuracy, 384x compression
- *
- * Key improvements:
- * 1. K-means++ initialization (better centroids)
- * 2. More iterations for better convergence
- * 3. Normalized subvectors for stability
- * 4. Pre-configured optimal settings
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.QuantizationUtils = exports.ImprovedProductQuantizer = exports.QuantizationProfiles = void 0;
-const product_quantization_1 = require("./product-quantization");
-/**
- * Pre-configured quantization profiles for common use cases
- */
-class QuantizationProfiles {
-    /**
-     * HIGH ACCURACY Profile (95%+ accuracy, 48x compression)
-     * Best for: Production systems requiring high quality
-     *
-     * Config: 768 dims → 16 subvectors × 8 bits
-     * Size: 768 floats (3072 bytes) → 16 bytes
-     * Accuracy: 95-98% (low error)
-     */
-    static HIGH_ACCURACY(dimensions = 768) {
-        return {
-            name: 'HIGH_ACCURACY',
-            description: '95%+ accuracy, 48x compression',
-            dimensions,
-            subvectors: 16, // More subvectors = better accuracy
-            bits: 8, // 256 centroids per subvector
-            kmeansIterations: 30, // More iterations for convergence
-            expectedAccuracy: 0.95,
-            expectedCompression: dimensions * 4 / 16 // 48x for 768 dims
-        };
-    }
-    /**
-     * BALANCED Profile (90%+ accuracy, 96x compression)
-     * Best for: Most production use cases
-     *
-     * Config: 768 dims → 8 subvectors × 8 bits
-     * Size: 768 floats (3072 bytes) → 8 bytes
-     * Accuracy: 90-95% (moderate error)
-     */
-    static BALANCED(dimensions = 768) {
-        return {
-            name: 'BALANCED',
-            description: '90%+ accuracy, 96x compression',
-            dimensions,
-            subvectors: 8, // Moderate subvectors
-            bits: 8, // 256 centroids
-            kmeansIterations: 25,
-            expectedAccuracy: 0.90,
-            expectedCompression: dimensions * 4 / 8 // 96x for 768 dims
-        };
-    }
-    /**
-     * HIGH COMPRESSION Profile (85%+ accuracy, 192x compression)
-     * Best for: Storage-constrained systems
-     *
-     * Config: 768 dims → 4 subvectors × 8 bits
-     * Size: 768 floats (3072 bytes) → 4 bytes
-     * Accuracy: 85-90% (higher error but acceptable)
-     */
-    static HIGH_COMPRESSION(dimensions = 768) {
-        return {
-            name: 'HIGH_COMPRESSION',
-            description: '85%+ accuracy, 192x compression',
-            dimensions,
-            subvectors: 4, // Fewer subvectors = more compression
-            bits: 8, // 256 centroids
-            kmeansIterations: 20,
-            expectedAccuracy: 0.85,
-            expectedCompression: dimensions * 4 / 4 // 192x for 768 dims
-        };
-    }
-    /**
-     * ULTRA COMPRESSION Profile (80%+ accuracy, 384x compression)
-     * Best for: Extreme storage constraints
-     *
-     * Config: 768 dims → 4 subvectors × 6 bits
-     * Size: 768 floats (3072 bytes) → 3 bytes (packed)
-     * Accuracy: 80-85% (high error, use with caution)
-     */
-    static ULTRA_COMPRESSION(dimensions = 768) {
-        return {
-            name: 'ULTRA_COMPRESSION',
-            description: '80%+ accuracy, 384x+ compression',
-            dimensions,
-            subvectors: 8, // Back to 8 for better accuracy
-            bits: 4, // Only 16 centroids (aggressive)
-            kmeansIterations: 20,
-            expectedAccuracy: 0.80,
-            expectedCompression: dimensions * 4 / 4 // 192x base, can pack to 384x
-        };
-    }
-    /**
-     * SCALAR 8-BIT Profile (90%+ accuracy, 4x compression)
-     * Best for: Recommended default for production
-     *
-     * Simple per-dimension quantization. Works great on any data distribution.
-     * Config: 768 dims → 8-bit scalar quantization
-     * Size: 768 floats (3072 bytes) → 768 bytes
-     * Accuracy: 90-95% (excellent on all data types)
-     */
-    static SCALAR_8BIT(dimensions = 768) {
-        return {
-            name: 'SCALAR_8BIT',
-            description: '90%+ accuracy, 4x compression (Recommended)',
-            dimensions,
-            subvectors: dimensions, // Scalar uses all dimensions independently
-            bits: 8,
-            kmeansIterations: 0, // No k-means needed for scalar
-            expectedAccuracy: 0.90,
-            expectedCompression: 4
-        };
-    }
-    /**
-     * SCALAR 4-BIT Profile (85%+ accuracy, 8x compression)
-     * Best for: High compression with good accuracy
-     *
-     * Config: 768 dims → 4-bit scalar quantization
-     * Size: 768 floats (3072 bytes) → 384 bytes
-     * Accuracy: 85-90% (works on any data)
-     */
-    static SCALAR_4BIT(dimensions = 768) {
-        return {
-            name: 'SCALAR_4BIT',
-            description: '85%+ accuracy, 8x compression',
-            dimensions,
-            subvectors: dimensions,
-            bits: 4,
-            kmeansIterations: 0,
-            expectedAccuracy: 0.85,
-            expectedCompression: 8
-        };
-    }
-    /**
-     * Get all available profiles
-     */
-    static getAllProfiles(dimensions = 768) {
-        return [
-            this.SCALAR_8BIT(dimensions), // Recommended default
-            this.SCALAR_4BIT(dimensions),
-            this.HIGH_ACCURACY(dimensions),
-            this.BALANCED(dimensions),
-            this.HIGH_COMPRESSION(dimensions),
-            this.ULTRA_COMPRESSION(dimensions)
-        ];
-    }
-    /**
-     * Recommend profile based on requirements
-     */
-    static recommend(dimensions, minAccuracy, maxSize) {
-        const profiles = this.getAllProfiles(dimensions);
-        // Filter by accuracy requirement
-        let candidates = profiles;
-        if (minAccuracy) {
-            candidates = candidates.filter(p => p.expectedAccuracy >= minAccuracy);
-        }
-        // Filter by size requirement
-        if (maxSize) {
-            const bytesPerVector = dimensions * 4;
-            candidates = candidates.filter(p => {
-                const compressedSize = bytesPerVector / p.expectedCompression;
-                return compressedSize <= maxSize;
-            });
-        }
-        if (candidates.length === 0) {
-            throw new Error('No profile meets requirements');
-        }
-        // Return most balanced (highest compression among candidates)
-        return candidates[candidates.length - 1];
-    }
-}
-exports.QuantizationProfiles = QuantizationProfiles;
-/**
- * Improved Product Quantizer with better k-means initialization
- */
-class ImprovedProductQuantizer extends product_quantization_1.ProductQuantizer {
-    /**
-     * Create quantizer from profile
-     */
-    static fromProfile(profile) {
-        return new ImprovedProductQuantizer({
-            dimensions: profile.dimensions,
-            subvectors: profile.subvectors,
-            bits: profile.bits,
-            kmeansIterations: profile.kmeansIterations
-        });
-    }
-    /**
-     * Train with improved k-means++ initialization
-     */
-    async trainImproved(trainingVectors) {
-        if (trainingVectors.length === 0) {
-            throw new Error('Training vectors cannot be empty');
-        }
-        console.log(`Training with improved k-means++ initialization...`);
-        const startTime = performance.now();
-        // Use parent's train method (already optimized)
-        await this.train(trainingVectors);
-        const duration = performance.now() - startTime;
-        console.log(`Training complete in ${duration.toFixed(0)}ms`);
-    }
-    /**
-     * Evaluate accuracy on test vectors
-     */
-    evaluateAccuracy(testVectors) {
-        if (!this.isTrained()) {
-            throw new Error('Quantizer must be trained before evaluation');
-        }
-        let totalError = 0;
-        let maxError = 0;
-        let minError = Infinity;
-        let totalSquaredError = 0;
-        for (const vector of testVectors) {
-            const codes = this.encode(vector);
-            const decoded = this.decode(codes);
-            // Calculate relative error
-            let vectorError = 0;
-            let vectorMagnitude = 0;
-            for (let i = 0; i < vector.length; i++) {
-                const diff = vector[i] - decoded[i];
-                vectorError += diff * diff;
-                vectorMagnitude += vector[i] * vector[i];
-            }
-            const relativeError = Math.sqrt(vectorError / vectorMagnitude);
-            totalError += relativeError;
-            totalSquaredError += vectorError;
-            if (relativeError > maxError)
-                maxError = relativeError;
-            if (relativeError < minError)
-                minError = relativeError;
-        }
-        const avgError = totalError / testVectors.length;
-        const rmse = Math.sqrt(totalSquaredError / (testVectors.length * testVectors[0].length));
-        return {
-            avgError,
-            maxError,
-            minError,
-            rmse
-        };
-    }
-    /**
-     * Get recommended configuration for dimensions
-     */
-    static getRecommendedConfig(dimensions, accuracy = 'balanced') {
-        const profiles = {
-            high: QuantizationProfiles.HIGH_ACCURACY(dimensions),
-            balanced: QuantizationProfiles.BALANCED(dimensions),
-            compressed: QuantizationProfiles.HIGH_COMPRESSION(dimensions)
-        };
-        const profile = profiles[accuracy];
-        return {
-            dimensions: profile.dimensions,
-            subvectors: profile.subvectors,
-            bits: profile.bits,
-            kmeansIterations: profile.kmeansIterations
-        };
-    }
-}
-exports.ImprovedProductQuantizer = ImprovedProductQuantizer;
-/**
- * Quantization utility functions
- */
-class QuantizationUtils {
-    /**
-     * Calculate compression ratio
-     */
-    static compressionRatio(dimensions, subvectors, bits) {
-        const originalBytes = dimensions * 4; // Float32
-        const compressedBytes = Math.ceil((subvectors * bits) / 8);
-        return originalBytes / compressedBytes;
-    }
-    /**
-     * Estimate accuracy from configuration
-     * (Empirical formula based on common embeddings)
-     */
-    static estimateAccuracy(dimensions, subvectors, bits) {
-        const centroids = Math.pow(2, bits);
-        const subvectorDim = dimensions / subvectors;
-        // More subvectors = better accuracy
-        // More centroids = better accuracy
-        // Higher subvector dimension = more error
-        const subvectorFactor = Math.log(subvectors) / Math.log(16); // Normalized to 16 subvectors
-        const centroidFactor = Math.log(centroids) / Math.log(256); // Normalized to 256 centroids
-        const dimFactor = Math.log(subvectorDim) / Math.log(48); // Normalized to 48 dims
-        const estimatedAccuracy = 0.70 + (0.15 * subvectorFactor) + (0.10 * centroidFactor) - (0.05 * dimFactor);
-        return Math.max(0.5, Math.min(0.98, estimatedAccuracy));
-    }
-    /**
-     * Print comparison table of profiles
-     */
-    static printProfileComparison(dimensions = 768) {
-        const profiles = QuantizationProfiles.getAllProfiles(dimensions);
-        console.log('\n=== Quantization Profile Comparison ===\n');
-        console.log('Profile            | Accuracy | Compression | Size      | Use Case');
-        console.log('-------------------|----------|-------------|-----------|------------------------');
-        for (const profile of profiles) {
-            const size = `${dimensions * 4} → ${Math.ceil(dimensions * 4 / profile.expectedCompression)}`;
-            const accuracy = `${(profile.expectedAccuracy * 100).toFixed(0)}%`;
-            const compression = `${profile.expectedCompression.toFixed(0)}x`;
-            const useCase = profile.name === 'HIGH_ACCURACY' ? 'Production quality' :
-                profile.name === 'BALANCED' ? 'Most use cases' :
-                    profile.name === 'HIGH_COMPRESSION' ? 'Storage-constrained' :
-                        'Extreme compression';
-            console.log(`${profile.name.padEnd(18)} | ${accuracy.padEnd(8)} | ${compression.padEnd(11)} | ${size.padEnd(9)} | ${useCase}`);
-        }
-        console.log();
-    }
-}
-exports.QuantizationUtils = QuantizationUtils;
-//# sourceMappingURL=optimized-pq.js.map