def __init__(self):
super(modifiedItrackerImageModel, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=0),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.CrossMapLRN2d(size=5, alpha=0.0001, beta=0.75, k=1.0),
nn.Conv2d(96, 256, kernel_size=5, stride=1, padding=2, groups=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.CrossMapLRN2d(size=5, alpha=0.0001, beta=0.75, k=1.0),
nn.Conv2d(256, 384, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(384, 64, kernel_size=1, stride=1, padding=0),
nn.ReLU(inplace=True),
)
# add the special weight layer
self.special_weight = nn.Sequential(
nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0),
nn.ReLU(inplace=True),
nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0),
nn.ReLU(inplace=True),
nn.Conv2d(64, 1, kernel_size=1, stride=1, padding=0),
nn.ReLU(inplace=True),
)
def __init__(self, num_features=512, dilation=1, initialize=True):
super(Inception_v1, self).__init__()
self.dilation = dilation
self.pretrained = os.environ['INCEPTION_V1_PRETRAINED']
#conv2d0
self.conv1__7x7_s2 = nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3)
self.max_pool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, ceil_mode=True)
self.lrn1 = nn.CrossMapLRN2d(5, 0.0001, 0.75, 1)
#conv2d1
self.conv2__3x3_reduce = nn.Conv2d(64, 64, kernel_size=1, stride=1, padding=0)
#conv2d2
self.conv2__3x3 = nn.Conv2d(64, 192, kernel_size=3, stride=1, padding=1)
self.lrn3 = nn.CrossMapLRN2d(5, 0.0001, 0.75, 1)
self.max_pool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, ceil_mode=True)
self.inception_3a = Inception_base(1, 192, [[64], [96,128], [16, 32], [3, 32]]) #3a
self.inception_3b = Inception_base(1, 256, [[128], [128,192], [32, 96], [3, 64]]) #3b
if self.dilation == 1:
self.max_pool_inc3= nn.MaxPool2d(kernel_size=3, stride=2, padding=0, ceil_mode=True)
pool_kernel = self.dilation*2 + 1
self.inception_4a = Inception_base(1, 480, [[192], [ 96,208], [16, 48], [pool_kernel, 64]], dilation=self.dilation) #4a
self.inception_4b = Inception_base(1, 512, [[160], [112,224], [24, 64], [pool_kernel, 64]], dilation=self.dilation) #4b
self.inception_4c = Inception_base(1, 512, [[128], [128,256], [24, 64], [pool_kernel, 64]], dilation=self.dilation) #4c
self.inception_4d = Inception_base(1, 512, [[112], [144,288], [32, 64], [pool_kernel, 64]], dilation=self.dilation) #4d
self.inception_4e = Inception_base(1, 528, [[256], [160,320], [32,128], [pool_kernel,128]], dilation=self.dilation) #4e
self.input_feat = nn.Conv2d(832, num_features, (1,1), (1,1), (0,0))
self.bn = nn.BatchNorm2d(num_features, affine=False)
if initialize:
self.init_pretrained()
def __init__(self, dim=512, self_supervision_rot=0):
super(Model, self).__init__()
self.features = nn.Sequential(OrderedDict([
('conv1', nn.Sequential(OrderedDict([
('7x7_s2', nn.Conv2d(3, 64, (7, 7), (2, 2), (3, 3))),
('relu1', nn.ReLU(True)),
('pool1', nn.MaxPool2d((3, 3), (2, 2), ceil_mode = True)),
('lrn1', nn.CrossMapLRN2d(5, 0.0001, 0.75, 1))
]))),
('conv2', nn.Sequential(OrderedDict([
('3x3_reduce', nn.Conv2d(64, 64, (1, 1), (1, 1), (0, 0))),
('relu1', nn.ReLU(True)),
('3x3', nn.Conv2d(64, 192, (3, 3), (1, 1), (1, 1))),
('relu2', nn.ReLU(True)),
('lrn2', nn.CrossMapLRN2d(5, 0.0001, 0.75, 1)),
('pool2', nn.MaxPool2d((3, 3), (2, 2), ceil_mode = True))
]))),
('inception_3a', InceptionModule(192, 64, 96, 128, 16, 32, 32)),
('inception_3b', InceptionModule(256, 128, 128, 192, 32, 96, 64)),
('pool3', nn.MaxPool2d((3, 3), (2, 2), ceil_mode = True)),
('inception_4a', InceptionModule(480, 192, 96, 208, 16, 48, 64)),
('inception_4b', InceptionModule(512, 160, 112, 224, 24, 64, 64)),
('inception_4c', InceptionModule(512, 128, 128, 256, 24, 64, 64)),
('inception_4d', InceptionModule(512, 112, 144, 288, 32, 64, 64)),
('inception_4e', InceptionModule(528, 256, 160, 320, 32, 128, 128)),
('pool4', nn.MaxPool2d((3, 3), (2, 2), ceil_mode = True)),
('inception_5a', InceptionModule(832, 256, 160, 320, 32, 128, 128)),
('inception_5b', InceptionModule(832, 384, 192, 384, 48, 128, 128)),
('pool5', nn.AvgPool2d((7, 7), (1, 1), ceil_mode = True))])
)
self.dim = dim
self.self_supervision_rot = self_supervision_rot
normalized = (self.dim % 64 == 0)
self.classifier = Embedding(1024, self.dim, normalized=normalized)
if self.self_supervision_rot:
self.classifier_rot = nn.Sequential(
nn.Linear(1024, 512),
nn.ReLU(True),
nn.Linear(512, 4),
nn.ReLU(True),
)
print(self.classifier_rot)
for m in self.modules():
if isinstance(m, nn.Conv2d):
#print(m)
nn.init.kaiming_normal_(m.weight)
elif isinstance(m, nn.BatchNorm2d):
#print(m)
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.Linear):
#print(m)
nn.init.constant_(m.bias, 0)
def __init__(self):
super(deep_feature, self).__init__()
self.model_name = 'DeepFeatureExtration'
self.feature = t.nn.Sequential(
#这里的in_channal存在疑问
nn.Conv2d(256, 96, kernel_size=11,
stride=4), # 这里没有找到卷积核的初始化方式该如何给出
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.CrossMapLRN2d(size=5, alpha=0.0001, beta=0.75),
nn.Conv2d(96,
256,
kernel_size=5,
stride=1,
padding=2,
groups=2,
bias=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.CrossMapLRN2d(size=5, alpha=0.0001, beta=0.75),
nn.Conv2d(256,
384,
kernel_size=3,
stride=1,
padding=1,
groups=1,
bias=0),
nn.ReLU(),
nn.Conv2d(384,
384,
kernel_size=3,
stride=1,
padding=1,
groups=2,
bias=1),
nn.ReLU(),
nn.Conv2d(384,
256,
kernel_size=3,
stride=1,
padding=1,
groups=2,
bias=1),
nn.ReLU(),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Linear(256, 4096, bias=1),
nn.Dropout(p=0.5))
self.classifier1 = nn.Sequential(nn.Linear(256 * 6 * 6, 4096),
nn.ReLU(), nn.Dropout(0.5))
def __init__(self, pretrained=True, weight_path='./data/googlenet.h5'):
super(GoogleNet, self).__init__(
OrderedDict([
('conv1',
nn.Sequential(
OrderedDict([
('7x7_s2', nn.Conv2d(3, 64, (7, 7), (2, 2), (3, 3))),
('relu1', nn.ReLU(True)),
('pool1', nn.MaxPool2d((3, 3), (2, 2),
ceil_mode=True)),
('lrn1', nn.CrossMapLRN2d(5, 0.0001, 0.75, 1))
]))),
('conv2',
nn.Sequential(
OrderedDict([
('3x3_reduce',
nn.Conv2d(64, 64, (1, 1), (1, 1), (0, 0))),
('relu1', nn.ReLU(True)),
('3x3', nn.Conv2d(64, 192, (3, 3), (1, 1), (1, 1))),
('relu2', nn.ReLU(True)),
('lrn2', nn.CrossMapLRN2d(5, 0.0001, 0.75, 1)),
('pool2', nn.MaxPool2d((3, 3), (2, 2),
ceil_mode=True))
]))),
('inception_3a', InceptionModule(192, 64, 96, 128, 16, 32,
32)),
('inception_3b', InceptionModule(256, 128, 128, 192, 32, 96,
64)),
('pool3', nn.MaxPool2d((3, 3), (2, 2), ceil_mode=True)),
('inception_4a', InceptionModule(480, 192, 96, 208, 16, 48,
64)),
('inception_4b', InceptionModule(512, 160, 112, 224, 24, 64,
64)),
('inception_4c', InceptionModule(512, 128, 128, 256, 24, 64,
64)),
('inception_4d', InceptionModule(512, 112, 144, 288, 32, 64,
64)),
('inception_4e',
InceptionModule(528, 256, 160, 320, 32, 128, 128)),
('pool4', nn.MaxPool2d((3, 3), (2, 2), ceil_mode=True)),
('inception_5a',
InceptionModule(832, 256, 160, 320, 32, 128, 128)),
('inception_5b',
InceptionModule(832, 384, 192, 384, 48, 128, 128)),
('pool5', nn.AvgPool2d((7, 7), (1, 1), ceil_mode=True)),
# ('drop5', nn.Dropout(0.4))
]))
if pretrained:
self.load(weight_path)
def __init__(self):
super(ItrackerImageModel, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(1, 32, kernel_size=11, stride=4, padding=0),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.CrossMapLRN2d(size=5, alpha=0.0001, beta=0.75, k=1.0),
nn.Conv2d(32, 64, kernel_size=5, stride=1, padding=2, groups=2),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.CrossMapLRN2d(size=5, alpha=0.0001, beta=0.75, k=1.0),
nn.Conv2d(64, 32, kernel_size=3, stride=1, padding=1),
nn.ReLU(inplace=True),
nn.Conv2d(32, 16, kernel_size=1, stride=1, padding=0),
nn.ReLU(inplace=True),
)
def __init__(self):
super(ConvNet, self).__init__()
self.conv1 = nn.Conv2d(1, 96, kernel_size=7, stride=4)
self.maxPool1 = nn.MaxPool2d(kernel_size=3, stride=2)
self.norm1 = nn.CrossMapLRN2d(5, alpha=0.0001, beta=0.75)
self.conv2 = nn.Conv2d(96, 256, kernel_size=5, padding=2)
self.maxPool2 = nn.MaxPool2d(kernel_size=3, stride=2)
self.norm2 = nn.CrossMapLRN2d(5, alpha=0.0001, beta=0.75)
self.conv3 = nn.Conv2d(256, 384, kernel_size=3, padding=1)
self.maxPool3 = nn.MaxPool2d(kernel_size=3, stride=2)
self.fc1 = nn.Linear(384 * 6 * 6, 512)
self.dropout1 = nn.Dropout2d(0.5)
self.fc2 = nn.Linear(512, 512)
self.dropout2 = nn.Dropout2d(0.5)
self.fc3 = nn.Linear(512, 10)
def __init__(self):
super(AlexNet_Horse, self).__init__()
self.features = []
self.features.append(nn.Conv2d(3, 96, 11, 4,))
self.features.append(nn.ReLU(True))
self.features.append(nn.CrossMapLRN2d(5))
self.features.append(nn.MaxPool2d(3,2))
self.features.append(nn.Conv2d(96, 256, 5, 1, 2,groups=2))
self.features.append(nn.ReLU(True))
self.features.append(nn.CrossMapLRN2d(5))
self.features.append(nn.MaxPool2d(3,2))
self.features.append(nn.Conv2d(256, 384, 3, 1, 1))
self.features.append(nn.ReLU(True))
self.features.append(nn.Conv2d(384, 384, 3, 1, 1,groups=2))
self.features.append(nn.ReLU(True))
self.features.append(nn.Conv2d(384, 256, 3, 1, 1,groups=2))
self.features.append(nn.ReLU(True))
self.features.append(nn.BatchNorm2d(256))
self.features.append(nn.Conv2d(256, 128, 1))
self.features.append(nn.ReLU(True))
self.features.append(nn.MaxPool2d(3,2))
self.features = nn.Sequential(*self.features)
self.classifier = []
self.classifier.append(nn.BatchNorm1d(4608))
self.classifier.append(nn.Linear(4608,128))
self.classifier.append(nn.ReLU(True))
self.classifier.append(nn.Dropout(0.5))
self.classifier.append(nn.BatchNorm1d(128))
# self.classifier.append(nn.Linear(128,50))
new_layer = nn.Linear(128,2)
nn.init.xavier_normal(list(new_layer.parameters())[0])
nn.init.constant(list(new_layer.parameters())[1],0.)
self.classifier.append(new_layer)
self.classifier = nn.Sequential(*self.classifier)
def __init__(self):
super(inception_v1_decoder, self).__init__(
OrderedDict([
# ('upsample7', nn.Upsample(scale_factor=7)),
# ('deconv1', nn.ConvTranspose2d(1024, 1024, 7, 3, 1, 2)),
('inception_5b',
InceptionModule(1024, 256, 160, 320, 32, 128, 128)),
('inception_5a',
InceptionModule(832, 256, 160, 320, 32, 128, 128)),
('upsample14x14', nn.Upsample(scale_factor=2)),
('inception_4e', InceptionModule(832, 112, 144, 288, 32, 64,
64)),
('inception_4d', InceptionModule(528, 128, 128, 256, 24, 64,
64)),
('inception_4c', InceptionModule(512, 160, 112, 224, 24, 64,
64)),
('inception_4b', InceptionModule(512, 192, 96, 208, 16, 48,
64)),
('inception_4a', InceptionModule(512, 128, 128, 192, 32, 96,
64)),
('upsample28x28', nn.Upsample(scale_factor=2)),
('inception_3b', InceptionModule(480, 64, 96, 128, 16, 32,
32)),
('upsample28x28', nn.Upsample(scale_factor=2)),
('conv2',
nn.Sequential(
OrderedDict([
('3x3', nn.Conv2d(256, 192, (3, 3), (1, 1), (1, 1))),
('relu2', nn.ReLU(True)),
('bn2', nn.BatchNorm2d(192)),
('3x3_reduce',
nn.Conv2d(192, 64, (1, 1), (1, 1), (0, 0))),
('relu1', nn.ReLU(True)),
('lrn2', nn.CrossMapLRN2d(5, 0.0001, 0.75, 1)),
]))),
('conv1',
nn.Sequential(
OrderedDict([
('upsample56x56', nn.Upsample(scale_factor=2)),
('deconv2', nn.ConvTranspose2d(64, 64, 7, 2, 3, 1)),
('relu', nn.ReLU(True)), ('bn', nn.BatchNorm2d(64)),
('deconv3', nn.ConvTranspose2d(64, 3, 7, 2, 3, 1)),
('tanh', nn.Tanh())
])))
]))
def __init__(self,
num_classes: int = 1000,
model_path: str = None,
model_url: str = None,
class_names: list = None,
class_desc: list = None):
"""
Construct VGG-M-2048 model with specified number of prediction classes.
:param num_classes: Number of prediction classes.
:param model_path: Path of weights of model stored locally.
:param model_url: URL of weights of model available via the web.
:param class_names: Name of prediction classes.
:param class_desc: Description of prediction classes.
"""
super(VGG_M_2048, self).__init__()
self.class_names = None
self.class_desc = None
if class_names is not None and class_desc is not None:
if num_classes != len(class_names) or num_classes != len(class_desc):
print('Warning: mismatch between number of classes and number of class names or descriptions: {}:{}:{}'
.format(num_classes, len(class_names), len(class_desc)))
else:
self.class_names = class_names
self.class_desc = class_desc
self.features = nn.Sequential(OrderedDict([
('conv1', nn.Conv2d(3, 96, kernel_size=7, stride=2)),
('relu1', nn.ReLU()),
('norm1', nn.CrossMapLRN2d(5, alpha=1e-4, beta=0.75, k=2)),
('pool1', nn.MaxPool2d(kernel_size=3, stride=2, padding=0)),
('conv2', nn.Conv2d(96, 256, kernel_size=5, stride=2, padding=1)),
('relu2', nn.ReLU()),
('norm2', nn.CrossMapLRN2d(5, alpha=1e-4, beta=0.75, k=2)),
('pool2', nn.MaxPool2d(kernel_size=3, stride=2, padding=0)),
('conv3', nn.Conv2d(256, 512, kernel_size=3, stride=1, padding=1)),
('relu3', nn.ReLU()),
('conv4', nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)),
('relu4', nn.ReLU()),
('conv5', nn.Conv2d(512, 512, kernel_size=3, stride=1, padding=1)),
('relu5', nn.ReLU()),
('pool5', nn.MaxPool2d(kernel_size=3, stride=2, padding=1)),
('fc6', nn.Conv2d(512, 4096, kernel_size=6, stride=1, padding=0)),
('relu6', nn.ReLU()),
('dropout6', nn.Dropout()),
('fc7', nn.Conv2d(4096, 2048, kernel_size=1, stride=1, padding=0)),
('relu7', nn.ReLU()),
('dropout7', nn.Dropout())]))
self.classifier = nn.Sequential(OrderedDict([
('fc8ext', nn.Conv2d(2048, num_classes, kernel_size=1, stride=1, padding=0)),
('dropout8', nn.Dropout()),
('prob', nn.Softmax(dim=1))]))
self.bbox_reg = nn.Conv2d(2048, 4, kernel_size=1, stride=1, padding=0)
# Initialize the FC layers with all 0 parameters to prevent messing up the other parameters.
nn.init.constant_(self.bbox_reg.weight, 0)
nn.init.constant_(self.bbox_reg.bias, 0)
nn.init.constant_(self.classifier.fc8ext.weight, 0)
nn.init.constant_(self.classifier.fc8ext.bias, 0)
if model_path is not None:
self.load(model_path)
elif model_url is not None:
self.features.load_state_dict(model_zoo.load_url(model_url))
