datly 0.0.2 → 0.0.3

package/src/ml/SupportVectorMachine.js

@@ -1,299 +0,0 @@
-import BaseModel from './baseModel.js';
-
-class SupportVectorMachine extends BaseModel {
-  constructor(C = 1.0, kernel = 'linear', gamma = 'scale', degree = 3, learningRate = 0.001, iterations = 1000) {
-    super();
-    this.C = C; // Regularization parameter
-    this.kernel = kernel; // 'linear', 'rbf', 'poly'
-    this.gamma = gamma; // Kernel coefficient ('scale', 'auto', or number)
-    this.degree = degree; // Degree for polynomial kernel
-    this.learningRate = learningRate;
-    this.iterations = iterations;
-    this.weights = null;
-    this.bias = null;
-    this.supportVectors = null;
-    this.classes = null;
-    this.normParams = null;
-  }
-
-  fit(X, y, normalize = true) {
-    this.validateTrainingData(X, y);
-
-    let X_train = X.map(row => Array.isArray(row) ? row : [row]);
-    this.classes = [...new Set(y)].sort();
-
-    if (this.classes.length !== 2) {
-      throw new Error('SVM currently only supports binary classification');
-    }
-
-    // Convert labels to -1 and 1
-    const yBinary = y.map(label => label === this.classes[1] ? 1 : -1);
-
-    if (normalize) {
-      const { normalized, means, stds } = this.normalizeFeatures(X_train);
-      X_train = normalized;
-      this.normParams = { means, stds };
-    }
-
-    const nSamples = X_train.length;
-    const nFeatures = X_train[0].length;
-
-    // Calculate gamma if set to 'scale' or 'auto'
-    if (this.gamma === 'scale') {
-      const variance = this.calculateVariance(X_train);
-      this.gamma = 1 / (nFeatures * variance);
-    } else if (this.gamma === 'auto') {
-      this.gamma = 1 / nFeatures;
-    }
-
-    // Initialize weights and bias
-    this.weights = Array(nFeatures).fill(0);
-    this.bias = 0;
-
-    const losses = [];
-
-    // Simplified SMO-like algorithm (gradient descent)
-    for (let iter = 0; iter < this.iterations; iter++) {
-      let loss = 0;
-
-      for (let i = 0; i < nSamples; i++) {
-        const xi = X_train[i];
-        const yi = yBinary[i];
-
-        const prediction = this.decisionFunction([xi])[0];
-        const margin = yi * prediction;
-
-        if (margin < 1) {
-          // Update weights for misclassified or margin violations
-          for (let j = 0; j < nFeatures; j++) {
-            this.weights[j] += this.learningRate * (yi * xi[j] - 2 * (1 / this.C) * this.weights[j]);
-          }
-          this.bias += this.learningRate * yi;
-          loss += 1 - margin;
-        } else {
-          // Update weights for correct classifications
-          for (let j = 0; j < nFeatures; j++) {
-            this.weights[j] += this.learningRate * (-2 * (1 / this.C) * this.weights[j]);
-          }
-        }
-      }
-
-      // Add regularization term to loss
-      const regTerm = (1 / this.C) * this.weights.reduce((sum, w) => sum + w * w, 0);
-      losses.push(loss / nSamples + regTerm);
-    }
-
-    // Identify support vectors (samples near the margin)
-    this.identifySupportVectors(X_train, yBinary);
-
-    this.trained = true;
-
-    this.trainingMetrics = {
-      finalLoss: losses[losses.length - 1],
-      losses: losses,
-      nSupportVectors: this.supportVectors.length,
-      supportVectorRatio: this.supportVectors.length / nSamples
-    };
-
-    return this;
-  }
-
-  calculateVariance(X) {
-    const n = X.length;
-    const m = X[0].length;
-    let totalVariance = 0;
-
-    for (let j = 0; j < m; j++) {
-      const column = X.map(row => row[j]);
-      const mean = column.reduce((sum, val) => sum + val, 0) / n;
-      const variance = column.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / n;
-      totalVariance += variance;
-    }
-
-    return totalVariance / m;
-  }
-
-  identifySupportVectors(X, y) {
-    this.supportVectors = [];
-
-    for (let i = 0; i < X.length; i++) {
-      const prediction = this.decisionFunction([X[i]])[0];
-      const margin = Math.abs(prediction);
-
-      // Support vectors are points close to the decision boundary
-      if (margin < 1.5) {
-        this.supportVectors.push({
-          index: i,
-          vector: X[i],
-          label: y[i],
-          margin: margin
-        });
-      }
-    }
-  }
-
-  kernelFunction(x1, x2) {
-    if (this.kernel === 'linear') {
-      return x1.reduce((sum, val, i) => sum + val * x2[i], 0);
-    } else if (this.kernel === 'rbf') {
-      const squaredDistance = x1.reduce((sum, val, i) =>
-        sum + Math.pow(val - x2[i], 2), 0);
-      return Math.exp(-this.gamma * squaredDistance);
-    } else if (this.kernel === 'poly') {
-      const dotProduct = x1.reduce((sum, val, i) => sum + val * x2[i], 0);
-      return Math.pow(dotProduct + 1, this.degree);
-    }
-
-    return 0;
-  }
-
-  decisionFunction(X) {
-    return X.map(x => {
-      let score = this.bias;
-      for (let j = 0; j < this.weights.length; j++) {
-        score += this.weights[j] * x[j];
-      }
-      return score;
-    });
-  }
-
-  predict(X) {
-    this.validatePredictionData(X);
-
-    let X_test = X.map(row => Array.isArray(row) ? row : [row]);
-
-    if (this.normParams) {
-      const { means, stds } = this.normParams;
-      X_test = X_test.map(row =>
-        row.map((val, j) => (val - means[j]) / stds[j])
-      );
-    }
-
-    const decisions = this.decisionFunction(X_test);
-    return decisions.map(score => score >= 0 ? this.classes[1] : this.classes[0]);
-  }
-
-  predictProba(X) {
-    this.validatePredictionData(X);
-
-    let X_test = X.map(row => Array.isArray(row) ? row : [row]);
-
-    if (this.normParams) {
-      const { means, stds } = this.normParams;
-      X_test = X_test.map(row =>
-        row.map((val, j) => (val - means[j]) / stds[j])
-      );
-    }
-
-    const decisions = this.decisionFunction(X_test);
-
-    // Use sigmoid function to convert decision scores to probabilities
-    return decisions.map(score => {
-      const prob1 = 1 / (1 + Math.exp(-score));
-      return {
-        [this.classes[0]]: 1 - prob1,
-        [this.classes[1]]: prob1
-      };
-    });
-  }
-
-  score(X, y) {
-    const predictions = this.predict(X);
-
-    let correct = 0;
-    for (let i = 0; i < y.length; i++) {
-      if (predictions[i] === y[i]) correct++;
-    }
-    const accuracy = correct / y.length;
-
-    const cm = this.confusionMatrix(y, predictions);
-    const metrics = this.calculateClassMetrics(cm);
-
-    return {
-      accuracy: accuracy,
-      confusionMatrix: cm,
-      classMetrics: metrics,
-      predictions: predictions
-    };
-  }
-
-  confusionMatrix(yTrue, yPred) {
-    const n = this.classes.length;
-    const matrix = Array(n).fill(0).map(() => Array(n).fill(0));
-
-    for (let i = 0; i < yTrue.length; i++) {
-      const trueIdx = this.classes.indexOf(yTrue[i]);
-      const predIdx = this.classes.indexOf(yPred[i]);
-      matrix[trueIdx][predIdx]++;
-    }
-
-    return {
-      matrix: matrix,
-      classes: this.classes,
-      display: this.formatConfusionMatrix(matrix)
-    };
-  }
-
-  formatConfusionMatrix(matrix) {
-    const maxLen = Math.max(...matrix.flat().map(v => v.toString().length), 8);
-    const pad = (str) => str.toString().padStart(maxLen);
-
-    let output = '\n' + ' '.repeat(maxLen + 2) + 'Predicted\n';
-    output += ' '.repeat(maxLen + 2) + this.classes.map(c => pad(c)).join(' ') + '\n';
-
-    for (let i = 0; i < matrix.length; i++) {
-      if (i === 0) output += 'Actual ';
-      else output += '       ';
-      output += pad(this.classes[i]) + ' ';
-      output += matrix[i].map(v => pad(v)).join(' ') + '\n';
-    }
-
-    return output;
-  }
-
-  calculateClassMetrics(cm) {
-    const matrix = cm.matrix;
-    const metrics = {};
-
-    this.classes.forEach((cls, i) => {
-      const tp = matrix[i][i];
-      const fn = matrix[i].reduce((sum, val) => sum + val, 0) - tp;
-      const fp = matrix.map(row => row[i]).reduce((sum, val) => sum + val, 0) - tp;
-
-      const precision = tp + fp > 0 ? tp / (tp + fp) : 0;
-      const recall = tp + fn > 0 ? tp / (tp + fn) : 0;
-      const f1 = precision + recall > 0 ? 2 * (precision * recall) / (precision + recall) : 0;
-
-      metrics[cls] = {
-        precision: precision,
-        recall: recall,
-        f1Score: f1,
-        support: tp + fn
-      };
-    });
-
-    return metrics;
-  }
-
-  summary() {
-    if (!this.trained) {
-      throw new Error('Model must be trained first');
-    }
-
-    return {
-      modelType: 'Support Vector Machine',
-      classes: this.classes,
-      trainingMetrics: this.trainingMetrics,
-      hyperparameters: {
-        C: this.C,
-        kernel: this.kernel,
-        gamma: this.gamma,
-        degree: this.degree,
-        learningRate: this.learningRate,
-        iterations: this.iterations
-      }
-    };
-  }
-}
-
-export default SupportVectorMachine;

