def __init__(self, channel, embedding_size=128, **kwargs):
super(Net, self).__init__()
self.features = nn.Sequential(
nn.Conv2d(channel, 64, kernel_size=11, stride=4, padding=2),
nn.ReLU(inplace=True),
nn.BatchNorm2d(64),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(64, 192, kernel_size=5, padding=2),
nn.BatchNorm2d(192),
nn.ReLU(inplace=True),
nn.MaxPool2d(kernel_size=3, stride=2),
nn.Conv2d(192, 384, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.BatchNorm2d(384),
nn.Conv2d(384, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.BatchNorm2d(256),
nn.Conv2d(256, 256, kernel_size=3, padding=1),
nn.ReLU(inplace=True),
nn.BatchNorm2d(256),
nn.MaxPool2d(kernel_size=3, stride=2),
)
self.classifier = nn.Sequential(nn.Dropout(),
nn.Linear(256 * 1 * 1, 4096),
nn.ReLU(inplace=True),
nn.BatchNorm1d(4096), nn.Dropout(),
nn.Linear(4096, 4096),
nn.ReLU(inplace=True),
nn.BatchNorm1d(4096),
AngleLinear(4096, embedding_size))
def __init__(self, growth_rate=32, block_config=(6, 12, 48, 32),
num_init_features=64, bn_size=4, drop_rate=0.2, channel=3, embedding_size=1000):
super(DenseNet, self).__init__()
# First convolution
self.features = nn.Sequential(OrderedDict([
('conv0', nn.Conv2d(channel, num_init_features, kernel_size=7, stride=2, padding=3, bias=False)),
('norm0', nn.BatchNorm2d(num_init_features)),
('relu0', nn.ReLU(inplace=True)),
('pool0', nn.MaxPool2d(kernel_size=3, stride=1, padding=1)),
]))
# Each denseblock
num_features = num_init_features
for i, num_layers in enumerate(block_config):
block = _DenseBlock(num_layers=num_layers, num_input_features=num_features,
bn_size=bn_size, growth_rate=growth_rate, drop_rate=drop_rate)
self.features.add_module('denseblock%d' % (i + 1), block)
num_features = num_features + num_layers * growth_rate
if i != len(block_config) - 1:
trans = _Transition(num_input_features=num_features, num_output_features=num_features // 2)
self.features.add_module('transition%d' % (i + 1), trans)
num_features = num_features // 2
# Final batch norm
self.features.add_module('norm5', nn.BatchNorm2d(num_features))
# Linear layer
self.classifier = AngleLinear(num_features, embedding_size)
def __init__(self, channel=1, embedding_size=10, **kwargs):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(channel, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.conv2_drop = nn.Dropout2d()
self.fc1 = nn.Linear(320, 50)
self.fc2 = AngleLinear(50, embedding_size)
def __init__(self, channel=3, embedding_size=128, **kwargs):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(channel, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 13 * 13, 512)
self.fc2 = nn.Linear(512, 256)
self.fc3 = AngleLinear(256, embedding_size)
def __init__(self, channel=3, embedding_size=128, **kwargs):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(channel, 6, 5)
self.pool = nn.MaxPool2d(2, 2)
self.conv2 = nn.Conv2d(6, 16, 5)
self.fc1 = nn.Linear(16 * 5 * 5, 120)
self.fc2 = nn.Linear(120, 84)
self.fc3 = AngleLinear(84, embedding_size)