def __init__(self,
in_c,
out_c,
kernel=(1, 1),
stride=(1, 1),
padding=(0, 0),
groups=1):
super(Conv_block, self).__init__()
# print(in_c, out_c, groups)
self.conv = Conv2d(in_c,
out_c,
kernel_size=kernel,
groups=groups,
stride=stride,
padding=padding,
bias=False)
self.bn = BatchNorm2d(out_c)
self.prelu = PReLU(out_c)
def __init__(self, num_blocks=1):
super().__init__()
print("Initialized generator network..")
self.conv1 = Conv2d(1, 64, kernel_size=9, padding=4)
self.prelu = PReLU()
self.layers = self._get_residual_blocks(num_blocks)
self.conv2 = Conv2d(64, 64, kernel_size=3, padding=1)
self.bn2 = BatchNorm2d(64)
self.conv3 = Conv2d(64, 256, kernel_size=3, padding=1)
self.pxshuffle = PixelShuffle(upscale_factor=2) # up-sampling
# used in original SR-GAN paper, only for 4x up-sampling
# self.conv4 = Conv2d(256, 256, kernel_size=3, padding=1)
self.conv5 = Conv2d(64, 1, kernel_size=9, padding=4)
def __init__(self, in_channels, out_channels, stride):
super(BottleneckIRSE, self).__init__()
self.identity = 0
if in_channels == out_channels:
if stride == 1:
self.identity = 1
else:
self.shortcut_layer = MaxPool2d(1, stride)
else:
self.shortcut_layer = Sequential(
Conv2d(in_channels, out_channels, (1, 1), stride, bias=False),
BatchNorm2d(out_channels))
self.res_layer = Sequential(
BatchNorm2d(in_channels),
Conv2d(in_channels, out_channels, (3, 3), (1, 1), 1, bias=False),
BatchNorm2d(out_channels), PReLU(out_channels),
Conv2d(out_channels, out_channels, (3, 3), stride, 1, bias=False),
BatchNorm2d(out_channels), SEModule(out_channels, 16))
def __init__(self,
in_c,
out_c,
kernel=(1, 1),
stride=(1, 1),
padding=(0, 0),
groups=1,
use_hs=1):
super(Conv_block, self).__init__()
self.conv = Conv2d(in_c,
out_channels=out_c,
kernel_size=kernel,
groups=groups,
stride=stride,
padding=padding,
bias=False)
self.bn = BatchNorm2d(out_c)
self.unlinearity = h_swish() if use_hs else PReLU(out_c)
def __init__(self, input_size, num_layers, mode='ir'):
super(Backbone, self).__init__()
assert input_size[0] in [
112, 224
], "input_size should be [112, 112] or [224, 224]"
assert num_layers in [50, 100,
152], "num_layers should be 50, 100 or 152"
assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se"
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
if input_size[0] == 112:
self.output_layer = Sequential(BatchNorm2d(512), Dropout(),
Flatten(), Linear(512 * 7 * 7, 512),
BatchNorm1d(512))
# # for rknn
# self.output_layer = Sequential(BatchNorm2d(512),
# Conv2d(512,512,(7,7),1,0,bias=True),
# BatchNorm2d(512)
# )
else:
self.output_layer = Sequential(
BatchNorm2d(512),
# Dropout(),
# Flatten(),
Linear(512 * 14 * 14, 512),
BatchNorm1d(512))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
self._initialize_weights()
def __init__(self, scale_factor):
upsample_block_num = int(math.log(scale_factor, 2))
super(Generator, self).__init__()
self.block1 = Sequential(
Conv2d(3, 64, kernel_size=(9, 9), padding=(4, 4)), PReLU())
self.block2 = ResidualBlock(64)
self.block3 = ResidualBlock(64)
self.block4 = ResidualBlock(64)
self.block5 = ResidualBlock(64)
self.block6 = ResidualBlock(64)
self.block7 = Sequential(
Conv2d(64, 64, kernel_size=(3, 3), padding=(1, 1)),
BatchNorm2d(64))
# up sampling
block8 = [UpSampleBlock(64, 2) for _ in range(upsample_block_num)]
block8.append(Conv2d(64, 3, kernel_size=(9, 9), padding=(4, 4)))
self.block8 = Sequential(*block8)
def __init__(self, opts=None):
super(MntToVecEncoderEncoderIntoWPlus, self).__init__()
print('Using MntToVecEncoderEncoderIntoWPlus')
blocks = get_blocks(num_layers=50)
unit_module = bottleneck_SE
self.input_layer = Sequential(
Conv2d(opts.input_nc, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.output_layer_2 = Sequential(BatchNorm2d(512),
torch.nn.AdaptiveAvgPool2d((7, 7)),
Flatten(), Linear(512 * 7 * 7, 512))
self.linear = EqualLinear(512, 512 * 18, lr_mul=1)
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
def __init__(self, num_layers, mode='ir'):
super(Backbone, self).__init__()
assert num_layers in [50, 100,
152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
def __init__(self, num_layers, mode='ir', opts=None):
super(GradualStyleEncoder, self).__init__()
assert num_layers in [50, 100,
152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(
Conv2d(opts.input_nc, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
self.styles = nn.ModuleList()
self.style_count = opts.n_styles
self.coarse_ind = 3
self.middle_ind = 7
for i in range(self.style_count):
if i < self.coarse_ind:
style = GradualStyleBlock(512, 512, 16)
elif i < self.middle_ind:
style = GradualStyleBlock(512, 512, 32)
else:
style = GradualStyleBlock(512, 512, 64)
self.styles.append(style)
self.latlayer1 = nn.Conv2d(256,
512,
kernel_size=1,
stride=1,
padding=0)
self.latlayer2 = nn.Conv2d(128,
512,
kernel_size=1,
stride=1,
padding=0)
def __init__(self, num_layers=50, drop_ratio=0.6, mode='ir'):
super(Backbone_bp, self).__init__()
assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se','cbam','danet'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
print("THe mode is IR")
unit_module = bottleneck_IR
elif mode == 'cbam':
print("The mode is CBAM")
unit_module = bottleneck_CBAM
elif mode == 'danet':
print("The mode is danet")
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64, eps=2e-5, momentum=0.9),
PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512, eps=2e-5, momentum=0.9),
Dropout(drop_ratio),
Flatten(),
Linear(512 * 7 * 7, 256),
BatchNorm1d(256, eps=2e-5, momentum=0.9, affine=False))
modules = []
item = 0
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel,
bottleneck.depth,
bottleneck.stride))
# if item == 0: # 修改第一个block的blockneck的结构
# modules[0].shortcut_layer = Sequential(
# Conv2d(bottleneck.in_channel, bottleneck.depth, (1, 1), bottleneck.stride, bias=False),
# BatchNorm2d(bottleneck.depth, eps=2e-5, momentum=0.9))
# item += 1
if mode == "danet":
modules.append(DANetHead(512,512,BatchNorm2d))
self.body = Sequential(*modules)
def __init__(self,
num_layers,
drop_ratio,
mode='ir',
embedding_size=512,
classnum=51332,
s=64.,
m=0.5):
super(IR_With_Head, self).__init__()
# backbone part
assert num_layers in [50, 100,
152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512), Dropout(drop_ratio),
Flatten(), Linear(512 * 7 * 7, 512),
BatchNorm1d(512))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
# head part
self.classnum = classnum
self.kernel = Parameter(torch.Tensor(embedding_size, classnum))
# initial kernel
self.kernel.data.uniform_(-1, 1).renorm_(2, 1, 1e-5).mul_(1e5)
self.m = m # the margin value, default is 0.5
self.s = s # scalar value default is 64, see normface https://arxiv.org/abs/1704.06369
self.cos_m = math.cos(m)
self.sin_m = math.sin(m)
self.mm = self.sin_m * m # issue 1
self.threshold = math.cos(math.pi - m)
def __init__(self, in_channel, depth, stride):
"""Intermediate Resblock of bottleneck.
Args:
in_channel (int): Input channels.
depth (int): Output channels.
stride (int): Conv2d stride.
"""
super(bottleneck_IR, self).__init__()
if in_channel == depth:
self.shortcut_layer = MaxPool2d(1, stride)
else:
self.shortcut_layer = Sequential(
Conv2d(in_channel, depth, (1, 1), stride, bias=False),
BatchNorm2d(depth))
self.res_layer = Sequential(
BatchNorm2d(in_channel),
Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False),
PReLU(depth), Conv2d(depth, depth, (3, 3), stride, 1, bias=False),
BatchNorm2d(depth))
def __init__(self, in_channel, depth, stride):
super(bottleneck_IR, self).__init__()
# if in_channel == depth:
if stride == 1:
self.shortcut_layer = MaxPool2d(1, stride)
else:
self.shortcut_layer = Sequential(
Conv2d(in_channel, depth, (1, 1), stride, bias=False),
BatchNorm2d(depth))
# self.res_layer = Sequential(
# BatchNorm2d(in_channel),
# Conv2d(in_channel, depth, (3, 3), (1, 1), 1 ,bias=False), PReLU(depth),
# Conv2d(depth, depth, (3, 3), stride, 1 ,bias=False), BatchNorm2d(depth))
self.res_layer = Sequential(
BatchNorm2d(in_channel),
Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False),
BatchNorm2d(depth), # added by fengchen
PReLU(depth),
Conv2d(depth, depth, (3, 3), stride, 1, bias=False),
BatchNorm2d(depth))
def __init__(self, in_channel, depth, stride,set_channel):
super(bottleneck_IR, self).__init__()
# if set_channel!=0:
# print(set_channel)
if in_channel == depth :
# self.shortcut_layer = MaxPool2d(1, stride)
self.shortcut_layer = Sequential()
else:
self.shortcut_layer = Sequential(
Conv2d(in_channel, depth, (1, 1), stride, bias=False), BatchNorm2d(depth,eps=2e-5))
if set_channel==64:
self.shortcut_layer = Sequential(
Conv2d(in_channel, depth, (1, 1), stride, bias=False), BatchNorm2d(depth,eps=2e-5))
self.res_layer = Sequential(
BatchNorm2d(in_channel,eps=2e-5),
Conv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False),
BatchNorm2d(depth,eps=2e-5), # new added
PReLU(depth),
Conv2d(depth, depth, (3, 3), stride, 1, bias=False), BatchNorm2d(depth,eps=2e-5))
def __init__(self, numOfLayer):
super(Backbone_onlyGlobal, self).__init__()
unit_module = bottleneck_IR
self.input_layer = Sequential(
Conv2d(in_channels=3,
out_channels=64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False), BatchNorm2d(64), PReLU(64))
blocks = get_blocks(numOfLayer)
self.layer1 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[0]
]) #get_block(in_channel=64, depth=64, num_units=3)])
self.layer2 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[1]
]) #get_block(in_channel=64, depth=128, num_units=4)])
self.layer3 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[2]
]) #get_block(in_channel=128, depth=256, num_units=14)])
self.layer4 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[3]
]) #get_block(in_channel=256, depth=512, num_units=3)])
self.output_layer = Sequential(
nn.Conv2d(in_channels=512,
out_channels=64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1)))
self.fc = nn.Linear(64, 7)
self.fc.apply(init_weights)
def __init__(self, in_channel, depth, stride):
super(bottleneck_IR_SE, self).__init__()
if in_channel == depth:
# 池化层函数
self.shortcut_layer = MaxPool2d(1, stride)
else:
# 将层的列表传递给Sequential的构造函数，来创建一个Sequential模型
self.shortcut_layer = Sequential(
# nn.BatchNorm2d() 的作用是根据统计的mean 和var来对数据进行标准化，并且这个mena和var在每个batch中都会进行，为了使得数据更有统计意义，
# 使得整个训练数据的特征都能够被保存，则在每个batch过程中，都会对网络的mean和var进行更新，这里就涉及到新的 batch的统计数据mean和
# var与网络已经保存的这两个统计数据之间的取舍问题了，而这个0.8就指定了保存的比例，这个参数名为momentum.
Conv2d(in_channel, depth, (1, 1), stride ,bias=False),
BatchNorm2d(depth))
self.res_layer = Sequential(
BatchNorm2d(in_channel),
Conv2d(in_channel, depth, (3,3), (1,1),1 ,bias=False),
PReLU(depth),
Conv2d(depth, depth, (3,3), stride, 1 ,bias=False),
BatchNorm2d(depth),
SEModule(depth,16)
)
def __init__(self, num_layers=50, drop_ratio=0.4, mode='ir_se'):
super(ResnetFaceSTNLockedShear, self).__init__()
assert num_layers in [50, 100, 152]
assert mode in ['ir', 'ir_se']
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.localization = Sequential(bottleneck_IR(3, 16, 2),
bottleneck_IR(16, 32, 2),
bottleneck_IR(32, 32, 2),
bottleneck_IR(32, 64, 2),
bottleneck_IR(64, 64, 1),
torch.nn.AdaptiveAvgPool2d(1))
self.fc_loc = Sequential(Flatten(), Linear(64 * 1 * 1, 6))
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512), Dropout(drop_ratio),
Flatten(), Linear(512 * 7 * 7, 512),
BatchNorm1d(512))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
self.fc_loc[1].weight.data.zero_()
# WARNING remember to change the bias according to input size
# NOTE for img size 128 -> 112
self.fc_loc[1].bias.data.copy_(
torch.tensor([1, 0, 0, 0, 1, 0], dtype=torch.float32))
self.warp_param_adder = Parameter(torch.ones(1, 1))
def __init__(self, num_layers, drop_ratio=0.4, mode='ir_se'):
super(SE_IR, self).__init__()
assert num_layers in [50, 100,
152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512), Dropout(drop_ratio),
Flatten(), Linear(512 * 7 * 7, 512),
BatchNorm1d(512))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
def __init__(self, num_layers, mode='ir', opts=None):
super(BackboneEncoderUsingLastLayerIntoW, self).__init__()
print('Using BackboneEncoderUsingLastLayerIntoW')
assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(opts.input_nc, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64),
PReLU(64))
self.output_pool = torch.nn.AdaptiveAvgPool2d((1, 1))
self.linear = EqualLinear(512, 512, lr_mul=1)
modules = []
for block in blocks:
for bottleneck in block:
modules.append(unit_module(bottleneck.in_channel,
bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
def __init__(self, input_size, feature_dim, num_layers, mode='ir'):
super(Backbone, self).__init__()
assert input_size[0] in [
112, 128, 224
], "input_size should be [112, 112] or [224, 224]"
assert num_layers in [34, 50, 100,
152], "num_layers should be 50, 100 or 152"
assert mode in ['ir', 'ir_vconv',
'ir_se'], "mode should be ir or ir_se"
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
elif mode == 'ir_vconv':
unit_module = bottleneck_IR_VConv
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.output_layer = Sequential(
BatchNorm2d(512),
Dropout(),
Flatten(),
# Conv2d(512,512,(int(input_size[0]/16),int(input_size[1]/16)),padding=0, dilation=1,bias=False),
Linear(512 * int(input_size[0] / 16) * int(input_size[1] / 16),
feature_dim),
BatchNorm1d(feature_dim),
# Flatten(),
)
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(in_channel=bottleneck.in_channel,
depth=bottleneck.depth,
stride=bottleneck.stride))
self.body = Sequential(*modules)
self._initialize_weights()
def __init__(self, classnum, num_layers, mode='ir'):
super(Backbone, self).__init__()
assert num_layers in [50, 100, 152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64,momentum=0.9,eps=2e-5),
PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512,momentum=0.9,eps=2e-5),
Dropout(0.4),
Flatten(),
Linear(512 * 7 * 7, 512),
BatchNorm1d(512,momentum=0.9,eps=2e-5))
# self.ac_fc=Arcface(classnum=classnum)
self.ac_fc=Arcface(embedding_size=512,classnum=classnum)
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel,
bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
for m in self.modules():
if isinstance(m, nn.Conv2d):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(3. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
n = m.out_features
m.weight.data.normal_(0, math.sqrt(3. / n))
def __init__(self, opts=None):
super(GradualMntToVecEncoder, self).__init__()
print('Using GradualMntToVecEncoder')
blocks = get_blocks(num_layers=50)
unit_module = bottleneck_SE
self.input_layer = Sequential(
Conv2d(opts.input_nc, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
self.styles = nn.ModuleList()
self.style_count = opts.style_count
self.coarse_ind = 3
self.middle_ind = 7
for i in range(self.style_count):
if i < self.coarse_ind:
style = GradualStyleBlock(512, 512, 16)
elif i < self.middle_ind:
style = GradualStyleBlock(512, 512, 32)
else:
style = GradualStyleBlock(512, 512, 64)
self.styles.append(style)
self.latlayer1 = nn.Conv2d(256,
512,
kernel_size=1,
stride=1,
padding=0)
self.latlayer2 = nn.Conv2d(128,
512,
kernel_size=1,
stride=1,
padding=0)
def __init__(self, num_layers, drop_ratio, mode='ir', output=512):
super(Backbone, self).__init__()
assert num_layers in [34, 50, 100,
152], 'num_layers should be 50,100, or 152'
assert mode in ['ir', 'ir_se'], 'mode should be ir or ir_se'
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512), Dropout(drop_ratio),
Flatten(), Linear(512 * 7 * 7, output),
BatchNorm1d(output))
self.body = torch.nn.ModuleList()
for x in range(3):
if x == 0:
self.body.append(bottleneck_IR_SE(64, 64, 2))
else:
self.body.append(bottleneck_IR_SE(64, 64, 1))
for x in range(4):
if x == 0:
self.body.append(bottleneck_IR_SE(64, 128, 2))
else:
self.body.append(bottleneck_IR_SE(128, 128, 1))
for x in range(14):
if x == 0:
self.body.append(bottleneck_IR_SE(128, 256, 2))
else:
self.body.append(bottleneck_IR_SE(256, 256, 1))
for x in range(3):
if x == 0:
self.body.append(bottleneck_IR_SE(256, 512, 2))
else:
self.body.append(bottleneck_IR_SE(512, 512, 1))
def __init__(self):
super().__init__()
blocks = [
get_block(in_channel=64, depth=64, num_units=3),
get_block(in_channel=64, depth=128, num_units=4),
get_block(in_channel=128, depth=256, num_units=14),
get_block(in_channel=256, depth=512, num_units=3)
]
unit_module = bottleneck_IR
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.output_layer = Sequential(BatchNorm2d(512), Dropout(), Flatten(),
Linear(512 * 7 * 7, 512),
BatchNorm1d(512))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
self._initialize_weights()
def __init__(self,
input_size,
num_layers,
mode='ir',
drop_ratio=0.4,
affine=True):
super(Backbone, self).__init__()
assert input_size in [112, 224], "input_size should be 112 or 224"
assert num_layers in [50, 100,
152], "num_layers should be 50, 100 or 152"
assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se"
blocks = get_blocks(num_layers)
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
if input_size == 112:
self.output_layer = Sequential(BatchNorm2d(512),
Dropout(drop_ratio), Flatten(),
Linear(512 * 7 * 7, 512),
BatchNorm1d(512, affine=affine))
else:
self.output_layer = Sequential(BatchNorm2d(512),
Dropout(drop_ratio), Flatten(),
Linear(512 * 14 * 14, 512),
BatchNorm1d(512, affine=affine))
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
self.body = Sequential(*modules)
def __init__(
self, num_layers, drop_ratio, mode="ir", feat_dim=512, out_h=7, out_w=7
):
super(Resnet, self).__init__()
assert num_layers in [
50,
100,
152,
], "num_layers should be 50,100, or 152"
assert mode in ["ir", "ir_se"], "mode should be ir or ir_se"
blocks = get_blocks(num_layers)
if mode == "ir":
unit_module = bottleneck_IR
elif mode == "ir_se":
unit_module = bottleneck_IR_SE
self.input_layer = Sequential(
Conv2d(3, 64, (3, 3), 1, 1, bias=False), BatchNorm2d(64), PReLU(64)
)
self.output_layer = Sequential(
BatchNorm2d(512),
Dropout(drop_ratio),
Flatten(),
Linear(512 * out_h * out_w, feat_dim), # for eye
BatchNorm1d(feat_dim),
)
modules = []
for block in blocks:
for bottleneck in block:
modules.append(
unit_module(
bottleneck.in_channel,
bottleneck.depth,
bottleneck.stride,
)
)
self.body = Sequential(*modules)
def create_activation(act_type: str, inplace: bool, num_channels: int,
**kwargs) -> Module:
"""
Create an activation function using the given parameters.
:param act_type: the type of activation to replace with; options:
[relu, relu6, prelu, lrelu, swish, hardswish, silu]
:param inplace: True to create the activation as an inplace, False otherwise
:param num_channels: The number of channels to create the activation for
:param kwargs: Additional kwargs to pass to the activation constructor
:return: the created activation layer
"""
act_type = act_type.lower()
if act_type == "relu":
return ReLU(num_channels=num_channels, inplace=inplace)
if act_type == "relu6":
return ReLU6(num_channels=num_channels, inplace=inplace)
if act_type == "prelu":
return PReLU(num_parameters=num_channels, **kwargs)
if act_type == "lrelu":
return LeakyReLU(inplace=inplace, **kwargs)
if act_type == "swish":
return Swish(num_channels=num_channels)
if act_type == "hardswish":
return Hardswish(num_channels=num_channels, inplace=inplace)
if act_type == "silu":
return SiLU(**kwargs)
raise ValueError("unknown act_type given of {}".format(act_type))
def __init__(self, input_size, num_layers, mode='ir'):
super(IResNet, self).__init__()
assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se"
if mode == 'ir':
unit_module = bottleneck_IR
elif mode == 'ir_se':
unit_module = bottleneck_IR_SE
else:
raise NotImplementedError
self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
BatchNorm2d(64), PReLU(64))
self.block1 = get_block(unit_module,
in_channel=64,
depth=64,
num_units=num_layers[0])
self.block2 = get_block(unit_module,
in_channel=64,
depth=128,
num_units=num_layers[1])
self.block3 = get_block(unit_module,
in_channel=128,
depth=256,
num_units=num_layers[2])
self.block4 = get_block(unit_module,
in_channel=256,
depth=512,
num_units=num_layers[3])
self.output_layer = Sequential(
BatchNorm2d(512), Dropout(), Flatten(),
Linear(512 * (input_size // 16)**2, 512), BatchNorm1d(512))
self._initialize_weights()
def __init__(self, numOfLayer):
super(Backbone, self).__init__()
unit_module = bottleneck_IR
self.input_layer = Sequential(
Conv2d(in_channels=3,
out_channels=64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1),
bias=False), BatchNorm2d(64), PReLU(64))
blocks = get_blocks(numOfLayer)
self.layer1 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[0]
]) #get_block(in_channel=64, depth=64, num_units=3)])
self.layer2 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[1]
]) #get_block(in_channel=64, depth=128, num_units=4)])
self.layer3 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[2]
]) #get_block(in_channel=128, depth=256, num_units=14)])
self.layer4 = Sequential(*[
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride) for bottleneck in blocks[3]
]) #get_block(in_channel=256, depth=512, num_units=3)])
self.output_layer = Sequential(
nn.Conv2d(in_channels=512,
out_channels=64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)), nn.ReLU(), nn.AdaptiveAvgPool2d((1, 1)))
cropNet_modules = []
cropNet_blocks = [
get_block(in_channel=128, depth=256, num_units=2),
get_block(in_channel=256, depth=512, num_units=2)
]
for block in cropNet_blocks:
for bottleneck in block:
cropNet_modules.append(
unit_module(bottleneck.in_channel, bottleneck.depth,
bottleneck.stride))
cropNet_modules += [
nn.Conv2d(in_channels=512,
out_channels=64,
kernel_size=(3, 3),
stride=(1, 1),
padding=(1, 1)),
nn.ReLU()
]
self.Crop_Net = nn.ModuleList(
[copy.deepcopy(nn.Sequential(*cropNet_modules)) for i in range(5)])
self.fc1 = nn.Linear(64 + 320, 7)
self.fc1.apply(init_weights)
self.fc2 = nn.Linear(64 + 320, 7)
self.fc2.apply(init_weights)
self.GAP = nn.AdaptiveAvgPool2d((1, 1))
import torch
import onnx
from torch.nn import ReLU, PReLU
def myprelu(input, weight=.25):
for i in range(input.shape[0]):
input[i] = input[i] if input[i] >= 0 else weight * input[i]
return input
if __name__ == '__main__':
# testing relu
relu = ReLU()
prelu = PReLU()
td1 = np.array([9., 11., -4., -5., -9., -4., -7., 5., 0., 7.])
res_relu = relu(torch.Tensor(td1))
res_prelu = prelu(torch.Tensor(td1))
myrelu = myprelu(td1)
print("orig ", np.array(td1))
print("relu ", res_relu.detach().numpy())
print("prelu ", res_prelu.detach().numpy())
print("my relu ", myrelu)
print('finished!')
