def residBlock(inmaps, hmaps, stride, blockname, convShortcut, actInplace,
bnInplace, initscheme):
block = Sequential()
branch = Sequential()
branch.extend(
residMiniBlock(inmaps, hmaps, 1, stride, 0, blockname, "2a", True,
actInplace, bnInplace, initscheme))
branch.extend(
residMiniBlock(hmaps, hmaps, 3, 1, 1, blockname, "2b", True,
actInplace, bnInplace, initscheme))
branch.extend(
residMiniBlock(hmaps, 4 * hmaps, 1, 1, 0, blockname, "2c", False,
actInplace, bnInplace, initscheme))
shortcut = Sequential()
if convShortcut:
shortcut.extend(
residMiniBlock(inmaps, 4 * hmaps, 1, stride, 0, blockname, "1",
False, actInplace, bnInplace, initscheme))
else:
shortcut.append(Identity())
block.append(Replicate(2))
block.append(Parallel().append(branch).append(shortcut))
block.append(Add())
block.append(Activation(relu, inplace=actInplace))
return block
def buildBall(stage=2, inplace=True):
ball = Sequential()
ball.append(Replicate(2))
left = buildBranch(stage=stage, num=1, inplace=inplace)
right = buildBranch(stage=stage, num=2, inplace=inplace)
ball.append(Parallel().append(left).append(right))
ball.append(Concat(axis=1))
return ball
def buildSmallBlock(inplace=True):
block = Sequential()
block.append(Replicate(3))
left = buildSmallBranch(inplace=inplace, num=1)
right = buildSmallBranch(inplace=inplace, num=2)
shortcut = Sequential().append(Identity())
block.append(Parallel().append(left).append(right).append(shortcut))
block.append(Concat(axis=1, name="concat_stage2"))
return block
def factorBlock(inmaps, b1m, b2m, b3m, b4m, name, act, bn, scheme):
block = Sequential()
b1towername, b1names = name, ["conv"]
b2towername, b2names = "%s_tower" % name, ["conv", "conv_1", "conv_2"]
b3towername, b3names = "%s_tower_1" % name, [
"conv", "conv_1", "conv_2", "conv_3", "conv_4"
]
b4towername, b4names = "%s_tower_2" % name, ["avg_pool", "conv"]
branch1 = tower(b1towername,
b1names, [inmaps] + b1m, [1], [1], [0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch2 = tower(b2towername,
b2names, [inmaps] + b2m, [1, (1, 7), (7, 1)], [1, 1, 1],
[0, (0, 3), (3, 0)],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch3 = tower(b3towername,
b3names, [inmaps] + b3m,
[1, (7, 1), (1, 7), (7, 1), (1, 7)], [1, 1, 1, 1, 1],
[0, (3, 0), (0, 3), (3, 0), (0, 3)],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch4 = tower(b4towername,
b4names, [inmaps, inmaps] + b4m, [3, 1], [1, 1], [1, 0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
block.append(Replicate(times=4))
block.append(Parallel().append(branch1).append(branch2).append(
branch3).append(branch4))
block.append(Concat(axis=1, name="ch_concat_%s_chconcat" % name))
return block
def buildBigBlock(stage=2, prenet=None, inplace=True):
block = Sequential()
block.append(Replicate(2))
shortcut = Sequential().append(Identity())
if prenet is None:
ball = buildBall(stage=stage, inplace=inplace)
else:
ball = prenet
ball.extend(buildBall(stage=stage, inplace=inplace))
block.append(Parallel().append(ball).append(shortcut))
block.append(Concat(axis=1, name="concat_stage%d" % (stage + 1)))
return block
def v3ShrinkBlock(inmaps, b1m, b2m, name, act, bn, scheme):
block = Sequential()
b1towername, b1names = "%s_tower" % name, ["conv", "conv_1"]
b2towername, b2names = "%s_tower_1" % name, [
"conv", "conv_1", "conv_2", "conv_3"
]
b3towername, b3names = name, ["max_pool"]
branch1 = tower(b1towername,
b1names, [inmaps] + b1m, [1, 3], [1, 2], [0, 0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch2 = tower(b2towername,
b2names, [inmaps] + b2m, [1, (1, 7), (7, 1), 3],
[1, 1, 1, 2], [0, (0, 3), (3, 0), 0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch3 = tower(b3towername,
b3names, [inmaps, inmaps], [3], [2], [0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
block.append(Replicate(times=3))
block.append(Parallel().append(branch1).append(branch2).append(branch3))
block.append(Concat(axis=1, name="ch_concat_%s_chconcat" % name))
return block
def expandBlock(inmaps, b1m, b2m, b3m, b4m, name, act, bn, scheme, pool="avg"):
block = Sequential()
b1towername, b1names = name, ["conv"]
b2towername, b2names, b2sub1names, b2sub2names = "%s_tower" % name, [
"conv"
], ["mixed_conv"], ["mixed_conv_1"]
b3towername, b3names, b3sub1names, b3sub2names = "%s_tower_1" % name, [
"conv", "conv_1"
], ["mixed_conv"], ["mixed_conv_1"]
branch1 = tower(b1towername,
b1names, [inmaps] + b1m, [1], [1], [0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch2 = tower(b2towername,
b2names, [inmaps, b2m[0]], [1], [1], [0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch2sub1 = tower(b2towername,
b2sub1names, [b2m[0], b2m[1]], [(1, 3)], [1], [(0, 1)],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch2sub2 = tower(b2towername,
b2sub2names, [b2m[0], b2m[2]], [(3, 1)], [1], [(1, 0)],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch2.append(Replicate(times=2))
branch2.append(Parallel().append(branch2sub1).append(branch2sub2))
branch3 = tower(b3towername,
b3names, [inmaps, b3m[0], b3m[1]], [1, 3], [1, 1], [0, 1],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch3sub1 = tower(b3towername,
b3sub1names, [b3m[1], b3m[2]], [(1, 3)], [1], [(0, 1)],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch3sub2 = tower(b3towername,
b3sub2names, [b3m[1], b3m[3]], [(3, 1)], [1], [(1, 0)],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
branch3.append(Replicate(times=2))
branch3.append(Parallel().append(branch3sub1).append(branch3sub2))
if pool == "avg":
branch4 = tower("%s_tower_2" % name, ["avg_pool", "conv"],
[inmaps, inmaps] + b4m, [3, 1], [1, 1], [1, 0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
elif pool == "max":
branch4 = tower("%s_tower_2" % name, ["max_pool", "conv"],
[inmaps, inmaps] + b4m, [3, 1], [1, 1], [1, 0],
act=act,
bn=bn,
scheme=scheme,
typ="v3")
else:
raise ValueError("Unrecognized block type")
block.append(Replicate(times=4))
block.append(Parallel().append(branch1).append(branch2).append(
branch3).append(branch4))
block.append(ToList())
block.append(Concat(axis=1, name="ch_concat_%s_chconcat" % name))
return block
def bnShrinkBlock(inmaps,
b1m,
b2m,
name,
act,
bn,
scheme,
b1deep=True,
pad=1,
typ="bn"):
block = Sequential()
if typ == "bn":
if b1deep:
b1towername, b1names = name, ["3x3_reduce", "3x3"]
else:
b1towername, b1names = name, ["3x3"]
b2towername, b2names = name, [
"double_3x3_reduce", "double_3x3_0", "double_3x3_1"
]
b3towername, b3names = name, ["max_pool"]
elif typ == "v3":
if b1deep:
b1towername, b1names = name, ["conv"]
else:
b1towername, b1names = name, ["conv"]
b2towername, b2names = "%s_tower" % name, ["conv", "conv_1", "conv_2"]
b3towername, b3names = name, ["max_pool"]
else:
raise ValueError("Unrecognized block type")
if b1deep:
branch1 = tower(b1towername,
b1names, [inmaps] + b1m, [1, 3], [1, 2], [0, pad],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
else:
branch1 = tower(b1towername,
b1names, [inmaps] + b1m, [3], [2], [pad],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
branch2 = tower(b2towername,
b2names, [inmaps] + b2m, [1, 3, 3], [1, 1, 2], [0, 1, pad],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
branch3 = tower(b3towername,
b3names, [inmaps, inmaps], [3], [2], [pad],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
block.append(Replicate(times=3))
block.append(Parallel().append(branch1).append(branch2).append(branch3))
block.append(Concat(axis=1, name="ch_concat_%s_chconcat" % name))
return block
def bnBlock(inmaps,
b1m,
b2m,
b3m,
b4m,
name,
act,
bn,
scheme,
b2size=3,
b2pad=1,
typ="bn"):
block = Sequential()
if typ == "bn":
b1towername, b1names = name, ["1x1"]
b2towername, b2names = name, ["3x3_reduce", "3x3"]
b3towername, b3names = name, [
"double_3x3_reduce", "double_3x3_0", "double_3x3_1"
]
b4towername, b4names = name, ["avg_pool", "proj"]
elif typ == "v3":
b1towername, b1names = name, ["conv"]
b2towername, b2names = "%s_tower" % name, ["conv", "conv_1"]
b3towername, b3names = "%s_tower_1" % name, [
"conv", "conv_1", "conv_2"
]
b4towername, b4names = "%s_tower_2" % name, ["avg_pool", "conv"]
else:
raise ValueError("Unrecognized block type")
branch1 = tower(b1towername,
b1names, [inmaps] + b1m, [1],
strides=[1],
pads=[0],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
branch2 = tower(b2towername,
b2names, [inmaps] + b2m, [1, b2size],
strides=[1, 1],
pads=[0, b2pad],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
branch3 = tower(b3towername,
b3names, [inmaps] + b3m, [1, 3, 3],
strides=[1, 1, 1],
pads=[0, 1, 1],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
branch4 = tower(b4towername,
b4names, [inmaps, inmaps] + b4m, [3, 1],
strides=[1, 1],
pads=[1, 0],
act=act,
bn=bn,
scheme=scheme,
typ=typ)
block.append(Replicate(times=4))
block.append(Parallel().append(branch1).append(branch2).append(
branch3).append(branch4))
block.append(Concat(axis=1, name="ch_concat_%s_chconcat" % name))
return block
def loadNet(name="", inplace=True, modelpath=None):
net = Sequential(name)
net.append(Conv2D(3, 64, 3, pad=1, initscheme="none", name="conv1_1"))
net.append(Activation(relu, name="relu1_1", inplace=inplace))
net.append(Conv2D(64, 64, 3, pad=1, initscheme="none", name="conv1_2"))
net.append(Activation(relu, name="relu1_2", inplace=inplace))
net.append(MaxPool2D(name="pool1_stage1"))
net.append(Conv2D(64, 128, 3, pad=1, initscheme="none", name="conv2_1"))
net.append(Activation(relu, name="relu2_1", inplace=inplace))
net.append(Conv2D(128, 128, 3, pad=1, initscheme="none", name="conv2_2"))
net.append(Activation(relu, name="relu2_2", inplace=inplace))
net.append(MaxPool2D(name="pool2_stage1"))
net.append(Conv2D(128, 256, 3, pad=1, initscheme="none", name="conv3_1"))
net.append(Activation(relu, name="relu3_1", inplace=inplace))
net.append(Conv2D(256, 256, 3, pad=1, initscheme="none", name="conv3_2"))
net.append(Activation(relu, name="relu3_2", inplace=inplace))
net.append(Conv2D(256, 256, 3, pad=1, initscheme="none", name="conv3_3"))
net.append(Activation(relu, name="relu3_3", inplace=inplace))
net.append(Conv2D(256, 256, 3, pad=1, initscheme="none", name="conv3_4"))
net.append(Activation(relu, name="relu3_4", inplace=inplace))
net.append(MaxPool2D(name="pool3_stage1"))
net.append(Conv2D(256, 512, 3, pad=1, initscheme="none", name="conv4_1"))
net.append(Activation(relu, name="relu4_1", inplace=inplace))
net.append(Conv2D(512, 512, 3, pad=1, initscheme="none", name="conv4_2"))
net.append(Activation(relu, name="relu4_2", inplace=inplace))
net.append(
Conv2D(512, 256, 3, pad=1, initscheme="none", name="conv4_3_CPM"))
net.append(Activation(relu, name="relu4_3_CPM"))
net.append(
Conv2D(256, 128, 3, pad=1, initscheme="none", name="conv4_4_CPM"))
net.append(Activation(relu, name="relu4_4_CPM"))
block2 = buildSmallBlock(inplace=inplace)
block3 = buildBigBlock(stage=2, prenet=block2, inplace=inplace)
block4 = buildBigBlock(stage=3, prenet=block3, inplace=inplace)
block5 = buildBigBlock(stage=4, prenet=block4, inplace=inplace)
block6 = buildBigBlock(stage=5, prenet=block5, inplace=inplace)
net.extend(block6)
net.append(Replicate(2))
net.append(Parallel().append(buildBranch(stage=6, num=2,
inplace=inplace)).append(
buildBranch(stage=6,
num=1,
inplace=inplace)))
net.append(Concat(axis=1))
if modelpath is not None:
net.load(modelpath, assumeUniqueNames=True)
return net
def buildNet(vocabulary,
branches,
w2v,
sentlength,
embsize,
wscale,
dim=2,
branchMaps=100,
name="sentinet"):
def onVocabulary(W):
W[0] = np.zeros((1, embsize), dtype=np.float32)
arrayPOS = [
"", "_S", "_A", "_V", "_UNKN", "_ADJ", "_ADV", "_INTJ", "_NOUN",
"_PROPN", "_VERB", "_ADP", "_AUX", "_CCONJ", "_DET", "_NUM",
"_PART", "_PRON", "_SCONJ", "_SUM", "_X"
]
tmpPOS = []
if not w2v:
return
for word in vocabulary:
for pos in tmpPOS:
if (word + pos) in w2v.vocab:
W[vocabulary[word]] = w2v[word + pos]
break
for i, pos in enumerate(arrayPOS):
if (word + pos) in w2v.vocab:
tmpPOS.append(pos)
W[vocabulary[word]] = w2v[word + pos]
del arrayPOS[i]
break
net = Sequential(name)
net.setAttr("timestamp", int(time.time()))
net.append(
Embedder(vocabulary,
sentlength,
embsize,
wscale=wscale,
onVocabulary=onVocabulary,
learnable=True,
name="embedder"))
net.append(Reshape((-1, 1, sentlength, embsize)))
branchNum = len(branches)
net.append(Replicate(times=branchNum))
par = Parallel()
for branchFilterSize in branches:
par.append(
buildBranch(branchFilterSize, sentlength, branchMaps, embsize))
net.append(par)
net.append(Concat(axis=1))
net.append(Activation(relu))
net.append(Dropout(p=0.5))
net.append(Linear(branchNum * branchMaps, dim))
return net