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 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 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 load_qt():
'''Load data from QTdb.'''
qt = QTloader()
sig = qt.load('sel100')
plt.plot(sig['sig'])
plt.show()
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 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 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 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 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 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 Test_regression():
'''Regression test.'''
target_label = 'T'
qt = QTloader()
rec_ind = 65
reclist = qt.getreclist()
sig = qt.load(reclist[rec_ind])
raw_sig = sig['sig']
len_sig = len(raw_sig)
rf = RegressionLearner(target_label=target_label)
rf.TrainQtRecords(reclist[0:])
# Load the trained model
# with open('./tmp.mdl', 'rb') as fin:
# mdl = pickle.load(fin)
# rf.LoadModel(mdl)
# Save the trained model
with open('./tmp.mdl', 'wb') as fout:
pickle.dump(rf.mdl, fout)
dpi = DPI()
qrs_list = dpi.QRS_Detection(raw_sig)
start_time = time.time()
detected_poslist = rf.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]
sig = qt.load(reclist[rec_ind])
raw_sig = sig['sig']
plt.plot(raw_sig, label='raw signal')
amp_list = [raw_sig[int(x)] for x in detected_poslist]
plt.plot(detected_poslist,
amp_list,
'ro',
markersize=12,
label=target_label)
plt.legend()
plt.show()
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 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 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 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 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 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)
class RecSelector():
def __init__(self):
self.qt = QTloader()
def inspect_recs(self):
reclist = self.qt.getQTrecnamelist()
sel1213 = conf['sel1213']
sel1213set = set(sel1213)
out_reclist = set(reclist) # - sel1213set
# records selected
selected_record_list = []
for ind, recname in enumerate(out_reclist):
# inspect
print '{} records left.'.format(len(out_reclist) - ind - 1)
self.qt.plotrec(recname)
# debug
if ind > 2:
pass
#print 'debug break'
#break
def plot_rec_dwt(self):
reclist = self.qt.getQTrecnamelist()
sel1213 = conf['sel1213']
sel1213set = set(sel1213)
out_reclist = set(reclist) # - sel1213set
# dwt coef
dwtECG = WTfeature()
# records selected
selected_record_list = []
for ind, recname in enumerate(out_reclist):
# inspect
print 'processing record : {}'.format(recname)
print '{} records left.'.format(len(out_reclist) - ind - 1)
# debug selection
if not recname.startswith(ur'sele0704'):
continue
sig = self.qt.load(recname)
# wavelet
waveletobj = dwtECG.gswt_wavelet()
self.plot_dwt_coef_with_annotation(sig['sig'],
waveletobj=waveletobj,
ECGrecordname=recname)
def plotResult():
'''Plot ECG delineation result.'''
record_name = 'sel808'
result_file_path = './round1/round2/sel808.json'
qt = QTloader()
sig = qt.load(record_name)
raw_sig = sig['sig']
# Load expert labels
with open(result_file_path, 'r') as fin:
data = json.load(fin)
annots = data
fig, ax = plt.subplots(1, 1)
plt.plot(raw_sig)
plt.grid(true)
plotExpertLabels(ax, raw_sig, annots)
plt.show()
def res_to_mat_fromfilename(res_filename, mat_filename):
recID, reslist = load_result(res_filename)
# load QT rawsig
qt = QTloader()
sig = qt.load(recID)
rawsig = sig['sig']
# 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,
]
label_dict['sig'] = rawsig
scipy.io.savemat(mat_filename, label_dict)
print 'mat file [{}] saved.'.format(mat_filename)
def TrainQtRecords(self, record_list):
'''API for QTdb: training model with given record_list.'''
QTdb = QTloader()
training_count = 1
# Extracting feature from each record.
for record_name in record_list:
sig_struct = QTdb.load(record_name)
raw_signal = sig_struct['sig']
expert_labels = QTdb.getExpert(record_name)
self.AddNewTrainingSignal(raw_signal, expert_labels)
# Logging
log.info('Extracted features from %s' % record_name)
print '.' * training_count, '(%d/%d)' % (training_count, len(record_list))
training_count += 1
# Training with feature pool
self.training()
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:
Tonset_file_name = os.path.join(
'/home/alex/code/Python/Tonset/results',
'%s_poslist.json' % record_name)
if os.path.exists(Tonset_file_name) == True:
with open(Tonset_file_name, 'r') as fin:
Tonset_info = json.load(fin)
poslist = Tonset_info['poslist']
if len(poslist) == 0:
continue
Tonset_marks = zip(poslist, [
'Tonset',
] * len(poslist))
else:
expert_marks = qt.getExpert(record_name)
Tonset_marks = [x for x in expert_marks if x[1] == 'Tonset']
if len(Tonset_marks) == 0:
continue
print 'Collecting features from record %s.' % record_name
sig = qt.load(record_name)
walker.collect_training_data(sig['sig'], Tonset_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 DPI(fs=250.0):
'''High pass filtering.'''
qt = QTloader()
sig = qt.load('sel100')
raw_sig = sig['sig'][0:1000]
fsig = HPF(raw_sig)
# DPI
m1 = -2
m2 = 300
len_sig = fsig.size
dpi_arr = list()
N_m2 = int(fs * 1.71)
# for ind in xrange(0, len_sig):
ind = 140
for m2 in xrange(0, N_m2):
lower_index = ind + m1 + 1
upper_index = ind + m1 + m2
lower_index = max(0, lower_index)
upper_index = min(len_sig - 1, upper_index)
if upper_index >= lower_index:
s_avg = float(np.sum(np.abs(fsig[lower_index:upper_index + 1])))
# s_avg /= m2 ** 0.5
s_avg /= math.pow(m2, 0.5)
else:
s_avg = 1.0
# Prevent 0 division error
if s_avg < 1e-6:
s_avg = 1.0
dpi_val = np.abs(fsig[ind]) / s_avg
dpi_arr.append(dpi_val)
plt.plot(xrange(ind, ind + len(dpi_arr)), dpi_arr, label='DPI')
plt.plot(fsig, label='fsig')
plt.title('DPI')
plt.legend()
plt.show()
def Test():
'''Test function for HOG1D class.'''
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=15)
# hoger.ComputeHog(sig, debug_plot = True)
hoger.DiscretiseHog(sig, debug_plot=True)
plt.figure(2)
plt.plot(np.array(sig) * 10)
plt.grid(True)
plt.show()
def getRRhisto():
## plot RR histogram
from MedEvaluationClass import MedEvaluation
# get test result list
testlist = getresultfilelist()
# filter testlist
invalidlist = conf['InvalidRecords']
for testrec in testlist:
print 'processing record:{}'.format(testrec)
with open(testrec,'r') as fin:
(recname,resdata) = pickle.load(fin)
if recname in invalidlist:
continue
# RR histo
medeval = MedEvaluation(resdata)
medeval.RRhistogram()
# load signal rawdata
qtloader = QTloader()
ECGsigstruct = qtloader.load(recname = recname)
ECGsig = ECGsigstruct['sig']
medeval.RRhisto_check(ECGsig)
def TEST_PredictionQRS():
recname = 'sel873'
GroupResultFolder = os.path.join(curfolderpath, 'MultiLead4',
'GroupRound1')
QTdb = QTloader()
rawsig = QTdb.load(recname)
rawsig = rawsig['sig']
with open(os.path.join(GroupResultFolder, '{}.json'.format(recname)),
'r') as fin:
RawResultDict = json.load(fin)
LeadResult = RawResultDict['LeadResult']
MarkDict = LeadResult[0]
MarkList = Convert2ExpertFormat(MarkDict)
# Display with 2 subplots.
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 test0():
'''Test code for fast_tester.'''
from QTdata.loadQTdata import QTloader
qt = QTloader()
sig = qt.load('sel100')
range_right = 1000
raw_sig = sig['sig2'][0:range_right]
ft = FastTester()
res_list = ft.testing(raw_sig, fs=250.0)
labels = set([x[1] for x in res_list])
plt.plot(raw_sig)
for label in labels:
poslist = [x[0] for x in filter(lambda x: x[1] == label, res_list)]
amplist = [
raw_sig[int(x)] for x in filter(lambda x: x < range_right, poslist)
]
plt.plot(poslist, amplist, 'o', markersize=12, alpha=0.5, label=label)
plt.title('sel100')
plt.legend()
plt.show()
