def test_case_0(in_dim=1, out_dim=1):
import numpy as np
from lasagne_ext.utils import get_layer_by_name
model_D = build_model_D(in_dim=in_dim, out_dim=out_dim)
model_L = build_model_L(in_dim=in_dim, out_dim=out_dim)
W = np.random.rand(in_dim, out_dim).astype(np.float32)
b = np.random.rand(out_dim).astype(np.float32)
model_D.dense.W.set_value(W)
model_D.dense.b.set_value(b)
get_layer_by_name(model_L, 'dense0').W.set_value(W)
get_layer_by_name(model_L, 'dense0').b.set_value(b)
X = get_layer_by_name(model_L, 'input0').input_var
y_D = model_D.forward(X)
y_L = get_output(model_L)
fn_D = theano.function([X], y_D, no_default_updates=True)
fn_L = theano.function([X], y_L, no_default_updates=True)
for i in range(20):
x = np.random.rand(16, in_dim).astype(np.float32)
y_D = fn_D(x)
y_L = fn_L(x)
diff = np.sum(np.abs(y_D - y_L))
print('i=%d, diff=%0.6f' % (i, diff))
if diff > 1e-4:
raise ValueError('diff is too big')
def test_case_0():
import numpy as np
from lasagne_ext.utils import get_layer_by_name
in_channel = 1
out_channel = 3
kernel_size = (3, 3)
stride = (1, 1)
pad = 'valid'
dilation = (1, 1)
num_groups = 1
model_D = build_model_D(in_channel=in_channel,
out_channel=out_channel,
kernel_size=kernel_size,
stride=stride,
pad=pad,
dilation=dilation,
num_groups=num_groups)
model_L = build_model_L(in_channel=in_channel,
out_channel=out_channel,
kernel_size=kernel_size,
stride=stride,
pad=pad)
W = np.random.rand(out_channel, in_channel, kernel_size[0],
kernel_size[1]).astype(np.float32)
b = np.random.rand(out_channel).astype(np.float32)
model_D.conv2d.W.set_value(W)
model_D.conv2d.b.set_value(b)
conv_L = get_layer_by_name(model_L, 'conv0')
conv_L.W.set_value(W)
conv_L.b.set_value(b)
X = get_layer_by_name(model_L, 'input0').input_var
y_D = model_D.forward(X)
y_L = get_output(model_L)
fn_D = theano.function([X],
y_D,
no_default_updates=True,
on_unused_input='ignore')
fn_L = theano.function([X],
y_L,
no_default_updates=True,
on_unused_input='ignore')
for i in range(20):
x = np.random.rand(3, in_channel, 32, 32).astype(np.float32) - 0.5
y_D = fn_D(x)
y_L = fn_L(x)
diff = np.max(np.abs(y_D - y_L))
print('i=%d, diff=%0.6f' % (i, diff))
if diff > 1e-4:
print('y_D=\n', y_D)
print('y_L=\n', y_L)
raise ValueError('diff is too big')
def test_case_0():
import numpy as np
from lasagne_ext.utils import get_layer_by_name
in_dim, out_dim = 6, 5
model_D = build_model_D(in_dim=in_dim, out_dim=out_dim)
model_L = build_model_L(in_dim=in_dim, out_dim=out_dim)
W_in = np.random.rand(in_dim, 3 * out_dim).astype(np.float32)
b_in = np.random.rand(3 * out_dim).astype(np.float32)
W_hid = np.random.rand(out_dim, 3 * out_dim).astype(np.float32)
h_ini = np.random.rand(out_dim).astype(np.float32)
model_D.gru.W_in.set_value(W_in)
model_D.gru.b_in.set_value(b_in)
model_D.gru.W_hid.set_value(W_hid)
model_D.gru.h_ini.set_value(h_ini)
gru_L = get_layer_by_name(model_L, 'gru0')
gru_L.W_in_to_resetgate.set_value(W_in[:, :out_dim])
gru_L.W_in_to_updategate.set_value(W_in[:, out_dim:2 * out_dim])
gru_L.W_in_to_hidden_update.set_value(W_in[:, 2 * out_dim:3 * out_dim])
gru_L.W_hid_to_resetgate.set_value(W_hid[:, :out_dim])
gru_L.W_hid_to_updategate.set_value(W_hid[:, out_dim:2 * out_dim])
gru_L.W_hid_to_hidden_update.set_value(W_hid[:, 2 * out_dim:3 * out_dim])
gru_L.b_resetgate.set_value(b_in[:out_dim])
gru_L.b_updategate.set_value(b_in[out_dim:2 * out_dim])
gru_L.b_hidden_update.set_value(b_in[2 * out_dim:3 * out_dim])
gru_L.hid_init.set_value(h_ini.reshape((1, out_dim)))
X = get_layer_by_name(model_L, 'input0').input_var
y_D = model_D.forward(X)
y_L = get_output(model_L)
fn_D = theano.function([X],
y_D,
no_default_updates=True,
on_unused_input='ignore')
fn_L = theano.function([X],
y_L,
no_default_updates=True,
on_unused_input='ignore')
for i in range(20):
x = np.random.rand(2, 5, in_dim).astype(np.float32) - 0.5
y_D = fn_D(x)
y_L = fn_L(x)
diff = np.max(np.abs(y_D - y_L))
print('i=%d, diff=%0.6f' % (i, diff))
if diff > 1e-4:
print('y_D=\n', y_D)
print('y_L=\n', y_L)
raise ValueError('diff is too big')
def test_case_1():
import numpy as np
from lasagne_ext.utils import get_layer_by_name
np.random.seed(0)
pyramid_dims = [4]
model_D = build_model_D_1(pyramid_dims=pyramid_dims)
model_L = build_model_L_1(pyramid_dims=pyramid_dims)
X = get_layer_by_name(model_L, 'input0').input_var
y_D = model_D.forward(X)
# y_L = get_output(model_L)
fn_D = theano.function([X],
y_D,
no_default_updates=True,
on_unused_input='ignore')
# fn_L = theano.function([X], y_L, no_default_updates=True, on_unused_input='ignore')
x = np.array([[[[0.1, 0.2, 0.3], [0.4, 0.5, 0.6], [0.7, 0.8, 0.9]]]])
x = x.astype(np.float32)
# y = fn_L(x) # Lasagne will crash
y = fn_D(x)
y_expect = np.array([[[[0.1, 0.2, 0.3, 0.0], [0.4, 0.5, 0.6, 0.0],
[0.7, 0.8, 0.9, 0.0], [0.0, 0.0, 0.0, 0.0]]]])
y_expect = y_expect.astype(np.float32)
y_expect = y_expect.reshape((1, 1, -1))
diff = np.max(np.abs(y - y_expect))
print('diff=%0.6f' % diff)
if diff > 1e-4:
raise ValueError('diff is too big')
def test_case_0():
import numpy as np
from lasagne_ext.utils import get_layer_by_name
pyramid_dims = [3, 2, 1]
model_D = build_model_D(pyramid_dims=pyramid_dims)
model_L = build_model_L(pyramid_dims=pyramid_dims)
X = get_layer_by_name(model_L, 'input0').input_var
y_D = model_D.forward(X)
y_L = get_output(model_L)
fn_D = theano.function([X], y_D, no_default_updates=True, on_unused_input='ignore')
fn_L = theano.function([X], y_L, no_default_updates=True, on_unused_input='ignore')
for i in range(20):
B = np.random.randint(low=1, high=33)
C = np.random.randint(low=1, high=32)
H = np.random.randint(low=5, high=512)
W = np.random.randint(low=5, high=513)
x = np.random.rand(B, C, H, W).astype(np.float32) - 0.5
y_D = fn_D(x)
y_L = fn_L(x)
# print(y_D)
diff = np.max(np.abs(y_D - y_L))
print('i=%d, diff=%0.6f' % (i, diff))
if diff>1e-4:
print('y_D=\n', y_D)
print('y_L=\n', y_L)
raise ValueError('diff is too big')
def compile_lasagne_model(model):
"""
Compile the model train & predict functions
:param model:
:param fn_tags: list of function tags
:return:
"""
X_var = get_layer_by_name(model, 'input0').input_var
Y_var = lasa_layer.get_output(model, deterministic=True)
predict_fn = theano.function([X_var], Y_var, no_default_updates=True)
return predict_fn
def compile_model(model, fn_tags=('train', 'predict')):
"""
Compile the model train & predict functions
:param model:
:param fn_tags: list of function tags
:return:
"""
fns = []
for fn_tag in fn_tags:
if fn_tag == 'train':
X_var = get_layer_by_name(model, 'input0').input_var
Y_var = tensor.fmatrix('Y')
X_mask_var = tensor.fmatrix('X_mask')
Y_mask_var = tensor.fmatrix('Y_mask')
scorematrix = get_output(model)
loss = ctc_cost_logscale(Y_var, scorematrix, Y_mask_var,
X_mask_var)
resultseq, resultseq_mask = ctc_best_path_decode(
scorematrix, X_mask_var)
CER, TE, TG = ctc_CER(resultseq, Y_var.T, resultseq_mask,
Y_mask_var.T)
params = get_all_params(model, trainable=True)
updates = adadelta(loss, params)
train_fn = theano.function([X_var, Y_var, X_mask_var, Y_mask_var],
[loss, CER, TE, TG],
updates=updates)
fns.append(train_fn)
elif fn_tag == 'predict':
X_var = get_layer_by_name(model, 'input0').input_var
scorematrix_test = get_output(model, deterministic=True)
predict_fn = theano.function([X_var],
scorematrix_test,
no_default_updates=True)
fns.append(predict_fn)
else:
raise ValueError('fn_tag = %s not recognized' % fn_tag)
if len(fns) == 1:
return fns[0]
else:
return fns
def test_case_0():
import numpy as np
from lasagne_ext.utils import get_layer_by_name
B, C, H, W = 2, 1, 8, 8
input_shape = (None, C, H, W)
axes = 'auto'
model_D = build_model_D(input_shape=input_shape, axes=axes)
model_L = build_model_L(input_shape=input_shape, axes=axes)
X = get_layer_by_name(model_L, 'input0').input_var
#--- predict ---#
if 0:
y_D = model_D.predict(X)
y_L = get_output(model_L, deterministic=True)
fn_L = theano.function([X], y_L, no_default_updates=True)
fn_D = theano.function([X], y_D, no_default_updates=True)
#--- train ---#
if 1:
y_D = model_D.forward(X)
y_L = get_output(model_L, deterministic=False)
update_L = fix_update_bcasts(get_all_updates(model_L))
update_D = fix_update_bcasts(model_D.collect_self_updates())
fn_L = theano.function([X], y_L, updates=update_L, no_default_updates=True)
fn_D = theano.function([X],
y_D,
updates=update_D,
no_default_updates=False)
# fn_L = theano.function([X], y_L, no_default_updates=True)
# fn_D = theano.function([X], y_D, no_default_updates=True)
for i in range(20):
x = np.random.rand(B, C, H, W).astype(np.float32)
y_D = fn_D(x)
y_L = fn_L(x)
diff = np.sum(np.abs(y_D - y_L))
print('i=%d, diff=%0.6f' % (i, diff))
if diff > 1e-4:
print(y_D)
print(y_L)
raise ValueError('diff is too big')
print('test_case_0 passed')
def test_case_0():
import numpy as np
from lasagne_ext.utils import get_layer_by_name
in_dim, out_dim = 32, 3
model_D = build_model_D(in_dim=in_dim, out_dim=out_dim)
model_L = build_model_L(in_dim=in_dim, out_dim=out_dim)
W_in = np.random.rand(in_dim, 4 * out_dim).astype(np.float32)
b_in = np.random.rand(4 * out_dim).astype(np.float32)
W_hid = np.random.rand(out_dim, 4 * out_dim).astype(np.float32)
h_ini = np.random.rand(out_dim).astype(np.float32)
c_ini = np.random.rand(out_dim).astype(np.float32)
w_cell_to_igate = np.random.rand(out_dim).astype(np.float32)
w_cell_to_fgate = np.random.rand(out_dim).astype(np.float32)
w_cell_to_ogate = np.random.rand(out_dim).astype(np.float32)
model_D.lstm.W_in.set_value(W_in)
model_D.lstm.b_in.set_value(b_in)
model_D.lstm.W_hid.set_value(W_hid)
model_D.lstm.h_ini.set_value(h_ini)
model_D.lstm.c_ini.set_value(c_ini)
model_D.lstm.w_cell_to_igate.set_value(w_cell_to_igate)
model_D.lstm.w_cell_to_fgate.set_value(w_cell_to_fgate)
model_D.lstm.w_cell_to_ogate.set_value(w_cell_to_ogate)
lstm_L = get_layer_by_name(model_L, 'lstm0')
lstm_L.W_in_to_ingate.set_value(W_in[:, :out_dim])
lstm_L.W_in_to_forgetgate.set_value(W_in[:, out_dim:2 * out_dim])
lstm_L.W_in_to_cell.set_value(W_in[:, 2 * out_dim:3 * out_dim])
lstm_L.W_in_to_outgate.set_value(W_in[:, 3 * out_dim:])
lstm_L.W_hid_to_ingate.set_value(W_hid[:, :out_dim])
lstm_L.W_hid_to_forgetgate.set_value(W_hid[:, out_dim:2 * out_dim])
lstm_L.W_hid_to_cell.set_value(W_hid[:, 2 * out_dim:3 * out_dim])
lstm_L.W_hid_to_outgate.set_value(W_hid[:, 3 * out_dim:])
lstm_L.b_ingate.set_value(b_in[:out_dim])
lstm_L.b_forgetgate.set_value(b_in[out_dim:2 * out_dim])
lstm_L.b_cell.set_value(b_in[2 * out_dim:3 * out_dim])
lstm_L.b_outgate.set_value(b_in[3 * out_dim:])
lstm_L.hid_init.set_value(h_ini.reshape((1, out_dim)))
lstm_L.cell_init.set_value(c_ini.reshape((1, out_dim)))
lstm_L.W_cell_to_ingate.set_value(w_cell_to_igate)
lstm_L.W_cell_to_forgetgate.set_value(w_cell_to_fgate)
lstm_L.W_cell_to_outgate.set_value(w_cell_to_ogate)
X = get_layer_by_name(model_L, 'input0').input_var
y_D = model_D.forward(X)
y_L = get_output(model_L)
fn_D = theano.function([X],
y_D,
no_default_updates=True,
on_unused_input='ignore')
fn_L = theano.function([X],
y_L,
no_default_updates=True,
on_unused_input='ignore')
for i in range(20):
x = np.random.rand(4, 16, in_dim).astype(np.float32)
y_D = fn_D(x)
y_L = fn_L(x)
diff = np.max(np.abs(y_D - y_L))
print('i=%d, diff=%0.6f' % (i, diff))
if diff > 1e-4:
print('y_D=\n', y_D)
print('y_L=\n', y_L)
raise ValueError('diff is too big')
