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)
