GitPlanet

Cheap and reliable Node.js hosting starts at $3/month, and $1/month static HTML hosting

Created with love in Canada, visit hostnodejs.com today

Feel like to post an Ad? Learn Details
All Projects → ankane → khiva-ruby

ankane / khiva-ruby

Licence: MPL-2.0 License
High-performance time series algorithms for Ruby

Programming Languages

ruby
36898 projects - #4 most used programming language
python
139335 projects - #7 most used programming language

Labels

time-seriesstompanomaly-detectionmatrix-profile

Projects that are alternatives of or similar to khiva-ruby

Pyodds
An End-to-end Outlier Detection System
Stars: ✭ 141 (+422.22%)
Mutual labels:  time-series, anomaly-detection
Taganomaly
Anomaly detection analysis and labeling tool, specifically for multiple time series (one time series per category)
Stars: ✭ 200 (+640.74%)
Mutual labels:  time-series, anomaly-detection
Matrixprofile
A Python 3 library making time series data mining tasks, utilizing matrix profile algorithms, accessible to everyone.
Stars: ✭ 141 (+422.22%)
Mutual labels:  time-series, anomaly-detection
Rnn Time Series Anomaly Detection
RNN based Time-series Anomaly detector model implemented in Pytorch.
Stars: ✭ 718 (+2559.26%)
Mutual labels:  time-series, anomaly-detection
singular-spectrum-transformation
fast implementation of singular spectrum transformation (change point detection algorithm)
Stars: ✭ 41 (+51.85%)
Mutual labels:  time-series, anomaly-detection
Getting Things Done With Pytorch
Jupyter Notebook tutorials on solving real-world problems with Machine Learning & Deep Learning using PyTorch. Topics: Face detection with Detectron 2, Time Series anomaly detection with LSTM Autoencoders, Object Detection with YOLO v5, Build your first Neural Network, Time Series forecasting for Coronavirus daily cases, Sentiment Analysis with BERT.
Stars: ✭ 738 (+2633.33%)
Mutual labels:  time-series, anomaly-detection
Lstm anomaly thesis
Anomaly detection for temporal data using LSTMs
Stars: ✭ 178 (+559.26%)
Mutual labels:  time-series, anomaly-detection
Deepadots
Repository of the paper "A Systematic Evaluation of Deep Anomaly Detection Methods for Time Series".
Stars: ✭ 335 (+1140.74%)
Mutual labels:  time-series, anomaly-detection
tsmp
R Functions implementing UCR Matrix Profile Algorithm
Stars: ✭ 63 (+133.33%)
Mutual labels:  time-series, matrix-profile
Matrix-Profile
A Java library for Matrix Profile
Stars: ✭ 14 (-48.15%)
Mutual labels:  time-series, matrix-profile
Ad examples
A collection of anomaly detection methods (iid/point-based, graph and time series) including active learning for anomaly detection/discovery, bayesian rule-mining, description for diversity/explanation/interpretability. Analysis of incorporating label feedback with ensemble and tree-based detectors. Includes adversarial attacks with Graph Convolutional Network.
Stars: ✭ 641 (+2274.07%)
Mutual labels:  time-series, anomaly-detection
mvts-ano-eval
A repository for code accompanying the manuscript 'An Evaluation of Anomaly Detection and Diagnosis in Multivariate Time Series' (published at TNNLS)
Stars: ✭ 26 (-3.7%)
Mutual labels:  time-series, anomaly-detection
Adtk
A Python toolkit for rule-based/unsupervised anomaly detection in time series
Stars: ✭ 615 (+2177.78%)
Mutual labels:  time-series, anomaly-detection
Awesome Ts Anomaly Detection
List of tools & datasets for anomaly detection on time-series data.
Stars: ✭ 2,027 (+7407.41%)
Mutual labels:  time-series, anomaly-detection
Telemanom
A framework for using LSTMs to detect anomalies in multivariate time series data. Includes spacecraft anomaly data and experiments from the Mars Science Laboratory and SMAP missions.
Stars: ✭ 589 (+2081.48%)
Mutual labels:  time-series, anomaly-detection
Adaptive Alerting
Anomaly detection for streaming time series, featuring automated model selection.
Stars: ✭ 152 (+462.96%)
Mutual labels:  time-series, anomaly-detection
Anomalize
Tidy anomaly detection
Stars: ✭ 263 (+874.07%)
Mutual labels:  time-series, anomaly-detection
Luminaire
Luminaire is a python package that provides ML driven solutions for monitoring time series data.
Stars: ✭ 316 (+1070.37%)
Mutual labels:  time-series, anomaly-detection
msda
Library for multi-dimensional, multi-sensor, uni/multivariate time series data analysis, unsupervised feature selection, unsupervised deep anomaly detection, and prototype of explainable AI for anomaly detector
Stars: ✭ 80 (+196.3%)
Mutual labels:  time-series, anomaly-detection
awesome-time-series
Resources for working with time series and sequence data
Stars: ✭ 178 (+559.26%)
Mutual labels:  time-series, anomaly-detection
View All Similar Projects ➔

