def _initParams(model): d=model.d; n=model.n; k=model.k if(DBG): tl.msg("init params") if(DBG): tl.msg("d: %d, n: %d, k:%d"%(d, n, k)) # init KF params A=np.random.random((k,k)) C=np.random.random((d,k)) A0=np.random.random(k)*tl.ZERO C0=np.random.random(d)*tl.ZERO # set KF params kf = KalmanFilter( transition_matrices=A, transition_offsets=A0, observation_matrices=C, observation_offsets=C0, #transition_covariance = np.eye(k)*tl.ZERO, #((k,k)), #observation_covariance = np.eye(d)*tl.ZERO, #((k,k)), #n_dim_state=k, n_dim_obs=d, em_vars=[ 'transition_matrices', 'transition_covariance', 'transition_offsets', 'observation_matrices', 'observation_covariance', 'observation_offsets', 'initial_state_mean', 'initial_state_covariance']) return kf
def _FM(mdb, Xc, lene, smin, PE, fixORopt): # dictMS (see, om_trans.py) dictMS = { 'cid': PE['cid'], 'si': tl.dcopy(PE['md'].si), 'rho': mdb.rho_MS, 'smin': smin, 'errV': tl.INF } if (fixORopt == 'OPT'): dictMS = om_trans.fit_forward(Xc, mdb, dictMS, W_FM) #, DPS) (Ve, Se, Re) = om_trans.gen_forward_multi_trans(Xc, mdb, dictMS, lene, MULTI_TRANS) #(Ve, Se, Re)=om_trans.gen_forward(mdb, dictMS, lene) errV = tl.RMSE(Xc, Ve[0:len(Xc)]) if (_isUnfit(Ve, mdb)): Ve[:] = np.nan Se[:] = np.nan Re[:] = REID_NULL errV = tl.INF if (DBG0): tl.msg("%s ++++++ _FM(%s): errV:%f (cid:%d) " % (IDT_F, fixORopt, errV, dictMS['cid'])) PF = {'Ve': Ve, 'Se': Se, 'Re': Re, 'errV': errV} return PF
def _update_ms_insert(mdb, PE_fr, PE_to): idx_fr=PE_fr['cid']; idx_to=PE_to['cid']; # if not exist, just ignore if(idx_fr == -1 or idx_to == -1): return mdb # create new ms record ms_new=_create_new_ms_rcd(PE_fr, PE_to) # (a) find fr_to in mdb idxs="%d_%d"%(idx_fr, idx_to) if(not (idxs in mdb.MS)): mdb.MS[idxs]=[] # best-candidate ms_best=-1; err_best=tl.INF # (a-i) find closest mss for ms_idxs_i in mdb.MS[idxs]: ms_d=ms_idxs_i['medoid'] err_i=0.5*( tl.RMSE(ms_d['vn_fr'],ms_new['vn_fr']) + tl.RMSE(ms_d['v0_to'],ms_new['v0_to']) ) #tl.eprint(mdb.rho_MS, err_i) #tl.eprint(ms_d['vn_fr'], ms_new['vn_fr'], ms_d['v0_to'],ms_new['v0_to']) if(err_i<err_best): ms_best=ms_idxs_i; err_best=err_i; #tl.eprint("err_best: %f (%f)"%(err_best, mdb.rho_MS)) # (b) update MS[idxs] if(err_best<mdb.rho_MS): # if we have similar ms ms_best['object'].append(ms_new) if(DBG): tl.msg("MDB-MS (insert): # of object=%d"%(len(ms_best['object']))) else: # if unknown, then create new MS mdb.MS[idxs].append({'medoid':ms_new, 'object':[ms_new]}) return mdb
def _RU(Xc, PE_cr, fixORopt): tm_st = PE_cr['tm_st'] tm_ed = PE_cr['tm_ed'] if (_isNullP(PE_cr)): if (DBG0): tl.msg("%s ...... _RU: (null)" % (IDT_E)) else: cid = PE_cr['cid'] # put cid md_c = tl.dcopy(PE_cr['md']) # copy model md_c.n = len(Xc) md_c.data = Xc # copy data if (fixORopt == 'OPT'): md_c = md_c.fit_si(W_RR, DPS) # update init si (i.e., s(0)=si) (Sc, Vc) = md_c.gen() # generate events errV = tl.RMSE(Xc, Vc) md_c.fn = "seg:t%d-%d_e%.2f" % (tm_st, tm_ed, errV) if (DBG0): tl.msg("%s ...... _RU: errV:%f (cid:%d)" % (IDT_E, errV, cid)) PE_cr = { 'md': md_c, 'cid': cid, 'Vc': Vc, 'Sc': Sc, 'siset': {}, 'tm_st': tm_st, 'tm_ed': tm_ed, 'errV': errV } return PE_cr
def _update_ms_apoptosis(mdb, minc): # (a) check each len(MS[idxs][j]) for idxs in mdb.MS: rlst=[] # rls: remove list for j in range(0,len(mdb.MS[idxs])): cnum=len(mdb.MS[idxs][j]['object']) #blocked=mdb.MS[idxs][j]['medoid']['block'] active=mdb.MS[idxs][j]['medoid']['active'] if(DBG): tl.msg("|-------- MDB-MS (apoptosis-minc:%d): %s[%d], #ofsamples:%d, active=%d"%(minc, idxs, j, cnum, active)) #if(cnum<=minc): # or blocked): notfinA if(cnum<=minc or (active == tl.NO)): # if less than minc or non-active rlst.append(j) # (a') remove id from mdb rlst.sort(reverse=True) for j in rlst: mdb.MS[idxs].pop(j) # (b) check each len(MS[idxs]) rlst=[] # rls: remove list for idxs in mdb.MS: cnum=len(mdb.MS[idxs]) if(DBG): tl.msg("|-------- MDB-MS (apoptosis:%d): %s[xx], #ofsamples:%d"%(minc, idxs, cnum)) if(cnum<=0): # if is_empty rlst.append(idxs) # (b') remove id from mdb for idxs in rlst: del(mdb.MS[idxs]) return mdb
def run_est(Xorg, lstep, outdir, mscale_h=1): tl.msg("run_est - start ...") _set_env(lstep, mscale_h) if (mscale_h == 1): # single run_est_single(Xorg, lstep, outdir) else: # multi-scale om_multiscale.run_est_mscale(Xorg, lstep, mscale_h, outdir) tl.msg('run_est - end.')
def run_scan(Xorg, lstep, modeldir, outdir, mscale_h=1): tl.msg("run_scan - start ...") _set_env(lstep, mscale_h) if (mscale_h == 1): # single run_scan_single(Xorg, lstep, modeldir, outdir) else: # multi-scale om_multiscale.run_scan_mscale(Xorg, lstep, mscale_h, modeldir, outdir) tl.msg('run_scan - end.')
def run_viz(cdir, animation=ANIMATION): _set_env(cdir, animation) tl.msg("om_viz (visualization), animation=%d, mscale=%d" % (animation, MSCALE_H)) if (MSCALE_H == 0): _run_single(cdir, animation) else: _run_mscale(cdir, animation) #--------------------------------# tl.msg('om_viz end.')
def __init__(self, data, fn='', ma=1): if (DBG): tl.msg("NLDS") (n, d) = np.shape(data) self.kmax = max(2, d + KMAXPLS) #max(KLIST) #self.kmax=max(KLIST) self.data = data self.fn = fn self.ma = ma
def gen_forward_multi_trans(Xc, mdb, dictMS, lene, MULTI_TRANS=tl.YES, dps=1): if (DBG): tl.msg("om_trans: generate (forward + multi_trans)") lene_l = int(lene * L_R) # generate Ve + extra #--------------------------------# (Ve, Se, Re, Final) = _forward(mdb, dictMS, lene_l, dps, MULTI_TRANS) if (MULTI_TRANS): (Ve) = _combine_multi_trans(Xc, Final, Ve, Re) #--------------------------------# Ve = Ve[:lene, :] Se = Se[:lene, :] Re = Re[:lene] return (Ve, Se, Re)
def gen_forward(mdb, dictMS, lene, dps=1): if (DBG): tl.msg("om_trans: generate (forward)") lene_l = int(lene * L_R) # generate Ve + extra #--------------------------------# MULTI_TRANS = tl.NO (Ve, Se, Re, Final) = _forward(mdb, dictMS, lene_l, dps, MULTI_TRANS) #--------------------------------# Ve = Ve[:lene, :] Se = Se[:lene, :] Re = Re[:lene] return (Ve, Se, Re)
def _set_env(cdir, animation): mscale = 0 while (True): dir_i = '%s_Level%d' % (cdir, mscale) if (not tl.os.path.isdir(dir_i)): break mscale += 1 global MSCALE_H MSCALE_H = mscale global ANIMATION ANIMATION = animation tl.msg('om_viz (set_env): animation=%d, mscale=%d' % (animation, mscale))
def _FP(Xc, lene): (lenc, d) = np.shape(Xc) Ve = np.zeros((lene, d)) if (CUTNP == "MEAN"): Ve[0:lene, :] = tl.mynanmean(Xc, axis=0) if (CUTNP == "LAST"): Ve[0:lene, :] = Xc[-1, :] Se = -1 * np.ones((lene, 1)) Re = REID_NULL * np.ones(lene) errV = tl.RMSE(Xc, Ve[0:len(Xc)]) #=tl.INF # if (DBG0): tl.msg("%s ++++++ _FP(FIX): errV:inf (cid:%d) " % (IDT_F, REID_NULL)) PF = {'Ve': Ve, 'Se': Se, 'Re': Re, 'errV': errV, 'MSs': []} return PF
def run_est_mscale(Xorg, lstep, mscale_h, outdir): tl.msg("multiscale (run_est_mscale) start... (multiprocessing: %d)"%MULTI) # (1) create multi-scale sequences (XHs, wdHs, outdirHs) = _create_multiscale_seqs(Xorg, lstep, mscale_h, outdir) # (2) arg-setting arg_list=[] for i in range(0,mscale_h): arg_list.append([XHs[i], lstep, outdirHs[i], wdHs[i]]) # (3) start orbitmap (pre-processing) if(MULTI): _multi_proc_run_est(arg_list) else: for i in range(0,mscale_h): orbitmap.run_est_single(XHs[i], lstep, outdirHs[i], wdHs[i]) tl.msg('multiscale (run_est_mscale) end.')
def _update_md_insert(mdb, PE_ins): cid=PE_ins['cid']; md_ins=PE_ins['md']; if(DBG): tl.msg("om_mdb: MDB-MD (insert): cid:%d (c=%d)"%(cid, mdb.get_c())) # (A) if, known regime, then insert & return if(cid!=-1): mdb.MD[cid]['object'].append(md_ins) # (B) if unknown regime, then create new MD if(cid==-1): mdb.cid_counter+=1; cid=mdb.cid_counter; mdb.MD[cid]={'medoid':md_ins, 'object':[md_ins]} PE_ins['cid']=cid # (C) return result return (mdb, PE_ins)
def _update_md_apoptosis(mdb, Snaps, minc): # (a) find id list rlst=[] # rls: remove list for i in mdb.MD: md=mdb.MD[i] cnum=len(md['object']) if(DBG): tl.msg("|-------- MDB-MD (apoptosis-minc:%d): %s, #ofsamples:%d"%(minc, i, cnum)) if(cnum<=minc): rlst.append(i) # (b) remove id from mdb for i in rlst: mdb=_update_md_ms_delete_idx(mdb, i) # delete regime_id=i from MDB MD_IDs={}; MD_IDs[i]=REID_NULL; Snaps=_init_MD_ID_Snaps(Snaps, MD_IDs) # Snaps: delete regime_id=i return (mdb, Snaps)
def _FS(mdb, Xc, lene, PE, fixORopt): md_c = PE['md'] #; si=md_c.si (Se, Ve) = md_c.gen(lene) #(Se,Ve)=md_c.forward(si, lene) Re = REID_NULL * np.ones(lene) errV = tl.RMSE(Xc, Ve[0:len(Xc)]) if (_isUnfit(Ve, mdb)): Ve[:] = np.nan Se[:] = np.nan Re[:] = REID_NULL errV = tl.INF if (DBG0): tl.msg("%s ++++++ _FS(%s): errV:%f (cid:%d) " % (IDT_F, fixORopt, errV, REID_NULL)) PF = {'Ve': Ve, 'Se': Se, 'Re': Re, 'errV': errV} return PF
def run_scan_mscale(Xorg, lstep, mscale_h, modeldir, outdir): tl.msg("multiscale (run_scan_mscale) start... (multiprocessing: %d)"%MULTI) # (1) create multi-scale sequences (XHs, wdHs, outdirHs) = _create_multiscale_seqs(Xorg, lstep, mscale_h, outdir) # (2) arg-setting mdirHs={}; arg_list=[] for i in range(0,mscale_h): mdirHs[i]='%s_Level%d/'%(modeldir,i) arg_list.append([XHs[i], lstep, mdirHs[i], outdirHs[i], wdHs[i]]) # (3) start orbitmap (streaming) if(MULTI): _multi_proc_run_scan(arg_list) else: for i in range(0,mscale_h): orbitmap.run_scan_single(XHs[i], lstep, mdirHs[i], outdirHs[i], wdHs[i]) tl.msg("multiscale (run_scan_mscale) end.")
def _nl_fit(nlds, ftype, wtype, dps): #---------------------------------------# # (1) create param set P = _createP(nlds, ftype) #---------------------------------------# # (2) start lmfit lmsol = lmfit.Minimizer(_distfunc, P, fcn_args=(nlds.data, nlds, ftype, wtype, dps)) res = lmsol.leastsq(xtol=XTL, ftol=FTL, maxfev=MAXFEV) if (DBG): tl.msg("end") #---------------------------------------# # (3) update param set nlds = _updateP(res.params, nlds, ftype) #---------------------------------------# return nlds
def __init__(self, lbl): if(DBG): tl.msg("MDB") self.lbl=lbl # label # model params self.MD={} # MD[c] model-dynamics self.MS={} # MS["from_to"] model-shift self.cid_counter=0 # cid_counter # rho self.rho_RE=tl.INF #RHOini_RE #self.errVes=[] self.rho_RF=tl.INF #RHOini_RF #self.errVfs=[] self.rho_MS=tl.INF #RHOini_ms #RHOini # RHOini, notfin # causal-cast self.CC=tl.YES self.Xmin= tl.INF self.Xmax= - tl.INF
def _fit(Xe, mdb, ftype, dictMS, wtype, dps): #---------------------------------------# # (1) create param set P = _createP(dictMS, ftype) #---------------------------------------# # (2) start lmfit lmsol = lmfit.Minimizer(_distfunc, P, fcn_args=(Xe, mdb, dictMS, ftype, wtype, dps)) res = lmsol.leastsq(xtol=XTL, ftol=FTL, maxfev=MAXFEV) if (DBG): tl.msg("end") #---------------------------------------# # (3) update param set dictMS = _updateP(res.params, dictMS, ftype) #---------------------------------------# # (4) generate return (dictMS)
def write_dot(CGraph, outfn): if (DBG): tl.msg("Write graph %s.dot" % (outfn)) #--------------------------------# f = open("%s.dot" % (outfn), "w") f.write("digraph G {\n") #f.write("node [fontname=Arial, fontsize=12, color=white, style=filled];") f.write("bgcolor=\"#ffffff00\"\n") # RGBA (with alpha) f.write("ratio=2.0\n") #f.write("splines=true\n") #f.write("overlap=scale\n") f.write("graph [size=\"4.0,8.0\", center=true];") #viz quality notfinA #f.write("graph [size=\"4,4\",page=\"4.0,4.0\", center=true];") #viz quality notfinA #f.write("graph [dpi = 80];") #viz quality notfinA f.write("node [color=white, style=filled, fontsize=%d];" % (FONTSIZE)) f.write("edge [fontsize=%d];" % (FONTSIZE)) #f.write("size =\"4,4\";\n") for rcd in CGraph['MD']: if (not 'col' in rcd): rcd['col'] = 'lightgray' if (not 'cnt' in rcd): rcd['cnt'] = 1.0 if (DBG): lbl = '#%d (%d)' % (rcd['id'], rcd['cnt']) else: lbl = '#%d' % (rcd['id']) size = min(MINSIZE + np.log2(rcd['cnt'] + 1), MAXSIZE) f.write( "%s [label=\" %s \", shape=circle, width=%f, fillcolor=%s];\n" % (rcd['id'], lbl, size, rcd['col'])) for rcd in CGraph['MS']: #if(not 'col' in rcd): rcd['col']='dimgrey' if (not 'col' in rcd): rcd['col'] = 'black' if (not 'shape' in rcd): rcd['shape'] = 'solid' if (not 'cnt' in rcd): rcd['cnt'] = 1.0 if (DBG): lbl = '%d (%d)' % (rcd['tcnt'], rcd['cnt']) else: lbl = '%d' % (rcd['cnt']) #lbl='' size = min(MINSIZE + (rcd['cnt']), MAXSIZE) f.write( "%s -> %s [label=\" %s \", color=%s, style=%s, penwidth=%f];\n" % (rcd['fr'], rcd['to'], lbl, rcd['col'], rcd['shape'], size)) f.write("}\n") f.close() #--------------------------------# # convert dot -> pdf tl.os.system("dot -T pdf %s.dot -o %s.pdf" % (outfn, outfn)) tl.os.system("dot -T png %s.dot -o %s.png" % (outfn, outfn))
def _RE(Xc, tm_st, tm_ed): # estimate new model dynamics (md_c) md_c = nl.NLDS(Xc, "t%d-%d" % (tm_st, tm_ed)) md_c = md_c.fit(W_RE) # lmfit (Sc, Vc) = md_c.gen() # generate events errV = tl.RMSE(Xc, Vc) md_c.fn = "seg:t%d-%d_e%.2f" % (tm_st, tm_ed, errV) if (DBG0): tl.msg("%s ...... _RE: errV:%f (cid:-1)" % (IDT_E, errV)) PE_cr = { 'md': md_c, 'cid': -1, 'Vc': Vc, 'Sc': Sc, 'siset': {}, 'tm_st': tm_st, 'tm_ed': tm_ed, 'errV': errV } return PE_cr
def _create_new_ms_rcd(PE_fr, PE_to): idx_fr=PE_fr['cid']; md_fr=PE_fr['md'] idx_to=PE_to['cid']; md_to=PE_to['md'] cpt=PE_to['tm_st'] # create new regime-shift record # here, ms_rcd={cpt, active, md_fr, vn_fr, md_to, si_to} rcd={'cpt': cpt, 'active': tl.YES} # --- from --- # (Sta, Obs) = md_fr.gen(); rcd['md_fr']=md_fr; rcd['si_fr']=Sta[0,:]; rcd['sn_fr']=Sta[-1,:]; rcd['v0_fr']=Obs[0,:]; rcd['vn_fr']=Obs[-1,:] # --- to --- # (Sta, Obs) = md_to.gen(); rcd['md_to']=md_to; rcd['si_to']=Sta[0,:]; rcd['sn_to']=Sta[-1,:]; rcd['v0_to']=Obs[0,:]; rcd['vn_to']=Obs[-1,:] if(DBG): tl.msg("|-------- MDB-MS (object): cpt: %d, from: %d, to:%d (%s, %s)"%(cpt, idx_fr, idx_to, md_fr.fn, md_to.fn)) return rcd
def _distfunc(P, Xe, mdb, dictMS, ftype, wtype, dps): #data, nlds, ftype, wtype, dps): if (DBG): tl.dotting() if (DBG): tl.msg("_distfunc: rmse:%f, rho:%f" % (_distfunc_rmse(Xe, mdb, dictMS), dictMS['rho'])) (n, d) = np.shape(Xe) lene = n # update parameter set dictMS = _updateP(P, dictMS, ftype) # generate seq (Oe, Se, Re) = om_trans.gen_forward(mdb, dictMS, lene, dps) if (dps > 1): Xe = Xe[range(0, lene, dps), :] # diffs diff = Xe.flatten() - Oe.flatten() diff[np.isnan(diff)] = 0 # weighted-fit diff = diff * tl.func_Weight(len(diff), wtype) return diff
def fit(Xe, mdb, ftype, dictMS, wtype='uniform', dps=1): #--------------------------------# if (DBG): tl.comment("=== start LMfit ===") if (DBG): tl.comment("(%s,%s,%d)" % (ftype, wtype, dps)) if (DBG): tl.msg("rmse: %f" % _distfunc_rmse(Xe, mdb, dictMS)) if (DBG): tl.comment("start fitting") #--------------------------------# if (DBG): tic = time.clock() (dictMS) = _fit(Xe, mdb, ftype, dictMS, wtype, dps) if (DBG): toc = time.clock() fittime = toc - tic dictMS['errV'] = _distfunc_rmse(Xe, mdb, dictMS) #--------------------------------# if (DBG): tl.comment("end fitting") if (DBG): tl.msg("time: %f" % fittime) if (DBG): tl.comment("=== end LMfit ===") #--------------------------------# return dictMS
def _compute_rho_min(Xorg, lstep): (n, d) = np.shape(Xorg) lmin = max(LMIN, int(lstep * AVGR)) errs = [] for i in range(0, AVG_TRIAL): tm_st = int((n - lmin) * np.random.rand()) tm_ed = tm_st + lmin if (tm_st < 0 or tm_ed >= n): continue Xc = Xorg[tm_st:tm_ed, :] md_c = nl.NLDS(Xc, "t-%d" % (i)) md_c = md_c.fit(W_RE) # lmfit (Sc, Vc) = md_c.gen() # generate events err = tl.RMSE(Xc, Vc) errs.append(err) if (DBG1): tl.msg("trial: %d, st:%d, ed:%d, err:%.2f" % (i, tm_st, tm_ed, err)) #md_c.plot("%s_s_%d"%(mdb.fn,i)) rho = om_mdb.compute_RHO_W_ERRs(errs) tl.eprint("estimated initial rho: ", rho) #, errs) return rho
def _create_multiscale_seqs(Xorg, lstep, mscale_h, outdir): tl.msg("_create_multiscale_seq (lstep: %d, mscale_h: %d)"%(lstep, mscale_h)) tl.save_seq_txt_pdf(Xorg, "%sXorg"%outdir) # multi-scale sequences XHs={}; Xagg=tl.dcopy(Xorg); outdirHs={} wdHs={} # window size list for i in range(0,mscale_h): # window size at i-th level if(i<mscale_h-1): wdHs[i]=lstep*(2**(mscale_h-1-i)) # if HT=4: 3,2,1 ... (i.e., 8xlstep, 4xlstep, 2xlstep, 1) #if(i<mscale_h-1): wdHs[i]=lstep*(2**(mscale_h-2-i)) # if HT=4: 2,1,0 ... (i.e., 4xlstep, 2xlstep, lstep, 1) #if(i<mscale_h-1): wdHs[i]=lstep*(2**(mscale_h-3-i)) # if HT=4: 1,0,-1 ... (i.e., 2xlstep, lstep, 1/2xlstep, 1 else: wdHs[i]=1 # if, last seq for i in range(0,mscale_h): XHs[i]=tl.smoothWMAo(Xagg, wdHs[i]) # compute i-th level Xagg=Xagg-XHs[i] # delete current scale for i in range(0,mscale_h): #XHs[i]= XHs[i][int(wdHs[0]):,:] # delete longest-window XHs[i][0:int(wdHs[0]),:]=tl.NAN # delete longest-window outdirHs[i]='%s_Level%d/'%(outdir,i); tl.mkdir(outdirHs[i]) # directory # save sequence at i-th level tl.save_txt(XHs[i], '%sXorg.txt'%(outdirHs[i])) # save data tl.plt.clf(); tl.plt.plot(XHs[i]) # plot and save figure tl.savefig("%sXorg"%(outdirHs[i]), 'pdf') tl.msg("wdHs: ") tl.msg(wdHs) return (XHs, wdHs, outdirHs)
def nl_fit(nlds, ftype, wtype, dps): nlds_org = tl.dcopy(nlds) #--------------------------------# if (ftype != 'si' and ftype != 'A2' and ftype != 'A01' and ftype != 'B01'): tl.warning("fit.py: usage: [si/M2/A01/B01]") #--------------------------------# if (ftype == 'si'): # if si, i.e., arg{s(0)=si} global MAXFEV MAXFEV = MAXFEVi global XTL XTL = XTLi global FTL FTL = FTLi #--------------------------------# if (DBG): tl.comment("=== start LMfit ===") if (DBG): tl.comment("(%s,%s,%d)" % (ftype, wtype, dps)) if (DBG): tl.msg("rmse: %f" % _distfunc_rmse(nlds)) if (DBG): tl.comment("start fitting") #--------------------------------# if (DBG): tic = time.clock() nlds = _nl_fit(nlds, ftype, wtype, dps) if (DBG): toc = time.clock() fittime = toc - tic #--------------------------------# if (_distfunc_rmse(nlds_org) < _distfunc_rmse(nlds)): nlds = nlds_org #notfin if (DBG): tl.comment("end fitting") if (DBG): tl.msg("time: %f" % fittime) if (DBG): tl.msg("rmse: %f" % _distfunc_rmse(nlds)) if (DBG): tl.comment("=== end LMfit ===") #--------------------------------# return nlds
def _find_opt_cut(Xorg, PE_vp, PE_vc, lenw, lmin): tp_st = PE_vp['tm_st'] tc_ed = PE_vc['tm_ed'] # start/end points tcut = PE_vp['tm_ed'] # current cut-point errs = [] locs = [] # find best-cut-position t_st = max(tp_st + lmin, tcut - int(lenw / 2)) t_ed = min(tc_ed - lmin, tcut + int(lenw / 2)) PE_vps = [] PE_vcs = [] if (t_st == t_ed): return (PE_vp, PE_vc) for loc in range(t_st, t_ed, int(max(1, (t_ed - t_st) / OPTCNT))): PE_vpi = tl.dcopy(PE_vp) PE_vci = tl.dcopy(PE_vc) PE_vpi['tm_ed'] = loc PE_vci['tm_st'] = loc PE_vpi = _RU(Xorg[tp_st:loc, :], PE_vpi, 'OPT') PE_vci = _RU(Xorg[loc:tc_ed, :], PE_vci, 'OPT') err = PE_vpi['errV'] + PE_vci['errV'] PE_vps.append(PE_vpi) PE_vcs.append(PE_vci) locs.append(loc) errs.append(err) if (DBG0): tl.msg("%s ...... _find_opt_cut l:%d (%f + %f = %f)" % (IDT_E, loc, PE_vpi['errV'], PE_vci['errV'], err)) ibest = np.argmin(errs) locbest = locs[ibest] if (DBG0): tl.msg("%s ...... _find_opt_cut l:%d (%f + %f = %f)" % (IDT_E, locbest, PE_vps[ibest]['errV'], PE_vcs[ibest]['errV'], err)) PE_vp = PE_vps[ibest] PE_vc = PE_vcs[ibest] return (PE_vp, PE_vc)