Optimizador de Dimensiones de Vectores

/**
 * client-reducer.ts
 * Browser-safe embedding dimensionality reducer & optimizer.
 * Designed for Matryoshka Representation Learning (MRL) and local quantization.
 */

export function optimizeEmbedding(
  vector: number[],
  targetDim: number = 256,
  format: 'float32' | 'int8' | 'binary' = 'float32'
): {
  data: Float32Array | Int8Array | Uint8Array;
  scale?: number;
} {
  // 1. Matryoshka Truncation (Slice prefix)
  const sliced = vector.slice(0, targetDim);

  // 2. L2 Re-normalization (Ensure unit length)
  let sumSq = 0;
  for (let i = 0; i < targetDim; i++) {
    sumSq += sliced[i] * sliced[i];
  }
  const norm = Math.sqrt(sumSq);
  const normalized = new Float32Array(targetDim);
  if (norm > 0) {
    for (let i = 0; i < targetDim; i++) {
      normalized[i] = sliced[i] / norm;
    }
  }

  // 3. Apply Quantization Format
  if (format === 'float32') {
    return { data: normalized };
  }

  if (format === 'int8') {
    // Find absolute maximum value for scaling
    let maxVal = 0;
    for (let i = 0; i < targetDim; i++) {
      const abs = Math.abs(normalized[i]);
      if (abs > maxVal) maxVal = abs;
    }
    const scale = maxVal > 0 ? 127 / maxVal : 1;
    const int8Data = new Int8Array(targetDim);
    for (let i = 0; i < targetDim; i++) {
      int8Data[i] = Math.round(normalized[i] * scale);
    }
    return { data: int8Data, scale };
  }

  if (format === 'binary') {
    // Pack every 8 float values into a single byte
    const byteLen = Math.ceil(targetDim / 8);
    const binaryData = new Uint8Array(byteLen);
    for (let i = 0; i < targetDim; i++) {
      if (normalized[i] >= 0) {
        const byteIdx = Math.floor(i / 8);
        const bitIdx = i % 8;
        binaryData[byteIdx] |= (1 << bitIdx);
      }
    }
    return { data: binaryData };
  }

  throw new Error('Unsupported quantization format');
}

/**
 * Helper to calculate Hamming Distance between two Packed Binary Vectors
 */
export function hammingDistance(a: Uint8Array, b: Uint8Array): number {
  let distance = 0;
  for (let i = 0; i < a.length; i++) {
    let xor = a[i] ^ b[i];
    while (xor > 0) {
      if (xor & 1) distance++;
      xor >>= 1;
    }
  }
  return distance;
}