def __init__(self, num_class):
self.base1 = rm.Sequential([
InceptionV2Stem(),
InceptionV2BlockA([64, 48, 64, 64, 96, 32]),
InceptionV2BlockA(),
InceptionV2BlockA(),
InceptionV2BlockB(),
InceptionV2BlockC([192, 128, 192, 128, 192, 192]),
InceptionV2BlockC(),
InceptionV2BlockC(),
InceptionV2BlockC()])
self.aux1 = rm.Sequential([
rm.AveragePool2d(filter=5, stride=3),
rm.Conv2d(128, filter=1),
rm.Relu(),
rm.Conv2d(768, filter=1),
rm.Relu(),
rm.Flatten(),
rm.Dense(num_class)])
self.base2 = rm.Sequential([
InceptionV2BlockD(),
InceptionV2BlockE(),
InceptionV2BlockE(),
rm.AveragePool2d(filter=8),
rm.Flatten()])
self.aux2 = rm.Dense(num_class)
def transition_layer(growth_rate):
return rm.Sequential([
rm.BatchNormalize(epsilon=0.001, mode='feature'),
rm.Relu(),
rm.Conv2d(growth_rate, filter=1, padding=0, stride=1),
rm.AveragePool2d(filter=2, stride=2)
])
def __init__(self, num_class):
self.block1 = rm.Sequential([InceptionV4Stem(),
InceptionV4BlockA(),
InceptionV4BlockA(),
InceptionV4BlockA(),
InceptionV4BlockA(),
InceptionV4ReductionA()])
self.block2 = rm.Sequential([
InceptionV4BlockB(),
InceptionV4BlockB(),
InceptionV4BlockB(),
InceptionV4BlockB(),
InceptionV4BlockB(),
InceptionV4BlockB(),
InceptionV4BlockB(),
InceptionV4ReductionB()])
self.block3 = rm.Sequential([
InceptionV4BlockC(),
InceptionV4BlockC(),
InceptionV4BlockC(),
rm.AveragePool2d(filter=8),
rm.Flatten(),
rm.Dropout(0.2)
])
self.fc = rm.Dense(num_class)
def __init__(self, num_class):
self.base1 = rm.Sequential([rm.Conv2d(64, filter=7, padding=3, stride=2),
rm.Relu(),
rm.MaxPool2d(filter=3, stride=2, padding=1),
rm.BatchNormalize(mode='feature'),
rm.Conv2d(64, filter=1, stride=1),
rm.Relu(),
rm.Conv2d(192, filter=3, padding=1, stride=1),
rm.Relu(),
rm.BatchNormalize(mode='feature'),
rm.MaxPool2d(filter=3, stride=2, padding=1),
InceptionV1Block(),
InceptionV1Block([128, 128, 192, 32, 96, 64]),
rm.MaxPool2d(filter=3, stride=2),
InceptionV1Block([192, 96, 208, 16, 48, 64]),
])
self.aux1 = rm.Sequential([rm.AveragePool2d(filter=5, stride=3),
rm.Flatten(),
rm.Dense(1024),
rm.Dense(num_class)])
self.base2 = rm.Sequential([InceptionV1Block([160, 112, 224, 24, 64, 64]),
InceptionV1Block([128, 128, 256, 24, 64, 64]),
InceptionV1Block([112, 144, 288, 32, 64, 64])])
self.aux2 = rm.Sequential([rm.AveragePool2d(filter=5, stride=3),
rm.Flatten(),
rm.Dense(1024),
rm.Dense(num_class)])
self.base3 = rm.Sequential([InceptionV1Block([256, 160, 320, 32, 128, 128]),
InceptionV1Block([256, 160, 320, 32, 128, 128]),
InceptionV1Block([192, 384, 320, 48, 128, 128]),
rm.AveragePool2d(filter=7, stride=1),
rm.Flatten()])
self.aux3 = rm.Dense(num_class)
def test_gpu_node_average_pooling(a):
with use_cuda():
layer = rm.AveragePool2d()
g1 = Variable(a)
g3 = rm.sum(layer(g1))
g = g3.grad()
g_g3 = g.get(g1)
g3.to_cpu()
c3 = rm.sum(layer(g1))
c3.grad()
c_g3 = g.get(g1)
close(g3, c3)
close(c_g3, g_g3)
def __init__(self, num_class=1000, load_pretrained_weight=False):
super(Darknet, self).__init__([
# 1st Block
rm.Conv2d(channel=64,
filter=7,
stride=2,
padding=3,
ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.MaxPool2d(stride=2, filter=2),
# 2nd Block
rm.Conv2d(channel=192, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.MaxPool2d(stride=2, filter=2),
# 3rd Block
rm.Conv2d(channel=128, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=256, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=256, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=512, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.MaxPool2d(stride=2, filter=2),
# 4th Block
rm.Conv2d(channel=256, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=512, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=256, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=512, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=256, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=512, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=256, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=512, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=512, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=1024, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.MaxPool2d(stride=2, filter=2),
# 5th Block
rm.Conv2d(channel=512, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=1024, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=512, filter=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
rm.Conv2d(channel=1024, filter=3, padding=1, ignore_bias=True),
rm.BatchNormalize(mode='feature'),
rm.LeakyRelu(slope=0.1),
# layers for ImageNet
rm.Conv2d(channel=num_class, filter=1),
rm.LeakyRelu(slope=0.1),
rm.AveragePool2d(filter=7),
rm.Softmax()
])
if load_pretrained_weight:
if isinstance(load_pretrained_weight, bool):
load_pretrained_weight = self.__class__.__name__ + '.h5'
if not os.path.exists(load_pretrained_weight):
download(self.WEIGHT_URL, load_pretrained_weight)
self.load(load_pretrained_weight)