Project: VictoriaMetrics (Observability and Analysis / Observability)
File: models.md

title: Models weight: 1 sort: 1 menu: docs: identifier: "vmanomaly-models" parent: "vmanomaly-components" weight: 1 aliases: /anomaly-detection/components/models.html /anomaly-detection/components/models/custom_model.html /anomaly-detection/components/models/models.html This section describes `Models` component of VictoriaMetrics Anomaly Detection (or simply ) and the guide of how to define a respective section of a config to launch the service. `vmanomaly` includes various . you can also integrate your custom model - see . Note: Starting from model section in config supports multiple models via aliasing. <br>Also, `vmanomaly` expects model section to be named `models`. Using old (flat) format with `model` key is deprecated and will be removed in future versions. Having `model` and `models` sections simultaneously in a config will result in only `models` being used: ```yaml models: modelunivariate1: class: 'model.zscore.ZscoreModel' z_threshold: 2.5 queries: ['query_alias2'] # referencing queries defined in `reader` section modelmultivariate1: class: 'model.isolation_forest.IsolationForestMultivariateModel' contamination: 'auto' args: n_estimators: 100 random_state: 42 ``` Old-style configs (< ) ```yaml model: class: "model.zscore.ZscoreModel" z_threshold: 3.0 ``` will be implicitly converted to ```yaml models: default_model: # default model alias, backward compatibility class: "model.zscore.ZscoreModel" z_threshold: 3.0 queries: ['q1', 'q2', 'q3'] # i.e., if your `queries` in `reader` section has exactly q1, q2, q3 aliases ``` From , common args, supported by every model (and model type) were introduced. Introduced in , as a part to support multi-model configs, `queries` arg is meant to define particular model should be run on (meaning, all the series returned by each of these queries will be used in such model for fitting and inferencing). `queries` arg is supported for all (as well as for ) models. This arg is backward compatible - if there is no explicit `queries` arg, then the model, defined in a config, will be run on ALL queries found in reader section: ```yaml models: modelalias1: ``` will be implicitly converted to ```yaml models: modelalias1: queries: ['q1', 'q2', 'q3'] # i.e., if your `queries` in `reader` section has exactly q1, q2, q3 aliases ``` Introduced in , as a part to support multi-scheduler configs, `schedulers` arg is meant to define particular model should be attached to. `schedulers` arg is supported for all (as well as for ) models. This arg is backward compatible - if there is no explicit `schedulers` arg, then the model, defined in a config, will be attached to ALL the schedulers found in scheduler section: ```yaml models: modelalias1: ``` will be implicitly converted to ```yaml models: modelalias1: schedulers: ['s1', 's2', 's3'] # i.e., if your `schedulers` section has exactly s1, s2, s3 aliases ``` Introduced in , `provideseries` arg limit the by `vmanomaly` for writing. I.e. if the model produces default output series `['anomalyscore', 'yhat', 'yhatlower', 'yhatupper']` by specifying `provideseries` section as below, you limit the data being written to only `['anomalyscore']` for each metric received as a subject to anomaly detection. ```yaml models: modelalias1: provideseries: ['anomalyscore'] # only `anomaly_score` metric will be available for writing back to the database ``` Note If `provideseries` is not specified in model config, the model will produce its default . The output can't be less than `['anomalyscore']`. Even if `timestamp` column is ommitted, it will be implicitly added to `provide_series` list, as it's required for metrics to be properly written. There are 2 model types, supported in `vmanomaly`, resulting in 4 possible combinations: Each of these models can be For a univariate type, one separate model is fit/used for inference per each time series, defined in its arg. For example, if you have some univariate model, defined to use 3 , each returning 5 time series, there will be 35=15 models created in

