def __init__(self, fig, ax, start_index): self.fig = fig self.ax = ax self.SaveFolder = os.path.join(curfolderpath, 'results') self.text = self.ax.text(0.05, 0.95, 'selected: none', transform=self.ax.transAxes, va='top') # ============================ # QTdb self.QTdb = QTloader() self.reclist = self.QTdb.reclist self.recInd = start_index self.recname = self.reclist[self.recInd] self.sigStruct = self.QTdb.load(self.recname) self.rawSig = self.sigStruct['sig'] self.expLabels = self.QTdb.getexpertlabeltuple(self.recname) tableau20 = [(31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120), (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150), (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148), (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199), (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)] self.colors = [] for color_tri in tableau20: self.colors.append((color_tri[0] / 255.0, color_tri[1] / 255.0, color_tri[2] / 255.0)) # =========================== # Mark list self.poslist = [] self.totalWhiteCount = 0
def DPI(): '''High pass filtering.''' qt = QTloader() sig = qt.load('sel100') raw_sig = sig['sig'] fsig = HPF(raw_sig) # DPI m1 = 100 m2 = 300 len_sig = fsig.size dpi_arr = list() for ind in xrange(0, len_sig): lower_index = ind + m1 + 1 upper_index = ind + m1 + m2 if upper_index >= lower_index: s_avg = float(np.sum(np.abs(fsig[lower_index:upper_index + 1]))) s_avg /= m2 else: s_avg = 1.0 dpi_val = np.abs(fsig[ind]) / s_avg dpi_val /= 5.0 dpi_arr.append(dpi_val) plt.plot(dpi_arr, label='DPI') plt.plot(fsig, label='fsig') plt.title('DPI') plt.legend() plt.show()
def TestRecord(saveresultpath): '''Test all records in testinglist, training on remaining records in QTdb.''' qt_loader = QTloader() QTreclist = qt_loader.getQTrecnamelist() # Get training record list testinglist = QTreclist[0:10] # traininglist = QTreclist[0:10] # debug # traininglist = QTreclist[0:10] # testinglist = QTreclist[0:10] # log.warning('Using custom testing & training records.') # log.warning('Training range: 0-10') # log.warning('Testing range: 0-10') rf_classifier = ECGrf(SaveTrainingSampleFolder = saveresultpath) # Multi Process rf_classifier.TestRange = 'All' # Load classification model. with open(os.path.join(saveresultpath, 'trained_model.mdl'), 'rb') as fin: trained_model = pickle.load(fin) rf_classifier.mdl = trained_model # testing log.info('Testing records:\n %s',', '.join(testinglist)) for record_name in testinglist: sig = qt_loader.load(record_name) raw_signal = sig['sig'] result = rf_classifier.testing(raw_signal, trained_model) with open(os.path.join(saveresultpath, 'result_{}'.format(record_name)),'w') as fout: json.dump(result,fout,indent = 4)
def __init__(self, fig, ax, ax2): self.fig = fig self.ax = ax self.ax2 = ax2 # ============================ # QTdb self.QTdb = QTloader() self.reclist = self.QTdb.reclist self.result_folder_path = os.path.join(os.path.dirname(curfolderpath), 'MultiLead4', 'GroupRound11') self.recInd = 0 # self.recname = self.reclist[self.recInd] self.recname = 'sel16273' self.result_file_path = os.path.join(self.result_folder_path, '{}.json'.format(self.recname)) self.sigStruct = self.QTdb.load(self.recname) self.rawSig = self.sigStruct['sig'] self.rawSig2 = self.sigStruct['sig2'] self.expLabels = self.QTdb.getexpertlabeltuple(self.recname) tableau20 = [(31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120), (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150), (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148), (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199), (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)] self.colors = [] for color_tri in tableau20: self.colors.append((color_tri[0] / 255.0, color_tri[1] / 255.0, color_tri[2] / 255.0))
def TestQT(record_name, save_result_folder, model_folder, random_pattern_file_name): '''Test case1.''' fs = 250.0 qt = QTloader() sig = qt.load(record_name) expert_annotations = qt.getExpert(record_name) pos_list, label_list = zip(*expert_annotations) test_range = [np.min(pos_list) - 100, np.max(pos_list) + 100] result_mat = list() print 'Lead1' raw_sig = sig['sig'] results = TestSignal(raw_sig, fs, test_range, model_folder, random_pattern_file_name) for ind in xrange(0, len(results)): results[ind] = [results[ind][0] + test_range[0], results[ind][1]] result_mat.append((record_name, results)) print 'Lead2' raw_sig = sig['sig2'] results = TestSignal(raw_sig, fs, test_range, model_folder, random_pattern_file_name) for ind in xrange(0, len(results)): results[ind] = [results[ind][0] + test_range[0], results[ind][1]] result_mat.append((record_name + '_sig2', results)) result_file_name = os.path.join(save_result_folder, '%s.json' % record_name) with open(result_file_name, 'w') as fout: json.dump(result_mat, fout, indent = 4) print 'Results saved as %s.' % result_file_name
def TestAllQTdata(saveresultpath, testinglist): '''Test all records in testinglist, training on remaining records in QTdb.''' qt_loader = QTloader() QTreclist = qt_loader.getQTrecnamelist() # Get training record list traininglist = list(set(QTreclist) - set(testinglist)) # Testing from randomwalk.test_api import GetModels from randomwalk.test_api import Testing # pattern_filename = os.path.join(os.path.dirname(saveresultpath), 'randrel.json') pattern_filename = '/home/alex/LabGit/ECG_random_walk/randomwalk/data/Lw3Np4000/random_pattern.json' model_folder = '/home/alex/LabGit/ECG_random_walk/randomwalk/data/Lw3Np4000' model_list = GetModels(model_folder, pattern_filename) for record_name in testinglist: sig = qt_loader.load(record_name) raw_sig = sig['sig'] start_time = time.time() results = Testing(raw_sig, 250.0, model_list, walker_iterations=100) time_cost = time.time() - start_time with open(os.path.join(saveresultpath, '%s.json' % record_name), 'w') as fout: json.dump(results, fout) print 'Testing time %f s, data time %f s.' % (time_cost, len(raw_sig) / 250.0)
def TEST_ExpertQRS(): recname = 'sel103' QTdb = QTloader() rawsig = QTdb.load(recname) rawsig = rawsig['sig'] MarkList = QTdb.getExpert(recname) swt = SWT_NoPredictQRS(rawsig, MarkList) swt.swt() # cDlist wtlist = swt.cDlist[-4] plt.figure(1) # plot Non QRS ECG & SWT plt.subplot(211) plt.plot(rawsig) plt.plot(wtlist) plt.grid(True) # plot Original ECG rawsig = swt.QTdb.load(recname) rawsig = rawsig['sig'] rawsig = swt.crop_data_for_swt(rawsig) coeflist = pywt.swt(rawsig, 'db6', 9) cAlist, cDlist = zip(*coeflist) wtlist = cDlist[-4] plt.subplot(212) plt.plot(rawsig) plt.plot(wtlist) plt.grid(True) plt.show()
def TrainSwtModel(save_model_folder, save_sample_folder, target_label, random_relation_file_path): '''Test all records in testinglist, training on remaining records in QTdb.''' qt_loader = QTloader() QTreclist = qt_loader.getQTrecnamelist() # Get training record list random.shuffle(QTreclist) traininglist = QTreclist[0:75] random_relation_file_path = os.path.dirname(random_relation_file_path) rf_classifier = ECGrf(SaveTrainingSampleFolder=save_sample_folder, allowed_label_list=[ target_label, ], random_relation_path=random_relation_file_path) # Multi Process rf_classifier.TestRange = 'All' # Training time_cost_output = [] timing_for(rf_classifier.TrainQtRecords, [ traininglist, ], prompt='Total Training time:', time_cost_output=time_cost_output) log.info('Total training time cost: %.2f seconds', time_cost_output[-1]) # save trained mdl backupobj(rf_classifier.mdl, os.path.join(save_model_folder, 'trained_model.mdl'))
def res_to_mat_fromResult(recID, reslist, mat_filename): # load QT rawsig qt = QTloader() sig = qt.load(recID) rawsig = sig['sig'] # load expert label expert_reslist = qt.getexpertlabeltuple(recID) # save sig and reslist label_dict = dict() for pos, label in reslist: if label in label_dict: label_dict[label].append(pos) else: label_dict[label] = [ pos, ] # Expert Labels for pos, label in expert_reslist: exp_label = 'expert_' + label if exp_label in label_dict: label_dict[exp_label].append(pos) else: label_dict[exp_label] = [ pos, ] label_dict['sig'] = rawsig scipy.io.savemat(mat_filename, label_dict) print 'mat file [{}] saved.'.format(mat_filename)
def Test1(): '''Comparing to expert labels in QTdb.''' qt = QTloader() reclist = qt.getreclist() rec_ind = 0 for rec_ind in xrange(0, len(reclist)): print 'Processing record[%d] %s ...' % (rec_ind, reclist[rec_ind]) sig = qt.load(reclist[rec_ind]) raw_sig = sig['sig'] expert_labels = qt.getExpert(reclist[rec_ind]) R_pos_list = [ x[0] for x in filter(lambda item: item[1] == 'R', expert_labels) ] # Skip empty expert lists if len(R_pos_list) == 0: continue dpi = DPI() qrs_list = dpi.QRS_Detection(raw_sig) # Find FN FN_arr = GetFN(R_pos_list, qrs_list) R_pos_list = FN_arr if len(R_pos_list) > 0: plt.plot(raw_sig) amp_list = [raw_sig[x] for x in qrs_list] plt.plot(qrs_list, amp_list, 'ro', markersize=12) amp_list = [raw_sig[x] for x in R_pos_list] plt.plot(R_pos_list, amp_list, 'ys', markersize=14) plt.show()
def load_qt(): '''Load data from QTdb.''' qt = QTloader() sig = qt.load('sel100') plt.plot(sig['sig']) plt.show()
def TrainModel(save_result_folder): '''Train a random forest model with QT records.''' qt_loader = QTloader() QTreclist = qt_loader.getQTrecnamelist() training_record_list = QTreclist[0:15] # training Training(save_result_folder, training_record_list)
def TrainingModels(target_label, model_file_name, training_list): '''Randomly select num_training records to train, and test others.''' qt = QTloader() record_list = qt.getreclist() testing_list = list(set(record_list) - set(training_list)) random_forest_config = dict(max_depth=10) walker = RandomWalker(target_label=target_label, random_forest_config=random_forest_config, random_pattern_file_name=os.path.join( os.path.dirname(model_file_name), 'random_pattern.json')) start_time = time.time() for record_name in training_list: print 'Collecting features from record %s.' % record_name sig = qt.load(record_name) walker.collect_training_data(sig['sig'], qt.getExpert(record_name)) print 'random forest start training(%s)...' % target_label walker.training() print 'trianing used %.3f seconds' % (time.time() - start_time) import joblib start_time = time.time() walker.save_model(model_file_name) print 'Serializing model time cost %f' % (time.time() - start_time)
def Test(): '''Test function for HOG1D class.''' # Import packages in this project from QTdata.loadQTdata import QTloader qt = QTloader() sig_struct = qt.load('sel17152') sig = sig_struct['sig'] sig = sig[10000:10900] # Plot ECG signal # plt.figure(1) # plt.plot(sig) # plt.show() # HOG 1d class hoger = HogClass(segment_len = 20) # hoger.ComputeHog(sig, debug_plot = True) hoger.GetRealHogArray(sig, diff_step = 5, debug_plot = True) # hoger.DiscretiseHog(sig, debug_plot = True) plt.figure(2) plt.plot(np.array(sig) * 10) plt.grid(True) plt.show()
def TEST(): '''Test code for WaveDelineator.''' qt = QTloader() sig = qt.load('sel31') raw_sig = sig['sig'][1000:2000] pd = WaveDelineator(raw_sig, fs=250.0) result = pd.run() pd.plot_results(raw_sig, result)
def plot_QTdb_filtered_Result_with_syntax_filter(RFfolder, TargetRecordList, ResultFilterType, showExpertLabels=False): # exit # ========================== # plot prediction result # ========================== reslist = getresultfilelist(RFfolder) qtdb = QTloader() non_result_extensions = ['out', 'json', 'log', 'txt'] for fi, fname in enumerate(reslist): # block *.out file_extension = fname.split('.')[-1] if file_extension in non_result_extensions: continue print 'file name:', fname currecname = os.path.split(fname)[-1] print currecname #if currecname == 'result_sel820': #pdb.set_trace() if TargetRecordList is not None: if currecname not in TargetRecordList: continue # load signal and reslist with open(fname, 'r') as fin: (recID, reslist) = pickle.load(fin) # filter result of QT resfilter = ResultFilter(reslist) if len(ResultFilterType) >= 1 and ResultFilterType[0] == 'G': reslist = resfilter.group_local_result(cp_del_thres=1) reslist_syntax = reslist if len(ResultFilterType) >= 2 and ResultFilterType[1] == 'S': reslist_syntax = resfilter.syntax_filter(reslist) # empty signal result #if reslist is None or len(reslist) == 0: #continue #pdb.set_trace() sigstruct = qtdb.load(recID) if showExpertLabels == True: # Expert Label AdditionalPlot ExpertRes = qtdb.getexpertlabeltuple(recID) ExpertPoslist = map(lambda x: x[0], ExpertRes) AdditionalPlot = [ ['kd', 'Expert Labels', ExpertPoslist], ] else: AdditionalPlot = None # plot res #resploter = ECGResultPloter(sigstruct['sig'],reslist) #resploter.plot(plotTitle = 'QT database',plotShow = True,plotFig = 2) # syntax_filter resploter_syntax = ECGResultPloter(sigstruct['sig'], reslist_syntax) resploter_syntax.plot(plotTitle='QT Record {}'.format(recID), plotShow=True, AdditionalPlot=AdditionalPlot)
def __init__(self, rfmdl, RandomPairList_Path): # get random relations randrel_path = RandomPairList_Path with open(randrel_path, 'r') as fin: self.randrels = json.load(fin) self.rfmdl = rfmdl self.trees = rfmdl.estimators_ self.qt = QTloader() self.qt_reclist = self.qt.getQTrecnamelist()
def Test1(): '''Test case1.''' # data = sio.loadmat('./data/ft.mat') # v2 = np.squeeze(data['II']) # raw_sig = v2 # fs = 500 qt = QTloader() sig = qt.load('sel32') raw_sig = sig['sig'][1000:3000] fs = 250 # raw_sig = scipy.signal.resample(raw_sig, len(raw_sig) / 2) # fs = 250 model_folder = '/home/alex/LabGit/ECG_random_walk/randomwalk/data/m3_full_models' pattern_file_name = '/home/alex/LabGit/ECG_random_walk/randomwalk/data/m3_full_models/random_pattern.json' model_list = GetModels(model_folder, pattern_file_name) start_time = time.time() # First: QRS detection dpi = DPI(debug_info=dict()) r_list = dpi.QRS_Detection(raw_sig, fs=fs) results = zip(r_list, len(r_list) * [ 'R', ]) results.extend(Testing_QS(raw_sig, fs, r_list)) walk_results = Testing_random_walk(raw_sig, fs, r_list, model_list) results.extend(walk_results) # results = Testing(raw_sig, fs, model_list) print 'Testing time cost %f secs.' % (time.time() - start_time) samples_count = len(raw_sig) time_span = samples_count / fs print 'Span of testing range: %f samples(%f seconds).' % (samples_count, time_span) with open('./data/new_result.json', 'w') as fout: json.dump(results, fout, indent=4) # Display results plt.figure(1) plt.plot(raw_sig, label='ECG') pos_list, label_list = zip(*results) labels = set(label_list) for label in labels: pos_list = [ int(x[0]) for x in results if x[1] == label and x[0] < len(raw_sig) ] amp_list = [raw_sig[x] for x in pos_list] plt.plot(pos_list, amp_list, 'o', markersize=15, label=label) plt.title('ECG') plt.grid(True) plt.legend() plt.show()
def Test_hog1d(): '''Hog feature method test.''' target_label = 'T' qt = QTloader() rec_ind = 103 reclist = qt.getreclist() sig = qt.load(reclist[rec_ind]) raw_sig = sig['sig'] len_sig = len(raw_sig) # Hog feature tester hog = HogFeatureExtractor(target_label=target_label) rec_list = hog.qt.getreclist() training_list = reclist[0:100] # training_rec = list(set(rec_list) - set(testing_rec)) hog.Train(training_list) # Load the trained model # with open('./hog.mdl', 'rb') as fin: # mdl = pickle.load(fin) # hog.LoadModel(mdl) # Save the trained model with open('./hog.mdl', 'wb') as fout: pickle.dump(hog.gbdt, fout) dpi = DPI() qrs_list = dpi.QRS_Detection(raw_sig) start_time = time.time() detected_poslist = hog.Testing(raw_sig, zip(qrs_list, [ 'R', ] * len(qrs_list))) print 'Testing time: %d s.' % (time.time() - start_time) while len(detected_poslist) > 0 and detected_poslist[-1] > len_sig: del detected_poslist[-1] while len(detected_poslist) > 0 and detected_poslist[0] < 0: del detected_poslist[0] sig = qt.load(reclist[rec_ind]) raw_sig = sig['sig'] plt.plot(raw_sig, label='raw signal D1') plt.plot(sig['sig2'], label='raw signal D2') amp_list = [raw_sig[int(x)] for x in detected_poslist] plt.plot(detected_poslist, amp_list, 'ro', markersize=12, label=target_label) plt.title('Record name %s' % reclist[rec_ind]) plt.legend() plt.show()
def TestAllQTdata(saveresultpath): # Leave Ntest out of 30 records to test # qt_loader = QTloader() QTreclist = qt_loader.getQTrecnamelist() print 'Totoal QT record number:{}'.format(len(QTreclist)) ## Training record list selall0 = conf["selQTall0"] selrecords = list(set(QTreclist) - set(selall0)) rf = ECGRF.ECGrf() # Multi Process rf.useParallelTest = True rf.TestRange = 'All' # ================ # evaluate time cost for each stage # ================ # clear debug logger ECGRF.debugLogger.clear() # display the time left to finish program one_round_time_cost = [] # ==================== # Training # ==================== ECGRF.debugLogger.dump('\n====Test Start ====\n') time0 = time.time() # training the rf classifier with reclist # # dump to debug logger rf.training(selrecords) # timing time1 = time.time() print 'Total Training time:', time1 - time0 ECGRF.debugLogger.dump('Total Training time: {:.2f} s\n'.format(time1 - time0)) # save the trained model savemodelpath = os.path.join(saveresultpath, 'QT_sel.mdl') with open(savemodelpath, 'w') as fout: pickle.dump(rf.mdl, fout) return ## test testinglist = selall0 print '\n>>Testing:', testinglist ECGRF.debugLogger.dump('\n======\n\nTest Set :{}'.format(selrecords)) rf.testrecords(reclist=selrecords, TestResultFileName=os.path.join(saveresultpath, 'TestResult.out'))
def __init__(self,recname,reslist,leadname,MaxSWTLevel = 9): self.recres = reslist #self.LeadRes = (reslist,reslist2) self.recname = recname self.QTdb = QTloader() self.sig_struct = self.QTdb.load(self.recname) self.rawsig = self.sig_struct[leadname] self.res_groups = None self.peak_dict = dict(T=[],P=[],Ponset = [],Poffset = [],Tonset = [],Toffset = []) self.getSWTcoeflist(MaxLevel = MaxSWTLevel)
def viewQT(): qt = QTloader() record_list = qt.getreclist() index = 19 for record_name in record_list[index:]: print 'record index:', index # if record_name != 'sele0612': # continue sig = qt.load(record_name) raw_sig = sig['sig'][2000:7000] viewCWTsignal(raw_sig, 250, figure_title=record_name) index += 1
def TEST1(save_result_path, target_label='T'): qt_loader = QTloader() qt_record_list = qt_loader.getQTrecnamelist() # testing& training set training_list = qt_record_list[0:4] testing_list = qt_record_list[41:50] # Start traing & testing TestAllQTdata(save_result_path, testing_list, training_list, target_label=target_label)
def TestQT(record_index): '''Test case''' result_folder = '/home/alex/LabGit/ECG_random_walk/randomwalk/data/test_results/r2' qt = QTloader() P_width = 50 result_files = glob.glob(os.path.join(result_folder, 'sel*.json')) with open(result_files[record_index], 'r') as fin: data = json.load(fin) record_name = data[0][0] print 'Record name:', record_name sig = qt.load(record_name) raw_sig = np.array(sig['sig']) / 40.0 + 1.0 results = data[0][1] fs = 250 if abs(fs - 250.0) > 1e-6: raw_sig = scipy.signal.resample(raw_sig, int(len(raw_sig) / float(fs) * 250.0)) fs_recover = fs fs = 250.0 P_positions = results P_positions.sort(key=lambda x: x[0]) show_count = 1 segment_list = list() wholewave_list = list() for ind in xrange(0, len(P_positions)): if show_count > 2: break pos, label = P_positions[ind] if label == 'P': Pon = pos - P_width / 2.0 Poff = pos + P_width / 2.0 for pi in xrange(ind - 1, -1, -1): if P_positions[pi][1] == 'Ponset': Pon = P_positions[pi][0] break elif (P_positions[pi][1] == 'Roffset' or P_positions[pi][1] == 'Toffset' or P_positions[pi][1] == 'T'): Pon = P_positions[pi][0] break for pi in xrange(ind + 1, len(P_positions)): if P_positions[pi][1] == 'Poffset': Poff = P_positions[pi][0] break elif P_positions[pi][1] == 'Ronset': Poff = P_positions[pi][0] break Pshape(raw_sig, (Pon, pos, Poff))
def plot_QTdb_filtered_Result_with_syntax_filter(): # exit RFfolder = os.path.join(\ projhomepath,\ 'TestResult',\ 'pc',\ 'r5') TargetRecordList = [ 'result_sel39', 'result_sel41', 'result_sel48', ] #'sel38','sel42','result_sel821','result_sel14046'] # ========================== # plot prediction result # ========================== reslist = glob.glob(os.path.join(\ RFfolder,'*')) qtdb = QTloader() non_result_extensions = ['out', 'json', 'log'] for fi, fname in enumerate(reslist): # block *.out file_extension = fname.split('.')[-1] if file_extension in non_result_extensions: continue print 'file name:', fname currecname = os.path.split(fname)[-1] print currecname #if currecname == 'result_sel820': #pdb.set_trace() if currecname not in TargetRecordList: pass continue # load signal and reslist with open(fname, 'r') as fin: (recID, reslist) = pickle.load(fin) # filter result of QT resfilter = ResultFilter(reslist) reslist = resfilter.group_local_result(cp_del_thres=1) reslist_syntax = resfilter.syntax_filter(reslist) # empty signal result #if reslist is None or len(reslist) == 0: #continue #pdb.set_trace() sigstruct = qtdb.load(recID) # plot res #resploter = ECGResultPloter(sigstruct['sig'],reslist) #resploter.plot(plotTitle = 'QT database',plotShow = True,plotFig = 2) # syntax_filter resploter_syntax = ECGResultPloter(sigstruct['sig'], reslist_syntax) resploter_syntax.plot(plotTitle='QT database syntax_filter', plotShow=True)
def __init__(self, rfmdl, RandomPairList_Path): # get random relations randrel_path = RandomPairList_Path with open(randrel_path, 'r') as fin: self.randrels = json.load(fin) self.rfmdl = rfmdl self.trees = rfmdl.estimators_ self.qt = QTloader() self.qt_reclist = self.qt.getQTrecnamelist() self.MaxHeartBeatWidth = 350 self.QRS_segment_expand_length = 30 self.FixedSignalLength = self.MaxHeartBeatWidth + 2 * self.QRS_segment_expand_length
def TrainingModels(target_label, model_file_name, training_list): '''Randomly select num_training records to train, and test others. CP: Characteristic points ''' qt = QTloader() record_list = qt.getreclist() testing_list = list(set(record_list) - set(training_list)) random_forest_config = dict(max_depth=10) walker = RandomWalker(target_label=target_label, random_forest_config=random_forest_config, random_pattern_file_name=os.path.join( os.path.dirname(model_file_name), 'random_pattern.json')) start_time = time.time() for record_name in training_list: CP_file_name = os.path.join( '/home/alex/code/Python/EcgCharacterPointMarks', target_label, '%s_poslist.json' % record_name) # Add expert marks expert_marks = qt.getExpert(record_name) CP_marks = [x for x in expert_marks if x[1] == target_label] if len(CP_marks) == 0: continue # Add manual labels if possible if os.path.exists(CP_file_name) == True: with open(CP_file_name, 'r') as fin: CP_info = json.load(fin) poslist = CP_info['poslist'] if len(poslist) == 0: continue CP_marks.extend(zip(poslist, [ target_label, ] * len(poslist))) print 'Collecting features from record %s.' % record_name sig = qt.load(record_name) walker.collect_training_data(sig['sig'], CP_marks) print 'random forest start training(%s)...' % target_label walker.training() print 'trianing used %.3f seconds' % (time.time() - start_time) import joblib start_time = time.time() walker.save_model(model_file_name) print 'Serializing model time cost %f' % (time.time() - start_time)
def __init__(self, recname, reslist, reslist2, MaxSWTLevel=9): self.recres = reslist self.LeadRes = (reslist, reslist2) self.recname = recname self.QTdb = QTloader() self.sig_struct = self.QTdb.load(self.recname) self.rawsig = self.sig_struct['sig'] self.res_groups = None self.peak_dict = dict(T=[], P=[], Ponset=[], Poffset=[], Tonset=[], Toffset=[])
def __init__(self, fig, ax, ax2): self.fig = fig self.ax = ax self.ax2 = ax2 self.SaveFolder = os.path.join(curfolderpath, 'QTwhiteMarkList') self.text = self.ax.text(0.05, 0.95, 'selected: none', transform=self.ax.transAxes, va='top') #self.selected, = self.ax.plot([xs[0]], [ys[0]], 'o', ms=12, alpha=0.4, #color='yellow', visible=False) # ============================ # QTdb self.QTdb = QTloader() #self.reclist = self.QTdb.reclist self.resultlist = glob.glob( os.path.join(projhomepath, 'result', 'swt-paper-7', 'round68', 'result_*')) print 'len result list:', len(self.resultlist) self.recInd = 0 self.recname = os.path.split(self.resultlist[self.recInd])[-1][7:] print 'self.recname', self.recname self.sigStruct = self.QTdb.load(self.recname) self.rawSig = self.sigStruct['sig'] self.rawSig2 = self.sigStruct['sig2'] self.expLabels = self.QTdb.getexpertlabeltuple(self.recname) tableau20 = [(31, 119, 180), (174, 199, 232), (255, 127, 14), (255, 187, 120), (44, 160, 44), (152, 223, 138), (214, 39, 40), (255, 152, 150), (148, 103, 189), (197, 176, 213), (140, 86, 75), (196, 156, 148), (227, 119, 194), (247, 182, 210), (127, 127, 127), (199, 199, 199), (188, 189, 34), (219, 219, 141), (23, 190, 207), (158, 218, 229)] self.colors = [] for color_tri in tableau20: self.colors.append((color_tri[0] / 255.0, color_tri[1] / 255.0, color_tri[2] / 255.0)) # =========================== # Mark list self.whiteRegionList = [] self.totalWhiteCount = 0
def ContinueAddQtTrainingSamples(walker, target_label): '''Add QT training samples.''' qt = QTloader() record_list = qt.getreclist() start_time = time.time() for record_name in record_list: # Add expert marks expert_marks = qt.getExpert(record_name) CP_marks = [x for x in expert_marks if x[1] == target_label] if len(CP_marks) == 0: continue print 'Collecting features from QT record %s.' % record_name sig = qt.load(record_name) walker.collect_training_data(sig['sig'], CP_marks)