def __init__(self, addresses): super(LogicVenturesExperiment, self).__init__(addresses=addresses, type=peers.CLIENT) #initialise game engin for current user user_id = self.get_param('user_id') self.logger.info("Starting maze for user: "******"Unknown session name - abort") #initialise server to receive wii analysis messages from experiment server via udpServer srv = UdpServer(engine, self.get_param('internal_ip')) self.set_param('internal_port', str(srv.socket.getsockname()[1])) thread.start_new_thread(srv.run, ()) self.ready() engine.run() self.logger.info("Gui closed. Wait for finish saving..") acquisition_helper.finish_saving(addresses, ['wii']) self.logger.info("Finish saving ended! Exiting app ...") sys.exit(0)
def __init__(self, addresses): super(Downsampling, self).__init__(addresses=addresses, type=peers.CLIENT) self.new_fs = int(float(self.config.get_param("new_sampling_freq"))) file_name = self.config.get_param("file_name") self.file_path = self.config.get_param("file_path") if not file_name: _file = acquisition_helper.get_file_path(self.file_path, file_name) try: files = [f for f in listdir(_file) if isfile(join(_file, f))] except OSError: self.logger.error( "No such file or directory: {}".format(_file)) sys.exit(1) self.old_file = [f.split(".")[0] for f in files if "raw" in f] self.logger.info( "Prepered to resampling {} files from {}... \n files list: {}". format(len(self.old_file), self.file_path, self.old_file)) else: self.old_file = [file_name] self.logger.info( "Prepered to resampling {} file from {}...".format( self.old_file[0], self.file_path)) self.ready()
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 _init_save_file_name(self): file_name = open(get_file_path(self.file_with_name_path, self.file_with_name),'r').read() full_save_file_name = file_name + self.file_name_addition full_config_name = file_name + self.config_name_addition self.config.set_param('save_file_name', full_save_file_name) self.config.set_param('config_file_name', full_config_name)
def get_csp_config(path, name): file_name = acquisition_helper.get_file_path(path, name) csp_file = file_name+'.csp' f = open(csp_file, 'r') d = pickle.load(f) f.close() LOGGER.info("Got csp config:") LOGGER.info(str(d)) return d
def get_csp_config(path, name): file_name = acquisition_helper.get_file_path(path, name) csp_file = file_name + '.csp' f = open(csp_file, 'r') d = pickle.load(f) f.close() LOGGER.info("Got csp config:") LOGGER.info(str(d)) return d
def _init_save_file_name(self): file_name = open( get_file_path(self.file_with_name_path, self.file_with_name), 'r').read() full_save_file_name = file_name + self.file_name_addition full_config_name = file_name + self.config_name_addition self.config.set_param('save_file_name', full_save_file_name) self.config.set_param('config_file_name', full_config_name)
def _init_files(self): self.f_data = get_file_path(self.config.get_param('data_file_dir'), self.config.get_param('data_file_name')+'.obci.raw') i_dir = self.config.get_param('info_file_dir') if len(i_dir) == 0: i_dir = self.config.get_param('data_file_dir') i_name = self.config.get_param('info_file_name') if len(i_name) == 0: i_name = self.config.get_param('data_file_name') self.f_info = get_file_path(i_dir, i_name+'.obci.xml') t_dir = self.config.get_param('tags_file_dir') if len(t_dir) == 0: t_dir = self.config.get_param('data_file_dir') t_name = self.config.get_param('tags_file_name') if len(t_name) == 0: t_name = self.config.get_param('data_file_name') self.f_tags = get_file_path(t_dir, t_name+'.obci.tag')
def _init_files(self): self.f_data = get_file_path( self.config.get_param('data_file_dir'), self.config.get_param('data_file_name') + '.obci.raw') i_dir = self.config.get_param('info_file_dir') if len(i_dir) == 0: i_dir = self.config.get_param('data_file_dir') i_name = self.config.get_param('info_file_name') if len(i_name) == 0: i_name = self.config.get_param('data_file_name') self.f_info = get_file_path(i_dir, i_name + '.obci.xml') t_dir = self.config.get_param('tags_file_dir') if len(t_dir) == 0: t_dir = self.config.get_param('data_file_dir') t_name = self.config.get_param('tags_file_name') if len(t_name) == 0: t_name = self.config.get_param('data_file_name') self.f_tags = get_file_path(t_dir, t_name + '.obci.tag')
def __init__(self, addresses): super(LogicVenturesCognitive, self).__init__(addresses=addresses, type=peers.CLIENT) self.ready() user_id = self.get_param('user_id') self.logger.info("Starting cognitive maze for user: "+str(user_id)) tag_name = self.get_param('save_file_name') tag_dir = acquisition_helper.get_file_path(self.get_param('save_file_path'), '') session_name = self.get_param('session_name') session_type = 'experiment' if session_name == 'ventures_game' else 'training' maze.MazeGame(user_id, tag_dir=tag_dir, tag_name=tag_name, session_type=session_type).run() sys.exit(0)
def calculate(file_path, file_name, show=True): file_name = acquisition_helper.get_file_path(file_path, file_name) w = WBBReadManager(file_name+'.obci.xml', file_name+'.obci.raw', file_name+'.obci.tag') w.get_x() w.get_y() w.mgr.set_param('sampling_frequency', estimate_fs(w.mgr.get_channel_samples('TSS'))) w = wii_filter_signal(w, 20, 2, use_filtfilt=True) w = wii_downsample_signal(w, factor=2, pre_filter=False, use_filtfilt=False) smart_tags = wii_cut_fragments(w, start_tag_name='ss_start', end_tags_names=['ss_stop']) x = smart_tags[0].get_channel_samples('x') y = smart_tags[0].get_channel_samples('y') xa, ya = np.std(x)*5, np.mean(y) xb, yb = np.mean(x), np.std(y)*5 xc, yc = np.mean(x), np.mean(y) if show: show_results(x, y, xa, ya, xb, yb, xc, yc) return xa, ya, xb, yb, xc, yc
def run(self): f_name = self.config.get_param("data_file_name") f_dir = self.config.get_param("data_file_path") context = ctx.get_new_context() context['logger'] = self.logger cfg = logic_ssvep_csp_fast_analysis.run( acquisition_helper.get_file_path(f_dir, f_name), self.use_channels, self.ignore_channels, self.montage, self.montage_channels, self.mode in ['offline', 'manual'], True, context) maybe_buffer = self.config.get_param('buffer_len') if len(maybe_buffer) > 0: self.logger.info("Overwrite csp buffer len:" + str(cfg['buffer']) + "with from config:" + str(maybe_buffer)) cfg['buffer'] = float(maybe_buffer) self.finish(cfg)
def __init__(self, addresses): super(LogicVenturesCognitive, self).__init__(addresses=addresses, type=peers.CLIENT) self.ready() user_id = self.get_param('user_id') self.logger.info("Starting cognitive maze for user: " + str(user_id)) tag_name = self.get_param('save_file_name') tag_dir = acquisition_helper.get_file_path( self.get_param('save_file_path'), '') session_name = self.get_param('session_name') session_type = 'experiment' if session_name == 'ventures_game' else 'training' maze.MazeGame(user_id, tag_dir=tag_dir, tag_name=tag_name, session_type=session_type).run() sys.exit(0)
def run(self): f_name = self.config.get_param("data_file_name") f_dir = self.config.get_param("data_file_path") context = ctx.get_new_context() context['logger'] = self.logger cfg = logic_ssvep_csp_fast_analysis.run( acquisition_helper.get_file_path(f_dir, f_name), self.use_channels, self.ignore_channels, self.montage, self.montage_channels, self.mode in ['offline', 'manual'], True, context) maybe_buffer = self.config.get_param('buffer_len') if len(maybe_buffer) > 0: self.logger.info("Overwrite csp buffer len:"+str(cfg['buffer'])+"with from config:"+str(maybe_buffer)) cfg['buffer'] = float(maybe_buffer) self.finish(cfg)
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 __init__(self, addresses): super(Downsampling, self).__init__(addresses=addresses, type=peers.CLIENT) self.new_fs = int(float(self.config.get_param("new_sampling_freq"))) file_name = self.config.get_param("file_name") self.file_path = self.config.get_param("file_path") if not file_name: _file = acquisition_helper.get_file_path(self.file_path, file_name) try: files = [f for f in listdir(_file) if isfile(join(_file, f))] except OSError: self.logger.error("No such file or directory: {}".format(_file)) sys.exit(1) self.old_file = [f.split(".")[0] for f in files if "raw" in f] self.logger.info("Prepered to resampling {} files from {}... \n files list: {}".format(len(self.old_file), self.file_path, self.old_file)) else: self.old_file = [file_name] self.logger.info("Prepered to resampling {} file from {}...".format(self.old_file[0], self.file_path)) self.ready()
def calculate(file_path, file_name, show=True): file_name = acquisition_helper.get_file_path(file_path, file_name) w = WBBReadManager(file_name + '.obci.xml', file_name + '.obci.raw', file_name + '.obci.tag') w.get_x() w.get_y() w.mgr.set_param('sampling_frequency', estimate_fs(w.mgr.get_channel_samples('TSS'))) w = wii_filter_signal(w, 20, 2, use_filtfilt=True) w = wii_downsample_signal(w, factor=2, pre_filter=False, use_filtfilt=False) smart_tags = wii_cut_fragments(w, start_tag_name='ss_start', end_tags_names=['ss_stop']) x = smart_tags[0].get_channel_samples('x') y = smart_tags[0].get_channel_samples('y') xa, ya = np.std(x) * 5, np.mean(y) xb, yb = np.mean(x), np.std(y) * 5 xc, yc = np.mean(x), np.mean(y) if show: show_results(x, y, xa, ya, xb, yb, xc, yc) return xa, ya, xb, yb, xc, yc
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 __init__(self, file_name='Enter.wav'): dir_name = os.path.join(settings.MAIN_DIR, 'utils/tagger_gui/sounds') sound_file = acquisition_helper.get_file_path(dir_name, file_name) self.sound = pygame.mixer.Sound(sound_file)
def set_csp_config(path, name, config): csp_file = acquisition_helper.get_file_path(path, name) + '.csp' f = open(csp_file, 'w') pickle.dump(config, f) f.close()
def get_database_file_name(file_name): dir_name = os.path.join(settings.MAIN_DIR, 'exps/ventures/data') return acquisition_helper.get_file_path(dir_name, file_name)
def set_csp_config(path, name, config): csp_file = acquisition_helper.get_file_path(path, name)+'.csp' f = open(csp_file, 'w') pickle.dump(config, f) f.close()
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(idx=[1,7]) ntrgTags = data.get_not_p300_tags(idx=[1,7]) trgTags = trgTags[trgTags<Signal.shape[1]-fs] ntrgTags = ntrgTags[ntrgTags<Signal.shape[1]-fs] trgTags = trgTags[trgTags>0] ntrgTags = ntrgTags[ntrgTags>0] 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 if (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 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(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 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 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()