Each such model produce individual * for each of time series. If during an inference, you got a series having new labelset (not present in any of fitted models), the inference will be skipped until you get a model, trained particularly for such labelset during forthcoming re-fit step. Implications: Univariate models are a go-to default, when your queries returns changing amount of individual time series of different magnitude, or , so you won't be mixing incompatible data with different behavior within a single fit model (context isolation). Examples: , <p></p> <img alt="vmanomaly-model-type-univatiate" src="/anomaly-detection/components/model-lifecycle-univariate.webp" width="800px"/> For a multivariate type, one shared model is fit/used for inference on all time series simultaneously, defined in its arg. For example, if you have some multivariate model to use 3 , each returning 5 time series, there will be one shared model created in total. Once fit, this model will expect exactly 15 time series with exact same labelsets as an input. This model will produce one shared . If during an inference, you got a different amount of series or some series having a new labelset (not present in any of fitted models), the inference will be skipped until you get a model, trained particularly for such labelset during forthcoming re-fit step. Implications: Multivariate models are a go-to default, when your queries returns fixed amount of individual time series (say, some aggregations), to be used for adding cross-series (and cross-query) context, useful for catching or (expanded to multi-input scenario). For example, you may set it up for anomaly detection of CPU usage in different modes (`idle`, `user`, `system`, etc.) and use its cross-dependencies to detect unseen (in fit data) behavior. Examples: <p></p> <img alt="vmanomaly-model-type-multivariate" src="/anomaly-detection/components/model-lifecycle-multivariate.webp" width="800px"/> A rolling model is a model that, once trained, cannot be (naturally) used to make inference on data, not seen during its fit phase. An instance of rolling model is simultaneously fit and used for inference during its `infer` method call. As a result, such model instances are not stored between consecutive re-fit calls (defined by `fit_every` in `PeriodicScheduler`), leading to lower RAM consumption. Such models put more pressure on your reader's source, i.e. if your model should be fit on large amount of data (say, 14 days with 1-minute resolution) and at the same time you have frequent inference (say, once per minute) on new chunks of data - that's because such models require (fit + infer) window of data to be fit first to be used later in each inference call. Note: Rolling models require `fitevery` to be set equal to `inferevery` in your . Examples: <p></p> <img alt="vmanomaly-model-type-rolling" src="/anomaly-detection/components/model-type-rolling.webp" width="800px"/> Everything that is not classified as . Produced models can be explicitly used to infer on data, not seen during its fit phase, thus, it doesn't require re-fit procedure. Such models put less pressure on your reader's source, i.e. if you fit on large amount of data (say, 14 days with 1-minute resolution) but do it occasionally (say, once per day), at the same time you have frequent inference(say, once per minute) on new chunks of data Note: However, it's still highly recommended, to keep your model up-to-date with tendencies found in your data as it evolves in time. Produced model instances are stored in-memory between consecutive re-fit calls (defined by `fit_every` in `PeriodicScheduler`), leading to higher RAM consumption. Examples: <p></p> <img alt="vmanomaly-model-type-non-rolling" src="/anomaly-detection/components/model-type-non-rolling.webp" width="800px"/> VM Anomaly Detection (`vmanomaly` hereinafter) models support 2 groups of parameters: `vmanomaly`-specific arguments - please refer to Parameters specific for vmanomaly and Default model parameters subsections for each of the models

Arguments to inner model (say, ), passed in a `args` argument as key-value pairs, that will be directly given to the model during initialization to allow granular control. Optional. Note: For users who may not be familiar with Python data types such as `list in Python is a data structure that stores data values in key-value pairs. This structure allows for efficient data retrieval and management. Models: - designed to take the cognitive load off the user, allowing any of built-in models below to be re-tuned for best params on data seen during each `fit` phase of the algorithm. Tradeoff is between increased computational time and optimized results / simpler maintenance. - the most versatile one for production usage, especially for complex data (, , ) - useful for testing and for simpler data ( data without strict and with anomalies of similar magnitude as your "normal" data) well-suited for data with moderate complexity*, exhibiting distinct and/or . similarly to Z-score, is effective for identifying outliers in relatively consistent data* (useful for detecting sudden, stark deviations from the median) best for data with evolving patterns*, as it adapts to changes over a rolling window. similarly to Holt-Winters, is best for data with pronounced and components* useful for metrics data interaction (several queries/metrics -> single anomaly score) and efficient in detecting anomalies in high-dimensional datasets* benefit from your own models and expertise to better support your unique use case*. Tuning hyperparameters of a model can be tricky and often requires in-depth knowledge of Machine Learning. `AutoTunedModel` is designed specifically to take the cognitive load off the user - specify as little as `anomalypercentage` param from `(0, 0.5)` interval and `tunedmodel_class` (i.e. ) to get it working with best settings that match your data. Parameters specific for vmanomaly: `class` (string) - model class name `"model.auto.AutoTunedModel"` `tunedclassname` (string) - Built-in model class to tune, i.e. `model.zscore.ZscoreModel`. `optimizationparams` (dict) - Optimization parameters for unsupervised model tuning. Control % of found anomalies, as well as a tradeoff between time spent and the accuracy. The more `timeout` and `ntrials` are, the better model configuration can be found for `tunedclassname`, but the longer it takes and vice versa. Set `n_jobs` to `-1` to use all the CPUs available, it makes sense if only you have a big dataset to train on during `fit` calls, otherwise overhead isn't worth it. `anomaly_percentage` (float) - expected percentage of anomalies that can be seen in training data, from (0, 0.5) interval. `seed` (int) - Random seed for reproducibility and deterministic nature of underlying optimizations. `n_splits` (int) - How many folds to create for hyperparameter tuning out of your data. The higher, the longer it takes but the better the results can be. Defaults to 3. `n_trials` (int) - How many trials to sample from hyperparameter search space. The higher, the longer it takes but the better the results can be. Defaults to 128. `timeout` (float) - How many seconds in total can be spent on each model to tune hyperparameters. The higher, the longer it takes, allowing to test more trials out of defined `n_trials`, but the better the results can be. <img alt="vmanomaly-autotune-schema" src="/anomaly-detection/components/autotune.webp" width="800px"/> ```yaml models: yourdesiredaliasfora_model: class: 'model.auto.AutoTunedModel' tunedclassname: 'model.zscore.ZscoreModel' optimization_params: anomaly_percentage: 0.004 # required. i.e. we expect <= 0.4% of anomalies to be present in training data seed: 42 # fix reproducibility & determinism n_splits: 4 # how much folds are created for internal cross-validation n_trials: 128 # how many configurations to sample from search space during optimization timeout:

