def forward(self, x, pool_size=(2, 2), pool_type='avg'):
x = self.conv1(x)
x = self.bn1(x)
x = F.relu(x)
if pool_type == 'max':
x = F.max_pool2d(x, kernel_size=pool_size)
elif pool_type == 'avg':
x = F.avg_pool2d(x, kernel_size=pool_size)
elif pool_type == 'avg+max':
x = F.avg_pool2d(x, kernel_size=pool_size) + F.max_pool2d(x, kernel_size=pool_size)
else:
raise Exception(
f'Pooling type of {pool_type} is not supported. It must be one of "max", "avg" and "avg+max".')
return x
def forward(self, inputs):
out = self.branch2a(inputs)
feature_split = paddle.split(out, self.scales, 1)
out_split = []
for i in range(self.scales - 1):
if i == 0 or self.stride == 2:
out_split.append(self.branch2b[i](feature_split[i]))
else:
out_split.append(self.branch2b[i](paddle.add(
feature_split[i], out_split[-1])))
if self.stride == 1:
out_split.append(feature_split[-1])
else:
out_split.append(F.avg_pool2d(feature_split[-1], 3, self.stride,
1))
out = self.branch2c(paddle.concat(out_split, 1))
if self.shortcut:
short = inputs
else:
short = self.branch1(inputs)
out = paddle.add(out, short)
out = F.relu(out)
return out
def forward(self, x):
x = self.conv1(x)
x = self.bn1(x)
x = self.relu(x)
if self.network_type == "ImageNet":
x = self.maxpool(x)
x = self.layer1(x)
if not self.bam1 is None:
x = self.bam1(x)
x = self.layer2(x)
if not self.bam2 is None:
x = self.bam2(x)
x = self.layer3(x)
if not self.bam3 is None:
x = self.bam3(x)
x = self.layer4(x)
if self.network_type == "ImageNet":
x = self.avgpool(x)
else:
x = F.avg_pool2d(x, 4)
x = paddle.reshape(x, [x.shape[0], -1])
x = self.fc(x)
return x
def forward(self, body_feats):
num_backbone_stages = len(body_feats)
outs = []
outs.append(body_feats[0])
# resize
for i in range(1, num_backbone_stages):
resized = F.interpolate(
body_feats[i], scale_factor=2**i, mode='bilinear')
outs.append(resized)
# concat
out = paddle.concat(outs, axis=1)
assert out.shape[
1] == self.in_channel, 'in_channel should be {}, be received {}'.format(
out.shape[1], self.in_channel)
# reduction
out = self.reduction(out)
# conv
outs = [out]
for i in range(1, self.num_out):
outs.append(F.avg_pool2d(out, kernel_size=2**i, stride=2**i))
outputs = []
for i in range(self.num_out):
conv_func = self.fpn_conv if self.share_conv else self.fpn_conv[i]
conv = conv_func(outs[i])
outputs.append(conv)
fpn_feats = [outputs[k] for k in range(self.num_out)]
return fpn_feats
def forward(self, x):
channel_att_sum = None
for pool_type in self.pool_types:
if pool_type == 'avg':
avg_pool = F.avg_pool2d(x, (x.shape[2], x.shape[3]),
stride=(x.shape[2], x.shape[3]))
channel_att_raw = self.mlp(avg_pool)
elif pool_type == 'max':
max_pool = F.max_pool2d(x, (x.shape[2], x.shape[3]),
stride=(x.shape[2], x.shape[3]))
channel_att_raw = self.mlp(max_pool)
elif pool_type == 'lp':
lp_pool = F.lp_pool2d(x,
2, (x.shape[2], x.shape[3]),
stride=(x.shape[2], x.shape[3]))
channel_att_raw = self.mlp(lp_pool)
elif pool_type == 'lse':
# LSE pool only
lse_pool = logsumexp_2d(x)
channel_att_raw = self.mlp(lse_pool)
if channel_att_sum is None:
channel_att_sum = channel_att_raw
else:
channel_att_sum = channel_att_sum + channel_att_raw
scale = F.sigmoid(channel_att_sum)
scale = paddle.unsqueeze(scale, 2)
scale = paddle.unsqueeze(scale, 3)
scale = paddle.expand_as(scale, x)
return x * scale
def forward(self, x):
feat = self.conv(x)
atten = F.avg_pool2d(feat, feat.shape[2:])
atten = self.conv_atten(atten)
atten = self.bn_atten(atten)
atten = self.sigmoid_atten(atten)
out = feat * atten
return out
def forward(self, in_tensor):
avg_pool = F.avg_pool2d(in_tensor,
in_tensor.shape[2],
stride=in_tensor.shape[2])
tmp = paddle.unsqueeze(self.gate_c(avg_pool), 2)
tmp = paddle.unsqueeze(tmp, 3)
result = paddle.expand_as(tmp, in_tensor)
return result
def forward(self, x):
out = self.conv1(x)
out = self.block1(out)
out = self.block2(out)
out = self.block3(out)
out = self.relu(self.bn1(out))
out = F.avg_pool2d(out, 8)
out = paddle.reshape(out, shape=(-1, self.nChannels))
# out = out.view(-1, self.nChannels)
return self.fc(out)
def forward(self, fsp, fcp):
fcat = paddle.concat([fsp, fcp], axis=1)
feat = self.convblk(fcat)
atten = F.avg_pool2d(feat, feat.shape[2:])
atten = self.conv1(atten)
atten = self.relu(atten)
atten = self.conv2(atten)
atten = self.sigmoid(atten)
feat_atten = feat * atten
feat_out = feat_atten + feat
return feat_out
def run5():
with fluid.dygraph.guard():
input_np = np.random.uniform(-1, 1,
[2, 3, 32, 32]).astype(np.float32)
input_pd = fluid.dygraph.to_variable(input_np)
padding = "padding"
res_pd = avg_pool2d(input_pd,
kernel_size=2,
stride=2,
padding=padding,
data_format='NHWC')
def forward(self, x):
out = x
if self.sn is not None:
self.conv.weight.set_value(self.sn(self.conv.weight))
out = self.conv(out)
if self.norm is not None:
out = self.norm(out)
out = F.leaky_relu(out, 0.2)
if self.pool:
out = F.avg_pool2d(out, kernel_size=2, stride=2, ceil_mode=False)
return out
def forward(self, x):
y = paddle.rand(shape=[1, 3, 4, 4])
w1 = paddle.shape(y)[0]
w2 = paddle.shape(x)[0]
while w2 != w1:
x = F.avg_pool2d(x, kernel_size=3, padding=1, stride=2)
w2 = paddle.shape(x)[0]
return x + y
def forward(self, feats):
h, w = paddle.shape(feats)[2:4]
out = [feats]
for stage in self.stages:
feats = F.avg_pool2d(feats, kernel_size=3, stride=2, padding='same')
upsampled = F.interpolate(stage(feats),
size=[h, w],
mode='bilinear',
align_corners=True)
out.append(upsampled)
return self.project(paddle.concat(out, axis=1))
def run_stride_out_of_range():
with fluid.dygraph.guard():
input_np = np.random.uniform(-1, 1,
[2, 3, 32, 32]).astype(np.float32)
input_pd = fluid.dygraph.to_variable(input_np)
res_pd = avg_pool2d(
input_pd,
kernel_size=3,
stride=[0, 2],
padding=0,
ceil_mode=False,
data_format='NHWC')
def local_pairwise_distances2(x, y, max_distance=9):
"""Computes pairwise squared l2 distances using a local search window.
Naive implementation using map_fn.
Used as a slow fallback for when correlation_cost is not available.
Args:
x: Float32 tensor of shape [height, width, feature_dim].
y: Float32 tensor of shape [height, width, feature_dim].
max_distance: Integer, the maximum distance in pixel coordinates
per dimension which is considered to be in the search window.
Returns:
Float32 distances tensor of shape
[height, width, (2 * max_distance + 1) ** 2].
"""
ori_h, ori_w, _ = x.shape
x = paddle.transpose(x, [2, 0, 1]).unsqueeze(0)
x = F.avg_pool2d(x, (2, 2), (2, 2))
y = paddle.transpose(y, [2, 0, 1]).unsqueeze(0)
y = F.avg_pool2d(y, (2, 2), (2, 2))
_, channels, height, width = x.shape
padding_val = 1e20
padded_y = F.pad(y,
(max_distance, max_distance, max_distance, max_distance),
mode='constant',
value=padding_val)
offset_y = F.unfold(padded_y, kernel_sizes=[height, width]).reshape(
[1, channels, height, width, -1])
x = x.reshape([1, channels, height, width, 1])
minus = x - offset_y
dists = paddle.sum(paddle.multiply(minus, minus),
axis=1).reshape([1, height, width,
-1]).transpose([0, 3, 1, 2])
dists = (paddle.nn.functional.sigmoid(dists) - 0.5) * 2
dists = F.interpolate(dists,
size=[ori_h, ori_w],
mode='bilinear',
align_corners=True)
dists = dists.squeeze(0).transpose([1, 2, 0])
return dists
def _forward(self, x):
branch1x1 = self.branch1x1(x)
branch5x5 = self.branch5x5_1(x)
branch5x5 = self.branch5x5_2(branch5x5)
branch3x3dbl = self.branch3x3dbl_1(x)
branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)
branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
branch_pool = self.branch_pool(branch_pool)
outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]
return outputs
def forward(self, x):
x = self.conv1(x)
# x = self.maxpool(x)
x = self.stage2(x)
x = self.stage3(x)
x = self.stage4(x)
# global average pooling layer
x = F.avg_pool2d(x, x.shape[-2:])
# flatten for input to fully-connected layer
x = x.flatten(1)
x = self.fc(x)
return F.log_softmax(x, axis=1)
def forward(self, x):
skips = []
for i in range(self.n_skip):
skips.append(getattr(self, 'ConvBlockskip' + str(i + 1))(x))
x = F.avg_pool2d(x, 2)
x = getattr(self, 'ConvBlock' + str(i + 1))(x)
x = self.ConvBlock5(x)
for i in range(self.n_skip):
x = getattr(self, 'ConvBlock' + str(i + 6))(x)
x = F.upsample(x, scale_factor=2)
x = skips[self.n_skip - i - 1] + x
return x
def _forward(self, level, inp):
up1 = inp
up1 = self._sub_layers['b1_' + str(level)](up1)
low1 = F.avg_pool2d(inp, 2, stride=2)
low1 = self._sub_layers['b2_' + str(level)](low1)
if level > 1:
low2 = self._forward(level - 1, low1)
else:
low2 = low1
low2 = self._sub_layers['b2_plus_' + str(level)](low2)
low3 = low2
low3 = self._sub_layers['b3_' + str(level)](low3)
up2 = F.interpolate(low3, scale_factor=2, mode='nearest')
return up1 + up2
def forward(self, x):
# N x 768 x 17 x 17
x = F.avg_pool2d(x, kernel_size=5, stride=3)
# N x 768 x 5 x 5
x = self.conv0(x)
# N x 128 x 5 x 5
x = self.conv1(x)
# N x 768 x 1 x 1
# Adaptive average pooling
x = F.adaptive_avg_pool2d(x, (1, 1))
# N x 768 x 1 x 1
x = paddle.flatten(x, 1)
# N x 768
x = self.fc(x)
# N x 1000
return x
def forward(self, x):
# save for combining later with output
residual = x
if self.combine == 'concat':
residual = F.avg_pool2d(residual,
kernel_size=3,
stride=2,
padding=1)
out = self.g_conv_1x1_compress(x)
out = channel_shuffle(out, self.groups)
out = self.depthwise_conv3x3(out)
out = self.bn_after_depthwise(out)
out = self.g_conv_1x1_expand(out)
out = self._combine_func(residual, out)
return F.relu(out)
def _forward(self, x):
branch1x1 = self.branch1x1(x)
branch7x7 = self.branch7x7_1(x)
branch7x7 = self.branch7x7_2(branch7x7)
branch7x7 = self.branch7x7_3(branch7x7)
branch7x7dbl = self.branch7x7dbl_1(x)
branch7x7dbl = self.branch7x7dbl_2(branch7x7dbl)
branch7x7dbl = self.branch7x7dbl_3(branch7x7dbl)
branch7x7dbl = self.branch7x7dbl_4(branch7x7dbl)
branch7x7dbl = self.branch7x7dbl_5(branch7x7dbl)
branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
branch_pool = self.branch_pool(branch_pool)
outputs = [branch1x1, branch7x7, branch7x7dbl, branch_pool]
return outputs
def check_avg_dygraph_results(self, place):
with fluid.dygraph.guard(place):
input_np = np.random.random([2, 3, 32, 32]).astype("float32")
input = fluid.dygraph.to_variable(input_np)
result = avg_pool2d(input, kernel_size=2, stride=2, padding=0)
result_np = pool2D_forward_naive(
input_np,
ksize=[2, 2],
strides=[2, 2],
paddings=[0, 0],
pool_type='avg')
self.assertTrue(np.allclose(result.numpy(), result_np))
avg_pool2d_dg = paddle.nn.layer.AvgPool2D(
kernel_size=2, stride=2, padding=0)
result = avg_pool2d_dg(input)
self.assertTrue(np.allclose(result.numpy(), result_np))
def forward(self, x, inputs=None):
avg_out = self.avg(x)
eesp_out = self.eesp(x)
output = paddle.concat([avg_out, eesp_out], axis=1)
if inputs is not None:
w1 = paddle.shape(avg_out)[2]
w2 = paddle.shape(inputs)[2]
while w2 != w1:
inputs = F.avg_pool2d(inputs,
kernel_size=3,
padding=1,
stride=2)
w2 = paddle.shape(inputs)[2]
# import pdb
# pdb.set_trace()
output = output + self.shortcut_layer(inputs)
return self._act(output)
def check_avg_static_results(self, place):
with fluid.program_guard(fluid.Program(), fluid.Program()):
input = fluid.data(
name="input", shape=[2, 3, 32, 32], dtype="float32")
result = avg_pool2d(input, kernel_size=2, stride=2, padding=0)
input_np = np.random.random([2, 3, 32, 32]).astype("float32")
result_np = pool2D_forward_naive(
input_np,
ksize=[2, 2],
strides=[2, 2],
paddings=[0, 0],
pool_type='avg')
exe = fluid.Executor(place)
fetches = exe.run(fluid.default_main_program(),
feed={"input": input_np},
fetch_list=[result])
self.assertTrue(np.allclose(fetches[0], result_np))
def forward(self, x):
H0, W0 = x.shape[2:]
feat8, feat16, feat32 = self.backbone_forward(x)
H8, W8 = feat8.shape[2:]
H16, W16 = feat16.shape[2:]
H32, W32 = feat32.shape[2:]
avg = F.avg_pool2d(feat32, feat32.shape[2:])
avg = self.conv_avg(avg)
avg_up = F.interpolate(avg, size=(H32, W32), mode='nearest')
feat32_arm = self.arm32(feat32)
feat32_sum = feat32_arm + avg_up
feat32_up = F.interpolate(feat32_sum, size=(H16, W16), mode='nearest')
feat32_up = self.conv_head32(feat32_up)
feat16_arm = self.arm16(feat16)
feat16_sum = feat16_arm + feat32_up
feat16_up = F.interpolate(feat16_sum, size=(H8, W8), mode='nearest')
feat16_up = self.conv_head16(feat16_up)
return feat8, feat16_up, feat32_up # x8, x8, x16
def forward(self, x):
x, _ = self.conv1(x)
x = F.relu(self.bn1(x), True)
x = F.avg_pool2d(self.conv2(x), 2, stride=2)
x = self.conv3(x)
x = self.conv4(x)
outputs = []
boundary_channels = []
tmp_out = None
ll, boundary_channel = self._sub_layers['m0'](x, tmp_out)
ll = self._sub_layers['top_m_0'](ll)
ll = F.relu(self._sub_layers['bn_end0']
(self._sub_layers['conv_last0'](ll)), True)
# Predict heatmaps
tmp_out = self._sub_layers['l0'](ll)
if self.end_relu:
tmp_out = F.relu(tmp_out) # HACK: Added relu
outputs.append(tmp_out)
boundary_channels.append(boundary_channel)
return outputs, boundary_channels
def pyramid_forward(self, feat):
each_stripe_size = int(feat.shape[2] / self.num_stripes)
feat_list, logits_list = [], []
idx_levels = 0
used_branches = 0
for idx_branches in range(self.num_branches):
if idx_branches >= sum(self.num_in_each_level[0:idx_levels + 1]):
idx_levels += 1
if self.used_levels[idx_levels] == 0:
continue
idx_in_each_level = idx_branches - sum(
self.num_in_each_level[0:idx_levels])
stripe_size_in_each_level = each_stripe_size * (idx_levels + 1)
start = idx_in_each_level * each_stripe_size
end = start + stripe_size_in_each_level
k = feat.shape[-1]
local_feat_avgpool = F.avg_pool2d(
feat[:, :, start:end, :],
kernel_size=(stripe_size_in_each_level, k))
local_feat_maxpool = F.max_pool2d(
feat[:, :, start:end, :],
kernel_size=(stripe_size_in_each_level, k))
local_feat = local_feat_avgpool + local_feat_maxpool
local_feat = self.pyramid_conv_list0[used_branches](local_feat)
local_feat = paddle.reshape(local_feat,
shape=[local_feat.shape[0], -1])
feat_list.append(local_feat)
local_logits = self.pyramid_fc_list0[used_branches](
self.dropout_layer(local_feat))
logits_list.append(local_logits)
used_branches += 1
return feat_list, logits_list
def _forward(self, x):
branch1x1 = self.branch1x1(x)
branch3x3 = self.branch3x3_1(x)
branch3x3 = [
self.branch3x3_2a(branch3x3),
self.branch3x3_2b(branch3x3),
]
branch3x3 = paddle.cat(branch3x3, 1)
branch3x3dbl = self.branch3x3dbl_1(x)
branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
branch3x3dbl = [
self.branch3x3dbl_3a(branch3x3dbl),
self.branch3x3dbl_3b(branch3x3dbl),
]
branch3x3dbl = paddle.cat(branch3x3dbl, 1)
branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1)
branch_pool = self.branch_pool(branch_pool)
outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]
return outputs
def forward(self, x):
x = self.model(x)
x = F.avg_pool2d(x, 7)
x = x.view(-1, 1024)
x = self.fc(x)
return x
