Custom Weights

Per-observation weights that encode data quality directly into the LOESS fit.

How Custom Weights Work

Standard LOESS assigns equal prior trust to all observations. Custom weights let you override this assumption point by point — before any distance or robustness weighting is applied.

The effective weight of observation $j$ in a local fit centred at $x_i$ is:

$w_{ij} = \text{custom\_weights}[j] \times K\!\left(\frac{d_{ij}}{h_i}\right) \times r_j$

where $K$ is the distance kernel, $h_i$ is the local bandwidth, and $r_j$ is the robustness weight from the current iteration.

custom_weights supplies one finite non-negative prior weight per observation. Batch accepts a vector with fit; Streaming accepts process_chunk_weighted; Online accepts add_point_weighted or add_point_vector_weighted. Streaming preserves weights through overlap buffers, and Online evicts each weight with its observation. Existing unweighted calls use weight 1.0.

When to Use Custom Weights

Situation	Recommended weight
Point known to be erroneous	`0.0` — fully excluded
Unreliable sensor / low precision	`0.1 – 0.5`
Standard observation	`1.0` (default)
Carefully calibrated measurement	`> 1.0`
Measurement uncertainty $\sigma_i$	$1 / \sigma_i^2$

Custom Weights vs. Robustness Iterations

Both mechanisms handle unreliable data, but they serve different purposes:

	Custom Weights	Robustness Iterations
When known	Before fitting	Computed from residuals
Knowledge required	Prior knowledge of quality	None — data-driven
Effect	Fixed throughout fit	Adapts each iteration
Use case	Known bad sensors, calibration	Unknown outlier contamination

They compose: you can use both simultaneously. Custom weights suppress a priori bad points; robustness iterations then handle any residual outliers that remain.

Basic Usage

Suppress a Known Outlier

Set the weight to 0 at the bad point — it is excluded from every local fit that would otherwise include it.

const { Loess } = require('fastloess-wasm');

const n = 100;
const x = Float64Array.from({ length: n }, (_, i) => i * 2 * Math.PI / (n - 1));
const y = Float64Array.from(x, (xi, i) => Math.sin(xi) + (((i * 7 + 3) % 17) / 17 - 0.5) * 0.6);

const weights = new Float64Array(y.length).fill(1);
weights[4] = 0; // Exclude 5th point
const model = new Loess({});
const result = model.fit(x, y, weights);
console.log("y[0]:", result.y[0].toFixed(4));

y[0]: 0.1578

Emphasize Important Points

Assign high weights to measurements you trust most — calibration standards, reference instruments, or low-noise observations.

const { Loess } = require('fastloess-wasm');

const n = 100;
const x = Float64Array.from({ length: n }, (_, i) => i * 2 * Math.PI / (n - 1));
const y = Float64Array.from(x, xi => Math.sin(xi) + 0.1);

const calibrationIndices = [5, 20, 40, 60, 80];
const weights = new Float64Array(x.length).fill(1.0);
for (const i of calibrationIndices) weights[i] = 10.0;

const model = new Loess({ fraction: 0.5 });
const result = model.fit(x, y, weights);
console.log("y[0]:", result.y[0].toFixed(4));

y[0]: 0.3134

Propagate Measurement Uncertainty

If each observation has a known standard deviation $\sigma_i$ , set $w_i = 1 / \sigma_i^2$ to give the fit information-theoretically optimal weighting.

const { Loess } = require('fastloess-wasm');

const n = 100;
const x = Float64Array.from({ length: n }, (_, i) => i * 2 * Math.PI / (n - 1));
const y = Float64Array.from(x, xi => Math.sin(xi) + 0.1);

const sigma = Float64Array.from({ length: n }, (_, i) => 0.1 + (i % 4) * 0.1);
const weights = Float64Array.from(sigma, s => 1.0 / (s * s));
const model = new Loess({ fraction: 0.5 });
const result = model.fit(x, y, weights);
console.log("y[0]:", result.y[0].toFixed(4));

y[0]: 0.3284

Combined with Robustness Iterations

Custom weights and robustness iterations compose naturally: use custom weights for known bad points and robustness for unknown contamination.

const { Loess } = require('fastloess-wasm');

const x = Float64Array.from({ length: 20 }, (_, i) => i);
const y = Float64Array.from({ length: 20 }, (_, i) => i * 1.5);
y[3]  = -50.0;  // known bad
y[12] = 80.0;   // unknown outlier

const weights = new Float64Array(20).fill(1.0);
weights[3] = 0.0;

const model = new Loess({ fraction: 0.4, iterations: 3 });
const result = model.fit(x, y, weights);
console.log("y[0]:", result.y[0].toFixed(4));

y[0]: 0.8674

Validation Rules

Rule	Effect
Length must equal `n`	Error at fit time if mismatched
All values must be ≥ 0	Negative weights are rejected
All-zero weight vector	Error: no points remain for any local fit
Uniform weights (`1.0` everywhere)	Identical result to omitting weights