def test_average_pooling_2d():
ksize = (2, 3)
stride = (1, 2)
pad = (0, 1)
inputs = [nnoir.Value(b'v0', np.zeros((2, 3, 4, 5)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((2, 3, 3, 3)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.AveragePooling2D(
input_names,
output_names,
kernel=list(ksize),
stride=list(stride),
pad_h=[pad[0], pad[0] + stride[0] - 1],
pad_w=[pad[1], pad[1] + stride[1] - 1],
count_exclude_pad=False)
result = nnoir.NNOIR(b'AveragePooling2D', b'nnoir2chainer_test', '0.1',
input_names, output_names, nodes, [function])
result.dump('average_pooling_2d.nnoir')
x = np.random.randn(2, 3, 4, 5).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('average_pooling_2d.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_max_pooling_2d():
kh, kw = 2, 3
sy, sx = 1, 2
pad_h, pad_w = 1, 2
inputs = [nnoir.Value(b'v0', np.zeros((2, 3, 4, 5)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((2, 3, 5, 4)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.MaxPooling2D(input_names,
output_names,
kernel=(kh, kw),
stride=(sy, sx),
pad_h=(pad_h, pad_h + sy - 1),
pad_w=(pad_w, pad_w + sx - 1))
result = nnoir.NNOIR(b'MaxPooling2D', b'nnoir2chainer_test', '0.1',
input_names, output_names, nodes, [function])
result.dump('max_pooling_2d.nnoir')
x = np.random.randn(2, 3, 4, 5).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('max_pooling_2d.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_batch_normalization():
shape = (2, 3, 4, 5)
channel = 3
gamma = np.zeros(channel, dtype=np.float32)
beta = np.zeros(channel, dtype=np.float32)
avg_mean = np.zeros(channel, dtype=np.float32)
avg_var = np.zeros(channel, dtype=np.float32)
eps = 2e-05
gamma[:] = 0.9
beta[:] = 0.1
avg_mean[:] = 0.2
avg_var[:] = 0.8
inputs = [nnoir.Value(b'v0', np.zeros(shape).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros(shape).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.BatchNormalization(input_names,
output_names,
eps=eps,
avg_mean=avg_mean,
avg_var=avg_var,
gamma=gamma,
beta=beta)
result = nnoir.NNOIR(b'BatchNormalization', b'nnoir2chainer_test', '0.1',
input_names, output_names, nodes, [function])
result.dump('batch_normalization.nnoir')
x = np.random.randn(*shape).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('batch_normalization.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_transpose():
inputs = [nnoir.Value(b'v0', np.zeros((2, 3, 4, 5)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((4, 5, 2, 3)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.Transpose(input_names, output_names, axes=(2, 3, 0, 1))
result = nnoir.NNOIR(b'Transpose', b'nnoir2chainer_test', '0.1', input_names, output_names, nodes, [function])
result.dump('transpose.nnoir')
x = np.random.randn(2, 3, 4, 5).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('transpose.nnoir')
y = m(x)
assert(np.all(abs(y-ref).data < util.epsilon))
def test_clipped_relu():
inputs = [nnoir.Value(b'v0', np.zeros((10, 10)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((10, 10)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.ClippedReLU(input_names, output_names, upper=40.0)
result = nnoir.NNOIR(b'ClippedReLU', b'nnoir2chainer_test', '0.1', input_names, output_names, nodes, [function])
result.dump('clipped_relu.nnoir')
x = np.random.randn(10, 10).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('clipped_relu.nnoir')
y = m(x)
assert(np.all(abs(y-ref).data < util.epsilon))
def single_function_model(function, inputs, outputs, **kwargs):
inputs = [nnoir.Value(x[0], shape=x[1], dtype='<f4') for x in inputs]
outputs = [nnoir.Value(x[0], shape=x[1], dtype='<f4') for x in outputs]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
functions = [
getattr(nnoir.functions, function)(input_names, output_names, **kwargs)
]
actual = nnoir.NNOIR(function.encode(), b'nnoir2chainer_test', "0.1",
input_names, output_names, nodes, functions).pack()
expected = nnoir.load(
os.path.join(os.path.abspath(os.path.dirname(__file__)),
function + '.nnoir')).pack()
print(actual)
print(expected)
assert expected == actual
def test_depthwise_convolution_2d_dilate():
sy, sx = 2, 3
ph, pw = 1, 3
kh, kw = 3, 4
batch = 2
in_ch = 6
in_h = 10
in_w = 9
ch_mul = 2
out_ch = in_ch * ch_mul
out_h = 5
out_w = 4
dy, dx = (2, 3)
inputs = [
nnoir.Value(b'v0',
np.zeros((batch, in_ch, in_h, in_w)).astype('float32'))
]
outputs = [
nnoir.Value(b'v1',
np.zeros((batch, out_ch, out_h, out_w)).astype('float32'))
]
W = np.random.randn(ch_mul, in_ch, kh, kw).astype('float32')
b = np.random.randn(out_ch).astype('float32')
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.DepthwiseConvolution2D(input_names,
output_names,
W=W,
b=b,
pad_h=(1, 1),
pad_w=(3, 3),
stride=(sy, sx),
dilate=(dy, dx))
result = nnoir.NNOIR(b'DepthwiseConvolution2D', b'nnoir2chainer_test',
'0.1', input_names, output_names, nodes, [function])
result.dump('depthwise_convolution_2d_dilate.nnoir')
x = np.random.randn(batch, in_ch, in_h, in_w).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('depthwise_convolution_2d_dilate.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_mul():
inputs = [nnoir.Value(b'v0', np.zeros((10, 10)).astype('float32')),
nnoir.Value(b'v1', np.zeros((10, 10)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((10, 10)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.Mul(input_names, output_names)
result = nnoir.NNOIR(b'Mul', b'nnoir2chainer_test', '0.1', input_names, output_names, nodes, [function])
result.dump('mul.nnoir')
x1 = np.random.randn(10, 10).astype('float32')
x2 = np.random.randn(10, 10).astype('float32')
ref = function.run(x1, x2)
with chainer.using_config('train', False):
m = NNOIRFunction('mul.nnoir')
y = m(x1, x2)
assert(np.all(abs(y-ref) < util.epsilon))
def test_bilinear_2d():
in_shape = (2, 3, 9, 10)
out_shape = (2, 3, 4, 5)
inputs = [nnoir.Value(b'v0', np.zeros(in_shape).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros(out_shape).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.Bilinear2D(input_names, output_names, size=(out_shape[2], out_shape[3]))
result = nnoir.NNOIR(b'Bilinear2D', b'nnoir2chainer_test', '0.1', input_names, output_names, nodes, [function])
result.dump('bilinear_2d.nnoir')
x = np.random.randn(*in_shape).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('bilinear_2d.nnoir')
y = m(x)
assert(np.all(abs(y-ref).data < util.epsilon))
def test_bias():
inputs = [nnoir.Value(b'v0', np.zeros((2, 3, 4, 5)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((2, 3, 4, 5)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
b = np.random.randn(3).astype('float32')
params = {'axis': 1, 'b': b}
function = nnoir.functions.Bias(input_names, output_names, **params)
result = nnoir.NNOIR(b'Bias', b'nnoir2chainer_test', '0.1', input_names,
output_names, nodes, [function])
result.dump('bias.nnoir')
x = np.random.randn(2, 3, 4, 5).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('bias.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_swish():
inputs = [nnoir.Value(b'v0', np.zeros((10, 10, 3)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((10, 10, 3)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.Swish(input_names,
output_names,
beta=np.arange(10).astype(np.float32))
result = nnoir.NNOIR(b'Swish', b'nnoir2chainer_test', '0.1', input_names,
output_names, nodes, [function])
result.dump('swish.nnoir')
x = np.random.randn(10, 10).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('swish.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_add_constant():
inputs = [nnoir.Value(b'v0', np.zeros((10, 10)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((10, 10)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.AddConstant(input_names,
output_names,
value=2.0)
result = nnoir.NNOIR(b'AddConstant', b'nnoir2chainer_test', '0.1',
input_names, output_names, nodes, [function])
result.dump('add_constant.nnoir')
x = np.random.randn(10, 10).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('add_constant.nnoir')
y = m(x)
assert (np.all(abs(y - ref) < util.epsilon))
def test_convolution_2d():
batch = 2
in_ch = 4
in_h = 10
in_w = 9
out_ch = 7
out_h = 6
out_w = 3
kh = 4
kw = 3
inputs = [
nnoir.Value(b'v0',
np.zeros((batch, in_ch, in_h, in_w)).astype('float32'))
]
outputs = [
nnoir.Value(b'v1',
np.zeros((batch, out_ch, out_h, out_w)).astype('float32'))
]
W = np.random.randn(out_ch, in_ch, kh, kw).astype('float32')
b = np.random.randn(out_ch).astype('float32')
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.Convolution2D(input_names,
output_names,
W=W,
b=b,
pad_h=(2, 2),
pad_w=(1, 1),
stride=(2, 3),
dilate=(1, 1),
groups=1)
result = nnoir.NNOIR(b'Convolution2D', b'nnoir2chainer_test', '0.1',
input_names, output_names, nodes, [function])
result.dump('convolution_2d.nnoir')
x = np.random.randn(batch, in_ch, in_h, in_w).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('convolution_2d.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_pad():
inputs = [nnoir.Value(b'v0', np.zeros((2, 3, 4, 5)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((3, 5, 7, 10)).astype('float32'))]
pads = ((1, 0), (1, 1), (1, 2), (0, 5))
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.ConstantPadding(input_names,
output_names,
pads=pads,
value=1.0)
result = nnoir.NNOIR(b'ConstantPadding', b'nnoir2chainer_test', '0.1',
input_names, output_names, nodes, [function])
result.dump('pad.nnoir')
x = np.random.randn(2, 3, 4, 5).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('pad.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def test_linear():
batch = 2
in_ch = 3
out_ch = 4
inputs = [nnoir.Value(b'v0', np.zeros((batch, in_ch)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((batch, out_ch)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
W = np.random.randn(out_ch, in_ch).astype('float32')
b = np.random.randn(out_ch).astype('float32')
function = nnoir.functions.Linear(input_names, output_names, W=W, b=b)
result = nnoir.NNOIR(b'Linear', b'nnoir2chainer_test', '0.1', input_names,
output_names, nodes, [function])
result.dump('linear.nnoir')
x = np.random.randn(batch, in_ch).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('linear.nnoir')
y = m(x)
assert (np.all(abs(y - ref).data < util.epsilon))
def single_function_model(function, _inputs, _outputs, **kwargs):
inputs = [nnoir.Value(x[0], shape=x[1], dtype='<f4') for x in _inputs]
outputs = [nnoir.Value(x[0], shape=x[1], dtype='<f4') for x in _outputs]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
functions = [
getattr(nnoir.functions,
function.partition('_')[0])(input_names, output_names,
**kwargs)
]
actual = nnoir.NNOIR(function.encode(), b'nnoir2chainer_test', "0.1",
input_names, output_names, nodes, functions)
expected = nnoir.load(
os.path.join(os.path.abspath(os.path.dirname(__file__)),
function + '.nnoir'))
xs = [np.random.randn(*x[1]).astype('<f4') for x in _inputs]
actuals = actual.run(*xs)
expecteds = expected.run(*xs)
assert len(expecteds) == len(actuals)
for a, e in zip(actuals, expecteds):
print(a - e)
assert (a == e).all()
def test_concat():
v0 = nnoir.Value(b'v0', np.zeros((10, 11)).astype('float32'))
v1 = nnoir.Value(b'v1', np.zeros((10, 12)).astype('float32'))
graph_inputs = [v0, v1]
inputs = [v0,
v0,
v1]
outputs = [nnoir.Value(b'v2', np.zeros((10, 34)).astype('float32'))]
graph_input_names = [x.name for x in graph_inputs]
nodes = graph_inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.Concat(input_names, output_names, axis=1)
result = nnoir.NNOIR(b'Concat', b'nnoir2chainer_test', '0.1', graph_input_names, output_names, nodes, [function])
result.dump('concat.nnoir')
x1 = np.random.randn(10, 11).astype('float32')
x2 = np.random.randn(10, 12).astype('float32')
ref = function.run(x1, x1, x2)
with chainer.using_config('train', False):
m = NNOIRFunction('concat.nnoir')
y = m(x1, x2)
assert(np.all(abs(y-ref).data < util.epsilon))
def test_unpooling_2d():
kh, kw = 2, 3
sy, sx = 1, 2
batch = 2
ch = 3
in_h, in_w = 5, 6
out_h, out_w = 4, 9
ph, pw = 1, 2
inputs = [nnoir.Value(b'v0', np.zeros((batch, ch, in_h, in_w)).astype('float32'))]
outputs = [nnoir.Value(b'v2', np.zeros((batch, ch, out_h, out_w)).astype('float32'))]
nodes = inputs + outputs
input_names = [x.name for x in inputs]
output_names = [x.name for x in outputs]
function = nnoir.functions.Unpooling2D(input_names, output_names, kh=kh, kw=kw, sy=sy, sx=sx, ph=ph, pw=pw,
cover_all=False, outh=out_h, outw=out_w)
result = nnoir.NNOIR(b'Unpooling2D', b'nnoir2chainer_test', '0.1', input_names, output_names, nodes, [function])
result.dump('unpooling_2d.nnoir')
x = np.random.randn(batch, ch, in_h, in_w).astype('float32')
ref = function.run(x)
with chainer.using_config('train', False):
m = NNOIRFunction('unpooling_2d.nnoir')
y = m(x)
assert(np.all(abs(y-ref).data < util.epsilon))
def _value(node):
return nnoir.Value(_variable_elem_name(node), node.node)
def to_nnoir_node(self, inputs, outputs):
lstm_in = inputs[0]
lstm_out = outputs[0]
# upward
upward_inputs = [nnoir.Value(b'v0', np.zeros(lstm_in.shape).astype(lstm_in.dtype))]
upward_outputs = [nnoir.Value(b'v1', np.zeros((lstm_out.shape[0], 4*lstm_out.shape[1])).astype(lstm_out.dtype))]
upward_input_names = [x.name for x in upward_inputs]
upward_output_names = [x.name for x in upward_outputs]
upward_values = upward_inputs + upward_outputs
upward_functions_linear_b = encode_ndarray(self.upward.b.data) if (
hasattr(self, "b") and self.upward.b is not None) else None
upward_functions = [NNOIR.Linear(upward_input_names,
upward_output_names,
W=encode_ndarray(self.upward.W.data),
b=upward_functions_linear_b)]
upward = nnoir.NNOIR(b'linear',
b'chainer',
chainer.__version__,
upward_input_names,
upward_output_names,
upward_values,
upward_functions)
# lateral
lateral_inputs = [nnoir.Value(b'v0', np.zeros((lstm_out.shape[0], lstm_out.shape[1])).astype(lstm_out.dtype))]
lateral_outputs = [nnoir.Value(b'v1', np.zeros((lstm_out.shape[0], 4*lstm_out.shape[1])).astype(lstm_out.dtype))]
lateral_input_names = [x.name for x in lateral_inputs]
lateral_output_names = [x.name for x in lateral_outputs]
lateral_values = lateral_inputs + lateral_outputs
lateral_functions_linear_b = encode_ndarray(self.lateral.b.data) if (
hasattr(self, "b") and self.lateral.b is not None) else None
lateral_functions = [NNOIR.Linear(lateral_input_names,
lateral_output_names,
W=encode_ndarray(self.lateral.W.data),
b=lateral_functions_linear_b)]
lateral = nnoir.NNOIR(b'linear',
b'chainer',
chainer.__version__,
lateral_input_names,
lateral_output_names,
lateral_values,
lateral_functions)
# sigmoid
sigmoid_inputs = [nnoir.Value(b'v0', np.zeros((lstm_out.shape[0], lstm_out.shape[1])).astype(lstm_out.dtype))]
sigmoid_outputs = [nnoir.Value(b'v1', np.zeros((lstm_out.shape[0], lstm_out.shape[1])).astype(lstm_out.dtype))]
sigmoid_input_names = [x.name for x in sigmoid_inputs]
sigmoid_output_names = [x.name for x in sigmoid_outputs]
sigmoid_values = sigmoid_inputs + sigmoid_outputs
sigmoid_functions = [NNOIR.Sigmoid(sigmoid_input_names, sigmoid_output_names)]
sigmoid = nnoir.NNOIR(b'sigmoid',
b'chainer',
chainer.__version__,
sigmoid_input_names,
sigmoid_output_names,
sigmoid_values,
sigmoid_functions)
# tanh
tanh_inputs = [nnoir.Value(b'v0', np.zeros((lstm_out.shape[0], lstm_out.shape[1])).astype(lstm_out.dtype))]
tanh_outputs = [nnoir.Value(b'v1', np.zeros((lstm_out.shape[0], lstm_out.shape[1])).astype(lstm_out.dtype))]
tanh_input_names = [x.name for x in tanh_inputs]
tanh_output_names = [x.name for x in tanh_outputs]
tanh_values = tanh_inputs + tanh_outputs
tanh_functions = [NNOIR.Tanh(tanh_input_names, tanh_output_names)]
tanh = nnoir.NNOIR(b'tanh',
b'chainer',
chainer.__version__,
tanh_input_names,
tanh_output_names,
tanh_values,
tanh_functions)
return NNOIR.LSTM(
[x.name for x in inputs],
[x.name for x in outputs],
upward=upward,
lateral=lateral,
activation_input=sigmoid,
activation_output=sigmoid,
activation_forget=sigmoid,
activation_cell=tanh,
activation_hidden=tanh,
peephole_input=None,
peephole_output=None,
peephole_forget=None,
)
