CNNClassifierTorch

class CNNClassifierTorch(num_epochs: int = 2000, batch_size: int = 16, kernel_sizes: tuple[int, ...] = (7, 7), avg_pool_size: int = 3, filter_sizes: tuple[int, ...] = (6, 12), padding: str = 'auto', use_bias: bool = True, activation: str | Callable | None = None, activation_hidden: str | Callable = 'Sigmoid', optimizer: str | None | Callable = 'Adam', optimizer_kwargs: dict | None = None, criterion: str | None | Callable = 'CrossEntropyLoss', criterion_kwargs: dict | None = None, callbacks: None | str | tuple[str, ...] = 'ReduceLROnPlateau', callback_kwargs: dict | None = None, lr: float = 0.01, verbose: bool = False, init_weights: str | None = None, random_state: int | None = None)[source]

Time Convolutional Neural Network (CNN) in PyTorch, as described in [1].

Zhao et al. 2017 uses MSE loss and sigmoid activation in all layers. To obtain same behaviour as Zhao et al. 2017, set activation and criterion to “sigmoid” and “MSELoss” respectively.

Adapted from the implementation from Fawaz et. al https://github.com/hfawaz/dl-4-tsc/blob/master/classifiers/cnn.py

Parameters:

num_epochsint, default = 2000

Number of epochs to train the model.

batch_sizeint, default = 16

Size of each mini-batch.

kernel_sizestuple of int, default = (7, 7)

A tuple of length equal to the number of conv layers with each entry in the tuple specifies the kernel size for the corresponding convolutional layer. The length of kernel_sizes must be equal to the length of filter_sizes.

avg_pool_sizeint, default = 3

Size of the average pooling window.

filter_sizestuple of int, default = (6, 12)

A tuple of length equal to the number of conv layers with each entry in the tuple specifies the filter size for the corresponding convolutional layer. The length of filter_sizes must be equal to the length of kernel_sizes.

paddingstr, default = “auto”

Padding for conv layers. “auto”: “same” if series_length < 60 else “valid”; “valid” or “same” otherwise.

use_biasbool, default = True

Whether to use bias in output layer.

activationstr, Callable, or None, default=None

Activation applied to the output layer.

Permitted values:

None: no activation is applied to the output layer and the network returns raw outputs (logits). This is typically required when using CrossEntropyLoss, which expects logits as input.
str: name of a class in torch.nn. Case-sensitive names are recommended and must match PyTorch (e.g., "ReLU", "LeakyReLU"). Lowercase aliases for common activations are also accepted (e.g., "relu" is resolved to "ReLU"). The class is instantiated with default constructor arguments. Must be a valid torch.nn activation; see https://pytorch.org/docs/stable/nn.html#non-linear-activations-weighted-sum-nonlinearity
torch.nn.Module: an instance of a torch.nn.Module subclass, for example torch.nn.ReLU(). Arbitrary callables are not supported.

activation_hiddenstr, Callable, or None, default=”Sigmoid”

Activation applied to the hidden layers.

Permitted values:

None: no activation is applied to the hidden layers.
str: name of a class in torch.nn. Case-sensitive names are recommended and must match PyTorch (e.g., "ReLU", "LeakyReLU"). Lowercase aliases for common activations are also accepted (e.g., "relu" is resolved to "ReLU"). The class is instantiated with default constructor arguments. Must be a valid torch.nn activation; see https://pytorch.org/docs/stable/nn.html#non-linear-activations-weighted-sum-nonlinearity
torch.nn.Module: an instance of a torch.nn.Module subclass, for example torch.nn.ReLU(). Arbitrary callables are not supported.

Recommended activations: Sigmoid, ReLU, Tanh, Softmax, LogSoftmax.

optimizerstr or callable, default = “Adam”

Optimizer to use. Same as TF default (Adam).

optimizer_kwargsdict or None, default = None

Additional keyword arguments for the optimizer.

criterionstr or callable, default = “CrossEntropyLoss”

Loss function for training.

criterion_kwargsdict or None, default = None

Additional keyword arguments for the criterion.

callbacksNone or str or tuple of str, default = “ReduceLROnPlateau”

Learning rate schedulers as callbacks.

callback_kwargsdict or None, default = None

Keyword arguments for callbacks.

lrfloat, default = 0.01

Learning rate (TF CNN uses Adam(lr=0.01)).

verbosebool, default = False

Whether to print progress during training.

init_weights: str or None, default = None

The method to initialize the weights of the conv layers. Supported values are ‘kaiming_uniform’, ‘kaiming_normal’, ‘xavier_uniform’, ‘xavier_normal’, or None for default PyTorch initialization.

random_stateint or None, default = None

Seed for reproducibility.

Attributes:

is_fitted: Whether fit has been called.

References

[1]

Zhao et al. Convolutional neural networks for time series classification, Journal of Systems Engineering and Electronics, 28(1):2017.

Examples

>>> from sktime.classification.deep_learning.cnn import CNNClassifierTorch
>>> from sktime.datasets import load_unit_test
>>> X_train, y_train = load_unit_test(split="train")
>>> X_test, y_test = load_unit_test(split="test")
>>> clf = CNNClassifierTorch(num_epochs=20, batch_size=4)
>>> clf.fit(X_train, y_train)
CNNClassifierTorch(...)

Methods

`check_is_fitted`([method_name])	Check if the estimator has been fitted.
`clone`()	Obtain a clone of the object with same hyper-parameters and config.
`clone_tags`(estimator[, tag_names])	Clone tags from another object as dynamic override.
`create_test_instance`([parameter_set])	Construct an instance of the class, using first test parameter set.
`create_test_instances_and_names`([parameter_set])	Create list of all test instances and a list of names for them.
`fit`(X, y)	Fit time series classifier to training data.
`fit_predict`(X, y[, cv, change_state])	Fit and predict labels for sequences in X.
`fit_predict_proba`(X, y[, cv, change_state])	Fit and predict labels probabilities for sequences in X.
`get_class_tag`(tag_name[, tag_value_default])	Get class tag value from class, with tag level inheritance from parents.
`get_class_tags`()	Get class tags from class, with tag level inheritance from parent classes.
`get_config`()	Get config flags for self.
`get_fitted_params`([deep])	Get fitted parameters.
`get_param_defaults`()	Get object's parameter defaults.
`get_param_names`([sort])	Get object's parameter names.
`get_params`([deep])	Get a dict of parameters values for this object.
`get_tag`(tag_name[, tag_value_default, ...])	Get tag value from instance, with tag level inheritance and overrides.
`get_tags`()	Get tags from instance, with tag level inheritance and overrides.
`get_test_params`([parameter_set])	Return testing parameter settings for the estimator.
`is_composite`()	Check if the object is composed of other BaseObjects.
`load_from_path`(serial)	Load object from file location.
`load_from_serial`(serial)	Load object from serialized memory container.
`predict`(X)	Predicts labels for sequences in X.
`predict_proba`(X)	Predicts labels probabilities for sequences in X.
`reset`()	Reset the object to a clean post-init state.
`save`([path, serialization_format])	Save serialized self to bytes-like object or to (.zip) file.
`score`(X, y)	Scores predicted labels against ground truth labels on X.
`set_config`(**config_dict)	Set config flags to given values.
`set_params`(**params)	Set the parameters of this object.
`set_random_state`([random_state, deep, ...])	Set random_state pseudo-random seed parameters for self.
`set_tags`(**tag_dict)	Set instance level tag overrides to given values.