from chainer.functions.connection.convolution_2d import Convolution2DFunction
from nnoir_chainer.patch import patched_function_apply, patched_function_call
if hasattr(Convolution2DFunction, 'apply'):
Convolution2DFunction.apply = patched_function_apply(
Convolution2DFunction.apply)
else:
Convolution2DFunction.__call__ = patched_function_call(
Convolution2DFunction.__call__)
from chainer.functions.activation.sigmoid import Sigmoid
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Sigmoid, 'apply'):
Sigmoid.apply = patched_function_apply(Sigmoid.apply)
else:
Sigmoid.__call__ = patched_function_call(Sigmoid.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Sigmoid([x.name for x in inputs], [x.name for x in outputs])
Sigmoid.to_nnoir_node = to_nnoir_node
from chainer.functions.normalization.batch_normalization import FixedBatchNormalization
from nnoir_chainer.patch import patched_function_apply, patched_function_call
if hasattr(FixedBatchNormalization, 'apply'):
FixedBatchNormalization.apply = patched_function_apply(FixedBatchNormalization.apply)
else:
FixedBatchNormalization.__call__ = patched_function_call(FixedBatchNormalization.__call__)
from chainer.functions.pooling.unpooling_2d import Unpooling2D
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Unpooling2D, 'apply'):
Unpooling2D.apply = patched_function_apply(Unpooling2D.apply)
else:
Unpooling2D.__call__ = patched_function_call(Unpooling2D.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Unpooling2D(
[x.name for x in inputs],
[x.name for x in outputs],
kh=self.kh,
kw=self.kw,
sy=self.sy,
sx=self.sx,
ph=self.ph,
pw=self.pw,
cover_all=self.cover_all,
outh=self.outh,
outw=self.outw,
)
Unpooling2D.to_nnoir_node = to_nnoir_node
from chainer.functions.pooling.max_pooling_nd import MaxPoolingND
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(MaxPoolingND, 'apply'):
MaxPoolingND.apply = patched_function_apply(MaxPoolingND.apply)
else:
MaxPoolingND.__call__ = patched_function_call(MaxPoolingND.__call__)
def to_nnoir_node(self, inputs, outputs):
if self.ndim != 2:
raise Exception('unsupported ndim "{}"'.format(self.ndim))
return NNOIR.MaxPooling2D(
[x.name for x in inputs],
[x.name for x in outputs],
kernel=tuple(self.ksize[:2]),
stride=tuple(self.stride[:2]),
pad_h=(self.pad[0], self.pad[0] + self.stride[0] - 1),
pad_w=(self.pad[1], self.pad[1] + self.stride[1] - 1),
)
MaxPoolingND.to_nnoir_node = to_nnoir_node
from chainer.functions.math.basic_math import Add, AddConstant, Sub, Mul, MulConstant
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Add, 'apply'):
Add.apply = patched_function_apply(Add.apply)
else:
Add.__call__ = patched_function_call(Add.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Add([x.name for x in inputs], [x.name for x in outputs])
Add.to_nnoir_node = to_nnoir_node
if hasattr(AddConstant, 'apply'):
AddConstant.apply = patched_function_apply(AddConstant.apply)
else:
AddConstant.__call__ = patched_function_call(AddConstant.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.AddConstant([x.name for x in inputs], [x.name for x in outputs], value=float(self.value))
AddConstant.to_nnoir_node = to_nnoir_node
if hasattr(Sub, 'apply'):
Sub.apply = patched_function_apply(Sub.apply)
else:
from chainer.functions.math.sum import Sum
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Sum, 'apply'):
Sum.apply = patched_function_apply(Sum.apply)
else:
Sum.__call__ = patched_function_call(Sum.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Sum([x.name for x in inputs], [x.name for x in outputs],
axes=self.axis,
keepdims=self.keepdims)
Sum.to_nnoir_node = to_nnoir_node
from chainer.functions.activation.clipped_relu import ClippedReLU
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(ClippedReLU, 'apply'):
ClippedReLU.apply = patched_function_apply(ClippedReLU.apply)
else:
ClippedReLU.__call__ = patched_function_call(ClippedReLU.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.ClippedReLU([x.name for x in inputs], [x.name for x in outputs], upper=self.cap)
ClippedReLU.to_nnoir_node = to_nnoir_node
from chainer.functions.array.transpose import Transpose
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Transpose, 'apply'):
Transpose.apply = patched_function_apply(Transpose.apply)
else:
Transpose.__call__ = patched_function_call(Transpose.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Transpose([x.name for x in inputs], [x.name for x in outputs], axes=self.axes)
Transpose.to_nnoir_node = to_nnoir_node
from chainer.functions.connection.linear import LinearFunction
from nnoir_chainer.patch import patched_function_apply, patched_function_call
if hasattr(LinearFunction, 'apply'):
LinearFunction.apply = patched_function_apply(LinearFunction.apply)
else:
LinearFunction.__call__ = patched_function_call(LinearFunction.__call__)
from chainer.functions.array.reshape import Reshape
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Reshape, 'apply'):
Reshape.apply = patched_function_apply(Reshape.apply)
else:
Reshape.__call__ = patched_function_call(Reshape.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Reshape([x.name for x in inputs], [x.name for x in outputs],
shape=self.shape)
Reshape.to_nnoir_node = to_nnoir_node
from chainer.functions.activation.softmax import Softmax
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Softmax, 'apply'):
Softmax.apply = patched_function_apply(Softmax.apply)
else:
Softmax.__call__ = patched_function_call(Softmax.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Softmax([x.name for x in inputs], [x.name for x in outputs],
axis=self.axis)
Softmax.to_nnoir_node = to_nnoir_node
from chainer.functions.noise.dropout import Dropout
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Dropout, 'apply'):
Dropout.apply = patched_function_apply(Dropout.apply)
else:
Dropout.__call__ = patched_function_call(Dropout.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Dropout([x.name for x in inputs], [x.name for x in outputs])
Dropout.to_nnoir_node = to_nnoir_node
from chainer.functions.array.pad import Pad
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
import numpy as np
if hasattr(Pad, 'apply'):
Pad.apply = patched_function_apply(Pad.apply)
else:
Pad.__call__ = patched_function_call(Pad.__call__)
def to_nnoir_node(self, inputs, outputs):
[var] = self.chainer_input_variables
zero_padded_ones = np.pad(np.ones(var.shape, dtype=np.int32),
self.pad_width,
mode='constant',
constant_values=0)
ones_positions = np.transpose(np.where(zero_padded_ones > 0))
pad_befores = ones_positions[0]
pad_afters = np.array(zero_padded_ones.shape) - ones_positions[-1] - 1
pad_width = list(
map(lambda x: (int(x[0]), int(x[1])),
np.stack([pad_befores, pad_afters]).T))
if self.mode == 'constant':
if type(self.keywords['constant_values']) == int:
value = float(self.keywords['constant_values'])
elif type(self.keywords['constant_values'][0]) == tuple:
value = float(self.keywords['constant_values'][0][0])
for (b, a) in self.keywords['constant_values']:
if b != value or a != value:
raise Exception('unsupported pad value "{}"'.format(
from chainer.functions.activation.leaky_relu import LeakyReLU
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(LeakyReLU, 'apply'):
LeakyReLU.apply = patched_function_apply(LeakyReLU.apply)
else:
LeakyReLU.__call__ = patched_function_call(LeakyReLU.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.LeakyReLU([x.name for x in inputs], [x.name for x in outputs],
slope=self.slope)
LeakyReLU.to_nnoir_node = to_nnoir_node
from chainer.functions.normalization.local_response_normalization import LocalResponseNormalization
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(LocalResponseNormalization, 'apply'):
LocalResponseNormalization.apply = patched_function_apply(
LocalResponseNormalization.apply)
else:
LocalResponseNormalization.__call__ = patched_function_call(
LocalResponseNormalization.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.LocalResponseNormalization([x.name for x in inputs],
[x.name for x in outputs],
n=int(self.n),
k=float(self.k),
alpha=float(self.alpha),
beta=float(self.beta))
LocalResponseNormalization.to_nnoir_node = to_nnoir_node
from chainer.functions.loss.softmax_cross_entropy import SoftmaxCrossEntropy
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(SoftmaxCrossEntropy, 'apply'):
SoftmaxCrossEntropy.apply = patched_function_apply(
SoftmaxCrossEntropy.apply)
else:
SoftmaxCrossEntropy.__call__ = patched_function_call(
SoftmaxCrossEntropy.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.SoftmaxCrossEntropy(
[x.name for x in inputs],
[x.name for x in outputs],
normalize=self.normalize,
cache_score=self.cache_score,
)
SoftmaxCrossEntropy.to_nnoir_node = to_nnoir_node
from chainer.functions.array.concat import Concat
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(Concat, 'apply'):
Concat.apply = patched_function_apply(Concat.apply)
else:
Concat.__call__ = patched_function_call(Concat.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Concat([x.name for x in inputs], [x.name for x in outputs],
axis=self.axis)
Concat.to_nnoir_node = to_nnoir_node
from chainer.functions.array.resize_images import ResizeImages
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(ResizeImages, 'apply'):
ResizeImages.apply = patched_function_apply(ResizeImages.apply)
else:
ResizeImages.__call__ = patched_function_call(ResizeImages.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.Bilinear2D([x.name for x in inputs], [x.name for x in outputs], size=(self.out_H, self.out_W))
ResizeImages.to_nnoir_node = to_nnoir_node
from chainer.functions.array.broadcast import BroadcastTo
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(BroadcastTo, 'apply'):
BroadcastTo.apply = patched_function_apply(BroadcastTo.apply)
else:
BroadcastTo.__call__ = patched_function_call(BroadcastTo.__call__)
def to_nnoir_node(self, inputs, outputs):
output = outputs[0]
return NNOIR.BroadcastTo([x.name for x in inputs],
[x.name for x in outputs],
shape=outputs.shape)
BroadcastTo.to_nnoir_node = to_nnoir_node
from chainer.functions.activation.elu import ELU
from nnoir_chainer.patch import patched_function_apply, patched_function_call
import nnoir.functions as NNOIR
if hasattr(ELU, 'apply'):
ELU.apply = patched_function_apply(ELU.apply)
else:
ELU.__call__ = patched_function_call(ELU.__call__)
def to_nnoir_node(self, inputs, outputs):
return NNOIR.ELU([x.name for x in inputs], [x.name for x in outputs],
alpha=self.alpha)
ELU.to_nnoir_node = to_nnoir_node
