@genai-fi/nanogpt 0.0.1

package/dist/tokeniser/NodeTokeniser.d.ts

@@ -0,0 +1,19 @@
+import { default as EE } from 'eventemitter3';
+import { ITokeniser } from './type';
+export default class NodeTokeniser extends EE<'trainStatus'> implements ITokeniser {
+    vocabSize: number;
+    eosToken: number;
+    private bpe;
+    constructor(vocab?: string[], merges?: [string, string][]);
+    get trained(): boolean;
+    destroy(): void;
+    train(text: string[], vocabSize: number): Promise<number>;
+    tokenise(text: string[], numeric: true): Promise<number[][]>;
+    tokenise(text: string[]): Promise<string[][]>;
+    detokenise(tokens: number[][]): Promise<string[]>;
+    encode(text: string): Promise<number[]>;
+    decode(tokens: number[]): Promise<string>;
+    getVocab(): string[];
+    getMerges(): Promise<[string, string][]>;
+    createTrainingData(text: string[], windowSize?: number): Promise<[number[], number[]]>;
+}

package/dist/tokeniser/NodeTokeniser.js

@@ -0,0 +1,46 @@
+import { E as a } from "../index-SOhdqzHq.js";
+import o from "./bpe.js";
+class b extends a {
+  vocabSize = 0;
+  eosToken = 0;
+  bpe = new o();
+  constructor(e, t) {
+    super(), e && (this.bpe = new o(e, t), this.vocabSize = e.length);
+  }
+  get trained() {
+    return this.vocabSize > 0;
+  }
+  destroy() {
+  }
+  async train(e, t) {
+    return this.bpe.train(e, t), this.vocabSize = this.bpe.getVocab().length, this.vocabSize;
+  }
+  async tokenise(e, t) {
+    return t ? this.bpe.tokenise(e, !0) : this.bpe.tokenise(e);
+  }
+  async detokenise(e) {
+    const t = this.bpe.getVocab();
+    return e.map((n) => n.map((i) => t[i]).join(""));
+  }
+  async encode(e) {
+    return (await this.tokenise([e], !0))[0];
+  }
+  async decode(e) {
+    return (await this.detokenise([e]))[0];
+  }
+  getVocab() {
+    return this.bpe.getVocab();
+  }
+  async getMerges() {
+    return this.bpe.getMerges();
+  }
+  async createTrainingData(e, t = 5) {
+    const s = this.bpe.tokenise(e, !0), n = [], i = [];
+    for (let r = 0; r < s.length - t; r++)
+      n.push(...s[r].slice(0, t)), i.push(s[r + 1][0]);
+    return [n, i];
+  }
+}
+export {
+  b as default
+};

package/dist/tokeniser/WebTokeniser.d.ts

@@ -0,0 +1,18 @@
+import { default as EE } from 'eventemitter3';
+import { ITokeniser } from './type';
+export default class WebTokeniser extends EE<'trainStatus'> implements ITokeniser {
+    private id;
+    vocabSize: number;
+    private handler?;
+    constructor();
+    destroy(): void;
+    private post;
+    train(text: string[], vocabSize: number): Promise<number>;
+    tokenise(text: string[], numeric: true): Promise<number[][]>;
+    tokenise(text: string[]): Promise<string[][]>;
+    detokenise(tokens: number[][]): Promise<string[]>;
+    encode(text: string): Promise<number[]>;
+    decode(tokens: number[]): Promise<string>;
+    getVocab(): Promise<string[]>;
+    createTrainingData(text: string[], windowSize?: number): Promise<[number[], number[]]>;
+}

package/dist/tokeniser/WebTokeniser.js

