textopt 0.0.0

package/dist/optimizer-B7SpRwl7.d.cts

@@ -0,0 +1,288 @@
+import { d as UsageTotals, i as EvaluationBatch, n as Candidate, o as EvaluationPhase, s as EvaluationSplit, t as Adapter } from "./types-CWv4IQFF.cjs";
+import { n as EvaluationCache, t as CachedScore } from "./cache-CuSo0NJ8.cjs";
+//#region src/budget.d.ts
+interface Budget {
+  readonly maxMetricCalls: number;
+  spent(): number;
+  remaining(): number;
+  canAfford(calls: number): boolean;
+  /** Debits `calls` atomically. False when the allowance cannot cover them. */
+  reserve(calls: number): boolean;
+  /** Credits back calls a reservation did not end up spending. */
+  refund(calls: number): void;
+}
+/**
+ * Rollouts are the currency of prompt optimization: an optimizer's cost is
+ * measured in metric calls, not iterations. The engine debits this budget
+ * before every evaluation and stops when it can no longer afford the next one.
+ *
+ * Debiting happens up front, as an atomic reserve-then-refund rather than a
+ * check followed by a charge: proposals evaluated concurrently would otherwise
+ * each see the same remaining allowance and all spend it.
+ */
+declare function createBudget(args: {
+  maxMetricCalls: number;
+  /** Rollouts a resumed run already paid for before the checkpoint. */
+  spent?: number;
+}): Budget;
+//#endregion
+//#region src/evaluation.d.ts
+/**
+ * One evaluation, reported as it happens. Optimizer-agnostic: every search
+ * pays for rollouts the same way, and a caller watching cost should not have
+ * to know which algorithm is spending it.
+ */
+interface EvaluationEvent {
+  iteration: number;
+  phase: EvaluationPhase;
+  split: EvaluationSplit;
+  candidateId: number | null;
+  /** Rollouts this evaluation actually bought. Cached instances are not here. */
+  metricCalls: number;
+  cacheHits: number;
+  meanScore: number;
+}
+/** Scores plus, when the adapter reports them, their per-objective breakdown. */
+interface ScoredBatch<Output> {
+  scores: number[];
+  objectiveScores: (Record<string, number> | undefined)[];
+  /** Populated only under `trackOutputs`, and only for fresh rollouts. */
+  outputs: (Output | undefined)[];
+  /** Per instance: the score came from an infrastructure failure, not the candidate. */
+  transient: boolean[];
+}
+interface EvaluateBatchArgs<Datum, K extends string> {
+  candidate: Candidate<K>;
+  batch: readonly Datum[];
+  /** Instance ids, aligned with `batch`, naming rows in the cache. */
+  ids: readonly string[];
+  split: EvaluationSplit;
+  phase: EvaluationPhase;
+  candidateId: number | null;
+  iteration: number;
+  /**
+   * Whether these rollouts come out of the search budget. Measurement taken
+   * after the search has chosen a winner passes false: charging it would let
+   * the size of a held-out set change which candidate wins.
+   */
+  charge?: boolean;
+}
+interface EvaluateTracedArgs<Datum, K extends string> {
+  candidate: Candidate<K>;
+  batch: readonly Datum[];
+  split: EvaluationSplit;
+  phase: EvaluationPhase;
+  candidateId: number | null;
+  iteration: number;
+}
+/**
+ * The part of an optimizer that spends money. Every search built on this
+ * package shares it, so caching, budgeting, transient-failure handling and
+ * cost reporting behave identically whichever algorithm is running.
+ */
+interface Evaluator<Datum, Trajectory, Output, K extends string> {
+  evaluate(args: EvaluateBatchArgs<Datum, K>): Promise<ScoredBatch<Output>>;
+  /**
+   * A rollout with traces captured, always fresh. Reflection reads the traces,
+   * and the cache stores scores rather than trajectories, so a cached instance
+   * has nothing to reflect on — serving one here would silently hand the
+   * reflection model an empty dataset.
+   *
+   * Returns null when the budget cannot cover the batch, rather than throwing:
+   * a run that cannot afford to reflect is finished, not broken.
+   */
+  evaluateTraced(args: EvaluateTracedArgs<Datum, K>): Promise<EvaluationBatch<Trajectory, Output> | null>;
+  /**
+   * How many of `ids` this candidate has not been scored on yet — what a sweep
+   * would actually cost. Lets a caller price an evaluation before committing
+   * to it, instead of discovering the shortfall halfway through.
+   */
+  countUncached(args: {
+    candidate: Candidate<K>;
+    ids: readonly string[];
+    split: EvaluationSplit;
+  }): number;
+  /** Instances served from the cache, which no budget was charged for. */
+  cacheHits(): number;
+  /** Rollouts made with `charge: false`, tracked apart from the budget. */
+  unchargedCalls(): number;
+  /** Tokens and money the run has spent, as far as adapters have reported it. */
+  usage(): UsageTotals;
+  /** Cache contents for checkpointing, when the cache can enumerate them. */
+  entries(): [string, CachedScore][] | undefined;
+  restore(entries: Iterable<readonly [string, CachedScore]>): void;
+}
+/**
+ * How often a rollout the adapter reported as infrastructure failure is tried
+ * again before its instance is left unmeasured.
+ */
+interface RetryPolicy {
+  /** Extra attempts per instance, beyond the first. Zero disables retrying. */
+  attempts?: number;
+  /** Wait before the first retry. Doubled for each attempt after it. */
+  delayMs?: number;
+}
+/**
+ * Raised when a reservation cannot be met mid-flight. A concurrent evaluation
+ * cannot check the budget and then spend it — another may take the remainder
+ * in between — so running out is reported where it happens and turned into a
+ * stop reason by whichever loop is driving.
+ */
+declare class BudgetExhausted extends Error {}
+declare function createEvaluator<Datum, Trajectory, Output, K extends string>(args: {
+  adapter: Adapter<Datum, Trajectory, Output, K>;
+  budget: Budget;
+  /** Omit to run uncached; every instance is then a fresh rollout. */
+  cache?: EvaluationCache;
+  /** Keep what each rollout produced. Costs memory proportional to outputs. */
+  trackOutputs?: boolean;
+  onEvaluation?: (event: EvaluationEvent) => void;
+  signal?: AbortSignal;
+  /** Resumed counters, so a continued run reports totals rather than deltas. */
+  cacheHits?: number;
+  /**
+   * Rate limits and 5xx responses are the common case in a long run, and a
+   * transient row costs the instance whichever optimizer is driving: it is
+   * either an unexplained zero or a hole in the candidate's coverage. Retrying
+   * here fixes it once for every optimizer rather than in each search loop.
+   */
+  retry?: RetryPolicy;
+  /** Scopes every cache key to the system these rollouts were measured under. */
+  cacheNamespace?: string;
+}): Evaluator<Datum, Trajectory, Output, K>;
+/**
+ * Mean over the rows that measured the candidate. Transient rows measured the
+ * infrastructure instead, so averaging their zeros in would reject a candidate
+ * for an outage; undefined when no row measured anything at all, which is a
+ * batch that says nothing rather than a batch that says zero.
+ */
+declare function measuredMean(batch: {
+  scores: readonly number[];
+  transient?: readonly boolean[];
+}): number | undefined;
+/**
+ * Whether a run has spent what it was allowed to. Checked between evaluations,
+ * because usage is only known once a rollout has been paid for.
+ */
+declare function costExhausted(args: {
+  usage: UsageTotals;
+  maxCostUsd?: number;
+}): boolean;
+/**
+ * The measured mean of an evaluation a run cannot continue without — its seed
+ * baseline, and the sweeps it compares everything against.
+ *
+ * Reporting zero for a batch in which nothing ran would set the search a
+ * baseline no rollout produced, and every later comparison would be made
+ * against it. Failing here names the provider outage instead.
+ */
+declare function requireMeasuredMean(args: {
+  batch: {
+    scores: readonly number[];
+    transient?: readonly boolean[];
+  };
+  phase: string;
+}): number;
+//#endregion
+//#region src/optimizer.d.ts
+/**
+ * The run-level inputs every optimizer needs, whatever search it runs. An
+ * optimizer's own task type is a superset of this; the shared members are what
+ * a caller can rely on without knowing which optimizer it holds.
+ */
+interface OptimizerTask<Datum, Trajectory = unknown, Output = unknown, K extends string = string> {
+  seedCandidate: Candidate<K>;
+  trainingSet: readonly Datum[];
+  validationSet?: readonly Datum[];
+  /**
+   * `NoInfer` keeps the adapter out of `K`'s inference: an adapter built by a
+   * factory knows nothing about component names, and one inference candidate of
+   * `string` widens `K` back to `string` everywhere.
+   */
+  adapter: Adapter<Datum, Trajectory, Output, NoInfer<K>>;
+  /**
+   * Instances held back from the search entirely, used once at the end to
+   * score the winner. Selection pressure is applied to the validation set for the
+   * whole run, so `bestScore` is partly fitted to it; `testScore` is the only
+   * number in a result that no candidate was ever selected against.
+   */
+  testSet?: readonly Datum[];
+  maxMetricCalls: number;
+  /**
+   * Dollars the run may spend, as reported by the adapter's usage. Checked
+   * between evaluations rather than during one, so a run stops at the first
+   * decision point past the ceiling rather than exactly on it.
+   *
+   * A rollout ceiling cannot bound spend on its own: reflective search grows
+   * the text it optimizes, so late rollouts cost more than early ones.
+   */
+  maxCostUsd?: number;
+  /**
+   * Wall-clock milliseconds the run may take. Checked between evaluations, so
+   * a run overruns by at most the length of one.
+   *
+   * Neither a rollout ceiling nor a cost ceiling bounds duration: a run behind
+   * a rate limit spends almost nothing and takes as long as the provider
+   * makes it take. This is what makes an optimizer safe to put behind a
+   * request timeout or a nightly job.
+   */
+  maxWallClockMs?: number;
+  /**
+   * Names the system under optimization — model id, decoding settings, scorer
+   * version — so cached scores measured under one are never served to another.
+   * Change it whenever anything outside the candidate text changes.
+   */
+  cacheNamespace?: string;
+  /**
+   * How a rollout the adapter reported as an infrastructure failure is retried.
+   * Optimizer-agnostic, because a rate limit costs every search the same thing:
+   * an instance that measured the provider rather than the candidate.
+   */
+  retry?: RetryPolicy;
+  signal?: AbortSignal;
+}
+/**
+ * What every optimizer reports. `Stop` has no default: an optimizer that cannot
+ * enumerate the reasons it stops has not finished being designed, and a default
+ * here would put `string` back.
+ */
+interface OptimizerResult<K extends string, Stop extends string, Output = unknown> {
+  bestCandidate: Candidate<K>;
+  bestScore: number;
+  bestOutputs?: (Output | undefined)[];
+  metricCalls: number;
+  /**
+   * Tokens and dollars the run spent, summed from what the adapter reported.
+   * Zero throughout when the adapter reports no usage.
+   */
+  usage: UsageTotals;
+  /**
+   * `bestCandidate`'s mean score over the held-out testSet. Absent when no
+   * testSet was given. A large gap below `bestScore` is the search having
+   * fitted the validation instances rather than the task.
+   */
+  testScore?: number;
+  /**
+   * Rollouts the held-out sweep cost. Reported separately because it is
+   * measurement rather than search, and so is not charged to `maxMetricCalls`.
+   */
+  testMetricCalls?: number;
+  stopReason: Stop;
+}
+/**
+ * An optimizer: a task in, the best candidate it found out. Exactly one method.
+ *
+ * `Datum` and `K` are inferred per call, so they live on the method rather than
+ * on the interface — a class parameter could only be fixed at `new`, where no
+ * seed candidate exists yet.
+ *
+ * The interface names the contract; it is not a type to hold instances in.
+ * Method parameters are bivariant, which is what lets an optimizer with a
+ * richer task type implement it at all, and equally what lets a task missing
+ * that optimizer's own inputs typecheck against this signature.
+ */
+interface Optimizer<Stop extends string> {
+  optimize<Datum, Trajectory = unknown, Output = unknown, const K extends string = string>(task: OptimizerTask<Datum, Trajectory, Output, K>): Promise<OptimizerResult<K, Stop, Output>>;
+}
+//#endregion
+export { EvaluateBatchArgs as a, Evaluator as c, costExhausted as d, createEvaluator as f, createBudget as g, Budget as h, BudgetExhausted as i, RetryPolicy as l, requireMeasuredMean as m, OptimizerResult as n, EvaluateTracedArgs as o, measuredMean as p, OptimizerTask as r, EvaluationEvent as s, Optimizer as t, ScoredBatch as u };