package/src/ml/baseModel.js

@@ -1,106 +0,0 @@
-class BaseModel {
-  constructor() {
-    this.trained = false;
-    this.model = null;
-    this.features = null;
-    this.target = null;
-    this.trainingMetrics = {};
-  }
-
-  validateTrainingData(X, y) {
-    if (!Array.isArray(X) || X.length === 0) {
-      throw new Error('X must be a non-empty array');
-    }
-    if (!Array.isArray(y) || y.length === 0) {
-      throw new Error('y must be a non-empty array');
-    }
-    if (X.length !== y.length) {
-      throw new Error('X and y must have the same length');
-    }
-  }
-
-  validatePredictionData(X) {
-    if (!this.trained) {
-      throw new Error('Model must be trained before making predictions');
-    }
-    if (!Array.isArray(X) || X.length === 0) {
-      throw new Error('X must be a non-empty array');
-    }
-  }
-
-  normalizeFeatures(X) {
-    const n = X.length;
-    const m = X[0].length;
-    const normalized = [];
-    const means = [];
-    const stds = [];
-
-    for (let j = 0; j < m; j++) {
-      const column = X.map(row => row[j]);
-      const mean = column.reduce((sum, val) => sum + val, 0) / n;
-      const variance = column.reduce((sum, val) => sum + Math.pow(val - mean, 2), 0) / n;
-      const std = Math.sqrt(variance);
-
-      means.push(mean);
-      stds.push(std === 0 ? 1 : std);
-    }
-
-    for (let i = 0; i < n; i++) {
-      const row = [];
-      for (let j = 0; j < m; j++) {
-        row.push((X[i][j] - means[j]) / stds[j]);
-      }
-      normalized.push(row);
-    }
-
-    return { normalized, means, stds };
-  }
-
-  splitTrainTest(X, y, testSize = 0.2, shuffle = true) {
-    const n = X.length;
-    const indices = Array.from({ length: n }, (_, i) => i);
-
-    if (shuffle) {
-      for (let i = n - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-        [indices[i], indices[j]] = [indices[j], indices[i]];
-      }
-    }
-
-    const testCount = Math.floor(n * testSize);
-    const trainCount = n - testCount;
-
-    const trainIndices = indices.slice(0, trainCount);
-    const testIndices = indices.slice(trainCount);
-
-    return {
-      X_train: trainIndices.map(i => X[i]),
-      X_test: testIndices.map(i => X[i]),
-      y_train: trainIndices.map(i => y[i]),
-      y_test: testIndices.map(i => y[i])
-    };
-  }
-
-  save() {
-    if (!this.trained) {
-      throw new Error('Cannot save untrained model');
-    }
-    return {
-      model: this.model,
-      features: this.features,
-      target: this.target,
-      trainingMetrics: this.trainingMetrics,
-      timestamp: new Date().toISOString()
-    };
-  }
-
-  load(modelData) {
-    this.model = modelData.model;
-    this.features = modelData.features;
-    this.target = modelData.target;
-    this.trainingMetrics = modelData.trainingMetrics;
-    this.trained = true;
-  }
-}
-
-export default BaseModel;