PyRQA 2.0.0

Basic Computations

RQA computations are conducted as follows.

from pyrqa.time_series import SingleTimeSeries
from pyrqa.settings import Settings
from pyrqa.neighbourhood import FixedRadius
from pyrqa.metric import EuclideanMetric
from pyrqa.computation import RQAComputation
time_series = SingleTimeSeries([0.1, 0.5, 0.3, 1.7, 0.8, 2.4, 0.6, 1.2, 1.4, 2.1, 0.8],
                                embedding_dimension=3,
                                time_delay=2)
settings = Settings(time_series,
                    neighbourhood=FixedRadius(0.83),
                    similarity_measure=EuclideanMetric,
                    theiler_corrector=1)
computation = RQAComputation.create(settings,
                                    verbose=True)
result = computation.run()
result.min_diagonal_line_length = 3
result.min_vertical_line_length = 2
result.min_white_vertical_line_length = 4
print(result)

Recurrence plot computations can be conducted likewise.

from pyrqa.computation import RecurrencePlotComputation
from pyrqa.image_generator import ImageGenerator
computation = RecurrencePlotComputation.create(settings)
result = computation.run()
ImageGenerator.save_recurrence_plot(result.recurrence_matrix_reverse,
                                    'recurrence_plot.png')

Moreover, it is possible to read time series data that is stored column-wise from a file.

from pyrqa.file_reader import FileReader
time_series = SingleTimeSeries(FileReader.file_as_float_array('data.csv',
                                                              delimiter=';',
                                                              column=0))

Custom OpenCL Environment

The previous examples use the default OpenCL environment. A custom environment using command line input can also be created.

from pyrqa.opencl import OpenCL
opencl = OpenCL(command_line=True)

The OpenCL platform as well as the computing devices can also be selected using their IDs.

opencl = OpenCL(platform_id=0,
                device_ids=(0,))
computation = RQAComputation.create(settings,
                                    verbose=True,
                                    opencl=opencl)
result = computation.run()

OpenCL Compiler Optimisations Enablement

OpenCL compiler optimisations are disabled by default to ensure the comparability of computing results. They can be enabled to leverage additional performance improvements.

computation = RQAComputation.create(settings,
                                    variants_kwargs={'optimisations_enabled': True})
result = computation.run()

Adaptive Implementation Selection

Adaptive implementation selection is performed using one of multiple greedy selection strategies. It is conducted based on a customized pool of implementation variants. These variants may be adapted using a set of keyword arguments.

from pyrqa.variants.rqa.fixed_radius.column_materialisation_uncompressed_bit_no_recycling import ColumnMaterialisationUncompressedBitNoRecycling
from pyrqa.variants.rqa.fixed_radius.column_materialisation_uncompressed_bit_recycling import ColumnMaterialisationUncompressedBitRecycling
from pyrqa.variants.rqa.fixed_radius.column_materialisation_uncompressed_byte_no_recycling import ColumnMaterialisationUncompressedByteNoRecycling
from pyrqa.variants.rqa.fixed_radius.column_materialisation_uncompressed_byte_recycling import ColumnMaterialisationUncompressedByteRecycling
from pyrqa.variants.rqa.fixed_radius.column_no_materialisation import ColumnNoMaterialisation
from pyrqa.selector import EpsilonGreedySelector
computation = RQAComputation.create(settings,
                                    selector=EpsilonGreedySelector(explore=10),
                                    variants=(ColumnMaterialisationUncompressedBitNoRecycling,
                                              ColumnMaterialisationUncompressedBitRecycling,
                                              ColumnMaterialisationUncompressedByteNoRecycling,
                                              ColumnMaterialisationUncompressedByteRecycling,
                                              ColumnNoMaterialisation),
                                    variants_kwargs={'optimisations_enabled': True})
result = computation.run()

Floating Point Precision Selection

PyRQA allows to select the precision regarding the representations of the time series data, which determines the precision of the computations on the OpenCL devices. Currently, the following precisions are supported:

• Half precision (16 bit)

• Single precision (32 bit)

• Double precision (64 bit)

Note that not all precisions may be supported by the OpenCL devices that are used to conduct the computations. The following example depicts the usage of double precision.

import numpy as np
time_series = SingleTimeSeries([0.1, 0.5, 0.3, 1.7, 0.8, 2.4, 0.6, 1.2, 1.4, 2.1, 0.8],
                                embedding_dimension=3,
                                time_delay=2,
                                dtype=np.float64)

v2.0.0

• Major refactoring.

• Removal of operator and variant implementations that do not refer to OpenCL brute force computing.

• Time series data may be represented using half, single and double precision floating point values, which is reflected in the computations on the OpenCL devices.

• Several changes to the public API.

v1.0.6

• Changes to the public API have been made, e.g., to the definition of the settings. This leads to an increase in the major version number (see http://semver.org/).

• Time series objects either consist of one or multiple series. The former requires to specify a value for the embedding delay as well as the time delay parameter.

• Regarding the RQA computations, minimum line lengths are now specified on the result object. This allows to compute quantitative results using different lengths without having to inspect the matrix using the same parametrisation multiple times.

• Modules for selecting well-performing implementations based on greedy selection strategies have been added. By default, the selection pool consists of a single pre-defined implementation.

• Operators and implementation variants based on multidimensional search trees and grid data structures have been added.

• The diagonal line based quantitative measures are modified regarding the semantics of the Theiler corrector.

• The creation of the OpenCL environment now supports device fission.

v0.1.0

• Initial release.