def param_init_encoder(options, params, prefix='lstm_encoder'):
n_x = options['n_x']
n_h = options['n_h']
W = np.concatenate([
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h)
],
axis=1)
params[_p(prefix, 'W')] = W
U = np.concatenate([
ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h)
],
axis=1)
params[_p(prefix, 'U')] = U
params[_p(prefix, 'b')] = zero_bias(4 * n_h)
# It is observed that setting a high initial forget gate bias for LSTMs can
# give slighly better results (Le et al., 2015). Hence, the initial forget
# gate bias is set to 3.
params[_p(prefix, 'b')][n_h:2 * n_h] = 3 * np.ones(
(n_h, )).astype(theano.config.floatX)
return params
def init_params(options, prefix):
temp = prefix
params = OrderedDict()
selected = np.random.permutation(options['C0'])
params['r'] = options['Lx'][selected[0:options['C']], :]
params['gp_beta'] = np.float32(1.)
params['gp_alpha'] = np.float32(2.)
if prefix == 'e' or temp == 'all':
prefix = 'e'
params[_p(prefix, 'b')] = uniform_weight(options[_p(prefix, 'K')],
options['C'])
params[_p(prefix, 'phi')] = uniform_weight(options[_p(prefix, 'K')],
options['C'] - 1)
params[_p(prefix, 'beta')] = uniform_weight(options[_p(prefix, 'K')],
1, 0, 0.05)
params[_p(prefix, 'omega')] = uniform_weight(options[_p(prefix, 'K')],
1, 0, 1.)
params[_p(prefix, 'bias')] = np.zeros((options[_p(prefix, 'K')]),
dtype=theano.config.floatX)
if prefix == 'cl' or temp == 'all':
prefix = 'cl'
params[_p(prefix, 'Wy')] = uniform_weight(options[_p(prefix, 'Wy')],
options[_p(prefix, 'ny')])
params[_p(prefix, 'by')] = np.zeros((options[_p(prefix, 'ny')]),
dtype=theano.config.floatX)
return params
def param_init_decoder(options, params, prefix='decoder_gru'):
n_x = options['n_x']
n_h = options['n_h']
W = np.concatenate([uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h)],
axis=1)
params[_p(prefix, 'W')] = W
U = np.concatenate([ortho_weight(n_h), ortho_weight(n_h)], axis=1)
params[_p(prefix, 'U')] = U
params[_p(prefix, 'b')] = zero_bias(2 * n_h)
Wx = uniform_weight(n_x, n_h)
params[_p(prefix, 'Wx')] = Wx
Ux = ortho_weight(n_h)
params[_p(prefix, 'Ux')] = Ux
params[_p(prefix, 'bx')] = zero_bias(n_h)
params[_p(prefix, 'b0')] = zero_bias(n_h)
return params
def param_init_decoder(options, params, prefix='decoder_gru'):
n_x = options['n_x']
n_h = options['n_h']
W = np.concatenate([uniform_weight(n_x,n_h),
uniform_weight(n_x,n_h)], axis=1)
params[_p(prefix,'W')] = W
U = np.concatenate([ortho_weight(n_h),
ortho_weight(n_h)], axis=1)
params[_p(prefix,'U')] = U
params[_p(prefix,'b')] = zero_bias(2*n_h)
Wx = uniform_weight(n_x, n_h)
params[_p(prefix,'Wx')] = Wx
Ux = ortho_weight(n_h)
params[_p(prefix,'Ux')] = Ux
params[_p(prefix,'bx')] = zero_bias(n_h)
params[_p(prefix,'b0')] = zero_bias(n_h)
return params
def param_init_decoder(options, params, prefix='decoder_lstm'):
n_x = options['n_x']
n_h = options['n_h']
W = np.concatenate([
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h)
],
axis=1)
params[_p(prefix, 'W')] = W
U = np.concatenate([
ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h)
],
axis=1)
params[_p(prefix, 'U')] = U
params[_p(prefix, 'b')] = zero_bias(4 * n_h)
params[_p(prefix, 'b')][n_h:2 * n_h] = 3 * np.ones(
(n_h, )).astype(theano.config.floatX)
return params
def param_init_encoder(options, params, prefix='lstm_encoder'):
n_x = options['n_x']
n_h = options['n_h']
W = np.concatenate([uniform_weight(n_x,n_h),
uniform_weight(n_x,n_h),
uniform_weight(n_x,n_h),
uniform_weight(n_x,n_h)], axis=1)
params[_p(prefix, 'W')] = W
U = np.concatenate([ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h)], axis=1)
params[_p(prefix, 'U')] = U
params[_p(prefix,'b')] = zero_bias(4*n_h)
# It is observed that setting a high initial forget gate bias for LSTMs can
# give slighly better results (Le et al., 2015). Hence, the initial forget
# gate bias is set to 3.
params[_p(prefix, 'b')][n_h:2*n_h] = 3*np.ones((n_h,)).astype(theano.config.floatX)
return params
def init_params(options, W):
n_words = options['n_words']
n_x = options['n_x']
n_h = options['n_h']
n_z = options['n_z']
n_s = options['n_s']
params = OrderedDict()
# word embedding init or load
# params['Wemb'] = uniform_weight(n_words,n_x)
params['Wemb'] = W.astype(config.floatX)
options[_p('lstm', 'n_x')] = n_x
options[_p('lstm', 'n_h')] = n_h
options[_p('lstm', 'n_g')] = n_s
params = param_init_lstm(options, params, 'lstm')
params['Vhid'] = uniform_weight(n_h, n_x)
params['bhid'] = zero_bias(n_words)
params['bos'] = zero_bias(n_x)
params['Tv'] = uniform_weight(n_z, n_h)
params['Ts'] = uniform_weight(n_x, n_h)
params['Ta'] = uniform_weight(n_s, n_h)
#re-z
params['task_W'] = uniform_weight(n_h, n_z)
params['task_b'] = zero_bias(n_z)
return params
def init_params(options):
n_chars = options['n_chars']
n_h = options['n_h']
params = OrderedDict()
# character embedding
params['W1'] = uniform_weight(n_chars, n_h)
params['b1'] = zero_bias(n_h)
params['W2'] = uniform_weight(n_h, n_h)
params['b2'] = zero_bias(n_h)
return params
def init_params(options):
n_y = options['n_y']
n_z = options['n_z']
params = OrderedDict()
params['Wy1'] = uniform_weight(n_z, 512)
params['by1'] = zero_bias(512)
params['Wy2'] = uniform_weight(512, n_y)
params['by2'] = zero_bias(n_y)
return params
def LSTM(input_x, rnn_size,
batch_size): #input(batch_size, steps, embedding_size)
num_steps = int(input_x.get_shape()[1])
embedding_size = int(input_x.get_shape()[2])
#define parameter
W = tf.get_variable("W",
initializer=tf.concat(1, [
uniform_weight(embedding_size, rnn_size),
uniform_weight(embedding_size, rnn_size)
]))
U = tf.get_variable(
"U",
initializer=tf.concat(1,
[ortho_weight(rnn_size),
ortho_weight(rnn_size)]))
b = tf.get_variable("b", initializer=tf.zeros([2 * rnn_size]))
Wx = tf.get_variable("Wx",
initializer=uniform_weight(embedding_size, rnn_size))
Ux = tf.get_variable("Ux", initializer=ortho_weight(rnn_size))
bx = tf.get_variable("bx", initializer=tf.zeros([rnn_size]))
h_ = tf.zeros([batch_size, rnn_size])
one = tf.fill([batch_size, rnn_size], 1.)
state_below = tf.transpose(tf.batch_matmul(
input_x,
tf.tile(tf.reshape(W, [1, embedding_size, 2 * rnn_size]),
[batch_size, 1, 1])) + b,
perm=[1, 0, 2])
state_belowx = tf.transpose(tf.batch_matmul(
input_x,
tf.tile(tf.reshape(Wx, [1, embedding_size, rnn_size]),
[batch_size, 1, 1])) + bx,
perm=[1, 0, 2]) #(steps, batch_size, rnn_size)
output = [] #(steps, batch_size, rnn_size)
with tf.variable_scope("GRU"):
for time_step in range(num_steps):
preact = tf.matmul(h_, U)
preact = tf.add(preact, state_below[time_step])
r = tf.nn.sigmoid(_slice(preact, 0, rnn_size))
u = tf.nn.sigmoid(_slice(preact, 1, rnn_size))
preactx = tf.matmul(h_, Ux)
preactx = tf.mul(preactx, r)
preactx = tf.add(preactx, state_belowx[time_step])
h = tf.tanh(preactx)
h_ = tf.add(tf.mul(u, h_), tf.mul(tf.sub(one, u), h))
output.append(h_)
output = tf.transpose(output, perm=[1, 0, 2])
return output #(batch_size, steps, rnn_size)
def _init_gru(in_dim, hid_dim, prefix_):
param[prefix_ + '_W'] = numpy.concatenate(
[uniform_weight(in_dim, hid_dim),
uniform_weight(in_dim, hid_dim)],
axis=1)
param[prefix_ + '_Wx'] = uniform_weight(in_dim, hid_dim)
param[prefix_ + '_U'] = numpy.concatenate(
[ortho_weight(hid_dim),
ortho_weight(hid_dim)], axis=1)
param[prefix_ + '_b'] = zero_vector(2 * hid_dim)
param[prefix_ + '_Ux'] = ortho_weight(hid_dim)
param[prefix_ + '_bx'] = zero_vector(hid_dim)
def param_init_gru(options, param, prefix='gru', nin=None, dim=None):
param[prefix + '_W'] = numpy.concatenate(
[uniform_weight(nin, dim),
uniform_weight(nin, dim)], axis=1)
param[prefix + '_U'] = numpy.concatenate(
[ortho_weight(dim), ortho_weight(dim)], axis=1)
param[prefix + '_b'] = zero_vector(2 * dim)
param[prefix + '_Wx'] = uniform_weight(nin, dim)
param[prefix + '_Ux'] = ortho_weight(dim)
param[prefix + '_bx'] = zero_vector(dim)
return param
def evaluateOneEpoch(inputCoor, inputGraph, inputLabel, para, sess, trainOperaion):
test_loss = []
test_acc = []
test_predict = []
for i in range(len(inputCoor)):
xTest, graphTest, labelTest = inputCoor[i], inputGraph[i], inputLabel[i]
graphTest = graphTest.tocsr()
labelBinarize = label_binarize(labelTest, classes=[i for i in range(para.outputClassN)])
test_batch_size = para.testBatchSize
for testBatchID in range(len(labelTest) / test_batch_size):
start = testBatchID * test_batch_size
end = start + test_batch_size
batchCoor, batchGraph, batchLabel = get_mini_batch(xTest, graphTest, labelBinarize, start, end)
batchWeight = uniform_weight(batchLabel)
batchGraph = batchGraph.todense()
feed_dict = {trainOperaion['inputPC']: batchCoor, trainOperaion['inputGraph']: batchGraph,
trainOperaion['outputLabel']: batchLabel, trainOperaion['weights']: batchWeight,
trainOperaion['keep_prob_1']: 1.0, trainOperaion['keep_prob_2']: 1.0}
predict, loss_test, acc_test = sess.run(
[trainOperaion['predictLabels'], trainOperaion['loss'], trainOperaion['acc']], feed_dict=feed_dict)
test_loss.append(loss_test)
test_acc.append(acc_test)
test_predict.append(predict)
test_average_loss = np.mean(test_loss)
test_average_acc = np.mean(test_acc)
return test_average_loss, test_average_acc, test_predict
def init_params(options):
n_words = options['n_words']
n_x = options['n_x']
n_h = options['n_h']
params = OrderedDict()
params['Wemb'] = uniform_weight(n_words, n_x)
params = param_init_decoder(options, params, prefix='decoder_h1')
options['n_x'] = n_h
params = param_init_decoder(options, params, prefix='decoder_h2')
options['n_x'] = n_x
params['Vhid'] = uniform_weight(n_h, n_words)
params['bhid'] = zero_bias(n_words)
return params
def param_init_gru(options, param, prefix='gru', nin=None, dim=None):
param[prefix + '_W'] = numpy.concatenate(
[
uniform_weight(nin, dim), uniform_weight(nin, dim)
],
axis=1)
param[prefix + '_U'] = numpy.concatenate(
[
ortho_weight(dim), ortho_weight(dim)
],
axis=1)
param[prefix + '_b'] = zero_vector(2 * dim)
param[prefix + '_Wx'] = uniform_weight(nin, dim)
param[prefix + '_Ux'] = ortho_weight(dim)
param[prefix + '_bx'] = zero_vector(dim)
return param
def init_params(options, W):
n_words = options['n_words']
n_x = options['n_x']
n_h = options['n_h']
n_z = options['n_z']
params = OrderedDict()
# word embedding
# params['Wemb'] = uniform_weight(n_words,n_x)
params['Wemb'] = W.astype(config.floatX)
params = param_init_encoder(options, params)
params['Vhid'] = uniform_weight(n_h, n_x)
params['bhid'] = zero_bias(n_words)
params['C0'] = uniform_weight(n_z, n_x)
return params
def trainOneEpoch(inputCoor, inputGraph, inputLabel, para, sess, trainOperaion, weight_dict, learningRate):
dataChunkLoss = []
dataChunkAcc = []
dataChunkRegLoss = []
for i in range(len(inputCoor)):
xTrain_1, graphTrain_1, labelTrain_1 = inputCoor[i], inputGraph[i], inputLabel[i]
graphTrain_1 = graphTrain_1.tocsr()
labelBinarize = label_binarize(labelTrain_1, classes=[j for j in range(para.outputClassN)])
xTrain, graphTrain, labelTrain = shuffle(xTrain_1, graphTrain_1, labelBinarize)
# labelBinarize = label_binarize(labelTrain, classes=[j for j in range(40)])
batch_loss = []
batch_acc = []
batch_reg = []
batchSize = para.batchSize
for batchID in range(len(labelBinarize) / para.batchSize):
start = batchID * batchSize
end = start + batchSize
batchCoor, batchGraph, batchLabel = get_mini_batch(xTrain, graphTrain, labelTrain, start, end)
batchGraph = batchGraph.todense()
batchCoor = add_noise(batchCoor, sigma=0.008, clip=0.02)
if para.weighting_scheme == 'uniform':
batchWeight = uniform_weight(batchLabel)
elif para.weighting_scheme == 'weighted':
batchWeight = weights_calculation(batchLabel, weight_dict)
else:
print 'please enter the valid weighting scheme'
#print batchWeight
feed_dict = {trainOperaion['inputPC']: batchCoor, trainOperaion['inputGraph']: batchGraph,
trainOperaion['outputLabel']: batchLabel, trainOperaion['lr']: learningRate,
trainOperaion['weights']: batchWeight,
trainOperaion['keep_prob_1']: para.keep_prob_1, trainOperaion['keep_prob_2']: para.keep_prob_2}
opt, loss_train, acc_train, loss_reg_train = sess.run(
[trainOperaion['train'], trainOperaion['loss_total'], trainOperaion['acc'], trainOperaion['loss_reg']],
feed_dict=feed_dict)
#print('The loss loss_reg and acc for this batch is {},{} and {}'.format(loss_train, loss_reg_train, acc_train))
batch_loss.append(loss_train)
batch_acc.append(acc_train)
batch_reg.append(loss_reg_train)
dataChunkLoss.append(np.mean(batch_loss))
dataChunkAcc.append(np.mean(batch_acc))
dataChunkRegLoss.append(np.mean(batch_reg))
train_average_loss = np.mean(dataChunkLoss)
train_average_acc = np.mean(dataChunkAcc)
loss_reg_average = np.mean(dataChunkRegLoss)
return train_average_loss, train_average_acc, loss_reg_average
def param_init_fflayer(options,
param,
prefix='ff',
nin=None,
nout=None,
ortho=True):
param[prefix + '_W'] = uniform_weight(nin, nout)
param[prefix + '_b'] = zero_vector(nout)
return param
def param_init_fflayer(options,
param,
prefix='ff',
nin=None,
nout=None,
ortho=True):
param[prefix + '_W'] = uniform_weight(nin, nout)
param[prefix + '_b'] = zero_vector(nout)
return param
def param_init_gru_cond(options,
param,
prefix='gru_cond',
nin=None,
dim=None,
dimctx=None,
nin_nonlin=None,
dim_nonlin=None):
if nin_nonlin is None:
nin_nonlin = nin
if dim_nonlin is None:
dim_nonlin = dim
param = param_init_gru(options, param, prefix=prefix, nin=nin, dim=dim)
param[prefix + '_U_nl'] = numpy.concatenate(
[ortho_weight(dim_nonlin),
ortho_weight(dim_nonlin)], axis=1)
param[prefix + '_b_nl'] = zero_vector(2 * dim_nonlin)
param[prefix + '_Ux_nl'] = ortho_weight(dim_nonlin)
param[prefix + '_bx_nl'] = zero_vector(dim_nonlin)
# context to LSTM
param[prefix + '_Wc'] = uniform_weight(dimctx, dim * 2)
param[prefix + '_Wcx'] = uniform_weight(dimctx, dim)
# attention: combined -> hidden
param[prefix + '_W_comb_att'] = uniform_weight(dim, dimctx)
# attention: context -> hidden
param[prefix + '_Wc_att'] = uniform_weight(dimctx, dimctx)
# attention: hidden bias
param[prefix + '_b_att'] = zero_vector(dimctx)
# attention:
param[prefix + '_U_att'] = uniform_weight(dimctx, 1)
param[prefix + '_c_att'] = zero_vector(1)
return param
def init_params(options):
n_x = options['n_x']
n_h = options['n_h']
params = OrderedDict()
params = param_init_decoder(options,params)
params['Vhid'] = uniform_weight(n_h,n_x)
params['bhid'] = zero_bias(n_x)
return params
def param_init_decoder(options, params, prefix='decoder'):
n_x = options['n_x']
n_h = options['n_h']
n_z = options['n_z']
W = np.concatenate([
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h),
uniform_weight(n_x, n_h)
],
axis=1)
params[_p(prefix, 'W')] = W
U = np.concatenate([
ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h),
ortho_weight(n_h)
],
axis=1)
params[_p(prefix, 'U')] = U
C = np.concatenate([
uniform_weight(n_z, n_h),
uniform_weight(n_z, n_h),
uniform_weight(n_z, n_h),
uniform_weight(n_z, n_h)
],
axis=1)
params[_p(prefix, 'C')] = C
params[_p(prefix, 'b')] = zero_bias(4 * n_h)
params[_p(prefix, 'b')][n_h:2 * n_h] = 3 * np.ones(
(n_h, )).astype(theano.config.floatX)
C0 = uniform_weight(n_z, n_h)
params[_p(prefix, 'C0')] = C0
params[_p(prefix, 'b0')] = zero_bias(n_h)
#params[_p(prefix,'b_y')] = zero_bias(n_x) # 48
return params
def param_init_gru_cond(options,
param,
prefix='gru_cond',
nin=None,
dim=None,
dimctx=None):
assert type(dim) is list
last_dim = dim[-1]
param = param_init_gru(options, param, prefix=prefix, nin=nin, dim=dim)
prefix_ = prefix + '_%d' % (len(dim) - 1)
# context to LSTM
param[prefix_ + '_Wc'] = numpy.concatenate(
[uniform_weight(dimctx, last_dim),
uniform_weight(dimctx, last_dim)],
axis=1)
param[prefix_ + '_Wcx'] = uniform_weight(dimctx, last_dim)
# attention: combined -> hidden
param[prefix_ + '_W_comb_att'] = uniform_weight(last_dim, dimctx)
# attention: context -> hidden
param[prefix_ + '_Wc_att'] = uniform_weight(dimctx, dimctx)
# attention: hidden bias
param[prefix_ + '_b_att'] = zero_vector(dimctx)
# attention:
param[prefix_ + '_U_att'] = uniform_weight(dimctx, 1)
return param
def init_params(options):
n_chars = options['n_chars']
n_x = options['n_x']
params = OrderedDict()
# character embedding
params['Wemb'] = uniform_weight(n_chars, n_x)
# encoding characters into words
params = param_init_encoder(options, params, prefix='encoder_f')
params = param_init_encoder(options, params, prefix='encoder_b')
return params
def init_params(options):
n_chars = options['n_chars']
img_w = options['img_w']
params = OrderedDict()
# character embedding
params['Wemb'] = uniform_weight(n_chars,img_w)
# encoding characters into words
length = len(options['filter_shapes'])
for idx in range(length):
params = param_init_encoder(options['filter_shapes'][idx],params,prefix=_p('cnn_encoder',idx))
return params
def param_init_decoder(options, params, prefix='decoder_vanilla'):
n_x = options['n_x']
n_h = options['n_h']
W = uniform_weight(n_x, n_h)
params[_p(prefix, 'W')] = W
U = ortho_weight(n_h)
params[_p(prefix, 'U')] = U
params[_p(prefix, 'b')] = zero_bias(n_h)
return params
def init_params(options):
n_words = options['n_words']
n_x = options['n_x']
n_h = options['n_h']
params = OrderedDict()
# word embedding
params['Wemb'] = uniform_weight(n_words,n_x)
#params['Wemb'] = W.astype(config.floatX)
params['Wemb'][-1] = np.zeros((n_x,)).astype(theano.config.floatX)
# encoding words into sentences
length = len(options['filter_shapes'])
for idx in range(length):
params = param_init_encoder(options['filter_shapes'][idx],params,prefix=_p('cnn_encoder',idx))
options['n_z'] = options['feature_maps'] * length
params = param_init_decoder(options,params,prefix='decoder')
params['Vhid'] = uniform_weight(n_h,n_x)
params['bhid'] = zero_bias(n_words)
return params
def param_init_fflayer(options,
param,
prefix='ff',
nin=None,
nout=None,
ortho=True):
if type(nin) is int and type(nout) is int:
param[prefix + '_W'] = uniform_weight(nin, nout)
param[prefix + '_b'] = zero_vector(nout)
else:
assert type(nout) is list
if type(nin) is int:
nin = [nin] + nout[:-1]
elif type(nin) is list:
assert len(nin) == len(nout)
for l, (in_dim, out_dim) in enumerate(zip(nin, nout)):
prefix_ = prefix + '_%d' % l
param[prefix_ + '_W'] = uniform_weight(in_dim, out_dim)
param[prefix_ + '_b'] = zero_vector(out_dim)
return param
def evaluateOneEpoch(inputCoor, inputGraph, inputLabel, para, sess, trainOperaion):
# Description: Performance on the test set data
# Input: (1)inputCoor: input coordinates (B, N, 3) (2) inputGraph: input graph (B, N*N) (3) inputLabel: labels (B, 1)
# (4) para: global Parameters (5) sess: Session (6) trainOperaion: placeholder dictionary
# Return: average loss, acc, regularization loss for test set
test_loss = []
test_acc = []
test_predict = []
for i in range(len(inputCoor)):
xTest, graphTest, labelTest = inputCoor[i], inputGraph[i], inputLabel[i]
graphTest = graphTest.tocsr()
labelBinarize = label_binarize(labelTest, classes=[j for j in range(40)])
test_batch_size = para.testBatchSize
for testBatchID in range(len(labelTest) / test_batch_size):
start = testBatchID * test_batch_size
end = start + test_batch_size
batchCoor, batchGraph, batchLabel = get_mini_batch(xTest, graphTest, labelBinarize, start, end)
batchWeight = uniform_weight(batchLabel)
batchGraph = batchGraph.todense()
batchIndexL1, centroid_coordinates = farthest_sampling_new(batchCoor, M=para.clusterNumberL1,
k=para.nearestNeighborL1, batch_size=test_batch_size,
nodes_n=para.pointNumber)
batchMiddleGraph = middle_graph_generation(centroid_coordinates, batch_size = test_batch_size, M = para.clusterNumberL1)
feed_dict = {trainOperaion['inputPC']: batchCoor, trainOperaion['inputGraph']: batchGraph,
trainOperaion['outputLabel']: batchLabel, trainOperaion['weights']: batchWeight,
trainOperaion['keep_prob_1']: 1.0, trainOperaion['keep_prob_2']: 1.0,
trainOperaion['batch_index_l1']: batchIndexL1,
trainOperaion['l2Graph']: batchMiddleGraph, trainOperaion['batch_size']: test_batch_size
}
predict, loss_test, acc_test = sess.run(
[trainOperaion['predictLabels'], trainOperaion['loss'], trainOperaion['acc']], feed_dict=feed_dict)
test_loss.append(loss_test)
test_acc.append(acc_test)
test_predict.append(predict)
test_average_loss = np.mean(test_loss)
test_average_acc = np.mean(test_acc)
return test_average_loss, test_average_acc, test_predict
def evaluateOneEpoch(inputCoor, inputGraph, inputLabel, para, sess, trainOperaion):
# Description: Performance on the test set data
# Input: (1)inputCoor: input coordinates (B, N, 3) (2) inputGraph: input graph (B, N*N) (3) inputLabel: labels (B, 1)
# (4) para: global Parameters (5) sess: Session (6) trainOperaion: placeholder dictionary
# Return: average loss, acc, regularization loss for test set
test_loss = []
test_acc = []
test_predict = []
for i in range(len(inputCoor)):
xTest, graphTest, labelTest = inputCoor[i], inputGraph[i], inputLabel[i]
graphTest = graphTest.tocsr()
labelBinarize = label_binarize(labelTest, classes=[j for j in range(40)])
test_batch_size = para.testBatchSize
for testBatchID in range(len(labelTest) / test_batch_size):
start = testBatchID * test_batch_size
end = start + test_batch_size
batchCoor, batchGraph, batchLabel = get_mini_batch(xTest, graphTest, labelBinarize, start, end)
batchWeight = uniform_weight(batchLabel)
batchGraph = batchGraph.todense()
# select the centroid points by farthest sampling and get the index of each centroid points n nearest neighbors
batchIndexL1, centroid_coordinates = farthest_sampling(batchCoor, M=para.clusterNumberL1,
k=para.nearestNeighborL1, batch_size=test_batch_size,
nodes_n=para.pointNumber)
batchMiddleGraph = middle_graph_generation(centroid_coordinates, batch_size = test_batch_size, M = para.clusterNumberL1)
feed_dict = {trainOperaion['inputPC']: batchCoor, trainOperaion['inputGraph']: batchGraph,
trainOperaion['outputLabel']: batchLabel, trainOperaion['weights']: batchWeight,
trainOperaion['keep_prob_1']: 1.0, trainOperaion['keep_prob_2']: 1.0,
trainOperaion['batch_index_l1']: batchIndexL1,
trainOperaion['l2Graph']: batchMiddleGraph, trainOperaion['batch_size']: test_batch_size
}
predict, loss_test, acc_test = sess.run(
[trainOperaion['predictLabels'], trainOperaion['loss'], trainOperaion['acc']], feed_dict=feed_dict)
test_loss.append(loss_test)
test_acc.append(acc_test)
test_predict.append(predict)
test_average_loss = np.mean(test_loss)
test_average_acc = np.mean(test_acc)
return test_average_loss, test_average_acc, test_predict
def init_params(options,W):
params = OrderedDict()
# W is initialized by the pretrained word embedding
params['Wemb'] = W.astype(config.floatX)
# otherwise, W will be initialized randomly
# n_words = options['n_words']
# n_x = options['n_x']
# params['Wemb'] = uniform_weight(n_words,n_x)
length = len(options['filter_shapes'])
for idx in range(length):
params = param_init_encoder(options['filter_shapes'][idx],params,prefix=_p('cnn_encoder',idx))
n_h = options['feature_maps'] * length
params['Wy'] = uniform_weight(n_h,options['n_y'])
params['by'] = zero_bias(options['n_y'])
return params
def init_params(options, W):
params = OrderedDict()
# W is initialized by the pretrained word embedding
params['Wemb'] = W.astype(config.floatX)
# otherwise, W will be initialized randomly
# n_words = options['n_words']
# n_x = options['n_x']
# params['Wemb'] = uniform_weight(n_words,n_x)
length = len(options['filter_shapes'])
for idx in range(length):
params = param_init_encoder(options['filter_shapes'][idx],
params,
prefix=_p('cnn_encoder', idx))
n_h = options['feature_maps'] * length
params['Wy'] = uniform_weight(n_h, options['n_y'])
params['by'] = zero_bias(options['n_y'])
return params
def init_params(options,W):
n_h = options['n_h']
n_y = options['n_y']
params = OrderedDict()
# W is initialized by the pretrained word embedding
params['Wemb'] = W.astype(config.floatX)
# otherwise, W will be initialized randomly
# n_words = options['n_words']
# n_x = options['n_x']
# params['Wemb'] = uniform_weight(n_words,n_x)
# bidirectional LSTM
params = param_init_encoder(options,params,prefix="lstm_encoder")
params = param_init_encoder(options,params,prefix="lstm_encoder_rev")
params['Wy'] = uniform_weight(2*n_h,n_y)
params['by'] = zero_bias(n_y)
return params
def train_one_epoch(input_pc, input_graph, input_label, hyperparameters, sess,
train_operation, weight_dict, learning_rate):
batch_loss = []
batch_accuracy = []
batch_reg_loss = []
minibatch_size = hyperparameters.minibatch_size
for minibatch_id in range(len(input_pc) / minibatch_size):
start = minibatch_id * minibatch_size
end = start + minibatch_size
minibatch_coords, minibatch_graph, minibatch_label = input_pc[
start:end], input_graph[start:end], input_label[start:label]
minibatch_weight = utils.uniform_weight(minibatch_label)
minibatch_graph = minibatch_graph.todense()
feed_dict = {
train_operation['input_pc']: minibatch_coords,
train_operation['input_graph']: minibatch_graph,
train_operation['output_label']: minibatch_label,
train_operation['learning_rate']: learning_rate,
train_operation['weights']: minibatch_weight,
train_operation['keep_prob_1']: hyperparameters.keep_prob_1,
train_operation['keep_prob_2']: hyperparameters.keep_prob_2
}
train_opt, train_loss, train_accuracy, train_reg_loss = sess.run(
[
train_operation['train'], train_operation['loss'],
train_operation['accuracy'], train_operation['loss_reg']
],
feed_dict=feed_dict)
batch_loss.append(train_loss)
batch_accuracy.append(train_accuracy)
batch_reg_loss.append(train_reg_loss)
train_average_loss = np.mean(batch_loss)
train_average_accuracy = np.mean(batch_accuracy)
train_average_reg_loss = np.mean(batch_reg_loss)
return train_average_loss, train_average_accuracy, train_average_reg_loss
def init_params(options, W):
n_p = options['n_p']
n_h = options['n_h']
n_y = options['n_y']
params = OrderedDict()
# W is initialized by the pretrained word embedding
params['Wemb'] = W.astype(config.floatX)
# otherwise, W will be initialized randomly
# n_words = options['n_words']
# n_x = options['n_x']
# params['Wemb'] = uniform_weight(n_words,n_x)
# bidirectional LSTM
#params = param_init_encoder(options,params, prefix="lstm_encoder")
#params = param_init_encoder(options,params, prefix="lstm_encoder_rev")
params = param_init_encoder(options, params, prefix="gru_encoder")
params = param_init_encoder(options, params, prefix="gru_encoder_rev")
#params['Wy'] = uniform_weight(n_p, 2*n_h+1, scale=0.1)
params['Wy'] = np.squeeze(uniform_weight(n_p, 2 * n_h, 1))
return params
def evaluate_one_epoch(input_pc, input_graph, input_label, hyperparameters,
sess, train_operation):
test_loss = []
test_accuracy = []
test_predictions = []
minibatch_size = hyperparameters.minibatch_size
for minibatch_id in range(len(input_pc) / minibatch_size):
start = minibatch_id * minibatch_size
end = start + minibatch_size
minibatch_coords, minibatch_graph, minibatch_label = input_pc[
start:end], input_graph[start:end], input_label[start:label]
minibatch_weight = utils.uniform_weight(minibatch_label)
minibatch_graph = minibatch_graph.todense()
feed_dict = {
train_operation['input_pc']: minibatch_coords,
train_operation['input_graph']: minibatch_graph,
train_operation['output_label']: minibatch_label,
train_operation['weights']: minibatch_weight,
train_operation['keep_prob_1']: 1.0,
train_operation['keep_prob_2']: 1.0
}
predictions, loss, accuracy = sess.run([
train_operation['predict_label'], train_operation['loss'],
train_operation['accuracy']
],
feed_dict=feed_dict)
test_loss.append(loss)
test_accuracy.append(accuracy)
test_predictions.append(predictions)
test_average_loss = np.mean(test_loss)
test_average_accuracy = np.mean(test_accuracy)
return test_average_loss, test_average_accuracy, test_predictions
def trainOneEpoch(inputCoor, inputGraph, inputLabel, para, sess, trainOperaion,
weight_dict, learningRate):
# Description: training one epoch (two options to train the model, using weighted gradient descent or normal gradient descent)
# Input: (1)inputCoor: input coordinates (B, N, 3) (2) inputGraph: input graph (B, N*N) (3) inputLabel: labels (B, 1)
# (4) para: global Parameters (5) sess: Session (6) trainOperaion: placeholder dictionary
# (7) weight_dict: weighting scheme used of weighted gradient descnet (8)learningRate: learning rate for current epoch
# Return: average loss, acc, regularization loss for training set
dataChunkLoss = []
dataChunkAcc = []
dataChunkRegLoss = []
for i in range(len(inputLabel)):
xTrain_1, graphTrain_1, labelTrain_1 = inputCoor[i], inputGraph[i], inputLabel[i]
graphTrain_1 = graphTrain_1.tocsr()
labelBinarize = label_binarize(labelTrain_1, classes=[j for j in range(40)])
xTrain, graphTrain, labelTrain = shuffle(xTrain_1, graphTrain_1, labelBinarize)
batch_loss = []
batch_acc = []
batch_reg = []
batchSize = para.batchSize
for batchID in range(len(labelBinarize) / para.batchSize):
start = batchID * batchSize
end = start + batchSize
batchCoor, batchGraph, batchLabel = get_mini_batch(xTrain, graphTrain, labelTrain, start, end)
batchGraph = batchGraph.todense()
batchCoor = add_noise(batchCoor, sigma=0.008, clip=0.02)
if para.weighting_scheme == 'uniform':
batchWeight = uniform_weight(batchLabel)
elif para.weighting_scheme == 'weighted':
batchWeight = weights_calculation(batchLabel, weight_dict)
else:
print 'please enter a valid weighting scheme'
batchIndexL1, centroid_coordinates = farthest_sampling_new(batchCoor, M=para.clusterNumberL1,
k=para.nearestNeighborL1, batch_size=batchSize,
nodes_n=para.pointNumber)
batchMiddleGraph = middle_graph_generation(centroid_coordinates, batch_size = batchSize, M = para.clusterNumberL1)
feed_dict = {trainOperaion['inputPC']: batchCoor, trainOperaion['inputGraph']: batchGraph,
trainOperaion['outputLabel']: batchLabel, trainOperaion['lr']: learningRate,
trainOperaion['weights']: batchWeight,
trainOperaion['keep_prob_1']: para.keep_prob_1, trainOperaion['keep_prob_2']: para.keep_prob_2,
trainOperaion['batch_index_l1']: batchIndexL1,
trainOperaion['l2Graph']: batchMiddleGraph, trainOperaion['batch_size']: para.batchSize}
opt, loss_train, acc_train, loss_reg_train = sess.run(
[trainOperaion['train'], trainOperaion['loss_total'], trainOperaion['acc'], trainOperaion['loss_reg']],
feed_dict=feed_dict)
batch_loss.append(loss_train)
batch_acc.append(acc_train)
batch_reg.append(loss_reg_train)
#print "The loss, L2 loss and acc for this batch is {}, {} and {}".format(loss_train, loss_reg_train, acc_train)
dataChunkLoss.append(np.mean(batch_loss))
dataChunkAcc.append(np.mean(batch_acc))
dataChunkRegLoss.append(np.mean(batch_reg))
train_average_loss = np.mean(dataChunkLoss)
train_average_acc = np.mean(dataChunkAcc)
loss_reg_average = np.mean(dataChunkRegLoss)
return train_average_loss, train_average_acc, loss_reg_average