def __init__(self):
super(PNet, self).__init__()
# suppose we have input with size HxW, then
# after first layer: H - 2,
# after pool: ceil((H - 2)/2),
# after second conv: ceil((H - 2)/2) - 2,
# after last conv: ceil((H - 2)/2) - 4,
# and the same for W
self.features = nn.Sequential(
OrderedDict([('conv1', SphereConv2D(3, 10, stride=1)),
('prelu1', nn.PReLU(10)),
('pool1', nn.MaxPool2d(2, 2, ceil_mode=True)),
('conv2', SphereConv2D(10, 16, stride=1)),
('prelu2', nn.PReLU(16)),
('conv3', SphereConv2D(16, 32, stride=1)),
('prelu3', nn.PReLU(32))]))
self.conv4_1 = nn.Conv2d(32, 2, 1, 1)
self.conv4_2 = nn.Conv2d(32, 4, 1, 1)
weights = np.load('../sphere_mtcnn/weights/pnet.npy',
allow_pickle=True)[()]
for n, p in self.named_parameters():
p.data = torch.FloatTensor(weights[n])
def __init__(self):
super(SphereNet, self).__init__()
self.conv1 = SphereConv2D(1, 32, kernel_size=k, stride=1)
self.pool1 = SphereMaxPool2D(kernel_size=k, stride=2)
self.conv2 = SphereConv2D(32, 64, kernel_size=k, stride=1)
self.pool2 = SphereMaxPool2D(kernel_size=k, stride=2)
self.fc = nn.Linear(14400, 10)
def sph_vgg(cfg, i, batch_norm=False):
layers = []
in_channels = i
for v in cfg:
if v == 'M':
layers += [SphereMaxPool2D(stride=2)]
else:
conv2d = SphereConv2D(in_channels, v, stride=1)
if batch_norm:
layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
else:
layers += [conv2d, nn.ReLU(inplace=True)]
in_channels = v
pool5 = SphereMaxPool2D(stride=1)
conv6 = SphereConv2D(512, 1024, stride=1)
conv7 = SphereConv2D(1024, 1024, stride=1)
layers += [pool5, conv6,
nn.ReLU(inplace=True), conv7, nn.ReLU(inplace=True)]
return layers
def __init__(self):
super(Generator360, self).__init__()
self.coord_conv = AddCoordsTh(x_dim=128, y_dim=256, with_r=False)
# Image pipeline
self.image_conv1 = SphereConv2D(5, 64, stride=2, bias=False)
self.image_norm1 = nn.BatchNorm2d(64)
self.leaky_relu1 = nn.LeakyReLU(0.2, inplace=True)
self.image_conv2 = SphereConv2D(64, 128, stride=2, bias=False)
self.image_norm2 = nn.BatchNorm2d(128)
self.leaky_relu2 = nn.LeakyReLU(0.2, inplace=True)
self.image_conv3 = SphereConv2D(128, 256, stride=2, bias=False)
self.image_norm3 = nn.BatchNorm2d(256)
self.leaky_relu3 = nn.LeakyReLU(0.2, inplace=True)
self.image_conv3_5 = SphereConv2D(256, 512, stride=2, bias=False)
self.image_norm3_5 = nn.BatchNorm2d(512)
self.leaky_relu3_5 = nn.LeakyReLU(0.2, inplace=True)
# Joint pipeline
self.sum_chan = 512 + 2
self.image_conv4 = nn.Conv2d(self.sum_chan, 256, 4, 2, 1, bias=False)
self.image_norm4 = nn.BatchNorm2d(256)
self.leaky_relu4 = nn.LeakyReLU(0.2, inplace=True)
self.image_conv5 = nn.Conv2d(256, 64, 4, 2, 1, bias=False)
self.image_norm5 = nn.BatchNorm2d(64)
self.leaky_relu5 = nn.LeakyReLU(0.2, inplace=True)
self.fc1 = nn.Linear(64 * 4 * 2, 90)
self.flatten = nn.Flatten()
self.activation = nn.Sigmoid()
self.activation = nn.Tanh()
def __init__(self):
super(AuxiliaryConvolutions, self).__init__()
# Auxiliary/additional convolutions on top of the VGG base
self.conv8_1 = SphereConv2D(1024, 256)
self.conv8_2 = SphereConv2D(256, 512, stride=2)
self.conv9_1 = SphereConv2D(512, 128)
self.conv9_2 = SphereConv2D(128, 256, stride=2)
self.conv10_1 = SphereConv2D(256, 128)
self.conv10_2 = SphereConv2D(128, 256, stride=2)
self.conv11_1 = SphereConv2D(256, 128)
self.conv11_2 = SphereConv2D(128, 256, stride=3)
# Initialize convolutions' parameters
self.init_conv2d()
def __init__(self):
super(SphereNet, self).__init__()
self.down1 = SphereEncoder(3, 24, kernel_size=3)
self.down2 = SphereEncoder(24, 64, kernel_size=3)
self.down3 = SphereEncoder(64, 128, kernel_size=3)
self.down4 = SphereEncoder(128, 256, kernel_size=3)
self.center = nn.Sequential(
SphereBlock(256, 256, kernel_size=3, padding=1, stride=1), )
self.up4 = SphereDecoder(256, 128, kernel_size=3)
self.up3 = SphereDecoder(128, 64, kernel_size=3)
self.up2 = SphereDecoder(64, 24, kernel_size=3)
self.up1 = SphereDecoder(24, 24, kernel_size=3)
self.end = SphereConv2D(24, 1, stride=1, bias=True)
def __init__(self):
super(VGGBase, self).__init__()
# Standard convolutional layers in VGG16
self.conv1_1 = SphereConv2D(3, 64) # stride = 1, by default.
self.conv1_2 = SphereConv2D(64, 64)
self.pool1 = SphereMaxPool2D(stride=2)
self.conv2_1 = SphereConv2D(64, 128)
self.conv2_2 = SphereConv2D(128, 128)
self.pool2 = SphereMaxPool2D(stride=2)
self.conv3_1 = SphereConv2D(128, 256)
self.conv3_2 = SphereConv2D(256, 256)
self.pool3 = SphereMaxPool2D(stride=2)
self.conv4_1 = SphereConv2D(256, 512)
self.pool4 = SphereMaxPool2D(stride=2)
# Replacements for FC6 and FC7 in VGG16
self.conv6 = SphereConv2D(512, 1024)
self.conv7 = SphereConv2D(1024, 1024)
def __init__(self,
in_channels,
out_channels,
kernel_size=3,
padding=1,
dilation=1,
stride=1,
groups=1,
is_bn=True,
is_relu=True):
super(SphereBlock, self).__init__()
# Spherical Convolution
self.conv = SphereConv2D(in_channels,
out_channels,
stride=stride,
bias=False)
# Batch normalization
self.bn = nn.BatchNorm2d(out_channels, eps=1e-4)
# ReLU activation
self.relu = nn.ReLU(inplace=True)
# If no BN or ReLU indicated, then the step is avoided
if is_bn is False: self.bn = None
if is_relu is False: self.relu = None
def __init__(self, n_classes):
"""
:param n_classes: number of different types of objects
"""
super(PredictionConvolutions, self).__init__()
self.n_classes = n_classes
# Number of prior-boxes we are considering per position in each feature map
n_boxes = {'conv4_3': 4,
'conv7': 6,
'conv8_2': 6,
'conv9_2': 6,
'conv10_2': 4,
'conv11_2': 4}
# 4 prior-boxes implies we use 4 different aspect ratios, etc.
# Localization prediction convolutions (predict offsets w.r.t prior-boxes)
self.loc_conv4_3 = SphereConv2D(512, n_boxes['conv4_3'] * 4)
self.loc_conv7 = SphereConv2D(1024, n_boxes['conv7'] * 4)
self.loc_conv8_2 = SphereConv2D(512, n_boxes['conv8_2'] * 4)
self.loc_conv9_2 = SphereConv2D(256, n_boxes['conv9_2'] * 4)
self.loc_conv10_2 = SphereConv2D(256, n_boxes['conv10_2'] * 4)
self.loc_conv11_2 = SphereConv2D(256, n_boxes['conv11_2'] * 4)
# Class prediction convolutions (predict classes in localization boxes)
self.cl_conv4_3 = SphereConv2D(512, n_boxes['conv4_3'] * n_classes)
self.cl_conv7 = SphereConv2D(1024, n_boxes['conv7'] * n_classes)
self.cl_conv8_2 = SphereConv2D(512, n_boxes['conv8_2'] * n_classes)
self.cl_conv9_2 = SphereConv2D(256, n_boxes['conv9_2'] * n_classes)
self.cl_conv10_2 = SphereConv2D(256, n_boxes['conv10_2'] * n_classes)
self.cl_conv11_2 = SphereConv2D(256, n_boxes['conv11_2'] * n_classes)
# Initialize convolutions' parameters
self.init_conv2d()