RandomizedSearchCV

class RandomizedSearchCV<TEstimator extends CrossValEstimator> {
  constructor(
    estimatorFactory: (params: Record<string, unknown>) => TEstimator,
    paramDistributions: ParamDistributions,
    options?: RandomizedSearchCVOptions
  )

  fit(X: Matrix, y: Vector, sampleWeight?: Vector): this
  predict(X: Matrix): Vector
  score(X: Matrix, y: Vector): number

  bestEstimator_: TEstimator | null
  bestParams_: Record<string, unknown> | null
  bestScore_: number | null
  cvResults_: RandomizedSearchResultRow[]
}

fit(X: Matrix, y: Vector, sampleWeight?: Vector): this

predict(X: Matrix): Vector

score(X: Matrix, y: Vector): number

import { RandomizedSearchCV } from 'bun-scikit';
import { LinearRegression } from 'bun-scikit';

const X = [
  [1, 1], [1, 2], [2, 2], [2, 3],
  [3, 1], [3, 2], [4, 2], [4, 3]
];
const y = [3, 4, 5, 6, 5, 6, 7, 8];

// Define parameter distributions
const paramDistributions = {
  fitIntercept: [true, false],
  normalize: [true, false]
};

// Sample 10 random combinations
const randomSearch = new RandomizedSearchCV(
  (params) => new LinearRegression(params),
  paramDistributions,
  { 
    nIter: 10,
    cv: 5,
    scoring: 'r2',
    randomState: 42
  }
);

// Fit on data
randomSearch.fit(X, y);

// View results
console.log('Best parameters:', randomSearch.bestParams_);
console.log('Best R² score:', randomSearch.bestScore_);

// Use best model for prediction
const predictions = randomSearch.predict([[2.5, 2.5]]);
console.log('Prediction:', predictions);

import { RandomizedSearchCV } from 'bun-scikit';
import { LogisticRegression } from 'bun-scikit';

const X = [
  [1, 2], [2, 3], [3, 4], [4, 5],
  [5, 6], [6, 7], [7, 8], [8, 9]
];
const y = [0, 0, 0, 0, 1, 1, 1, 1];

// Large parameter space
const paramDistributions = {
  learningRate: [0.001, 0.003, 0.01, 0.03, 0.1, 0.3, 1.0],
  maxIterations: [50, 100, 200, 500, 1000, 2000],
  regularization: [0, 0.001, 0.01, 0.1, 1.0, 10.0],
  solver: ['sgd', 'newton', 'lbfgs']
};
// Total combinations: 7 × 6 × 6 × 3 = 756
// Testing all would be expensive!

// Sample only 50 combinations
const randomSearch = new RandomizedSearchCV(
  (params) => new LogisticRegression(params),
  paramDistributions,
  {
    nIter: 50,  // Much faster than 756 evaluations
    cv: 4,
    scoring: 'accuracy',
    randomState: 123
  }
);

randomSearch.fit(X, y);

console.log('Tested 50 combinations out of 756 possible');
console.log('Best accuracy:', randomSearch.bestScore_);
console.log('Best hyperparameters:', randomSearch.bestParams_);

import { GridSearchCV, RandomizedSearchCV } from 'bun-scikit';
import { LinearRegression } from 'bun-scikit';

const X = [[1], [2], [3], [4], [5]];
const y = [1, 2, 3, 4, 5];

const paramGrid = {
  alpha: [0.001, 0.01, 0.1, 1, 10],
  beta: [0.1, 0.5, 1.0, 2.0, 5.0]
};
// 5 × 5 = 25 total combinations

// GridSearch: Tests ALL 25 combinations
const gridSearch = new GridSearchCV(
  (params) => new LinearRegression(params),
  paramGrid,
  { cv: 3 }
);
gridSearch.fit(X, y);
console.log('GridSearch tested:', gridSearch.cvResults_.length, 'combinations');

// RandomizedSearch: Tests only 10 combinations
const randomSearch = new RandomizedSearchCV(
  (params) => new LinearRegression(params),
  paramGrid,
  { nIter: 10, cv: 3, randomState: 42 }
);
randomSearch.fit(X, y);
console.log('RandomizedSearch tested:', randomSearch.cvResults_.length, 'combinations');

// Often finds similar performance with less computation
console.log('Grid best score:', gridSearch.bestScore_);
console.log('Random best score:', randomSearch.bestScore_);

import { RandomizedSearchCV } from 'bun-scikit';

const paramDistributions = {
  alpha: [0.1, 0.5, 1.0, 2.0, 5.0],
  beta: [0.01, 0.1, 1.0, 10.0]
};

// Same randomState = same parameter combinations
const search1 = new RandomizedSearchCV(
  (params) => new LinearRegression(params),
  paramDistributions,
  { nIter: 5, randomState: 42 }
);

const search2 = new RandomizedSearchCV(
  (params) => new LinearRegression(params),
  paramDistributions,
  { nIter: 5, randomState: 42 }
);

search1.fit(X, y);
search2.fit(X, y);

// Will sample the same 5 combinations
console.log('Same parameters tested:', 
  JSON.stringify(search1.bestParams_) === JSON.stringify(search2.bestParams_)
);

import { RandomizedSearchCV } from 'bun-scikit';

// After fitting...
const results = randomSearch.cvResults_;

console.log(`Sampled ${results.length} combinations:\n`);

for (const result of results) {
  console.log('Parameters:', result.params);
  console.log('Mean score:', result.meanTestScore.toFixed(4));
  console.log('Rank:', result.rank);
  console.log('---');
}

// Get top 3 parameter combinations
const top3 = results
  .sort((a, b) => a.rank - b.rank)
  .slice(0, 3);

console.log('\nTop 3 combinations:');
top3.forEach(r => console.log(r.params, '→', r.meanTestScore));