# how many seconds to spend on optimization for each trained model during `fit` phase call n_jobs: 1 # how many jobs in parallel to launch. Consider making it > 1 only if you have fit window containing > 10000 datapoints for each series ``` Note: Autotune can't be made on your . Also, it can't be applied to itself (like `tunedclassname: 'model.auto.AutoTunedModel'`) Here we utilize the Facebook Prophet implementation, as detailed in their . All parameters from this library are compatible and can be passed to the model. Parameters specific for vmanomaly: `class` (string) - model class name `"model.prophet.ProphetModel"` `seasonalities` (list Prophet param. Note: Apart from standard `vmanomaly` output, Prophet model can provide . Additional output metrics produced by FB Prophet Depending on chosen `seasonality` parameter FB Prophet can return additional metrics such as: `trend`, `trendlower`, `trendupper` `additiveterms`, `additivetermslower`, `additiveterms_upper`, `multiplicativeterms`, `multiplicativetermslower`, `multiplicativeterms_upper`, `daily`, `dailylower`, `dailyupper`, `hourly`, `hourlylower`, `hourlyupper`, `holidays`, `holidayslower`, `holidaysupper`, and a number of columns for each holiday if `holidays` param is set Config Example ```yaml models: yourdesiredaliasfora_model: class: 'model.prophet.ProphetModel' provideseries: ['anomalyscore', 'yhat', 'yhatlower', 'yhatupper', 'trend'] seasonalities: name: 'hourly' period: 0.04166666666 fourier_order: 30 args: interval_width: 0.98 country_holidays: 'US' ``` Resulting metrics of the model are described Parameters specific for vmanomaly: `class` (string) - model class name `"model.zscore.ZscoreModel"` `z_threshold` (float, optional) - for calculation boundaries and anomaly score. Defaults to `2.5`. Config Example ```yaml models: yourdesiredaliasfora_model: class: "model.zscore.ZscoreModel" z_threshold: 2.5 ``` Resulting metrics of the model are described . Here we use Holt-Winters Exponential Smoothing implementation from `statsmodels` . All parameters from this library can be passed to the model. Parameters specific for vmanomaly: `class` (string) - model class name `"model.holtwinters.HoltWinters"` `frequency` (string) - Must be set equal to sampling_period. Model needs to know expected data-points frequency (e.g. '10m'). If omitted, frequency is guessed during fitting as the median of intervals between fitting data timestamps*. During inference, if incoming data doesn't have the same frequency, then it will be interpolated. E.g. data comes at 15 seconds resolution, and our resample_freq is '1m'. Then fitting data will be downsampled to '1m' and internal model is trained at '1m' intervals. So, during inference, prediction data would be produced at '1m' intervals, but interpolated to "15s" to match with expected output, as output data must have the same timestamps. As accepted by pandas.Timedelta (e.g. '5m'). `seasonality` (string, optional) - As accepted by pandas.Timedelta. If `seasonal_periods` is not specified, it is calculated as `seasonality` / `frequency` Used to compute "seasonal_periods" param for the model (e.g. '1D' or '1W'). `z_threshold` (float, optional) - for calculating boundaries to define anomaly score. Defaults to 2.5. Default model parameters: If `seasonal` is not specified, default value will be `add`. If `initialization_method` is not specified, default value will be `estimated`. `args` (dict, optional) - Inner model args (key-value pairs). See accepted params in . Defaults to empty (not provided). Example: {"seasonal": "add", "initialization_method": "estimated"} Config Example ```yaml models: yourdesiredaliasfora_model: class: "model.holtwinters.HoltWinters" seasonality: '1d' frequency: '1h' args: seasonal: 'add' initialization_method: 'estimated' ``` Resulting metrics of the model are described . The MAD model is a robust method for anomaly detection that is less sensitive to outliers in data compared to standard deviation-based models. It considers a point as an anomaly if the absolute deviation from the median is significantly large. Parameters specific for vmanomaly: `class` (string) - model class name `"model.mad.MADModel"` `threshold` (float, optional) - The threshold multiplier for the MAD to determine anomalies. Defaults to `2.5`. Higher values will identify fewer points as anomalies. Config Example ```yaml models: yourdesiredaliasfora_model: class: "model.mad.MADModel" threshold: 2.5 ``` Resulting metrics of the model are described

