@mark1russell7/rigor-statistics 0.1.7 → 0.1.9

package/README.md

@@ -71,8 +71,35 @@ To vary a conditional dimension, `sliceResponse` needs its parent at a level ins
 
 The band of a curve is `value ± width × RMSE`, from the held-out error of the folds. On a log scale, the band is a ratio. The band has one width along the curve. It is the mean error of the model.
 
+A measure with the field `range` keeps each view inside it, for example `[0, 1]` for a share. `sliceResponse` and `surfaceResponse` move `value`, `low` and `high` to the nearest end. Such a place has the field `clipped`, and the field `clipped` of the view counts these places. `predictResponse` gives the value that the model fitted, and a fit does not use the range. `parseResponseRecord` refuses a measured value outside the range.
+
 The field `nearest` of each place tells how far the place is from a measurement. It goes from 0 to 1, and 0 means that a point was measured there. A viewer can fade the band away from the data. A table cell with the `fallback` value has `nearest` above 0.
 
+### The error of one cell
+
+Each fold keeps one error for each measure. To get the error of a chosen set of points, fit with the option `outOfFold`. Each fold then stores the prediction of each held-out point with a value, on the scale of the model. The default is off, and a record with no option has the same bytes as a record of an earlier version.
+
+`heldOutErrorAt(record, "ms", ids)` gives the fields of `heldOutError` for these points. The baseline of a point is the mean of the training points of its fold. The set of all the points gives the pooled error of the folds, to the rounding of the sums. A test examines this at 24 seeds, with a relative tolerance of 1e-12.
+
+### The reason that a measure is absent
+
+A measure with `null` has no value. To tell why, declare the reasons in the field `reasons` of the data. Then map the measure to a reason in the field `absent` of the point:
+
+```json
+{
+  "reasons": [{ "id": "budget", "label": "Out of budget" }],
+  "points": [{ "id": "p7", "values": { "boxes": 10000 }, "measures": { "ms": null }, "absent": { "ms": "budget" } }]
+}
+```
+
+`parseResponseRecord` refuses a reason on a measure with a number, and a reason with no declaration. A measure with `null` and no reason is good. `fitResponse` treats each of them as `null`, and it keeps the reasons in the record.
+
+`sliceResponse` and `surfaceResponse` give these points in a list `absent`, beside the list `points`. Each item has `id`, `at`, `reason` and `group`. The value of `reason` is `null` when the point states no reason. Thus a chart can draw each reason apart.
+
+### Many levels with few pairs
+
+The default expansion has one product for each pair of levels of two dimensions. Two dimensions with 76 and 33 levels thus give 2508 products, and the limit `RESPONSE_MAX_TERMS` refuses them. With the option `interactions: "seen"`, a ridge fit keeps only the terms that are not 0 at one point or more. This choice looks only at the inputs of the points. A term with no point has the weight 0, so the choice does not change a prediction. The limit applies after the choice.
+
 ## The functions
 
 | Function | What it gives |
@@ -98,7 +125,10 @@ The field `nearest` of each place tells how far the place is from a measurement.
 | `fitResponse(data, options)` | A record of the format `response-records/1`, with one model for each measure and held-out folds. |
 | `parseResponseRecord(value)` | The examination of unknown data. It gives the record, or one fault with a path for each error. |
 | `predictResponse(model, inputs)`, `heldOutError(record, measure)` | The value of a model at one set of inputs, and the error of the folds of a measure. |
-| `sliceResponse(record, measure, options)`, `surfaceResponse(record, measure, options)` | A fitted curve over one dimension, or a fitted surface over two, with the matching measured points, a band and the distance to the nearest measurement. |
+| `heldOutErrorAt(record, measure, ids)` | The held-out error of a chosen set of points, from the predictions of the option `outOfFold`. |
+| `responseCells(record, vary, steps)` | The number of fitted places of a view, level axes included. It lets a caller bound the time of a view before the view starts. |
+| `whenHolds(dimension, values)` | True when a place has the condition of a dimension. A dimension with no `when` is always present. |
+| `sliceResponse(record, measure, options)`, `surfaceResponse(record, measure, options)` | A fitted curve over one dimension, or a fitted surface over two, with the matching measured points, the matching points with no value, a band and the distance to the nearest measurement. |
 
 Each function throws a RangeError for an empty list, for a NaN and for a parameter out of its range. Thus a missing value cannot make a quiet NaN in a record.
 

