def initialize(self, step, multiplier, c_pp, c_p, c, rate):
self.multiplier = multiplier
self.step = step
if c_pp != -1:
self.preprocess0 = M.ConvLayer(1,
c,
batch_norm=True,
usebias=False)
if rate == 2:
self.preprocess1 = FactReduce(c)
elif rate == 0:
self.preprocess1 = FactIncrease(c)
else:
self.preprocess1 = M.ConvLayer(1,
c,
activation=M.PARAM_RELU,
batch_norm=True,
usebias=False)
self._ops = nn.ModuleList()
self.step = step
for i in range(step):
for j in range(2 + i):
if c_pp == -1 and j == 0:
self._ops.append(None)
else:
self._ops.append(MixedOp(c, 1))
self.conv_last = M.ConvLayer(1,
c,
activation=M.PARAM_RELU,
batch_norm=True,
usebias=False)
def initialize(self): self.c1 = M.ConvLayer(3, 64, pad='SAME_LEFT', stride=2, activation=M.PARAM_RELU, usebias=False, batch_norm=True) self.c2 = M.ConvLayer(3, 64, pad='SAME_LEFT', stride=2, activation=M.PARAM_RELU, usebias=False, batch_norm=True) self.layer1 = ResBlock(256, 1, 4) self.stage1 = Stage([32, 64], [1, 2], 4, 1) self.stage2 = Stage([32, 64, 128], [None, None, 2], 4, 4) self.stage3 = Stage([32, 64, 128, 256], [None,None,None,2], 4, 3)
def initialize(self, num_layer, num_chn, multiplier, step):
# step means how many mixed ops you want in one layer
# the num_layer here is not number of conv layers, but number of block of layers
self.num_layer = num_layer
self.step = step
self.c1 = M.ConvLayer(5,
64,
stride=2,
activation=M.PARAM_RELU,
batch_norm=True,
usebias=False)
cells = nn.ModuleList()
connections = []
for i in range(num_layer):
in_size = min(i + 1, 4)
out_size = min(i + 2, 4)
cell, conn = build_cells(step, multiplier, num_chn, in_size,
out_size)
cells.append(cell)
connections.append(conn)
self.cells = cells
self.connections = connections
self.down1 = FuseDown(3, 64, 512)
self.down2 = FuseDown(2, 128, 512)
self.down3 = FuseDown(1, 256, 512)
self.down4 = M.ConvLayer(1, 512, batch_norm=True, usebias=False)
self.final_conv = M.ConvLayer(1, 512, batch_norm=True, usebias=False)
def initialize(self, out, stride, shortcut=False): self.shortcut = shortcut self.c1 = M.ConvLayer(1, out//4, usebias=False, activation=M.PARAM_RELU, batch_norm=True) self.c2 = M.ConvLayer(3, out//4, usebias=False, activation=M.PARAM_RELU, pad='SAME_LEFT', stride=stride, batch_norm=True) self.c3 = M.ConvLayer(1, out, usebias=False, batch_norm=True) if shortcut: self.sc = M.ConvLayer(1, out, usebias=False, stride=stride, batch_norm=True)
def initialize(self, steps, inp, o): self.mods = nn.ModuleList() for i in range(steps): if i==(steps-1): self.mods.append(M.ConvLayer(3, o, stride=2, pad='SAME_LEFT', batch_norm=True, usebias=False)) else: self.mods.append(M.ConvLayer(3, inp, stride=2, pad='SAME_LEFT', activation=M.PARAM_RELU, batch_norm=True, usebias=False))
def initialize(self, outchn, stride):
self.stride = stride
self.outchn = outchn
self.bn0 = M.BatchNorm()
self.c1 = M.ConvLayer(3,
outchn,
activation=M.PARAM_PRELU,
usebias=False,
batch_norm=True)
self.c2 = M.ConvLayer(3,
outchn,
stride=stride,
usebias=False,
batch_norm=True)
# se module
#self.c3 = M.ConvLayer(1, outchn//16, activation=M.PARAM_PRELU)
#self.c4 = M.ConvLayer(1, outchn, activation=M.PARAM_SIGMOID)
# shortcut
self.sc = M.ConvLayer(1,
outchn,
stride=stride,
usebias=False,
batch_norm=True)
def initialize(self,
num_kpts,
temp_length,
input_dimension=3,
output_dimension=3,
output_pts=None):
self.num_kpts = num_kpts
self.temp_length = temp_length
self.output_dimension = output_dimension
self.output_pts = num_kpts if output_pts is None else output_pts
self.input_dimension = input_dimension
self.c1 = M.ConvLayer1D(3,
1024,
stride=3,
activation=M.PARAM_PRELU,
pad='VALID',
batch_norm=True,
usebias=False)
self.r1 = ResBlock1D(k=3)
self.r2 = ResBlock1D(k=3)
self.r3 = ResBlock1D(k=3)
self.r4 = ResBlock1D(k=3)
# self.r3 = ResBlock1D(k=3, dilation=3)
# self.c5 = M.ConvLayer1D(9, 256, activation=M.PARAM_PRELU, pad='VALID', batch_norm=True, usebias=False)
self.c4 = M.ConvLayer1D(1, self.output_pts * self.output_dimension)
def initialize(self, num_heads, dim_per_head, drop):
self.att = MultiHeadAtt(num_heads, dim_per_head, drop)
self.l1 = M.Dense(dim_per_head * num_heads * 4)
self.l2 = M.Dense(dim_per_head * num_heads)
self.ln1 = M.LayerNorm(1)
self.ln2 = M.LayerNorm(1)
self.drop = drop
def initialize(self, dim, num_heads, attn_drop): self.num_heads = num_heads self.head_dim = dim // num_heads self.scale = self.head_dim ** -0.5 self.attn_drop = attn_drop self.qkv = M.Dense(dim*3, usebias=True) self.proj = M.Dense(dim)
def initialize(self, channel_list, blocknum_list, embedding_size, embedding_bn=True): self.c1 = M.ConvLayer(3, channel_list[0], activation=M.PARAM_PRELU) # self.u1 = ResBlock_v1(channel_list[1], stride=2) self.stage1 = Stage(channel_list[1], blocknum_list[0]) self.stage2 = Stage(channel_list[2], blocknum_list[1]) self.stage3 = Stage(channel_list[3], blocknum_list[2]) self.stage4 = Stage(channel_list[4], blocknum_list[3]) self.bn1 = M.BatchNorm() self.fc1 = M.Dense(512)
def initialize(self, outchns, strides): self.trans = nn.ModuleList() for i,(o,s) in enumerate(zip(outchns,strides)): if o is None or s is None: self.trans.append(None) elif s==1: self.trans.append(M.ConvLayer(3,o, stride=s, pad='SAME_LEFT', activation=M.PARAM_RELU, usebias=False, batch_norm=True)) else: self.trans.append(M.ConvLayer(3,o, stride=s, pad='SAME_LEFT', activation=M.PARAM_RELU, usebias=False, batch_norm=True))
def initialize(self, unit_list, chn_list, multiplier, step): self.step = step self.c1 = M.ConvLayer(5, 64, stride=2, activation=M.PARAM_RELU, batch_norm=True, usebias=False) self.c2 = M.ConvLayer(3, 64, stride=1, activation=M.PARAM_RELU, batch_norm=True, usebias=False) self.stage1 = Stage(unit_list[0], chn_list[0], multiplier, step, reduce_size=chn_list[1]) self.stage2 = Stage(unit_list[1], chn_list[1], multiplier, step, reduce_size=chn_list[2]) self.stage3 = Stage(unit_list[2], chn_list[2], multiplier, step, reduce_size=chn_list[3]) self.stage4 = Stage(unit_list[3], chn_list[3], multiplier, step, reduce_size=None)
def initialize(self, outchn=512, dilation=1, k=3):
self.bn = M.BatchNorm()
self.c1 = M.ConvLayer1D(k,
outchn,
dilation_rate=dilation,
activation=M.PARAM_PRELU,
batch_norm=True,
usebias=False,
pad='VALID')
self.c2 = M.ConvLayer1D(3, outchn, pad='VALID')
def initialize(self, channel_list, blocknum_list, embedding_size, embedding_bn=True):
self.c1 = M.ConvLayer(3, channel_list[0], 1, usebias=False, activation=M.PARAM_PRELU, batch_norm=True)
# self.u1 = ResBlock_v1(channel_list[1], stride=2)
self.stage1 = Stage(channel_list[1], blocknum_list[0])
self.stage2 = Stage(channel_list[2], blocknum_list[1])
self.stage3 = Stage(channel_list[3], blocknum_list[2])
self.stage4 = Stage(channel_list[4], blocknum_list[3])
self.bn1 = M.BatchNorm()
print('Embedding_size:', embedding_size)
self.fc1 = M.Dense(embedding_size, usebias=False)
def initialize(self, upsample_layers, upsample_chn): self.prevlayers = nn.ModuleList() #self.uplayer = M.DeConvLayer(3, upsample_chn, stride=2, activation=M.PARAM_PRELU, batch_norm=True, usebias=False) self.uplayer = M.ConvLayer(3, upsample_chn*4, activation=M.PARAM_PRELU, usebias=False) self.d2s = DepthToSpace(2) self.postlayers = nn.ModuleList() for i in range(upsample_layers): self.prevlayers.append(M.ConvLayer(3, upsample_chn, activation=M.PARAM_PRELU, batch_norm=True, usebias=False)) for i in range(upsample_layers): self.postlayers.append(M.ConvLayer(3, upsample_chn, activation=M.PARAM_PRELU, batch_norm=True, usebias=False))
def initialize(self, num_layers, channel, density_level):
self.layers = nn.ModuleList()
for i in range(num_layers):
self.layers.append(
M.ConvLayer(3,
channel,
activation=M.PARAM_PRELU,
batch_norm=True,
usebias=False))
self.layers.append(M.ConvLayer(1, density_level))
def initialize(self, num_layers, channel, final_chn):
self.layers = nn.ModuleList()
for i in range(num_layers):
self.layers.append(
M.Dense(
channel,
activation=M.PARAM_PRELU,
usebias=False,
batch_norm=True)) # we do Laplasian norm in previous step
self.layers.append(M.Dense(final_chn))
def initialize(self, num_kpts, temp_length): self.num_kpts = num_kpts self.temp_length = temp_length self.c1 = M.ConvLayer1D(3, 1024, stride=3, activation=M.PARAM_PRELU, pad='VALID', batch_norm=True, usebias=False) self.r1 = ResBlock1D(k=3) self.r2 = ResBlock1D(k=3) self.r3 = ResBlock1D(k=3) self.r4 = ResBlock1D(k=3) # self.r3 = ResBlock1D(k=3, dilation=3) # self.c5 = M.ConvLayer1D(9, 256, activation=M.PARAM_PRELU, pad='VALID', batch_norm=True, usebias=False) self.c4 = M.ConvLayer1D(1, num_kpts*3)
def initialize(self, density_num_layers, density_channels, density_level, gcn_layers, gcn_channels, head_layernum, head_chn, upsample_layers, upsample_chn): self.backbone = hrnet.Body() self.upsample = UpSample(upsample_layers, upsample_chn) self.head = Head(head_layernum, head_chn) self.head2 = Head(head_layernum, head_chn) # self.head_density = Head(head_layernum, head_chn) # self.density_branch = DensityBranch(density_num_layers, density_channels, config.num_pts*2) # self.id_branch = DensityBranch(density_num_layers, density_channels, config.id_featdim * config.num_pts) # self.density_branch = M.ConvLayer(1, config.num_pts) self.c1 = M.ConvLayer(1, config.num_pts) self.c2 = M.ConvLayer(1, config.num_pts)
def initialize(self, D=8, W=256, skips=[4]):
# use_viewdirs = True
self.layers = nn.ModuleList()
for i in range(D):
self.layers.append(M.Dense(W, activation=M.PARAM_RELU))
self.skips = skips
self.alpha_fc = M.Dense(1)
self.bottleneck = M.Dense(256)
self.hidden = M.Dense(W//2)
self.out_fc = M.Dense(3)
def initialize(self, head_layernum, head_chn, upsample_layers,
upsample_chn):
self.backbone = hrnet.Body()
self.upsample = UpSample(upsample_layers, upsample_chn)
self.head = Head(head_layernum, head_chn)
self.head2 = Head(head_layernum, head_chn)
self.head3 = Head(head_layernum, head_chn)
self.head4 = Head(head_layernum, head_chn)
self.c1 = M.ConvLayer(1, config.num_pts)
self.c2 = M.ConvLayer(1, config.num_pts)
self.c3 = M.ConvLayer(1, 1)
self.c4 = M.ConvLayer(1, config.num_pts - 1)
def initialize(self, channel_list, blocknum_list, drop_prob):
self.c1 = M.ConvLayer(3,
channel_list[0],
usebias=False,
batch_norm=True,
activation=M.PARAM_PRELU)
self.stage1 = Stage(channel_list[1], blocknum_list[0], drop_prob)
self.stage2 = Stage(channel_list[2], blocknum_list[1], drop_prob)
self.stage3 = Stage(channel_list[3], blocknum_list[2], drop_prob)
self.stage4 = Stage(channel_list[4], blocknum_list[3], drop_prob)
self.bn1 = M.BatchNorm()
self.fc1 = M.Dense(512, usebias=False, batch_norm=True)
def initialize(self, num_pts, out_size):
self.dekr = DEKR(num_pts)
self.sampling = SamplingLayer(out_size)
self.pre_conv = M.ConvLayer(3,
32,
activation=M.PARAM_RELU,
batch_norm=True,
usebias=False)
self.refine_blocks = nn.ModuleList()
self.refine_blocks.append(AdaptConvBlk(32))
self.refine_blocks.append(AdaptConvBlk(32))
self.final_conv = M.ConvLayer(1, num_pts + 1)
self.num_pts = num_pts
def initialize(self, channel_list, blocknum_list):
self.c1 = M.ConvLayer(7,
channel_list[0],
stride=2,
usebias=False,
batch_norm=True,
activation=M.PARAM_RELU)
self.maxpool = M.MaxPool2D(3, 2)
self.stage1 = Stage(channel_list[1], blocknum_list[0], stride=1)
self.stage2 = Stage(channel_list[2], blocknum_list[1], stride=2)
self.stage3 = Stage(channel_list[3], blocknum_list[2], stride=2)
self.stage4 = Stage(channel_list[4], blocknum_list[3], stride=2)
self.fc1 = M.Dense(1000)
def initialize(self, num_pts): self.backbone = Body() self.transition_hmap = M.ConvLayer(1, 32, usebias=False, batch_norm=True, activation=M.PARAM_RELU) self.head_hmap = ResBasicBlock(32, 1) self.conv_hmap = M.ConvLayer(1, num_pts+1) self.transition_off = M.ConvLayer(1, 15*num_pts, usebias=False, batch_norm=True, activation=M.PARAM_RELU) self.reg_blks_off = nn.ModuleList() self.convs_off = nn.ModuleList() for _ in range(num_pts): self.reg_blks_off.append(AdaptConvBlk()) self.reg_blks_off.append(AdaptConvBlk()) self.convs_off.append(M.ConvLayer(1, 2))
def initialize(self, outchn=1024, k=3):
self.k = k
# self.bn = M.BatchNorm()
self.c1 = M.ConvLayer1D(k,
outchn,
stride=k,
activation=M.PARAM_PRELU,
batch_norm=True,
usebias=False,
pad='VALID')
self.c2 = M.ConvLayer1D(1,
outchn,
activation=M.PARAM_PRELU,
batch_norm=True,
usebias=False,
pad='VALID')
def __init__(self, modelpath, nms=0.4):
model = mnet.Detector()
model = model.eval()
x = torch.from_numpy(np.ones([1, 3, 640, 640]).astype(np.float32))
_ = model(x)
M.Saver(model).restore(modelpath)
model.cuda()
self.model = model
self.nms_threshold = nms
self.fpn_keys = []
self._feat_stride_fpn = [32, 16, 8]
for s in self._feat_stride_fpn:
self.fpn_keys.append('stride%s' % s)
self._anchors_fpn = dict(
zip(self.fpn_keys, generate_anchors_fpn(dense_anchor=False)))
for k in self._anchors_fpn:
v = self._anchors_fpn[k].astype(np.float32)
v = torch.from_numpy(v).cuda()
self._anchors_fpn[k] = v
self._num_anchors = dict(
zip(self.fpn_keys,
[anchors.shape[0] for anchors in self._anchors_fpn.values()]))
def __init__(self, modelpath, nms=0.4, worker=2):
model = retina_resnet.Detector()
model = model.eval()
x = torch.from_numpy(np.ones([1, 3, 640, 640]).astype(np.float32))
_ = model(x)
M.Saver(model).restore(modelpath)
model.cuda()
if isinstance(config.gpus, list):
if len(config.gpus) > 1:
print('Using multiple gpus:', config.gpus)
model = torch.nn.DataParallel(model, device_ids=config.gpus)
self.model = model
self.nms_threshold = nms
self.fpn_keys = []
self._feat_stride_fpn = [32, 16, 8]
for s in self._feat_stride_fpn:
self.fpn_keys.append('stride%s' % s)
self._anchors_fpn = dict(
zip(self.fpn_keys, generate_anchors_fpn(dense_anchor=False)))
for k in self._anchors_fpn:
v = self._anchors_fpn[k].astype(np.float32)
v = torch.from_numpy(v).cuda()
self._anchors_fpn[k] = v
self._num_anchors = dict(
zip(self.fpn_keys,
[anchors.shape[0] for anchors in self._anchors_fpn.values()]))
self.worker = worker
def forward(self, x):
x = M.activation(x, M.PARAM_RELU)
x1 = self.c1(x)
x2 = self.c2(x[:, 1:, 1:, :])
x = torch.cat([x1, x2], axis=1)
x = self.bn(x)
return x
def initialize(self, out, stride):
self.c1 = M.ConvLayer(5,
out,
stride=stride,
dilation_rate=2,
batch_norm=True,
usebias=False)