Khiva Ruby

Khiva - high-performance time series algorithms - for Ruby

🔥 Runs on GPUs (even on Mac) and CPUs

Build Status

Installation

First, install Khiva. For Homebrew, use:

brew install khiva

Add this line to your application’s Gemfile:

gem 'khiva'

Getting Started

Calculate the matrix profile between two time series

a = Khiva::Array.new([11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11], type: :f32)
b = Khiva::Array.new([9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 9], type: :f32)
m = 3 # subsequence length
profile, index = Khiva::Matrix.stomp(a, b, m)

Find motifs (repeated patterns)

n = 2 # number of motifs to extract
distances, indices, subsequences = Khiva::Matrix.find_best_n_motifs(profile, index, m, n)

Find discords (anomalies)

n = 2 # number of discords to extract
distances, indices, subsequences = Khiva::Matrix.find_best_n_discords(profile, index, m, n)

Examples

Anomaly Detection

Detect anomalies in a time series

# generate a random time series with anomalies from position 100-109
series = 1000.times.map { |i| i >= 100 && i <= 109 ? 0.5 : rand }

# calculate the matrix profile with subsequence length 10
a = Khiva::Array.new(series, type: :f32)
m = 10
profile, index = Khiva::Matrix.stomp_self_join(a, m)

# find and print the position of the most anomalous subsequence
_, _, subsequences = Khiva::Matrix.find_best_n_discords(profile, index, m, 1)
pos = subsequences.to_a.first
p pos

Use matplotlib.rb for visualization

require "matplotlib/pyplot"
plt = Matplotlib::Pyplot

# series
plt.figure(0)
plt.title("Series")
plt.plot(series)

# matrix profile
plt.figure(1)
plt.title("Matrix Profile")
plt.plot(profile.to_a)

# most anomalous subsequence and its closest subsequence
plt.figure(2)
plt.title("Subsequences")
plt.plot(series[pos, m], label: "Anomalous")
plt.plot(series[index.to_a[pos], m], label: "Closest")
plt.legend

Similarity Search

Find a similar pattern in time series

series = [1, 1, 1, 3, 4, 1, 1, 1, 1]
query = [1, 2, 3]

s = Khiva::Array.new(series, type: :f32)
q = Khiva::Array.new(query, type: :f32)
_, indices = Khiva::Matrix.find_best_n_occurrences(q, s, 1)
pos = indices.to_a.first
similar_subsequence = series[pos, query.size] # [1, 3, 4]

Modules

Array

Create an array from a Ruby array

Khiva::Array.new([1, 2, 3])

Specify the type - :b8, :f32, :f64, :s16, :s32, :s64, :u8, :u16, :u32, :u64

Khiva::Array.new([1, 2, 3], type: :s64)

Get the type and dimensions

a.type
a.dims

Perform operations on arrays

a + b
a - b
a * b
a / b
a % b
a ** b

Compare arrays

a.eq(b)
a.ne(b)
a.lt(b)
a.gt(b)
a.le(b)
a.ge(b)

Clustering

k-means algorithm

centroids, labels = Khiva::Clustering.k_means(tss, k)

k-Shape algorithm

centroids, labels = Khiva::Clustering.k_shape(tss, k)

Dimensionality

Piecewise Aggregate Approximation (PAA)

Khiva::Dimensionality.paa(a, bins)

Perceptually Important Points (PIP)

Khiva::Dimensionality.pip(a, number_ips)

Piecewise Linear Approximation (PLA Bottom Up)

Khiva::Dimensionality.pla_bottom_up(a, max_error)

Piecewise Linear Approximation (PLA Sliding Window)

Khiva::Dimensionality.pla_sliding_window(a, max_error)

Ramer-Douglas-Peucker (RDP)

Khiva::Dimensionality.ramer_douglas_peucker(a, epsilon)

Symbolic Aggregate ApproXimation (SAX)

Khiva::Dimensionality.sax(a, alphabet_size)

Visvalingam

Khiva::Dimensionality.visvalingam(a, num_points)

Distances

Dynamic time warping (DTW) distance

Khiva::Distances.dtw(tss)

Euclidean distance

Khiva::Distances.euclidean(tss)

Hamming distance

Khiva::Distances.hamming(tss)

Manhattan distance

Khiva::Distances.manhattan(tss)

Shape-based distance (SBD)

Khiva::Distances.sbd(tss)