Parameters specific for vmanomaly: `class` (string) - model class name `"model.rolling_quantile.RollingQuantileModel"` `quantile` (float) - quantile value, from 0.5 to 1.0. This constraint is implied by 2-sided confidence interval. `windowsteps` (integer) - size of the moving window. (see 'samplingperiod') Config Example ```yaml models: yourdesiredaliasfora_model: class: "model.rolling_quantile.RollingQuantileModel" quantile: 0.9 window_steps: 96 ``` Resulting metrics of the model are described . Here we use Seasonal Decompose implementation from `statsmodels` . Parameters from this library can be passed to the model. Some parameters are specifically predefined in `vmanomaly` and can't be changed by user(`model`='additive', `two_sided`=False). Parameters specific for vmanomaly: `class` (string) - model class name `"model.std.StdModel"` `period` (integer) - Number of datapoints in one season. `z_threshold` (float, optional) - for calculating boundaries to define anomaly score. Defaults to `2.5`. Config Example ```yaml models: yourdesiredaliasfora_model: class: "model.std.StdModel" period: 2 ``` Resulting metrics of the model are described . Additional output metrics produced by Seasonal Trend Decomposition model `resid` - The residual component of the data series. `trend` - The trend component of the data series. `seasonal` - The seasonal component of the data series. Detects anomalies using binary trees. The algorithm has a linear time complexity and a low memory requirement, which works well with high-volume data. It can be used on both univatiate and multivariate data, but it is more effective in multivariate case. Important: Be aware of . Don't use single multivariate model if you expect your queries to return many time series of less datapoints that the number of metrics. In such case it is hard for a model to learn meaningful dependencies from too sparse data hypercube. Here we use Isolation Forest implementation from `scikit-learn` . All parameters from this library can be passed to the model. Parameters specific for vmanomaly: `class` (string) - model class name `"model.isolation_forest.IsolationForestMultivariateModel"` `contamination` (float or string, optional) - The amount of contamination of the data set, i.e. the proportion of outliers in the data set. Used when fitting to define the threshold on the scores of the samples. Default value - "auto". Should be either `"auto"` or be in the range (0.0, 0.5]. `seasonal_features` (list of string) - List of seasonality to encode through , i.e. `dow` (day of week). Introduced in *. Empty by default for backward compatibility. Example: `seasonal_features: ['dow', 'hod']`. Supported seasonalities: "minute" - minute of hour (0-59) "hod" - hour of day (0-23) "dow" - day of week (1-7) "month" - month of year (1-12) `args` (dict, optional) - Inner model args (key-value pairs). See accepted params in . Defaults to empty (not provided). Example: {"randomstate": 42, "nestimators": 100} Config Example ```yaml models: yourdesiredaliasfora_model: class: "model.isolation_forest.IsolationForestMultivariateModel" contamination: "0.01" provideseries: ['anomalyscore'] seasonal_features: ['dow', 'hod'] args: n_estimators: 100 random_state: 42 ``` Resulting metrics of the model are described . When `vmanomaly` is executed, it generates various metrics, the specifics of which depend on the model employed. These metrics can be renamed in the writer's section. The default metrics produced by `vmanomaly` include: `anomaly_score`: This is the primary metric. It is designed in such a way that values from 0.0 to 1.0 indicate non-anomalous data. A value greater than 1.0 is generally classified as an anomaly, although this threshold can be adjusted in the alerting configuration. The decision to set the changepoint at 1 was made to ensure consistency across various models and alerting configurations, such that a score above 1 consistently signifies an anomaly. `yhat`: This represents the predicted expected value. `yhat_lower`: This indicates the predicted lower boundary. `yhat_upper`: This refers to the predicted upper

