def _manage_params(self):
self._manage_files()
mgr = read_manager.ReadManager(self.f_info, self.f_data, self.f_tags)
self.set_param('sample_type', mgr.get_param('sample_type'))
self.set_param('sampling_rate',
str(int(float(mgr.get_param('sampling_frequency')))))
self.set_param('channel_names',
';'.join(mgr.get_param('channels_names')))
self.set_param('active_channels', self.get_param('channel_names'))
self.set_param('channel_gains',
';'.join(mgr.get_param('channels_gains')))
self.set_param('channel_offsets',
';'.join(mgr.get_param('channels_offsets')))
self._samples = mgr.get_samples()
self._tags = mgr.get_tags()
self._ind = 0
super(PyAmplifierFile, self)._manage_params()
def montage_custom(mgr, chnls):
'''apply custom montage to manager, by chnls'''
indexes = []
for chnl in chnls:
index = mgr.get_param('channels_names').index(chnl)
if index < 0:
raise Exception("Montage - couldn`t channel: " + str(chnl))
else:
indexes.append(index)
new_samples = get_montage(
mgr.get_samples(),
get_montage_matrix_custom(int(mgr.get_param('number_of_channels')),
indexes))
info_source = copy.deepcopy(mgr.info_source)
tags_source = copy.deepcopy(mgr.tags_source)
samples_source = read_data_source.MemoryDataSource(new_samples)
return read_manager.ReadManager(info_source, samples_source, tags_source)
def filter(mgr,
wp,
ws,
gpass,
gstop,
analog=0,
ftype='ellip',
output='ba',
unit='radians',
use_filtfilt=False):
if unit == 'radians':
b, a = signal.iirdesign(wp, ws, gpass, gstop, analog, ftype, output)
elif unit == 'hz':
sampling = float(mgr.get_param('sampling_frequency'))
try:
wp = wp / sampling
ws = ws / sampling
except TypeError:
wp = [i / sampling for i in wp]
ws = [i / sampling for i in ws]
b, a = signal.iirdesign(wp, ws, gpass, gstop, analog, ftype, output)
if use_filtfilt:
import filtfilt
#samples_source = read_data_source.MemoryDataSource(mgr.get_samples(), False)
for i in range(int(mgr.get_param('number_of_channels'))):
print("FILT FILT CHANNEL " + str(i))
mgr.get_samples()[i, :] = filtfilt.filtfilt(
b, a,
mgr.get_samples()[i])
samples_source = read_data_source.MemoryDataSource(
mgr.get_samples(), False)
else:
print("FILTER CHANNELs")
filtered = signal.lfilter(b, a, mgr.get_samples())
print("FILTER CHANNELs finished")
samples_source = read_data_source.MemoryDataSource(filtered, True)
info_source = copy.deepcopy(mgr.info_source)
tags_source = copy.deepcopy(mgr.tags_source)
new_mgr = read_manager.ReadManager(info_source, samples_source,
tags_source)
return new_mgr
def make_new_file(self, old_file):
in_file = acquisition_helper.get_file_path(self.file_path, old_file)
try:
manager = read_manager.ReadManager(in_file + ".obci.xml",
in_file + ".obci.raw",
in_file + ".obci.tag")
except IOError:
self.logger.error("No such file or directory: {}".format(in_file))
sys.exit(1)
fs = int(float(manager.get_param("sampling_frequency")))
data = manager.get_samples()
self.logger.info(
"START resampling: file: {}, old_fs = {} Hz, new_fs = {} Hz...".
format(old_file, fs, self.new_fs))
if not fs % self.new_fs == 0:
self.logger.error(
"WRONG new sampling frequency!!\n You can choose sampling frequency, which is the divisor of old sampling frequency"
)
sys.exit(0)
else:
sample_step = fs / self.new_fs
new_data = np.array(
[data[:, i] for i in range(0, data.shape[1], sample_step)]).T
manager.set_samples(new_data, manager.get_param("channels_names"))
manager.set_param("sampling_frequency", str(self.new_fs))
self.logger.info(
"FINISH resampling: file: {}, old_fs = {} Hz, new_fs = {} Hz".
format(old_file, fs, self.new_fs))
self.logger.info(
"START saving data to {}...".format(in_file + "_resampling_to_" +
str(self.new_fs)))
manager.save_to_file(self.file_path,
in_file + "_resampling_to_" + str(self.new_fs))
self.logger.info("FINISH saving new data")
def run(self):
self.logger.info("START FDA...")
f_name = self.config.get_param("data_file_name")
f_dir = self.config.get_param("data_file_path")
in_file = acquisition_helper.get_file_path(f_dir, f_name)
filename = os.path.join(f_dir, f_name + ".obci")
data = sp.signalParser(filename)
fs = int(float(data.getSamplingFrequency()))
mgr = read_manager.ReadManager(in_file + '.obci.xml',
in_file + '.obci.raw',
in_file + '.obci.tag')
if self.use_channels is None:
self.use_channels = data.getChannelList()
if self.ignore_channels is not None:
for i in self.ignore_channels:
try:
self.use_channels.remove(i)
except:
pass
self.montage = self.config.get_param("montage")
tmp = self.config.get_param("montage_channels")
if len(tmp) > 0:
self.montage_channels = tmp.split(';')
else:
self.montage_channels = []
self.logger.info("USE CHANNELS: " + str(self.use_channels))
self.logger.info("CHANNELS NAMES: " +
str(mgr.get_param('channels_names')))
## Get data and tags
data.setMontage(self.montage_channels)
Signal = data.getData(self.use_channels)
trgTags = data.get_p300_tags()
ntrgTags = data.get_not_p300_tags()
print "Signal.shape[1]: ", Signal.shape[1]
print "last trg: ", trgTags[-1]
print "last ntrg: ", ntrgTags[-1]
m = max([trgTags[-1], ntrgTags[-1]])
# ?!?!?!?!?!?!?!?! Why blinks are <0
trgTags = trgTags[trgTags > 0]
ntrgTags = ntrgTags[ntrgTags > 0]
trgTags = trgTags[trgTags < Signal.shape[1] - fs]
ntrgTags = ntrgTags[ntrgTags < Signal.shape[1] - fs]
print "last trg: ", trgTags[-1]
print "last ntrg: ", ntrgTags[-1]
target, nontarget = data.getTargetNontarget(Signal, trgTags, ntrgTags)
## Get params from file
pPer = float(self.config.get_param("p_per"))
nRepeat = int(self.config.get_param("n_repeat"))
nMin = int(self.config.get_param("n_min"))
nMax = int(self.config.get_param("n_max"))
avrM_l = map(lambda x: int(x),
self.config.get_param("avr_m").split(';'))
conN_l = map(lambda x: int(x),
self.config.get_param("con_n").split(';'))
csp_dt_l = map(lambda x: float(x),
self.config.get_param("csp_dt").split(';'))
csp_time_l = map(lambda x: float(x),
self.config.get_param("csp_time").split(';'))
plotFlag = int(self.config.get_param("plot_flag"))
debugFlag = int(self.config.get_param("debug_flag"))
## Define buffer
buffer = 1.1 * fs
self.logger.info("Computer buffer len: " + str(buffer))
## Make montage matrix
conf = self.use_channels, self.montage, self.montage_channels
self.montage_matrix = self._get_montage_matrix(
conf[0], conf[1], conf[2], mgr.get_param('channels_names'))
print "self.montage_matrix: ", self.montage_matrix
channels = ";".join(self.use_channels)
# Test all combination of parameters
N = 0
d = {}
for avrM in avrM_l:
for conN in conN_l:
for csp_time in csp_time_l:
for dt in csp_dt_l:
d[N] = {
"avrM": avrM,
"conN": conN,
"csp_time": [csp_time, csp_time + dt]
}
print "d[%i] = " % N, d[N]
N += 1
#################################
## CROSS CHECKING
P_dict, dVal_dict = {}, {}
l = np.zeros(N)
for idxN in range(N):
KEY = d[idxN].keys()
for k in KEY:
exec "{0}_tmp = {1}".format(k,
d[idxN][k]) in globals(), locals()
self.logger.info("Zestaw: {0} / {1}".format(idxN, N))
self.logger.info(str(d[idxN]))
csp = csp_time_tmp[0] * fs, csp_time_tmp[1] * fs
# Crop signalas to csp_time : csp_time+csp_dt
_target = target[:, :, csp[0]:csp[1]]
_nontarget = nontarget[:, :, csp[0]:csp[1]]
p300 = P300_train(channels, fs, avrM_tmp, conN_tmp, csp_time_tmp,
pPer)
l[idxN] = p300.valid_kGroups(Signal, _target, _nontarget, 2)
P_dict[idxN] = p300.getPWC()
dVal_dict[idxN] = p300.getDValDistribution()
if debugFlag:
p300.saveDist2File("target_%i" % idxN, "nontarget_%i" % idxN)
self.logger.info("Test score: " + str(l[idxN]))
self.logger.info("Calibration passed")
#################################
if debugFlag:
distributionDraw = P300_draw(fs)
# Plot all d distributions
for idx in range(N):
dTarget, dNontarget = dVal_dict[idx]
distributionDraw.plotDistribution(dTarget, dNontarget)
#################################
# Finding best
self.logger.info("\n" * 5)
self.logger.info("L: " + str(l))
P, conN, avrM, csp_time = None, None, None, None
BEST = -1
arr = np.arange(len(l))
for i in range(5):
bestN = int(arr[l == l.min()][0])
print "best_{0}: {1}".format(i, bestN)
print "d[bestN]: ", d[bestN]
print "l[bestN]: ", l.min()
if (l.min() > 100) and (BEST == -1): BEST = bestN
l[bestN] = l.max() - 1
P, w, c = P_dict[BEST]
dTarget, dNontarget = dVal_dict[BEST]
pVal = st.scoreatpercentile(dNontarget, pPer)
pdf = dNontarget
avrM = d[BEST]["avrM"]
conN = d[BEST]["conN"]
csp_time = d[BEST]["csp_time"]
cfg = {
"csp_time": csp_time,
"use_channels": ';'.join(self.use_channels),
'avrM': avrM,
'conN': conN,
'pdf': pdf,
"P": P,
"w": w,
"c": c,
"montage": self.montage,
"montage_channels": ';'.join(self.montage_channels),
"buffer": buffer
}
f_name = self.config.get_param("fda_file_name")
f_dir = self.config.get_param("fda_file_path")
csp_helper.set_csp_config(f_dir, f_name, cfg)
if plotFlag:
## Plotting best
p300_draw = P300_draw()
p300_draw.setCalibration(target, nontarget)
p300_draw.setCSP(P)
p300_draw.setTimeLine(conN, avrM, csp_time)
p300_draw.plotSignal()
#~ p300_draw.plotSignal_ds()
self.logger.info("FDA classifier -- DONE")
if not self.run_offline:
self._run_next_scenario()
def montage_custom_matrix(mgr, montage_matrix):
new_samples = get_montage(mgr.get_samples(), montage_matrix)
info_source = copy.deepcopy(mgr.info_source)
tags_source = copy.deepcopy(mgr.tags_source)
samples_source = read_data_source.MemoryDataSource(new_samples)
return read_manager.ReadManager(info_source, samples_source, tags_source)
def find_and_print(info_file, data_file, spare_memory=True):
manager = read_manager.ReadManager(info_file, data_file, None)
l = find_lost_samples(manager, spare_memory=spare_memory)
print_result(l)
f['data'] = sys.argv[2]
else:
dr = '/media/windows/titanis/bci/projekty/eksperyment_mikolaj/dane_07_12_2010/201/'
f_name = 'test2-Tue_Dec__7_14_03_55_2010'
f = {
'info': os.path.join(dr, f_name + '.obci.info'),
'data': os.path.join(dr, f_name + '.obci.dat'),
#'tags':os.path.join(dr, f_name+'.obci.tags')
}
try:
spare_memory = int(sys.argv[3])
except:
spare_memory = True
try:
saw_name = sys.argv[4]
except:
saw_name = "DriverSaw"
print("ANALYSE: " + str(f))
manager = read_manager.ReadManager(
f['info'],
f['data'],
None #f['tags']
)
l = find_lost_samples(manager,
spare_memory=spare_memory,
saw_name=saw_name)
print_result(l)
def run(self):
LOGGER.info("START FDA...")
f_name = self.config.get_param("data_file_name")
f_dir = self.config.get_param("data_file_path")
in_file = acquisition_helper.get_file_path(f_dir, f_name)
filename = os.path.join(f_dir, f_name + ".obci")
data = sp.signalParser(filename)
fs = int(float(data.getSamplingFrequency()))
mgr = read_manager.ReadManager(in_file + '.obci.xml',
in_file + '.obci.raw',
in_file + '.obci.tag')
if self.use_channels is None:
self.use_channels = data.getChannelList()
if self.ignore_channels is not None:
for i in self.ignore_channels:
try:
self.use_channels.remove(i)
except:
pass
self.montage = self.config.get_param("montage")
tmp = self.config.get_param("montage_channels")
if len(tmp) > 0:
self.montage_channels = tmp.split(';')
else:
self.montage_channels = []
LOGGER.info("USE CHANNELS: " + str(self.use_channels))
LOGGER.info("CHANNELS NAMES: " + str(mgr.get_param('channels_names')))
## Get data and tags
data.setMontage(self.montage_channels)
Signal = data.getData(self.use_channels)
trgTags = data.get_p300_tags()
ntrgTags = data.get_not_p300_tags()
target, nontarget = data.getTargetNontarget(Signal, trgTags, ntrgTags)
## Get params from file
pVal = float(self.config.get_param("p_val"))
nRepeat = int(self.config.get_param("n_repeat"))
nMin = int(self.config.get_param("n_min"))
nMax = int(self.config.get_param("n_max"))
avrM_l = map(lambda x: int(x),
self.config.get_param("avr_m").split(';'))
conN_l = map(lambda x: int(x),
self.config.get_param("con_n").split(';'))
csp_dt_l = map(lambda x: float(x),
self.config.get_param("csp_dt").split(';'))
csp_time_l = map(lambda x: float(x),
self.config.get_param("csp_time").split(';'))
## Define buffer
buffer = 1.1 * fs
LOGGER.info("Computer buffer len: " + str(buffer))
## Make montage matrix
conf = self.use_channels, self.montage, self.montage_channels
self.montage_matrix = self._get_montage_matrix(
conf[0], conf[1], conf[2], mgr.get_param('channels_names'))
print "self.montage_matrix: ", self.montage_matrix
channels = ";".join(self.use_channels)
# make sure that:
# channels -- is in format like "P07;O1;Oz;O2"
# fs -- is a number
# avrM -- are int
# conN -- are int
# csp_time -- is a list of two float 0 < x < 1
N = 0
d, P_dict = {}, {}
for avrM in avrM_l:
for conN in conN_l:
for csp_time in csp_time_l:
for dt in csp_dt_l:
d[N] = {
"avrM": avrM,
"conN": conN,
"csp_time": [csp_time, csp_time + dt]
}
print "d[%i] = " % N, d[N]
N += 1
#################################
## CROSS CHECKING
l = np.zeros(N)
for idxN in range(N):
KEY = d[idxN].keys()
for k in KEY:
#~ c = "{0} = {1}".format(k, d[idxN][k])
#~ print c
#~ exec(c)
exec "{0}_tmp = {1}".format(k,
d[idxN][k]) in globals(), locals()
p300 = P300_train(channels, fs, avrM_tmp, conN_tmp, csp_time_tmp)
l[idxN] = p300.valid_kGroups(Signal, target, nontarget, 2)
P_dict[idxN] = p300.getPWC()
#################################
# Finding best
print "\n" * 5
print "L: ", l
P, conN, avrM, csp_time = None, None, None, None
BEST = -1
arr = np.arange(len(l))
for i in range(5):
bestN = int(arr[l == l.max()])
print "best_{0}: {1}".format(i, bestN)
print "d[bestN]: ", d[bestN]
print "l[bestN]: ", l.max()
if (l.max() < 1000) and (BEST == -1): BEST = bestN
l[bestN] = l.min() - 1
print "best: ", BEST
P, w, c = P_dict[BEST]
avrM = d[BEST]["avrM"]
conN = d[BEST]["conN"]
csp_time = d[BEST]["csp_time"]
cfg = {
"csp_time": csp_time,
"use_channels": ';'.join(self.use_channels),
'pVal': pVal,
'avrM': avrM,
'conN': conN,
"nRepeat": nRepeat,
"P": P,
"w": w,
"c": c,
"montage": self.montage,
"montage_channels": ';'.join(self.montage_channels),
"buffer": buffer
}
f_name = self.config.get_param("csp_file_name")
f_dir = self.config.get_param("csp_file_path")
ssvep_csp_helper.set_csp_config(f_dir, f_name, cfg)
## Plotting best
p300_draw = P300_draw()
p300_draw.setCalibration(target, nontarget, trgTags, ntrgTags)
p300_draw.setCSP(P)
p300_draw.setTimeLine(conN, avrM, csp_time)
p300_draw.plotSignal()
p300_draw.plotSignal_ds()
LOGGER.info("FDA Calibration complete")
if not self.run_offline:
self._run_next_scenario()
def gsr_dat_csv(files):
for f in files:
print("START GSR FOR " + str(f) +
"#############################################################")
csv = csv_manager.Writer(f['tags'] + '.gsr.csv',
d=';',
q=CCC.QUOTE_NONE)
csv.write_row(
['id', 'block_index', 'condition', 'gsr', 'gsr-base', 'gsr/base'])
mgr = read_manager.ReadManager(f['info'], f['data'], f['tags'])
sig = mgr.get_samples()
tags = mgr.get_tags(p_tag_type='word')
sf = float(mgr.get_param("sampling_frequency"))
gain = float(mgr.get_param('channels_gains')[0])
offset = float(mgr.get_param('channels_offsets')[0])
bs_tag = mgr.get_tags(p_tag_type='baseline')[0]
bs_raw = mgr.get_samples(
(bs_tag['start_timestamp'] + 7.0) * sf,
(bs_tag['end_timestamp'] - bs_tag['start_timestamp']) * sf)[0]
bs_unit = bs_raw * gain + offset
bs_avg = np.average(bs_unit)
print("GAIN / OFFSET / SF / BS_AVG / sig_len:")
print(gain, offset, sf, bs_avg, len(sig[0]))
curr_block = 0
last_ind = 0
start_ts = tags[0]['start_timestamp']
prev_tag = tags[0]
for i, t in enumerate(tags[1:]):
if int(t['desc']['block_index']) != curr_block:
print("How many tags?: " + str(i - last_ind))
last_ind = i
print("Signal to grab: from: " + str(start_ts) + "len: " +
str(prev_tag['end_timestamp'] - start_ts))
signal_start = int(start_ts * sf)
signal_len = int((prev_tag['end_timestamp'] - start_ts) * sf)
print("Signal to grab in samples: from: " + str(signal_start) +
"len: " + str(signal_len))
gsr = np.average(
mgr.get_samples(signal_start, signal_len)[0] * gain +
offset)
print("GSR!!!!!!!!!!!!!!!!: " + str(gsr))
print(
mgr.get_samples(signal_start, signal_len)[0] * gain +
offset)
gsr_base = gsr - bs_avg
gsrbase = gsr / bs_avg
csv.write_row([
f['info'][f['info'].rfind('/') + 1:f['info'].find('.')],
t['desc']['block_index'], t['desc']['condition'], gsr,
gsr_base, gsrbase
])
start_ts = t['start_timestamp']
curr_block = int(t['desc']['block_index'])
prev_tag = t
csv.close()
def run(self):
self.logger.info("START CSP...")
f_name = self.config.get_param("data_file_name")
f_dir = self.config.get_param("data_file_path")
in_file = acquisition_helper.get_file_path(f_dir, f_name)
mgr = read_manager.ReadManager(in_file + '.obci.xml',
in_file + '.obci.raw',
in_file + '.obci.tag')
fs = int(float(mgr.get_param("sampling_frequency")))
if self.use_channels is None:
self.use_channels = mgr.get_param('channels_names')
if self.ignore_channels is not None:
for i in self.ignore_channels:
try:
self.use_channels.remove(i)
except:
pass
self.logger.info("USE CHANNELS: " + str(self.use_channels))
csp_time = [0.0, 0.7]
data = p300.p300_train(in_file + '.obci',
self.use_channels,
fs,
self.montage_channels,
self.montage,
idx=1,
csp_time=csp_time) #idx oznacza indeks na który
new_tags = data.wyr()
not_idx_tags = data.data.get_p300_tags(
idx=1, rest=True,
samples=False) #Tutaj idx musi być -idx z linijki 11
#Tagi pozostałych przypadków
mean, left, right = data.get_mean(new_tags,
m_time=csp_time,
plot_mean=True)
buffer_start = int(-csp_time[0] * fs)
buffer_len = len(mean)
self.logger.info("Computer buffer start / len: " + str(buffer_start) +
" / " + str(buffer_len))
mean[:left] = 0
mean[right:] = 0
t_vec = data.show_mean_CSP(csp_time, new_tags)
plt.plot(t_vec, mean, 'r-')
plt.show()
sr = 12 #Maksymalna liczba odcinków do uśrednienia; gdzieś do parametryzacji
#targets = np.zeros([sr, len(new_tags)])
#non_targets = np.zeros([sr, len(not_idx_tags)])
#mu = np.zeros(sr)
#sigma = np.zeros(sr)
#for i in xrange(1, sr + 1):
#x = data.get_n_mean(i, new_tags, csp_time, 0.05)
#targets[i - 1, :], non_targets[i - 1, :], mu[i - 1], sigma[i - 1] = x
cl, mu, sigma, mean, left, right = data.prep_classifier(
sr, P_vectors=2, reg=1, mean_time=csp_time)
q = data
cfg = {
'mu': mu,
'sigma': sigma,
'mean': mean,
#'targets':targets,
#'non_targets':non_targets,
'q': q,
'buffer_len': buffer_len,
'buffer_start': buffer_start,
'use_channels': ';'.join(self.use_channels),
'montage': self.montage,
'montage_channels': ';'.join(self.montage_channels),
'left': left,
'right': right,
'cl': cl,
'a_features': data.a_features,
'bands': data.bands
}
f_name = self.config.get_param("csp_file_name")
f_dir = self.config.get_param("csp_file_path")
ssvep_csp_helper.set_csp_config(f_dir, f_name, cfg)
self.logger.info("CSP DONE")
if not self.run_offline:
self._run_next_scenario()
def run(in_file,
use_channels,
ignore_channels,
montage,
montage_channels,
dec_count,
plot_stats=True,
context=ctx.get_dummy_context('UgmBlinkingConnection')):
logger = context['logger']
mgr = read_manager.ReadManager(in_file + '.obci.xml',
in_file + '.obci.raw',
in_file + '.obci.tag')
to_frequency = int(float(mgr.get_param("sampling_frequency")))
if use_channels is None:
use_channels = mgr.get_param('channels_names')
if ignore_channels is not None:
for i in ignore_channels:
try:
use_channels.remove(i)
except:
pass
exp_info = mgr.get_tags('experimentInfo')[0]['desc']
to_signal = float(exp_info['target_time'])
freqs = [int(i) for i in exp_info['all_freqs'].split(';')]
data = sp.signalParser(in_file + '.obci')
train_tags = data.get_train_tags(trial_separator_name='diodes',
screen=True)
logger.info("Run csp with: use_channels: " + str(use_channels) +
" motage: " + str(montage) + " montage_channels: " +
str(montage_channels))
q = csp.modCSP(in_file + '.obci', freqs, use_channels, montage,
montage_channels)
q.start_CSP(to_signal,
to_frequency,
baseline=False,
filt='cheby',
method='regular',
train_tags=train_tags) #liczenie CSP
time = pylab.linspace(1, to_signal, 7)
t1, t2 = q.time_frequency_selection(to_frequency,
train_tags,
time=time,
frequency_no=dec_count,
plt=False)
logger.info("Got times t1: " + str(t1) + " and t2: " + str(t2))
logger.info("Set buffer time:" + str(t2))
value, mu, sigma, means, stds, out_top, out_bottom = q.count_stats(
to_signal, to_frequency, train_tags,
plt=plot_stats) #Liczenie statystyk
logger.info("For freqs: " + str(freqs))
logger.info("Got means: " + str(means))
pairs = zip(means, freqs)
pairs.sort(reverse=True)
logger.info("Sorted: " + str(pairs))
best = [i[1] for i in pairs]
best_means = [i[0] for i in pairs]
logger.info("Best freqs: " + str(best))
logger.info("dec_count: " + str(dec_count))
logger.info("freqs: " + str(best[:dec_count]))
logger.info("Finished CSP with stats:")
logger.info(str(value) + " / " + str(mu) + " / " + str(sigma))
logger.info("And q:")
logger.info(str(q))
d = {
'value': value,
'mu': mu,
'sigma': sigma,
'q': q,
'freqs': ';'.join([str(i) for i in best[:dec_count]]),
'all_freqs': ';'.join([str(i) for i in best]),
'all_means': ';'.join([str(i) for i in best_means]),
'dec_count': dec_count,
'buffer': t2,
'use_channels': ';'.join(use_channels),
'montage': montage,
'montage_channels': ';'.join(montage_channels),
'out_top': out_top,
'out_bottom': out_bottom
}
return d