Squared Euclidean distance

Khiva::Distances.squared_euclidean(tss)

Features

Sum of square values

Khiva::Features.abs_energy(tss)

Absolute sum of changes

Khiva::Features.absolute_sum_of_changes(tss)

Aggregated autocorrelation

Khiva::Features.aggregated_autocorrelation(tss, aggregation_function)

Approximate entropy

Khiva::Features.approximate_entropy(tss, m, r)

Autocorrelation

Khiva::Features.auto_correlation(tss, max_lag, unbiased)

Auto-covariance

Khiva::Features.auto_covariance(tss, unbiased: false)

Binned entropy

Khiva::Features.binned_entropy(tss, max_bins)

Schreiber, T. and Schmitz, A. (1997) measure of non-linearity

Khiva::Features.c3(tss, lag)

Estimate of complexity defined by Batista, Gustavo EAPA, et al (2014)

Khiva::Features.cid_ce(tss, z_normalize)

Number of values above the mean

Khiva::Features.count_above_mean(tss)

Number of values below the mean

Khiva::Features.count_below_mean(tss)

Cross-correlation

Khiva::Features.cross_correlation(xss, yss, unbiased)

Cross-covariance

Khiva::Features.cross_covariance(xss, yss, unbiased)

Energy ratio by chunks

Khiva::Features.energy_ratio_by_chunks(arr, num_segments, segment_focus)

The spectral centroid (mean), variance, skew, and kurtosis of the absolute fourier transform spectrum

Khiva::Features.fft_aggregated(tss)

First location of the maximum value

Khiva::Features.first_location_of_maximum(tss)

First location of the minimum value

Khiva::Features.first_location_of_minimum(tss)

Maximum is duplicated

Khiva::Features.has_duplicate_max(tss)

Minimum is duplicated

Khiva::Features.has_duplicate_min(tss)

Any elements are duplicated

Khiva::Features.has_duplicates(tss)

Index of the mass quantile

Khiva::Features.index_mass_quantile(tss, q)

Kurtosis

Khiva::Features.kurtosis(tss)

Standard deviation above threshold

Khiva::Features.large_standard_deviation(tss, r)

Last location of the maximum value

Khiva::Features.last_location_of_maximum(tss)

Last location of the minimum value

Khiva::Features.last_location_of_minimum(tss)

Length of the series

Khiva::Features.length(tss)

Local maximals

Khiva::Features.local_maximals(tss)

Length of the longest consecutive subsequence above the mean

Khiva::Features.longest_strike_above_mean(tss)

Length of the longest consecutive subsequence below the mean

Khiva::Features.longest_strike_below_mean(tss)

Maximum

Khiva::Features.maximum(tss)

Mean

Khiva::Features.mean(tss)

Mean absolute change

Khiva::Features.mean_absolute_change(tss)

Mean change

Khiva::Features.mean_change(tss)

Mean of a central approximation of the second derivative

Khiva::Features.mean_second_derivative_central(tss)

Median

Khiva::Features.median(tss)

Minimum

Khiva::Features.minimum(tss)

Number of m-crossings

Khiva::Features.number_crossing_m(tss, m)

Number of peaks of at least support n

Khiva::Features.number_peaks(tss, n)

Partial autocorrelation

Khiva::Features.partial_autocorrelation(tss, lags)

Percentage of unique values present more than once

Khiva::Features.percentage_of_reoccurring_datapoints_to_all_datapoints(tss, sorted)

Percentage of values present more than once

Khiva::Features.percentage_of_reoccurring_values_to_all_values(tss, sorted)

Quantile

Khiva::Features.quantile(tss, q, precision: 100000000)

Count of values within the interval [min, max]

Khiva::Features.range_count(tss, min, max)

Ratio of values more than r sigma away from the mean

Khiva::Features.ratio_beyond_r_sigma(tss, coeff)

Ratio of unique values

Khiva::Features.ratio_value_number_to_time_series_length(tss)

Sample entropy

Khiva::Features.sample_entropy(tss)

Skewness

Khiva::Features.skewness(tss)

Cross power spectral density at different frequencies

Khiva::Features.spkt_welch_density(tss, coeff)

Standard deviation

Khiva::Features.standard_deviation(tss)

Sum of all data points present more than once

Khiva::Features.sum_of_reoccurring_datapoints(tss, sorted: false)

Sum of all values present more than once

Khiva::Features.sum_of_reoccurring_values(tss, sorted: false)

Sum of values

Khiva::Features.sum_values(tss)

If looks symmetric

Khiva::Features.symmetry_looking(tss, r)

Time reversal asymmetry

Khiva::Features.time_reversal_asymmetry_statistic(tss, lag)

Number of occurrences of a value

