def __init__(self, num_filters, channels_in, stride):
super(AvgPoolPadding, self).__init__()
self.identity = nn.AvgPool2d(stride, stride=stride)
self.num_zeros = num_filters - channels_in
def __init__(self,
in_channel,
block,
layers,
num_classes=10,
lam=2,
eta_coeff=1.,
init_theta=0.5,
all_filter=False):
super(ResNet_Cifar, self).__init__()
self.inchannel = in_channel
self.lam = lam
self.all_filter = all_filter
self.preprocess = [
'no_op', 'max_3x3', 'max_5x5', 'min_3x3', 'min_5x5', 'ave_3x3',
'ave_5x5', 'sobel_h', 'sobel_w', 'lap_3x3', 'lap_5x5', 'gaus_3x3',
'gaus_5x5', 'shap_4', 'shap_8', 'bin_0.5'
]
self.d = len(self.preprocess) * self.inchannel
self.inplanes = 16
self.conv1 = nn.Conv2d(self.d,
16,
kernel_size=3,
stride=1,
padding=1,
bias=False)
self.bn1 = nn.BatchNorm2d(16)
self.relu = nn.ReLU(inplace=True)
self.layer1 = self._make_layer(block, 16, layers[0])
self.layer2 = self._make_layer(block, 32, layers[1], stride=2)
self.layer3 = self._make_layer(block, 64, layers[2], stride=2)
self.avgpool = nn.AvgPool2d(8, stride=1)
self.fc = nn.Linear(64 * block.expansion, num_classes)
func0 = FilterProcess(None) # no operation
func1 = MaxOrMinFilterProcess(3, True)
func2 = MaxOrMinFilterProcess(5, True)
func3 = MaxOrMinFilterProcess(3, False)
func4 = MaxOrMinFilterProcess(5, False)
func5 = FilterProcess(f.ave_3x3)
func6 = FilterProcess(f.ave_5x5)
func7 = FilterProcess(f.sobel_h)
func8 = FilterProcess(f.sobel_w)
func9 = FilterProcess(f.lap_3x3)
func10 = FilterProcess(f.lap_5x5)
func11 = FilterProcess(f.gaus_3x3)
func12 = FilterProcess(f.gaus_5x5)
func13 = FilterProcess(f.shap_4)
func14 = FilterProcess(f.shap_8)
func15 = Binarization(0.5)
self.preprocess_listR = [
func0, func1, func2, func3, func4, func5, func6, func7, func8,
func9, func10, func11, func12, func13, func14, func15
]
self.preprocess_listG = [
func0, func1, func2, func3, func4, func5, func6, func7, func8,
func9, func10, func11, func12, func13, func14, func15
]
self.preprocess_listB = [
func0, func1, func2, func3, func4, func5, func6, func7, func8,
func9, func10, func11, func12, func13, func14, func15
]
init_theta = init_theta * np.ones(self.d)
non_inc_f = W.SelectionNonIncFunc(threshold=0.25, negative_weight=True)
w = W.QuantileBasedWeight(non_inc_f=non_inc_f,
tie_case=True,
normalization=False,
min_problem=True)
self.igo = BernoulliIGO(d=self.d,
weight_func=w,
theta=init_theta,
eta=eta_coeff / self.d,
theta_max=1. - 1. / self.d,
theta_min=1. / self.d)
self.arch = self.igo.sampling_model().sampling(self.lam)
for m in self.modules():
if isinstance(nn.Conv2d):
nn.init.kaiming_normal_(m.weight,
mode='fan_out',
nonlinearity='relu')
elif isinstance(m, nn.BatchNorm2d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
def __init__(self, in_channels: int = 3, num_classes=1000, version=1.0):
super(SqueezeNet, self).__init__()
if version not in [1.0, 1.1]:
raise ValueError("Unsupported SqueezeNet version {version}:"
"1.0 or 1.1 expected".format(version=version))
self.num_classes = num_classes
if version == 1.0:
self.features = nn.Sequential(
nn.Conv2d(in_channels, 96, kernel_size=7, stride=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
Fire(96, 16, 64, 64),
Fire(128, 16, 64, 64),
Fire(128, 32, 128, 128),
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
Fire(256, 32, 128, 128),
Fire(256, 48, 192, 192),
Fire(384, 48, 192, 192),
Fire(384, 64, 256, 256),
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
Fire(512, 64, 256, 256),
)
else:
self.features = nn.Sequential(
nn.Conv2d(in_channels, 64, kernel_size=3, stride=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
Fire(64, 16, 64, 64),
Fire(128, 16, 64, 64),
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
Fire(128, 32, 128, 128),
Fire(256, 32, 128, 128),
nn.MaxPool2d(kernel_size=3, stride=2, ceil_mode=True),
Fire(256, 48, 192, 192),
Fire(384, 48, 192, 192),
Fire(384, 64, 256, 256),
Fire(512, 64, 256, 256),
)
# Final convolution is initialized differently form the rest
final_conv = nn.Conv2d(512, 1024, kernel_size=1)
self.classifier = nn.Sequential(nn.Dropout(p=0.5), final_conv,
nn.ReLU(inplace=True),
nn.AvgPool2d(13))
# TODO 在Squeezenet最后增加了linear评价器和分类器
self.critic_linear = nn.Linear(1024, 1) # value function 评价器
self.cls_linear = Categorical(1024, num_classes) # classification 分类器
self.train() # 设置成训练模式
self.apply(weights_init) # 初始化相关参数
for m in self.modules():
if isinstance(m, nn.Conv2d):
gain = 2.0
if m is final_conv:
m.weight.data.normal_(0, 0.01)
else:
fan_in = m.kernel_size[0] * m.kernel_size[1] * m.in_channels
u = math.sqrt(3.0 * gain / fan_in)
m.weight.data.uniform_(-u, u)
if m.bias is not None:
m.bias.data.zero_()
import torch
import torch.nn as nn
OPS = {
'none':
lambda C, stride, affine: Zero(stride),
'avg_pool_3x3':
lambda C, stride, affine: nn.AvgPool2d(
3, stride=stride, padding=1, count_include_pad=False),
'max_pool_3x3':
lambda C, stride, affine: nn.MaxPool2d(3, stride=stride, padding=1),
'skip_connect':
lambda C, stride, affine: Identity()
if stride == 1 else FactorizedReduce(C, C, affine=affine),
'sep_conv_3x3':
lambda C, stride, affine: SepConv(C, C, 3, stride, 1, affine=affine),
'sep_conv_5x5':
lambda C, stride, affine: SepConv(C, C, 5, stride, 2, affine=affine),
'dil_conv_3x3':
lambda C, stride, affine: DilConv(C, C, 3, stride, 2, 2, affine=affine),
'dil_conv_5x5':
lambda C, stride, affine: DilConv(C, C, 5, stride, 4, 2, affine=affine),
'conv_7x1_1x7':
lambda C, stride, affine: nn.Sequential(
nn.ReLU(inplace=False),
nn.Conv2d(C, C,
(1, 7), stride=(1, stride), padding=(0, 3), bias=False),
nn.Conv2d(C, C,
(7, 1), stride=(stride, 1), padding=(3, 0), bias=False),
nn.BatchNorm2d(C, affine=affine)),
}
def __init__(self,
in_channels,
out_channels,
d_spectral_norm,
leaky_relu,
synchronized_bn,
downsample=True):
super(DiscBlock, self).__init__()
self.d_spectral_norm = d_spectral_norm
self.downsample = downsample
if leaky_relu:
self.activation = nn.LeakyReLU(negative_slope=0.1, inplace=True)
else:
self.activation = nn.ReLU(inplace=True)
self.ch_mismatch = False
if in_channels != out_channels:
self.ch_mismatch = True
if d_spectral_norm:
if self.ch_mismatch or downsample:
self.conv2d0 = snconv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
stride=1,
padding=0)
self.conv2d1 = snconv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=3,
stride=1,
padding=1)
self.conv2d2 = snconv2d(in_channels=out_channels,
out_channels=out_channels,
kernel_size=3,
stride=1,
padding=1)
else:
if self.ch_mismatch or downsample:
self.conv2d0 = conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=1,
stride=1,
padding=0)
self.conv2d1 = conv2d(in_channels=in_channels,
out_channels=out_channels,
kernel_size=3,
stride=1,
padding=1)
self.conv2d2 = conv2d(in_channels=out_channels,
out_channels=out_channels,
kernel_size=3,
stride=1,
padding=1)
if synchronized_bn:
if self.ch_mismatch or downsample:
self.bn0 = sync_batchnorm_2d(in_features=in_channels)
self.bn1 = sync_batchnorm_2d(in_features=in_channels)
self.bn2 = sync_batchnorm_2d(in_features=out_channels)
else:
if self.ch_mismatch or downsample:
self.bn0 = batchnorm_2d(in_features=in_channels)
self.bn1 = batchnorm_2d(in_features=in_channels)
self.bn2 = batchnorm_2d(in_features=out_channels)
self.average_pooling = nn.AvgPool2d(2)
def forward(self, x):
dim = x.size()
pool = nn.AvgPool2d(dim[-1])
x = pool(x)
return x.view(dim[0], dim[1])
def __init__(self, nIn, nOut, stride):
super(DownsampleB, self).__init__()
self.avg = nn.AvgPool2d(stride)
self.expand_ratio = nOut // nIn
def create_modules(blocks, print_net=True):
net_info = blocks[
0] #Captures the information about the input and pre-processing
module_list = nn.ModuleList()
index = 0 #indexing blocks helps with implementing route layers (skip connections)
prev_filters = 3
output_filters = []
for x in blocks:
if (x["type"] == "net"):
continue
if (print_net is True):
print(str(index) + " " + str(x))
module = nn.Sequential()
#fx YOLO input layer
if (x["type"] == "input"):
module_list.append(module)
output_filters.append(0)
index += 1
continue
#If it's a convolutional layer
if (x["type"] == "convolutional"
or x["type"] == "dilated_convolutional"
): #dilated_convolutional for deeplab
#Get the info about the layer
try:
activation = x["activation"]
except:
activation = ""
try:
batch_normalize = int(x["batch_normalize"])
except:
batch_normalize = 0
if batch_normalize > 0:
bias = False
else:
bias = True
filters = int(x["filters"])
padding = int(x.get("pad", 0))
try:
kernel_size = int(x["size"])
kernel_size_w = kernel_size
kernel_size_h = kernel_size
except:
kernel_size_w = int(x["size_w"])
kernel_size_h = int(x["size_h"])
stride = int(x["stride"])
rate = int(x.get("rate", 1))
groups = int(x.get("groups", 1))
if padding:
pad = (kernel_size - 1) // 2
else:
pad = 0
#Add the convolutional layer
#conv = nn.Conv2d(prev_filters, filters, kernel_size, stride, pad, bias = bias, dilation=rate)
conv = nn.Conv2d(prev_filters,
filters, (kernel_size_h, kernel_size_w),
stride,
pad,
bias=bias,
dilation=rate,
groups=groups)
if rate > 1:
module.add_module("dilated_conv_{0}".format(index), conv)
else:
module.add_module("conv_{0}".format(index), conv)
#Add the Batch Norm Layer
if batch_normalize:
bn = nn.BatchNorm2d(filters)
module.add_module("batch_norm_{0}".format(index), bn)
#Check the activation.
#It is either Linear or a Leaky ReLU for YOLO
if activation == "leaky":
activn = nn.LeakyReLU(0.1, inplace=True)
module.add_module("leaky_{0}".format(index), activn)
#If it's an upsampling layer
#We use Bilinear2dUpsampling
elif (x["type"] == "upsample"):
stride = int(x["stride"])
# upsample = Upsample(stride)
upsample = nn.Upsample(scale_factor=2, mode="nearest")
module.add_module("upsample_{}".format(index), upsample)
#If it is a route layer
elif (x["type"] == "route"):
route = EmptyLayer()
module.add_module("route_{0}".format(index), route)
x["layers"] = x["layers"].split(',')
filters = 0
for layer in x["layers"]:
i = int(layer)
if i > 0:
i -= index
if i < 0:
filters += output_filters[index + i]
##Start of a route
#start = int(x["layers"][0])
#
##end, if there exists one.
#try:
# end = int(x["layers"][1])
#except:
# end = 0
#
##Positive anotation
#if start > 0:
# start = start - index
#
#if end > 0:
# end = end - index
#
#if end < 0:
# filters = output_filters[index + start] + output_filters[index + end]
#else:
# filters= output_filters[index + start]
#shortcut corresponds to skip connection
elif x["type"] == "shortcut":
from_ = int(x["from"])
shortcut = EmptyLayer()
module.add_module("shortcut_{}".format(index), shortcut)
elif x["type"] == "maxpool":
stride = int(x["stride"])
size = int(x["size"])
if stride != 1:
maxpool = nn.MaxPool2d(size, stride)
else:
maxpool = MaxPoolStride1(size)
module.add_module("maxpool_{}".format(index), maxpool)
#Yolo is the detection layer
elif x["type"] == "yolo":
mask = x["mask"].split(",")
mask = [int(x) for x in mask]
anchors = x["anchors"].split(",")
anchors = [int(a) for a in anchors]
anchors = [(anchors[i], anchors[i + 1])
for i in range(0, len(anchors), 2)]
anchors = [anchors[i] for i in mask]
detection = DetectionLayer(anchors)
module.add_module("Detection_{}".format(index), detection)
elif x["type"] == "softmax": #for deeplab
spatial = int(x["spatial"])
softmax = EmptyLayer()
module.add_module("softmax_{}".format(index), softmax)
elif x["type"] == "bilinear": #for deeplab
stride = int(x["stride"])
bilinear = nn.UpsamplingBilinear2d(scale_factor=stride)
module.add_module("bilinear_{}".format(index), bilinear)
elif x["type"] == "avgpool": #for deeplab
avgpool = nn.AvgPool2d(1)
module.add_module("avgpool_{}".format(index), avgpool)
####
#elif x["type"] == "connected":#for vgg16
# output = int(x["output"])
# connected = nn.Linear( ,output)
elif x["type"] == "dropout": #for vgg16
dropout = nn.Dropout(p=0.5)
module.add_module("dropout_{}".format(index), dropout)
else:
print("Something I dunno: " + x["type"])
assert False
module_list.append(module)
prev_filters = filters
output_filters.append(filters)
index += 1
return (net_info, module_list)
def _make_layer(self,
block,
planes,
blocks,
stride=1,
dilate=False,
replace_stride_with_avgpool=False):
norm_name = self.norm_name
norm_name_base = self.norm_name_base
norm_groups = self.norm_groups
norm_k = self.norm_k
norm_attention_mode = self.norm_attention_mode
norm_all_mix = self.norm_all_mix
downsample = None
previous_dilation = self.dilation
if dilate:
self.dilation *= stride
stride = 1
downsample_op = []
if stride != 1 or self.inplanes != planes * block.expansion:
downsample_stride = stride
if replace_stride_with_avgpool and stride > 1:
downsample_op.append(nn.AvgPool2d((stride, stride), stride))
downsample_stride = 1
downsample_op.append(
conv1x1(self.inplanes, planes * block.expansion,
downsample_stride))
downsample_op.append(
FeatureNorm(norm_name_base,
planes * block.expansion,
num_groups=norm_groups,
num_k=norm_k,
attention_mode=norm_attention_mode))
if len(downsample_op) > 0:
downsample = nn.Sequential(*downsample_op)
layers = []
layers.append(
block(self.inplanes,
planes,
stride,
downsample,
self.groups,
base_width=self.base_width,
dilation=previous_dilation,
norm_name=norm_name,
norm_groups=norm_groups,
norm_k=norm_k,
norm_attention_mode=norm_attention_mode,
norm_all_mix=norm_all_mix))
self.inplanes = planes * block.expansion
for _ in range(1, blocks):
layers.append(
block(self.inplanes,
planes,
groups=self.groups,
base_width=self.base_width,
dilation=self.dilation,
norm_name=norm_name,
norm_groups=norm_groups,
norm_k=norm_k,
norm_attention_mode=norm_attention_mode,
norm_all_mix=norm_all_mix))
if self.extra_norm_ac:
layers.append(self._extra_norm_ac(self.inplanes, norm_k))
return nn.Sequential(*layers)
def lua_recursive_model(module, seq):
for m in module.modules:
name = type(m).__name__
real = m
if name == 'TorchObject':
name = m._typename.replace('cudnn.', '')
m = m._obj
if name == 'SpatialConvolution' or name == 'nn.SpatialConvolutionMM':
if not hasattr(m, 'groups') or m.groups is None:
m.groups = 1
n = nn.Conv2d(
m.nInputPlane,
m.nOutputPlane, (m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH),
1,
m.groups,
bias=(m.bias is not None))
copy_param(m, n)
add_submodule(seq, n)
elif name == 'SpatialBatchNormalization':
n = nn.BatchNorm2d(
m.running_mean.size(0), m.eps, m.momentum, m.affine)
copy_param(m, n)
add_submodule(seq, n)
elif name == 'VolumetricBatchNormalization':
n = nn.BatchNorm3d(
m.running_mean.size(0), m.eps, m.momentum, m.affine)
copy_param(m, n)
add_submodule(seq, n)
elif name == 'ReLU':
n = nn.ReLU()
add_submodule(seq, n)
elif name == 'Sigmoid':
n = nn.Sigmoid()
add_submodule(seq, n)
elif name == 'SpatialMaxPooling':
n = nn.MaxPool2d(
(m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH),
ceil_mode=m.ceil_mode)
add_submodule(seq, n)
elif name == 'SpatialAveragePooling':
n = nn.AvgPool2d(
(m.kW, m.kH), (m.dW, m.dH), (m.padW, m.padH),
ceil_mode=m.ceil_mode)
add_submodule(seq, n)
elif name == 'SpatialUpSamplingNearest':
n = nn.UpsamplingNearest2d(scale_factor=m.scale_factor)
add_submodule(seq, n)
elif name == 'View':
n = Lambda(lambda x: x.view(x.size(0), -1))
add_submodule(seq, n)
elif name == 'Reshape':
n = Lambda(lambda x: x.view(x.size(0), -1))
add_submodule(seq, n)
elif name == 'Linear':
# Linear in pytorch only accept 2D input
n1 = Lambda(lambda x: x.view(1, -1) if 1 == len(x.size()) else x)
n2 = nn.Linear(
m.weight.size(1), m.weight.size(0), bias=(m.bias is not None))
copy_param(m, n2)
n = nn.Sequential(n1, n2)
add_submodule(seq, n)
elif name == 'Dropout':
m.inplace = False
n = nn.Dropout(m.p)
add_submodule(seq, n)
elif name == 'SoftMax':
n = nn.Softmax()
add_submodule(seq, n)
elif name == 'Identity':
n = Lambda(lambda x: x) # do nothing
add_submodule(seq, n)
elif name == 'SpatialFullConvolution':
n = nn.ConvTranspose2d(m.nInputPlane, m.nOutputPlane, (m.kW, m.kH),
(m.dW, m.dH), (m.padW, m.padH),
(m.adjW, m.adjH))
copy_param(m, n)
add_submodule(seq, n)
elif name == 'VolumetricFullConvolution':
n = nn.ConvTranspose3d(m.nInputPlane, m.nOutputPlane,
(m.kT, m.kW, m.kH), (m.dT, m.dW, m.dH),
(m.padT, m.padW, m.padH),
(m.adjT, m.adjW, m.adjH), m.groups)
copy_param(m, n)
add_submodule(seq, n)
elif name == 'SpatialReplicationPadding':
n = nn.ReplicationPad2d((m.pad_l, m.pad_r, m.pad_t, m.pad_b))
add_submodule(seq, n)
elif name == 'SpatialReflectionPadding':
n = nn.ReflectionPad2d((m.pad_l, m.pad_r, m.pad_t, m.pad_b))
add_submodule(seq, n)
elif name == 'Copy':
n = Lambda(lambda x: x) # do nothing
add_submodule(seq, n)
elif name == 'Narrow':
n = Lambda(
lambda x, a=(m.dimension, m.index, m.length): x.narrow(*a))
add_submodule(seq, n)
elif name == 'SpatialCrossMapLRN':
lrn = lnn.SpatialCrossMapLRN(m.size, m.alpha, m.beta, m.k)
n = Lambda(lambda x: Variable(lrn.forward(x.data)))
add_submodule(seq, n)
elif name == 'Sequential':
n = nn.Sequential()
lua_recursive_model(m, n)
add_submodule(seq, n)
elif name == 'ConcatTable': # output is list
n = LambdaMap(lambda x: x)
lua_recursive_model(m, n)
add_submodule(seq, n)
elif name == 'CAddTable': # input is list
n = LambdaReduce(lambda x, y: x + y)
add_submodule(seq, n)
elif name == 'Concat':
dim = m.dimension
n = LambdaReduce(lambda x, y: torch.cat((x, y), dim))
lua_recursive_model(m, n)
add_submodule(seq, n)
elif name == 'SpatialZeroPadding':
n = nn.ZeroPad2d([m.pad_l, m.pad_r, m.pad_t, m.pad_b])
add_submodule(seq, n)
elif (name == 'SpatialUpSamplingBilinear'
or name == 'nn.SpatialUpSamplingBilinear'):
size = [m.oheight, m.owidth]
if m.oheight is None or m.owidth is None:
size = None
n = nn.UpSample(size, m.scale_factor, mode='bilinear')
add_submodule(seq, n)
elif name == 'TorchObject':
print('Not Implement', name, real._typename)
else:
print('Not Implement', name)
def __init__(self,
block,
layers,
num_classes=10,
embed_dim=10,
hidden_dim=10,
gate_type='rnn',
in_planes=64):
self.inplanes = in_planes
super(ResNetRecurrentGateSP, self).__init__()
self.num_layers = layers
# self.conv1 = conv3x3(3, 16, input_signed=True, predictive_forward=False, writer_prefix='conv1')
self.conv1 = conv3x3(3,
in_planes,
input_signed=True,
predictive_forward=False,
writer_prefix='conv1')
# self.bn1 = nn.BatchNorm2d(16)
self.bn1 = nn.BatchNorm2d(in_planes)
self.relu = nn.ReLU(inplace=True)
self.embed_dim = embed_dim
self.hidden_dim = hidden_dim
# self._make_group(block, 16, layers[0], group_id=1, pool_size=32, writer_prefix='group_1')
# self._make_group(block, 32, layers[1], group_id=2, pool_size=16, writer_prefix='group_2')
# self._make_group(block, 64, layers[2], group_id=3, pool_size=8, writer_prefix='group_3')
if in_planes == 16:
self._make_group(block,
16,
layers[0],
group_id=1,
pool_size=32,
writer_prefix='group_1')
self._make_group(block,
32,
layers[1],
group_id=2,
pool_size=16,
writer_prefix='group_2')
self._make_group(block,
64,
layers[2],
group_id=3,
pool_size=8,
writer_prefix='group_3')
final_pool_size = 8
final_channel_number = 64
elif in_planes == 64:
self._make_group(block,
64,
layers[0],
group_id=1,
pool_size=32,
writer_prefix='group_1')
self._make_group(block,
128,
layers[1],
group_id=2,
pool_size=16,
writer_prefix='group_2')
self._make_group(block,
256,
layers[2],
group_id=3,
pool_size=8,
writer_prefix='group_3')
self._make_group(block,
512,
layers[3],
group_id=4,
pool_size=4,
writer_prefix='group_4')
final_pool_size = 4
final_channel_number = 512
# define recurrent gating module
# self.avgpool = nn.AvgPool2d(8)
self.avgpool = nn.AvgPool2d(final_pool_size)
print(num_classes)
# self.fc = nn.Linear(64 * block.expansion, num_classes)
self.fc = nn.Linear(final_channel_number * block.expansion,
num_classes)
for m in self.modules():
if isinstance(m, (nn.Conv2d, PredictiveConv2d)):
n = m.kernel_size[0] * m.kernel_size[1] * m.out_channels
m.weight.data.normal_(0, math.sqrt(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
n = m.weight.size(0) * m.weight.size(1)
m.weight.data.normal_(0, math.sqrt(2. / n))
def __init__(self,
depth,
step_size=2.0,
momentum=0.5,
num_classes=1000,
block_name='BasicBlock',
feature_vec='x'):
super(MomentumNet, self).__init__()
# Model type specifies number of layers for CIFAR-10 model
if block_name.lower() == 'basicblock':
assert (
depth - 2
) % 6 == 0, 'When use basicblock, depth should be 6n+2, e.g. 20, 32, 44, 56, 110, 1202'
n = (depth - 2) // 6
block = BasicBlock
elif block_name.lower() == 'bottleneck':
assert (
depth - 2
) % 9 == 0, 'When use bottleneck, depth should be 9n+2, e.g. 20, 29, 47, 56, 110, 1199'
n = (depth - 2) // 9
block = Bottleneck
else:
raise ValueError('block_name shoule be Basicblock or Bottleneck')
self.inplanes = 16
# for momentum net
self.step_size = step_size
self.momentum = momentum
self.feature_vec = feature_vec
self.conv1 = nn.Conv2d(3, 16, kernel_size=3, padding=1, bias=False)
self.layer1 = self._make_layer(block,
16,
n,
step_size=self.step_size,
momentum=self.momentum)
self.layer2 = self._make_layer(block,
32,
n,
stride=2,
step_size=self.step_size,
momentum=self.momentum)
self.layer3 = self._make_layer(block,
64,
n,
stride=2,
step_size=self.step_size,
momentum=self.momentum)
self.bn = nn.BatchNorm2d(64 * block.expansion)
self.relu = nn.ReLU(inplace=True)
self.avgpool = nn.AvgPool2d(8)
self.fc = nn.Linear(64 * block.expansion, num_classes)
self.loss = nn.CrossEntropyLoss()
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(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self, n_classes=42):
super().__init__()
self.conv1 = nn.Sequential(
nn.Conv2d(in_channels=3, out_channels=32, kernel_size=7, stride=2),
nn.ReLU(),
nn.AvgPool2d(kernel_size=3, stride=2)
)
self.conv2 = nn.Sequential(
nn.Conv2d(in_channels=32, out_channels=64, kernel_size=5, stride=2),
nn.BatchNorm2d(64),
nn.ReLU(),
nn.AvgPool2d(kernel_size=3, stride=2)
)
self.conv3 = nn.Sequential(
nn.Conv2d(in_channels=64, out_channels=128, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(128),
nn.ReLU(),
)
self.conv4 = nn.Sequential(
nn.Conv2d(in_channels=128, out_channels=256, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(256),
nn.ReLU(),
)
self.conv5 = nn.Sequential(
nn.Conv2d(in_channels=256, out_channels=256, kernel_size=3, stride=1, padding=1),
nn.BatchNorm2d(256),
nn.ReLU()
)
self.conv6 = nn.Sequential(
nn.Conv2d(in_channels=256, out_channels=256, kernel_size=2),
nn.BatchNorm2d(256),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2)
)
self.fc1 = nn.Sequential(
nn.Linear(4 * 4 * 256, 2048),
nn.BatchNorm1d(2048),
nn.ReLU(),
)
self.fc2 = nn.Sequential(
nn.Linear(2048, 2048),
nn.BatchNorm1d(2048),
nn.ReLU()
)
self.fc3 = nn.Sequential(
nn.Linear(2048, 2048),
nn.BatchNorm1d(2048),
nn.ReLU()
)
self.fc4 = nn.Sequential(
nn.Linear(2048, n_classes),
)
def __init__(self):
super(Generator, self).__init__()
self.det_conv0 = nn.Sequential(nn.Conv2d(4, 32, 3, 1, 1), nn.ReLU())
self.det_conv1 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(),
nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU())
self.det_conv2 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(),
nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU())
self.det_conv3 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(),
nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU())
self.det_conv4 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(),
nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU())
self.det_conv5 = nn.Sequential(nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU(),
nn.Conv2d(32, 32, 3, 1, 1), nn.ReLU())
self.conv_i = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1),
nn.Sigmoid())
self.conv_f = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1),
nn.Sigmoid())
self.conv_g = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1), nn.Tanh())
self.conv_o = nn.Sequential(nn.Conv2d(32 + 32, 32, 3, 1, 1),
nn.Sigmoid())
self.det_conv_mask = nn.Sequential(nn.Conv2d(32, 1, 3, 1, 1),
#nn.Conv2d(64, 1, 3, 1, 1),
)
self.conv1 = nn.Sequential(
nn.Conv2d(4, 64, 5, 1, 2),
#nn.BatchNorm2d(64),
nn.ReLU())
self.conv2 = nn.Sequential(
nn.Conv2d(64, 128, 3, 2, 1),
#nn.BatchNorm2d(128),
nn.ReLU())
self.conv3 = nn.Sequential(
nn.Conv2d(128, 128, 3, 1, 1),
#nn.BatchNorm2d(128),
nn.ReLU())
self.conv4 = nn.Sequential(
nn.Conv2d(128, 256, 3, 2, 1),
#nn.BatchNorm2d(256),
nn.ReLU())
self.conv5 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 1),
#nn.BatchNorm2d(256),
nn.ReLU())
self.conv6 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 1),
#nn.BatchNorm2d(256),
nn.ReLU())
self.diconv1 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 2, dilation=2),
#nn.BatchNorm2d(256),
nn.ReLU())
self.diconv2 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 4, dilation=4),
#nn.BatchNorm2d(256),
nn.ReLU())
self.diconv3 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 8, dilation=8),
#nn.BatchNorm2d(256),
nn.ReLU())
self.diconv4 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 16, dilation=16),
#nn.BatchNorm2d(256)
nn.ReLU())
self.conv7 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 1),
#nn.BatchNorm2d(256),
nn.ReLU())
self.conv8 = nn.Sequential(
nn.Conv2d(256, 256, 3, 1, 1),
#nn.BatchNorm2d(256),
nn.ReLU())
self.deconv1 = nn.Sequential(
nn.ConvTranspose2d(256, 128, 4, 2, 1),
nn.ReflectionPad2d((1, 0, 1, 0)),
nn.AvgPool2d(2, stride=1),
#nn.BatchNorm2d(128),
nn.ReLU())
self.conv9 = nn.Sequential(
nn.Conv2d(128, 128, 3, 1, 1),
#nn.BatchNorm2d(128),
nn.ReLU())
self.deconv2 = nn.Sequential(
nn.ConvTranspose2d(128, 64, 4, 2, 1),
nn.ReflectionPad2d((1, 0, 1, 0)),
nn.AvgPool2d(2, stride=1),
#nn.BatchNorm2d(64),
nn.ReLU())
self.conv10 = nn.Sequential(
nn.Conv2d(64, 32, 3, 1, 1),
#nn.BatchNorm2d(32),
nn.ReLU())
self.outframe1 = nn.Sequential(nn.Conv2d(256, 3, 3, 1, 1), nn.ReLU())
self.outframe2 = nn.Sequential(nn.Conv2d(128, 3, 3, 1, 1), nn.ReLU())
self.output = nn.Sequential(nn.Conv2d(32, 3, 3, 1, 1),
#nn.Sigmoid()
)
def __init__(self, nIn, nOut, stride=2):
super(DownsampleB, self).__init__()
self.avg = nn.AvgPool2d(stride)
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, 3, 2)
self.conv2 = nn.Conv2d(N, 64, 3, 2)
self.conv3 = nn.Conv2d(64, 10, 3, 1)
self.GAP = nn.AvgPool2d((4, 4), stride=1, padding=0)
def transition_block(in_channels, out_channels):
blk = nn.Sequential(nn.BatchNorm2d(in_channels), nn.ReLU(),
nn.Conv2d(in_channels, out_channels, kernel_size=1),
nn.AvgPool2d(kernel_size=2, stride=2))
return blk
def __init__(self, num_classes=1001):
super(InceptionResNetV2, self).__init__()
# Special attributs
self.input_space = None
self.input_size = (299, 299, 3)
self.mean = None
self.std = None
# Modules
self.conv2d_1a = BasicConv2d(3, 32, kernel_size=3, stride=2)
self.conv2d_2a = BasicConv2d(32, 32, kernel_size=3, stride=1)
self.conv2d_2b = BasicConv2d(32, 64, kernel_size=3, stride=1, padding=1)
self.maxpool_3a = nn.MaxPool2d(3, stride=2)
self.conv2d_3b = BasicConv2d(64, 80, kernel_size=1, stride=1)
self.conv2d_4a = BasicConv2d(80, 192, kernel_size=3, stride=1)
self.maxpool_5a = nn.MaxPool2d(3, stride=2)
self.mixed_5b = Mixed_5b()
self.repeat = nn.Sequential(
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17),
Block35(scale=0.17)
)
self.mixed_6a = Mixed_6a()
self.repeat_1 = nn.Sequential(
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10),
Block17(scale=0.10)
)
self.mixed_7a = Mixed_7a()
self.repeat_2 = nn.Sequential(
Block8(scale=0.20),
Block8(scale=0.20),
Block8(scale=0.20),
Block8(scale=0.20),
Block8(scale=0.20),
Block8(scale=0.20),
Block8(scale=0.20),
Block8(scale=0.20),
Block8(scale=0.20)
)
self.block8 = Block8(no_relu=True)
self.conv2d_7b = BasicConv2d(2080, 1536, kernel_size=1, stride=1)
self.avgpool_1a = nn.AvgPool2d(8, count_include_pad=False)
self.last_linear = nn.Linear(1536, num_classes)
def __init__(self, classes, n_way=2, n_shot=5, g=True, l=True, p=True):
super(_narpnRCNN, self).__init__()
self.classes = classes
self.n_classes = len(classes)
# loss
self.RCNN_loss_cls = 0
self.RCNN_loss_bbox = 0
# define rpn
self.RCNN_rpn = _RPN(self.dout_base_model)
# for proposal-target matching
self.RCNN_proposal_target = _ProposalTargetLayer(self.n_classes)
# pooling or align
self.RCNN_roi_pool = ROIPool((cfg.POOLING_SIZE, cfg.POOLING_SIZE),
1.0 / 16.0)
self.RCNN_roi_align = ROIAlign((cfg.POOLING_SIZE, cfg.POOLING_SIZE),
1.0 / 16.0, 0)
# few shot rcnn head
self.global_relation = g
self.local_correlation = l
self.patch_relation = p
self.pool_feat_dim = 1024
self.soft_gamma = 1e1
self.avgpool = nn.AvgPool2d(14, stride=1)
self.avgpool_fc = nn.AvgPool2d(7)
self.patch_avgpool = nn.AvgPool2d(kernel_size=3, stride=1)
dim_in = self.pool_feat_dim
if self.global_relation:
self.global_fc_1 = nn.Linear(dim_in * 2, dim_in)
self.global_fc_2 = nn.Linear(dim_in, dim_in)
self.global_cls_score = nn.Linear(dim_in, 2) #nn.Linear(dim_in, 2)
init.normal_(self.global_fc_1.weight, std=0.01)
init.constant_(self.global_fc_1.bias, 0)
init.normal_(self.global_fc_2.weight, std=0.01)
init.constant_(self.global_fc_2.bias, 0)
init.normal_(self.global_cls_score.weight, std=0.01)
init.constant_(self.global_cls_score.bias, 0)
if self.local_correlation:
self.corr_conv = nn.Conv2d(dim_in,
dim_in,
1,
padding=0,
bias=False)
#self.bbox_pred_cor = nn.Linear(dim_in, 4 * 2)
self.corr_cls_score = nn.Linear(dim_in, 2) #nn.Linear(dim_in, 2)
init.normal_(self.corr_conv.weight, std=0.01)
init.normal_(self.corr_cls_score.weight, std=0.01)
init.constant_(self.corr_cls_score.bias, 0)
if self.patch_relation:
self.patch_conv_1 = nn.Conv2d(2 * dim_in,
int(dim_in / 4),
1,
padding=0,
bias=False)
self.patch_conv_2 = nn.Conv2d(int(dim_in / 4),
int(dim_in / 4),
3,
padding=0,
bias=False)
self.patch_conv_3 = nn.Conv2d(int(dim_in / 4),
dim_in,
1,
padding=0,
bias=False)
self.patch_cls_score = nn.Linear(dim_in, 2)
init.normal_(self.patch_conv_1.weight, std=0.01)
init.normal_(self.patch_conv_2.weight, std=0.01)
init.normal_(self.patch_conv_3.weight, std=0.01)
init.normal_(self.patch_cls_score.weight, std=0.01)
init.constant_(self.patch_cls_score.bias, 0)
# few shot settings
self.n_way = n_way
self.n_shot = n_shot
def convMeanpool(inplanes, outplanes):
sequence = []
sequence += [conv3x3(inplanes, outplanes)]
sequence += [nn.AvgPool2d(kernel_size=2, stride=2)]
return nn.Sequential(*sequence)
def __init__(self, block, layers, num_classes=1000, train=True):
self.inplanes = 64
super(ResNet, self).__init__()
self.istrain = train
self.frames = 16
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.conv1_t = MultiConv(planes=64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
self.layer1 = self._make_layer(block, 64, layers[0])
self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
self.layer4 = self._make_layer(block, 512, layers[3], stride=1)
self.avgpool = nn.AvgPool2d((16, 8), stride=1)
self.num_features = 128
self.feat = nn.Linear(512 * block.expansion, self.num_features)
self.feat_bn = nn.BatchNorm1d(self.num_features)
self.feat_bn1 = nn.BatchNorm1d(self.num_features)
self.feat_bn2 = nn.BatchNorm1d(self.num_features)
self.feat_bn3 = nn.BatchNorm1d(self.num_features)
self.drop = nn.Dropout(0.5)
self.drop1 = nn.Dropout(0.5)
self.drop2 = nn.Dropout(0.5)
self.drop3 = nn.Dropout(0.5)
self.classifier = nn.Linear(4 * self.num_features, num_classes)
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(2. / n))
elif isinstance(m, nn.BatchNorm1d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.BatchNorm3d):
m.weight.data.fill_(1)
m.bias.data.zero_()
elif isinstance(m, nn.Linear):
init.normal_(m.weight, std=0.001)
init.constant_(m.bias, 0)
init.kaiming_normal_(self.feat.weight, mode='fan_out')
init.constant_(self.feat.bias, 0)
self.feat1 = nn.Conv2d(1,
128,
kernel_size=(3, 128),
stride=1,
dilation=(1, 1),
padding=(1, 0),
bias=False)
self.feat2 = nn.Conv2d(1,
128,
kernel_size=(3, 128),
stride=1,
dilation=(2, 1),
padding=(2, 0),
bias=False)
self.feat3 = nn.Conv2d(1,
128,
kernel_size=(3, 128),
stride=1,
dilation=(3, 1),
padding=(3, 0),
bias=False)
init.normal_(self.feat1.weight, std=0.001)
init.normal_(self.feat2.weight, std=0.001)
init.normal_(self.feat3.weight, std=0.001)
def __init__(self,
block,
layers,
groups,
reduction,
dropout_p=0.2,
inplanes=128,
input_3x3=True,
downsample_kernel_size=3,
downsample_padding=1,
num_classes=1000):
"""
Parameters
----------
block (nn.Module): Bottleneck class.
- For SENet154: SEBottleneck
- For SE-ResNet models: SEResNetBottleneck
- For SE-ResNeXt models: SEResNeXtBottleneck
layers (list of ints): Number of residual blocks for 4 layers of the
network (layer1...layer4).
groups (int): Number of groups for the 3x3 convolution in each
bottleneck block.
- For SENet154: 64
- For SE-ResNet models: 1
- For SE-ResNeXt models: 32
reduction (int): Reduction ratio for Squeeze-and-Excitation modules.
- For all models: 16
dropout_p (float or None): Drop probability for the Dropout layer.
If `None` the Dropout layer is not used.
- For SENet154: 0.2
- For SE-ResNet models: None
- For SE-ResNeXt models: None
inplanes (int): Number of input channels for layer1.
- For SENet154: 128
- For SE-ResNet models: 64
- For SE-ResNeXt models: 64
input_3x3 (bool): If `True`, use three 3x3 convolutions instead of
a single 7x7 convolution in layer0.
- For SENet154: True
- For SE-ResNet models: False
- For SE-ResNeXt models: False
downsample_kernel_size (int): Kernel size for downsampling convolutions
in layer2, layer3 and layer4.
- For SENet154: 3
- For SE-ResNet models: 1
- For SE-ResNeXt models: 1
downsample_padding (int): Padding for downsampling convolutions in
layer2, layer3 and layer4.
- For SENet154: 1
- For SE-ResNet models: 0
- For SE-ResNeXt models: 0
num_classes (int): Number of outputs in `last_linear` layer.
- For all models: 1000
"""
super(SENet, self).__init__()
self.inplanes = inplanes
if input_3x3:
layer0_modules = [
('conv1', nn.Conv2d(3, 64, 3, stride=2, padding=1,
bias=False)),
('bn1', nn.BatchNorm2d(64)),
('relu1', nn.ReLU(inplace=True)),
('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1,
bias=False)),
('bn2', nn.BatchNorm2d(64)),
('relu2', nn.ReLU(inplace=True)),
('conv3',
nn.Conv2d(64, inplanes, 3, stride=1, padding=1, bias=False)),
('bn3', nn.BatchNorm2d(inplanes)),
('relu3', nn.ReLU(inplace=True)),
]
else:
layer0_modules = [
('conv1',
nn.Conv2d(3,
inplanes,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('bn1', nn.BatchNorm2d(inplanes)),
('relu1', nn.ReLU(inplace=True)),
]
# To preserve compatibility with Caffe weights `ceil_mode=True`
# is used instead of `padding=1`.
layer0_modules.append(('pool', nn.MaxPool2d(3,
stride=2,
ceil_mode=True)))
self.layer0 = nn.Sequential(OrderedDict(layer0_modules))
self.layer1 = self._make_layer(block,
planes=64,
blocks=layers[0],
groups=groups,
reduction=reduction,
downsample_kernel_size=1,
downsample_padding=0)
self.layer2 = self._make_layer(
block,
planes=128,
blocks=layers[1],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.layer3 = self._make_layer(
block,
planes=256,
blocks=layers[2],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.layer4 = self._make_layer(
block,
planes=512,
blocks=layers[3],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.avg_pool = nn.AvgPool2d(7, stride=1)
self.dropout = nn.Dropout(dropout_p) if dropout_p is not None else None
self.last_linear = nn.Linear(512 * block.expansion, num_classes)
def __init__(self,
block,
layers,
groups,
reduction,
dropout_p=0.2,
inplanes=128,
input_3x3=True,
downsample_kernel_size=3,
downsample_padding=1,
num_classes=1000):
super(AttentionResNet, self).__init__()
self.inplanes = inplanes
if input_3x3:
layer0_modules = [
('conv1', nn.Conv2d(3, 64, 3, stride=2, padding=1,
bias=False)),
('bn1', nn.BatchNorm2d(64)),
('relu1', nn.ReLU(inplace=True)),
('conv2', nn.Conv2d(64, 64, 3, stride=1, padding=1,
bias=False)),
('bn2', nn.BatchNorm2d(64)),
('relu2', nn.ReLU(inplace=True)),
('conv3',
nn.Conv2d(64, inplanes, 3, stride=1, padding=1, bias=False)),
('bn3', nn.BatchNorm2d(inplanes)),
('relu3', nn.ReLU(inplace=True)),
]
else:
layer0_modules = [
('conv1',
nn.Conv2d(3,
inplanes,
kernel_size=7,
stride=2,
padding=3,
bias=False)),
('bn1', nn.BatchNorm2d(inplanes)),
('relu1', nn.ReLU(inplace=True)),
]
# To preserve compatibility with Caffe weights `ceil_mode=True`
# is used instead of `padding=1`.
layer0_modules.append(('pool', nn.MaxPool2d(3,
stride=2,
ceil_mode=True)))
self.layer0 = nn.Sequential(OrderedDict(layer0_modules))
self.layer1 = self._make_layer(block,
planes=64,
blocks=layers[0],
groups=groups,
reduction=reduction,
downsample_kernel_size=1,
downsample_padding=0)
self.layer2 = self._make_layer(
block,
planes=128,
blocks=layers[1],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.layer3 = self._make_layer(
block,
planes=256,
blocks=layers[2],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.layer4 = self._make_layer(
block,
planes=512,
blocks=layers[3],
stride=2,
groups=groups,
reduction=reduction,
downsample_kernel_size=downsample_kernel_size,
downsample_padding=downsample_padding)
self.avg_pool = nn.AvgPool2d(7, stride=1)
self.dropout = nn.Dropout(dropout_p) if dropout_p is not None else None
self.last_linear = nn.Linear(512 * block.expansion, num_classes)
def __init__(self):
super(Net, self).__init__()
# Input Block
self.convblock1 = nn.Sequential(
nn.Conv2d(in_channels=3,
out_channels=32,
kernel_size=(3, 3),
padding=0,
bias=False), nn.ReLU(),
nn.BatchNorm2d(32)) #i/p=32, output_size = 30 Rf 3 Jout - 1
# CONVOLUTION BLOCK 1
self.convblock2 = nn.Sequential(
nn.Conv2d(in_channels=32,
out_channels=128,
kernel_size=(3, 3),
padding=2,
bias=False), nn.ReLU(),
nn.BatchNorm2d(128)) # i/p=30,output_size = 32 RF 5 Jout -1
self.depthwise = nn.Conv2d(128,
128,
kernel_size=3,
padding=1,
groups=128)
self.pointwise = nn.Conv2d(128, 64, kernel_size=1)
#self.convblock3 = nn.Sequential(
# nn.Conv2d(in_channels=64, out_channels=64, kernel_size=(1, 1), padding=0, bias=False),
#) # i/p=30,output_size = 32 RF 5 Jout -1
# TRANSITION BLOCK 1
self.pool1 = nn.MaxPool2d(2,
2) # i./p=32,output_size = 16 RF 6 Jout - 2
# CONVOLUTION BLOCK 2
self.convblock4 = nn.Sequential(
nn.Conv2d(in_channels=64,
out_channels=128,
kernel_size=(3, 3),
padding=0,
bias=False,
dilation=2), ##dilation
nn.ReLU(),
nn.BatchNorm2d(128)) #i/p=16 output_size =12 RF 14 Jout - 2
# TRANSITION BLOCK 2
self.pool2 = nn.MaxPool2d(2,
2) #i/p=12 output_size = 6 RF 16 Jout - 4
#CONVOLUTION BLOCK 3
self.convblock5 = nn.Sequential(
nn.Conv2d(in_channels=128,
out_channels=128,
kernel_size=(3, 3),
padding=2,
bias=False), nn.ReLU(),
nn.BatchNorm2d(128)) # i/p=6,output_size =8 RF -24 ,Jout - 4
# TRANSITION BLOCK 3
self.pool3 = nn.MaxPool2d(2,
2) # i/p=8,output_size = 4 RF 32 Jout - 8
#CONVOLUTION BLOCK 4
self.convblock6 = nn.Sequential(
nn.Conv2d(in_channels=128,
out_channels=64,
kernel_size=(3, 3),
padding=1,
bias=False), nn.ReLU(),
nn.BatchNorm2d(64)) # i/p=4,output_size =4 RF 48 Jout - 8
# OUTPUT BLOCK
self.gap = nn.Sequential(
nn.AvgPool2d(kernel_size=4)) # output_size = 1
self.convblock9 = nn.Sequential(
nn.Conv2d(in_channels=64,
out_channels=10,
kernel_size=(1, 1),
padding=0,
bias=False), )
def __init__(self,
pretrained=True,
average_pool=True,
semantic=True,
final_dim=1024):
"""
:param average_pool: whether or not to average pool the representations
:param pretrained: Whether we need to load from scratch
:param semantic: Whether or not we want to introduce the mask and the class label early on (default Yes)
"""
super(SimpleDetector, self).__init__()
# huge thx to https://github.com/ruotianluo/pytorch-faster-rcnn/blob/master/lib/nets/resnet_v1.py
backbone = _load_resnet_imagenet(
pretrained=pretrained
) if USE_IMAGENET_PRETRAINED else _load_resnet(pretrained=pretrained)
self.backbone = nn.Sequential(
backbone.conv1,
backbone.bn1,
backbone.relu,
backbone.maxpool,
backbone.layer1,
backbone.layer2,
backbone.layer3,
# backbone.layer4
)
self.newbackbone = nn.Sequential(backbone.conv1, backbone.bn1,
backbone.relu, backbone.maxpool,
backbone.layer1, backbone.layer2,
backbone.layer3, backbone.layer4)
self.roi_align = ROIAlign((7, 7) if USE_IMAGENET_PRETRAINED else
(14, 14),
spatial_scale=1 / 16,
sampling_ratio=0)
if semantic:
self.mask_dims = 32
self.object_embed = torch.nn.Embedding(num_embeddings=81,
embedding_dim=128)
self.mask_upsample = torch.nn.Conv2d(
1,
self.mask_dims,
kernel_size=3,
stride=2 if USE_IMAGENET_PRETRAINED else 1,
padding=1,
bias=True)
else:
self.object_embed = None
self.mask_upsample = None
after_roi_align = [backbone.layer4]
self.final_dim = final_dim
if average_pool:
after_roi_align += [nn.AvgPool2d(7, stride=1), Flattener()]
self.after_roi_align = torch.nn.Sequential(*after_roi_align)
self.obj_downsample = torch.nn.Sequential(
torch.nn.Dropout(p=0.1),
torch.nn.Linear(2048 + (128 if semantic else 0), final_dim),
torch.nn.ReLU(inplace=True),
)
self.regularizing_predictor = torch.nn.Linear(2048, 81)
def _compute_grad_weights(self, grads):
grads = self._normalize(grads)
self.map_size = grads.size()[2:]
return nn.AvgPool2d(self.map_size)(grads)
def __init__(self,
in_channels: int = 3,
num_classes=1000,
expand_factor: int = 2):
super(DeeperSimpleNet, self).__init__()
mult = [32, 32, 64, 128] * expand_factor
print('build deepersimplenet with in_channel {}, and out_channel {}'.
format(in_channels, num_classes))
self.model = nn.Sequential(
# x112x112 --> x56x56
nn.Conv2d(in_channels=in_channels,
out_channels=mult[0],
kernel_size=3,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=mult[0]),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=mult[0],
out_channels=mult[0],
kernel_size=3,
stride=1,
padding=0),
nn.BatchNorm2d(num_features=mult[0]),
nn.ReLU(inplace=True),
# x56x56 --> x28x28
nn.Conv2d(in_channels=mult[0],
out_channels=mult[1],
kernel_size=3,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=mult[1]),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=mult[1],
out_channels=mult[1],
kernel_size=3,
stride=1,
padding=0),
nn.BatchNorm2d(num_features=mult[1]),
nn.ReLU(inplace=True),
# x28x28 --> x14x14
nn.Conv2d(in_channels=mult[1],
out_channels=mult[2],
kernel_size=3,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=mult[2]),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=mult[2],
out_channels=mult[2],
kernel_size=3,
stride=1,
padding=0),
nn.BatchNorm2d(num_features=mult[2]),
nn.ReLU(inplace=True),
# x14x14 --> x7x7
nn.Conv2d(in_channels=mult[2],
out_channels=mult[3],
kernel_size=3,
stride=2,
padding=1),
nn.BatchNorm2d(num_features=mult[3]),
nn.ReLU(inplace=True),
nn.Conv2d(in_channels=mult[3],
out_channels=mult[3],
kernel_size=3,
stride=1,
padding=0),
nn.BatchNorm2d(num_features=mult[3]),
nn.ReLU(inplace=True),
# pooling --> x1x1
nn.AvgPool2d(4))
self.num_nn = mult[3]
self.fc = nn.Sequential(
nn.Linear(in_features=self.num_nn, out_features=512, bias=True),
nn.ReLU(inplace=True))
self.critic_linear = nn.Linear(512, 1)
self.cls_linear = Categorical(512, num_classes) # classification 分类器
self.train() # 设置成训练模式
self.apply(weights_init) # 初始化相关参数
def __init__(self, block, layers, num_classes=1000):
self.inplanes = 64
super(ResNet, self).__init__()
self.conv1 = nn.Conv2d(3,
64,
kernel_size=7,
stride=2,
padding=3,
bias=False)
self.bn1 = nn.BatchNorm2d(64)
self.relu = nn.ReLU(inplace=True)
self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2,
padding=1) # 64*64*64
# bottom-up
self.layer1 = self._make_layer(block, 64, layers[0]) # 256*64*64
self.layer2 = self._make_layer(block, 128, layers[1],
stride=2) # 512*32*32
self.layer3 = self._make_layer(block, 256, layers[2],
stride=2) # 1024*16*16
self.layer4 = self._make_layer(block, 512, layers[3],
stride=2) # 2048*8*8
self.avgpool = nn.AvgPool2d(7) # 2048*1*1
# top-down
self.td_1 = self._make_top_down_layer(512 * block.expansion, 256 *
block.expansion) # 1024*8*8
self.td_2 = self._make_top_down_layer(256 * block.expansion, 128 *
block.expansion) # 512*16*16
self.td_3 = self._make_top_down_layer(128 * block.expansion, 64 *
block.expansion) # 256*32*32
# extra conv layers
self.p1_conv = self._make_conv_bn(256 * block.expansion,
256,
3,
padding=0,
stride=2,
use_relu=True) # 256*4*4
self.p2_conv = self._make_conv_bn(256 * block.expansion,
256,
3,
padding=0,
stride=2,
use_relu=True) # 256*8*8
self.p3_conv = self._make_conv_bn(128 * block.expansion,
256,
3,
padding=0,
stride=2,
use_relu=True) # 256*16*16
self.p4_conv = self._make_conv_bn(64 * block.expansion,
256,
3,
padding=0,
stride=2,
use_relu=True) # 256*32*32
# classification layer
self.cls1 = nn.Linear(256, out_features=num_classes, bias=True)
self.cls2 = nn.Linear(2304, out_features=num_classes, bias=True)
self.cls3 = nn.Linear(12544, out_features=num_classes, bias=True)
self.cls4 = nn.Linear(57600, out_features=num_classes, bias=True)
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(2. / n))
elif isinstance(m, nn.BatchNorm2d):
m.weight.data.fill_(1)
m.bias.data.zero_()
def __init__(self,
n_head,
n_mix,
d_model,
d_k,
d_v,
norm_layer=BatchNorm2d,
kq_transform='conv',
value_transform='conv',
pooling=True,
concat=False,
dropout=0.1):
super(SelfTrans, self).__init__()
self.n_head = n_head
self.n_mix = n_mix
self.d_k = d_k
self.d_v = d_v
self.pooling = pooling
self.concat = concat
if self.pooling:
self.pool = nn.AvgPool2d(3, 2, 1, count_include_pad=False)
if kq_transform == 'conv':
self.conv_qs = nn.Conv2d(d_model, n_head * d_k, 1)
nn.init.normal_(self.conv_qs.weight,
mean=0,
std=np.sqrt(2.0 / (d_model + d_k)))
elif kq_transform == 'ffn':
self.conv_qs = nn.Sequential(
nn.Conv2d(d_model, n_head * d_k, 3, padding=1, bias=False),
norm_layer(n_head * d_k),
nn.ReLU(True),
nn.Conv2d(n_head * d_k, n_head * d_k, 1),
)
nn.init.normal_(self.conv_qs[-1].weight,
mean=0,
std=np.sqrt(1.0 / d_k))
elif kq_transform == 'dffn':
self.conv_qs = nn.Sequential(
nn.Conv2d(d_model,
n_head * d_k,
3,
padding=4,
dilation=4,
bias=False),
norm_layer(n_head * d_k),
nn.ReLU(True),
nn.Conv2d(n_head * d_k, n_head * d_k, 1),
)
nn.init.normal_(self.conv_qs[-1].weight,
mean=0,
std=np.sqrt(1.0 / d_k))
else:
raise NotImplemented
self.conv_ks = self.conv_qs
if value_transform == 'conv':
self.conv_vs = nn.Conv2d(d_model, n_head * d_v, 1)
else:
raise NotImplemented
nn.init.normal_(self.conv_vs.weight,
mean=0,
std=np.sqrt(2.0 / (d_model + d_v)))
self.attention = MixtureOfSoftMax(n_mix=n_mix, d_k=d_k)
self.conv = nn.Conv2d(n_head * d_v, d_model, 1, bias=False)
self.norm_layer = norm_layer(d_model)
def train_net(images,
net,
lr=1e-3,
n_epochs_auxiliary=1000,
n_epochs_blockwise=500,
batch_size=20,
block_size=32,
save_path='trained_model.pt'):
"""Trains a network on images, and save the network.
:param images: list of torch.tensor on CUDA, each of shape (1, 4, Y, X) (Y and X can be different accross images)
:param net: nn.Module, network to train or retrain.
:param n_epochs_auxiliary: int, number of epochs on the auxiliary training net. Default: 1000
:param n_epochs_blockwise: int, number of epochs on the final blockwise net. Default: 500
:param batch_size: int. Default: 20
:param block_size: int. Default: 32
:param save_path: string, where to write the trained model. Default: 'trained_model.pt'.
"""
#writer = SummaryWriter('runs/Adaptive CFA Forensics')
running_loss = 0.0
criterion = SelfPixelwiseNLLLoss().cuda()
optim = torch.optim.Adam(net.auxiliary.parameters(), lr=lr)
optim.zero_grad()
for epoch in trange(n_epochs_auxiliary):
random.shuffle(images)
for i_img, img in enumerate(images):
o = net.auxiliary(img)
loss = criterion(o, global_best=True)
loss.backward()
running_loss += loss.item()
if (i_img + 1) % batch_size == 0:
optim.step()
optim.zero_grad()
writer.add_scalar('training loss auxiliary',
running_loss / 1000, epoch)
running_loss = 0.0
first_processor = nn.Sequential(net.spatial, net.pixelwise, net.grids,
nn.AvgPool2d(block_size))
images = [
torch.tensor(first_processor(img).detach().cpu().numpy()).cuda()
for img in images
] #Make sure no gradient stays
criterion = SelfNLLLoss().cuda()
optim = torch.optim.Adam(net.blockwise.parameters(), lr=lr)
optim.zero_grad()
running_loss = 0.0
for epoch in trange(n_epochs_blockwise):
random.shuffle(images)
for i_img, img in enumerate(images):
o = net.blockwise(img)
loss = criterion(o, global_best=True)
loss.backward()
running_loss += loss.item()
if (i_img + 1) % batch_size == 0:
optim.step()
optim.zero_grad()
writer.add_scalar('training loss blockwise',
running_loss / 1000, epoch)
running_loss = 0.0
torch.save(net.state_dict(), save_path)
