def data_input(testing_datalist, networks, feature, x, y, sess):
# testing_datalist = './dataset_splits/one_shot_train_22.txt'
features = []
batch_size = 1
seq_len = 32
X_test, y_test = data.load_video_list(testing_datalist)
X_teidx = np.asarray(np.arange(0, len(y_test)), dtype=np.int32)
y_test = np.asarray(y_test, dtype=np.int32)
for X_indices, y_label_t in tl.iterate.minibatches(X_teidx,
y_test,
batch_size,
shuffle=False):
# Read data for each batch
image_path = []
image_fcnt = []
image_olen = []
is_training = []
for data_a in range(batch_size):
X_index_a = X_indices[data_a]
key_str = '%06d' % X_index_a
image_path.append(X_test[key_str]['videopath'])
image_fcnt.append(X_test[key_str]['framecnt'])
image_olen.append(seq_len)
is_training.append(False) # Testing
image_info = zip(image_path, image_fcnt, image_olen, is_training)
X_data_t = tl.prepro.threading_data([_ for _ in image_info],
data.prepare_isogr_depth_data)
feed_dict = {x: X_data_t, y: y_label_t}
dp_dict = tl.utils.dict_to_one(networks.all_drop)
feed_dict.update(dp_dict)
feature_ = sess.run(feature, feed_dict=feed_dict)
features.extend(feature_)
return features
def data_input(testing_datalist,networks,feature,x,y,sess):
# testing_datalist = './dataset_splits/one_shot_train_22.txt'
features = []
batch_size=1
seq_len=32
X_test, y_test = data.load_video_list(testing_datalist)
X_teidx = np.asarray(np.arange(0, len(y_test)), dtype=np.int32)
y_test = np.asarray(y_test, dtype=np.int32)
for X_indices, y_label_t in tl.iterate.minibatches(X_teidx,
y_test,
batch_size,
shuffle=False):
# Read data for each batch
image_path = []
image_fcnt = []
image_olen = []
is_training = []
for data_a in range(batch_size):
X_index_a = X_indices[data_a]
key_str = '%06d' % X_index_a
image_path.append(X_test[key_str]['videopath'])
image_fcnt.append(X_test[key_str]['framecnt'])
image_olen.append(seq_len)
is_training.append(False) # Testing
image_info = zip(image_path, image_fcnt, image_olen, is_training)
X_data_t = tl.prepro.threading_data([_ for _ in image_info],
data.prepare_isogr_depth_data)
feed_dict = {x: X_data_t, y: y_label_t}
dp_dict = tl.utils.dict_to_one(networks.all_drop)
feed_dict.update(dp_dict)
feature_ = sess.run( feature,feed_dict=feed_dict)
features.extend(feature_)
return features
batch_size,
], name='y')
sess = tf.InteractiveSession()
networks = net.c3d_clstm(x, num_classes, False, False)
network_pred = tf.nn.softmax(networks.outputs)
network_y_op = tf.argmax(tf.nn.softmax(networks.outputs), 1)
network_accu = tf.reduce_mean(
tf.cast(tf.equal(tf.cast(network_y_op, tf.int32), y), tf.float32))
sess.run(tf.initialize_all_variables())
# RGB
testing_datalist = 'image4LSTM/test/test_rgb_DF.txt'
X_test, y_test = data.load_video_list(testing_datalist)
X_teidx = np.asarray(np.arange(0, len(y_test)), dtype=np.int32)
y_test = np.asarray(y_test, dtype=np.int32)
rgb_prediction = np.zeros((len(y_test), num_classes), dtype=np.float32)
load_params = tl.files.load_npz(name='Rgb_DF_model.npz')
tl.files.assign_params(sess, load_params, networks)
# networks.print_params(True)
average_accuracy = 0.0
test_iterations = 0
print '%s: rgb testing' % datetime.now()
for X_indices, y_label_t in tl.iterate.minibatches(X_teidx,
y_test,
batch_size,
shuffle=False):
# Read data for each batch
image_path = []
decay_steps,
decay_rate,
staircase=True)
train_params = networks.all_params
train_op = tf.train.GradientDescentOptimizer(lr).minimize(
cost, var_list=train_params, global_step=global_step)
sess.run(tf.initialize_all_variables())
if start_step > 0:
load_params = tl.files.load_npz(name='%s_model_iter_%d.npz' %
(dataset_name, start_step))
tl.files.assign_params(sess, load_params, networks)
networks.print_params(True)
# Data Reading
X_train, y_train = data.load_video_list(training_datalist)
X_tridx = np.asarray(np.arange(0, len(y_train)), dtype=np.int32)
y_train = np.asarray(y_train, dtype=np.int32)
X_test, y_test = data.load_video_list(testing_datalist)
X_teidx = np.asarray(np.arange(0, len(y_test)), dtype=np.int32)
y_test = np.asarray(y_test, dtype=np.int32)
X_data_a = np.empty((batch_size * queue_num, seq_len, 112, 112, 3), float)
y_label_a = np.empty((batch_size * queue_num, ), int)
full_flg = np.zeros((queue_num, 1))
rdwr_lock = threading.Lock()
def training_data_read():
wr_pos = 0
merged = tf.summary.merge_all()
train_writer = tf.summary.FileWriter('train_log', sess.graph)
# load the parameters from the pre-trained model
if start_step > 0:
load_params = tl.files.load_npz(path='models/', name='model-1000.npz')
tl.files.assign_params(sess, load_params, networks)
# tl.files.load_ckpt(sess,var_list=networks.all_params,mode_name="model-18000.ckpt",save_dir="models",printable=True)
networks.print_params(True)
# define the data queue
data_x = queue.Queue(maxsize=20)
data_y = queue.Queue(maxsize=20)
## load the file path and the labels
data, label = input.load_video_list(training_datalist)
X_tridx = np.asarray(np.arange(0, len(label)), dtype=np.int32)
y_train = np.asarray(label, dtype=np.int32)
X_data_a = np.empty((batch_size, seq_len, 112, 112, 3), float)
y_label_a = np.empty((batch_size, ), int)
def read_data():
#get image and labels from the file path
for i in range(n_epoch):
# 获取对应批次的数据
for X_indices, y_labels in tl.iterate.minibatches(X_tridx,
y_train,
batch_size,
shuffle=True):
assign_params_my(sess, load_params[38:44], networks,58)
assign_params_my(sess, load_params[44:50], networks,68)
print 'load param from %s'%(pretrained_model)
networks.print_params(True)
def assign_params_my(sess, params, network,index):
ops = []
for idx, param in enumerate(params):
ops.append(network.all_params[idx+index].assign(param))
if sess is not None:
sess.run(ops)
return ops
# Data Reading
X_train,y_train = data.load_video_list(training_datalist)
#X_tridx is an array of (0,len(y_train)
X_tridx = np.asarray(np.arange(0, len(y_train)), dtype=np.int32)
#y_train is an array of label
y_train = np.asarray(y_train, dtype=np.int32)
X_test,y_test = data.load_video_list(testing_datalist)
X_teidx = np.asarray(np.arange(0, len(y_test)), dtype=np.int32)
y_test = np.asarray(y_test, dtype=np.int32)
#X_data_a full of 0 y_label_a very large number
X_data_a = np.empty((batch_size*queue_num, seq_len, 112, 112, 3),float)
y_label_a = np.empty((batch_size*queue_num,),int)
full_flg = np.zeros((queue_num, 1))
rdwr_lock = threading.Lock()
def training_data_read():
feature, networks = net.c3d_biclstm(x, num_classes, False, False)
feature=feature.outputs
network_pred = tf.nn.softmax(networks.outputs)
network_y_op = tf.argmax(tf.nn.softmax(networks.outputs), 1)
pre_label=tf.cast(network_y_op,tf.int32)
network_accu = tf.reduce_mean(tf.cast(tf.equal(tf.cast(network_y_op, tf.int32), y), tf.float32))
sess.run(tf.global_variables_initializer())
# Depth
testing_datalist = './dataset_splits/test_samples.txt'
features=[]
labels=[]
true_labels=[]
X_test, y_test = data.load_video_list(testing_datalist)
X_teidx = np.asarray(np.arange(0, len(y_test)), dtype=np.int32)
y_test = np.asarray(y_test, dtype=np.int32)
testing_label = np.zeros((len(y_test), 1), dtype=np.float32)
depth_prediction = np.zeros((len(y_test), num_classes), dtype=np.float32)
#the pre-trained model is trained on 19 classes of gestures
load_params = tl.files.load_npz(name='%s/beihang_dataset_birnn_model_epoch_10.npz' % (model_prefix))
tl.files.assign_params(sess, load_params, networks)
# networks.print_params(True)
test_iterations = 0
print '%s: depth testing' % datetime.now()
for X_indices, y_label_t in tl.iterate.minibatches(X_teidx,
y_test,
batch_size,
shuffle=False):
# Read data for each batch