@@ -0,0 +1,96 @@
+import { E as d } from "../index-SOhdqzHq.js";
+const t = new Worker(new URL(
+  /* @vite-ignore */
+  "/assets/worker-BYeSPNkq.js",
+  import.meta.url
+), {
+  type: "module"
+});
+let r = 0;
+class m extends d {
+  id;
+  vocabSize = 0;
+  handler;
+  constructor() {
+    super(), this.id = r++, this.handler = (e) => {
+      e.data.type === "trainStatus" && e.data.id === this.id && (this.vocabSize = e.data.vocabSize, this.emit("trainStatus", e.data.progress, e.data.vocabSize));
+    }, t.addEventListener("message", this.handler);
+  }
+  destroy() {
+    this.handler && (t.removeEventListener("message", this.handler), this.handler = void 0);
+  }
+  post(e) {
+    t.postMessage(e);
+  }
+  async train(e, n) {
+    return new Promise((s) => {
+      const i = (a) => {
+        a.data.type === "trainResponse" && a.data.id === this.id && (t.removeEventListener("message", i), this.vocabSize = a.data.vocabSize, s(this.vocabSize));
+      };
+      t.addEventListener("message", i), this.post({
+        type: "train",
+        id: this.id,
+        text: e,
+        vocabSize: n
+      });
+    });
+  }
+  async tokenise(e, n) {
+    return new Promise((s) => {
+      const i = (a) => {
+        a.data.type === "tokeniseResponse" && a.data.id === this.id && (t.removeEventListener("message", i), s(a.data.tokens));
+      };
+      t.addEventListener("message", i), this.post({
+        type: "tokenise",
+        id: this.id,
+        text: e,
+        numeric: n
+      });
+    });
+  }
+  async detokenise(e) {
+    return new Promise((n) => {
+      const s = (i) => {
+        i.data.type === "detokeniseResponse" && i.data.id === this.id && (t.removeEventListener("message", s), n(i.data.text));
+      };
+      t.addEventListener("message", s), this.post({
+        type: "detokenise",
+        id: this.id,
+        tokens: e
+      });
+    });
+  }
+  async encode(e) {
+    return (await this.tokenise([e], !0))[0];
+  }
+  async decode(e) {
+    return (await this.detokenise([e]))[0];
+  }
+  async getVocab() {
+    return new Promise((e) => {
+      const n = (s) => {
+        s.data.type === "tokensResponse" && s.data.id === this.id && (t.removeEventListener("message", n), e(s.data.tokens));
+      };
+      t.addEventListener("message", n), this.post({
+        type: "tokens",
+        id: this.id
+      });
+    });
+  }
+  async createTrainingData(e, n = 5) {
+    return new Promise((s) => {
+      const i = (a) => {
+        a.data.type === "buildTrainingDataResponse" && a.data.id === this.id && (t.removeEventListener("message", i), s(a.data.trainingData));
+      };
+      t.addEventListener("message", i), this.post({
+        type: "buildTrainingData",
+        id: this.id,
+        text: e,
+        windowSize: n
+      });
+    });
+  }
+}
+export {
+  m as default
+};

package/dist/tokeniser/bpe.d.ts

@@ -0,0 +1,14 @@
+export default class BPE {
+    private vocab;
+    private vocabIndex;
+    private merges;
+    private pretokenMap;
+    constructor(vocab?: string[], merges?: [string, string][]);
+    train(text: string[], vocabSize: number, onUpdate?: (progress: number, vocabSize: number) => void): void;
+    getVocab(): string[];
+    getMerges(): [string, string][];
+    private tokeniseWord;
+    private tokeniseStrings;
+    tokenise(text: string[], numeric: true): number[][];
+    tokenise(text: string[]): string[][];
+}

package/dist/tokeniser/bpe.js

