def to_nnoir(self, name=None): def _value(node): return nnoir.Value(_variable_elem_name(node), node.node) sorted_nodes = sorted(self.nodes, key=lambda n: n.no) values = list( map( _value, filter(lambda node: isinstance(node.node, variable.Variable), sorted_nodes))) dvalues = {x.name: x for x in values} def _function(node): inputs = list(map(_variable_elem_name, reversed(node.in_edges))) outputs = list(map(_variable_elem_name, node.out_edges)) return node.node.to_nnoir_node([dvalues[x] for x in inputs], [dvalues[x] for x in outputs]) return nnoir.NNOIR((name or self.model.__class__.__name__).encode(), b'chainer', chainer.__version__, list(map(_variable_elem_name, self.input_variables)), list(map(_variable_elem_name, self.output_variables)), values, list( map( _function, filter( lambda node: not isinstance( node.node, variable.Variable), sorted_nodes)))).pack()
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_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_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_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_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_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 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, )