def test_tabularize(): n_obs_X = 20 n_cols_X = 3 X = generate_df_from_array(np.random.normal(size=n_obs_X), n_rows=10, n_cols=n_cols_X) # Test single series input. Xt = tabularize(X.iloc[:, 0], return_array=True) assert Xt.shape[0] == X.shape[0] assert Xt.shape[1] == n_obs_X Xt = tabularize(X.iloc[:, 0]) assert Xt.index.equals(X.index) # Test dataframe input with columns having series of different length. n_obs_Y = 13 n_cols_Y = 2 Y = generate_df_from_array(np.random.normal(size=n_obs_Y), n_rows=10, n_cols=n_cols_Y) X = pd.concat([X, Y], axis=1) Xt = tabularize(X, return_array=True) assert Xt.shape[0] == X.shape[0] assert Xt.shape[1] == (n_cols_X * n_obs_X) + (n_cols_Y * n_obs_Y) Xt = tabularize(X) assert Xt.index.equals(X.index)
def test_row_transformer_transform_inverse_transform(): X, y = load_gunpoint(return_X_y=True) t = RowTransformer(StandardScaler()) Xt = t.fit_transform(X) Xit = t.inverse_transform(Xt) assert Xit.shape == X.shape assert isinstance(Xit.iloc[0, 0], ( pd.Series, np.ndarray)) # check series-to-series transforms np.testing.assert_array_almost_equal(tabularize(X).values, tabularize(Xit).values, decimal=5)
def test_random_state(): X = generate_df_from_array(np.random.normal(size=10)) random_state = 1234 for n_intervals in [0.5, 10, 'sqrt', 'random', 'log']: trans = RandomIntervalSegmenter(n_intervals=n_intervals, random_state=random_state) first_Xt = trans.fit_transform(X) for _ in range(N_ITER): trans = RandomIntervalSegmenter(n_intervals=n_intervals, random_state=random_state) Xt = trans.fit_transform(X) np.testing.assert_array_equal(tabularize(first_Xt).values, tabularize(Xt).values)
def distance(instance_a, instance_b, **params): # find distance instance_a = tabularize(instance_a, return_array=True) # todo use specific # dimension rather than whole # thing? instance_b = tabularize(instance_b, return_array=True) # todo use specific # dimension rather than whole thing? instance_a = np.transpose(instance_a) instance_b = np.transpose(instance_b) return distance_measure(instance_a, instance_b, **params)
def test_output_format_dim(len_series, n_instances, n_components): np.random.seed(42) X = detabularize(pd.DataFrame(data=np.random.randn(n_instances, len_series))) trans = PCATransformer(n_components=n_components) Xt = trans.fit_transform(X) # Check number of rows and output type. assert isinstance(Xt, pd.DataFrame) assert Xt.shape[0] == X.shape[0] # Check number of principal components in the output. assert tabularize(Xt).shape[1] == min(n_components, tabularize(X).shape[1])
def transform(self, X, y=None): """ Transform X, transforms univariate time-series using sklearn's PCA class Parameters ---------- X : nested pandas DataFrame of shape [n_samples, 1] Nested dataframe with univariate time-series in cells. Returns ------- Xt : pandas DataFrame Transformed pandas DataFrame with the same number of rows and the (potentially reduced) PCA transformed column. Time indices of the original column are replaced with 0:( n_components - 1). """ self.check_is_fitted() X = check_X(X, enforce_univariate=True) # Transform X using the fitted PCA Xtab = tabularize(X) Xpca = pd.DataFrame(data=self.pca.transform(Xtab), index=Xtab.index, columns=Xtab.columns[:self.pca.n_components_]) # Back-transform into time series data format Xt = detabularise(Xpca, index=X.index) Xt.columns = X.columns return Xt
def _transform_words(self, X): self.check_is_fitted() X = check_X(X, enforce_univariate=False) 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 = tabularize(X_dim, return_array=True) 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 fit(self, X, y=None): """Calculate word breakpoints using _mcb Parameters ---------- X : nested pandas DataFrame of shape [n_instances, 1] Nested dataframe with univariate time-series in cells. y : array-like, shape = [n_samples] or [n_samples, n_outputs] The class labels. Returns ------- self : object """ if self.alphabet_size < 2 or self.alphabet_size > 4: raise ValueError( "Alphabet size must be an integer between 2 and 4") if self.word_length < 1 or self.word_length > 16: raise ValueError("Word length must be an integer between 1 and 16") if self.igb and y is None: raise ValueError( "Class values must be provided for information gain binning") X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) self.n_instances, self.series_length = X.shape self.breakpoints = self._igb(X, y) if self.igb else self._mcb(X) self._is_fitted = True return self
def _transform_words(self, X): self.check_is_fitted() X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) bag_all_words = [dict() for _ in range(len(X))] for i, window_size in enumerate(self.window_sizes): # SFA transform sfa_words = self.SFA_transformers[i].transform(X) 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 for j in range(len(bag)): for (key, value) in bag[j].items(): # append the prefices to the words to distinguish # between window-sizes if isinstance(key, tuple): word = ( ((key[0] << self.highest_bit) | key[1]) << 3 ) | window_size else: # word = ((key << self.highest_bit) << 3) | window_size word = WEASEL.shift_left(key, self.highest_bit, window_size) bag_all_words[j][word] = value return bag_all_words
def predict(self, X): self.check_is_fitted() if isinstance(X, pd.Series) or isinstance(X, pd.DataFrame): X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) rng = check_random_state(self.random_state) classes = [] test_bags = self.transformer.transform(X) test_bags = test_bags[0] # .iloc[:, 0] for test_bag in test_bags: best_sim = -1 nn = None for n, bag in enumerate(self.transformed_data): sim = histogram_intersection(test_bag, bag) if sim > best_sim or (sim == best_sim and rng.random() < 0.5): best_sim = sim nn = self.class_vals[n] classes.append(nn) return np.array(classes)
def test_dft_mft(): # load training data X, Y = load_gunpoint(split="train", return_X_y=True) X_tab = tabularize(X, return_array=True) word_length = 6 alphabet_size = 4 print("Single DFT transformation") window_size = np.shape(X_tab)[1] p = SFA(word_length=word_length, alphabet_size=alphabet_size, window_size=window_size, binning_method="equi-depth").fit(X, Y) dft = p._discrete_fourier_transform(X_tab[0]) mft = p._mft(X_tab[0]) assert ((mft-dft < 0.0001).all()) print("Windowed DFT transformation") for norm in [True, False]: for window_size in [140]: p = SFA(word_length=word_length, norm=norm, alphabet_size=alphabet_size, window_size=window_size, binning_method="equi-depth").fit(X, Y) mft = p._mft(X_tab[0]) for i in range(len(X_tab[0]) - window_size + 1): dft_transformed = p._discrete_fourier_transform( X_tab[0, i:window_size+i]) assert(mft[i] - dft_transformed < 0.001).all() assert(len(mft) == len(X_tab[0]) - window_size + 1) assert(len(mft[0]) == word_length)
def _combine_data_frames(self, dataFrames, weighting_factor, col_names): """ Helper function for the shape_dtw class to combine two dataframes together into a single dataframe. Used when the shape_descriptor_function is set to "compound". """ first_desc = dataFrames[0] second_desc = dataFrames[1] first_desc_array = [] second_desc_array = [] # Convert the dataframes into arrays for x in first_desc.columns: first_desc_array.append( tabularize(first_desc[x], return_array=True)) for x in second_desc.columns: second_desc_array.append( tabularize(second_desc[x], return_array=True)) # Concatenate the arrays together res = [] for x in range(len(first_desc_array)): dim1 = [] for y in range(len(first_desc_array[x])): dim2 = [] dim2.extend(first_desc_array[x][y]) dim2.extend(second_desc_array[x][y] * weighting_factor) dim1.append(dim2) res.append(dim1) res = np.asarray(res) # Convert to pandas dataframe df = pd.DataFrame() for col in col_names: colToAdd = [] for row in range(len(res[col])): inst = res[col][row] colToAdd.append(pd.Series(inst)) df[col] = colToAdd return df
def transform(self, X, y=None): """ Parameters ---------- X : nested pandas DataFrame of shape [n_instances, 1] Nested dataframe with univariate time-series in cells. Returns ------- dims: Pandas data frame with first dimension in column zero """ self.check_is_fitted() X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) num_atts = X.shape[1] num_insts = X.shape[0] dims = pd.DataFrame() data = [] for i in range(num_insts): series = X[i, :] frames = [] current_frame = 0 current_frame_size = 0 frame_length = num_atts / self.num_intervals frame_sum = 0 for n in range(num_atts): remaining = frame_length - current_frame_size if remaining > 1: frame_sum += series[n] current_frame_size += 1 else: frame_sum += remaining * series[n] current_frame_size += remaining if current_frame_size == frame_length: frames.append(frame_sum / frame_length) current_frame += 1 frame_sum = (1 - remaining) * series[n] current_frame_size = (1 - remaining) # if the last frame was lost due to double imprecision if current_frame == self.num_intervals - 1: frames.append(frame_sum / frame_length) data.append(pd.Series(frames)) dims[0] = data return dims
def predict_proba(self, X): """ Find probability estimates for each class for all cases in X. Parameters ---------- X : The training input samples. array-like or sparse matrix of shape = [n_test_instances, series_length] If a Pandas data frame is passed (sktime format) a check is performed that it only has one column. If not, an exception is thrown, since this classifier does not yet have multivariate capability. Local variables ---------- n_test_instances : int, number of cases to classify series_length : int, number of attributes in X, must match _num_atts determined in fit Returns ------- output : array of shape = [n_test_instances, num_classes] of probabilities """ self.check_is_fitted() X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) n_test_instances, series_length = X.shape if series_length != self.series_length: raise TypeError( " ERROR number of attributes in the train does not match " "that in the test data") sums = np.zeros((X.shape[0], self.n_classes), dtype=np.float64) for i in range(0, self.n_estimators): transformed_x = np.empty(shape=(3 * self.n_intervals, n_test_instances), dtype=np.float32) for j in range(0, self.n_intervals): means = np.mean( X[:, self.intervals[i][j][0]:self.intervals[i][j][1]], axis=1) std_dev = np.std( X[:, self.intervals[i][j][0]:self.intervals[i][j][1]], axis=1) slope = self._lsq_fit( X[:, self.intervals[i][j][0]:self.intervals[i][j][1]]) transformed_x[3 * j] = means transformed_x[3 * j + 1] = std_dev transformed_x[3 * j + 2] = slope transformed_x = transformed_x.T sums += self.classifiers[i].predict_proba(transformed_x) output = sums / (np.ones(self.n_classes) * self.n_estimators) return output
def transform(self, X, y=None): """ Transform X, segments time-series in each column into random intervals using interval indices generated during `fit`. Parameters ---------- X : nested pandas DataFrame of shape [n_samples, n_features] Nested dataframe with time-series in cells. Returns ------- Xt : pandas DataFrame Transformed pandas DataFrame with same number of rows and one column for each generated interval. """ # Check inputs. self.check_is_fitted() X = check_X(X) # Check that the input is of the same shape as the one passed # during fit. if X.shape[1] != self.input_shape_[1]: raise ValueError( 'Number of columns of input is different from what was seen' 'in `fit`') # # Input validation # if not all([np.array_equal(fit_idx, trans_idx) # for trans_idx, fit_idx in zip(check_equal_index(X), # self._time_index)]): # raise ValueError('Indexes of input time-series are different # from what was seen in `fit`') # Segment into intervals. # TODO generalise to non-equal-index cases intervals = [] colname = X.columns[0] colnames = [] # Tabularise assuming series arr = tabularize(X, return_array=True) # have equal indexes in any given column print(self.intervals_) for start, end in self.intervals_: interval = arr[:, start:end] intervals.append(interval) colnames.append(f"{colname}_{start}_{end}") # Return nested pandas DataFrame. Xt = pd.DataFrame(concat_nested_arrays(intervals, return_arrays=True)) Xt.columns = colnames return Xt
def test_tsfresh_extractor(default_fc_parameters): X, y = make_classification_problem() X_train, X_test, y_train, y_test = train_test_split(X, y) transformer = TSFreshFeatureExtractor( default_fc_parameters=default_fc_parameters, disable_progressbar=True) Xt = transformer.fit_transform(X_train, y_train) actual = Xt.filter(like="__mean", axis=1).values.ravel() expected = tabularize(X_train).mean(axis=1).values assert expected[0] == X_train.iloc[0, 0].mean() np.testing.assert_allclose(actual, expected)
def _apply_rowwise(self, func, X, y=None): """Helper function to apply transform or inverse_transform function on each row of data container""" self.check_is_fitted() X = check_X(X) # 1st attempt: apply, relatively fast but not robust # try and except, but sometimes breaks in other cases than excepted # ValueError # Works on single column, but on multiple columns only if columns # have equal-length series. # try: # Xt = X.apply(self.transformer.fit_transform) # # # Otherwise call apply on each column separately. # except ValueError as e: # if str(e) == "arrays must all be same length": # Xt = pd.concat([pd.Series(col.apply( # self.transformer.fit_transform)) for _, col in X.items()], # axis=1) # else: # raise # 2nd attempt: apply but iterate over columns, still relatively fast # but still not very robust # but column is not 2d and thus breaks if transformer expects 2d input try: Xt = pd.concat([pd.Series(col.apply(func)) for _, col in X.items()], axis=1) # 3rd attempt: explicit for-loops, most robust but very slow except Exception: cols_t = [] for c in range(X.shape[1]): # loop over columns col = X.iloc[:, c] rows_t = [] for row in col: # loop over rows in each column row_2d = pd.DataFrame(row) # convert into 2d dataframe row_t = func(row_2d).ravel() # apply transform rows_t.append(row_t) # append transformed rows cols_t.append(rows_t) # append transformed columns # if series-to-series transform, flatten transformed series Xt = concat_nested_arrays( cols_t) # concatenate transformed columns # tabularise/unnest series-to-primitive transforms xt = Xt.iloc[0, 0] if isinstance(xt, (pd.Series, np.ndarray)) and len(xt) == 1: Xt = tabularize(Xt) return Xt
def transform(self, X, y=None): """ Function to transform a data frame of time series data. Parameters ---------- X : a pandas dataframe of shape = [n_samples, num_dims] The training input samples. Returns ------- dims: a pandas data frame of shape = [n_samples, num_dims] """ # Check the data self.check_is_fitted() X = check_X(X, enforce_univariate=False) # Get information about the dataframe num_insts = X.shape[0] col_names = X.columns num_atts = len(X.iloc[0, 0]) # Check the parameters are appropriate self._check_parameters(num_atts) df = pd.DataFrame() for x in col_names: # Convert one of the columns in the dataframe to a numpy array arr = tabularize(pd.DataFrame(X[x]), return_array=True) # Get the HOG1Ds of each time series transformedData = [] for y in range(num_insts): inst = self._calculate_hog1ds(arr[y]) transformedData.append(inst) # Convert to numpy array transformedData = np.asarray(transformedData) # Add it to the dataframe colToAdd = [] for i in range(len(transformedData)): inst = transformedData[i] colToAdd.append(pd.Series(inst)) df[x] = colToAdd return df
def test_pca_results(n_components): np.random.seed(42) # sklearn X = pd.DataFrame(data=np.random.randn(10, 5)) pca = PCA(n_components=n_components) Xt1 = pca.fit_transform(X) # sktime Xs = detabularize(X) pca_transform = PCATransformer(n_components=n_components) Xt2 = pca_transform.fit_transform(Xs) assert np.allclose(np.asarray(Xt1), np.asarray(tabularize(Xt2)))
def transform(self, X, y=None): """ Function to perform the transformation on the time series data. Parameters ---------- X : a pandas dataframe of shape = [n_instances, 1] The training input samples. Returns ------- dims: a pandas data frame of shape = [n_instances, n_timepoints] """ # get the number of attributes and instances self.check_is_fitted() X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) n_timepoints = X.shape[1] n_instances = X.shape[0] # Check the parameters are appropriate self._check_parameters(n_timepoints) pad_amnt = math.floor(self.window_length/2) padded_data = np.zeros((n_instances, n_timepoints + (2*pad_amnt))) # Pad both ends of X for i in range(n_instances): padded_data[i] = np.pad(X[i], pad_amnt, mode='edge') subsequences = np.zeros((n_instances, n_timepoints, self.window_length)) # Extract subsequences for i in range(n_instances): subsequences[i] = self._extract_subsequences(padded_data[i], n_timepoints) # Convert this into a panda's data frame df = pd.DataFrame() for i in range(len(subsequences)): inst = subsequences[i] data = [] for j in range(len(inst)): data.append(pd.Series(inst[j])) df[i] = data return df.transpose()
def test_padding_paramterised_transformer(): # load data name = 'JapaneseVowels' X_train, y_train = _load_dataset(name, split='train', return_X_y=True) X_test, y_test = _load_dataset(name, split='test', return_X_y=True) # print(X_train) padding_transformer = PaddingTransformer(pad_length=40) Xt = padding_transformer.fit_transform(X_train) # when we tabulrize the data it has 12 dimensions # and we've truncated them all to (10-2) long. data = tabularize(Xt) assert len(data.columns) == 40 * 12
def test_padding_transformer(): # load data name = 'JapaneseVowels' X_train, y_train = _load_dataset(name, split='train', return_X_y=True) X_test, y_test = _load_dataset(name, split='test', return_X_y=True) # print(X_train) padding_transformer = PaddingTransformer() Xt = padding_transformer.fit_transform(X_train) # when we tabulrize the data it has 12 dimensions # and we've padded them to there normal length of 29 data = tabularize(Xt) assert len(data.columns) == 29 * 12
def test_truncation_transformer(): # load data name = 'JapaneseVowels' X_train, y_train = _load_dataset(name, split='train', return_X_y=True) X_test, y_test = _load_dataset(name, split='test', return_X_y=True) # print(X_train) truncated_transformer = TruncationTransformer(5) Xt = truncated_transformer.fit_transform(X_train) # when we tabulrize the data it has 12 dimensions # and we've truncated them all to 5 long. data = tabularize(Xt) assert len(data.columns) == 5 * 12
def predict_proba(self, X): self.check_is_fitted() X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) sums = np.zeros((X.shape[0], self.n_classes)) for n, clf in enumerate(self.classifiers): preds = clf.predict(X) for i in range(0, X.shape[0]): sums[i, self.class_dictionary[preds[i]]] += self.weights[n] dists = sums / (np.ones(self.n_classes) * self.weight_sum) return dists
def transform(self, X, y=None): self.check_is_fitted() X = check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) bags = pd.DataFrame() dim = [] for i in range(X.shape[0]): dfts = self._mft(X[i, :]) bag = {} last_word = -1 repeat_words = 0 words = [] for window in range(dfts.shape[0]): word_raw = _create_word(dfts[window], self.word_length, self.alphabet_size, self.breakpoints) word = _BitWord(word=word_raw) words.append(word) repeat_word = (self._add_to_pyramid( bag, word, last_word, window - int(repeat_words / 2)) if self.levels > 1 else self._add_to_bag(bag, word, last_word)) if repeat_word: repeat_words += 1 else: last_word = word.word repeat_words = 0 if self.bigrams: if window - self.window_size >= 0 and window > 0: bigram = words[window - self.window_size] \ .create_bigram(word, self.word_length) if self.levels > 1: bigram = (bigram, 0) bag[bigram] = bag.get(bigram, 0) + 1 if self.save_words: self.words.append(words) dim.append(pd.Series(bag)) bags[0] = dim return bags
def transform(self, X, y=None): """ Parameters ---------- X : a pandas dataframe of shape = [n_samples, num_dims] The training input samples. Returns ------- df: a pandas data frame of shape = [num_intervals, num_dims] """ # Check the data self.check_is_fitted() X = check_X(X, enforce_univariate=False) # Get information about the dataframe n_timepoints = len(X.iloc[0, 0]) num_instances = X.shape[0] col_names = X.columns self._check_parameters(n_timepoints) df = pd.DataFrame() for x in col_names: # Convert one of the columns in the dataframe to numpy array arr = tabularize(pd.DataFrame(X[x]), return_array=True) # Calculate gradients transformedData = [] for y in range(num_instances): res = self._get_gradients_of_lines(arr[y]) transformedData.append(res) # Convert to Numpy array transformedData = np.asarray(transformedData) # Add it to the dataframe colToAdd = [] for i in range(len(transformedData)): inst = transformedData[i] colToAdd.append(pd.Series(inst)) df[x] = colToAdd return df
def transform(self, X, y=None): """Transform nested pandas dataframe into tabular dataframe. Parameters ---------- X : pandas DataFrame Nested dataframe with pandas series or numpy arrays in cells. y : array-like, optional (default=None) Returns ------- Xt : pandas DataFrame Transformed dataframe with only primitives in cells. """ self.check_is_fitted() X = check_X(X) return tabularize(X)
def fit(self, X, y): if isinstance(X, pd.Series) or isinstance(X, pd.DataFrame): X, y = check_X_y(X, y, enforce_univariate=True) X = tabularize(X, return_array=True) sfa = self.transformer.fit_transform(X, y) self.transformed_data = sfa[0] # .iloc[:, 0] self.class_vals = y self.num_classes = np.unique(y).shape[0] self.classes_ = class_distribution(np.asarray(y).reshape(-1, 1))[0][0] for index, classVal in enumerate(self.classes_): self.class_dictionary[classVal] = index self._is_fitted = True return self
def _perform_paa_along_dim(self, X): X = tabularize(X, return_array=True) num_atts = X.shape[1] num_insts = X.shape[0] dims = pd.DataFrame() data = [] for i in range(num_insts): series = X[i, :] frames = [] current_frame = 0 current_frame_size = 0 frame_length = num_atts / self.num_intervals frame_sum = 0 for n in range(num_atts): remaining = frame_length - current_frame_size if remaining > 1: frame_sum += series[n] current_frame_size += 1 else: frame_sum += remaining * series[n] current_frame_size += remaining if current_frame_size == frame_length: frames.append(frame_sum / frame_length) current_frame += 1 frame_sum = (1 - remaining) * series[n] current_frame_size = (1 - remaining) # if the last frame was lost due to double imprecision if current_frame == self.num_intervals - 1: frames.append(frame_sum / frame_length) data.append(pd.Series(frames)) dims[0] = data return dims
def predict_proba(self, X): """ Find probability estimates for each class for all cases in X. Parameters ---------- X : array-like or sparse matrix of shape = [n_instances, n_columns] The training input samples. If a Pandas data frame is passed, Local variables ---------- n_samps : int, number of cases to classify n_columns : int, number of attributes in X, must match _num_atts determined in fit Returns ------- output : array of shape = [n_instances, n_classes] of probabilities """ self.check_is_fitted() check_X(X, enforce_univariate=True) X = tabularize(X, return_array=True) n_cases, n_columns = X.shape if n_columns != self.series_length: raise TypeError( " ERROR number of attributes in the train does not match " "that in the test data") sums = np.zeros((X.shape[0], self.n_classes), dtype=np.float64) for i in range(0, self.n_estimators): acf_x = np.empty(shape=(n_cases, self.lags[i])) ps_len = (self.intervals[i][1] - self.intervals[i][0]) / 2 ps_x = np.empty(shape=(n_cases, int(ps_len))) for j in range(0, n_cases): acf_x[j] = acf(X[j, self.intervals[i][0]:self.intervals[i][1]], self.lags[i]) ps_x[j] = ps(X[j, self.intervals[i][0]:self.intervals[i][1]]) transformed_x = np.concatenate((acf_x, ps_x), axis=1) sums += self.estimators_[i].predict_proba(transformed_x) output = sums / (np.ones(self.n_classes) * self.n_estimators) return output