def onetrial_feature(self, data):
'''
Generate multiscale Riemannian one trial and temp window
Parameters
----------
data: array, shape (n_channel,n_samples)
input time samples
Return
------
feat: array, shape: if vectorized: (n_freq x n_riemann)
else (n_freq , n_riemann)
'''
n_samples = data.shape[1]
feat = np.zeros((self.n_freq, self.n_riemann))
for freq_idx in range(self.n_freq):
# filter signal
data_filter = butter_fir_filter(data, self.filter_bank[freq_idx])
# regularized covariance matrix
cov_mat = 1 / (n_samples - 1) * np.dot(
data_filter, np.transpose(data_filter)
) + self.rho / n_samples * np.eye(self.n_channel)
#
feat[freq_idx] = self.riem_kernel(cov_mat,
self.c_ref_invsqrtm[freq_idx])
if self.vectorized:
return feat.reshape(-1)
else:
return feat
def extract_feature(data, w, filter_bank, time_windows, do_vectorization=True):
''' calculate features using the precalculated spatial filters
Keyword arguments:
data -- numpy array of size [NO_trials,channels,time_samples]
w -- spatial filters, numpy array of size [NO_timewindows,NO_freqbands,22,NO_csp]
filter_bank -- numpy array containing butter sos filter coeffitions dim [NO_bands,order,6]
time_windows -- numpy array [[start_time1,end_time1],...,[start_timeN,end_timeN]]
Return: features, numpy array of size [NO_trials,(NO_csp*NO_bands*NO_time_windows)]
'''
NO_csp = len(w[0, 0, 0, :])
time_windows = time_windows.reshape((-1, 2))
NO_time_windows = int(time_windows.size / 2)
NO_bands = filter_bank.shape[0]
NO_trials = len(data[:, 0, 0])
NO_features = NO_csp * NO_bands * NO_time_windows
feature_mat = np.zeros((NO_trials, NO_time_windows, NO_bands, NO_csp))
# initialize feature vector
feat = np.zeros((NO_time_windows, NO_bands, NO_csp))
# go through all trials
for trial in range(0, NO_trials):
# iterate through all time windows
for t_wind in range(0, NO_time_windows):
# get start and end point of current time window
t_start = time_windows[t_wind, 0]
t_end = time_windows[t_wind, 1]
for subband in range(0, NO_bands):
#Apply spatial Filter to data
cur_data_s = np.dot(np.transpose(w[t_wind, subband]),
data[trial, :, t_start:t_end])
#frequency filtering
cur_data_f_s = butter_fir_filter(cur_data_s,
filter_bank[subband])
# calculate variance of all channels
feat[t_wind, subband] = np.var(cur_data_f_s, axis=1)
# calculate log10 of normalized feature vector
for subband in range(0, NO_bands):
feat[:,
subband] = np.log10(feat[:,
subband]) #/np.sum(feat[:,subband]))
# store feature in list
feature_mat[trial, :, :, :] = feat
if do_vectorization:
return np.reshape(feature_mat, (NO_trials, -1)) #
else:
return feature_mat
def features(self, data):
'''
Generate multiscale Riemannian features
Parameters
----------
data: array, shape (n_trial,n_channel,n_samples)
input time samples
Return
------
feat: array, shape: if vectorized: (n_trial,(n_temp x n_freq x n_riemann)
else (n_trial,n_temp , n_freq , n_riemann)
'''
n_trial = data.shape[0]
feat = np.zeros((n_trial, self.n_temp, self.n_freq, self.n_riemann))
# calculate training covariance matrices
for trial_idx in range(n_trial):
for temp_idx in range(self.n_temp):
t_start, t_end = self.temp_windows[
temp_idx, 0], self.temp_windows[temp_idx, 1]
n_samples = t_end - t_start
for freq_idx in range(self.n_freq):
# filter signal
data_filter = butter_fir_filter(
data[trial_idx, :, t_start:t_end],
self.filter_bank[freq_idx])
# regularized covariance matrix
cov_mat = 1 / (n_samples - 1) * np.dot(
data_filter, np.transpose(data_filter)
) + self.rho / n_samples * np.eye(self.n_channel)
#
feat[trial_idx, temp_idx, freq_idx] = self.riem_kernel(
cov_mat, self.c_ref_invsqrtm[freq_idx])
if self.vectorized:
return feat.reshape(n_trial, -1)
else:
return feat
def fit(self, data):
'''
Calculate average covariance matrices and return freatures of training data
Parameters
----------
data: array, shape (n_tr_trial,n_channel,n_samples)
input training time samples
Return
------
train_feat: array, shape: if vectorized: (n_tr_trial,(n_temp x n_freq x n_riemann)
else (n_tr_trial,n_temp , n_freq , n_riemann)
'''
n_tr_trial, n_channel, _ = data.shape
self.n_channel = n_channel
self.n_riemann = int((n_channel + 1) * n_channel / 2)
cov_mat = np.zeros(
(n_tr_trial, self.n_temp, self.n_freq, n_channel, n_channel))
# calculate training covariance matrices
for trial_idx in range(n_tr_trial):
for temp_idx in range(self.n_temp):
t_start, t_end = self.temp_windows[
temp_idx, 0], self.temp_windows[temp_idx, 1]
n_samples = t_end - t_start
for freq_idx in range(self.n_freq):
# filter signal
data_filter = butter_fir_filter(
data[trial_idx, :, t_start:t_end],
self.filter_bank[freq_idx])
# regularized covariance matrix
cov_mat[trial_idx, temp_idx,
freq_idx] = 1 / (n_samples - 1) * np.dot(
data_filter, np.transpose(data_filter)
) + self.rho / n_samples * np.eye(n_channel)
# calculate mean covariance matrix
self.c_ref_invsqrtm = np.zeros((self.n_freq, n_channel, n_channel))
for freq_idx in range(self.n_freq):
if self.riem_opt == 'No_Adaptation':
self.c_ref_invsqrtm[freq_idx] = np.eye(n_channel)
else:
# Mean covariance matrix over all trials and temp winds per frequency band
cov_avg = mean.mean_covariance(cov_mat[:, :, freq_idx].reshape(
-1, n_channel, n_channel),
metric=self.mean_metric)
self.c_ref_invsqrtm[freq_idx] = base.invsqrtm(cov_avg)
# calculate training features
train_feat = np.zeros(
(n_tr_trial, self.n_temp, self.n_freq, self.n_riemann))
for trial_idx in range(n_tr_trial):
for temp_idx in range(self.n_temp):
for freq_idx in range(self.n_freq):
train_feat[trial_idx, temp_idx,
freq_idx] = self.riem_kernel(
cov_mat[trial_idx, temp_idx, freq_idx],
self.c_ref_invsqrtm[freq_idx])
if self.vectorized:
return train_feat.reshape(n_tr_trial, -1)
else:
return train_feat
def generate_projection(data,
class_vec,
NO_csp,
filter_bank,
time_windows,
NO_classes=4):
''' generate spatial filters for every timewindow and frequancy band
Keyword arguments:
data -- numpy array of size [NO_trials,channels,time_samples]
class_vec -- containing the class labels, numpy array of size [NO_trials]
NO_csp -- number of spatial filters (24)
filter_bank -- numpy array containing butter sos filter coeffitions dim [NO_bands,order,6]
time_windows -- numpy array [[start_time1,end_time1],...,[start_timeN,end_timeN]]
Return: spatial filter numpy array of size [NO_timewindows,NO_freqbands,22,NO_csp]
'''
time_windows = time_windows.reshape((-1, 2))
NO_bands = filter_bank.shape[0]
NO_time_windows = len(time_windows[:, 0])
NO_channels = len(data[0, :, 0])
NO_trials = class_vec.size
# Initialize spatial filter:
w = np.zeros((NO_time_windows, NO_bands, NO_channels, NO_csp))
# iterate through all time windows
for t_wind in range(0, NO_time_windows):
# get start and end point of current time window
t_start = time_windows[t_wind, 0]
t_end = time_windows[t_wind, 1]
# iterate through all frequency bandwids
for subband in range(0, NO_bands):
cov = np.zeros(
(NO_classes, NO_trials, NO_channels,
NO_channels)) # sum of covariance depending on the class
cov_avg = np.zeros((NO_classes, NO_channels, NO_channels))
cov_cntr = np.zeros(NO_classes).astype(
int) # counter of class occurence
#go through all trials and estimate covariance matrix of every class
for trial in range(0, NO_trials):
#frequency band of every channel
data_filter = butter_fir_filter(data[trial, :, t_start:t_end],
filter_bank[subband])
cur_class_idx = int(class_vec[trial] - 1)
# caclulate current covariance matrix
cov[cur_class_idx, cov_cntr[cur_class_idx], :, :] = np.dot(
data_filter, np.transpose(data_filter))
# update covariance matrix and class counter
cov_cntr[cur_class_idx] += 1
# calculate average of covariance matrix
for clas in range(0, NO_classes):
cov_avg[clas, :, :] = rie_mean.mean_covariance(
cov[clas, :cov_cntr[clas], :, :], metric='euclid')
w[t_wind, subband, :, :] = csp_one_one(cov_avg, NO_csp, NO_classes)
return w
