def MotionNet(order,
epoch,
batch_size,
save_period,
optimizer='sgd',
learning_rate=0.1,
lr_step=1000,
lr_factor=0.9,
stop_factor_lr=1e-08,
use_gpu=True,
use_cudnn=True,
test=False,
predict_size=5,
time_step=150,
seed_timestep=30,
batch_Frame=5,
frame_time=30):
print("-------------------Motion Net-------------------")
'''1. Data_Loading - bvh_reader'''
Normalization_factor, train_motion, train_label_motion, seed_timestep, pre_timestep, column, file_directory = br.Motion_Data_Preprocessing(
time_step, seed_timestep, batch_Frame)
if test == True:
data = OrderedDict()
data['seed_motion'] = train_motion
label = {'label_motion': train_label_motion}
test_iter = mx.io.NDArrayIter(data=data, label=label)
train_iter = mx.io.NDArrayIter(
data=data, label=label, shuffle=False, last_batch_handle='pad'
) # Motion data is complex and requires sequential learning to learn from easy examples. So shuffle = False
else:
train_motion = train_motion[:predict_size]
train_label_motion = train_label_motion[:predict_size]
data = OrderedDict()
data['seed_motion'] = train_motion
label = {'label_motion': train_label_motion}
train_iter = mx.io.NDArrayIter(
data=data,
label=label,
batch_size=batch_size,
shuffle=False,
last_batch_handle='pad'
) # Motion data is complex and requires sequential learning to learn from easy examples. So shuffle = False
'''2. hyperparameter'''
rnn_layer_number = 1
rnn_hidden_number = 200
fc_number = 200
Dropout_rate = 0.0
if use_cudnn == True and use_gpu == True:
ctx = mx.gpu(0)
elif use_cudnn == False and use_gpu == True:
ctx = mx.gpu(0)
else:
#why? mx.rnn.FusedRNNCell only works on use_cudnn == True and use_gpu == True
ctx = mx.cpu(0)
'''3. Network'''
all_motion = mx.sym.Variable('seed_motion')
seed_motion = mx.sym.transpose(mx.sym.slice_axis(data=all_motion,
axis=1,
begin=0,
end=seed_timestep),
axes=(1, 0, 2)) # (time,batch,column)
label_motion = mx.sym.Variable('label_motion')
e_cell = encoder(use_cudnn=use_cudnn,
layer_number=rnn_layer_number,
hidden_number=rnn_hidden_number,
Dropout_rate=Dropout_rate)
d_cell = decoder(use_cudnn=use_cudnn,
layer_number=rnn_layer_number,
hidden_number=rnn_hidden_number,
Dropout_rate=Dropout_rate)
e_output, e_state = e_cell.unroll(length=seed_timestep,
inputs=seed_motion,
merge_outputs=False,
layout='TNC') #(batch,hidden)
print(e_state)
#seq2seq in test
if test == True:
e_output_end = e_output[-1] # Shape: (1, N, C)
e_output_end = mx.sym.reshape(data=e_output_end, shape=(1, 1, -1))
d_input = mx.sym.broadcast_to(e_output_end, shape=(pre_timestep, 0, 0))
d_output, d_state = d_cell.unroll(length=pre_timestep,
begin_state=e_state,
inputs=d_input,
merge_outputs=False,
layout='TNC')
#seq2seq in training
else:
e_output_end = e_output[-1] # Shape: (1, N, C)
e_output_end = mx.sym.reshape(data=e_output_end,
shape=(1, batch_size, -1))
d_input = mx.sym.broadcast_to(e_output_end, shape=(pre_timestep, 0, 0))
d_output, d_state = d_cell.unroll(length=pre_timestep,
begin_state=e_state,
inputs=d_input,
merge_outputs=False,
layout='TNC')
# if use_cudnn=False , begin_state = e_state do not working.
if use_cudnn:
rnn_output = mx.sym.Reshape(d_output[-1],
shape=(-1, 2 * rnn_hidden_number))
else:
rnn_output = d_output[-1]
# if you use dropout
# rnn_output = mx.sym.Dropout(data=rnn_output,p=0.3)
affine1 = mx.sym.FullyConnected(
data=rnn_output, num_hidden=fc_number,
name='affine1') # if use_cudnn=False , data=state[-1] i
act1 = mx.sym.Activation(data=affine1, act_type='tanh', name='tanh1')
drop1 = mx.sym.Dropout(act1, p=Dropout_rate)
affine2 = mx.sym.FullyConnected(data=drop1,
num_hidden=fc_number,
name='affine2')
act2 = mx.sym.Activation(data=affine2, act_type='tanh', name='tanh2')
drop2 = mx.sym.Dropout(act2, p=Dropout_rate)
output = mx.sym.FullyConnected(data=drop2,
num_hidden=pre_timestep * column,
name='affine3')
output = mx.sym.LinearRegressionOutput(data=output, label=label_motion)
# We visualize the network structure with output size (the batch_size is ignored.) - In pycharm or vs code, not working
if use_cudnn:
#shape = {'seed_motion': (seed_timestep, batch_size, column)
mx.viz.plot_network(
symbol=output) # The diagram can be found on the Jupiter notebook.
else:
#shape = {'seed_motion': (batch_size, seed_timestep , column)}
mx.viz.plot_network(
symbol=output) # The diagram can be found on the Jupiter notebook.
print(output.list_arguments())
# training mod
mod = mx.module.Module(symbol=output,
data_names=['seed_motion'],
label_names=['label_motion'],
context=ctx)
# Network information print
print(mod.data_names)
print(mod.label_names)
if test == False:
print(train_iter.provide_data)
print(train_iter.provide_label)
else:
print(test_iter.provide_data)
print(test_iter.provide_label)
'''
grad_req (str, list of str, dict of str to str) –
Requirement for gradient accumulation. Can be ‘write’, ‘add’, or ‘null’
(default to ‘write’). Can be specified globally (str) or for each argument (list, dict).
'''
mod.bind(data_shapes=train_iter.provide_data,
label_shapes=train_iter.provide_label,
for_training=True,
shared_module=None,
inputs_need_grad=False,
force_rebind=False,
grad_req='write')
# weights load
cudnn_weights_path = 'weights/Cudnn_MotionNet-{}th-{}.params'.format(
order, save_period)
weights_path = 'weights/MotionNet-{}th-{}.params'.format(
order, save_period)
if os.path.exists(
cudnn_weights_path) and use_cudnn == True and use_gpu == True:
mod.load_params(cudnn_weights_path)
elif (os.path.exists(weights_path) and use_cudnn == False and use_gpu
== True) and (os.path.exists(weights_path) and use_cudnn == True
and use_gpu == False) and (os.path.exists(weights_path)
and use_cudnn == False
and use_gpu == False):
mod.load_params(weights_path)
else:
mod.init_params(initializer=mx.initializer.Xavier(
rnd_type='gaussian', factor_type='avg', magnitude=1))
if optimizer == 'sgd':
lr_sch = mx.lr_scheduler.FactorScheduler(step=lr_step,
factor=lr_factor,
stop_factor_lr=stop_factor_lr)
mod.init_optimizer(optimizer=optimizer,
optimizer_params={
'learning_rate': learning_rate,
'lr_scheduler': lr_sch
})
else:
mod.init_optimizer(optimizer=optimizer,
optimizer_params={'learning_rate': learning_rate})
metric = mx.metric.create(['mse'])
start_time = time.time()
if test == False:
for epoch in range(1, epoch + 1, 1):
train_iter.reset()
for batch in train_iter:
mod.forward(batch, is_train=True)
mod.update_metric(metric, batch.label)
mod.backward()
mod.update()
print('Epoch : {}'.format(epoch, metric.get()))
if epoch % 100 == 0:
end_time = time.time()
print(
"-------------------------------------------------------")
print("{}_learning time : {}".format(epoch,
end_time - start_time))
print(
"-------------------------------------------------------")
cal = mod.predict(eval_data=train_iter,
merge_batches=True,
reset=True,
always_output_list=False).asnumpy()
cost = cal - train_label_motion
cost = (cost**2) / 2
cost = np.mean(cost)
print("joint angle Square Error : {}".format(cost))
if cost < 0.01:
if not os.path.exists("weights"):
os.makedirs("weights")
if use_cudnn:
print('Saving weights')
mod.save_params(
"weights/Cudnn_MotionNet-{}th-{}.params".format(
order, epoch))
else:
print('Saving weights')
mod.save_params("weights/MotionNet-{}th-{}.params".format(
order, epoch))
print(
"############################################################################################"
)
print("End the learning.")
print(
"############################################################################################"
)
#training-data_test
seed = train_iter.data[0][1].asnumpy()
prediction_motion = mod.predict(
eval_data=train_iter,
merge_batches=True,
reset=True,
always_output_list=False).asnumpy() / Normalization_factor
'''Creating a bvh file with predicted values -bvh_writer'''
bw.Motion_Data_Making(seed[:, :seed_timestep] /
Normalization_factor,
prediction_motion,
seed_timestep,
pre_timestep,
batch_Frame,
frame_time,
file_directory,
test=False)
return "completed", epoch
# Network information print
print(mod.data_shapes)
print(mod.label_shapes)
print(mod.output_shapes)
print(mod.get_params())
print(mod.get_outputs())
print("Optimization complete")
#tall data test
if test == True:
# test mod
test_mod = mx.mod.Module(symbol=output,
data_names=['seed_motion'],
label_names=['label_motion'],
context=ctx)
test_mod.bind(data_shapes=test_iter.provide_data,
label_shapes=test_iter.provide_label,
for_training=False,
shared_module=mod)
if os.path.exists(cudnn_weights_path) or os.path.exists(
weights_path): #FusedRNN
seed = test_iter.data[0][1].asnumpy()
prediction_motion = test_mod.predict(
eval_data=test_iter,
merge_batches=True,
always_output_list=False).asnumpy() / Normalization_factor
'''Creating a bvh file with predicted values -bvh_writer'''
bw.Motion_Data_Making(seed[:, :seed_timestep],
prediction_motion,
seed_timestep,
pre_timestep,
batch_Frame,
frame_time,
file_directory,
test=True)
else:
print("Can not test")
print("finished")
def MotionNet(epoch=None , batch_size=None , save_period=None , cost_limit=None ,
optimizer=None, learning_rate=None , lr_step=None , lr_factor=None , stop_factor_lr=None , use_gpu=True ,
TEST=None , num_layer=None , cell=None, hidden_unit=None ,time_step = None , seed_timestep = None , batch_Frame= None , frame_time=None, graphviz=None , parameter_shared=True , Model = None):
print("-------------------Motion Net-------------------")
'''1. Data_Loading - bvh_reader'''
Normalization_factor, train_motion, train_label_motion , seed_timestep, pre_timestep, column, file_directory = br.Motion_Data_Preprocessing(time_step , seed_timestep , batch_Frame , TEST , Model)
if TEST==True:
print("<TEST>")
data = OrderedDict()
data['seed_motion'] = train_motion
label = {'label_motion': train_label_motion}
test_iter = mx.io.NDArrayIter(data=data, label=label)
else:
print("<Training>")
data = OrderedDict()
data['seed_motion'] = train_motion
label = {'label_motion': train_label_motion}
train_iter = mx.io.NDArrayIter(data=data, label=label, batch_size=batch_size, shuffle=False, last_batch_handle='pad') # Motion data is complex and requires sequential learning to learn from easy examples. So shuffle = False ->In here, not using sequential learning
if use_gpu:
ctx = mx.gpu(0)
else:
ctx = mx.cpu(0)
'''2. Network'''
all_motion = mx.sym.Variable('seed_motion')
label_motion = mx.sym.Variable('label_motion')
seed_motion = mx.sym.slice_axis(data=all_motion , axis=1 , begin = 0 , end = seed_timestep) # (batch , time , column)
if TEST == True:
pre_motion = mx.sym.reshape(mx.sym.slice_axis(data=all_motion, axis=1, begin=seed_timestep-1, end=seed_timestep),
shape=(1, -1)) # (batch=1,column) - first frame
else:
pre_motion = mx.sym.reshape(mx.sym.slice_axis(data=all_motion, axis=1, begin=seed_timestep-1, end=seed_timestep),
shape=(batch_size, -1)) # (batch,column) - first frame
print("-------------------Network Shape--------------------")
'''
only if encoder's parameter_shared=True , parameter Encoder and decoder parameters are shared.
'''
e_cell , encoder_parameter = encoder(layer_number= num_layer , hidden_number=hidden_unit , Dropout_rate=0.0 , Zoneout_rate=0.0 , cell=cell , parameter_shared = parameter_shared ) # if parameter_shared = True, paramter = encoder's weights , else False = []
if num_layer==1 and parameter_shared==True: #only if num_layer=1 , Both Residual = True and Residual = False are possible.
d_cell = decoder(layer_number= num_layer , hidden_number=hidden_unit , output_number=column , Dropout_rate=0.0 , Zoneout_rate=0.0 , Residual = True , cell=cell , param=encoder_parameter)
elif num_layer>1 and parameter_shared==True:# There is no way to share parameters with the encoder.
d_cell = decoder(layer_number=num_layer, hidden_number=hidden_unit, output_number=column, Dropout_rate=0.0,Zoneout_rate=0.0, Residual=False, cell=cell, param=encoder_parameter)
else: # parameter_shared=False , Both Residual = True and Residual = False are possible.
d_cell = decoder(layer_number=num_layer, hidden_number=hidden_unit, output_number=column, Dropout_rate=0.0,Zoneout_rate=0.0, Residual=True, cell=cell, param=encoder_parameter)
print("\n")
_ , e_state = e_cell.unroll(length=seed_timestep , inputs=seed_motion , merge_outputs=True , layout='NTC')
# customized by JG
if num_layer==1:
d_output, _ = d_cell.SingleLayer_feed_previous_unroll(length=pre_timestep, begin_state=e_state,inputs=pre_motion, merge_outputs=True, layout='NTC') # MultiLayer_feed_previous_unroll is also possible.
else:
d_output, _ = d_cell.MultiLayer_feed_previous_unroll(length=pre_timestep, begin_state=e_state, inputs=pre_motion, merge_outputs=True, layout='NTC') # MultiLayer_feed_previous_unroll is also possible.
#output = mx.sym.LinearRegressionOutput(data = d_output , label=label_motion , grad_scale = 1)
output = mx.sym.Custom(data=d_output, label=label_motion, grad_scale=1, name="LinearRegression", op_type='LinearRegression')
digraph=mx.viz.plot_network(symbol=output,hide_weights=True)
#why? batch_Frame>=10 ? -> graph 'plot' size too small for label
if graphviz==True and TEST == True and batch_Frame>=10:
digraph.view("{}_batch_Frame_TEST_Seq2Seq".format(batch_Frame)) #show graph
elif graphviz==True and TEST == False and batch_Frame>=10:
digraph.view("{}_batch_Frame_Training_Seq2Seq".format(batch_Frame)) #show graph
print("-------------------Network Learning Parameter--------------------")
print(output.list_arguments())
print("\n")
if TEST == False:
mod = mx.module.Module(symbol=output, data_names=['seed_motion'], label_names=['label_motion'], context=ctx)
print("-------------------Network Data Name--------------------")
print(mod.data_names)
print(mod.label_names)
print("\n")
else:
# test mod
test_mod = mx.mod.Module(symbol=output , data_names=['seed_motion'] , label_names=['label_motion'] , context=ctx)
print("-------------------Network Data Name--------------------")
print(test_mod.data_names)
print(test_mod.label_names)
print("\n")
print("-------------------Network Data Shape--------------------")
if TEST==False:
print(train_iter.provide_data)
print(train_iter.provide_label)
else:
print(test_iter.provide_data)
print(test_iter.provide_label)
print("\n")
'''
grad_req (str, list of str, dict of str to str) –
Requirement for gradient accumulation. Can be ‘write’, ‘add’, or ‘null’
(default to ‘write’). Can be specified globally (str) or for each argument (list, dict).
'''
if TEST == False:
mod.bind(data_shapes=train_iter.provide_data , label_shapes=train_iter.provide_label , for_training=True , shared_module=None , inputs_need_grad=False , force_rebind=False , grad_req='write')
# weights load
weights_path = 'weights/MotionNet-{}.params'.format(save_period)
if os.path.exists(weights_path):
print("load weights")
mod.load_params(weights_path)
else:
print("init weights")
mod.init_params(initializer=mx.initializer.Normal(sigma=0.01)) # very important
start_time=time.time()
print("-------------------Learning Start--------------------")
if optimizer=='sgd':
lr_sch = mx.lr_scheduler.FactorScheduler(step = lr_step, factor = lr_factor , stop_factor_lr = stop_factor_lr)
mod.init_optimizer(optimizer=optimizer, optimizer_params={'learning_rate': learning_rate , 'lr_scheduler': lr_sch})
else:
mod.init_optimizer(optimizer=optimizer, optimizer_params={'learning_rate': learning_rate})
metric = mx.metric.create(['mse'])
for epoch in range(1, epoch + 1, 1):
train_iter.reset()
metric.reset()
for batch in train_iter:
if epoch % 2 == 0: # Only noise is added when it is an even number
'''1. Add noise to input - Data Augmentation'''
#random_normal
noise = mx.nd.random_normal(loc=0 , scale=5 , shape=(batch_size , seed_timestep+pre_timestep , column) , ctx=ctx) # random_normal
#random_uniform
#noise = mx.nd.random_uniform(low=-1 , high=1 , shape=(batch_size , seed_timestep+pre_timestep , column) ,ctx=ctx) # random_uniform
mod.forward(data_batch=mx.io.DataBatch(data = list([mx.nd.add(batch.data[0].as_in_context(ctx), noise)]), label= list(batch.label)), is_train=True)
#Data Order Transform (N,T,C)
else:
mod.forward(data_batch=batch , is_train=True)
mod.update_metric(metric,batch.label)
mod.backward()
mod.update()
#print('epoch : {} , MSE : {}'.format(epoch,metric.get()))
if epoch % 100 == 0:
end_time=time.time()
print("-------------------------------------------------------")
print("{}_learning time : {}".format(epoch,end_time-start_time))
print("-------------------------------------------------------")
if epoch % 10000 == 0:
if not os.path.exists("weights"):
os.makedirs("weights")
print('Saving weights')
mod.save_params("weights/MotionNet-{}.params".format(epoch))
cal = mod.predict(eval_data=train_iter , merge_batches=True , reset=True, always_output_list=False).asnumpy() / Normalization_factor
cost = cal - train_label_motion
cost=(cost**2)/2
cost=np.mean(cost)
print('{} epoch '.format(epoch), end='')
print("Joint Angle Square Error : {}".format(cost))
if cost < cost_limit:
if not os.path.exists("weights"):
os.makedirs("weights")
print('Saving weights')
mod.save_params("weights/MotionNet-{}.params".format(epoch))
print("############################################################################################")
print("End the learning.")
print("############################################################################################")
return "optimization completed"
print("\n")
print("-------------------Network Information--------------------")
print(mod.data_shapes)
print(mod.label_shapes)
print(mod.output_shapes)
print(mod.get_params())
print(mod.get_outputs())
print("{} learning optimization completed".format(epoch))
print("\n")
if TEST==True:
test_mod.bind(data_shapes=test_iter.provide_data , label_shapes=test_iter.provide_label , for_training=False)
# weights load
weights_path = 'weights/MotionNet-{}.params'.format(save_period)
if os.path.exists(weights_path):
test_mod.load_params(weights_path)
#order : (N , T(all time) , C)
seed = test_iter.data[0][1].asnumpy()
#order : (N , T(predict time) , C)
prediction_motion = test_mod.predict(eval_data=test_iter , merge_batches=True , always_output_list=False).asnumpy()/Normalization_factor
print("Test Prediction motion shape : {}".format(np.shape(prediction_motion)))
#test cost
cost = prediction_motion - train_label_motion
cost=(cost**2)/2
print(style.available)
TimeStepError_Array=np.mean(cost,axis=(0,2)) # y-axis
print(TimeStepError_Array)
TimeStep = np.arange(1,pre_timestep+1,1) # x-axis
#Dram Error graph
style.use('seaborn')
plt.figure(figsize=(9,4))
bbox = dict(boxstyle = 'round' , fc = 'w' , ec = 'b' , lw = 2)
#plt.plot(TimeStep , TimeStepError_Array , "r." , lw=3 ,label = "Error")
plt.bar(TimeStep , TimeStepError_Array , width=0.7 ,label ='error', color = 'r')
plt.annotate("Error Prevention" ,fontsize=14, xy = (60,1000) , xytext=(0,1000), textcoords='data' ,arrowprops={'color' : 'blue' , 'alpha' : 0.3 , 'arrowstyle' : "simple"}, bbox = bbox)
plt.grid()
plt.xlabel("Time", fontsize=14)
plt.ylabel("Joint Angle Error" , fontsize=14)
plt.ylim(0,4400)
plt.legend(fontsize=15,loc='upper left')
plt.title("Prediction Error Graph", fontdict={'fontsize': 15 , 'fontweight' : 5})
print("cost graph saved")
plt.savefig("Cost Graph.jpg")
cost=np.mean(cost)
print("prediction error : {}".format(cost))
'''Creating a bvh file with predicted values -bvh_writer'''
bw.Motion_Data_Making(seed[:,:seed_timestep] / Normalization_factor , prediction_motion , seed_timestep , pre_timestep , batch_Frame , frame_time , file_directory , Model)
plt.show()
return "Test completed"
else:
print("Can not test")
def MotionNet(order=None,
epoch=None,
batch_size=None,
save_period=None,
cost_limit=None,
optimizer=None,
learning_rate=None,
lr_step=None,
lr_factor=None,
stop_factor_lr=None,
use_gpu=True,
TEST=None,
num_layer=None,
cell=None,
hidden_unit=None,
time_step=None,
seed_timestep=None,
batch_Frame=None,
frame_time=None,
graphviz=None):
print("-------------------Motion Net-------------------")
'''1. Data_Loading - bvh_reader'''
Normalization_factor, train_motion, train_label_motion, seed_timestep, pre_timestep, column, file_directory = br.Motion_Data_Preprocessing(
time_step, seed_timestep, batch_Frame, TEST)
if TEST == True:
print("<TEST>")
data = OrderedDict()
data['seed_motion'] = train_motion
label = {'label_motion': train_label_motion}
test_iter = mx.io.NDArrayIter(data=data, label=label)
else:
print("<Training>")
train_motion = train_motion[:batch_size]
train_label_motion = train_label_motion[:batch_size]
data = OrderedDict()
data['seed_motion'] = train_motion
label = {'label_motion': train_label_motion}
train_iter = mx.io.NDArrayIter(
data=data,
label=label,
batch_size=batch_size,
shuffle=False,
last_batch_handle='pad'
) # Motion data is complex and requires sequential learning to learn from easy examples. So shuffle = False
if use_gpu:
ctx = mx.gpu(0)
else:
ctx = mx.cpu(0)
'''2. Network'''
all_motion = mx.sym.Variable('seed_motion')
label_motion = mx.sym.Variable('label_motion')
seed_motion = mx.sym.slice_axis(data=all_motion,
axis=1,
begin=0,
end=seed_timestep) # (batch,time,column)
if TEST == True:
pre_motion = mx.sym.reshape(
mx.sym.slice_axis(data=all_motion,
axis=1,
begin=seed_timestep,
end=seed_timestep + 1),
shape=(1, -1)) # (batch=1,column) - first frame
else:
pre_motion = mx.sym.slice_axis(data=all_motion,
axis=1,
begin=seed_timestep - 1,
end=-1)
print("-------------------Network Shape--------------------")
e_cell = encoder(layer_number=num_layer,
hidden_number=hidden_unit,
Dropout_rate=0.2,
cell=cell)
d_cell = decoder(layer_number=num_layer,
hidden_number=hidden_unit,
output_number=column,
Dropout_rate=0.2,
cell=cell)
print("\n")
_, e_state = e_cell.unroll(length=seed_timestep,
inputs=seed_motion,
merge_outputs=True,
layout='NTC') #(batch,hidden)
#seq2seq in test
if TEST == True:
# customized by JG
if num_layer == 1:
d_output, _ = d_cell.SingleLayer_feed_previous_unroll(
length=pre_timestep,
begin_state=e_state,
inputs=pre_motion,
merge_outputs=True,
layout='NTC'
) # MultiLayer_feed_previous_unroll is also possible.
else:
d_output, _ = d_cell.MultiLayer_feed_previous_unroll(
length=pre_timestep,
begin_state=e_state,
inputs=pre_motion,
merge_outputs=True,
layout='NTC')
#seq2seq in training
else:
d_output, _ = d_cell.unroll(length=pre_timestep,
begin_state=e_state,
inputs=pre_motion,
merge_outputs=True,
layout='NTC')
output = mx.sym.LinearRegressionOutput(data=d_output, label=label_motion)
digraph = mx.viz.plot_network(symbol=output, hide_weights=True)
#why? batch_Frame>=10 ? -> graph 'plot' size too small for label
if graphviz == True and TEST == True and batch_Frame >= 10:
digraph.view(
"{}_batch_Frame_TEST_Seq2Seq".format(batch_Frame)) #show graph
elif graphviz == True and TEST == False and order == 1 and batch_Frame >= 10:
digraph.view(
"{}_batch_Frame_Training_Seq2Seq".format(batch_Frame)) #show graph
print("-------------------Network Learning Parameter--------------------")
print(output.list_arguments())
print("\n")
if TEST == False:
mod = mx.module.Module(symbol=output,
data_names=['seed_motion'],
label_names=['label_motion'],
context=ctx)
print("-------------------Network Data Name--------------------")
print(mod.data_names)
print(mod.label_names)
print("\n")
else:
# test mod
test_mod = mx.mod.Module(symbol=output,
data_names=['seed_motion'],
label_names=['label_motion'],
context=ctx)
print("-------------------Network Data Name--------------------")
print(test_mod.data_names)
print(test_mod.label_names)
print("\n")
print("-------------------Network Data Shape--------------------")
if TEST == False:
print(train_iter.provide_data)
print(train_iter.provide_label)
else:
print(test_iter.provide_data)
print(test_iter.provide_label)
print("\n")
'''
grad_req (str, list of str, dict of str to str) –
Requirement for gradient accumulation. Can be ‘write’, ‘add’, or ‘null’
(default to ‘write’). Can be specified globally (str) or for each argument (list, dict).
'''
if TEST == False:
mod.bind(data_shapes=train_iter.provide_data,
label_shapes=train_iter.provide_label,
for_training=True,
shared_module=None,
inputs_need_grad=False,
force_rebind=False,
grad_req='write')
# weights load
weights_path = 'weights/MotionNet-{}th-{}.params'.format(
order, save_period)
if os.path.exists(weights_path):
mod.load_params(weights_path)
else:
mod.init_params(initializer=mx.initializer.Xavier(
rnd_type='gaussian', factor_type='avg', magnitude=1))
start_time = time.time()
print("-------------------Learning Start--------------------")
if optimizer == 'sgd':
lr_sch = mx.lr_scheduler.FactorScheduler(
step=lr_step, factor=lr_factor, stop_factor_lr=stop_factor_lr)
mod.init_optimizer(optimizer=optimizer,
optimizer_params={
'learning_rate': learning_rate,
'lr_scheduler': lr_sch
})
else:
mod.init_optimizer(
optimizer=optimizer,
optimizer_params={'learning_rate': learning_rate})
metric = mx.metric.create(['mse'])
for epoch in range(1, epoch + 1, 1):
train_iter.reset()
metric.reset()
for batch in train_iter:
mod.forward(batch, is_train=True)
#Data Order Transform (N,T,C)
mod.update_metric(metric, batch.label)
mod.backward()
mod.update()
#print('Epoch : {} , MSE : {}'.format(epoch,metric.get()))
if epoch % 100 == 0:
end_time = time.time()
print(
"-------------------------------------------------------")
print("{}_learning time : {}".format(epoch,
end_time - start_time))
print(
"-------------------------------------------------------")
if epoch % 10000 == 0:
if not os.path.exists("weights"):
os.makedirs("weights")
print('Saving weights')
mod.save_params("weights/MotionNet-{}.params".format(epoch))
cal = mod.predict(eval_data=train_iter,
merge_batches=True,
reset=True,
always_output_list=False).asnumpy()
cost = cal - train_label_motion
cost = (cost**2) / 2
cost = np.mean(cost)
print('{} epoch '.format(epoch), end='')
print("Joint Angle Square Error : {}".format(cost))
if cost < cost_limit:
if not os.path.exists("weights"):
os.makedirs("weights")
print('Saving weights')
mod.save_params("weights/MotionNet-{}th-{}.params".format(
order, epoch))
print(
"############################################################################################"
)
print("End the learning.")
print(
"############################################################################################"
)
#order : (N , T(all_time) , C)
seed = train_iter.data[0][1].asnumpy()
#order : (N , T(predict time) , C)
prediction_motion = mod.predict(
eval_data=train_iter,
merge_batches=True,
reset=True,
always_output_list=False).asnumpy() / Normalization_factor
'''Creating a bvh file with predicted values -bvh_writer'''
bw.Motion_Data_Making(
seed[:, :seed_timestep] / Normalization_factor,
prediction_motion, seed_timestep, pre_timestep,
batch_Frame, frame_time, file_directory, TEST)
return "completed", epoch
print("\n")
print("-------------------Network Information--------------------")
print(mod.data_shapes)
print(mod.label_shapes)
print(mod.output_shapes)
print(mod.get_params())
print(mod.get_outputs())
print("Optimization complete")
print("\n")
if TEST == True:
test_mod.bind(data_shapes=test_iter.provide_data,
label_shapes=test_iter.provide_label,
for_training=False)
# weights load
weights_path = 'weights/MotionNet-{}th-{}.params'.format(
order, save_period)
if os.path.exists(weights_path):
test_mod.load_params(weights_path)
#order : (N , T(all time) , C)
seed = test_iter.data[0][1].asnumpy()
#order : (N , T(predict time) , C)
prediction_motion = test_mod.predict(
eval_data=test_iter,
merge_batches=True,
always_output_list=False).asnumpy() / Normalization_factor
print("Test Prediction motion shape : {}".format(
np.shape(prediction_motion)))
#test cost
cost = prediction_motion - train_label_motion
cost = (cost**2) / 2
cost = np.mean(cost)
print("prediction error : {}".format(cost))
'''Creating a bvh file with predicted values -bvh_writer'''
bw.Motion_Data_Making(
seed[:, :seed_timestep] / Normalization_factor,
prediction_motion, seed_timestep, pre_timestep, batch_Frame,
frame_time, file_directory, TEST)
else:
print("Can not test")
import bvh_reader as br
import bvh_writer as bw
motion, time_step, batch_Frame, frame_Time, file_directory = br.Motion_Data_Preprocessing(
time_step=90, batch_Frame=1)
bw.Motion_Data_Making(motion, time_step, batch_Frame, frame_Time,
file_directory)