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