deepbox 0.1.0

package/dist/chunk-XEG44RF6.cjs

@@ -0,0 +1,1514 @@
+'use strict';
+
+var chunk6AE5FKKQ_cjs = require('./chunk-6AE5FKKQ.cjs');
+var chunkJSCDE774_cjs = require('./chunk-JSCDE774.cjs');
+
+// src/datasets/index.ts
+var datasets_exports = {};
+chunkJSCDE774_cjs.__export(datasets_exports, {
+  DataLoader: () => DataLoader,
+  loadBreastCancer: () => loadBreastCancer,
+  loadConcentricRings: () => loadConcentricRings,
+  loadCropYield: () => loadCropYield,
+  loadCustomerSegments: () => loadCustomerSegments,
+  loadDiabetes: () => loadDiabetes,
+  loadDigits: () => loadDigits,
+  loadEnergyEfficiency: () => loadEnergyEfficiency,
+  loadFitnessScores: () => loadFitnessScores,
+  loadFlowersExtended: () => loadFlowersExtended,
+  loadFruitQuality: () => loadFruitQuality,
+  loadGaussianIslands: () => loadGaussianIslands,
+  loadHousingMini: () => loadHousingMini,
+  loadIris: () => loadIris,
+  loadLeafShapes: () => loadLeafShapes,
+  loadLinnerud: () => loadLinnerud,
+  loadMoonsMulti: () => loadMoonsMulti,
+  loadPerfectlySeparable: () => loadPerfectlySeparable,
+  loadPlantGrowth: () => loadPlantGrowth,
+  loadSeedMorphology: () => loadSeedMorphology,
+  loadSensorStates: () => loadSensorStates,
+  loadSpiralArms: () => loadSpiralArms,
+  loadStudentPerformance: () => loadStudentPerformance,
+  loadTrafficConditions: () => loadTrafficConditions,
+  loadWeatherOutcomes: () => loadWeatherOutcomes,
+  makeBlobs: () => makeBlobs,
+  makeCircles: () => makeCircles,
+  makeClassification: () => makeClassification,
+  makeGaussianQuantiles: () => makeGaussianQuantiles,
+  makeMoons: () => makeMoons,
+  makeRegression: () => makeRegression
+});
+
+// src/datasets/utils.ts
+function assertPositiveInt(name, value) {
+  if (!Number.isInteger(value) || value <= 0 || !Number.isSafeInteger(value)) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `${name} must be a positive safe integer; received ${value}`,
+      name,
+      value
+    );
+  }
+}
+function assertBoolean(name, value) {
+  if (typeof value !== "boolean") {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `${name} must be a boolean; received ${String(value)}`,
+      name,
+      value
+    );
+  }
+}
+function normalizeOptionalSeed(name, value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `${name} must be a finite safe integer; received ${value}`,
+      name,
+      value
+    );
+  }
+  return value;
+}
+function createRng(seed) {
+  if (seed === void 0) return () => Math.random();
+  let state = (seed ^ 2654435769) >>> 0;
+  return () => {
+    state = state * 1664525 + 1013904223 >>> 0;
+    return state / 2 ** 32;
+  };
+}
+function normal01(rng) {
+  const u1 = Math.max(rng(), Number.EPSILON);
+  const u2 = rng();
+  return Math.sqrt(-2 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
+}
+function shuffleInPlace(array, rng) {
+  if (array.length <= 1) return;
+  for (let i = array.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    const tmp = array[i];
+    const swap = array[j];
+    if (tmp === void 0 || swap === void 0) {
+      throw new chunkJSCDE774_cjs.DeepboxError(
+        `Internal error: shuffle index out of bounds (i=${i}, j=${j}, len=${array.length})`
+      );
+    }
+    array[i] = swap;
+    array[j] = tmp;
+  }
+}
+function shufflePairedInPlace(left, right, rng) {
+  if (left.length !== right.length) {
+    throw new chunkJSCDE774_cjs.DeepboxError(
+      `Internal error: array length mismatch during shuffle (${left.length} vs ${right.length})`
+    );
+  }
+  if (left.length <= 1) return;
+  for (let i = left.length - 1; i > 0; i--) {
+    const j = Math.floor(rng() * (i + 1));
+    const leftTmp = left[i];
+    const leftSwap = left[j];
+    if (leftTmp === void 0 || leftSwap === void 0) {
+      throw new chunkJSCDE774_cjs.DeepboxError(
+        `Internal error: shuffle index out of bounds (i=${i}, j=${j}, len=${left.length})`
+      );
+    }
+    left[i] = leftSwap;
+    left[j] = leftTmp;
+    const rightTmp = right[i];
+    const rightSwap = right[j];
+    if (rightTmp === void 0 || rightSwap === void 0) {
+      throw new chunkJSCDE774_cjs.DeepboxError(
+        `Internal error: shuffle index out of bounds (i=${i}, j=${j}, len=${right.length})`
+      );
+    }
+    right[i] = rightSwap;
+    right[j] = rightTmp;
+  }
+}
+
+// src/datasets/DataLoader.ts
+var DataLoader = class {
+  X;
+  y;
+  batchSize;
+  shuffle;
+  dropLast;
+  indices;
+  seed;
+  nSamples;
+  constructor(X, yOrOptions, options) {
+    this.X = X;
+    let rawOpts;
+    if (yOrOptions instanceof chunk6AE5FKKQ_cjs.Tensor) {
+      this.y = yOrOptions;
+      rawOpts = options;
+    } else {
+      this.y = void 0;
+      rawOpts = yOrOptions === void 0 ? options : yOrOptions;
+    }
+    if (rawOpts !== void 0) {
+      if (rawOpts === null || typeof rawOpts !== "object" || Array.isArray(rawOpts)) {
+        throw new chunkJSCDE774_cjs.InvalidParameterError(
+          "options must be an object when provided",
+          "options",
+          rawOpts
+        );
+      }
+    }
+    const opts = rawOpts ?? {};
+    this.batchSize = opts.batchSize ?? 1;
+    this.shuffle = opts.shuffle ?? false;
+    this.dropLast = opts.dropLast ?? false;
+    this.seed = normalizeOptionalSeed("seed", opts.seed);
+    assertPositiveInt("batchSize", this.batchSize);
+    if (opts.shuffle !== void 0) assertBoolean("shuffle", this.shuffle);
+    if (opts.dropLast !== void 0) assertBoolean("dropLast", this.dropLast);
+    if (this.X.ndim === 0) {
+      throw new chunkJSCDE774_cjs.InvalidParameterError("X must have at least 1 dimension (samples axis)", "X");
+    }
+    const nSamples = this.X.shape[0];
+    if (nSamples === void 0 || nSamples === 0) {
+      throw new chunkJSCDE774_cjs.InvalidParameterError("X must have at least 1 sample", "X", nSamples);
+    }
+    const y = this.y;
+    if (y !== void 0) {
+      if (y.ndim === 0) {
+        throw new chunkJSCDE774_cjs.InvalidParameterError("y must have at least 1 dimension (samples axis)", "y");
+      }
+      const ySamples = y.shape[0];
+      if (ySamples !== nSamples) {
+        throw new chunkJSCDE774_cjs.InvalidParameterError(
+          `X and y must have the same number of samples; X has ${nSamples}, y has ${ySamples}`,
+          "y",
+          ySamples
+        );
+      }
+    }
+    this.nSamples = nSamples;
+    this.indices = Array.from({ length: nSamples }, (_, i) => i);
+  }
+  /**
+   * Number of batches in the data loader.
+   */
+  get length() {
+    return this.dropLast ? Math.floor(this.nSamples / this.batchSize) : Math.ceil(this.nSamples / this.batchSize);
+  }
+  [Symbol.iterator]() {
+    return this.y === void 0 ? this.iterateX() : this.iterateXY();
+  }
+  prepareIteration() {
+    const indices = [...this.indices];
+    if (this.shuffle) {
+      const rng = createRng(this.seed);
+      shuffleInPlace(indices, rng);
+    }
+    const nBatches = this.dropLast ? Math.floor(this.nSamples / this.batchSize) : Math.ceil(this.nSamples / this.batchSize);
+    return { indices, nBatches };
+  }
+  *iterateX() {
+    const { indices, nBatches } = this.prepareIteration();
+    for (let i = 0; i < nBatches; i++) {
+      const start = i * this.batchSize;
+      const end = Math.min(start + this.batchSize, this.nSamples);
+      const batchIndices = indices.slice(start, end);
+      const indexTensor = chunk6AE5FKKQ_cjs.tensor(batchIndices, { dtype: "int32" });
+      const xBatch = chunk6AE5FKKQ_cjs.gather(this.X, indexTensor, 0);
+      yield [xBatch];
+    }
+  }
+  *iterateXY() {
+    const { indices, nBatches } = this.prepareIteration();
+    const y = this.y;
+    if (y === void 0) {
+      throw new chunkJSCDE774_cjs.InvalidParameterError("Internal error: expected y to be defined", "y");
+    }
+    for (let i = 0; i < nBatches; i++) {
+      const start = i * this.batchSize;
+      const end = Math.min(start + this.batchSize, this.nSamples);
+      const batchIndices = indices.slice(start, end);
+      const indexTensor = chunk6AE5FKKQ_cjs.tensor(batchIndices, { dtype: "int32" });
+      const xBatch = chunk6AE5FKKQ_cjs.gather(this.X, indexTensor, 0);
+      const yBatch = chunk6AE5FKKQ_cjs.gather(y, indexTensor, 0);
+      yield [xBatch, yBatch];
+    }
+  }
+};
+
+// src/datasets/generators.ts
+function readAt(arr, index, label) {
+  if (!Number.isInteger(index) || index < 0 || index >= arr.length) {
+    throw new chunkJSCDE774_cjs.DeepboxError(`Internal error: ${label}[${index}] is out of bounds`);
+  }
+  const v = arr[index];
+  if (v === void 0) {
+    throw new chunkJSCDE774_cjs.DeepboxError(`Internal error: ${label}[${index}] is undefined`);
+  }
+  return v;
+}
+function readFiniteNumber(arr, index, label) {
+  const v = readAt(arr, index, label);
+  if (!Number.isFinite(v)) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError("Center coordinates must be finite", "centers", v);
+  }
+  return v;
+}
+function getRequired(arr, index, label) {
+  const v = arr[index];
+  if (v === void 0) {
+    throw new chunkJSCDE774_cjs.DeepboxError(`Internal error: ${label}[${index}] is undefined`);
+  }
+  return v;
+}
+function makeClassification(options = {}) {
+  const nSamples = options.nSamples ?? 100;
+  const nFeatures = options.nFeatures ?? 20;
+  const nInformative = options.nInformative ?? 2;
+  const nRedundant = options.nRedundant ?? 2;
+  const nClasses = options.nClasses ?? 2;
+  assertPositiveInt("nSamples", nSamples);
+  assertPositiveInt("nFeatures", nFeatures);
+  assertPositiveInt("nInformative", nInformative);
+  assertPositiveInt("nClasses", nClasses);
+  if (!Number.isInteger(nRedundant) || nRedundant < 0 || !Number.isSafeInteger(nRedundant)) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `nRedundant must be a non-negative safe integer; received ${nRedundant}`,
+      "nRedundant",
+      nRedundant
+    );
+  }
+  if (nInformative > nFeatures) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `nInformative (${nInformative}) cannot exceed nFeatures (${nFeatures})`,
+      "nInformative",
+      nInformative
+    );
+  }
+  if (nInformative + nRedundant > nFeatures) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `nInformative + nRedundant (${nInformative + nRedundant}) cannot exceed nFeatures (${nFeatures})`,
+      "nRedundant",
+      nRedundant
+    );
+  }
+  const seed = normalizeOptionalSeed("randomState", options.randomState);
+  const rng = createRng(seed);
+  const classMeans = Array.from({ length: nClasses }, () => new Float64Array(nInformative));
+  for (let c = 0; c < nClasses; c++) {
+    const meanVec = getRequired(classMeans, c, "classMeans");
+    for (let k = 0; k < nInformative; k++) {
+      meanVec[k] = (rng() - 0.5) * 2 * nClasses;
+    }
+  }
+  const weights = Array.from({ length: nRedundant }, () => new Float64Array(nInformative));
+  for (let j = 0; j < nRedundant; j++) {
+    const w = getRequired(weights, j, "weights");
+    for (let k = 0; k < nInformative; k++) {
+      w[k] = rng() - 0.5;
+    }
+  }
+  const XData = new Array(nSamples);
+  const yData = new Array(nSamples);
+  const nNoise = nFeatures - nInformative - nRedundant;
+  for (let i = 0; i < nSamples; i++) {
+    const label = Math.floor(rng() * nClasses);
+    yData[i] = label;
+    const meanVec = getRequired(classMeans, label, "classMeans");
+    const row = [];
+    const informative = new Float64Array(nInformative);
+    for (let k = 0; k < nInformative; k++) {
+      const mean = readAt(meanVec, k, "meanVec");
+      const v = mean + normal01(rng);
+      informative[k] = v;
+      row.push(v);
+    }
+    for (let j = 0; j < nRedundant; j++) {
+      const w = getRequired(weights, j, "weights");
+      let val = 0;
+      for (let k = 0; k < nInformative; k++) {
+        val += readAt(informative, k, "informative") * readAt(w, k, "weights");
+      }
+      row.push(val + normal01(rng) * 0.01);
+    }
+    for (let j = 0; j < nNoise; j++) {
+      row.push(normal01(rng));
+    }
+    XData[i] = row;
+  }
+  return [chunk6AE5FKKQ_cjs.tensor(XData), chunk6AE5FKKQ_cjs.tensor(yData, { dtype: "int32" })];
+}
+function makeRegression(options = {}) {
+  const nSamples = options.nSamples ?? 100;
+  const nFeatures = options.nFeatures ?? 100;
+  const noiseStd = options.noise ?? 0;
+  assertPositiveInt("nSamples", nSamples);
+  assertPositiveInt("nFeatures", nFeatures);
+  if (!Number.isFinite(noiseStd) || noiseStd < 0) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `noise must be a non-negative finite number; received ${noiseStd}`,
+      "noise",
+      noiseStd
+    );
+  }
+  const seed = normalizeOptionalSeed("randomState", options.randomState);
+  const rng = createRng(seed);
+  const weights = new Float64Array(nFeatures);
+  for (let j = 0; j < nFeatures; j++) {
+    weights[j] = normal01(rng);
+  }
+  const XData = new Array(nSamples);
+  const yData = new Array(nSamples);
+  for (let i = 0; i < nSamples; i++) {
+    const row = new Array(nFeatures);
+    let val = 0;
+    for (let j = 0; j < nFeatures; j++) {
+      const x = normal01(rng);
+      row[j] = x;
+      val += x * readAt(weights, j, "weights");
+    }
+    if (noiseStd > 0) val += normal01(rng) * noiseStd;
+    XData[i] = row;
+    yData[i] = val;
+  }
+  return [chunk6AE5FKKQ_cjs.tensor(XData), chunk6AE5FKKQ_cjs.tensor(yData)];
+}
+function makeBlobs(options = {}) {
+  const nSamples = options.nSamples ?? 100;
+  const clusterStd = options.clusterStd ?? 1;
+  const shuffle = options.shuffle ?? true;
+  assertPositiveInt("nSamples", nSamples);
+  if (!Number.isFinite(clusterStd) || clusterStd <= 0) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `clusterStd must be positive; received ${clusterStd}`,
+      "clusterStd",
+      clusterStd
+    );
+  }
+  assertBoolean("shuffle", shuffle);
+  const centersInput = options.centers === void 0 ? 3 : options.centers;
+  const seed = normalizeOptionalSeed("randomState", options.randomState);
+  const rng = createRng(seed);
+  let nFeatures;
+  let centerLocations;
+  if (typeof centersInput === "number") {
+    assertPositiveInt("centers", centersInput);
+    const nFeat = options.nFeatures ?? 2;
+    assertPositiveInt("nFeatures", nFeat);
+    nFeatures = nFeat;
+    centerLocations = Array.from({ length: centersInput }, () => {
+      const c = new Float64Array(nFeat);
+      for (let j = 0; j < nFeat; j++) c[j] = (rng() - 0.5) * 20;
+      return c;
+    });
+  } else if (Array.isArray(centersInput)) {
+    if (centersInput.length === 0) {
+      throw new chunkJSCDE774_cjs.InvalidParameterError("centers cannot be empty", "centers");
+    }
+    const firstCenter = centersInput[0];
+    if (!Array.isArray(firstCenter) || firstCenter.length === 0) {
+      throw new chunkJSCDE774_cjs.InvalidParameterError("centers must be a non-empty array of arrays", "centers");
+    }
+    nFeatures = options.nFeatures ?? firstCenter.length;
+    assertPositiveInt("nFeatures", nFeatures);
+    centerLocations = centersInput.map((c) => {
+      if (!Array.isArray(c) || c.length !== nFeatures) {
+        throw new chunkJSCDE774_cjs.InvalidParameterError(
+          `Center dimension mismatch. Expected ${nFeatures}; received ${Array.isArray(c) ? c.length : 0}`,
+          "centers",
+          c
+        );
+      }
+      const out = new Float64Array(nFeatures);
+      for (let j = 0; j < nFeatures; j++) {
+        out[j] = readFiniteNumber(c, j, "centers");
+      }
+      return out;
+    });
+  } else {
+    throw new chunkJSCDE774_cjs.InvalidParameterError("centers must be an int or an array of arrays", "centers");
+  }
+  const nCenters = centerLocations.length;
+  const base = Math.floor(nSamples / nCenters);
+  const remainder = nSamples % nCenters;
+  const XData = [];
+  const yData = [];
+  for (let c = 0; c < nCenters; c++) {
+    const nC = base + (c < remainder ? 1 : 0);
+    const center = getRequired(centerLocations, c, "centerLocations");
+    for (let i = 0; i < nC; i++) {
+      const row = new Array(nFeatures);
+      for (let j = 0; j < nFeatures; j++) {
+        row[j] = readAt(center, j, "center") + normal01(rng) * clusterStd;
+      }
+      XData.push(row);
+      yData.push(c);
+    }
+  }
+  if (shuffle) shufflePairedInPlace(XData, yData, rng);
+  return [chunk6AE5FKKQ_cjs.tensor(XData), chunk6AE5FKKQ_cjs.tensor(yData, { dtype: "int32" })];
+}
+function makeMoons(options = {}) {
+  const nSamples = options.nSamples ?? 100;
+  const noiseStd = options.noise ?? 0;
+  const shuffle = options.shuffle ?? true;
+  assertPositiveInt("nSamples", nSamples);
+  if (!Number.isFinite(noiseStd) || noiseStd < 0) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `noise must be a non-negative finite number; received ${noiseStd}`,
+      "noise",
+      noiseStd
+    );
+  }
+  assertBoolean("shuffle", shuffle);
+  const seed = normalizeOptionalSeed("randomState", options.randomState);
+  const rng = createRng(seed);
+  const samplesFirst = Math.ceil(nSamples / 2);
+  const samplesSecond = nSamples - samplesFirst;
+  const XData = [];
+  const yData = [];
+  for (let i = 0; i < samplesFirst; i++) {
+    const angle = Math.PI * (i / samplesFirst);
+    const x = Math.cos(angle) + normal01(rng) * noiseStd;
+    const y = Math.sin(angle) + normal01(rng) * noiseStd;
+    XData.push([x, y]);
+    yData.push(0);
+  }
+  for (let i = 0; i < samplesSecond; i++) {
+    const angle = Math.PI * (i / samplesSecond);
+    const x = 1 - Math.cos(angle) + normal01(rng) * noiseStd;
+    const y = 0.5 - Math.sin(angle) + normal01(rng) * noiseStd;
+    XData.push([x, y]);
+    yData.push(1);
+  }
+  if (shuffle) shufflePairedInPlace(XData, yData, rng);
+  return [chunk6AE5FKKQ_cjs.tensor(XData), chunk6AE5FKKQ_cjs.tensor(yData, { dtype: "int32" })];
+}
+function makeCircles(options = {}) {
+  const nSamples = options.nSamples ?? 100;
+  const noiseStd = options.noise ?? 0;
+  const factor = options.factor ?? 0.8;
+  const shuffle = options.shuffle ?? true;
+  assertPositiveInt("nSamples", nSamples);
+  if (!Number.isFinite(noiseStd) || noiseStd < 0) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `noise must be a non-negative finite number; received ${noiseStd}`,
+      "noise",
+      noiseStd
+    );
+  }
+  if (!Number.isFinite(factor) || factor <= 0 || factor >= 1) {
+    throw new chunkJSCDE774_cjs.InvalidParameterError(
+      `factor must be in (0, 1); received ${factor}`,
+      "factor",
+      factor
+    );
+  }
+  assertBoolean("shuffle", shuffle);
+  const seed = normalizeOptionalSeed("randomState", options.randomState);
+  const rng = createRng(seed);
+  const samplesOuter = Math.ceil(nSamples / 2);
+  const samplesInner = nSamples - samplesOuter;
+  const XData = [];
+  const yData = [];
+  for (let i = 0; i < samplesOuter; i++) {
+    const angle = 2 * Math.PI * (i / samplesOuter);
+    const x = Math.cos(angle) + normal01(rng) * noiseStd;
+    const y = Math.sin(angle) + normal01(rng) * noiseStd;
+    XData.push([x, y]);
+    yData.push(0);
+  }
+  for (let i = 0; i < samplesInner; i++) {
+    const angle = 2 * Math.PI * (i / samplesInner);
+    const x = factor * Math.cos(angle) + normal01(rng) * noiseStd;
+    const y = factor * Math.sin(angle) + normal01(rng) * noiseStd;
+    XData.push([x, y]);
+    yData.push(1);
+  }
+  if (shuffle) shufflePairedInPlace(XData, yData, rng);
+  return [chunk6AE5FKKQ_cjs.tensor(XData), chunk6AE5FKKQ_cjs.tensor(yData, { dtype: "int32" })];
+}
+function makeGaussianQuantiles(options = {}) {
+  const nSamples = options.nSamples ?? 100;
+  const nFeatures = options.nFeatures ?? 2;
+  const nClasses = options.nClasses ?? 3;
+  assertPositiveInt("nSamples", nSamples);
+  assertPositiveInt("nFeatures", nFeatures);
+  assertPositiveInt("nClasses", nClasses);
+  const seed = normalizeOptionalSeed("randomState", options.randomState);
+  const rng = createRng(seed);
+  const XData = new Array(nSamples);
+  const distances = new Array(nSamples);
+  for (let i = 0; i < nSamples; i++) {
+    const row = new Array(nFeatures);
+    let distSq = 0;
+    for (let j = 0; j < nFeatures; j++) {
+      const v = normal01(rng);
+      row[j] = v;
+      distSq += v * v;
+    }
+    XData[i] = row;
+    distances[i] = Math.sqrt(distSq);
+  }
+  const sortedDistances = [...distances].sort((a, b) => a - b);
+  const quantileBoundaries = [];
+  for (let c = 1; c < nClasses; c++) {
+    const idx = Math.floor(c * nSamples / nClasses);
+    quantileBoundaries.push(getRequired(sortedDistances, idx, "sortedDistances"));
+  }
+  const yData = new Array(nSamples);
+  for (let i = 0; i < nSamples; i++) {
+    const dist = getRequired(distances, i, "distances");
+    let label = 0;
+    for (const boundary of quantileBoundaries) {
+      if (dist > boundary) label++;
+      else break;
+    }
+    yData[i] = label;
+  }
+  return [chunk6AE5FKKQ_cjs.tensor(XData), chunk6AE5FKKQ_cjs.tensor(yData, { dtype: "int32" })];
+}
+
+// src/datasets/loaders.ts
+var SYNTHETIC_NOTE = "Synthetic (deterministic) dataset inspired by a common ML benchmark. Values are generated, not the original reference dataset.";
+var __iris;
+function getIrisData() {
+  if (__iris !== void 0) return __iris;
+  const rng = createRng(1337);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 50; i++) {
+    data.push([5 + rng() * 0.8, 3.4 + rng() * 0.4, 1.4 + rng() * 0.3, 0.2 + rng() * 0.2]);
+    target.push(0);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([5.9 + rng() * 0.8, 2.8 + rng() * 0.4, 4.2 + rng() * 0.5, 1.3 + rng() * 0.3]);
+    target.push(1);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([6.5 + rng() * 0.8, 3 + rng() * 0.4, 5.5 + rng() * 0.5, 2 + rng() * 0.4]);
+    target.push(2);
+  }
+  __iris = { data, target };
+  return __iris;
+}
+function loadIris() {
+  const { data, target } = getIrisData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: [
+      "sepal length (cm)",
+      "sepal width (cm)",
+      "petal length (cm)",
+      "petal width (cm)"
+    ],
+    targetNames: ["setosa", "versicolor", "virginica"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 4 features, 3 classes.`
+  };
+}
+var __digits;
+function getDigitsData() {
+  if (__digits !== void 0) return __digits;
+  const rng = createRng(7);
+  const data = [];
+  const target = [];
+  for (let digit = 0; digit < 10; digit++) {
+    const samplesPerDigit = digit === 9 ? 177 : 180;
+    for (let i = 0; i < samplesPerDigit; i++) {
+      const sample = [];
+      for (let j = 0; j < 64; j++) {
+        sample.push(Math.floor(rng() * 16));
+      }
+      data.push(sample);
+      target.push(digit);
+    }
+  }
+  __digits = { data, target };
+  return __digits;
+}
+function loadDigits() {
+  const { data, target } = getDigitsData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: Array.from({ length: 64 }, (_, i) => `pixel_${i}`),
+    targetNames: ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9"],
+    description: `${SYNTHETIC_NOTE} 1797 samples, 64 features, 10 classes.`
+  };
+}
+var __breastCancer;
+function getBreastCancerData() {
+  if (__breastCancer !== void 0) return __breastCancer;
+  const rng = createRng(99);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 212; i++) {
+    const sample = [];
+    for (let j = 0; j < 30; j++) {
+      sample.push(15 + rng() * 10);
+    }
+    data.push(sample);
+    target.push(0);
+  }
+  for (let i = 0; i < 357; i++) {
+    const sample = [];
+    for (let j = 0; j < 30; j++) {
+      sample.push(10 + rng() * 8);
+    }
+    data.push(sample);
+    target.push(1);
+  }
+  __breastCancer = { data, target };
+  return __breastCancer;
+}
+function loadBreastCancer() {
+  const { data, target } = getBreastCancerData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: [
+      "mean radius",
+      "mean texture",
+      "mean perimeter",
+      "mean area",
+      "mean smoothness",
+      "mean compactness",
+      "mean concavity",
+      "mean concave points",
+      "mean symmetry",
+      "mean fractal dimension",
+      "radius error",
+      "texture error",
+      "perimeter error",
+      "area error",
+      "smoothness error",
+      "compactness error",
+      "concavity error",
+      "concave points error",
+      "symmetry error",
+      "fractal dimension error",
+      "worst radius",
+      "worst texture",
+      "worst perimeter",
+      "worst area",
+      "worst smoothness",
+      "worst compactness",
+      "worst concavity",
+      "worst concave points",
+      "worst symmetry",
+      "worst fractal dimension"
+    ],
+    targetNames: ["malignant", "benign"],
+    description: `${SYNTHETIC_NOTE} 569 samples, 30 features, 2 classes.`
+  };
+}
+var __diabetes;
+function getDiabetesData() {
+  if (__diabetes !== void 0) return __diabetes;
+  const rng = createRng(123);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 442; i++) {
+    const sample = [];
+    for (let j = 0; j < 10; j++) {
+      sample.push(-0.1 + rng() * 0.2);
+    }
+    data.push(sample);
+    target.push(50 + rng() * 300);
+  }
+  __diabetes = { data, target };
+  return __diabetes;
+}
+function loadDiabetes() {
+  const { data, target } = getDiabetesData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["age", "sex", "bmi", "bp", "s1", "s2", "s3", "s4", "s5", "s6"],
+    description: `${SYNTHETIC_NOTE} 442 samples, 10 features (regression).`
+  };
+}
+var __linnerud;
+function getLinnerudData() {
+  if (__linnerud !== void 0) return __linnerud;
+  const rng = createRng(555);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 20; i++) {
+    data.push([
+      5 + Math.floor(rng() * 15),
+      100 + Math.floor(rng() * 100),
+      50 + Math.floor(rng() * 200)
+    ]);
+    target.push([170 + rng() * 30, 60 + rng() * 20, 50 + rng() * 20]);
+  }
+  __linnerud = { data, target };
+  return __linnerud;
+}
+function loadLinnerud() {
+  const { data, target } = getLinnerudData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["Chins", "Situps", "Jumps"],
+    targetNames: ["Weight", "Waist", "Pulse"],
+    description: `${SYNTHETIC_NOTE} 20 samples, 3 exercise features, 3 physiological targets.`
+  };
+}
+var __flowersExtended;
+function getFlowersExtendedData() {
+  if (__flowersExtended !== void 0) return __flowersExtended;
+  const rng = createRng(3001);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 45; i++) {
+    data.push([
+      4.5 + rng() * 1,
+      3 + rng() * 0.8,
+      1 + rng() * 0.8,
+      0.1 + rng() * 0.4,
+      2 + rng() * 1.5,
+      1.5 + rng() * 1
+    ]);
+    target.push(0);
+  }
+  for (let i = 0; i < 45; i++) {
+    data.push([
+      5.5 + rng() * 1.5,
+      2.5 + rng() * 0.8,
+      3.5 + rng() * 1.5,
+      1 + rng() * 0.8,
+      4 + rng() * 2,
+      2.5 + rng() * 1
+    ]);
+    target.push(1);
+  }
+  for (let i = 0; i < 45; i++) {
+    data.push([
+      6 + rng() * 1.9,
+      2.8 + rng() * 0.8,
+      4.5 + rng() * 2,
+      1.5 + rng() * 1,
+      5 + rng() * 2,
+      3 + rng() * 1.5
+    ]);
+    target.push(2);
+  }
+  for (let i = 0; i < 45; i++) {
+    data.push([
+      5 + rng() * 1.5,
+      2.2 + rng() * 0.8,
+      2.5 + rng() * 1.5,
+      0.8 + rng() * 0.6,
+      6 + rng() * 2.5,
+      2 + rng() * 1
+    ]);
+    target.push(3);
+  }
+  __flowersExtended = { data, target };
+  return __flowersExtended;
+}
+function loadFlowersExtended() {
+  const { data, target } = getFlowersExtendedData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: [
+      "sepal length (cm)",
+      "sepal width (cm)",
+      "petal length (cm)",
+      "petal width (cm)",
+      "color intensity",
+      "stem thickness (mm)"
+    ],
+    targetNames: ["setosa", "versicolor", "virginica", "chrysantha"],
+    description: `${SYNTHETIC_NOTE} 180 samples, 6 features, 4 species.`
+  };
+}
+var __leafShapes;
+function getLeafShapesData() {
+  if (__leafShapes !== void 0) return __leafShapes;
+  const rng = createRng(3002);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 30; i++) {
+    data.push([
+      15 + rng() * 15,
+      25 + rng() * 20,
+      0.8 + rng() * 0.4,
+      0.3 + rng() * 0.3,
+      0.3 + rng() * 0.2,
+      0.5 + rng() * 0.3,
+      0.7 + rng() * 0.3,
+      0.6 + rng() * 0.2
+    ]);
+    target.push(0);
+  }
+  for (let i = 0; i < 30; i++) {
+    data.push([
+      20 + rng() * 20,
+      30 + rng() * 20,
+      1 + rng() * 0.5,
+      0.2 + rng() * 0.3,
+      0.4 + rng() * 0.2,
+      0.3 + rng() * 0.3,
+      0.8 + rng() * 0.4,
+      0.7 + rng() * 0.2
+    ]);
+    target.push(1);
+  }
+  for (let i = 0; i < 30; i++) {
+    data.push([
+      8 + rng() * 10,
+      15 + rng() * 15,
+      1.2 + rng() * 0.6,
+      0.1 + rng() * 0.2,
+      0.5 + rng() * 0.2,
+      0.1 + rng() * 0.2,
+      1 + rng() * 0.5,
+      0.8 + rng() * 0.15
+    ]);
+    target.push(2);
+  }
+  for (let i = 0; i < 30; i++) {
+    data.push([
+      5 + rng() * 7,
+      20 + rng() * 15,
+      3 + rng() * 2,
+      0.05 + rng() * 0.15,
+      0.2 + rng() * 0.2,
+      0.05 + rng() * 0.1,
+      2 + rng() * 1.5,
+      0.85 + rng() * 0.13
+    ]);
+    target.push(3);
+  }
+  for (let i = 0; i < 30; i++) {
+    data.push([
+      10 + rng() * 12,
+      18 + rng() * 14,
+      0.9 + rng() * 0.4,
+      0.15 + rng() * 0.2,
+      0.5 + rng() * 0.2,
+      0.15 + rng() * 0.2,
+      0.8 + rng() * 0.3,
+      0.75 + rng() * 0.15
+    ]);
+    target.push(4);
+  }
+  __leafShapes = { data, target };
+  return __leafShapes;
+}
+function loadLeafShapes() {
+  const { data, target } = getLeafShapesData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: [
+      "area (cm\xB2)",
+      "perimeter (cm)",
+      "aspect ratio",
+      "curvature",
+      "compactness",
+      "lobedness",
+      "elongation",
+      "solidity"
+    ],
+    targetNames: ["maple", "oak", "birch", "willow", "ginkgo"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 8 geometric features, 5 plant species.`
+  };
+}
+var __fruitQuality;
+function getFruitQualityData() {
+  if (__fruitQuality !== void 0) return __fruitQuality;
+  const rng = createRng(3003);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 50; i++) {
+    data.push([150 + rng() * 70, 11 + rng() * 3, 3.2 + rng() * 0.6, 6 + rng() * 3, 5 + rng() * 3]);
+    target.push(0);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([130 + rng() * 70, 9 + rng() * 3, 3 + rng() * 0.5, 3 + rng() * 3, 6 + rng() * 3]);
+    target.push(1);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([100 + rng() * 50, 14 + rng() * 6, 4.5 + rng() * 1, 1 + rng() * 3, 4 + rng() * 3]);
+    target.push(2);
+  }
+  __fruitQuality = { data, target };
+  return __fruitQuality;
+}
+function loadFruitQuality() {
+  const { data, target } = getFruitQualityData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: [
+      "weight (g)",
+      "sugar content (Brix)",
+      "acidity (pH)",
+      "firmness (N)",
+      "color score"
+    ],
+    targetNames: ["apple", "orange", "banana"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 5 features, 3 fruit classes.`
+  };
+}
+var __seedMorphology;
+function getSeedMorphologyData() {
+  if (__seedMorphology !== void 0) return __seedMorphology;
+  const rng = createRng(3005);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 50; i++) {
+    data.push([5.5 + rng() * 2, 2.8 + rng() * 1, 0.75 + rng() * 0.17, 1.3 + rng() * 0.2]);
+    target.push(0);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([6 + rng() * 3, 1.8 + rng() * 0.7, 0.3 + rng() * 0.2, 1.1 + rng() * 0.2]);
+    target.push(1);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([8 + rng() * 5, 4 + rng() * 3, 0.55 + rng() * 0.2, 0.9 + rng() * 0.2]);
+    target.push(2);
+  }
+  __seedMorphology = { data, target };
+  return __seedMorphology;
+}
+function loadSeedMorphology() {
+  const { data, target } = getSeedMorphologyData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["length (mm)", "width (mm)", "roundness", "density (g/cm\xB3)"],
+    targetNames: ["wheat", "rice", "sunflower"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 4 features, 3 seed types.`
+  };
+}
+var __moonsMulti;
+function getMoonsMultiData() {
+  if (__moonsMulti !== void 0) return __moonsMulti;
+  const rng = createRng(3006);
+  const data = [];
+  const target = [];
+  for (let c = 0; c < 3; c++) {
+    const rotation = c * 2 * Math.PI / 3;
+    const cosR = Math.cos(rotation);
+    const sinR = Math.sin(rotation);
+    for (let j = 0; j < 50; j++) {
+      const t = Math.PI * (j / 50);
+      const baseX = Math.cos(t);
+      const baseY = Math.sin(t);
+      const x = baseX * cosR - baseY * sinR;
+      const y = baseX * sinR + baseY * cosR;
+      data.push([x + normal01(rng) * 0.08, y + normal01(rng) * 0.08]);
+      target.push(c);
+    }
+  }
+  __moonsMulti = { data, target };
+  return __moonsMulti;
+}
+function loadMoonsMulti() {
+  const { data, target } = getMoonsMultiData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["x", "y"],
+    targetNames: ["moon_0", "moon_1", "moon_2"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 2D, 3 interleaving moon classes.`
+  };
+}
+var __concentricRings;
+function getConcentricRingsData() {
+  if (__concentricRings !== void 0) return __concentricRings;
+  const rng = createRng(3007);
+  const data = [];
+  const target = [];
+  for (let c = 0; c < 3; c++) {
+    const radius = 1 + c * 1.5;
+    for (let j = 0; j < 50; j++) {
+      const angle = 2 * Math.PI * (j / 50);
+      data.push([
+        radius * Math.cos(angle) + normal01(rng) * 0.15,
+        radius * Math.sin(angle) + normal01(rng) * 0.15
+      ]);
+      target.push(c);
+    }
+  }
+  __concentricRings = { data, target };
+  return __concentricRings;
+}
+function loadConcentricRings() {
+  const { data, target } = getConcentricRingsData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["x", "y"],
+    targetNames: ["inner", "middle", "outer"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 2D, 3 concentric circle classes.`
+  };
+}
+var __spiralArms;
+function getSpiralArmsData() {
+  if (__spiralArms !== void 0) return __spiralArms;
+  const rng = createRng(3008);
+  const data = [];
+  const target = [];
+  for (let c = 0; c < 3; c++) {
+    const offset = c * 2 * Math.PI / 3;
+    for (let j = 0; j < 50; j++) {
+      const t = j / 50 * 3 * Math.PI;
+      const r = 0.5 + t * 0.15;
+      const angle = t + offset;
+      data.push([
+        r * Math.cos(angle) + normal01(rng) * 0.1,
+        r * Math.sin(angle) + normal01(rng) * 0.1
+      ]);
+      target.push(c);
+    }
+  }
+  __spiralArms = { data, target };
+  return __spiralArms;
+}
+function loadSpiralArms() {
+  const { data, target } = getSpiralArmsData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["x", "y"],
+    targetNames: ["arm_0", "arm_1", "arm_2"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 2D, 3 spiral classes.`
+  };
+}
+var __gaussianIslands;
+function getGaussianIslandsData() {
+  if (__gaussianIslands !== void 0) return __gaussianIslands;
+  const rng = createRng(3009);
+  const data = [];
+  const target = [];
+  const centers = [
+    [3, 3, 3],
+    [-3, 3, -3],
+    [-3, -3, 3],
+    [3, -3, -3]
+  ];
+  let c = 0;
+  for (const center of centers) {
+    for (let i = 0; i < 50; i++) {
+      data.push([
+        center[0] + normal01(rng) * 0.8,
+        center[1] + normal01(rng) * 0.8,
+        center[2] + normal01(rng) * 0.8
+      ]);
+      target.push(c);
+    }
+    c++;
+  }
+  __gaussianIslands = { data, target };
+  return __gaussianIslands;
+}
+function loadGaussianIslands() {
+  const { data, target } = getGaussianIslandsData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["x", "y", "z"],
+    targetNames: ["island_0", "island_1", "island_2", "island_3"],
+    description: `${SYNTHETIC_NOTE} 200 samples, 3D, 4 separated Gaussian clusters.`
+  };
+}
+var __plantGrowth;
+function getPlantGrowthData() {
+  if (__plantGrowth !== void 0) return __plantGrowth;
+  const rng = createRng(3010);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 200; i++) {
+    const sunlight = 4 + rng() * 8;
+    const water = 100 + rng() * 400;
+    const soilQuality = rng() * 10;
+    data.push([sunlight, water, soilQuality]);
+    const height = 5 + 2.5 * sunlight + 0.02 * water + 3 * soilQuality + (rng() - 0.5) * 10;
+    target.push(height);
+  }
+  __plantGrowth = { data, target };
+  return __plantGrowth;
+}
+function loadPlantGrowth() {
+  const { data, target } = getPlantGrowthData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["sunlight (hours/day)", "water (mL/day)", "soil quality (0-10)"],
+    description: `${SYNTHETIC_NOTE} 200 samples, 3 features, target: height (cm) after 30 days.`
+  };
+}
+var __housingMini;
+function getHousingMiniData() {
+  if (__housingMini !== void 0) return __housingMini;
+  const rng = createRng(3011);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 200; i++) {
+    const size = 30 + rng() * 170;
+    const rooms = 1 + Math.floor(rng() * 6);
+    const age = rng() * 50;
+    const distance = 0.5 + rng() * 29.5;
+    data.push([size, rooms, age, distance]);
+    const price = 80 + 2 * size + 15 * rooms - 0.5 * age - 1.5 * distance + (rng() - 0.5) * 30;
+    target.push(price);
+  }
+  __housingMini = { data, target };
+  return __housingMini;
+}
+function loadHousingMini() {
+  const { data, target } = getHousingMiniData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["size (sqm)", "rooms", "age (years)", "distance to center (km)"],
+    description: `${SYNTHETIC_NOTE} 200 samples, 4 features, target: price (thousands).`
+  };
+}
+var __energyEfficiency;
+function getEnergyEfficiencyData() {
+  if (__energyEfficiency !== void 0) return __energyEfficiency;
+  const rng = createRng(3012);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 200; i++) {
+    const insulation = 1 + rng() * 7;
+    const windowArea = 5 + rng() * 25;
+    const orientation = rng() * 360;
+    data.push([insulation, windowArea, orientation]);
+    const orientationRad = orientation * (Math.PI / 180);
+    const energy = 250 - 20 * insulation + 4 * windowArea + 15 * Math.cos(orientationRad) + (rng() - 0.5) * 20;
+    target.push(energy);
+  }
+  __energyEfficiency = { data, target };
+  return __energyEfficiency;
+}
+function loadEnergyEfficiency() {
+  const { data, target } = getEnergyEfficiencyData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["insulation (R-value)", "window area (sqm)", "orientation (degrees)"],
+    description: `${SYNTHETIC_NOTE} 200 samples, 3 features, target: energy usage (kWh).`
+  };
+}
+var __cropYield;
+function getCropYieldData() {
+  if (__cropYield !== void 0) return __cropYield;
+  const rng = createRng(3013);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 200; i++) {
+    const rainfall = 200 + rng() * 600;
+    const fertilizer = 50 + rng() * 250;
+    const temperature = 15 + rng() * 20;
+    data.push([rainfall, fertilizer, temperature]);
+    const tempEffect = -0.015 * (temperature - 25) * (temperature - 25);
+    const yieldVal = 2 + 5e-3 * rainfall + 8e-3 * fertilizer + tempEffect + (rng() - 0.5) * 1;
+    target.push(yieldVal);
+  }
+  __cropYield = { data, target };
+  return __cropYield;
+}
+function loadCropYield() {
+  const { data, target } = getCropYieldData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["rainfall (mm)", "fertilizer (kg/ha)", "temperature (\xB0C)"],
+    description: `${SYNTHETIC_NOTE} 200 samples, 3 features, target: yield (tons/ha).`
+  };
+}
+var __customerSegments;
+function getCustomerSegmentsData() {
+  if (__customerSegments !== void 0) return __customerSegments;
+  const rng = createRng(3014);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 50; i++) {
+    data.push([25 + normal01(rng) * 3, 30 + normal01(rng) * 5, 70 + normal01(rng) * 8]);
+    target.push(0);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([30 + normal01(rng) * 4, 80 + normal01(rng) * 8, 85 + normal01(rng) * 6]);
+    target.push(1);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([55 + normal01(rng) * 5, 50 + normal01(rng) * 8, 40 + normal01(rng) * 8]);
+    target.push(2);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([60 + normal01(rng) * 4, 90 + normal01(rng) * 7, 30 + normal01(rng) * 7]);
+    target.push(3);
+  }
+  __customerSegments = { data, target };
+  return __customerSegments;
+}
+function loadCustomerSegments() {
+  const { data, target } = getCustomerSegmentsData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["age", "income (thousands)", "spending score (0-100)"],
+    targetNames: ["young_budget", "young_premium", "mature_moderate", "mature_saver"],
+    description: `${SYNTHETIC_NOTE} 200 samples, 3 features, 4 natural clusters.`
+  };
+}
+var __sensorStates;
+function getSensorStatesData() {
+  if (__sensorStates !== void 0) return __sensorStates;
+  const rng = createRng(3015);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 60; i++) {
+    data.push([
+      50 + rng() * 10,
+      1013 + rng() * 5,
+      60 + rng() * 10,
+      220 + rng() * 5,
+      3 + rng() * 0.5,
+      0.5 + rng() * 0.3
+    ]);
+    target.push(0);
+  }
+  for (let i = 0; i < 60; i++) {
+    data.push([
+      80 + rng() * 15,
+      1010 + rng() * 8,
+      40 + rng() * 15,
+      218 + rng() * 8,
+      5 + rng() * 1,
+      0.8 + rng() * 0.4
+    ]);
+    target.push(1);
+  }
+  for (let i = 0; i < 60; i++) {
+    data.push([
+      30 + rng() * 40,
+      1e3 + rng() * 20,
+      20 + rng() * 60,
+      200 + rng() * 30,
+      1 + rng() * 8,
+      0.2 + rng() * 1.5
+    ]);
+    target.push(2);
+  }
+  __sensorStates = { data, target };
+  return __sensorStates;
+}
+function loadSensorStates() {
+  const { data, target } = getSensorStatesData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: [
+      "temperature (\xB0C)",
+      "pressure (hPa)",
+      "humidity (%)",
+      "voltage (V)",
+      "vibration (mm/s)",
+      "current (A)"
+    ],
+    targetNames: ["normal", "heating", "fault"],
+    description: `${SYNTHETIC_NOTE} 180 samples, 6 sensor readings, 3 hidden operating modes.`
+  };
+}
+var __studentPerformance;
+function getStudentPerformanceData() {
+  if (__studentPerformance !== void 0) return __studentPerformance;
+  const rng = createRng(3016);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 50; i++) {
+    data.push([Math.floor(rng() * 6), 8 + Math.floor(rng() * 8), 20 + Math.floor(rng() * 30)]);
+    target.push(0);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([4 + Math.floor(rng() * 8), 3 + Math.floor(rng() * 6), 45 + Math.floor(rng() * 30)]);
+    target.push(1);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([10 + Math.floor(rng() * 11), Math.floor(rng() * 4), 70 + Math.floor(rng() * 31)]);
+    target.push(2);
+  }
+  __studentPerformance = { data, target };
+  return __studentPerformance;
+}
+function loadStudentPerformance() {
+  const { data, target } = getStudentPerformanceData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["study hours (per week)", "absences", "quiz score (0-100)"],
+    targetNames: ["fail", "pass", "excellent"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 3 integer features, 3 outcome classes.`
+  };
+}
+var __trafficConditions;
+function getTrafficConditionsData() {
+  if (__trafficConditions !== void 0) return __trafficConditions;
+  const rng = createRng(3017);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 50; i++) {
+    data.push([Math.floor(rng() * 10), 50 + Math.floor(rng() * 40), 5 + Math.floor(rng() * 20)]);
+    target.push(0);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([
+      8 + Math.floor(rng() * 8),
+      25 + Math.floor(rng() * 30),
+      20 + Math.floor(rng() * 30)
+    ]);
+    target.push(1);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([
+      15 + Math.floor(rng() * 8),
+      5 + Math.floor(rng() * 25),
+      45 + Math.floor(rng() * 45)
+    ]);
+    target.push(2);
+  }
+  __trafficConditions = { data, target };
+  return __trafficConditions;
+}
+function loadTrafficConditions() {
+  const { data, target } = getTrafficConditionsData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["time of day (hour)", "speed (km/h)", "density (vehicles/km)"],
+    targetNames: ["light", "moderate", "heavy"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 3 features, 3 traffic level classes.`
+  };
+}
+var __fitnessScores;
+function getFitnessScoresData() {
+  if (__fitnessScores !== void 0) return __fitnessScores;
+  const rng = createRng(3018);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 100; i++) {
+    const duration = 20 + rng() * 70;
+    const intensity = 1 + rng() * 9;
+    const frequency = 1 + rng() * 6;
+    data.push([duration, intensity, frequency]);
+    target.push([
+      10 + 0.3 * duration + 5 * intensity + 3 * frequency + (rng() - 0.5) * 8,
+      15 + 0.5 * duration + 2 * intensity + 5 * frequency + (rng() - 0.5) * 8,
+      30 + 0.4 * duration + 1 * intensity + 2 * frequency + (rng() - 0.5) * 8
+    ]);
+  }
+  __fitnessScores = { data, target };
+  return __fitnessScores;
+}
+function loadFitnessScores() {
+  const { data, target } = getFitnessScoresData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["exercise duration (min)", "intensity (1-10)", "frequency (times/week)"],
+    targetNames: ["strength", "endurance", "flexibility"],
+    description: `${SYNTHETIC_NOTE} 100 samples, 3 exercise features, 3 fitness targets (multi-output).`
+  };
+}
+var __weatherOutcomes;
+function getWeatherOutcomesData() {
+  if (__weatherOutcomes !== void 0) return __weatherOutcomes;
+  const rng = createRng(3019);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 150; i++) {
+    const humidity = 20 + rng() * 80;
+    const pressure = 990 + rng() * 50;
+    const temperature = -5 + rng() * 40;
+    data.push([humidity, pressure, temperature]);
+    const rawRain = 0.01 * humidity - 3e-3 * (pressure - 1e3) + 5e-3 * temperature - 0.3 + (rng() - 0.5) * 0.1;
+    const rainProb = Math.max(0, Math.min(1, rawRain));
+    const windSpeed = 8 + 0.5 * Math.abs(pressure - 1013) + 0.3 * temperature + (rng() - 0.5) * 6;
+    target.push([rainProb, Math.max(0, windSpeed)]);
+  }
+  __weatherOutcomes = { data, target };
+  return __weatherOutcomes;
+}
+function loadWeatherOutcomes() {
+  const { data, target } = getWeatherOutcomesData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target),
+    featureNames: ["humidity (%)", "pressure (hPa)", "temperature (\xB0C)"],
+    targetNames: ["rain probability", "wind speed (km/h)"],
+    description: `${SYNTHETIC_NOTE} 150 samples, 3 features, 2 targets (multi-output regression).`
+  };
+}
+var __perfectlySeparable;
+function getPerfectlySeparableData() {
+  if (__perfectlySeparable !== void 0) return __perfectlySeparable;
+  const rng = createRng(3020);
+  const data = [];
+  const target = [];
+  for (let i = 0; i < 50; i++) {
+    data.push([1 + rng() * 0.8, 0.5 + rng() * 0.6, -1 + rng() * 0.7, 2 + rng() * 0.5]);
+    target.push(0);
+  }
+  for (let i = 0; i < 50; i++) {
+    data.push([4 + rng() * 0.8, 3.5 + rng() * 0.6, 2 + rng() * 0.7, 5 + rng() * 0.5]);
+    target.push(1);
+  }
+  __perfectlySeparable = { data, target };
+  return __perfectlySeparable;
+}
+function loadPerfectlySeparable() {
+  const { data, target } = getPerfectlySeparableData();
+  return {
+    data: chunk6AE5FKKQ_cjs.tensor(data),
+    target: chunk6AE5FKKQ_cjs.tensor(target, { dtype: "int32" }),
+    featureNames: ["feature_0", "feature_1", "feature_2", "feature_3"],
+    targetNames: ["class_0", "class_1"],
+    description: `${SYNTHETIC_NOTE} 100 samples, 4 features, 2 linearly separable classes.`
+  };
+}
+
+exports.DataLoader = DataLoader;
+exports.datasets_exports = datasets_exports;
+exports.loadBreastCancer = loadBreastCancer;
+exports.loadConcentricRings = loadConcentricRings;
+exports.loadCropYield = loadCropYield;
+exports.loadCustomerSegments = loadCustomerSegments;
+exports.loadDiabetes = loadDiabetes;
+exports.loadDigits = loadDigits;
+exports.loadEnergyEfficiency = loadEnergyEfficiency;
+exports.loadFitnessScores = loadFitnessScores;
+exports.loadFlowersExtended = loadFlowersExtended;
+exports.loadFruitQuality = loadFruitQuality;
+exports.loadGaussianIslands = loadGaussianIslands;
+exports.loadHousingMini = loadHousingMini;
+exports.loadIris = loadIris;
+exports.loadLeafShapes = loadLeafShapes;
+exports.loadLinnerud = loadLinnerud;
+exports.loadMoonsMulti = loadMoonsMulti;
+exports.loadPerfectlySeparable = loadPerfectlySeparable;
+exports.loadPlantGrowth = loadPlantGrowth;
+exports.loadSeedMorphology = loadSeedMorphology;
+exports.loadSensorStates = loadSensorStates;
+exports.loadSpiralArms = loadSpiralArms;
+exports.loadStudentPerformance = loadStudentPerformance;
+exports.loadTrafficConditions = loadTrafficConditions;
+exports.loadWeatherOutcomes = loadWeatherOutcomes;
+exports.makeBlobs = makeBlobs;
+exports.makeCircles = makeCircles;
+exports.makeClassification = makeClassification;
+exports.makeGaussianQuantiles = makeGaussianQuantiles;
+exports.makeMoons = makeMoons;
+exports.makeRegression = makeRegression;
+//# sourceMappingURL=chunk-XEG44RF6.cjs.map
+//# sourceMappingURL=chunk-XEG44RF6.cjs.map