def __init__(self, mne_set):
self.mne_set = mne_set
self.Fs = assert_int(mne_set.info['sfreq'])
self.channels = mne_set.info['ch_names']
self.ECG_CHAN = self.channels.index('C126') if len(
self.channels) > 1 else 0
log('loaded mne data: Fs=$', self.Fs)
def __init__(self, version=inf):
log('creating Algorithm: $$', self, version)
if version == inf:
from packaging import version
version = max(self.versions().keys(),
key=lambda k: version.parse(k))
self.version = version
def compare_IBI(s1, s2):
comp = s1.samplesToMs(s2.rPeaks - s1.rPeaks)
times = s1.times(s1.rPeaks) / 60.0
mistakes = arr(comp)[comp != 0]
mistakeTs = arr(times)[comp != 0]
for c, t in zip(mistakes, mistakeTs):
log(f'found a possible mis-detect of {c} at {t}')
log(f'{len(mistakes)=}')
l = PlotData(item_type='line',
y=comp,
x=times,
ylabel='change (ms)',
title=f'{s1.alg.name()} -> {s2.alg.name()}')
start = PlotData(
item_type='line',
y=[min(comp), max(comp)],
x=s1.samplesToMins([s1.RAND_SLICE.start, s1.RAND_SLICE.start]),
item_color='b',
)
stop = PlotData(
item_type='line',
y=[min(comp), max(comp)],
x=s1.samplesToMins([s1.RAND_SLICE.stop, s1.RAND_SLICE.stop]),
item_color='b',
)
t = MultiPlot(l, start, stop)
return t
def input(self, initial="") -> QLineEdit:
log('creating input3!!!')
textInput = QLineEdit(self)
textInput.setText(initial)
textInput.setPalette(MAIN_QPALETTE)
# button.clicked.connect(self.plswork)
return self.add(textInput)
def savepeaks(self):
if self.algmode == 'LOAD':
log('skipping savepeaks for ' + str(self) +
' because data was loaded from file')
#
return False
# obsolete stuff
# if 'heartbeatevents_py' in self.peakfile.load().keys():
# del self.peakfile['heartbeatevents_py']
# del self.peakfile['heartbeatevents_mat']
export = {
'latency': arr(self.rPeaks) + 1,
'type': ['ECG' for _ in itr(self.rPeaks)],
'urevent': [i + 1 for i in itr(self.rPeaks)]
}
self.peakfile[self.alg.name()] = {
'alg': {
'name': self.alg.__class__.__name__,
'version': self.alg.version,
'tag': self.alg.versions()[self.alg.version]
},
'py': arr(self.rPeaks),
'mat': arr(self.rPeaks) + 1,
'heartbeatevents': export
}
self.peakfile['heartbeatevents'] = export
return True
def textPathWrap(self, txt="", readOnly=True):
log('creating textPathWrap3!!!')
txt = PyQt5.QtWidgets.QTextEdit(txt, self)
txt.setAcceptRichText(False)
txt.setReadOnly(readOnly)
txt.setPalette(SPECIAL_TEXT_EDIT_PALETTE)
txt.setAlignment(QtCore.Qt.AlignCenter)
return self.add(txt)
def pane(self, returnBox=False, vertical=True):
log('creating pane3!!!')
box = MQWidget(self, vertical=vertical)
self.add(box)
if returnBox:
return box
else:
return box.gridLayout
def print_exception_again():
from mlib.boot.mlog import log, LOG_LEVEL, LogLevel
import mlib.boot.mlog
# @atexit.register is first in, last out.
# exctype, value, tb
if not mlib.boot.mlog.QUIET and LOG_LEVEL.value >= LogLevel.WARN.value: log(f'{len(exceptions)=}')
for e in exceptions:
if e[0] != Short_MException:
sys.__excepthook__(*e)
def flush(self):
if self.stopped: return
if not just_fun:
if print_not_log:
print(self.output_buffer.decode(), end='')
else:
log(
self.output_buffer.decode()
) # needs to go through log function for log table/pie chart to work
# sys.stdout.buffer.write(self.output_buffer)
self.output_buffer = bytearray()
def monitor():
log('in monitor thread')
while not self._detatch_monitor:
data = f"\n\n{self.__class__.__name__} Monitor\n{str(self.p)}\n\n"
if logfile is None:
print(data)
else:
from mlib.file import File
File(logfile).append(data)
sleep(5)
log('end of monitor thread')
def _save(self, pretrained=False):
model_save_file = f'_arch/{self.ARCH_LABEL}'
if pretrained:
model_save_file = f'{model_save_file}_pretrained'
try:
self.net.save(model_save_file)
self.net.save(f'{model_save_file}.h5')
log('saved model')
except TypeError:
warn(f'could not save model due to tf bug')
File(model_save_file).deleteIfExists()
File(f'{model_save_file}.h5').deleteIfExists()
def val_eval(self):
nnstate.CURRENT_TRUE_MAP = self.val_data.class_label_map
ds = self.val_data.dataset(self.HEIGHT_WIDTH)
steps = self.val_data.num_steps
log('Testing... (ims=$,steps=$)', len(self.val_data), steps)
net_mets.cmat = zeros(len(listkeys(nnstate.CURRENT_PRED_MAP)),
len(listkeys(nnstate.CURRENT_TRUE_MAP)))
nnstate.TEST_STEPS = steps
return self.net.evaluate(
ds,
verbose=self.VERBOSE_MODE,
steps=steps,
use_multiprocessing=True,
workers=16,
)
def zip_to(self, dest):
if not self.default_quiet:
mlog.log('zipping...')
from mlib.shell import ishell
p = ishell()
# p = shell()
p.cd(self.parentDir)
p.sendline('DONEVAR=DONEWITHZIP')
p.sendline('DONEVARR=REALLYDONEWITHZIP')
p.zip(['-r', File(dest).abspath, self.name])
p.echo('$DONEVAR$DONEVARR')
p.expect('DONEWITHZIPREALLYDONEWITHZIP')
p.close()
zipfile = File(dest).zipfile
assert zipfile.exists # might not if zip command doesnt exist in container
return zipfile
def text(self, txt="", data=None, click_handler=None):
log('creating text3!!!')
class MyQLabel(QLabel):
def __init__(self, *args, ldata=None):
super(QLabel, self).__init__(*args)
self.data = ldata
def mousePressEvent(self, event):
if click_handler is not None:
click_handler(self.data)
txt = MyQLabel(txt, self, ldata=data)
txt.setPalette(MAIN_QPALETTE)
txt.setAlignment(QtCore.Qt.AlignCenter)
return self.add(txt)
def lambda_and_raise_if_err(self, l=None):
if l is None:
l = lambda lin: log(f'{self}: {lin}')
lines = self.readlines()
for line in lines:
l(line)
if self.p.returncode != 0:
raise Exception(f'return code not 0: {self.p.returncode}')
def train(self):
log('training network...')
nnstate.CURRENT_PRED_MAP = self.train_data.class_label_map
nnstate.CURRENT_TRUE_MAP = self.train_data.class_label_map
ds = self.train_data.dataset(self.HEIGHT_WIDTH)
steps = self.train_data.num_steps
log('Training... (ims=$,steps=$)', len(self.train_data), steps)
net_mets.cmat = zeros(len(listkeys(nnstate.CURRENT_PRED_MAP)),
len(listkeys(nnstate.CURRENT_TRUE_MAP)))
history = self.net.fit(
# x,y,
ds,
epochs=1,
verbose=self.VERBOSE_MODE,
use_multiprocessing=True,
workers=16,
steps_per_epoch=steps,
shuffle=False)
return history
def update(self, s):
# @log_invokation
log('invoking update')
if self.update_fun is not None:
log('update fun is not none')
self.update_fun(s)
log('actually passed update fun')
def exec(self):
if self.worker_thread is not None:
log('starting worker')
# self.runnable.finished.connect(app.exit)
self.worker_thread.start()
self.start_worker_sig.emit()
# QThreadPool.globalInstance().start(self.runnable)
log('showing win')
self.win.show()
log('really executing app')
return super().exec()
def pipe_and_close_on(self, expect_s, close_fun=None):
for s in self.readlines_nonblocking():
if s is not None:
log(s)
if s is not None and expect_s in s:
log(f'done! ({self} got {expect_s})')
if close_fun is not None:
close_fun(self)
self.close()
log('closed p')
break
def pub_print_warn():
from mlib.boot.mlog import warnings, log, LOG_LEVEL, LogLevel, info
import mlib.boot.mlog
if not mlib.boot.mlog.QUIET and LOG_LEVEL.value >= LogLevel.WARN.value: log(f'{len(warnings)=}')
if len(warnings) > 0:
log('WARNINGS:')
warning_map = {}
for w in warnings:
if w in warning_map:
warning_map[w] += 1
else:
warning_map[w] = 1
for k, v in listitems(warning_map):
log(f'\t{k} ({v} occurrences)')
else:
info('NO WARNINGS!')
def clear_cell_cache():
c = len(CELL_CACHE.files_recursive)
CELL_CACHE.clear()
log(f'deleted {c} cell cache files')
def try_delete(w, p):
if w is not None:
log('removing1')
try:
p.removeWidget(w.name)
except AttributeError:
log('attribute error name')
except RuntimeError:
log('widget already deleted')
return
try:
w.deleteLater()
except AttributeError:
log('attribute error delete later')
try:
w.setParent(None)
except AttributeError:
log('attribute error set parent')
log('removing2')
def write_arch_summary(self):
arch_summary_file = self.arch_summary_folder[f'{self.ARCH_LABEL}.txt']
log('writing summary')
with open(arch_summary_file, 'w') as fh:
self.net.summary(print_fn=lambda x: fh.write(x + '\n'))
def button(self, text, fun):
log('creating button3!!!')
button = QPushButton(text, self)
button.setPalette(MAIN_QPALETTE)
button.clicked.connect(fun)
return self.add(button)
def rpeak_detect(self, ecg_raw, Fs, ecg_flt, ecg_raw_nopl_high):
ecg = self.ecg_raw # only needed for ecglab_slow
log('R wave detection in progress... Please wait...')
log('start slow algorithm')
# find peak
step = round(0.200 * Fs)
area = 2 * Fs
ret = assert_int(0.160 * Fs)
sz = len(ecg_flt)
ecg_temp = -1500 * ones((sz, 1))
n = 0
qrs = []
log('repeat for every cardiac cycle')
prog = Progress(sz)
while n + 1 < sz:
prog.tick(n)
maxval = 0
ind = None
if (n + area) < sz:
lm = 0.15 * max(abs(ecg_flt[n:n + area]))
else:
lm = 0.15 * max(abs(ecg_flt[(sz - area) - 1:sz]))
while (ecg_flt[n] > lm) and (n + 1 < sz):
if abs(ecg_flt[n]) > maxval:
maxval = abs(ecg_flt[n])
ind = n
n = n + 1
if ind is not None:
ecg_temp[ind] = 1
n = ind + step
else:
n = n + 1
for kk in range(0, sz - Fs, Fs):
ecg[kk:kk + Fs -
1] = ecg[kk:kk + Fs - 1] - mean(ecg[kk:kk + Fs - 1])
d1 = ret
n = 0
prog = Progress(sz)
while n + 1 <= sz:
prog.tick(n)
maxval = 0
ind = None
while ecg_temp[n] == 1 and n + 1 <= sz:
if (n + 1) - d1 > 0:
ini = n - ret
else:
ini = 0
maxval, ind = mymax(abs(ecg[ini:n + 1]))
ind = fix(ini + ind)
qrs.append(ind)
n += 1
n += 1
if len(qrs) == 0:
qrs = -1
log('returning qrs')
return qrs
def find_local_maxima(r_indices,
ecg_flt,
FIX_WIDTH=100,
CROP_FIRST_LAST=False,
AUTO=True,
ABS=True):
# (searchback)
if isint(FIX_WIDTH):
FIX_WIDTH = (FIX_WIDTH, FIX_WIDTH)
if ABS:
myabs = abs
else:
myabs = lambda x: x
r_indices = flat(r_indices)
y = []
for i in itr(r_indices):
y.append(ecg_flt[r_indices[i]])
newlats = r_indices
marks = []
if AUTO:
log('automatically fixing all heartbeats')
with Progress(len(r_indices), 'searching back on', 'marks') as prog:
for i in itr(r_indices):
if CROP_FIRST_LAST and (i == 0 or i == len(r_indices) - 1):
continue
fix_width_back = min(FIX_WIDTH[0], r_indices[0])
fix_width_forward = FIX_WIDTH[1]
the_lat = assert_int(r_indices[i])
mn = the_lat - fix_width_back
mx = the_lat + 1 + fix_width_forward
if len(ecg_flt) >= mx:
snippet = ecg_flt[mn:mx]
else:
snippet = ecg_flt[mn:len(ecg_flt)]
[M, I] = mymax(myabs(snippet))
fixed_lat = the_lat + I - fix_width_back
if M != ecg_flt[the_lat]:
if not AUTO:
log('i=' + num2str(i) + '/' + num2str(len(r_indices)))
plt.plot(ecg_flt)
plt.scatter([r_indices[i], fixed_lat], [y[i], M], [],
[[1, 0, 0], [0, 0, 1]])
plt.xlim([mn, mx])
plt.show()
s = input('fix?(y/n)')
else:
s = 'y'
if strcmp(s, 'y'):
if not AUTO:
disp('fixing')
newlats[i] = fixed_lat
marks = [marks, the_lat]
else:
disp('skipping')
prog.tick()
return newlats
def toc(self, n):
if not self.disabled:
t = time.monotonic_ns() - self._tic
log(f'{self.name}\t{n}\t{t}')
def line(fd):
from mlib.wolf.wolf_figs import defaultPlotOptions
x = fd.x
y = fd.y
log('creating a line with length: ' + str(len(fd.y)))
# if DS is not None and len(x) > DS:
# ds = floor(len(x) / DS)
# x = simple_downsample(x, ds)
# y = simple_downsample(y, ds)
#
# log("downsampled")
calcedMinY = min(list(filter(lambda x: x is not None, y)))
calcedMaxY = max(list(filter(lambda x: x is not None, y)))
map_expr = wlexpr('{#1, #2} &')
ops = defaultPlotOptions(fd)
if fd.callout is not None:
ops += [
LabelingFunction(
wlexpr(
f'If[#1[[1]] == {fd.callout_x}, Callout[",{fd.callout}", Above ,LabelStyle->{{10,Bold,White}},Background->Black]] &'
))
]
if fd.item_colors is not None:
ops.append(Rule(wl.PlotStyle, Color(*fd.item_colors)))
# data = wl.MapThread(map_expr, [x, y])
# err('we had to remove weval for pool debug')
# data = weval(data)
# data = list(data)
data = ziplist(x, y)
if fd.callouts is not None:
for i in range(len(y) - 1):
# print('\tcallout for ' + str(data[-1]))
col = fd.item_colors[i]
# print('\tcolor: ' + str(col))
col = Color(*col)
data[i] = list(data[i])
data[i][-1] = Callout(
data[i][-1],
fd.callouts[i],
data[i][-1], # pos
Background(col),
Appearance('Balloon'),
LeaderSize([5, wlexpr('180 Degree'), 1]))
elif False and len(y) > 2: #TEMP DISABLE
print('\tcallout for ' + str(data[-1]))
col = fd.item_colors
print('\tcolor: ' + str(col))
col = Color(*fd.item_colors)
data[-1] = Callout(
data[-1],
fd.y_label,
data[-1], # pos
Background(col),
Appearance('Balloon'),
LeaderSize([5, wlexpr('180 Degree'), 1]))
return ListLinePlot(
data,
defaultPlotOptions(fd),
ops,
)
if 'Asana' in fd.title:
return ListLinePlot(fd.x, fd.y, defaultPlotOptions(fd),
"todo: log scale if y_log_scale")
if firstLine:
fd2 = viss[1]
x2 = fd2.x
y2 = fd2.y
