def __init__(self,
MAX_PARA_CORE=6,
SaveTrainingSampleFolder=None,
allowed_label_list=None,
random_relation_path=None):
# only test on areas with expert labels
self.TestRange = 'Partial' # or 'All'
# Parallel
self.QTloader = QTdb.QTloader()
self.mdl = None
self.MAX_PARA_CORE = MAX_PARA_CORE
# maximum samples for bucket testing
self.MaxTestSample = 200
# save training samples folder
if SaveTrainingSampleFolder is None:
ResultFolder = projhomepath
ResultFolder_conf = conf['ResultFolder_Relative']
for folder in ResultFolder_conf:
ResultFolder = os.path.join(ResultFolder, folder)
self.SaveTrainingSampleFolder = ResultFolder
else:
self.SaveTrainingSampleFolder = SaveTrainingSampleFolder
# Allowed positive labels
if allowed_label_list is None:
allowed_label_list = [
'T', 'Tonset', 'Toffset', 'R', 'Ronset', 'Roffset', 'P',
'Ponset', 'Poffset'
]
self.allowed_label_list = allowed_label_list
self.random_relation_path = random_relation_path
def checkWT():
sel1213 = conf['sel1213']
QTloader = QTdb.QTloader()
wtfobj = wtf.WTfeature()
for recname in sel1213:
sig = QTloader.load(recname)
wtfobj.plot_wtcoefs(\
sig['sig'],\
waveletobj = wtfobj.gswt_wavelet(),\
figureID = 2)
def __init__(self,fResultList):
# result list:
# ((recname,record result)...)
#
# record result:
# ((pos,label)...)
self.fResultList = fResultList
self.QTloader = QTdb.QTloader()
self.pErr = None
self.pFN = None
self.pFP = None
def result_refiner(Reslist):
#
# Multiple prediction point -> single point output
## filter output for evaluation results
#
# parameters
#
#
# the number of the group must be greater than:
#
group_min_thres = 1
QTloader = QTdb.QTloader()
fRes = []
for recname,recres in Reslist:
sig = QTloader.load(recname)
posgroup_withAmp = []
# in var
prev_label = None
posGroup = []
#----------------------
# [pos,label] in recres
#----------------------
for pos,label in recres:
if prev_label is not None:
if label != prev_label:
posgroup_withAmp.append((prev_label,posGroup))
posGroup = []
prev_label = label
posGroup.append((pos,sig['sig'][pos]))
# last one
if len(posGroup)>0:
posgroup_withAmp.append((prev_label,posGroup))
# ======================
# [(label,posGroup),...]
# ======================
posgroup_withAmp = [x for x in posgroup_withAmp if len(x[1]) > group_min_thres]
# ----------------------
# earth line algorithm
# ----------------------
fposGroup= map(ECGrf.Group_Horizon,posgroup_withAmp)
# mean position
fposGroup = [(int(np.mean(x[1])),x[0]) for x in fposGroup ]
fRes.append((recname,fposGroup ))
return fRes
def CollectRecFeature(self, recname):
log.info('Collecting feature for %s', recname)
# Load signal.
QTloader = QTdb.QTloader()
sig = QTloader.load(recname)
if valid_signal_value(sig['sig']) == False:
return [[], []]
tX, ty = ECGrf.collectfeaturesforsig(
sig,
SaveTrainingSampleFolder=self.SaveTrainingSampleFolder,
blankrangelist=None,
recID=recname,
allowed_label_list=self.allowed_label_list,
random_relation_path=self.random_relation_path)
return (tX, ty)
def disp_rec(recname = 'sel103'):
QTloader = QTdb.QTloader()
sig = QTloader.load(recname)
pdb.set_trace()
plt.figure(1)
#plt.subplot(211)
#mark_ind = [sig['time'][x] for x in sig['marks']['T']]
#mark_amp= [sig['sig'][x] for x in sig['marks']['T']]
plt.plot(sig['sig'],'g')
plt.plot(sig['sig2'],'r')
#plt.plot(sig['time'],sig['sig'],'g')
#plt.plot(sig['time'],sig['sig2'],'r')
plt.title('QT rec: '+recname)
#plt.xlim(mark_ind[0],mark_ind[-1])
plt.show()
def disp_recID(recID = 1):
if isinstance(recID,int) == False:
raise Exception('recID input must be integer!')
QTloader = QTdb.QTloader()
reclist = QTloader.getQTrecnamelist()
sig = QTloader.load(reclist[recID])
plt.figure(1)
#plt.subplot(211)
#mark_ind = [sig['time'][x] for x in sig['marks']['T']]
#mark_amp= [sig['sig'][x] for x in sig['marks']['T']]
plt.plot(sig['sig'],'k')
#plt.plot(sig['time'],sig['sig'],'k',mark_ind,mark_amp,'ro')
plt.title('ECG signal')
#plt.xlim(mark_ind[0],mark_ind[-1])
plt.show()
def __init__(self, MAX_PARA_CORE=6, SaveTrainingSampleFolder=None):
# only test on areas with expert labels
self.TestRange = 'Partial' # or 'All'
# Parallel
self.QTloader = QTdb.QTloader()
self.mdl = None
self.MAX_PARA_CORE = MAX_PARA_CORE
# maximum samples for bucket testing
self.MaxTestSample = 200
# Save training samples folder.
if SaveTrainingSampleFolder is None:
ResultFolder = projhomepath
ResultFolder_conf = conf['ResultFolder_Relative']
for folder in ResultFolder_conf:
ResultFolder = os.path.join(ResultFolder, folder)
self.SaveTrainingSampleFolder = ResultFolder
else:
self.SaveTrainingSampleFolder = SaveTrainingSampleFolder
def Parallel_CollectRecFeature(recname):
print 'Parallel Collect RecFeature from {}'.format(recname)
# load blank area list
blkArea = conf['labelblankrange']
## debug log:
debugLogger.dump('collecting feature for {}\n'.format(recname))
# load sig
QTloader = QTdb.QTloader()
sig = QTloader.load(recname)
if valid_signal_value(sig['sig']) == False:
return [[],[]]
# blank list
blklist = None
if recname in blkArea:
print recname,'in blank Area list.'
blklist = blkArea[recname]
tX,ty = ECGrf.collectfeaturesforsig(sig,SaveTrainingSampleFolder,blankrangelist = blklist,recID = recname)
return (tX,ty)
def TEST1():
'''Test case 1.'''
# load signal from QTdb
loader = QTdb.QTloader()
sig_struct = loader.load('sel100')
sig_segment = sig_struct['sig'][100:]
# model path
model_path = os.path.join(projhomepath, 'result', 'swt-paper-8')
result = Testing(sig_segment, model_path, adapt_frequency=360.0)
# length check:
print 'length of signal: ', len(sig_segment)
print 'length of result: ', len(result)
# plot result
target_label = 'P'
plt.figure(1)
plt.plot(sig_segment, label='signal')
pos_list = [x[0] for x in result if x[1] == target_label]
amp_list = [sig_segment[x] for x in pos_list]
plt.plot(pos_list, amp_list, 'r^', label=target_label)
plt.legend()
plt.show()
if __name__ == '__main__':
# exit
RFfolder = os.path.join(\
projhomepath,\
'TestResult',\
'pc',\
'r5')
TargetRecordList = ['sel38', 'sel42', 'result_sel821', 'result_sel14046']
# ==========================
# plot prediction result
# ==========================
reslist = glob.glob(os.path.join(\
RFfolder,'*'))
qtdb = 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
def collectfeaturesforsig(sig,SaveTrainingSampleFolder,blankrangelist = None,recID = None, training_target_labels = None):
#
# parameters:
# blankrangelist : [[l,r],...]
#
# collect training features from sig
#
# init
Extractor = extfeature.ECGfeatures(sig['sig'])
negposlist = []
posposlist = [] # positive position list
labellist = [] # positive label list
tarpos = []
trainingX,trainingy = [],[]
# get Expert labels
QTloader = QTdb.QTloader()
# =======================================================
# modified negposlist inside function
# =======================================================
ExpertLabels = QTloader.getexpertlabeltuple(
None, sigIN = sig,
negposlist = negposlist
)
# Only train on target labels
if training_target_labels is not None:
ExpertLabels = filter(lambda x: x[1] in
training_target_labels,
ExpertLabels)
if len(ExpertLabels) == 0:
return [[],[]]
posposlist, labellist = zip(*ExpertLabels)
# ===============================
# convert feature & append to X,y
# Using Map build in function
# ===============================
FV = map(Extractor.frompos,posposlist)
# append to trainging vector
trainingX.extend(FV)
trainingy.extend(labellist)
# add neg samples
pickneg = pickNegtiveSample()
#negList = pickneg.getNegList4rec(recID)
negList = pickneg.getRandomNegSamples(recID)
# collect feature for negtive sample
time_neg0 = time.time()
negFv = map(Extractor.frompos,negList)
trainingX.extend(negFv)
trainingy.extend(['white']*len(negList))
print '\nTime for collect negtive samples:{:.2f}s'.format(time.time() - time_neg0)
# =========================================
# Save sample list
# =========================================
ResultFolder = os.path.join(SaveTrainingSampleFolder,'TrainingSamples')
# mkdir if not exists
if os.path.exists(ResultFolder) == False:
os.mkdir(ResultFolder)
# -----
# sample_list
# [(pos,label),...]
# -----
sample_list = zip(negList,len(negList)*['white'])
sample_list.extend(ExpertLabels)
if recID is not None:
# save recID sample list
with open(os.path.join(ResultFolder,recID+'.json'),'w') as fout:
json.dump(sample_list,fout,indent = 4,sort_keys = True)
return (trainingX,trainingy)
def collectfeaturesforsig(sig,
SaveTrainingSampleFolder,
blankrangelist=None,
recID=None,
allowed_label_list=None,
random_relation_path=None):
'''Label process & convert to feature.'''
#
# parameters:
# blankrangelist : [[l,r],...]
#
# collect training features from sig
#
# init
Extractor = extfeature.ECGfeatures(
sig['sig'], random_relation_path=random_relation_path)
negposlist = []
posposlist = [] # positive position list
labellist = [] # positive label list
tarpos = []
# Including positive samples & negtive samples.
trainingX, trainingy = [], []
# get Expert labels
QTloader = QTdb.QTloader()
# =======================================================
# modified negposlist inside function
# =======================================================
ExpertLabels = QTloader.getexpertlabeltuple(None,
sigIN=sig,
negposlist=negposlist)
# Filtering according to allowed labels
if allowed_label_list is not None:
allowed_expert_labels = filter(
lambda x: x[1] in allowed_label_list, ExpertLabels)
if len(allowed_expert_labels) == 0:
return ([], [])
posposlist, labellist = zip(*allowed_expert_labels)
# ===============================
# convert feature & append to X,y
# Using Map build in function
# ===============================
FV = map(Extractor.frompos, posposlist)
# append to trainging vector
trainingX.extend(FV)
trainingy.extend(labellist)
# add neg samples
Nneg = int(len(negposlist) * conf['negsampleratio'])
# if Number of Neg>0 then add negtive samples
if len(negposlist) == 0 or Nneg <= 0:
print '[In function collect feature] Warning: negtive sample position list length is 0.'
else:
# collect negtive sample features
#
# leave blank for area without labels
#
negposset = set(negposlist)
if blankrangelist is not None:
blklist = []
for pair in blankrangelist:
blklist.extend(range(pair[0], pair[1] + 1))
blkset = set(blklist)
negposset -= blkset
selnegposlist = random.sample(negposset, Nneg)
time_neg0 = time.time()
negFv = map(Extractor.frompos, selnegposlist)
trainingX.extend(negFv)
trainingy.extend(['white'] * Nneg)
print '\nTime for collect negtive samples:{:.2f}s'.format(
time.time() - time_neg0)
# =========================================
# Save sample list
# =========================================
ResultFolder = os.path.join(SaveTrainingSampleFolder,
'TrainingSamples')
# mkdir if not exists
if os.path.exists(ResultFolder) == False:
os.mkdir(ResultFolder)
# -----
# sample_list
# [(pos,label),...]
# -----
sample_list = zip(selnegposlist, len(selnegposlist) * ['white'])
sample_list.extend(ExpertLabels)
if recID is not None:
# save recID sample list
with open(os.path.join(ResultFolder, recID + '.pkl'), 'w') as fout:
pickle.dump(sample_list, fout)
save_mat_filename = os.path.join(ResultFolder, recID + '.mat')
reslist_to_mat(sample_list, mat_filename=save_mat_filename)
return (trainingX, trainingy)
def checkQTrec():
sel1213 = conf['sel1213']
QTloader = QTdb.QTloader()
for recname in sel1213:
QTloader.plotrec(recname)