package/build/index.d.ts

@@ -215,6 +215,18 @@ interface ResponseMeasure {
   readonly unit: string;
   /** The better direction of the value. The value `none` means that no direction is better. */
   readonly direction: "higher" | "lower" | "none";
+  /**
+   * The low and the high end of the possible values, for example `[0, 1]` for a share. Each measured value is in this
+   * range. A view clips its fitted values to it, and a fit does not use it.
+   */
+  readonly range?: readonly [number, number];
+}
+/** A declared reason that a measure is absent, for example infeasible, unsupported or out of budget. */
+interface ResponseReason {
+  /** The key of the reason in the field `absent` of a point. */
+  readonly id: string;
+  /** The name that a view shows. */
+  readonly label: string;
 }
 /** One measured point. */
 interface ResponsePoint {
@@ -225,6 +237,8 @@ interface ResponsePoint {
   readonly measures: Readonly<Record<string, number | null>>;
   /** The points of one group stay on one side of each split, for example the repeats of one seed. */
   readonly group?: string;
+  /** The reason of a measure with `null`: a map from the id of the measure to the id of a declared reason. */
+  readonly absent?: Readonly<Record<string, string>>;
 }
 /** One factor of a term: a power of a number dimension, or 1 at a level and 0 at each other level. */
 type ResponseFactor = {
@@ -322,6 +336,11 @@ interface ResponseFold {
   readonly heldOut: readonly string[];
   /** The error of each measure. A measure with no held-out point or no training point has no entry. */
   readonly errors: Readonly<Record<string, ResponseFoldError>>;
+  /**
+   * The prediction of each held-out point with a value, on the scale of the model. The keys are the id of the measure,
+   * then the id of the point. The model of this fold gave them. Only the option `outOfFold` of `fitResponse` writes this field.
+   */
+  readonly predictions?: Readonly<Record<string, Readonly<Record<string, number>>>>;
 }
 /** The data of a record, before a fit. */
 interface ResponseData {
@@ -329,6 +348,8 @@ interface ResponseData {
   readonly name: string;
   readonly dimensions: readonly ResponseDimension[];
   readonly measures: readonly ResponseMeasure[];
+  /** The reasons that a measure of a point can be absent. Each id in the field `absent` of a point is in this list. */
+  readonly reasons?: readonly ResponseReason[];
   readonly points: readonly ResponsePoint[];
 }
 /** A record: the data, one model for each measure, and the folds. */
@@ -390,6 +411,8 @@ interface ResponseBand {
    * count over the dimensions.
    */
   readonly nearest: number;
+  /** This field is true when the measure has a `range` and the view moved `value`, `low` or `high` into it. */
+  readonly clipped?: true;
 }
 /** One place of a curve. */
 interface ResponseCurvePoint extends ResponseBand {
@@ -404,6 +427,15 @@ interface ResponseSlicePoint {
   readonly value: number;
   readonly group?: string;
 }
+/** A point of a slice that matches the held values and has no value of the measure. */
+interface ResponseAbsentPoint {
+  readonly id: string;
+  /** The value of the varied dimension. */
+  readonly at: ResponseValue;
+  /** The id of the declared reason. The value `null` means that the point states no reason. */
+  readonly reason: string | null;
+  readonly group?: string;
+}
 /** The fitted curve over one dimension, and the measured points that match the held values. */
 interface ResponseSlice {
   readonly measure: string;
@@ -412,7 +444,11 @@ interface ResponseSlice {
   readonly held: Readonly<Record<string, ResponseInputValue>>;
   readonly curve: readonly ResponseCurvePoint[];
   readonly points: readonly ResponseSlicePoint[];
+  /** The points that match the held values and have no value of the measure, each with its reason. */
+  readonly absent: readonly ResponseAbsentPoint[];
   readonly error: ResponseHeldOutError;
+  /** The number of places of `curve` with the field `clipped`. */
+  readonly clipped: number;
 }
 /** A measured point of a surface. */
 interface ResponseSurfacePoint {
@@ -422,6 +458,15 @@ interface ResponseSurfacePoint {
   readonly value: number;
   readonly group?: string;
 }
+/** A point of a surface that matches the held values and has no value of the measure. */
+interface ResponseSurfaceAbsentPoint {
+  readonly id: string;
+  /** The values of the two varied dimensions. */
+  readonly at: readonly [ResponseValue, ResponseValue];
+  /** The id of the declared reason. The value `null` means that the point states no reason. */
+  readonly reason: string | null;
+  readonly group?: string;
+}
 /** The fitted surface over two dimensions, and the measured points that match the held values. */
 interface ResponseSurface {
   readonly measure: string;
@@ -433,8 +478,14 @@ interface ResponseSurface {
   /** One row for each value of `y`. Each row has one cell for each value of `x`. */
   readonly cells: readonly (readonly ResponseBand[])[];
   readonly points: readonly ResponseSurfacePoint[];
+  /** The points that match the held values and have no value of the measure, each with its reason. */
+  readonly absent: readonly ResponseSurfaceAbsentPoint[];
   readonly error: ResponseHeldOutError;
+  /** The number of places of `cells` with the field `clipped`. */
+  readonly clipped: number;
 }
+/** This function gives true when a place has the condition of a dimension. A dimension with no condition is present. */
+export declare function whenHolds(dimension: ResponseDimension, values: Readonly<Record<string, unknown>>): boolean;
 /**
  * This function gives the value of a model at `inputs`, on the scale of the measure. The inputs have a value for each
  * dimension that the model reads. An absent conditional dimension has `null`. A table model gives its `fallback` for a
@@ -451,10 +502,24 @@ export declare function predictResponse(model: ResponseModel, inputs: Readonly<R
  * fold has a small effect. The function throws a RangeError when no fold has the measure.
  */
 export declare function heldOutError(record: Pick<ResponseRecord, "folds">, measure: string): ResponseHeldOutError;
+/**
+ * This function gives the held-out error of a chosen set of points, on the scale of the model. It uses the stored
+ * predictions of the option `outOfFold`. Thus a reader can get the error of one cell. The result has the fields of
+ * `heldOutError`, and the set of all the points gives the same values to the rounding of the sums.
+ *
+ * Each point counts at most once. A point with no value of the measure, or with no prediction, adds nothing to `n`.
+ * The baseline of a point is the mean of the training points of its fold.
+ *
+ * The function throws a RangeError for an unknown measure and for a record with no predictions of the measure. It
+ * also throws for an unknown id, for a repeated id, and for a set with no point to score.
+ */
+export declare function heldOutErrorAt(record: ResponseRecord, measure: string, ids: readonly string[]): ResponseHeldOutError;
 /**
  * This function gives a view of a measure over one dimension of a parsed record:
  * - `curve`: the fitted value at each level, or at `steps` values of a continuous dimension, with its band.
  * - `points`: the measured points that match the held values. This list is empty when no point matches them.
+ * - `absent`: the points that match the held values and have no value of the measure, each with its reason. A chart
+ *   can draw each reason apart.
  * - `held`: the value of each other dimension.
  * - `error`: the held-out error.
  *
@@ -473,6 +538,10 @@ export declare function heldOutError(record: Pick<ResponseRecord, "folds">, meas
  * distance is on the log scale of the model, so the band is a ratio. The band has one width along all the curve. The
  * band is the mean error of the model, and `nearest` tells how far the place is from a measurement.
  *
+ * A measure with a `range` keeps each place inside it. The fields `value`, `low` and `high` move to the nearest end.
+ * The place then has the field `clipped`, and the field `clipped` of the view counts these places. The function
+ * `predictResponse` gives the value that the model fitted.
+ *
  * The function throws a RangeError for an unknown measure or dimension, and for a held value that is not good for its
  * dimension. It also throws for a dimension that is both varied and held, and for a bad option.
  */
@@ -484,6 +553,14 @@ export declare function sliceResponse(record: ResponseRecord, measure: string, o
  * It throws when a conditional dimension varies with its parent, and when two varied dimensions need no common level.
  */
 export declare function surfaceResponse(record: ResponseRecord, measure: string, options: ResponseSurfaceOptions): ResponseSurface;
+/**
+ * This function gives the number of fitted places of a view before the view starts: the product of the lengths of its
+ * axes. A level axis counts its levels, and a continuous axis counts `steps`. The field `nearest` reads each point at
+ * each place, so the reads of a view are this count times the number of points. The default of `steps` is the default
+ * of a view. The function throws a RangeError for an unknown dimension, for one dimension named two times, and for a
+ * bad `steps`.
+ */
+export declare function responseCells(record: Pick<ResponseRecord, "dimensions">, vary: string | readonly [string, string], steps?: number): number;
 /** The largest power of a factor. A larger power of a coordinate from -1 to 1 adds almost nothing to a model. */
 export declare const RESPONSE_MAX_POWER = 8;
 /** One fault of a record. */
@@ -515,6 +592,15 @@ type ParsedResponseRecord = {
  * - All the points of a group are in one fold, or all are in no fold. Thus no group is on both sides of a split.
  * - The count `n` of an error is the number of held-out points with a value of the measure.
  * - Each measure has an error in one fold or more.
+ *
+ * These rules apply to the predictions of a fold:
+ * - Each prediction is a finite number of a held-out point of the fold with a value of the measure.
+ * - The fold has a prediction of each such point, and an error of the measure.
+ * - When one fold has predictions of a measure, each fold with an error of the measure has them.
+ *
+ * These rules apply to the reasons of a point:
+ * - Each reason is on a known measure with no number. A measure with `null` and no reason is good.
+ * - Each reason has a declaration in the field `reasons` of the record.
  */
 export declare function parseResponseRecord(value: unknown): ParsedResponseRecord;
 /** The options of `fitResponse`. */
@@ -531,8 +617,11 @@ interface ResponseFitOptions {
    * When true, a ridge fit also has the products of two dimensions, up to `degree`. The default is true. The value
    * false also removes the products of a conditional dimension with the levels of its parent. Thus this option is the
    * way out of the limit `RESPONSE_MAX_TERMS`.
+   *
+   * The value `seen` is the expansion of true, with only the terms that are not 0 at one point or more. Thus a sparse
+   * product of two large sets of levels keeps only the pairs with points. The limit applies after this choice.
    */
-  readonly interactions?: boolean;
+  readonly interactions?: boolean | "seen";
   /** The stated terms of a ridge fit, in place of `degree` and `interactions`. */
   readonly terms?: readonly (readonly ResponseFactor[])[];
   /** The penalties that a ridge fit chooses from, each above 0. The default is `RESPONSE_LAMBDAS`. */
@@ -541,6 +630,11 @@ interface ResponseFitOptions {
   readonly log?: readonly string[];
   /** On a log scale, each smaller value takes this value. With no floor, a value of 0 or less is an error. */
   readonly logFloor?: number;
+  /**
+   * When true, each fold stores the prediction of each held-out point with a value. Then `heldOutErrorAt` gives the error of
+   * a chosen set of points. The default is false, and the record then has no field `predictions`.
+   */
+  readonly outOfFold?: boolean;
 }
 /** The default penalties of a ridge fit. The coordinates are from -1 to 1, so one list suits each record. */
 export declare const RESPONSE_LAMBDAS: readonly number[];
@@ -565,7 +659,10 @@ export declare const RESPONSE_MAX_TERMS = 1024;
  * The penalty: each fold of a ridge fit chooses from `lambdas` with the other folds. Thus the held-out error of a
  * fold is not optimistic. The model of the record chooses with all the folds.
  *
- * The errors: a fold scores the model of the other folds on its held-out points, on the scale of the model.
+ * The errors: a fold scores the model of the other folds on its held-out points, on the scale of the model. With the
+ * option `outOfFold`, the fold also stores the prediction of each of these points.
+ *
+ * The reasons: a measure with a stated reason is `null` for the fit. The field `reasons` of the data stays in the record.
  *
  * The result does not depend on the order of the points, except for the field `points`, which keeps the order of
  * the data. The same data and options give the same bytes in one JavaScript engine.
@@ -796,5 +893,5 @@ interface CalibrationLevel {
 }
 /** The hit rate of each stated level, from the lowest level. */
 export declare function calibration(forecasts: readonly Forecast[]): CalibrationLevel[];
-export type { BootstrapOptions, CalibrationLevel, CategoricalDimension, CompareOptions, Comparison, ContinuousDimension, Corrected, CountInterval, Effect, Forecast, Interval, LeastSquaresFit, LeastSquaresOptions, MedianInterval, NoiseOptions, NoiseState, NoiseVerdict, OrdinalDimension, ParsedResponseRecord, PermutationOptions, PermutationResult, Proportion, QuantileMethod, ResponseBand, ResponseCurvePoint, ResponseData, ResponseDimension, ResponseDimensionBase, ResponseFactor, ResponseFault, ResponseFitOptions, ResponseFold, ResponseFoldError, ResponseHeldOutError, ResponseInputValue, ResponseMeasure, ResponseModel, ResponseModelBase, ResponsePoint, ResponseRecord, ResponseSlice, ResponseSliceOptions, ResponseSlicePoint, ResponseSurface, ResponseSurfaceOptions, ResponseSurfacePoint, ResponseTableCell, ResponseValue, ResponseViewOptions, ResponseWhen, RidgeInput, RidgeInputBase, RidgeLevelInput, RidgeNumberInput, RidgeOptions, RidgeRankInput, RidgeResponseModel, RidgeTerm, Summary, TableResponseModel };
+export type { BootstrapOptions, CalibrationLevel, CategoricalDimension, CompareOptions, Comparison, ContinuousDimension, Corrected, CountInterval, Effect, Forecast, Interval, LeastSquaresFit, LeastSquaresOptions, MedianInterval, NoiseOptions, NoiseState, NoiseVerdict, OrdinalDimension, ParsedResponseRecord, PermutationOptions, PermutationResult, Proportion, QuantileMethod, ResponseAbsentPoint, ResponseBand, ResponseCurvePoint, ResponseData, ResponseDimension, ResponseDimensionBase, ResponseFactor, ResponseFault, ResponseFitOptions, ResponseFold, ResponseFoldError, ResponseHeldOutError, ResponseInputValue, ResponseMeasure, ResponseModel, ResponseModelBase, ResponsePoint, ResponseReason, ResponseRecord, ResponseSlice, ResponseSliceOptions, ResponseSlicePoint, ResponseSurface, ResponseSurfaceAbsentPoint, ResponseSurfaceOptions, ResponseSurfacePoint, ResponseTableCell, ResponseValue, ResponseViewOptions, ResponseWhen, RidgeInput, RidgeInputBase, RidgeLevelInput, RidgeNumberInput, RidgeOptions, RidgeRankInput, RidgeResponseModel, RidgeTerm, Summary, TableResponseModel };
 //# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/describe.ts","../src/regression.ts","../src/bootstrap.ts","../src/ridge.ts","../src/response.ts","../src/response-parse.ts","../src/response-fit.ts","../src/tests.ts","../src/rank.ts","../src/discrete.ts","../src/compare.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/describe.ts","../src/regression.ts","../src/bootstrap.ts","../src/ridge.ts","../src/response.ts","../src/response-parse.ts","../src/response-fit.ts","../src/tests.ts","../src/rank.ts","../src/discrete.ts","../src/compare.ts"],"mappings":"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"}