def get_inputs():
x_ratio = 0.27367970921530893
y_ratio = 0.2158152082279548
first_line = '_f2_gc_gt_3g_3x_43_4z_l2_lu_lz_lz_ly_l3_4w_4b_3e_2f_he_gc_fb_dh_ct_ch_cn_d2_ee_f3_gx_2g_3t_4z_ma_mu_ng_nn_nz_4b_3g_2z_2g_2g_22_2u_3e_3w_lb_lw_mm_n2_tg_uf_we_xa_xu_yh_yx_z3_zn_zu_zw_zw_zw_zw_zn_zm_zl_zl_z4_z3_z3_z3_z3_aa_bu_c4_g3_gm_h2_2e_3b_3x_ll_m2_ne_tb_ty_uu_wm_x2_yf_zc_zybbmbc2bdfbglbh2b2fb3cb3yb4ublmbm2bnfbtcbtybuubx2'
line_list = [
'_f2_f4_fw_gc_g4_gy_h3_2a_2n_32_4a_4m_le_lx_mh_mt_mx_mx_mt_mf_lm_4y_4c_3e_2f_hf_gd_ff_e2_dy_dm_e2_f4_gz_2n_4a_lh_mn_nw_tm_ud_u3_lc_4x_4g_3z_3l_3e_2y_2t_24_22_22_22_2t_3e_3u_44_lh_mh_n4_tn_uu_wn_x2_ya_y4_yy_zg_z4_zm_zn_zt_zt_zm_zl_z4_z4_z4_z4_z4_zl_zl_zn_aa_bf_cy_dw_em_f3_gf_hc_hz_2u_3t_43_lf_mc_mz_nu_tl_u2_wf_xb_xy_yw_zmba3bbgbccbczbdwbenbf3bggb3mb42blfbmbbmybnubtlbu2bwfbxcbxz',
'_ft_fu_fw_gd_g4_gx_he_hm_2b_2m_3d_3u_44_lc_lu_mf_mt_na_ne_nh_nh_nf_mx_m2_ly_lf_44_3n_2m_hu_gw_fx_fa_eh_dy_dm_ed_ey_fw_hb_2h_3n_4x_mb_mz_nw_tf_tl_ln_lg_lb_44_4a_3l_3c_2t_22_2d_2a_hx_hw_hw_hz_2g_2z_3n_44_lt_mw_nz_ua_uz_wt_xh_xy_yg_yn_yx_zb_ze_zg_z2_z4_z4_z4_z4_z4_z3_z2_z2_z2_z2_zh_zg_zg_zg_aa_cb_cy_em_f2_gf_hc_hy_2u_3m_42_lf_mc_my_nu_tm_u2_wf_xc_xy_yu_zmba2bbfbccbcybdubembf2bgfbhcbhyb2ub3mb42blfbu2bwfbxcbxybyubzmca2cbfcccccycducem',
'_2b_3g_4m_lx_mu_nd_ne_mz_lz_4h_24_gt_fe_eg_dx_dn_fc_hd_3f_lc_m3_nt_tu_ul_4d_4n_ld_ly_mw_nl_th_ue_wb_xa_ya_zbbabbatbbcbbgbbebaxbamba3bagbab_zw_zn_aa_ax_bu_c3_df_ea_ew_fm_g3_hg_2d_3f_3u_4m_lm_mg_tw_un_w4_xg_yd_za_zwban',
'_2f_2t_3h_4g_lh_mf_mu_ly_4h_2t_ha_fy_fd_ew_gd_2b_3z_ln_my_td_4g_4l_4m_la_ln_mh_mz_ub_w4_xl_yl_zd_zm_zx_zy_zl_zg_zg_zg_zg_aa_b2_cf_db_dy_eu_h2_2b_2y_3w_4m_l3_mf_nc_ul_w3_xh_yc_yy_zu',
'_t3_tc_nt_ng_mw_md_l2_4m_4a_3t_3m_3m_3m_3n_3t_3t_3m_3d_2m_hm_hh_he_hc_hc_he_hu_2u_3x_lc_mm_t3_we_xm_yz_zxba4bbabbe_aa_a4_bf_cc_cz_dw_em_f3_gg_hc_hz_2w_3n_43_lg_mc_mz_nw_tm'
]
data = [np.zeros((len(line_list), 128, 128, 3)) for i in range(2)]
first_points = data_trans.analysis_data(first_line)
first_points = get_velocity(first_points)
for i in range(len(line_list)):
for point in first_points:
data[0][i][int(point['x'] * x_ratio)][int(
point['y'] * y_ratio)] = [1, point['time'] / 100, point['v']]
for i, line in enumerate(line_list):
points = data_trans.analysis_data(line)
points = get_velocity(points)
for point in points:
data[1][i][int(point['x'] * x_ratio)][int(
point['y'] * y_ratio)] = [1, point['time'] / 100, point['v']]
return data
def draw(verify_paths):
n = len(verify_paths)
data = np.zeros((n, 128, 128, 3))
for i, raw_data in enumerate(verify_paths):
points = data_trans.analysis_data(raw_data)
points = data_trans.scale(points)
points = data_trans.get_velocity(points)
for point in points:
data[i][point['x']][point['y']] = [
1, point['time'] / 100, point['v']
]
color_start = (0, 0, 255)
color_end = (255, 0, 0)
all_gradient = [color_end[i] - color_start[i] for i in range(3)]
plt.figure()
for i in range(n):
v_max = -1
for x in range(128):
for y in range(128):
if data[i][x][y][-1] > v_max:
v_max = data[i][x][y][-1]
gradient = [g / v_max for g in all_gradient]
plt.subplot(3, 3, i + 1)
plt.title('max_v:' + str(v_max)[:4])
for x in range(128):
for y in range(128):
if data[i][x][y][0] == 0:
continue
else:
steps = data[i][x][y][2]
c = color_gradient(steps, gradient)
plt.scatter(x, y, c=c)
plt.show()
def get_eval_batch():
x_ratio = 0.27367970921530893
y_ratio = 0.2158152082279548
data = [np.zeros((20, 128, 128, 3)) for i in range(2)]
file_list = ['./data/siamese_data/sun_eval', './data/siamese_data/yu_eval', './data/siamese_data/yuan_eval']
true_file_num = random.choice(range(3))
file_path = file_list[true_file_num]
file_list.remove(file_path)
tmp_data = np.zeros((1, 128, 128, 3))
true_pair1, true_pair2 = np.random.choice(range(100), size=(2,))
line = linecache.getline(file_path, true_pair1+1)
points = data_trans.analysis_data(line)
points = get_velocity(points)
for point in points:
tmp_data[0][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100,
point['v']]
for n in range(20):
data[0][n] = tmp_data
true_num = random.choice(range(20))
line = linecache.getline(file_path, true_pair2+1)
points = data_trans.analysis_data(line)
points = get_velocity(points)
for point in points:
data[1][true_num][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100,
point['v']]
lines = []
for file in file_list:
with open(file, 'r') as f:
lines += f.readlines()
k = np.random.choice(range(200), size=(20,))
for iter, i in enumerate(k):
if iter == true_num:
continue
line = lines[i]
points = data_trans.analysis_data(line)
points = get_velocity(points)
for point in points:
data[1][iter][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100, point['v']]
label = np.zeros((20,))
label[true_num] = 1
return data, label
def get_eval_batch():
x_ratio = 0.3
y_ratio = 0.2
all_lines = load_data()
data = [np.zeros((20, 128, 128, 3)) for i in range(2)]
x, y, z = random.randint(0, 2), random.randint(0, 9), random.randint(15, 19)
true_line1 = all_lines[x][y][z]
tmp = list(range(15, 20))
tmp.remove(y)
z_2_t = random.choice(tmp)
true_line2 = all_lines[x][y][z_2_t]
tmp_data = np.zeros((1, 128, 128, 3))
true_points1 = data_trans.analysis_data(true_line1)
points = get_velocity(true_points1)
for point in points:
tmp_data[0][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100,
point['v']]
for n in range(20):
data[0][n] = tmp_data
true_points2 = data_trans.analysis_data(true_line2)
points = get_velocity(true_points2)
true_num = random.choice(range(20))
for point in points:
data[1][true_num][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100,
point['v']]
tmp = list(range(30))
tmp.remove(x * 10 + y)
rand_classes = np.random.choice(tmp, size=(19,))
z_2_fs = list(range(20))
z_2_fs.remove(true_num)
for i in range(19):
rand_class = rand_classes[i]
x_2_f = int(rand_class / 10)
y_2_f = rand_class % 10
false_line = all_lines[x_2_f - 1][y_2_f - 1][random.randint(0, 19)]
false_points = data_trans.analysis_data(false_line)
false_points = get_velocity(false_points)
for point in false_points:
data[1][z_2_fs[i]][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100,
point['v']]
def get_max_velocity(file_paths):
v_max = 0
for file_path in file_paths:
with open(file_path) as f:
for line in f.readlines():
points = data_trans.analysis_data(line)
points = get_velocity(points)
for point in points:
if point['v'] > v_max:
v_max = point['v']
return v_max
def get_size(file_path):
x_min = 1000
x_max = 0
y_min = 1000
y_max = 0
with open(file_path, 'r') as f:
for i, line in enumerate(f.readlines()):
ps = data_trans.analysis_data(line)
dt = pd.DataFrame(ps)
x_min = min(x_min, dt['x'].min())
x_max = max(x_max, dt['x'].max())
y_min = min(y_min, dt['y'].min())
y_max = max(y_max, dt['y'].max())
return x_min, y_min, x_max * 1.1 + 20, y_max * 1.1 + 20
def get_batch():
x_ratio = 0.27367970921530893
y_ratio = 0.2158152082279548
k = random.sample(range(50000), 32)
data = [np.zeros((32, 128, 128, 3)) for i in range(2)]
label = np.zeros((32,))
for iter, i in enumerate(k):
if i < 25000:
line = linecache.getline('./data/siamese_data/siamese0_shuffle.txt', i + 1)
label[iter] = 0
else:
i -= 25000
line = linecache.getline('./data/siamese_data/siamese1_shuffle.txt', i + 1)
label[iter] = 1
points1 = data_trans.analysis_data(line.split(' ')[0])
points2 = data_trans.analysis_data(line.split(' ')[1])
points1 = get_velocity(points1)
points2 = get_velocity(points2)
for point in points1:
data[0][iter][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100, point['v']]
for point in points2:
data[1][iter][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100, point['v']]
return data, label
def tmp():
file_paths = ['./data/siamese/sun2', './data/siamese/yuan2', './data/siamese/yu2']
x_ratio, y_ratio = check_data.get_scale_ratio(file_paths)
data = np.zeros((9000, 2, 128, 128, 3))
for n, file_path in enumerate(file_paths):
with open(file_path, 'r') as f:
for i, line in enumerate(f.readlines()):
points = data_trans.analysis_data(line)
points = sorted(points, key=lambda x: x['time'])
points = get_velocity(points)
for point in points:
data[i * 10 + j + 3000 * n][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1,
point['time'],
point['v']]
def validation(file_path):
x_ratio, y_ratio = get_scale_ratio(file_path)
test_data = np.zeros((40, 128, 128, 3))
with open(file_path) as f:
for i, line in enumerate(f.readlines()):
points = analysis_data(line)
points = sorted(points, key=lambda x: x['time'])
points = get_velocity(points)
for point in points:
test_data[i][int(point['x'] * x_ratio)][int(
point['y'] * y_ratio)] = [1, point['time'], point['v']]
predictions = model.predict(test_data)
for i in range(40):
print('num:' + str(i) + ' predict to:' +
str(np.argmax(predictions[i])) + ' num is:' +
str(max(predictions[i])))
def get_batch():
x_ratio = 0.3
y_ratio = 0.2
k = random.sample(range(202500), 32)
data = [np.zeros((32, 128, 128, 3)) for i in range(2)]
label = np.zeros((32,))
for iter, i in enumerate(k):
if i < 195750:
line = linecache.getline('./data/siamese_data/mul_0.txt', i + 1)
label[iter] = 0
else:
i -= 195750
line = linecache.getline('./data/siamese_data/mul_1.txt', i + 1)
label[iter] = 1
points = data_trans.analysis_data(line.split(' '))
points1 = get_velocity(points[0])
points2 = get_velocity(points[1])
for point in points1:
data[0][iter][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100, point['v']]
for point in points2:
data[1][iter][int(point['x'] * x_ratio)][int(point['y'] * y_ratio)] = [1, point['time'] / 100, point['v']]
return data, label
def draw(raw_data):
if type(raw_data).__name__ == 'str':
data = data_trans.analysis_data(raw_data)
else:
data = raw_data
xs = [data[0]['x']]
ys = [-data[0]['y']]
for i in range(len(data) - 1):
dis_x = data[i + 1]['x'] - data[i]['x']
dis_y = data[i + 1]['y'] - data[i]['y']
n = (data[i + 1]['time'] - data[i]['time']) / 10
step_x = dis_x / n
step_y = dis_y / n
tmp_x = data[i]['x']
tmp_y = data[i]['y']
for j in range(int(n)):
tmp_x += step_x
tmp_y += step_y
xs.append(tmp_x)
ys.append(-tmp_y)
xs.append(data[-1]['x'])
ys.append(-data[-1]['y'])
max_x = max(xs)
min_x = min(xs)
max_y = max(ys)
min_y = min(ys)
plt.ion()
for i in range(int(data[-1]['time'] / 10) + 1):
plt.clf()
plt.plot(max_x, max_y)
plt.plot(min_x, min_y)
plt.plot(xs[:i], ys[:i])
plt.pause(0.001)
plt.ioff()
plt.clf()
plt.plot(xs, ys)
plt.show()
str(np.argmax(predictions[i])) + ' num is:' +
str(max(predictions[i])))
model = keras.models.load_model('./model_3PEOPLE_DRAW2_10.h5')
for layer in model.layers[:-1]:
layer.trainable = False
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer=keras.optimizers.Adadelta(lr=0.1),
metrics=['accuracy'])
data = np.zeros((1, 128, 128, 3))
x_ratio, y_ratio = get_scale_ratio('./data/xuhao_tmp')
with open('./data/xuhao_tmp') as f:
for i, line in enumerate(f.readlines()):
points = analysis_data(line)
points = sorted(points, key=lambda x: x['time'])
for j in range(10):
points = create_fake(points)
points = get_velocity(points)
for point in points:
data[j][int(point['x'] * x_ratio)][int(
point['y'] * y_ratio)] = [1, point['time'], point['v']]
y_train = np.ones(10) * 3
y_train = keras.utils.to_categorical(y_train, 4)
model.fit(data, y_train, batch_size=1, epochs=5)
validation('./data/xuhao_new')
tmp_y = data[i]['y']
for j in range(int(n)):
tmp_x += step_x
tmp_y += step_y
xs.append(tmp_x)
ys.append(-tmp_y)
xs.append(data[-1]['x'])
ys.append(-data[-1]['y'])
max_x = max(xs)
min_x = min(xs)
max_y = max(ys)
min_y = min(ys)
plt.ion()
for i in range(int(data[-1]['time'] / 10) + 1):
plt.clf()
plt.plot(max_x, max_y)
plt.plot(min_x, min_y)
plt.plot(xs[:i], ys[:i])
plt.pause(0.001)
plt.ioff()
plt.clf()
plt.plot(xs, ys)
plt.show()
if __name__ == '__main__':
raw_data = 'bbmbbnbbxbcbbcebc2bcmbcubczbddbdhbdlbdubdybecbegbe3benbexbfbbfebf2bfmbfwbfzbgdbg2bgnbgybhebh3bhtb2ab2fb23b2mb2xb3cb3gb33b3tb3xb4bb4fb42b4lb4lb4lb4lb4nb4ybldbl3blmblmblmblmblmbl3bldb4xb4mb4hb4bb3wb3lb3fb2zb2tb22b2dbhzbhnbhhbhbbgwbg4bgebfzbfubflbfgbfabetbe3bedbanbazbbcbbgbb4bbtbbxbcbbcfbc3bcnbcwbdabdebd2bdlbdubdzbecbegbe4betbexbfbbffbf3bflbflbflbflbflbflbflbflbfhbfdbfcbezbewbembe2beebeabdwbdnbd2bdcbcxbcmbchbcgbcgbcfbccbbwbb4bbfbazbaubatbatbatbatbatbatbatbatbatbatbawbbbbbdbbdbbdbbdbbdbbdbbdbbdbb2bblbbnbbnbbnbbnbbn_aa_ew_gx_2z_lb_nd_ul_x4_z3bbybdzbgcb2db4gbmlbt3bwtbyncbaccxcfbchbc3hclfcnlcu3cyddbedefdhdd4hdnddwedzeebfed2egde2weleenaeu2exlezlfbufdwfg3f3mfmlfu4fxzgalgdwggtg2wgmdgubgybhblhd3hg2h3whmnhwahyx2bt2eu22f24z2tc2xg3aa3cn3fu33a3mn3un3ym4bx4ez4h243h4mn4ut4ytlbtlfa '
points = data_trans.analysis_data(raw_data)
points = data_trans.scale(points)
draw(points)
# for i, char_path in enumerate(char_paths):
# plt.subplot(130 + i + 1)
# ps = data_trans.analysis_data(char_path)
# x = [ps[i]['x'] for i in range(len(ps))]
# y = [-ps[i]['y'] for i in range(len(ps))]
# plt.plot(x, y)
# plt.savefig(rp + _ + '.jpg')
# plt.close()
for id, drawer in drawers.items():
rp = ''
for char in char_list:
if char == 'a':
rp = '_'
paths = drawer[char]
plt.figure(figsize=(24, 8))
for i, path in enumerate(paths):
plt.subplot(130 + i + 1)
ps = data_trans.analysis_data(path)
x = [ps[i]['x'] for i in range(len(ps))]
y = [-ps[i]['y'] for i in range(len(ps))]
plt.plot(x, y)
img_dir_path = 'img/' + id + '/'
isExists = os.path.exists(img_dir_path)
if isExists:
plt.savefig('img/' + id + '/' + char + rp + '.jpg')
else:
os.makedirs(img_dir_path)
plt.savefig('img/' + id + '/' + char + rp + '.jpg')
plt.close()
n = 10
file_path = './data/xuhao_tmp'
model_path = './model_3PEOPLE_DRAW2_10.h5'
data = np.zeros((n, 128, 128, 3))
model = keras.models.load_model(model_path)
for layer in model.layers[:-3]:
layer.trainable = False
x_ratio, y_ratio = check_data.get_scale_ratio(file_path)
with open(file_path) as f:
for i, line in enumerate(f.readlines()):
points = data_trans.analysis_data(line)
points = sorted(points, key=lambda x: x['time'])
for j in range(10):
points = fake_data.create_fake(points)
points = get_velocity(points)
for point in points:
data[j][int(point['x'] * x_ratio)][int(
point['y'] * y_ratio)] = [1, point['time'], point['v']]
y_train = np.ones(n) * 3
y_train = keras.utils.to_categorical(y_train, 4)
model.fit(data, y_train, batch_size=1, epochs=5)
x_ratio, y_ratio = check_data.get_scale_ratio('./data/xuhao_new')
test_data = np.zeros((40, 128, 128, 3))
with open('./data/xuhao_new') as f: