def fit(self, X, y=None, subsample=None):
"""Fit the model with a time series X
Parameters
----------
X : array-like, shape (n_timepoints, n_features)
Training data, where n_timepoints is the number of timepoints
and n_features is the number of features.
y : None
Ignored variable.
subsample : int or None
If set to an integer, a random number of timepoints is selected
equal to that integer
Returns
-------
X_new : array-like, shape (n_timepoints, n_components)
Transformed values.
"""
# Make hankel matrix from dataset
Xs = standardize_ts(X)
X_train = hankel_matrix(Xs, self.time_window)
if subsample:
self.train_indices, X_train = resample_dataset(
X_train, subsample, random_state=self.random_state)
if self.time_lag > 0:
self.model.fit([np.reshape(X_train, (X_train.shape[0], -1))])
else:
self.model.fit(np.reshape(X_train, (X_train.shape[0], -1)))
def fit(self, X, y=None, verbose=False, bins=None, timescale=None):
"""Fit the model with a time series X
Parameters
----------
X : array-like, shape (n_timepoints, n_features)
Training data, where n_timepoints is the number of timepoints
and n_features is the number of features.
y : None
Ignored variable.
Returns
-------
X_new : array-like, shape (n_timepoints, n_components)
Transformed values.
"""
Xs = standardize_ts(X)
if not self.lag_cutoff:
self.lag_cutoff = int(np.floor(len(Xs) / 2))
lagged_mi_vals = self._mutual_information_lagged(
Xs, self.lag_cutoff, bins)
if verbose:
plt.plot(lagged_mi_vals)
lag_times = self._find_minima(lagged_mi_vals, timescale)[0]
lag_time = lag_times[0]
self.lag_time = lag_time # overrides constant
def transform(self, X, y=None):
X_test = hankel_matrix(standardize_ts(X), self.time_window)
X_test = np.reshape(X_test, (X_test.shape[0], -1))
if self.time_lag > 0:
X_new = self.model.transform([X_test])[0]
else:
X_new = self.model.transform(X_test)
return X_new
def transform(self, X, y=None):
tau = self.time_window*self.lag_time
X_test = hankel_matrix(standardize_ts(X),
q = tau,
p = len(X) - tau
)
X_test = X_test[:, ::self.lag_time, :]
return np.squeeze(X_test)
def transform(self, X, y=None):
X_test = hankel_matrix(standardize_ts(X), self.time_window)
X_new = self.model.encoder.predict(X_test)
return X_new
def fit(self,
X,
y=None,
subsample=None,
tau=0,
learning_rate=1e-3,
batch_size=100,
train_steps=200,
loss='mse',
verbose=0,
optimizer="adam",
early_stopping=False):
"""Fit the model with a time series X
Parameters
----------
X : array-like, shape (n_timepoints, n_features)
Training data, where n_samples is the number of samples
and n_features is the number of features.
y : None
Ignored variable.
subsample : int or None
If set to an integer, a random number of timepoints is selected
equal to that integer
tau : int
The prediction time, or the number of timesteps to skip between
the input and output time series
Returns
-------
X_new : array-like, shape (n_timepoints, n_components)
Transformed values.
"""
# Make hankel matrix from dataset
Xs = standardize_ts(X)
# X_train = hankel_matrix(Xs, self.time_window)
# Split the hankel matrix for a prediction task
X0 = hankel_matrix(Xs, self.time_window + tau)
X_train = X0[:, :self.time_window]
Y_train = X0[:, -self.time_window:]
if subsample:
self.train_indices, _ = resample_dataset(
X_train, subsample, random_state=self.random_state)
X_train = X_train[self.train_indices]
Y_train = Y_train[self.train_indices]
optimizers = {
"adam": tf.keras.optimizers.Adam(lr=learning_rate),
"nadam": tf.keras.optimizers.Nadam(lr=learning_rate)
# "radam": tfa.optimizers.RectifiedAdam(lr=learning_rate),
}
tf.random.set_seed(self.random_state)
np.random.seed(self.random_state)
self.model.compile(
optimizer=optimizers[optimizer],
loss=loss,
#experimental_run_tf_function=False
)
if early_stopping:
callbacks = [
tf.keras.callbacks.EarlyStopping(monitor='loss',
mode='min',
patience=3)
]
else:
callbacks = [None]
self.train_history = self.model.fit(x=tf.convert_to_tensor(X_train),
y=tf.convert_to_tensor(Y_train),
epochs=train_steps,
batch_size=batch_size,
verbose=verbose)
