def _transform_words(self, X):
self.check_is_fitted()
X = check_X(X, enforce_univariate=False, coerce_to_pandas=True)
if self.use_first_order_differences:
X = self.add_first_order_differences(X)
bag_all_words = [dict() for _ in range(len(X))]
# On each dimension, perform SFA
for ind, column in enumerate(self.col_names):
X_dim = X[[column]]
X_dim = from_nested_to_3d_numpy(X_dim)
for i, window_size in enumerate(self.window_sizes[ind]):
# SFA transform
sfa_words = self.SFA_transformers[ind][i].transform(X_dim)
bag = sfa_words[0] # .iloc[:, 0]
# merging bag-of-patterns of different window_sizes
# to single bag-of-patterns with prefix indicating
# the used window-length
highest = np.int32(self.highest_bits[ind])
for j in range(len(bag)):
for (key, value) in bag[j].items():
# append the prefices to the words to distinguish
# between window-sizes
word = MUSE.shift_left(key, highest, ind,
self.highest_dim_bit,
window_size)
bag_all_words[j][word] = value
return bag_all_words
def test_from_nested_to_3d_numpy(n_instances, n_columns, n_timepoints):
nested, _ = make_classification_problem(n_instances, n_columns,
n_timepoints)
array = from_nested_to_3d_numpy(nested)
# check types and shapes
assert isinstance(array, np.ndarray)
assert array.shape == (n_instances, n_columns, n_timepoints)
# check values of random series
np.testing.assert_array_equal(nested.iloc[1, 0], array[1, 0, :])
def _multivariate_nested_df_to_array(X):
X = from_nested_to_3d_numpy(X)
# go from [n][d][m] to [n][m][d]
return X.transpose(0, 2, 1)
def fit(self, X, y):
"""Build a WEASEL+MUSE classifiers from the training set (X, y),
Parameters
----------
X : nested pandas DataFrame of shape [n_instances, 1]
Nested dataframe with univariate time-series in cells.
y : array-like, shape = [n_instances] The class labels.
Returns
-------
self : object
"""
X, y = check_X_y(X, y, coerce_to_pandas=True)
y = np.asarray(y)
# add first order differences in each dimension to TS
if self.use_first_order_differences:
X = self.add_first_order_differences(X)
# Window length parameter space dependent on series length
self.col_names = X.columns
rng = check_random_state(self.random_state)
self.n_dims = len(self.col_names)
self.highest_dim_bit = (math.ceil(math.log2(self.n_dims))) + 1
self.highest_bits = np.zeros(self.n_dims)
self.SFA_transformers = [[] for _ in range(self.n_dims)]
# the words of all dimensions and all time series
all_words = [dict() for _ in range(X.shape[0])]
# On each dimension, perform SFA
for ind, column in enumerate(self.col_names):
X_dim = X[[column]]
X_dim = from_nested_to_3d_numpy(X_dim)
series_length = X_dim.shape[
-1] # TODO compute minimum over all ts ?
# increment window size in steps of 'win_inc'
win_inc = self.compute_window_inc(series_length)
self.max_window = int(min(series_length, self.max_window))
self.window_sizes.append(
list(range(self.min_window, self.max_window, win_inc)))
self.highest_bits[ind] = math.ceil(math.log2(self.max_window)) + 1
for window_size in self.window_sizes[ind]:
transformer = SFA(
word_length=rng.choice(self.word_lengths),
alphabet_size=self.alphabet_size,
window_size=window_size,
norm=rng.choice(self.norm_options),
anova=self.anova,
binning_method=rng.choice(self.binning_strategies),
bigrams=self.bigrams,
remove_repeat_words=False,
lower_bounding=False,
save_words=False,
)
sfa_words = transformer.fit_transform(X_dim, y)
self.SFA_transformers[ind].append(transformer)
bag = sfa_words[0] # .iloc[:, 0]
# chi-squared test to keep only relevant features
relevant_features = {}
apply_chi_squared = self.chi2_threshold > 0
if apply_chi_squared:
bag_vec = DictVectorizer(sparse=False).fit_transform(bag)
chi2_statistics, p = chi2(bag_vec, y)
relevant_features = np.where(
chi2_statistics >= self.chi2_threshold)[0]
# merging bag-of-patterns of different window_sizes
# to single bag-of-patterns with prefix indicating
# the used window-length
highest = np.int32(self.highest_bits[ind])
for j in range(len(bag)):
for (key, value) in bag[j].items():
# chi-squared test
if (not apply_chi_squared) or (key
in relevant_features):
# append the prefices to the words to
# distinguish between window-sizes
word = MUSE.shift_left(key, highest, ind,
self.highest_dim_bit,
window_size)
all_words[j][word] = value
self.clf = make_pipeline(
DictVectorizer(sparse=False),
StandardScaler(with_mean=True, copy=False),
LogisticRegression(
max_iter=5000,
solver="liblinear",
dual=True,
# class_weight="balanced",
penalty="l2",
random_state=self.random_state,
),
)
self.clf.fit(all_words, y)
self._is_fitted = True
return self
def kneighbors(self, X, n_neighbors=None, return_distance=True):
"""Finds the K-neighbors of a point.
Returns indices of and distances to the neighbors of each point.
Parameters
----------
X : sktime-format pandas dataframe with shape([n_cases,n_dimensions]),
or numpy ndarray with shape([n_cases,n_readings,n_dimensions])
y : {array-like, sparse matrix}
Target values of shape = [n_samples]
n_neighbors : int
Number of neighbors to get (default is the value
passed to the constructor).
return_distance : boolean, optional. Defaults to True.
If False, distances will not be returned
Returns
-------
dist : array
Array representing the lengths to points, only present if
return_distance=True
ind : array
Indices of the nearest points in the population matrix.
"""
self.check_is_fitted()
X = check_X(X, enforce_univariate=False)
X = from_nested_to_3d_numpy(X)
if n_neighbors is None:
n_neighbors = self.n_neighbors
elif n_neighbors <= 0:
raise ValueError("Expected n_neighbors > 0. Got %d" % n_neighbors)
else:
if not np.issubdtype(type(n_neighbors), np.integer):
raise TypeError("n_neighbors does not take %s value, "
"enter integer value" % type(n_neighbors))
if X is not None:
query_is_train = False
X = check_array(X, accept_sparse="csr", allow_nd=True)
else:
query_is_train = True
X = self._fit_X
# Include an extra neighbor to account for the sample itself being
# returned, which is removed later
n_neighbors += 1
train_size = self._fit_X.shape[0]
if n_neighbors > train_size:
raise ValueError("Expected n_neighbors <= n_samples, "
" but n_samples = %d, n_neighbors = %d" %
(train_size, n_neighbors))
n_samples = X.shape[0]
sample_range = np.arange(n_samples)[:, None]
n_jobs = effective_n_jobs(self.n_jobs)
if self._fit_method == "brute":
reduce_func = partial(
self._kneighbors_reduce_func,
n_neighbors=n_neighbors,
return_distance=return_distance,
)
# for efficiency, use squared euclidean distances
kwds = ({
"squared": True
} if self.effective_metric_ == "euclidean" else
self.effective_metric_params_)
result = pairwise_distances_chunked(X,
self._fit_X,
reduce_func=reduce_func,
metric=self.effective_metric_,
n_jobs=n_jobs,
**kwds)
elif self._fit_method in ["ball_tree", "kd_tree"]:
if issparse(X):
raise ValueError(
"%s does not work with sparse matrices. Densify the data, "
"or set algorithm='brute'" % self._fit_method)
if LooseVersion(joblib_version) < LooseVersion("0.12"):
# Deal with change of API in joblib
delayed_query = delayed(self._tree.query, check_pickle=False)
parallel_kwargs = {"backend": "threading"}
else:
delayed_query = delayed(self._tree.query)
parallel_kwargs = {"prefer": "threads"}
result = Parallel(n_jobs, **parallel_kwargs)(
delayed_query(X[s], n_neighbors, return_distance)
for s in gen_even_slices(X.shape[0], n_jobs))
else:
raise ValueError("internal: _fit_method not recognized")
if return_distance:
dist, neigh_ind = zip(*result)
result = np.vstack(dist), np.vstack(neigh_ind)
else:
result = np.vstack(result)
if not query_is_train:
return result
else:
# If the query data is the same as the indexed data, we would like
# to ignore the first nearest neighbor of every sample, i.e
# the sample itself.
if return_distance:
dist, neigh_ind = result
else:
neigh_ind = result
sample_mask = neigh_ind != sample_range
# Corner case: When the number of duplicates are more
# than the number of neighbors, the first NN will not
# be the sample, but a duplicate.
# In that case mask the first duplicate.
dup_gr_nbrs = np.all(sample_mask, axis=1)
sample_mask[:, 0][dup_gr_nbrs] = False
neigh_ind = np.reshape(neigh_ind[sample_mask],
(n_samples, n_neighbors - 1))
if return_distance:
dist = np.reshape(dist[sample_mask],
(n_samples, n_neighbors - 1))
return dist, neigh_ind
return neigh_ind
def fit(self, X, y):
"""Fit the model using X as training data and y as target values
Parameters
----------
X : sktime-format pandas dataframe with shape([n_cases,n_dimensions]),
or numpy ndarray with shape([n_cases,n_readings,n_dimensions])
y : {array-like, sparse matrix}
Target values of shape = [n_samples]
"""
X, y = check_X_y(X, y, enforce_univariate=False)
y = np.asarray(y)
X = from_nested_to_3d_numpy(X)
check_classification_targets(y)
# print(X)
# if internal cv is desired, the relevant flag forces a grid search
# to evaluate the possible values,
# find the best, and then set this classifier's params to match
if self._cv_for_params:
grid = GridSearchCV(
estimator=KNeighborsTimeSeriesClassifier(metric=self.metric,
n_neighbors=1,
algorithm="brute"),
param_grid=self._param_matrix,
cv=LeaveOneOut(),
scoring="accuracy",
)
grid.fit(X, y)
self.metric_params = grid.best_params_["metric_params"]
if y.ndim == 1 or y.ndim == 2 and y.shape[1] == 1:
if y.ndim != 1:
warnings.warn(
"A column-vector y was passed when a 1d array "
"was expected. Please change the shape of y to "
"(n_samples, ), for example using ravel().",
DataConversionWarning,
stacklevel=2,
)
self.outputs_2d_ = False
y = y.reshape((-1, 1))
else:
self.outputs_2d_ = True
self.classes_ = []
self._y = np.empty(y.shape, dtype=np.int)
for k in range(self._y.shape[1]):
classes, self._y[:, k] = np.unique(y[:, k], return_inverse=True)
self.classes_.append(classes)
if not self.outputs_2d_:
self.classes_ = self.classes_[0]
self._y = self._y.ravel()
if hasattr(check_array, "__wrapped__"):
temp = check_array.__wrapped__.__code__
check_array.__wrapped__.__code__ = _check_array_ts.__code__
else:
temp = check_array.__code__
check_array.__code__ = _check_array_ts.__code__
fx = self._fit(X)
if hasattr(check_array, "__wrapped__"):
check_array.__wrapped__.__code__ = temp
else:
check_array.__code__ = temp
self._is_fitted = True
return fx
def check_X(
X,
enforce_univariate=False,
enforce_min_instances=1,
enforce_min_columns=1,
coerce_to_numpy=False,
coerce_to_pandas=False,
):
"""Validate input data.
Parameters
----------
X : pd.DataFrame or np.array
Input data
enforce_univariate : bool, optional (default=False)
Enforce that X is univariate.
enforce_min_instances : int, optional (default=1)
Enforce minimum number of instances.
enforce_min_columns : int, optional (default=1)
Enforce minimum number of columns (or time-series variables).
coerce_to_numpy : bool, optional (default=False)
If True, X will be coerced to a 3-dimensional numpy array.
coerce_to_pandas : bool, optional (default=False)
If True, X will be coerced to a nested pandas DataFrame.
Returns
-------
X : pd.DataFrame or np.array
Checked and possibly converted input data
Raises
------
ValueError
If X is invalid input data
"""
# check input type
if coerce_to_pandas and coerce_to_numpy:
raise ValueError(
"`coerce_to_pandas` and `coerce_to_numpy` cannot " "both be set to True"
)
if not isinstance(X, VALID_X_TYPES):
raise ValueError(
f"X must be a pd.DataFrame or a np.array, " f"but found: {type(X)}"
)
# check np.array
# check first if we have the right number of dimensions, otherwise we
# may not be able to get the shape of the second dimension below
if isinstance(X, np.ndarray):
if not X.ndim == 3:
raise ValueError(
f"If passed as a np.array, X must be a 3-dimensional "
f"array, but found shape: {X.shape}"
)
if coerce_to_pandas:
X = from_3d_numpy_to_nested(X)
# enforce minimum number of columns
n_columns = X.shape[1]
if n_columns < enforce_min_columns:
raise ValueError(
f"X must contain at least: {enforce_min_columns} columns, "
f"but found only: {n_columns}."
)
# enforce univariate data
if enforce_univariate and n_columns > 1:
raise ValueError(
f"X must be univariate with X.shape[1] == 1, but found: "
f"X.shape[1] == {n_columns}."
)
# enforce minimum number of instances
if enforce_min_instances > 0:
_enforce_min_instances(X, min_instances=enforce_min_instances)
# check pd.DataFrame
if isinstance(X, pd.DataFrame):
if not is_nested_dataframe(X):
raise ValueError(
"If passed as a pd.DataFrame, X must be a nested "
"pd.DataFrame, with pd.Series or np.arrays inside cells."
)
# convert pd.DataFrame
if coerce_to_numpy:
X = from_nested_to_3d_numpy(X)
return X