@@ -0,0 +1,102 @@
+import f from "../utilities/tokenParse.js";
+function b(r) {
+  const s = /* @__PURE__ */ new Map();
+  for (let e = 0; e < r.length; e++) {
+    const t = r[e];
+    for (let n = 0; n < t.length - 1; n++) {
+      const o = `${t[n]}${t[n + 1]}`, i = s.get(o) || {
+        a: t[n],
+        b: t[n + 1],
+        count: 0,
+        instances: /* @__PURE__ */ new Set()
+      };
+      i.count += 1, i.instances.add(e), s.set(o, i);
+    }
+  }
+  return { pairs: s, tokens: r };
+}
+function h(r, s, e, t, n) {
+  const o = `${s}${e}`;
+  if (r.pairs.has(o)) {
+    const i = r.pairs.get(o);
+    i.count += n, i.instances.add(t);
+  } else
+    r.pairs.set(o, { a: s, b: e, count: n, instances: /* @__PURE__ */ new Set([t]) });
+}
+function g(r) {
+  let s = null, e = 0;
+  for (const t of r.pairs.values())
+    t.count > e && (e = t.count, s = t);
+  return s;
+}
+function m(r, s) {
+  return r.map((e) => {
+    const t = [];
+    for (let n = 0; n < e.length; n++)
+      n < e.length - 1 && e[n] === s[0] && e[n + 1] === s[1] ? (t.push(s[0] + s[1]), n++) : t.push(e[n]);
+    return t;
+  });
+}
+function d(r, s) {
+  s.instances.forEach((e) => {
+    const t = r.tokens[e], n = [];
+    for (let o = 0; o < t.length; o++)
+      if (o < t.length - 1 && t[o] === s.a && t[o + 1] === s.b) {
+        const i = s.a + s.b;
+        n.push(i), o > 0 && (h(r, t[o - 1], s.a, e, -1), h(r, t[o - 1], i, e, 1)), o++, o < t.length - 1 && (h(r, s.b, t[o + 1], e, -1), h(r, i, t[o + 1], e, 1));
+      } else
+        n.push(t[o]);
+    r.tokens[e] = n;
+  }), r.pairs.delete(`${s.a}${s.b}`);
+}
+class w {
+  vocab = /* @__PURE__ */ new Set();
+  vocabIndex = /* @__PURE__ */ new Map();
+  merges = [];
+  pretokenMap = /* @__PURE__ */ new Map();
+  constructor(s, e) {
+    s && s.forEach((t, n) => {
+      this.vocab.add(t), this.vocabIndex.set(t, n);
+    }), e && (this.merges = e);
+  }
+  train(s, e, t) {
+    const n = s.map((a) => f(a, !0)).flat(1), o = new Set(n);
+    this.vocab = /* @__PURE__ */ new Set(), this.pretokenMap.clear(), this.merges = [], this.vocab.add("<eos>");
+    const i = Array.from(o), u = i.map((a) => a.split("").map((c) => (this.vocab.add(c), c))), p = b(u);
+    for (; this.vocab.size < e && this.merges.length < e; ) {
+      const a = g(p);
+      if (!a)
+        break;
+      this.merges.push([a.a, a.b]), this.vocab.add(a.a + a.b), d(p, a), t && this.vocab.size % 100 === 0 && t(this.vocab.size / e, this.vocab.size);
+    }
+    i.forEach((a, l) => {
+      const c = u[l];
+      this.pretokenMap.set(a, c);
+    }), this.vocabIndex.clear();
+    let k = 0;
+    for (const a of this.vocab.keys())
+      this.vocabIndex.set(a, k++);
+  }
+  getVocab() {
+    return Array.from(this.vocab);
+  }
+  getMerges() {
+    return this.merges;
+  }
+  tokeniseWord(s) {
+    let e = s.split("");
+    return this.merges.forEach((t) => {
+      e = m([e], t)[0];
+    }), this.pretokenMap.set(s, e), e;
+  }
+  tokeniseStrings(s) {
+    return s.map((e) => f(e, !0).map((o) => this.pretokenMap.has(o) ? this.pretokenMap.get(o) : this.tokeniseWord(o)).flat(1));
+  }
+  tokenise(s, e) {
+    const t = this.tokeniseStrings(s);
+    return e ? t.map((n) => n.map((o) => this.vocabIndex.get(o) ?? -1)) : t;
+  }
+}
+export {
+  w as default
+};

package/dist/tokeniser/messages.d.ts

@@ -0,0 +1,61 @@
+interface TrainMessage {
+    type: 'train';
+    id: number;
+    text: string[];
+    vocabSize: number;
+}
+interface TrainResponse {
+    type: 'trainResponse';
+    id: number;
+    vocabSize: number;
+}
+interface TrainStatusMessage {
+    type: 'trainStatus';
+    id: number;
+    progress: number;
+    vocabSize: number;
+}
+interface TokeniseMessage {
+    type: 'tokenise';
+    id: number;
+    numeric?: boolean;
+    text: string[];
+}
+interface TokeniseResponse {
+    type: 'tokeniseResponse';
+    id: number;
+    numeric: boolean;
+    tokens: string[][] | number[][];
+}
+interface DetokeniseMessage {
+    type: 'detokenise';
+    id: number;
+    tokens: number[][];
+}
+interface DetokeniseResponse {
+    type: 'detokeniseResponse';
+    id: number;
+    text: string[];
+}
+interface TokensMessage {
+    type: 'tokens';
+    id: number;
+}
+interface TokensResponse {
+    type: 'tokensResponse';
+    id: number;
+    tokens: string[];
+}
+interface BuildTrainingDataMessage {
+    type: 'buildTrainingData';
+    id: number;
+    text: string[];
+    windowSize: number;
+}
+interface BuildTrainingDataResponse {
+    type: 'buildTrainingDataResponse';
+    id: number;
+    trainingData: [number[], number[]];
+}
+export type TokeniserMessage = TrainMessage | TrainResponse | TrainStatusMessage | TokeniseMessage | DetokeniseMessage | TokeniseResponse | DetokeniseResponse | TokensMessage | TokensResponse | BuildTrainingDataMessage | BuildTrainingDataResponse;
+export {};

