def inceptionv4(options,params,rng, input):
results = OrderedDict()
# inception v4 lower part
params['W1_1'], results['layerR0'] = convolu_theano(rng, input,filter_shape=(32,3,3,3),image_shape=options['image_shape'],stride=(1,1),poolsize=(2,2), weights_path=None)
params['W1_2'], results['layerR1'] = convolu_theano(rng, ReLU(results['layerR1']),filter_shape=(32,3,3,3),image_shape=layerR0.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
params['W1_3'], results['layerR2'] = convolu_theano(rng, ReLU(results['layerR2']),filter_shape=(64,3,3,3),image_shape=layerR1.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
params['W1_4'], results['layerR3'] = convolu_theano(rng, ReLU(results['layerR3']),filter_shape=(96,3,3,3),image_shape=layerR2.shape,stride=(1,1),poolsize=(2,2), weights_path=None)
results['layerL1'] = fancy_max_pool(ReLU(results['layerR2']), pool_shape=(3,3), pool_stride=(1,1), ignore_border=False)
# inception v4 lower part concatenation
results['filter_concate_1'] = theano.concatenate([results['layerL1'], results['layerR3']], axis=3)
# inception v4 middle part
params['W2_1'], results['layerR4'] = convolu_theano(rng, results['filter_concate_1'], filter_shape=(64,3,1,1),image_shape=filter_concate_1.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
params['W2_2'], results['layerL2'] = convolu_theano(rng, results['filter_concate_1'], filter_shape=(64,3,1,1),image_shape=filter_concate_1.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
params['W2_3'], results['layerL3'] = convolu_theano(rng, ReLU(results['layerL2']), filter_shape=(96,3,1,1),image_shape=layerL2.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
params['W2_4'], results['layerR5'] = convolu_theano(rng, ReLU(results['layerR4']), filter_shape=(64,3,7,1),image_shape=layerR4.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
params['W2_5'], results['layerR6'] = convolu_theano(rng, ReLU(results['layerR5']), filter_shape=(64,3,1,7),image_shape=layerR5.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
params['W2_6'], results['layerR7'] = convolu_theano(rng, ReLU(results['layerR7']), filter_shape=(96,3,3,3),image_shape=layerR6.shape,stride=(0,0),poolsize=(2,2), weights_path=None)
#inception v4 middle part concatenation
results['filter_concate_2'] = theano.concatenate([results['layerL3'],results['layerR7'] ], axis=3)
#inception v4 upper part
results['layerR8'] = fancy_max_pool(results['filter_concate_2'], pool_shape=(2,2), pool_stride=(1,1), ignore_border=False)
params['W3_1'], results['layerL4'] = convolu_theano(rng, results['filter_concate_2'] , filter_shape=(192,3,3,3),image_shape=filter_concate_2.shape, stride=(0,0), poolsize=(2,2), weights_path=None)
#inception v4 upper part concatenation
results['filter_concate_3'] = theano.concatenate([ReLU(results['layerL4']),results['layerR8']], axis=3)
return params, results
def __init__(self, dim, use_bias):
super(ResnetBlock, self).__init__()
conv_block = []
conv_block += [
ReflectionPad2D(1),
Conv2D(dim,
num_filters=dim,
filter_size=3,
stride=1,
bias_attr=use_bias),
Instancenorm(),
ReLU()
]
conv_block += [
ReflectionPad2D(1),
Conv2D(dim,
num_filters=dim,
filter_size=3,
stride=1,
bias_attr=use_bias),
Instancenorm()
]
self.conv_block = Sequential(*conv_block)
def cnn_layer(tparams, proj, options):
#proj = proj.dimshuffle(1,'x',0,2) #(batchsize,1,max_len,dim_proj)
proj = proj.dimshuffle(
1, 3, 0, 2
) # (maxlen,n_sample(batchsize), dim_proj, num_chn) -> (batchsize,num_chn,max_len,dim_proj)
#image_shape = proj.shape
filter_shapes = options['filter_shapes']
image_shape = options['image_shape']
pool_sizes = options['pool_sizes']
image_shape = (None, image_shape[1], image_shape[2], image_shape[3])
conv_outs = []
for i in range(len(filter_shapes)):
filter_shape = filter_shapes[i]
pool_size = pool_sizes[i]
#img_h = image_shape[2]
filter_h = filter_shape[2]
#img_w = image_shape[3]
#filter_w = filter_shape[3]
#poolsize = (img_h-filter_h+1,img_w-filter_w+1)
conv_out = conv.conv2d(input=proj,
filters=tparams['cnn_f' + str(filter_h)],
filter_shape=filter_shape,
image_shape=image_shape)
conv_out_relu = ReLU(
conv_out +
tparams['cnn_b' + str(filter_h)].dimshuffle('x', 0, 'x', 'x'))
if options['pool_type'] == 'max':
conv_out_pool = pool.pool_2d(input=conv_out_relu,
ds=pool_size,
ignore_border=True,
mode='max')
# conv_out_pool = pool.pool_2d(input=conv_out_relu,ds=pool_size,ignore_border=True,mode='max')
elif options['pool_type'] == 'avg':
conv_out_pool = conv_out_relu.flatten(3)
conv_out_pool = tensor.mean(conv_out_pool, axis=2)
else:
sys.exit()
conv_outs.append(conv_out_pool.flatten(2))
proj = tensor.concatenate(conv_outs, 1)
return proj
def __init__(self, input_size, hidden_size, output_size, weight_init=0.01):
self.params = {}
# self.params["W1"] = weight_init*np.random.rand(input_size,hidden_size)
self.params["W1"] = np.random.randn(
input_size, hidden_size) / np.sqrt(input_size) * np.sqrt(2.0)
self.params["b1"] = np.zeros(hidden_size)
# self.params["W2"] = weight_init*np.random.rand(hidden_size,output_size)
self.params["W2"] = np.random.randn(
hidden_size, output_size) / np.sqrt(hidden_size) * np.sqrt(2.0)
self.params["b2"] = np.zeros(output_size)
self.layers = OrderedDict()
self.layers["Affine1"] = Affine(self.params["W1"], self.params["b1"])
self.layers["ReLU"] = ReLU()
self.layers["Affine2"] = Affine(self.params["W2"], self.params["b2"])
self.last_layer = IdentityWithLoss()
def __init__(self, dim, use_bias):
super(ResnetAdaILNBlock, self).__init__()
self.pad1 = ReflectionPad2D(1)
self.conv1 = Conv2D(dim,
num_filters=dim,
filter_size=3,
stride=1,
bias_attr=use_bias)
self.norm1 = adaILN(dim)
self.relu1 = ReLU()
self.pad2 = ReflectionPad2D(1)
self.conv2 = Conv2D(dim,
num_filters=dim,
filter_size=3,
stride=1,
bias_attr=use_bias)
self.norm2 = adaILN(dim)
def __init__(self, dim, use_bias):
super(ResnetBlock, self).__init__()
self.conv_block1_1 = ReflectionPad2D(1)
self.conv_block1_2 = Conv2D(dim,
dim,
filter_size=3,
stride=1,
padding=0,
bias_attr=use_bias)
self.conv_block1_4 = ReLU(False)
self.conv_block2_1 = ReflectionPad2D(1)
self.conv_block2_2 = Conv2D(dim,
dim,
filter_size=3,
stride=1,
padding=0,
bias_attr=use_bias)
def __init__(self,
input_nc,
output_nc,
ngf=64,
n_blocks=6,
img_size=256,
light=False):
assert (n_blocks >= 0)
super(ResnetGenerator, self).__init__()
self.input_nc = input_nc
self.output_nc = output_nc
self.ngf = ngf
self.n_blocks = n_blocks
self.img_size = img_size
self.light = light
self.DownBlock1_1 = ReflectionPad2D(3)
self.DownBlock1_2 = Conv2D(3,
64,
filter_size=7,
stride=1,
padding=0,
bias_attr=False)
self.DownBlock1_4 = ReLU(False)
self.DownBlock2_1 = ReflectionPad2D(1)
self.DownBlock2_2 = Conv2D(64,
128,
filter_size=3,
stride=2,
padding=0,
bias_attr=False)
self.DownBlock2_4 = ReLU(False)
self.DownBlock3_1 = ReflectionPad2D(1)
self.DownBlock3_2 = Conv2D(128,
256,
filter_size=3,
stride=2,
padding=0,
bias_attr=False)
self.DownBlock3_4 = ReLU(False)
n_downsampling = 2
# Down-Sampling
self.DownBlock1 = ResnetBlock(256, use_bias=False)
self.DownBlock2 = ResnetBlock(256, use_bias=False)
self.DownBlock3 = ResnetBlock(256, use_bias=False)
self.DownBlock4 = ResnetBlock(256, use_bias=False)
# Down-Sampling Bottleneck
mult = 4
# Class Activation Map
self.gap_fc = Linear(ngf * mult, 1, bias_attr=False)
self.gmp_fc = Linear(ngf * mult, 1, bias_attr=False)
self.conv1x1 = Conv2D(
ngf * mult * 2,
ngf * mult,
filter_size=1,
stride=1,
bias_attr=fluid.ParamAttr(initializer=fluid.initializer.Uniform(
low=-1 / math.sqrt(ngf * mult * 2),
high=1 / math.sqrt(ngf * mult * 2))))
self.relu = ReLU(False)
# Gamma, Beta block
if self.light:
FC = [
Linear(ngf * mult, ngf * mult, bias_attr=False),
ReLU(False),
Linear(ngf * mult, ngf * mult, bias_attr=False),
ReLU(False)
]
else:
FC = [
Linear(img_size // mult * img_size // mult * ngf * mult,
ngf * mult,
bias_attr=False),
ReLU(False),
Linear(ngf * mult, ngf * mult, bias_attr=False),
ReLU(False)
]
self.gamma = Linear(ngf * mult, ngf * mult, bias_attr=False)
self.beta = Linear(ngf * mult, ngf * mult, bias_attr=False)
# Up-Sampling Bottleneck
for i in range(n_blocks):
setattr(self, 'UpBlock1_' + str(i + 1),
ResnetAdaILNBlock(ngf * mult, use_bias=False))
# Up-Sampling
UpBlock2 = []
for i in range(n_downsampling):
mult = 2**(n_downsampling - i)
UpBlock2 += [
Upsample(scales=2, resamples='NEAREST'),
ReflectionPad2D(1),
Conv2D(ngf * mult,
int(ngf * mult / 2),
filter_size=3,
stride=1,
padding=0,
bias_attr=False),
ILN(int(ngf * mult / 2)),
ReLU(False)
]
UpBlock2 += [
ReflectionPad2D(3),
Conv2D(ngf,
output_nc,
filter_size=7,
stride=1,
padding=0,
bias_attr=False),
Tanh()
]
self.FC = Sequential(*FC)
self.UpBlock2 = Sequential(*UpBlock2)
def __init__(self,
input_nc,
output_nc,
ngf=64,
n_blocks=6,
img_size=256,
light=False):
assert (n_blocks >= 0)
super(ResnetGenerator, self).__init__()
self.input_nc = input_nc
self.output_nc = output_nc
self.ngf = ngf
self.n_blocks = n_blocks
self.img_size = img_size
self.light = light
DownBlock = []
DownBlock += [
ReflectionPad2D(3),
Conv2D(input_nc,
num_filters=ngf,
filter_size=7,
stride=1,
padding=0),
Instancenorm(),
ReLU()
]
# Down-Sampling
n_downsampling = 2
for i in range(n_downsampling):
mult = 2**i
DownBlock += [
ReflectionPad2D(1),
Conv2D(ngf * mult,
num_filters=ngf * mult * 2,
filter_size=3,
stride=2),
Instancenorm(),
ReLU()
]
# Down-Sampling Bottleneck
mult = 2**n_downsampling
for i in range(n_blocks):
DownBlock += [ResnetBlock(ngf * mult, use_bias=False)]
# Class Activation Map
self.gap_fc = Linear(ngf * mult, 1)
self.gmp_fc = Linear(ngf * mult, 1)
self.conv1x1 = Conv2D(ngf * mult * 2,
num_filters=ngf * mult,
filter_size=1,
stride=1,
bias_attr=True)
self.relu = ReLU()
# Gamma, Beta block
if self.light:
FC = [
Linear(ngf * mult, ngf * mult),
ReLU(),
Linear(ngf * mult, ngf * mult),
ReLU()
]
else:
FC = [
Linear(img_size // mult * img_size // mult * ngf * mult,
ngf * mult),
ReLU(),
Linear(ngf * mult, ngf * mult),
ReLU()
]
self.gamma = Linear(ngf * mult, ngf * mult)
self.beta = Linear(ngf * mult, ngf * mult)
# Up-Sampling Bottleneck
for i in range(n_blocks):
setattr(self, 'UpBlock1_' + str(i + 1),
ResnetAdaILNBlock(ngf * mult, use_bias=False))
# Up-Sampling
UpBlock2 = []
for i in range(n_downsampling):
mult = 2**(n_downsampling - i)
UpBlock2 += [
Resize_nearest(scale=2),
ReflectionPad2D(1),
Conv2D(ngf * mult,
num_filters=int(ngf * mult / 2),
filter_size=3,
stride=1),
ILN(int(ngf * mult / 2)),
ReLU()
]
UpBlock2 += [
ReflectionPad2D(3),
Conv2D(ngf, num_filters=output_nc, filter_size=7, stride=1),
Tanh()
]
self.DownBlock = Sequential(*DownBlock)
self.FC = Sequential(*FC)
self.UpBlock2 = Sequential(*UpBlock2)