Khiva::Features.value_count(tss, v)

Variance

Khiva::Features.variance(tss)

If variance is larger than one

Khiva::Features.variance_larger_than_standard_deviation(tss)

Library

Get backend info

Khiva::Library.backend_info

Get current backend

Khiva::Library.backend

Get available backends

Khiva::Library.backends

Set backend - :default, :cpu, :cuda, :opencl

Khiva::Library.set_backend(:cpu)

Set device

Khiva::Library.set_device(device_id)

Get device id

Khiva::Library.device_id

Get device count

Khiva::Library.device_count

Set device memory in GB

Khiva::Library.set_device_memory_in_gb(1.5)

Get version

Khiva::Library.version

Linalg

Khiva::Linalg.lls(a, b)

Matrix

Find discords

distances, indices, subsequences = Khiva::Matrix.find_best_n_discords(profile, index, m, n)

Find motifs

distances, indices, subsequences = Khiva::Matrix.find_best_n_motifs(profile, index, m, n)

Find best occurences

distances, indices = Khiva::Matrix.find_best_n_occurrences(q, t, n)

Mueen’s Algorithm for Similarity Search (MASS)

distances = Khiva::Matrix.mass(q, t)

Calculate the matrix profile between ta and tb using a subsequence length of m with the STOMP algorithm

profile, index = Khiva::Matrix.stomp(ta, tb, m)

Calculate the matrix profile between t and itself using a subsequence length of m with the STOMP algorithm

profile, index = Khiva::Matrix.stomp_self_join(t, m)

Calculate the matrix profile between ta and tb using a subsequence length of m

profile, index = Khiva::Matrix.matrix_profile(ta, tb, m)

Calculate the matrix profile between t and itself using a subsequence length of m

profile, index = Khiva::Matrix.matrix_profile_self_join(t, m)

Get chains

Khiva::Matrix.chains(tss, m)

Normalization

Decimal scaling

Khiva::Normalization.decimal_scaling_norm(tss)
Khiva::Normalization.decimal_scaling_norm!(tss)

Max min

Khiva::Normalization.max_min_norm(tss)
Khiva::Normalization.max_min_norm!(tss)

Mean

Khiva::Normalization.mean_norm(tss)
Khiva::Normalization.mean_norm!(tss)

Znorm

Khiva::Normalization.znorm(tss)
Khiva::Normalization.znorm!(tss)

Polynomial

Least squares polynomial fit

Khiva::Polynomial.polyfit(x, y, deg)

Regression

Linear least squares regression

slope, intercept, rvalue, pvalue, stderrest = Khiva::Regression.linear(xss, yss)

Regularization

Khiva::Regularization.group_by(tss, aggregation_function, columns_key: 1, n_columns_value: 1)

Statistics

Covariance

Khiva::Statistics.covariance(tss, unbiased: false)

Kurtosis

Khiva::Statistics.kurtosis(tss)

Ljung-Box

Khiva::Statistics.ljung_box(tss, lags)

Moment

Khiva::Statistics.moment(tss, k)

Quantile

Khiva::Statistics.quantile(tss, q, precision: 1e-8)

Quantiles cut

Khiva::Statistics.quantiles_cut(tss, quantiles, precision: 1e-8)

Standard deviation

Khiva::Statistics.sample_stdev(tss)

Skewness

Khiva::Statistics.skewness(tss)

Khiva Installation

Linux - Ubuntu

Install ArrayFire:

sudo apt-key adv --fetch-key https://repo.arrayfire.com/GPG-PUB-KEY-ARRAYFIRE-2020.PUB
echo "deb [arch=amd64] https://repo.arrayfire.com/ubuntu $(. /etc/os-release && echo $VERSION_CODENAME) main" | sudo tee /etc/apt/sources.list.d/arrayfire.list
sudo apt-get update
sudo apt-get install arrayfire-unified3 arrayfire-cpu3-openblas arrayfire-opencl3-openblas

And install Khiva:

wget https://github.com/shapelets/khiva/releases/download/v0.5.0/khiva-khiva_0.5.0_amd64.deb
sudo dpkg -i khiva-khiva_0.5.0_amd64.deb
sudo ldconfig

Linux - Other

See instructions.

Mac

Run:

brew install khiva

Windows

See instructions.

Credits

This library is modeled after the Khiva-Python API.

History

View the changelog

Contributing

Everyone is encouraged to help improve this project. Here are a few ways you can help:

To get started with development:

git clone https://github.com/ankane/khiva-ruby.git
cd khiva-ruby
bundle install
bundle exec rake test
Note that the project description data, including the texts, logos, images, and/or trademarks, for each open source project belongs to its rightful owner. If you wish to add or remove any projects, please contact us at [email protected].