🤖 AI

LLT: An R package for Linear Law-based Feature Space Transformation

This paper introduces the LLT R package, which implements a linear law-based feature space transformation algorithm to assist in classifying univariate and multivariate time series by identifying governing patterns in training data via time-delay embedding and spectral decomposition, and subsequently applying these patterns to transform test set features.

Original authors: Marcell T. Kurbucz, Péter Pósfay, Antal Jakovác

Published 2026-02-06

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Marcell T. Kurbucz, Péter Pósfay, Antal Jakovác

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to teach a computer to tell the difference between two types of weather patterns: "Warm Days" and "Cold Days." You have a huge pile of data—graphs showing electricity usage every ten minutes for a whole year. To a computer, these squiggly lines look messy and confusing. It's hard to see the pattern just by looking at the raw numbers.

This paper introduces a new tool, called the LLT package, which acts like a "pattern translator" for this kind of data. Its job is to take those messy squiggly lines and transform them into a format that is much easier for a computer to sort and classify.

Here is how it works, broken down into simple steps using an analogy:

1. The "Time-Travel" Mirror (Time-Delay Embedding)

Imagine you have a single line of music. If you just listen to one note, you don't know the song. But if you look at a sequence of notes, you start to hear the melody.

The LLT algorithm does something similar. It takes a single time series (like a day's electricity usage) and creates a "mirror" of it. It looks at the data point at time $t$ , then $t+1$ , then $t+2$ , and so on, stacking them up to create a 3D shape out of a 2D line. This helps the computer see the shape and flow of the data, not just the individual numbers.

2. Finding the "Secret Recipe" (Linear Laws)

Once the data is reshaped, the algorithm looks for a "Secret Recipe" (which the paper calls a Linear Law) for each type of data in the training set (the "Warm" days and the "Cold" days).

Think of this like a master chef tasting a soup. The chef knows exactly which combination of spices (mathematical weights) will make the soup taste "perfectly balanced" or, in math terms, cancel out to zero.

For the "Warm" days, there is a specific recipe that makes the data look like a flat, calm line (zero).
For the "Cold" days, there is a different recipe that does the same thing.

The algorithm finds these recipes by using a technique called "spectral decomposition" (a fancy way of saying it breaks the data down to find its most fundamental, quietest patterns).

3. The "Stress Test" (Transformation)

Now, the computer has a pile of new, unknown data (the "Test Set"). It doesn't know if these are "Warm" or "Cold" days yet.

The algorithm takes the "Secret Recipes" it learned from the training data and applies them to the new data.

It tries the "Warm" recipe on the new data. Does it flatten out the line? If yes, the new data is likely "Warm."
It tries the "Cold" recipe. Does that flatten it out? If yes, it's likely "Cold."

If the new data doesn't fit the recipe well, it means the data belongs to a different category. This process transforms the messy original data into a clean, new set of features that clearly show which category the data belongs to.

4. The Tool Itself (The R Package)

The paper presents this as a software tool written in R (a language used by statisticians). It's designed to be user-friendly and fast because it doesn't rely on heavy, slow external tools; it uses the computer's built-in math engines.

The tool is divided into three main "workers":

trainTest: Sorts your data into a "Learning Group" (Training) and a "Testing Group."
trainLaw: The "Chef." It tastes the Learning Group and writes down the Secret Recipes.
testTrans: The "Stress Tester." It takes the new data, applies the recipes, and transforms it into a format ready for classification.

Real-World Example in the Paper

The authors tested this on a real dataset from France involving household electricity usage. They wanted to see if the computer could tell the difference between "Warm Season" days and "Cold Season" days.

The Result: After using the LLT tool to transform the data, the computer correctly identified the season about 87% of the time.
The Bonus: The paper notes that this method is very fast and works well when combined with simple, standard classification tools (like the "k-nearest neighbor" algorithm).

Summary

In short, the LLT package is a translator. It takes complex, hard-to-read time-series data, finds the hidden mathematical "rules" that define specific patterns, and rewrites the data so that a computer can easily say, "Ah, this pattern matches the 'Warm' rule," or "This one matches the 'Cold' rule." It makes the job of sorting time-based data much easier and faster.

Technical Summary: LLT R Package for Linear Law-based Feature Space Transformation

Problem Statement
Time series classification (TSC) remains a challenging task in machine learning and data mining due to the large data sizes, high dimensionality, and continuous nature of temporal data collected by sensors. While existing approaches are generally categorized into feature-based methods (e.g., Discrete Wavelet Transform, Discrete Fourier Transform) and distance-based methods (e.g., Dynamic Time Warping with 1-Nearest Neighbor), there is a need for algorithms that can effectively transform feature spaces to facilitate the classification of both univariate and multivariate time series.

Methodology
The paper introduces the Linear Law-based Feature Space Transformation (LLT) algorithm and its implementation as an R package. The core methodology relies on identifying "linear laws"—governing patterns within time series—using time-delay embedding and spectral decomposition.

Linear Law Definition: For a time series $z_t$ , an $l$ -order time-delay embedding creates a matrix $A$ . A symmetric matrix $S = A^\top A$ is then generated. The "linear law" is defined as the eigenvector $v$ corresponding to the smallest eigenvalue of $S$ , satisfying $Sv \approx 0$ . Unlike Principal Component Analysis (PCA), which maximizes variance, this approach seeks components that minimize the variance of the projected data.
Transformation Process:
- Training: The dataset is split into training and test sets. For each input series (initial feature) in the training set, the algorithm computes the linear laws (eigenvectors) grouped by class.
- Testing: For test instances, the algorithm constructs $S$ matrices from the input series. These are left-multiplied by the training-derived law matrices ( $V^j$ ) corresponding to the same initial feature.
- Feature Selection: The resulting matrices ( $S^{te,j}V^j$ ) are analyzed. Columns with small variance or absolute mean indicate that the test data belongs to the same class as the training data used to derive the law. The dimension is reduced by selecting column vectors with the smallest variance and/or absolute mean (or a ranked combination of both) for each class and input series.

Key Contributions
The primary contribution of this work is the LLT R package, the first software implementation of the LLT algorithm. Key features of the package include:

Modular Architecture: The algorithm is decomposed into three main functions (trainTest, trainLaw, testTrans) and two auxiliary functions (embed, linlaw). This modularity facilitates further algorithmic development.
Efficiency: To ensure low computational demand, the package relies exclusively on built-in R functions rather than external community libraries.
Flexibility and Usability: The package is designed to be user-friendly, requiring only essential parameters (e.g., path, test ratio, dimension, lag, selection criteria) while supporting both univariate and multivariate data.
Open Availability: The package (v0.1.0) and a sample dataset with the required directory structure are publicly available on GitHub under the GNU General Public License v3.0.

Results
The paper validates the package using the PowerCons dataset (household electric power consumption from EDF), categorized into "Warm" and "Cold" seasonal classes.

Experimental Setup: The authors performed 300 transformations using a test ratio of 0.1 and a dimension ($dim$) of 5.
Performance: Using a simple classification rule (selecting the class with the smaller absolute mean of the transformed features), the method achieved an average accuracy of 87.204% with a standard deviation of 5.536%.
Comparative Context: The authors note that combining LLT with the k-Nearest Neighbor (KNN) algorithm has previously yielded accurate results with low computational demand in other studies (Kurbucz et al., 2022a). Additionally, prior work on the Activity Recognition system based on Multisensor data fusion (AReM) dataset demonstrated that LLT significantly increased the accuracy of traditional classifiers, outperforming state-of-the-art methods after feature space transformation.

Significance and Claims
The paper positions the LLT package as a practical tool that transforms the structure of feature sets to make time series data easier to classify. The authors emphasize that the algorithm offers a low computational complexity alternative to existing methods. The significance of the work lies in providing a flexible, user-friendly, and efficient implementation that separates the computational steps, thereby enabling researchers to further develop learning algorithms based on linear laws. The authors maintain a modest tone, presenting the package as a foundational implementation that facilitates the application of the LLT algorithm rather than claiming it as a universal solution for all TSC problems.