reconstruct

services/kmeans.ts

@@ -0,0 +1,144 @@
+export type Point = number[];
+
+export interface Cluster {
+    centroid: Point;
+    points: Point[];
+}
+
+export interface KMeansOptions {
+    batchSize?: number;
+    maxIterations?: number;
+    tolerance?: number;
+}
+
+export interface KMeansResult {
+    clusters: Cluster[];
+    iterations: number;
+    converged: boolean;
+}
+
+export class KMeans {
+    private readonly k: number;
+    private readonly batchSize: number;
+    private readonly maxIterations: number;
+    private readonly tolerance: number;
+    private readonly data: Point[];
+    private centroids: Point[] = [];
+
+    constructor(data: Point[], k: number, options: KMeansOptions = {}) {
+        this.data = data;
+        this.k = k;
+        this.batchSize = options.batchSize ?? 32;
+        this.maxIterations = options.maxIterations ?? 100;
+        this.tolerance = options.tolerance ?? 0.0001;
+    }
+
+    private static euclideanDistance(p1: Point, p2: Point): number {
+        return Math.sqrt(p1.reduce((sum, val, i) => sum + (val - p2[i]) ** 2, 0));
+    }
+
+    private initializeCentroids(): void {
+        const dataCopy = [...this.data];
+        for (let i = 0; i < this.k; i++) {
+            const randomIndex = Math.floor(Math.random() * dataCopy.length);
+            this.centroids.push([...dataCopy[randomIndex]]);
+            dataCopy.splice(randomIndex, 1);
+        }
+    }
+
+    /**
+     * Creates a random sample of the data.
+     */
+    private createMiniBatch(): Point[] {
+        const miniBatch: Point[] = [];
+        const dataCopy = [...this.data];
+        for (let i = 0; i < this.batchSize && dataCopy.length > 0; i++) {
+            const randomIndex = Math.floor(Math.random() * dataCopy.length);
+            miniBatch.push(dataCopy[randomIndex]);
+            dataCopy.splice(randomIndex, 1);
+        }
+        return miniBatch;
+    }
+    
+    /**
+     * Assigns all points in the full dataset to the final centroids.
+     */
+    private assignFinalClusters(): Cluster[] {
+        const clusters: Cluster[] = this.centroids.map(c => ({ centroid: c, points: [] }));
+
+        for (const point of this.data) {
+            let minDistance = Infinity;
+            let closestClusterIndex = -1;
+            for (let i = 0; i < this.centroids.length; i++) {
+                const distance = KMeans.euclideanDistance(point, this.centroids[i]);
+                if (distance < minDistance) {
+                    minDistance = distance;
+                    closestClusterIndex = i;
+                }
+            }
+            if (closestClusterIndex !== -1) {
+                clusters[closestClusterIndex].points.push(point);
+            }
+        }
+        return clusters;
+    }
+
+    public run(): KMeansResult {
+        this.initializeCentroids();
+        
+        const clusterPointCounts = new Array(this.k).fill(0);
+        let converged = false;
+        let iterations = 0;
+
+        for (let i = 0; i < this.maxIterations; i++) {
+            iterations = i + 1;
+            const miniBatch = this.createMiniBatch();
+            const previousCentroids = this.centroids.map(c => [...c]);
+
+            // Assign points in the batch and update centroids gradually
+            for (const point of miniBatch) {
+                let minDistance = Infinity;
+                let closestClusterIndex = -1;
+
+                for (let j = 0; j < this.k; j++) {
+                    const distance = KMeans.euclideanDistance(point, this.centroids[j]);
+                    if (distance < minDistance) {
+                        minDistance = distance;
+                        closestClusterIndex = j;
+                    }
+                }
+
+                if (closestClusterIndex !== -1) {
+                    clusterPointCounts[closestClusterIndex]++;
+                    const learningRate = 1 / clusterPointCounts[closestClusterIndex];
+                    const centroidToUpdate = this.centroids[closestClusterIndex];
+
+                    // Move the centroid slightly towards the new point
+                    for (let dim = 0; dim < centroidToUpdate.length; dim++) {
+                        centroidToUpdate[dim] = (1 - learningRate) * centroidToUpdate[dim] + learningRate * point[dim];
+                    }
+                }
+            }
+            
+            // Check for convergence
+            let totalMovement = 0;
+            for(let j = 0; j < this.k; j++) {
+                totalMovement += KMeans.euclideanDistance(previousCentroids[j], this.centroids[j]);
+            }
+            
+            if (totalMovement < this.tolerance) {
+                converged = true;
+                break;
+            }
+        }
+        
+        // After training, assign all points to the final centroids
+        const finalClusters = this.assignFinalClusters();
+
+        return {
+            clusters: finalClusters,
+            iterations,
+            converged
+        };
+    }
+}