package/dist/tokeniser/messages.js

@@ -0,0 +1 @@
+

package/dist/tokeniser/type.d.ts

@@ -0,0 +1,14 @@
+import { default as EE } from 'eventemitter3';
+export interface ITokeniser extends EE<'trainStatus'> {
+    train(text: string[], vocabSize: number): Promise<number>;
+    tokenise(text: string[], numeric?: boolean): Promise<string[][] | number[][]>;
+    detokenise(tokens: string[][] | number[][]): Promise<string[]>;
+    getVocab(): string[];
+    getMerges(): Promise<[string, string][]>;
+    destroy(): void;
+    encode(text: string): Promise<number[]>;
+    decode(tokens: number[]): Promise<string>;
+    vocabSize: number;
+    eosToken: number;
+    trained: boolean;
+}

package/dist/tokeniser/type.js

@@ -0,0 +1 @@
+

package/dist/tokeniser/worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tokeniser/worker.js

@@ -0,0 +1,53 @@
+import d from "./bpe.js";
+let e = new d();
+onmessage = async (s) => {
+  if (s.data.type === "tokenise")
+    if (s.data.numeric) {
+      const t = e.tokenise(s.data.text, !0), a = {
+        type: "tokeniseResponse",
+        id: s.data.id,
+        tokens: t,
+        numeric: !0
+      };
+      postMessage(a);
+    } else {
+      const t = e.tokenise(s.data.text), a = {
+        type: "tokeniseResponse",
+        id: s.data.id,
+        tokens: t,
+        numeric: !1
+      };
+      postMessage(a);
+    }
+  else if (s.data.type === "detokenise") {
+    const t = e.getVocab(), a = s.data.tokens.map((i) => i.map((n) => t[n]).join("")), o = {
+      type: "detokeniseResponse",
+      id: s.data.id,
+      text: a
+    };
+    postMessage(o);
+  } else if (s.data.type === "train") {
+    e = new d(), e.train(s.data.text, s.data.vocabSize ?? 100, (a, o) => {
+      const i = {
+        type: "trainStatus",
+        id: s.data.id,
+        progress: a,
+        vocabSize: o
+      };
+      postMessage(i);
+    });
+    const t = {
+      type: "trainResponse",
+      id: s.data.id,
+      vocabSize: e.getVocab().length
+    };
+    postMessage(t);
+  } else if (s.data.type === "tokens") {
+    const t = e.getVocab(), a = {
+      type: "tokensResponse",
+      id: s.data.id,
+      tokens: t
+    };
+    postMessage(a);
+  }
+};

package/dist/training/AdamExt.d.ts

@@ -0,0 +1,23 @@
+import { AdamOptimizer } from '@tensorflow/tfjs-core';
+import { NamedTensor, NamedVariableMap } from '@tensorflow/tfjs-core/dist/tensor_types';
+interface AdamExtConfig {
+    warmupSteps: number;
+    decaySteps: number;
+    minLearningRate: number;
+    weightDecay?: number;
+}
+/**
+ * Extended Adam optimizer with warmup, cosine decay, and optional weight decay.
+ */
+export default class AdamExt extends AdamOptimizer {
+    private config;
+    private step;
+    private startLearningRate;
+    constructor(learningRate: number, beta1: number, beta2: number, epsilon: number, config: AdamExtConfig);
+    get lr(): number;
+    private getAdjustedLearningRate;
+    applyGradients(gradientsAndVariables: NamedVariableMap | NamedTensor[]): void;
+    private decayVariable;
+    private applyWeightDecay;
+}
+export {};

package/dist/training/AdamExt.js

