def case2():
y0 = [[5, 5, 5], [2, 2, 2]]
stepsize = 0.01
maxorder = 2
boundary_order = 1
num_mode = 2
T = 5
ep = 0.01
mergeep = 0.01
method = 'merge'
t_list, y_list = simulation_ode_2(get_fvdp3(0), get_event1(0), y0, T,
stepsize)
A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
np.savetxt("data/A2.txt", A, fmt='%8f')
np.savetxt("data/b2.txt", b, fmt='%8f')
# print(y_list)
# P,G,C = infer_model(
# t_list, y_list, stepsize=stepsize, maxorder=maxorder, boundary_order=boundary_order,
# num_mode=num_mode, modelist=fvdp3, event=event1, ep=ep, mergeep= mergeep, method=method, verbose=False)
y1 = [[3, 3, 3], [4, 4, 4]]
t_test_list, y_test_list = simulation_ode_2(get_fvdp3(0), get_event1(0),
y0, T, stepsize)
YT, FT = diff(t_list + t_test_list, y_list + y_test_list, dynamics.fvdp3_3)
# np.savetxt("data/YT"+str(n)+".txt",YT,fmt='%8f')
# np.savetxt("data/FT"+str(n)+".txt",FT,fmt='%8f')
np.savetxt("data/YT2.txt", YT, fmt='%8f')
np.savetxt("data/FT2.txt", FT, fmt='%8f')
def case1():
y0 = [[0, 2], [0, 3]]
y1 = [[0, 1], [0, 5]]
T = 15
stepsize = 0.01
ep = 0.01,
mergeep = 0.01
maxorder = 3
boundary_order = 2
num_mode = 2
mode = get_mode(0)
event1 = get_event(0)
method = 'piecelinear'
t_list, y_list = simulation_ode_2(get_mode(0), get_event(0), y0, T,
stepsize)
t_test_list, y_test_list = simulation_ode_2(get_mode(0), get_event(0), y1,
T, stepsize)
P, G, C = infer_model(t_list,
y_list,
stepsize=stepsize,
maxorder=maxorder,
boundary_order=boundary_order,
num_mode=num_mode,
modelist=mode,
event=event1,
ep=ep,
mergeep=mergeep,
method=method,
verbose=False)
d_avg = test_model(P, G, C, num_mode, y_list + y_test_list, mode, event1,
maxorder, boundary_order)
print(d_avg)
def case1():
mode2 = experiment1.get_mode2(0)
event1 = experiment1.get_event1(0)
y0 = [[99.5,80],[97.5,100]]
stepsize = 0.1
maxorder = 1
boundary_order = 1
num_mode = 2
T = 50
ep = 0.01
mergeep = 0.01
method='piecelinear'
t_list, y_list = simulation_ode_2(mode2, event1, y0, T, stepsize)
with open('f1tr.txt','ab') as f:
for ypoints in y_list:
np.savetxt(f, ypoints, delimiter=" ")
P,G,C = infer_model(
t_list, y_list, stepsize=stepsize, maxorder=maxorder, boundary_order=boundary_order,
num_mode=num_mode, modelist=mode2, event=event1, ep=ep, mergeep = mergeep, method=method, verbose=False)
# A, b1, b2, Y, ytuple = diff_method_backandfor(t_list, y_list, maxorder, stepsize)
d_avg = test_model(
P, G, C, num_mode, y_list , mode2, event1, maxorder, boundary_order)
# d_avg = test_model2(
# P, G, C, num_mode, A, Y , mode2, event1, maxorder, boundary_order)
print(G)
print(C[0]/C[0],C[1]/C[0],C[2]/C[0])
print(d_avg)
@eventAttr()
def eventtest(t,y):
y0, y1 = y
return C[0] * y0 + C[1] * y1 + C[2]
ttest_list, ytest_list = simulation_ode_2([ode_test(G[0],maxorder),ode_test(G[1],maxorder)], eventtest, y0, T, stepsize)
for i, temp_y in enumerate(y_list):
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
if i == 0:
plt.plot(y0_list,y1_list,c='b',label='Original')
else:
plt.plot(y0_list,y1_list,c='b')
for i, temp_y in enumerate(ytest_list):
y0_list = temp_y.T[0][::5]
y1_list = temp_y.T[1][::5]
if i == 0:
plt.plot(y0_list,y1_list,mfc='None', mec='r',label='Inferred',marker='.',linestyle='None')
else:
# plt.plot(y0_list,y1_list,c='r',linestyle='--',marker=',')
plt.plot(y0_list,y1_list,mfc='None', mec='r',marker='.',linestyle='None')
plt.xlabel('x1')
plt.ylabel('x2')
plt.legend()
plt.show()
def case2():
fvdp3 = experiment2.get_fvdp3(0)
event1 = experiment2.get_event1(0)
y0 = [[5,5,5], [2,2,2]]
stepsize = 0.004
maxorder = 2
boundary_order = 1
num_mode = 2
T = 5
ep = 0.01
mergeep = 0.2
method='tolmerge'
t_list, y_list = simulation_ode_2(fvdp3, event1, y0, T, stepsize)
# A, b1, b2, Y, ytuple = diff_method_backandfor(t_list, y_list, maxorder, stepsize)
P,G,C = infer_model(
t_list, y_list, stepsize=stepsize, maxorder=maxorder, boundary_order=boundary_order,
num_mode=num_mode, modelist=fvdp3, event=event1, ep=ep, mergeep= mergeep,method=method, verbose=False)
d_avg = test_model(
P, G, C, num_mode, y_list , fvdp3, event1, maxorder, boundary_order)
# d_avg = test_model2(
# P, G, C, num_mode, A, Y , fvdp3, event1, maxorder, boundary_order)
print(G)
print(C[0]/C[0],C[1]/C[0],C[2]/C[0],C[3]/C[0])
print(d_avg)
with open('f2tr.txt','ab') as f:
for ypoints in y_list:
np.savetxt(f, ypoints, delimiter=" ")
@eventAttr()
def eventtest(t,y):
y0, y1, y2 = y
return C[0] * y0 + C[1] * y1 + C[2]* y2 + C[3]
ttest_list, ytest_list = simulation_ode_2([ode_test(G[0],maxorder),ode_test(G[1],maxorder)], eventtest, y0, T, stepsize)
ax = plt.axes(projection='3d')
for temp_y in y_list[0:1]:
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
y2_list = temp_y.T[2]
ax.plot3D(y0_list, y1_list, y2_list,c='b',label='Original')
for temp_y in ytest_list[0:1]:
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
y2_list = temp_y.T[2]
ax.plot3D(y0_list, y1_list, y2_list,c='r',label='Inferred', linestyle='--')
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_zlabel('x3')
plt.legend()
plt.show()
def case3():
mode2 = get_mode2(0)
event1 = get_event1(0)
y0 = [[99.5, 80], [97.5, 100]]
y1 = [[100.5, 90], [96, 80]]
stepsize = 0.1
maxorder = 1
boundary_order = 1
num_mode = 2
T = 50
ep = 0.01
mergeep = 0.01
method = 'piecelinear'
t_list, y_list = simulation_ode_2(mode2, event1, y0, T, stepsize, noise=0)
# A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
# x0 = np.zeros(num_mode*A.shape[1]*b.shape[1])
# re = infer_optimizationm(x0, A, b, 2)
# print(re.fun)
# print(re.success)
# print(re.x)
A, b1, b2, Y, ytuple = diff_method_backandfor(t_list, y_list, maxorder,
stepsize)
A, b1, b2, _ = seg_droprow(A, b1, b2, ep)
x0 = np.zeros(num_mode * A.shape[1] * b1.shape[1])
for i in range(len(x0)):
x0[i] = np.random.uniform(-1, 1)
re = infer_optimizationm(x0, A, b1, 2)
print(re.fun / A.shape[0])
print(re.success)
print(re.x)
def case8():
y0 = [[4,0.1,3.1,0],[5.9,0.2,-3,0],[4.1,0.5,2,0],[6,0.7,2,0]]
t_tuple = [(0,5),(0,5),(0,5),(0,5)]
stepsize = 0.01
maxorder = 2
# start = time.time()
t_list, y_list = simulation_ode_2([mmode1, mmode2], event3, y0, t_tuple, stepsize)
clfs, boundary = infer_multi_ch.infer_multi_linear_new(t_list, y_list, stepsize, maxorder)
for clf in clfs:
print(clf.coef_)
print(boundary)
num_pt0 = y_list[0].shape[0]
num_pt1 = y_list[1].shape[0]
sum = 0
for i in range(num_pt0):
# index = random.choice(range(num_pt0))
x = y_list[0][i]
sum += infer_multi_ch.test_classify(mmode, clfs, boundary, maxorder, x)
# print(infer_multi_ch.test_classify(fvdp3_3, clfs, boundary, maxorder, x))
for i in range(num_pt1):
# index = random.choice(range(num_pt0))
x = y_list[1][i]
sum += infer_multi_ch.test_classify(mmode, clfs, boundary, maxorder, x)
print(sum/(num_pt0+num_pt1))
def case3():
y0 = [[5, 5, 5], [2, 2, 2]]
stepsize = 0.01
maxorder = 2
boundary_order = 1
num_mode = 2
T = 5
ep = 0.01
mergeep = 0.01
method = 'merge'
t_list, y_list = simulation_ode_2(get_fvdp3(0), get_event1(0), y0, T,
stepsize)
A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
print("start")
x0 = np.zeros(num_mode * A.shape[1] * b.shape[1])
re = infer_optimizationm(x0, A, b, num_mode)
print(re.fun)
print(re.success)
print(re.x)
A, b1, b2, Y, ytuple = diff_method_backandfor(t_list, y_list, maxorder,
stepsize)
A, b1, b2, _ = seg_droprow(A, b1, b2, ep)
x0 = np.zeros(num_mode * A.shape[1] * b1.shape[1])
re = infer_optimizationm(x0, A, b1, num_mode)
print(re.fun)
print(re.success)
print(re.x)
def case1():
y0 = [[4, 0.1, 3.1, 0], [5.9, 0.2, -3, 0], [4.1, 0.5, 2, 0],
[6, 0.7, 2, 0]]
y0_test = [[4.6, 0.13, 2, 0], [5.3, 0.17, -2, 0]]
T = 5
stepsize = 0.01
ep = 0.01
maxorder = 2
boundary_order = 1
num_mode = 2
method = 'tolmerge'
t_list, y_list = simulation_ode_2(mmode, event1, y0, T, stepsize)
t_test_list, y_test_list = simulation_ode_2(mmode, event1, y0_test, T,
stepsize)
A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
np.savetxt("data/A4.txt", A, fmt='%8f')
np.savetxt("data/b4.txt", b, fmt='%8f')
YT, FT = diff(t_list + t_test_list, y_list + y_test_list, dynamics.modeex4)
np.savetxt("data/YT4.txt", YT, fmt='%8f')
np.savetxt("data/FT4.txt", FT, fmt='%8f')
def case2():
mode2 = get_mode2(0)
event1 = get_event1(0)
y0 = [[99.5, 80], [97.5, 100]]
y1 = [[100.5, 90], [96, 80]]
stepsize = 0.1
maxorder = 1
boundary_order = 1
num_mode = 2
T = 50
ep = 0.01
mergeep = 0.01
method = 'piecelinear'
t_list, y_list = simulation_ode_2(mode2, event1, y0, T, stepsize, noise=0)
A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
np.savetxt("data/A1.txt", A, fmt='%8f')
np.savetxt("data/b1.txt", b, fmt='%8f')
def case9():
y0 = [[4.7,0.2,-6,0,0,3]]
t_tuple = [(0,10)]
stepsize = 0.001
maxorder = 1
# start = time.time()
t_list, y_list = simulation_ode_2([mmode1, mmode2], event3, y0, t_tuple, stepsize)
tpar_list,ypar_list = parti(t_list,y_list,0.2,1/3)
print(tpar_list[0].shape)
tt = [tpar_list[0],tpar_list[2],tpar_list[4]]
yy = [ypar_list[0],ypar_list[2],ypar_list[4]]
A ,b = diff_method1(tt, yy, maxorder, stepsize)
# # clf = linear_model.LinearRegression(fit_intercept=False,normalize=True)
# # clf.fit(A,b)
# # g = clf.coef_
# bb = clf.predict(A)
g = pinv2(A).dot(b)
print("g=",g.T)
def case(y0, t_tuple, stepsize, maxorder, modelist, event, ep, method):
# print('Simulating')
t_list, y_list = simulation_ode_2(modelist, event, y0, t_tuple, stepsize)
draw2D(y_list)
if method == "new":
# print('Classifying')
A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
P, G, D = infer_dynamic_modes_new(t_list, y_list, stepsize, maxorder,
ep)
P, G = reclass(A, b, P, ep)
print(G)
P, D = dropclass(P, G, D, A, b, Y, ep, stepsize)
# print('Number of modes:', len(P))
y = []
x = []
for j in range(0, len(P[0])):
y.append(1)
x.append({1: Y[P[0][j], 0], 2: Y[P[0][j], 1]})
for j in range(0, len(P[1])):
y.append(-1)
x.append({1: Y[P[1][j], 0], 2: Y[P[1][j], 1]})
prob = svm_problem(y, x)
param = svm_parameter('-t 1 -d 1 -c 10 -r 1 -b 0 -q')
m = svm_train(prob, param)
svm_save_model('model_file', m)
nsv = m.get_nr_sv()
svc = m.get_sv_coef()
sv = m.get_SV()
g = -m.rho[0]
a1 = 0
a2 = 0
for i in range(0, nsv):
a1 = a1 + svc[i][0] * 0.5 * sv[i][1]
a2 = a2 + svc[i][0] * 0.5 * sv[i][2]
g = g + svc[i][0]
def f(x):
return a1 * x[0] + a2 * x[1] + g > 0
print(a1 / a1, a2 / a1, g / a1)
sum = 0
num = 0
@eventAttr()
def eventtest(t, y):
y0, y1 = y
return a1 * y0 + a2 * y1 + g
ttest_list, ytest_list = simulation_ode_2(
[ode_test(G[0], maxorder),
ode_test(G[1], maxorder)], eventtest, y0, t_tuple, stepsize)
for i, temp_y in enumerate(y_list):
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
if i == 0:
plt.plot(y0_list, y1_list, c='b', label='Original')
else:
plt.plot(y0_list, y1_list, c='b')
for i, temp_y in enumerate(ytest_list):
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
if i == 0:
plt.plot(y0_list, y1_list, c='r', label='Inferred')
else:
plt.plot(y0_list, y1_list, c='r')
plt.xlabel('x1')
plt.ylabel('x2')
plt.legend()
plt.show()
def get_poly_pt(x):
gene = generate_complete_polynomial(len(x), maxorder)
val = []
for i in range(gene.shape[0]):
val.append(1.0)
for j in range(gene.shape[1]):
val[i] = val[i] * (x[j]**gene[i, j])
poly_pt = np.mat(val)
return poly_pt
for ypoints in y_list:
num = num + ypoints.shape[0]
for i in range(ypoints.shape[0]):
if event(0, ypoints[i]) > 0:
exact = modelist[0](0, ypoints[i])
else:
exact = modelist[1](0, ypoints[i])
if f(ypoints[i]) == 1:
predict = np.matmul(get_poly_pt(ypoints[i]), G[0].T)
else:
predict = np.matmul(get_poly_pt(ypoints[i]), G[1].T)
exact = np.mat(exact)
diff = exact - predict
c = 0
a = 0
b = 0
for j in range(diff.shape[1]):
c = c + diff[0, j]**2
a = a + exact[0, j]**2
b = b + predict[0, j]**2
f1 = np.sqrt(c)
f2 = np.sqrt(a) + np.sqrt(b)
sum = sum + f1 / f2
return sum / num
def case(y0, t_tuple, stepsize, maxorder, modelist, event, ep, method):
t_list, y_list = simulation_ode_2(modelist, event, y0, t_tuple, stepsize)
if method == "new":
A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
P, G, D = infer_dynamic_modes_new(t_list, y_list, stepsize, maxorder,
0.01)
P, D = dropclass(P, G, D, A, b, Y, 0.01, stepsize)
# print(len(P))
print(G)
y = []
x = []
for j in range(0, len(P[0])):
y.append(1)
x.append({1: Y[P[0][j], 0], 2: Y[P[0][j], 1], 3: Y[P[0][j], 2]})
for j in range(0, len(P[1])):
y.append(-1)
x.append({1: Y[P[1][j], 0], 2: Y[P[1][j], 1], 3: Y[P[1][j], 2]})
prob = svm_problem(y, x)
param = svm_parameter('-t 1 -d 1 -c 10 -r 1 -b 0 -q')
m = svm_train(prob, param)
svm_save_model('model_file', m)
nsv = m.get_nr_sv()
svc = m.get_sv_coef()
sv = m.get_SV()
g = -m.rho[0]
a1 = 0
a2 = 0
a3 = 0
for i in range(0, nsv):
a1 = a1 + svc[i][0] * 0.5 * sv[i][1]
a2 = a2 + svc[i][0] * 0.5 * sv[i][2]
a3 = a3 + svc[i][0] * 0.5 * sv[i][3]
g = g + svc[i][0]
print(a1 / a1, a2 / a1, a3 / a1, g / a1)
def f(x):
return a1 * x[0] + a2 * x[1] + a3 * x[2] + g > 0
@eventAttr()
def eventtest(t, y):
y0, y1, y2 = y
return a1 * y0 + a2 * y1 + a3 * y2 + g
ttest_list, ytest_list = simulation_ode_2(
[ode_test(G[0], maxorder),
ode_test(G[1], maxorder)], eventtest, y0, t_tuple, stepsize)
ax = plt.axes(projection='3d')
for temp_y in y_list[0:1]:
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
y2_list = temp_y.T[2]
ax.plot3D(y0_list, y1_list, y2_list, c='b')
for temp_y in ytest_list[0:1]:
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
y2_list = temp_y.T[2]
ax.plot3D(y0_list, y1_list, y2_list, c='r')
plt.show()
sum = 0
num = 0
def get_poly_pt(x):
gene = generate_complete_polynomial(len(x), maxorder)
val = []
for i in range(gene.shape[0]):
val.append(1.0)
for j in range(gene.shape[1]):
val[i] = val[i] * (x[j]**gene[i, j])
poly_pt = np.mat(val)
return poly_pt
for ypoints in y_list:
num = num + ypoints.shape[0]
for i in range(ypoints.shape[0]):
if event(0, ypoints[i]) > 0:
exact = modelist[0](0, ypoints[i])
else:
exact = modelist[1](0, ypoints[i])
if f(ypoints[i]) == 1:
predict = np.matmul(get_poly_pt(ypoints[i]), G[0].T)
else:
predict = np.matmul(get_poly_pt(ypoints[i]), G[1].T)
exact = np.mat(exact)
diff = exact - predict
c = 0
a = 0
b = 0
for j in range(diff.shape[1]):
c = c + diff[0, j]**2
a = a + exact[0, j]**2
b = b + predict[0, j]**2
f1 = np.sqrt(c)
f2 = np.sqrt(a) + np.sqrt(b)
sum = sum + f1 / f2
return sum / num
def run_test(id, eid, case_id, methods, verbose=False):
np.random.seed(0)
if eid == 'A':
case_info = experiment1.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment1.get_mode2(params)
event = experiment1.get_event1(params)
maxorder = 1
boundary_order = 1
num_mode = 2
ep = 0.01
mergeep = 0.01
elif eid == 'B':
case_info = experiment2.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment2.get_fvdp3(params)
event = experiment2.get_event1(params)
maxorder = 2
boundary_order = 1
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
elif eid == 'C':
case_info = experiment3.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment3.get_mode(params)
event = experiment3.get_event(params)
maxorder = 3
boundary_order = 2
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
elif eid == 'D':
case_info = experiment4.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment4.get_mmode(params)
event = experiment4.get_event(params)
maxorder = 2
boundary_order = 1
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
elif eid == 'E':
case_info = experiment5.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment5.get_modetr(params)
event = experiment5.get_event(params)
labeltest = experiment5.get_labeltest(params)
maxorder = 2
boundary_order = 1
num_mode = 3
ep = case_info['ep']
mergeep = case_info['mergeep']
# Obtain simulated trajectory
start = time.time()
if num_mode == 2:
t_list, y_list = simulation_ode_2(modelist, event, y0, T, stepsize)
test_t_list, test_y_list = simulation_ode_2(modelist, event, y0_test,
T, stepsize)
elif num_mode == 3:
t_list, y_list = simulation_ode_3(modelist, event, labeltest, y0, T,
stepsize)
test_t_list, test_y_list = simulation_ode_3(modelist, event, labeltest,
y0_test, T, stepsize)
else:
raise NotImplementedError
end = time.time()
# print('eid:', eid, 'N_init:', len(y0), 't_step:', stepsize, 'ep:', ep, 'sim_time: %.3f' % (end - start))
d_avg = dict()
infer_time = dict()
for method in methods:
start = time.time()
if num_mode == 2:
P, G, boundary = infer_model(t_list,
y_list,
stepsize=stepsize,
maxorder=maxorder,
boundary_order=boundary_order,
num_mode=num_mode,
modelist=modelist,
event=event,
ep=ep,
mergeep=mergeep,
method=method,
verbose=verbose)
end = time.time()
d_avg[method] = test_model(P, G, boundary, num_mode,
y_list + test_y_list, modelist, event,
maxorder, boundary_order)
infer_time[method] = end - start
elif num_mode == 3:
P, G, boundary = infer_model(t_list,
y_list,
stepsize=stepsize,
maxorder=maxorder,
boundary_order=boundary_order,
num_mode=num_mode,
modelist=modelist,
event=event,
ep=ep,
mergeep=mergeep,
method=method,
verbose=verbose,
labeltest=labeltest)
end = time.time()
d_avg[method] = test_model(P,
G,
boundary,
num_mode,
y_list + test_y_list,
modelist,
event,
maxorder,
boundary_order,
labeltest=labeltest)
infer_time[method] = end - start
else:
raise NotImplementedError
# print('Method: %s, d_avg: %.6f, infer_time: %.3f' % (method, d_avg[method], infer_time[method]))
# best_method, best_avg = None, 1.0
# for method, avg in d_avg.items():
# total_d_avg[method] += avg
# if avg < best_avg:
# best_method, best_avg = method, avg
# for method, t in infer_time.items():
# total_time[method] += t
# total_win[best_method] += 1
print(
'%d & $%s$ & %d & %.3f & %d & %.3f & %.5f & %.5f & %.5f& & %.1f & %.1f & %.1f& & \\\\'
% (id, eid, len(y0), stepsize, T, mergeep, d_avg['dbscan'],
d_avg['tolmerge'], d_avg['piecelinear'], infer_time['dbscan'],
infer_time['tolmerge'], infer_time['piecelinear']))
return d_avg, infer_time
def case(y0, t_tuple, stepsize, maxorder, modelist, event, ep, method):
t_list, y_list = simulation_ode_2(modelist, event, y0, t_tuple, stepsize)
if method == "new":
A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
P, G, D = infer_dynamic_modes_new(t_list, y_list, stepsize, maxorder,
0.01)
P, D = dropclass(P, G, D, A, b, Y, 0.01, stepsize)
# print(len(P))
# print(G)
y = []
x = []
for j in range(0, len(P[0])):
y.append(1)
x.append({1: Y[P[0][j], 0], 2: Y[P[0][j], 1]})
for j in range(0, len(P[1])):
y.append(-1)
x.append({1: Y[P[1][j], 0], 2: Y[P[1][j], 1]})
prob = svm_problem(y, x)
param = svm_parameter('-t 1 -d 2 -r 1 -c 10 -b 0 -q')
m = svm_train(prob, param)
svm_save_model('model_file', m)
# p_label, p_acc, p_val = svm_predict(y, x, m)
nsv = m.get_nr_sv()
svc = m.get_sv_coef()
sv = m.get_SV()
def f(x):
g = -m.rho[0]
for i in range(0, nsv):
g = g + svc[i][0] * (0.5 *
(x[0] * sv[i][1] + x[1] * sv[i][2]) +
1)**2
return g > 0
sum = 0
num = 0
def get_poly_pt(x):
gene = generate_complete_polynomial(len(x), maxorder)
val = []
for i in range(gene.shape[0]):
val.append(1.0)
for j in range(gene.shape[1]):
val[i] = val[i] * (x[j]**gene[i, j])
poly_pt = np.mat(val)
return poly_pt
for ypoints in y_list:
num = num + ypoints.shape[0]
for i in range(ypoints.shape[0]):
if event(0, ypoints[i]) > 0:
exact = modelist[0](0, ypoints[i])
else:
exact = modelist[1](0, ypoints[i])
if f(ypoints[i]) == 1:
predict = np.matmul(get_poly_pt(ypoints[i]), G[0].T)
else:
predict = np.matmul(get_poly_pt(ypoints[i]), G[1].T)
exact = np.mat(exact)
diff = exact - predict
c = 0
a = 0
b = 0
for j in range(diff.shape[1]):
c = c + diff[0, j]**2
a = a + exact[0, j]**2
b = b + predict[0, j]**2
f1 = np.sqrt(c)
f2 = np.sqrt(a) + np.sqrt(b)
sum = sum + f1 / f2
return sum / num
def compare_opt(id, eid, case_id, verbose=False):
np.random.seed(0)
if eid == 'A':
case_info = experiment1.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment1.get_mode2(params)
event = experiment1.get_event1(params)
maxorder = 1
boundary_order = 1
num_mode = 2
ep = 0.01
mergeep = 0.01
dy = dynamics.mode2t
elif eid == 'B':
case_info = experiment2.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment2.get_fvdp3(params)
event = experiment2.get_event1(params)
maxorder = 2
boundary_order = 1
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.fvdp3_3
elif eid == 'C':
case_info = experiment3.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment3.get_mode(params)
event = experiment3.get_event(params)
maxorder = 3
boundary_order = 2
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.modeex3
elif eid == 'D':
case_info = experiment4.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment4.get_mmode(params)
event = experiment4.get_event(params)
maxorder = 2
boundary_order = 1
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.modeex4
elif eid == 'E':
case_info = experiment5.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment5.get_modetr(params)
event = experiment5.get_event(params)
labeltest = experiment5.get_labeltest(params)
maxorder = 2
boundary_order = 1
num_mode = 3
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.modetrt
# Obtain simulated trajectory
print(id, eid)
start = time.time()
if num_mode == 2:
t_list, y_list = simulation_ode_2(modelist, event, y0, T, stepsize)
test_t_list, test_y_list = simulation_ode_2(modelist, event, y0_test,
T, stepsize)
elif num_mode == 3:
t_list, y_list = simulation_ode_3(modelist, event, labeltest, y0, T,
stepsize)
test_t_list, test_y_list = simulation_ode_3(modelist, event, labeltest,
y0_test, T, stepsize)
else:
raise NotImplementedError
end = time.time()
# start = time.time()
# A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
A, b1, b2, Y, ytuple = diff_method_backandfor(t_list, y_list, maxorder,
stepsize)
optA, optb1, optb2, drop = seg_droprow(A, b1, b2, ep)
x0 = np.zeros(num_mode * optA.shape[1] * optb1.shape[1])
for ini in range(0, 5):
print('initial', ini)
for i in range(len(x0)):
x0[i] = np.random.uniform(-5, 5)
for optmethod in ['nelder-mead', 'COBYLA', 'Powell', 'CG']:
try:
infer_optimizationmtest(x0, optA, optb1, num_mode)
except:
print(optmethod, ' timeout')
def case7():
y0 = [[4,0.1,3.1,0],[5.9,0.2,-3,0],[4.1,0.5,2,0],[6,0.7,2,0]]
t_tuple = [(0,5),(0,5),(0,5),(0,5)]
stepsize = 0.01
maxorder = 2
# start = time.time()
t_list, y_list = simulation_ode_2([mmode1, mmode2], event3, y0, t_tuple, stepsize)
# for temp_y in y_list:
# y0_list = temp_y.T[0]
# y1_list = temp_y.T[1]
# plt.plot(y0_list,y1_list,'b')
# plt.show()
A, b, Y = diff_method_new1(t_list, y_list, maxorder, stepsize)
P,G,D = infer_dynamic_modes_new(t_list, y_list, stepsize, maxorder, 0.03)
print(P)
print(G)
print(D)
y = []
x = []
for j in range(0,len(P[0])):
y.append(1)
x.append({1:Y[P[0][j],0], 2:Y[P[0][j],1], 3:Y[P[0][j],2], 4:Y[P[0][j],3]})
for j in range(0,len(P[1])):
y.append(-1)
x.append({1:Y[P[1][j],0], 2:Y[P[1][j],1], 3:Y[P[1][j],2], 4:Y[P[1][j],3]})
prob = svm_problem(y, x)
param = svm_parameter('-t 1 -d 1 -c 10 -r 1 -b 1')
m = svm_train(prob, param)
svm_save_model('model_file', m)
# print("pred")
p_label, p_acc, p_val = svm_predict(y, x, m,'-q')
# print(p_label)
print('pre',p_acc[0])
# print(p_val)
nsv = m.get_nr_sv()
svc = m.get_sv_coef()
sv = m.get_SV()
# print(nsv)
# print(svc)
# print(sv)
# def clafun(x):
# g = -m.rho[0]
# for i in range(0,nsv):
# g = g + svc[i][0] * ((0.5 * (x[0]*sv[i][1] + x[1]*sv[i][2]))**3)
# return g
g = -m.rho[0]
a1 = 0
a2 = 0
a3 = 0
a4 = 0
for i in range(0,nsv):
a1 = a1 + svc[i][0] * 0.5 * sv[i][1]
a2 = a2 + svc[i][0] * 0.5 * sv[i][2]
a3 = a3 + svc[i][0] * 0.5 * sv[i][3]
a4 = a4 + svc[i][0] * 0.5 * sv[i][4]
g = g + svc[i][0]*1
def case6():
y0 = [[0,1],[0,2],[0,3],[0,4],[0,5]]
t_tuple = 20
stepsize = 0.01
maxorder = 3
# start = time.time()
t_list, y_list = simulation_ode_2([mode1, mode2], event2, y0, t_tuple, stepsize)
for temp_y in y_list:
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
plt.plot(y0_list,y1_list,'b')
plt.show()
# clfs, boundary = infer_multi_ch.infer_multi_linear_new(t_list, y_list, stepsize, maxorder)
# for clf in clfs:
# print('g',clf.coef_)
# print(boundary)
A, b, Y = diff_method_new1(t_list, y_list, maxorder, stepsize)
P,G,D = infer_dynamic_modes_new(t_list, y_list, stepsize, maxorder, 0.01)
print(P)
print(G)
print(D)
y = []
x = []
for j in range(0,len(P[0])):
y.append(1)
x.append({1:Y[P[0][j],0], 2:Y[P[0][j],1]})
for j in range(0,len(P[1])):
y.append(-1)
x.append({1:Y[P[1][j],0], 2:Y[P[1][j],1]})
y0_list = []
y1_list = []
for j in range(0,len(P[0])):
y0_list.append(Y[P[0][j],0])
y1_list.append(Y[P[0][j],1])
plt.scatter(y0_list,y1_list,s=1)
y0_list = []
y1_list = []
for j in range(0,len(P[1])):
y0_list.append(Y[P[1][j],0])
y1_list.append(Y[P[1][j],1])
plt.scatter(y0_list,y1_list,s=1)
prob = svm_problem(y, x)
param = svm_parameter('-t 1 -d 2 -r 1 -c 10 -b 0')
m = svm_train(prob, param)
svm_save_model('model_file', m)
print("pred")
p_label, p_acc, p_val = svm_predict(y, x, m)
# # print(p_label)
nsv = m.get_nr_sv()
svc = m.get_sv_coef()
sv = m.get_SV()
# print(nsv)
# print(svc)
# print(sv)
def f(x,y):
g = -m.rho[0]
for i in range(0,nsv):
g = g + svc[i][0] * (0.5*(x*sv[i][1]+y*sv[i][2])+1)**2
return g
x = np.linspace(-5,5,100)
y = np.linspace(-5,5,100)
X,Y = np.meshgrid(x,y)#将x，y指传入网格中
# plt.contourf(X,Y,f(X,Y),8,alpha=0.75,cmap=plt.cm.hot)#8指图中的8+1根线，绘制等温线，其中cmap指颜色
C = plt.contour(X,Y,f(X,Y),[0])#colors指等高线颜色
plt.clabel(C,inline=True,fontsize=10)#inline=True指字体在等高线中
plt.xticks(())
plt.yticks(())
plt.show()
def case1():
mode2 = get_mode2(0)
event1 = get_event1(0)
y0 = [[70, 70]]
stepsize = 1
maxorder = 1
boundary_order = 1
num_mode = 2
T = 200
ep = 0.01
method = 'kmeans'
t_list, y_list = simulation_ode_2(mode2, event1, y0, T, stepsize)
# P,G,C = infer_model(
# t_list, y_list, stepsize=stepsize, maxorder=maxorder, boundary_order=boundary_order,
# num_mode=num_mode, modelist=mode2, event=event1, ep=ep, method=method, verbose=False)
# A, b1, b2, Y = diff_method_backandfor(t_list, y_list, maxorder, stepsize)
# num_pt = Y.shape[0]
# Segment and fit
# P, drop, clfs = segment_and_fit(A, b1, b2)
# P, G = dbscan_cluster(clfs, P, A, b1, num_mode)
# P, _ = dropclass(P, G, drop, A, b1, Y, ep, stepsize)
# for i in range(0,len(P)):
# y0_list = []
# y1_list = []
# for j in range(0,len(P[i])):
# y0_list.append(Y[P[i][j],0])
# y1_list.append(Y[P[i][j],1])
# plt.scatter(y0_list,y1_list,s=1)
# plt.show()
# for i, temp_y in enumerate(y_list):
# y0_list = temp_y.T[0]
# # y0_list = t_list[i]
# y1_list = temp_y.T[1]
# plt.scatter(y0_list,y1_list,c='b',s=5)
# plt.scatter(y0_list[59],y1_list[59],c='r',s=5)
# # plt.scatter(y0_list,y1_list,c='b',s=5, label='x2')
# # y1_list = temp_y.T[0]
# # plt.scatter(y0_list,y1_list,c='r',s=5, label='x1')
# plt.xlabel('x1')
# plt.ylabel('x2')
# plt.legend()
# plt.show()
ax = plt.axes(projection='3d')
# x=np.arange(65,110,1)
# y=np.arange(70,140,1)
# X, Y = np.meshgrid(x, y)
# Z=-0.026*(X-Y)
# ax.plot_surface(X, Y, Z, rstride=1, cstride=1, color='r')
for temp_y in y_list:
y0_list = temp_y.T[0]
y1_list = temp_y.T[1]
y2_list = []
for i in range(5, len(y1_list)):
y2_list.append(
(y1_list[i] * 137 - y1_list[i - 1] * 300 +
y1_list[i - 2] * 300 - y1_list[i - 3] * 200 +
y1_list[i - 4] * 75 - y1_list[i - 5] * 12) / (60 * stepsize))
ax.scatter(y0_list[5:], y1_list[5:], y2_list, c='b', s=5)
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_zlabel('f')
plt.legend()
plt.show()
def compare1(id, eid, case_id, verbose=False):
np.random.seed(0)
if eid == 'A':
case_info = experiment1.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment1.get_mode2(params)
event = experiment1.get_event1(params)
maxorder = 1
boundary_order = 1
num_mode = 2
ep = 0.01
mergeep = 0.01
dy = dynamics.mode2t
elif eid == 'B':
case_info = experiment2.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment2.get_fvdp3(params)
event = experiment2.get_event1(params)
maxorder = 2
boundary_order = 1
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.fvdp3_3
elif eid == 'C':
case_info = experiment3.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment3.get_mode(params)
event = experiment3.get_event(params)
maxorder = 3
boundary_order = 2
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.modeex3
elif eid == 'D':
case_info = experiment4.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment4.get_mmode(params)
event = experiment4.get_event(params)
maxorder = 2
boundary_order = 1
num_mode = 2
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.modeex4
elif eid == 'E':
case_info = experiment5.cases[case_id]
params = case_info['params']
y0 = case_info['y0']
y0_test = case_info['y0_test']
T = case_info['t_tuple']
stepsize = case_info['stepsize']
modelist = experiment5.get_modetr(params)
event = experiment5.get_event(params)
labeltest = experiment5.get_labeltest(params)
maxorder = 2
boundary_order = 1
num_mode = 3
ep = case_info['ep']
mergeep = case_info['mergeep']
dy = dynamics.modetrt
# Obtain simulated trajectory
start = time.time()
if num_mode == 2:
t_list, y_list = simulation_ode_2(modelist, event, y0, T, stepsize)
test_t_list, test_y_list = simulation_ode_2(modelist, event, y0_test,
T, stepsize)
elif num_mode == 3:
t_list, y_list = simulation_ode_3(modelist, event, labeltest, y0, T,
stepsize)
test_t_list, test_y_list = simulation_ode_3(modelist, event, labeltest,
y0_test, T, stepsize)
else:
raise NotImplementedError
end = time.time()
# A, b, Y = diff_method_new(t_list, y_list, maxorder, stepsize)
# np.savetxt("data/CA"+str(id)+".txt",A,fmt='%8f')
# np.savetxt("data/Cb"+str(id)+".txt",b,fmt='%8f')
# YT, FT = diff(t_list+test_t_list, y_list+test_y_list, dy)
# np.savetxt("data/CYT"+str(id)+".txt",YT,fmt='%8f')
# np.savetxt("data/CFT"+str(id)+".txt",FT,fmt='%8f')
for i in range(0, len(y_list)):
np.savetxt("data1/YLIST" + str(id) + "_" + str(i) + ".txt",
y_list[i],
fmt='%8f')
for i in range(0, len(test_y_list)):
np.savetxt("data1/YTLIST" + str(id) + "_" + str(i) + ".txt",
test_y_list[i],
fmt='%8f')
