tslearn.neural_network.TimeSeriesMLPRegressor

class tslearn.neural_network.TimeSeriesMLPRegressor(hidden_layer_sizes=(100, ), activation='relu', *, solver='adam', alpha=0.0001, batch_size='auto', learning_rate='constant', learning_rate_init=0.001, power_t=0.5, max_iter=200, shuffle=True, random_state=None, tol=0.0001, verbose=False, warm_start=False, momentum=0.9, nesterovs_momentum=True, early_stopping=False, validation_fraction=0.1, beta_1=0.9, beta_2=0.999, epsilon=1e-08, n_iter_no_change=10, max_fun=15000)[source]

A Multi-Layer Perceptron regressor for time series.

This class mainly reshapes data so that it can be fed to scikit-learn’s MLPRegressor.

It accepts the exact same hyper-parameters as MLPRegressor, check scikit-learn docs for a list of parameters and attributes.

Attributes:
partial_fit

Update the model with a single iteration over the given data.

Notes

This method requires a dataset of equal-sized time series.

Examples

>>> mlp = TimeSeriesMLPRegressor(hidden_layer_sizes=(64, 64),
...                               random_state=0)
>>> mlp.fit(X=[[1, 2, 3], [1, 1.2, 3.2], [3, 2, 1]],
...         y=[0, 0, 1])  # doctest: +ELLIPSIS
TimeSeriesMLPRegressor(...)
>>> [c.shape for c in mlp.coefs_]
[(3, 64), (64, 64), (64, 1)]
>>> [c.shape for c in mlp.intercepts_]
[(64,), (64,), (1,)]

Methods

fit(X, y) Fit the model using X as training data and y as target values
get_params([deep]) Get parameters for this estimator.
predict(X) Predict the target for the provided data
score(X, y[, sample_weight]) Return the coefficient of determination \(R^2\) of the prediction.
set_params(**params) Set the parameters of this estimator.
fit(X, y)[source]

Fit the model using X as training data and y as target values

Parameters:
X : array-like, shape (n_ts, sz, d)

Training data.

y : array-like, shape (n_ts, ) or (n_ts, dim_y)

Target values.

Returns:
TimeSeriesMLPRegressor

The fitted estimator

get_params(deep=True)[source]

Get parameters for this estimator.

Parameters:
deep : bool, default=True

If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns:
params : dict

Parameter names mapped to their values.

partial_fit[source]

Update the model with a single iteration over the given data.

Parameters:
X : {array-like, sparse matrix} of shape (n_samples, n_features)

The input data.

y : ndarray of shape (n_samples,)

The target values.

Returns:
self : returns a trained MLP model.
predict(X)[source]

Predict the target for the provided data

Parameters:
X : array-like, shape (n_ts, sz, d)

Test samples.

Returns:
array, shape = (n_ts, ) or (n_ts, dim_y)

Array of predicted targets

score(X, y, sample_weight=None)[source]

Return the coefficient of determination \(R^2\) of the prediction.

The coefficient \(R^2\) is defined as \((1 - \frac{u}{v})\), where \(u\) is the residual sum of squares ((y_true - y_pred) ** 2).sum() and \(v\) is the total sum of squares ((y_true - y_true.mean()) ** 2).sum(). The best possible score is 1.0 and it can be negative (because the model can be arbitrarily worse). A constant model that always predicts the expected value of y, disregarding the input features, would get a \(R^2\) score of 0.0.

Parameters:
X : array-like of shape (n_samples, n_features)

Test samples. For some estimators this may be a precomputed kernel matrix or a list of generic objects instead with shape (n_samples, n_samples_fitted), where n_samples_fitted is the number of samples used in the fitting for the estimator.

y : array-like of shape (n_samples,) or (n_samples, n_outputs)

True values for X.

sample_weight : array-like of shape (n_samples,), default=None

Sample weights.

Returns:
score : float

\(R^2\) of self.predict(X) wrt. y.

Notes

The \(R^2\) score used when calling score on a regressor uses multioutput='uniform_average' from version 0.23 to keep consistent with default value of r2_score(). This influences the score method of all the multioutput regressors (except for MultiOutputRegressor).

set_params(**params)[source]

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as Pipeline). The latter have parameters of the form <component>__<parameter> so that it’s possible to update each component of a nested object.

Parameters:
**params : dict

Estimator parameters.

Returns:
self : estimator instance

Estimator instance.