@@ -0,0 +1,43 @@
+import { A as r, m as c, s as h, a as g, e as o } from "../index-B8nyc6IR.js";
+class u extends r {
+  constructor(t, e, s, a, i) {
+    super(t, e, s, a), this.config = i, this.startLearningRate = t;
+  }
+  step = 0;
+  startLearningRate;
+  get lr() {
+    return this.learningRate;
+  }
+  getAdjustedLearningRate() {
+    if (this.step++, this.step < this.config.warmupSteps) {
+      const s = Math.min(1, (this.step + 1) / (this.config.warmupSteps + 1));
+      return this.startLearningRate * s;
+    }
+    if (this.step > this.config.decaySteps)
+      return this.config.minLearningRate;
+    const t = (this.step - this.config.warmupSteps) / (this.config.decaySteps - this.config.warmupSteps), e = 0.5 * (1 + Math.cos(Math.PI * t));
+    return this.config.minLearningRate + e * (this.startLearningRate - this.config.minLearningRate);
+  }
+  applyGradients(t) {
+    this.learningRate = this.getAdjustedLearningRate(), super.applyGradients(t), this.config.weightDecay && this.config.weightDecay > 0 && this.applyWeightDecay(t);
+  }
+  decayVariable(t, e, s) {
+    if (t && t.shape.length >= 2) {
+      const a = c(t, h(s * e));
+      t.assign(g(t, a)), a.dispose();
+    }
+  }
+  applyWeightDecay(t) {
+    const e = this.config.weightDecay, s = this.learningRate, a = o().registeredVariables;
+    Array.isArray(t) ? t.forEach(({ name: i }) => {
+      const n = a[i];
+      this.decayVariable(n, e, s);
+    }) : Object.keys(t).forEach((i) => {
+      const n = a[i];
+      this.decayVariable(n, e, s);
+    });
+  }
+}
+export {
+  u as default
+};

package/dist/training/DatasetBuilder.d.ts

@@ -0,0 +1,12 @@
+import { ITokeniser } from '../tokeniser/type';
+import { default as TF } from '@tensorflow/tfjs';
+export declare class DatasetBuilder {
+    tokenizer: ITokeniser;
+    blockSize: number;
+    private tf;
+    constructor(tf: typeof TF, tokenizer: ITokeniser, blockSize?: number);
+    createTextDataset(textData: string[], batchSize?: number): Promise<TF.data.Dataset<{
+        xs: TF.Tensor;
+        ys: TF.Tensor;
+    }>>;
+}

package/dist/training/DatasetBuilder.js

@@ -0,0 +1,27 @@
+class l {
+  tokenizer;
+  blockSize;
+  tf;
+  constructor(s, i, o = 128) {
+    this.tokenizer = i, this.blockSize = o, this.tf = s;
+  }
+  // Create dataset from text files
+  async createTextDataset(s, i = 32) {
+    const o = await Promise.all(s.map((t) => this.tokenizer.encode(t))), a = this.tokenizer.eosToken >= 0, n = o.map((t) => a ? [...t, this.tokenizer.eosToken] : t).flat(), c = (function* () {
+      for (; ; ) {
+        const t = Math.floor(Math.random() * (n.length - this.blockSize - 1)), e = n.slice(t, t + this.blockSize), r = n.slice(t + 1, t + this.blockSize + 1);
+        yield { xs: e, ys: r };
+      }
+    }).bind(this);
+    return this.tf.data.generator(c).batch(i).map((t) => {
+      const e = t;
+      return this.tf.tidy(() => ({
+        xs: e.xs.cast("int32"),
+        ys: this.tf.oneHot(e.ys.cast("int32"), this.tokenizer.vocabSize)
+      }));
+    }).prefetch(2);
+  }
+}
+export {
+  l as DatasetBuilder
+};

package/dist/training/FullTrainer.d.ts

@@ -0,0 +1,17 @@
+import { ITokeniser } from '../tokeniser/type';
+import { default as NanoGPT } from '../NanoGPTModel';
+import { default as TF } from '@tensorflow/tfjs';
+import { default as GPTTrainer, TrainingOptions } from './Trainer';
+export default class FullTrainer extends GPTTrainer {
+    constructor(tf: typeof TF, model: NanoGPT, tokenizer: ITokeniser, learningRate?: number);
+    trainOnDataset(dataset: TF.data.Dataset<{
+        xs: TF.Tensor;
+        ys: TF.Tensor;
+    }>, options: Partial<TrainingOptions>, validationDataset?: TF.data.Dataset<{
+        xs: TF.Tensor;
+        ys: TF.Tensor;
+    }>): Promise<{
+        losses: number[];
+        validationLosses: number[];
+    }>;
+}

