Skip to content

P
PaddleClas

PaddlePaddle / PaddleClas
接近 2 年 前同步成功

通知 116
Star 4999
Fork 1114
P
PaddleClas
提交 d4b42a38 编写于 作者: S shippingwang
浏览文件
操作

fix

上级 994d198e
隐藏空白更改
内联 并排
Showing with 178 addition and 319 deletion
ppcls/modeling/architectures/evonorm.py 已删除 100644 → 0
浏览文件 @ 994d198e
import paddle
import torch
import numpy as np
import paddle.fluid as fluid
def instance_std_paddle(input, epsilon=1e-5):
v = paddle.var(input, axis=[2,3], keepdim=True )
v = paddle.expand_as(v, input)
return paddle.sqrt(v+epsilon)
def instance_std(x, eps=1e-5):
var = torch.var(x, dim = (2, 3), keepdim=True).expand_as(x)
if torch.isnan(var).any():
var = torch.zeros(var.shape)
return torch.sqrt(var + eps)
def group_std_paddle(input, groups=32, epsilon=1e-5):
#N, C, H, W = paddle.shape(input)
N,C,H,W = input.shape
#print(N,C,H,W)
input = paddle.reshape(input, [N, groups, C//groups, H, W])
v = paddle.var(input, axis=[2,3,4], keepdim=True)
v = paddle.expand_as(v, input)
return paddle.reshape(paddle.sqrt(v+epsilon),(N,C,H,W))
def group_std(x, groups = 32, eps = 1e-5):
N, C, H, W = x.size()
x = torch.reshape(x, (N, groups, C // groups, H, W))
var = torch.var(x, dim = (2, 3, 4), keepdim = True).expand_as(x)
return torch.reshape(torch.sqrt(var + eps), (N, C, H, W))
class EvoNorm(fluid.dygraph.Layer):
def __init__(self, channels, version='B0', affine=True, non_linear=True, groups=32, epsilon=1e-5,momentum=0.9, training=True):
super(EvoNorm, self).__init__()
self.channels = channels
self.affine = affine
self.version = version
self.non_linear = non_linear
self.groups = groups
self.epsilon = epsilon
self.training = training
self.momentum = momentum
if self.affine:
self.gamma = self.create_parameter([1, self.channels, 1, 1],
default_initializer=fluid.initializer.Constant(value=1.0))
self.beta = self.create_parameter([1, self.channels, 1, 1],
default_initializer=fluid.initializer.Constant(value=0.0))
if self.non_linear:
self.v = self.create_parameter([1, self.channels, 1, 1],
default_initializer=fluid.initializer.Constant(value=1.0))
else:
self.register_parameter('gamma', None)
self.register_parameter('beta', None)
self.register_buffer('v', None)
#self.running_var = self.create_parameter([1, self.channels, 1, 1],
# default_initializer=fluid.initializer.Constant(value=0.0))
#self.running_var.stop_gradient = True
#self.register_buffer('running_var', self.create_parameter([1, self.channels, 1, 1],
# default_initializer=fluid.initializer.Constant(value=1.0)))
self.register_buffer('running_var', paddle.fluid.layers.ones(shape=[1,self.channels,1,1], dtype='float32'))
def forward(self, input):
if self.version == 'S0':
if self.non_linear:
num = input * paddle.fluid.layers.sigmoid(self.v * input)
return num / group_std_paddle(input, groups=self.groups, epsilon=self.epsilon) * self.gamma + self.beta
else:
return input * self.gamma + self.beta
if self.version == 'B0':
if self.training:
var = paddle.var(input, axis=[0,2,3], unbiased=False, keepdim=True)
self.running_var = self.running_var * self.momentum
self.running_var = self.running_var + (1- self.momentum) * var
else:
var = self.running_var
if self.non_linear:
den = paddle.elementwise_max(paddle.sqrt((var+self.epsilon)), self.v * input + instance_std_paddle(input, epsilon=self.epsilon))
return input / den * self.gamma + self.beta
else:
return input * self.gamma + self.beta
ppcls/modeling/architectures/resnet.py
浏览文件 @ d4b42a38
# copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve. #copyright (c) 2020 PaddlePaddle Authors. All Rights Reserve.
# #
# Licensed under the Apache License, Version 2.0 (the "License"); #Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License. #you may not use this file except in compliance with the License.
# You may obtain a copy of the License at #You may obtain a copy of the License at
# #
# http://www.apache.org/licenses/LICENSE-2.0 # http://www.apache.org/licenses/LICENSE-2.0
# #
# Unless required by applicable law or agreed to in writing, software #Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, #distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and #See the License for the specific language governing permissions and
# limitations under the License. #limitations under the License.
from __future__ import absolute_import from __future__ import absolute_import
from __future__ import division from __future__ import division
from __future__ import print_function from __future__ import print_function
import numpy as np import math
import paddle import paddle
import paddle.fluid as fluid import paddle.fluid as fluid
from paddle.fluid.param_attr import ParamAttr from paddle.fluid.param_attr import ParamAttr
from paddle.fluid.layer_helper import LayerHelper
from paddle.fluid.dygraph.nn import Conv2D, Pool2D, BatchNorm, Linear, Dropout
import math
__all__ = ["ResNet18", "ResNet34", "ResNet50", "ResNet101", "ResNet152"]
class ConvBNLayer(fluid.dygraph.Layer):
def __init__(self,
num_channels,
num_filters,
filter_size,
stride=1,
groups=1,
act=None,
name=None):
super(ConvBNLayer, self).__init__()
self._conv = Conv2D(
num_channels=num_channels,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
act=None,
param_attr=ParamAttr(name=name + "_weights"),
bias_attr=False)
if name == "conv1":
bn_name = "bn_" + name
else:
bn_name = "bn" + name[3:]
self._batch_norm = BatchNorm(
num_filters,
act=act,
param_attr=ParamAttr(name=bn_name + "_scale"),
bias_attr=ParamAttr(bn_name + "_offset"),
moving_mean_name=bn_name + "_mean",
moving_variance_name=bn_name + "_variance")
def forward(self, inputs): __all__ = [
y = self._conv(inputs) "ResNet", "ResNet18", "ResNet34", "ResNet50", "ResNet101", "ResNet152"
y = self._batch_norm(y) ]
return y
class BottleneckBlock(fluid.dygraph.Layer): class ResNet():
def __init__(self, def __init__(self, layers=50):
num_channels,
num_filters,
stride,
shortcut=True,
name=None):
super(BottleneckBlock, self).__init__()
self.conv0 = ConvBNLayer(
num_channels=num_channels,
num_filters=num_filters,
filter_size=1,
act="relu",
name=name + "_branch2a")
self.conv1 = ConvBNLayer(
num_channels=num_filters,
num_filters=num_filters,
filter_size=3,
stride=stride,
act="relu",
name=name + "_branch2b")
self.conv2 = ConvBNLayer(
num_channels=num_filters,
num_filters=num_filters * 4,
filter_size=1,
act=None,
name=name + "_branch2c")
self.shortcut = shortcut
if not self.shortcut:
self.short = ConvBNLayer(
num_channels=num_channels,
num_filters=num_filters * 4,
filter_size=1,
stride=stride,
name=name + "_branch1")
self._num_channels_out = num_filters * 4
def forward(self, inputs):
y = self.conv0(inputs)
conv1 = self.conv1(y)
conv2 = self.conv2(conv1)
if self.shortcut:
short = inputs
else:
short = self.short(inputs)
y = fluid.layers.elementwise_add(x=short, y=conv2)
layer_helper = LayerHelper(self.full_name(), act="relu")
return layer_helper.append_activation(y)
class BasicBlock(fluid.dygraph.Layer):
def __init__(self,
num_channels,
num_filters,
stride,
shortcut=True,
name=None):
super(BasicBlock, self).__init__()
self.stride = stride
self.conv0 = ConvBNLayer(
num_channels=num_channels,
num_filters=num_filters,
filter_size=3,
stride=stride,
act="relu",
name=name + "_branch2a")
self.conv1 = ConvBNLayer(
num_channels=num_filters,
num_filters=num_filters,
filter_size=3,
act=None,
name=name + "_branch2b")
if not shortcut:
self.short = ConvBNLayer(
num_channels=num_channels,
num_filters=num_filters,
filter_size=1,
stride=stride,
name=name + "_branch1")
self.shortcut = shortcut
def forward(self, inputs):
y = self.conv0(inputs)
conv1 = self.conv1(y)
if self.shortcut:
short = inputs
else:
short = self.short(inputs)
y = fluid.layers.elementwise_add(x=short, y=conv1)
layer_helper = LayerHelper(self.full_name(), act="relu")
return layer_helper.append_activation(y)
class ResNet(fluid.dygraph.Layer):
def __init__(self, layers=50, class_dim=1000):
super(ResNet, self).__init__()
self.layers = layers self.layers = layers
def net(self, input, class_dim=1000, data_format="NCHW"):
layers = self.layers
supported_layers = [18, 34, 50, 101, 152] supported_layers = [18, 34, 50, 101, 152]
assert layers in supported_layers, \ assert layers in supported_layers, \
"supported layers are {} but input layer is {}".format( "supported layers are {} but input layer is {}".format(supported_layers, layers)
supported_layers, layers)
if layers == 18: if layers == 18:
depth = [2, 2, 2, 2] depth = [2, 2, 2, 2]
...@@ -189,25 +45,25 @@ class ResNet(fluid.dygraph.Layer): ...@@ -189,25 +45,25 @@ class ResNet(fluid.dygraph.Layer):
depth = [3, 4, 23, 3] depth = [3, 4, 23, 3]
elif layers == 152: elif layers == 152:
depth = [3, 8, 36, 3] depth = [3, 8, 36, 3]
else: num_filters = [64, 128, 256, 512]
raise ValueError('Input layer is not supported')
num_channels = [64, 256, 512,
1024] if layers >= 50 else [64, 64, 128, 256]
self.conv = ConvBNLayer( conv = self.conv_bn_layer(
num_channels=3, input=input,
num_filters=64, num_filters=64,
filter_size=7, filter_size=7,
stride=2, stride=2,
act="relu", act='relu',
name="conv1") name="conv1",
self.pool2d_max = Pool2D( data_format=data_format)
pool_size=3, pool_stride=2, pool_padding=1, pool_type="max") conv = fluid.layers.pool2d(
input=conv,
self.block_list = [] pool_size=3,
pool_stride=2,
pool_padding=1,
pool_type='max',
data_format=data_format)
if layers >= 50: if layers >= 50:
for block in range(len(depth)): for block in range(len(depth)):
shortcut = False
for i in range(depth[block]): for i in range(depth[block]):
if layers in [101, 152] and block == 2: if layers in [101, 152] and block == 2:
if i == 0: if i == 0:
...@@ -216,80 +72,169 @@ class ResNet(fluid.dygraph.Layer): ...@@ -216,80 +72,169 @@ class ResNet(fluid.dygraph.Layer):
conv_name = "res" + str(block + 2) + "b" + str(i) conv_name = "res" + str(block + 2) + "b" + str(i)
else: else:
conv_name = "res" + str(block + 2) + chr(97 + i) conv_name = "res" + str(block + 2) + chr(97 + i)
bottleneck_block = self.add_sublayer( conv = self.bottleneck_block(
conv_name, input=conv,
BottleneckBlock( num_filters=num_filters[block],
num_channels=num_channels[block] stride=2 if i == 0 and block != 0 else 1,
if i == 0 else num_filters[block] * 4, name=conv_name,
num_filters=num_filters[block], data_format=data_format)
stride=2 if i == 0 and block != 0 else 1,
shortcut=shortcut,
name=conv_name))
self.block_list.append(bottleneck_block)
shortcut = True
else: else:
for block in range(len(depth)): for block in range(len(depth)):
shortcut = False
for i in range(depth[block]): for i in range(depth[block]):
conv_name = "res" + str(block + 2) + chr(97 + i) conv_name = "res" + str(block + 2) + chr(97 + i)
basic_block = self.add_sublayer( conv = self.basic_block(
conv_name, input=conv,
BasicBlock( num_filters=num_filters[block],
num_channels=num_channels[block] stride=2 if i == 0 and block != 0 else 1,
if i == 0 else num_filters[block], is_first=block == i == 0,
num_filters=num_filters[block], name=conv_name,
stride=2 if i == 0 and block != 0 else 1, data_format=data_format)
shortcut=shortcut,
name=conv_name)) pool = fluid.layers.pool2d(
self.block_list.append(basic_block) input=conv,
shortcut = True pool_type='avg',
global_pooling=True,
self.pool2d_avg = Pool2D( data_format=data_format)
pool_size=7, pool_type='avg', global_pooling=True) stdv = 1.0 / math.sqrt(pool.shape[1] * 1.0)
out = fluid.layers.fc(
self.pool2d_avg_channels = num_channels[-1] * 2 input=pool,
size=class_dim,
stdv = 1.0 / math.sqrt(self.pool2d_avg_channels * 1.0) param_attr=fluid.param_attr.ParamAttr(
name="fc_0.w_0",
self.out = Linear( initializer=fluid.initializer.Uniform(-stdv, stdv)),
self.pool2d_avg_channels,
class_dim,
param_attr=ParamAttr(
initializer=fluid.initializer.Uniform(-stdv, stdv),
name="fc_0.w_0"),
bias_attr=ParamAttr(name="fc_0.b_0")) bias_attr=ParamAttr(name="fc_0.b_0"))
return out
def conv_bn_layer(self,
input,
num_filters,
filter_size,
stride=1,
groups=1,
act=None,
name=None,
data_format='NCHW'):
conv = fluid.layers.conv2d(
input=input,
num_filters=num_filters,
filter_size=filter_size,
stride=stride,
padding=(filter_size - 1) // 2,
groups=groups,
act=None,
param_attr=ParamAttr(name=name + "_weights"),
bias_attr=False,
name=name + '.conv2d.output.1',
data_format=data_format)
def forward(self, inputs): if name == "conv1":
y = self.conv(inputs) bn_name = "bn_" + name
y = self.pool2d_max(y) else:
for block in self.block_list: bn_name = "bn" + name[3:]
y = block(y) return fluid.layers.batch_norm(
y = self.pool2d_avg(y) input=conv,
y = fluid.layers.reshape(y, shape=[-1, self.pool2d_avg_channels]) act=act,
y = self.out(y) name=bn_name + '.output.1',
return y param_attr=ParamAttr(name=bn_name + '_scale'),
bias_attr=ParamAttr(bn_name + '_offset'),
moving_mean_name=bn_name + '_mean',
moving_variance_name=bn_name + '_variance',
data_layout=data_format)
def shortcut(self, input, ch_out, stride, is_first, name, data_format):
if data_format == 'NCHW':
ch_in = input.shape[1]
else:
ch_in = input.shape[-1]
if ch_in != ch_out or stride != 1 or is_first == True:
return self.conv_bn_layer(
input, ch_out, 1, stride, name=name, data_format=data_format)
else:
return input
def bottleneck_block(self, input, num_filters, stride, name, data_format):
conv0 = self.conv_bn_layer(
input=input,
num_filters=num_filters,
filter_size=1,
act='relu',
name=name + "_branch2a",
data_format=data_format)
conv1 = self.conv_bn_layer(
input=conv0,
num_filters=num_filters,
filter_size=3,
stride=stride,
act='relu',
name=name + "_branch2b",
data_format=data_format)
conv2 = self.conv_bn_layer(
input=conv1,
num_filters=num_filters * 4,
filter_size=1,
act=None,
name=name + "_branch2c",
data_format=data_format)
short = self.shortcut(
input,
num_filters * 4,
stride,
is_first=False,
name=name + "_branch1",
data_format=data_format)
return fluid.layers.elementwise_add(
x=short, y=conv2, act='relu', name=name + ".add.output.5")
def basic_block(self, input, num_filters, stride, is_first, name,
data_format):
conv0 = self.conv_bn_layer(
input=input,
num_filters=num_filters,
filter_size=3,
act='relu',
stride=stride,
name=name + "_branch2a",
data_format=data_format)
conv1 = self.conv_bn_layer(
input=conv0,
num_filters=num_filters,
filter_size=3,
act=None,
name=name + "_branch2b",
data_format=data_format)
short = self.shortcut(
input,
num_filters,
stride,
is_first,
name=name + "_branch1",
data_format=data_format)
return fluid.layers.elementwise_add(x=short, y=conv1, act='relu')
def ResNet18(**args): def ResNet18():
model = ResNet(layers=18, **args) model = ResNet(layers=18)
return model return model
def ResNet34(**args): def ResNet34():
model = ResNet(layers=34, **args) model = ResNet(layers=34)
return model return model
def ResNet50(**args): def ResNet50():
model = ResNet(layers=50, **args) model = ResNet(layers=50)
return model return model
def ResNet101(**args): def ResNet101():
model = ResNet(layers=101, **args) model = ResNet(layers=101)
return model return model
def ResNet152(**args): def ResNet152():
model = ResNet(layers=152, **args) model = ResNet(layers=152)
return model return model
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或