ROCKET for time series classification: method & codes

ROCKET (Random Convolutional Kernel Transform) is a method for time series classification (TSC) that is both highly efficient and accurate. It is designed to overcome the limitations of existing methods, which often trade-off between computational efficiency and classification performance. It was introduced in the paper: Dempster, Angus, François Petitjean, and Geoffrey I. Webb. “Rocket: exceptionally fast and accurate time series classification using random convolutional kernels.” Data Mining and Knowledge Discovery 34.5 (2020)

Key Ideas & Insights:

1. Random Convolutional Kernels:
   • ROCKET uses a large number of random convolutional kernels to extract important features from time series data, enabling it to capture various patterns and trends effectively.
   • The convolutional kernels are applied with randomly sampled parameters, including lengths, weights, biases, and dilation.
2. Feature Extraction:
   • The method generates two simple summary statistics from the output of the convolutions: maximum values and proportions of positive values.
   • These statistics are computationally inexpensive and provide discriminative information for classification.
3. Classifier:
   • The extracted features are used with a simple, fast classifier such as SVM, Ridge regression or logistic regression, making ROCKET extremely scalable.

Performance

• The experiments in the paper shows that ROCKET achieves state-of-the-art accuracy comparable to more complex models like shapelet-based methods and deep learning approaches.

Scalability

• The approach scales linearly with the number of time series and can handle large datasets with millions of instances.
• Its simplicity allows for efficient implementation and easy adaptation to diverse hardware architectures.

Applications

• Suitable for domains where time series classification is critical, including healthcare, finance, and sensor data analytics.
• Particularly advantageous in scenarios requiring real-time or resource-constrained processing.

Conclusion

ROCKET presents a paradigm shift in time series classification by leveraging randomness and simplicity to achieve both speed and accuracy. Its innovative use of random convolutional kernels and lightweight summary statistics makes it an essential tool in the TSC toolkit.

Python implementation

Note that the sktime library also has “from sktime.regression.kernel_based import RocketRegressor” for regression. However, here we only consider the classification task. So, let’s use the sktime package and the unit test dataset. The unit test data used in sktime is specifically designed for testing and benchmarking purposes. It is a small dataset that allows for quick and easy testing of algorithms. Step-by-step guides:

1. Importing Required Modules

from sktime.classification.kernel_based import RocketClassifier
from sktime.datasets import load_unit_test

• RocketClassifier: A time series classification model implemented in the sktime library. It uses the ROCKET (Random Convolutional Kernel Transform) methodology.
• load_unit_test: A utility function from sktime to load a toy dataset (unit test dataset), which is commonly used for testing and experimenting with time series models.

2. Loading the Dataset

X_train, y_train = load_unit_test(split="train", return_X_y=True)
X_test, y_test = load_unit_test(split="test", return_X_y=True)

• load_unit_test(split="train"):
  • Loads the training portion of the dataset (X_train contains features, y_train contains the target labels).
• load_unit_test(split="test"):
  • Loads the testing portion of the dataset (X_test contains features, y_test contains the target labels).
• return_X_y=True:
  • Ensures the function returns the features (X) and target (y) as separate variables.

3. Initializing the Model

reg = RocketClassifier(num_kernels=500)

• RocketClassifier:
  • Creates an instance of the ROCKET-based time series classifier.
• num_kernels=500:
  • Specifies the number of random convolutional kernels to use. These kernels extract features from the time series data.

4. Training the Model

reg.fit(X_train, y_train)

• The model is trained on the training data (X_train and y_train).
• The fit method learns patterns in the data by applying the random convolutional kernel transformation and training a classifier (e.g., ridge regression) on the extracted features.

5. Making Predictions

y_pred = reg.predict(X_test)

• The model predicts the target values (y_pred) for the test data (X_test) based on what it learned during training.

6. Evaluating the Model

accuracy = np.mean(y_pred == y_test)

• y_pred == y_test:
  • Compares the predicted labels (y_pred) to the true labels (y_test) to check which predictions are correct.
• np.mean():
  • Computes the proportion of correct predictions, giving the accuracy of the model.

Key Points

1. ROCKET Advantage:
   • The RocketClassifier is fast and effective for time series classification due to the use of random convolutional kernels.
2. Dataset:
   • The unit test dataset is small, making it ideal for quick demonstrations or testing.
3. Performance Metric:
   • Accuracy is used to evaluate how well the model predicts on the test dataset.

By running this code, you can train a ROCKET-based classifier, make predictions, and evaluate its performance on a standard dataset.

Combined codes (download):

# Import the RocketClassifier from sktime
from sktime.classification.kernel_based import RocketClassifier

# Import the unit test dataset from sktime
from sktime.datasets import load_unit_test

# Load the training data (features and target)
X_train, y_train = load_unit_test(split="train", return_X_y=True)

# Load the testing data (features and target)
X_test, y_test = load_unit_test(split="test", return_X_y=True) 

# Initialize the RocketClassifier with 500 kernels
reg = RocketClassifier(num_kernels=500) 

# Fit the RocketClassifier model on the training data
reg.fit(X_train, y_train) 

# Predict the target values for the test data
y_pred = reg.predict(X_test) 

# Calculate the accuracy of the predictions
accuracy = np.mean(y_pred == y_test)