Error Metric Filter
When producing any time series such as glucose-level prediction or performing a glucose-level control, we need to quantify how well we do - i.e.; how much we differ from a desired data series. With prediction, we need to quantify how much is the prediction different from the referenced, measured glucose levels. With glucose-level control, we need to quantify how much we differ from a desired glucose level, or how much time we spent outside a desired glucose-level range. For such a quantification, we use an error metric.
SmartCGMS offers two filters to compute the metric. First one, Signal Error
filter, accumulates all differences between measured(error-biased) and referenced signals/time series. Then, it uses a post-processing to compute the resulting
metric as precisely as possible. This filter is useful for processing on devices with no memory nor computational constraints. For example, it is good when devising and testing metric, or when computing some statistics about the patient.
To accelerate computationally intensive tasks and/or to conform low-power device constraints, SmartCGMS also provides Fast Signal Error
filter. While this filter provides less functionality and supports only the following metrics, it has minimalistic, constant memory requirements and trades execution speed
for less precision as it uses linear interpolation only. For interpolation, Signal Error
filter uses the IApproximator
to provide more elaborate interpolation, e.g.; Akima spline.
Fast Signal Error
Average plus Standard Deviation
The fast signal error filter does not use the metric entites, but rather reimplements the calculation in its own code. This concept was introduced to speed up the calculations when using commonly used metrics with a simple calculation.
(string) - a string description of the error values; this is displayed in GUI and written to the CSV fileReference_Signal
(GUID) - a GUID of a reference signalError_Signal
(GUID) - a GUID of an error signalMetric
(GUID) - a GUID of a metric to calculateLevels_Required
(integer) - metric parameter - how many levels are required to calculate the metric valueRelative_Error
(boolean) - metric parameter - use relative error instead of absoluteSquared_Diff
(boolean) - metric parameter - use squared differences for metric calculationPrefer_More_Levels
(boolean) - metric parameter - prefer more levels over less, when calculating metric valueError metric
(double) - metric parameter - a threshold for given metric; this is a specific parameter for every metric, may be ignoredEmit_Metric_As_Signal
(boolean) - emit calculated metric value as a signal and send it through the chainEmit_Last_Value_Only
(boolean) - if theEmit_Metric_As_Signal
is set totrue
, this causes the filter to emit just the last value of the metric upon segment end or shutdownOutput_CSV_file
(string) - if set, the filter summarizes the errors into a CSV file; please note, that this option is active even during the parameters optimalization and may potentially slow down the solving processFast error metric
There are no specific configuration parameters for fast error metric filter
(both filters)General function
Both filters shares a similar interface for metric calculation, but differs in a way they do it. The error metric filter favors calculation and structured approach, the fast error metric filter favors performance and constant memory requirements.
The error metric filter instantiates a metric entity. When a pair of matching signals (reference and error) comes through the chain, it calls the Accumulate
method of the metric object
to accumulate the differences between the signals.
The filter can be configured to emit the metric value as a signal by the Emit_Metric_As_Signal
parameter. If set, every metric value calculated will be send through the filter chain as a level device event with the
signal ID. Optionally, sending just the last value might be requested using the Emit_Last_Value_Only
parameter - if set to true
, the metric value is send through
the chain upon receiving a Time_Segment_End
device event. In the former case, just the single segment metric value is sent. The latter case finalizes all segments and sends their respective
metric values through the chain as separate device events.
Fast error metric
The fast signal error metric filter on the other hand does not initialize a metric entity. It shares the metric configuration to reimplement parts of the calculation in its own code. The configured Metric
GUID is used
to select the internal reimplementation of the selected metric.
Additionally, this filter does not store all the differences, but compresses them in a single value, depending on the selected metric. For example, stream calculation of an average difference metric is perfectly possible without the knowledge of all prior differences.
This filter does not support all the implemented metrics, as stated above. It sacrifices the generalization in favor of performance and constant memory requirements.