`y`: This is the original value obtained from the query result. Important: Be aware that if `NaN` (Not a Number) or `Inf` (Infinity) values are present in the input data during `infer` model calls, the model will produce `NaN` as the `anomaly_score` for these particular instances. Each model exposes to its `health_path` endpoint: Apart from `vmanomaly` , users can create their own custom models for anomaly detection. Here in this guide, we will Make a file containing our custom model definition Define VictoriaMetrics Anomaly Detection config file to use our custom model Run service Note: The file containing the model should be written in (3.11+) Note: By default, each custom model is created as / model. If you want to override this behavior, define models inherited from `RollingModel` (to get a rolling model), or having `is_multivariate` class arg set to `True` (please refer to the code example below). We'll create `custom_model.py` file with `CustomModel` class that will inherit from `vmanomaly`'s `Model` base class. In the `CustomModel` class there should be three required methods - `init`, `fit` and `infer`: `init` method should initiate parameters for the model. Note: if your model relies on configs that have `arg` , do not forget to use Python's `kwargs` in method's signature and to explicitly call ```python super().init(kwargs) ``` to initialize the base class each model derives from `fit` method should contain the model training process. Please be aware that for `RollingModel` defining `fit` method is not needed, as the whole fit/infer process should be defined completely in `infer` method. `infer` should return Pandas.DataFrame object with model's inferences. For the sake of simplicity, the model in this example will return one of two values of `anomaly_score` - 0 or 1 depending on input parameter `percentage`. ```python import numpy as np import pandas as pd import scipy.stats as st import logging from model.model import Model logger = logging.getLogger(name) class CustomModel(Model): """ Custom model implementation. """ def init(self, percentage: float = 0.95, kwargs): super().init(kwargs) self.percentage = percentage self._mean = np.nan self._std = np.nan def fit(self, df: pd.DataFrame): y = df['y'] self._mean = np.mean(y) self._std = np.std(y) if self._std == 0.0: self._std = 1 / 65536 def infer(self, df: pd.DataFrame) -> np.array: y = df['y'] zscores = (y - self.mean) / self.std anomalyscorecdf = st.norm.cdf(np.abs(zscores)) df_pred = df[['timestamp', 'y']].copy() dfpred['anomalyscore'] = anomalyscorecdf > self.percentage dfpred['anomalyscore'] = dfpred['anomalyscore'].astype('int32', errors='ignore') return df_pred ``` Next, we need to create `config.yaml` file with `vmanomaly` configuration and model input parameters. In the config file's `models` section we need to put our model class `model.custom.CustomModel` and all parameters used in `init` method. You can find out more about configuration parameters in `vmanomaly` . ```yaml schedulers: s1: infer_every: "1m" fit_every: "1m" fit_window: "1d" models: custom_model: class: "model.model.CustomModel" percentage: 0.9 reader: datasource_url: "http://localhost:8428/" queries: ingestionrate: 'sum(rate(vmrowsinsertedtotal)) by (type)' churnrate: 'sum(rate(vmnewtimeseriescreated_total[5m]))' writer: datasource_url: "http://localhost:8428/" metric_format: name: "custom_$VAR" for: "$QUERY_KEY" run: "test-format" monitoring: pull: port: 8080 push: url: "http://localhost:8428/" extra_labels: job: "vmanomaly-develop" config: "custom.yaml" ``` Let's pull the docker image for `vmanomaly`: ```sh docker pull victoriametrics/vmanomaly:latest ``` Now we can run the docker container putting as volumes both config and model file: Note: place the model file to `/model/custom.py` path when copying ```sh docker run -it \ --net [YOUR_NETWORK] \ -v [YOURLICENSEFILE_PATH]:/license.txt \ -v $(PWD)/custom_model.py:/vmanomaly/src/model/custom.py \ -v $(PWD)/custom.yaml:/config.yaml \ victoriametrics/vmanomaly:latest /config.yaml \ --license-file=/license.txt ``` Please find more detailed instructions (license, etc.) As the result, this model will return metric with labels, configured previously in `config.yaml`. In this particular example, 2 metrics will be produced. Also, there will be added other metrics from input query result. ```text {name="customanomalyscore", for="ingestionrate", modelalias="custommodel", scheduleralias="s1", run="test-format"}, {name="customanomalyscore", for="churnrate", modelalias="custommodel", scheduleralias="s1", run="test-format"} ```