package/dist/training/FullTrainer.js

@@ -0,0 +1,75 @@
+import { generateText as g } from "../utilities/generate.js";
+import T from "./Trainer.js";
+const b = {
+  epochs: 1,
+  stepsPerEpoch: 1e6,
+  desiredLoss: 0.01,
+  logInterval: 1
+};
+class S extends T {
+  constructor(a, r, t, i = 3e-4) {
+    super(a, r, t, i);
+  }
+  // Train for multiple epochs using Dataset API - FIXED memory leaks
+  async trainOnDataset(a, r, t) {
+    const { epochs: i, stepsPerEpoch: n, desiredLoss: c, logInterval: L, onStep: h, onEpoch: o, prompt: l } = {
+      ...b,
+      ...r
+    }, s = {
+      epoch: 0,
+      pass: 0,
+      depth: 1,
+      step: 0,
+      stepSinceDepthChange: 0,
+      lastLoss: 1e6,
+      epochLoss: 0,
+      totalSteps: 0,
+      losses: [],
+      validationLosses: []
+    };
+    this.dummyPass(), this.model.trainable = !0;
+    const m = Date.now();
+    for (s.epoch = 0; s.epoch < i; s.epoch++) {
+      s.step = 0, s.epochLoss = 0, s.pass = 0, s.depth = 1, s.stepSinceDepthChange = 0;
+      const u = await a.iterator();
+      try {
+        for (; !(n && s.step >= n || s.lastLoss < c); ) {
+          const e = await u.next();
+          if (e.done) break;
+          const f = e.value, w = this.trainBatch(s, f), p = {
+            epoch: s.epoch,
+            loss: s.lastLoss,
+            step: s.step,
+            time: Date.now() - m,
+            batchSize: f.xs.shape[0]
+          };
+          if (this.model.log.push(p), s.step % L === 0 && (await w, h)) {
+            if (l) {
+              const v = await g(this.tokenizer, this.model, l, 100, 0.8);
+              p.example = v;
+            }
+            await h(p);
+          }
+        }
+      } catch (e) {
+        throw console.error("Training error:", e), this.tf.dispose(), e;
+      }
+      const d = s.epochLoss / s.step;
+      if (t)
+        try {
+          const e = await this.evaluateOnDataset(t, 5);
+          s.validationLosses.push(e), o && await o(s.epoch, d, e);
+        } catch (e) {
+          console.error("Validation error:", e);
+        }
+      else
+        o && o(s.epoch, d);
+      if (this.tf.dispose(), s.lastLoss < c)
+        break;
+    }
+    return { losses: s.losses, validationLosses: s.validationLosses };
+  }
+}
+export {
+  S as default
+};

package/dist/training/LayerTrainer.d.ts

@@ -0,0 +1,28 @@
+import { ITokeniser } from '../tokeniser/type';
+import { default as NanoGPT } from '../NanoGPTModel';
+import { default as TF } from '@tensorflow/tfjs';
+import { default as GPTTrainer, TrainingOptions } from './Trainer';
+interface LayerTrainingOptions extends TrainingOptions {
+    stepsPerLayer: number;
+    maxPasses: number;
+    onLayerChange?: (layer: number, pass: number, valLoss?: number) => Promise<void> | void;
+    onPassComplete?: (pass: number) => Promise<void> | void;
+}
+export default class LayerTrainer extends GPTTrainer {
+    private trainingPattern;
+    private startPass;
+    private startLayer;
+    constructor(tf: typeof TF, model: NanoGPT, tokenizer: ITokeniser, learningRate?: number);
+    private applyTrainingPattern;
+    trainOnDataset(dataset: TF.data.Dataset<{
+        xs: TF.Tensor;
+        ys: TF.Tensor;
+    }>, options: Partial<LayerTrainingOptions>, validationDataset?: TF.data.Dataset<{
+        xs: TF.Tensor;
+        ys: TF.Tensor;
+    }>): Promise<{
+        losses: number[];
+        validationLosses: number[];
+    }>;
+}
+export {};