package/dist/optimizer-DqCoth_w.d.mts

@@ -0,0 +1,288 @@
+import { d as UsageTotals, i as EvaluationBatch, n as Candidate, o as EvaluationPhase, s as EvaluationSplit, t as Adapter } from "./types-CWv4IQFF.mjs";
+import { n as EvaluationCache, t as CachedScore } from "./cache-CuSo0NJ8.mjs";
+//#region src/budget.d.ts
+interface Budget {
+  readonly maxMetricCalls: number;
+  spent(): number;
+  remaining(): number;
+  canAfford(calls: number): boolean;
+  /** Debits `calls` atomically. False when the allowance cannot cover them. */
+  reserve(calls: number): boolean;
+  /** Credits back calls a reservation did not end up spending. */
+  refund(calls: number): void;
+}
+/**
+ * Rollouts are the currency of prompt optimization: an optimizer's cost is
+ * measured in metric calls, not iterations. The engine debits this budget
+ * before every evaluation and stops when it can no longer afford the next one.
+ *
+ * Debiting happens up front, as an atomic reserve-then-refund rather than a
+ * check followed by a charge: proposals evaluated concurrently would otherwise
+ * each see the same remaining allowance and all spend it.
+ */
+declare function createBudget(args: {
+  maxMetricCalls: number;
+  /** Rollouts a resumed run already paid for before the checkpoint. */
+  spent?: number;
+}): Budget;
+//#endregion
+//#region src/evaluation.d.ts
+/**
+ * One evaluation, reported as it happens. Optimizer-agnostic: every search
+ * pays for rollouts the same way, and a caller watching cost should not have
+ * to know which algorithm is spending it.
+ */
+interface EvaluationEvent {
+  iteration: number;
+  phase: EvaluationPhase;
+  split: EvaluationSplit;
+  candidateId: number | null;
+  /** Rollouts this evaluation actually bought. Cached instances are not here. */
+  metricCalls: number;
+  cacheHits: number;
+  meanScore: number;
+}
+/** Scores plus, when the adapter reports them, their per-objective breakdown. */
+interface ScoredBatch<Output> {
+  scores: number[];
+  objectiveScores: (Record<string, number> | undefined)[];
+  /** Populated only under `trackOutputs`, and only for fresh rollouts. */
+  outputs: (Output | undefined)[];
+  /** Per instance: the score came from an infrastructure failure, not the candidate. */
+  transient: boolean[];
+}
+interface EvaluateBatchArgs<Datum, K extends string> {
+  candidate: Candidate<K>;
+  batch: readonly Datum[];
+  /** Instance ids, aligned with `batch`, naming rows in the cache. */
+  ids: readonly string[];
+  split: EvaluationSplit;
+  phase: EvaluationPhase;
+  candidateId: number | null;
+  iteration: number;
+  /**
+   * Whether these rollouts come out of the search budget. Measurement taken
+   * after the search has chosen a winner passes false: charging it would let
+   * the size of a held-out set change which candidate wins.
+   */
+  charge?: boolean;
+}
+interface EvaluateTracedArgs<Datum, K extends string> {
+  candidate: Candidate<K>;
+  batch: readonly Datum[];
+  split: EvaluationSplit;
+  phase: EvaluationPhase;
+  candidateId: number | null;
+  iteration: number;
+}
+/**
+ * The part of an optimizer that spends money. Every search built on this
+ * package shares it, so caching, budgeting, transient-failure handling and
+ * cost reporting behave identically whichever algorithm is running.
+ */
+interface Evaluator<Datum, Trajectory, Output, K extends string> {
+  evaluate(args: EvaluateBatchArgs<Datum, K>): Promise<ScoredBatch<Output>>;
+  /**
+   * A rollout with traces captured, always fresh. Reflection reads the traces,
+   * and the cache stores scores rather than trajectories, so a cached instance
+   * has nothing to reflect on — serving one here would silently hand the
+   * reflection model an empty dataset.
+   *
+   * Returns null when the budget cannot cover the batch, rather than throwing:
+   * a run that cannot afford to reflect is finished, not broken.
+   */
+  evaluateTraced(args: EvaluateTracedArgs<Datum, K>): Promise<EvaluationBatch<Trajectory, Output> | null>;
+  /**
+   * How many of `ids` this candidate has not been scored on yet — what a sweep
+   * would actually cost. Lets a caller price an evaluation before committing
+   * to it, instead of discovering the shortfall halfway through.
+   */
+  countUncached(args: {
+    candidate: Candidate<K>;
+    ids: readonly string[];
+    split: EvaluationSplit;
+  }): number;
+  /** Instances served from the cache, which no budget was charged for. */
+  cacheHits(): number;
+  /** Rollouts made with `charge: false`, tracked apart from the budget. */
+  unchargedCalls(): number;
+  /** Tokens and money the run has spent, as far as adapters have reported it. */
+  usage(): UsageTotals;
+  /** Cache contents for checkpointing, when the cache can enumerate them. */
+  entries(): [string, CachedScore][] | undefined;
+  restore(entries: Iterable<readonly [string, CachedScore]>): void;
+}
+/**
+ * How often a rollout the adapter reported as infrastructure failure is tried
+ * again before its instance is left unmeasured.
+ */
+interface RetryPolicy {
+  /** Extra attempts per instance, beyond the first. Zero disables retrying. */
+  attempts?: number;
+  /** Wait before the first retry. Doubled for each attempt after it. */
+  delayMs?: number;
+}
+/**
+ * Raised when a reservation cannot be met mid-flight. A concurrent evaluation
+ * cannot check the budget and then spend it — another may take the remainder
+ * in between — so running out is reported where it happens and turned into a
+ * stop reason by whichever loop is driving.
+ */
+declare class BudgetExhausted extends Error {}
+declare function createEvaluator<Datum, Trajectory, Output, K extends string>(args: {
+  adapter: Adapter<Datum, Trajectory, Output, K>;
+  budget: Budget;
+  /** Omit to run uncached; every instance is then a fresh rollout. */
+  cache?: EvaluationCache;
+  /** Keep what each rollout produced. Costs memory proportional to outputs. */
+  trackOutputs?: boolean;
+  onEvaluation?: (event: EvaluationEvent) => void;
+  signal?: AbortSignal;
+  /** Resumed counters, so a continued run reports totals rather than deltas. */
+  cacheHits?: number;
+  /**
+   * Rate limits and 5xx responses are the common case in a long run, and a
+   * transient row costs the instance whichever optimizer is driving: it is
+   * either an unexplained zero or a hole in the candidate's coverage. Retrying
+   * here fixes it once for every optimizer rather than in each search loop.
+   */
+  retry?: RetryPolicy;
+  /** Scopes every cache key to the system these rollouts were measured under. */
+  cacheNamespace?: string;
+}): Evaluator<Datum, Trajectory, Output, K>;
+/**
+ * Mean over the rows that measured the candidate. Transient rows measured the
+ * infrastructure instead, so averaging their zeros in would reject a candidate
+ * for an outage; undefined when no row measured anything at all, which is a
+ * batch that says nothing rather than a batch that says zero.
+ */
+declare function measuredMean(batch: {
+  scores: readonly number[];
+  transient?: readonly boolean[];
+}): number | undefined;
+/**
+ * Whether a run has spent what it was allowed to. Checked between evaluations,
+ * because usage is only known once a rollout has been paid for.
+ */
+declare function costExhausted(args: {
+  usage: UsageTotals;
+  maxCostUsd?: number;
+}): boolean;
+/**
+ * The measured mean of an evaluation a run cannot continue without — its seed
+ * baseline, and the sweeps it compares everything against.
+ *
+ * Reporting zero for a batch in which nothing ran would set the search a
+ * baseline no rollout produced, and every later comparison would be made
+ * against it. Failing here names the provider outage instead.
+ */
+declare function requireMeasuredMean(args: {
+  batch: {
+    scores: readonly number[];
+    transient?: readonly boolean[];
+  };
+  phase: string;
+}): number;
+//#endregion
+//#region src/optimizer.d.ts
+/**
+ * The run-level inputs every optimizer needs, whatever search it runs. An
+ * optimizer's own task type is a superset of this; the shared members are what
+ * a caller can rely on without knowing which optimizer it holds.
+ */
+interface OptimizerTask<Datum, Trajectory = unknown, Output = unknown, K extends string = string> {
+  seedCandidate: Candidate<K>;
+  trainingSet: readonly Datum[];
+  validationSet?: readonly Datum[];
+  /**
+   * `NoInfer` keeps the adapter out of `K`'s inference: an adapter built by a
+   * factory knows nothing about component names, and one inference candidate of
+   * `string` widens `K` back to `string` everywhere.
+   */
+  adapter: Adapter<Datum, Trajectory, Output, NoInfer<K>>;
+  /**
+   * Instances held back from the search entirely, used once at the end to
+   * score the winner. Selection pressure is applied to the validation set for the
+   * whole run, so `bestScore` is partly fitted to it; `testScore` is the only
+   * number in a result that no candidate was ever selected against.
+   */
+  testSet?: readonly Datum[];
+  maxMetricCalls: number;
+  /**
+   * Dollars the run may spend, as reported by the adapter's usage. Checked
+   * between evaluations rather than during one, so a run stops at the first
+   * decision point past the ceiling rather than exactly on it.
+   *
+   * A rollout ceiling cannot bound spend on its own: reflective search grows
+   * the text it optimizes, so late rollouts cost more than early ones.
+   */
+  maxCostUsd?: number;
+  /**
+   * Wall-clock milliseconds the run may take. Checked between evaluations, so
+   * a run overruns by at most the length of one.
+   *
+   * Neither a rollout ceiling nor a cost ceiling bounds duration: a run behind
+   * a rate limit spends almost nothing and takes as long as the provider
+   * makes it take. This is what makes an optimizer safe to put behind a
+   * request timeout or a nightly job.
+   */
+  maxWallClockMs?: number;
+  /**
+   * Names the system under optimization — model id, decoding settings, scorer
+   * version — so cached scores measured under one are never served to another.
+   * Change it whenever anything outside the candidate text changes.
+   */
+  cacheNamespace?: string;
+  /**
+   * How a rollout the adapter reported as an infrastructure failure is retried.
+   * Optimizer-agnostic, because a rate limit costs every search the same thing:
+   * an instance that measured the provider rather than the candidate.
+   */
+  retry?: RetryPolicy;
+  signal?: AbortSignal;
+}
+/**
+ * What every optimizer reports. `Stop` has no default: an optimizer that cannot
+ * enumerate the reasons it stops has not finished being designed, and a default
+ * here would put `string` back.
+ */
+interface OptimizerResult<K extends string, Stop extends string, Output = unknown> {
+  bestCandidate: Candidate<K>;
+  bestScore: number;
+  bestOutputs?: (Output | undefined)[];
+  metricCalls: number;
+  /**
+   * Tokens and dollars the run spent, summed from what the adapter reported.
+   * Zero throughout when the adapter reports no usage.
+   */
+  usage: UsageTotals;
+  /**
+   * `bestCandidate`'s mean score over the held-out testSet. Absent when no
+   * testSet was given. A large gap below `bestScore` is the search having
+   * fitted the validation instances rather than the task.
+   */
+  testScore?: number;
+  /**
+   * Rollouts the held-out sweep cost. Reported separately because it is
+   * measurement rather than search, and so is not charged to `maxMetricCalls`.
+   */
+  testMetricCalls?: number;
+  stopReason: Stop;
+}
+/**
+ * An optimizer: a task in, the best candidate it found out. Exactly one method.
+ *
+ * `Datum` and `K` are inferred per call, so they live on the method rather than
+ * on the interface — a class parameter could only be fixed at `new`, where no
+ * seed candidate exists yet.
+ *
+ * The interface names the contract; it is not a type to hold instances in.
+ * Method parameters are bivariant, which is what lets an optimizer with a
+ * richer task type implement it at all, and equally what lets a task missing
+ * that optimizer's own inputs typecheck against this signature.
+ */
+interface Optimizer<Stop extends string> {
+  optimize<Datum, Trajectory = unknown, Output = unknown, const K extends string = string>(task: OptimizerTask<Datum, Trajectory, Output, K>): Promise<OptimizerResult<K, Stop, Output>>;
+}
+//#endregion
+export { EvaluateBatchArgs as a, Evaluator as c, costExhausted as d, createEvaluator as f, createBudget as g, Budget as h, BudgetExhausted as i, RetryPolicy as l, requireMeasuredMean as m, OptimizerResult as n, EvaluateTracedArgs as o, measuredMean as p, OptimizerTask as r, EvaluationEvent as s, Optimizer as t, ScoredBatch as u };