def generate_model(self, **kwargs):
nfilters_embeded = int(kwargs.get("nfilters_embeded", 1))
nlayers_embeded = int(kwargs.get("nlayers_embeded", 1))
nfilters_cloud = int(kwargs.get("nfilters_cloud", 1))
nlayers_cloud = int(kwargs.get("nlayers_cloud", 1))
model = Sequential()
for i in range(nlayers_embeded):
if i == 0:
nfilters = self.input_dims
model.add(
ConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3, 1,
1))
else:
nfilters = nfilters_embeded
model.add(
BinaryConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3,
1, 1))
branch = Sequential()
branch.add(BinaryLinearBNSoftmax(None, self.output_dims))
model.add(branch)
for i in range(nlayers_cloud):
if i == 0:
nfilters = nfilters_embeded
else:
nfilters = nfilters_cloud
model.add(
BinaryConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3, 1,
1))
model.add(BinaryLinearBNSoftmax(None, self.output_dims))
model.build()
return model
def generate_model(self, **kwargs):
nfilters_embeded = int(kwargs.get("nfilters_embeded", 1))
nlayers_embeded = int(kwargs.get("nlayers_embeded", 1))
nfilters_cloud = int(kwargs.get("nfilters_cloud", 1))
nlayers_cloud = int(kwargs.get("nlayers_cloud", 1))
model = Sequential()
for i in range(nlayers_embeded):
if i == 0:
nfilters = self.input_dims
model.add(
ConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3, 1,
1))
else:
nfilters = nfilters_embeded
model.add(
BinaryConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3,
1, 1))
branch = Sequential()
branch.add(BinaryLinearBNSoftmax(None, self.output_dims))
model.add(branch)
for i in range(nlayers_cloud):
if i == 0:
nfilters = nfilters_embeded
else:
nfilters = nfilters_cloud
model.add(Convolution2D(nfilters, nfilters_cloud, 3, 1, 1))
model.add(BatchNormalization(nfilters_cloud))
model.add(Activation('relu'))
model.add(max_pooling_2d(3, 1, 1))
model.add(Linear(None, self.output_dims))
model.build()
return model
def generate_model(self, **kwargs):
nfilters_embeded_last = int(kwargs.get("nfilters_embeded_last", 1))
nfilters_embeded = int(kwargs.get("nfilters_embeded", 1))
nlayers_embeded = int(kwargs.get("nlayers_embeded", 1))
input_model = Sequential()
for i in range(nlayers_embeded):
if i == 0:
nfilters = self.input_dims
input_model.add(
ConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3, 1,
1))
elif i == nlayers_embeded - 1:
nfilters = nfilters_embeded
input_model.add(
BinaryConvPoolBNBST(nfilters, nfilters_embeded_last, 3, 1,
1, 3, 1, 1))
else:
nfilters = nfilters_embeded
input_model.add(
BinaryConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3,
1, 1))
input_model.add(BinaryLinearBNSoftmax(None, self.output_dims))
input_model.build()
return input_model
def generate_model(self, **kwargs):
nfilters_embeded = int(kwargs.get("nfilters_embeded", 1))
nlayers_embeded = int(kwargs.get("nlayers_embeded", 1))
nfilters_cloud = int(kwargs.get("nfilters_cloud", 1))
nlayers_cloud = int(kwargs.get("nlayers_cloud", 1))
model = Sequential()
for i in range(nlayers_embeded):
if i == 0:
nfilters = self.input_dims
model.add(ConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3, 1, 1))
else:
nfilters = nfilters_embeded
model.add(BinaryConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3, 1, 1))
branch = Sequential()
branch.add(BinaryLinearBNSoftmax(None, self.output_dims))
model.add(branch)
# float branch
floatbranch = Sequential(stages=[1])
for i in range(nlayers_cloud):
if i == 0:
nfilters = nfilters_embeded
else:
nfilters = nfilters_cloud
floatbranch.add(Convolution2D(nfilters, nfilters_cloud, 3, 1, 1))
floatbranch.add(max_pooling_2d(3,1,1))
floatbranch.add(BatchNormalization(nfilters_cloud))
floatbranch.add(Activation('bst'))
# Note: should we move pool to before batch norm like in binary?
floatbranch.add(Linear(None, self.output_dims))
floatbranch.add(BatchNormalization(self.output_dims))
model.add(floatbranch)
# binary branch
for i in range(nlayers_cloud):
if i == 0:
nfilters = nfilters_embeded
else:
nfilters = nfilters_cloud
model.add(BinaryConvPoolBNBST(nfilters, nfilters_embeded, 3, 1, 1, 3, 1, 1))
model.add(BinaryLinearBNSoftmax(None, self.output_dims))
model.build()
return model
def generate_model(self, **kwargs):
nfilters_embeded = int(kwargs.get("nfilters_embeded", 1))
nlayers_embeded = int(kwargs.get("nlayers_embeded", 1))
model = Sequential()
for i in range(nlayers_embeded):
if i == 0:
nfilters = self.input_dims
else:
nfilters = nfilters_embeded
model.add(Convolution2D(nfilters, nfilters_embeded, 3, 1, 1))
model.add(max_pooling_2d(3, 1, 1))
model.add(BatchNormalization(nfilters_embeded))
model.add(Activation('bst'))
model.add(Linear(None, self.output_dims))
model.build()
return model
# float branch
#for i in range(nlayers_cloud):
# if i == 0:
# nfilters = nfilters_embeded
# else:
# nfilters = nfilters_cloud
# model.add(Convolution2D(nfilters, nfilters_cloud, 3, 1, 1))
# model.add(max_pooling_2d(3,1,1))
# model.add(BatchNormalization(nfilters_cloud))
# model.add(Activation('bst'))
# Note: should we move pool to before batch norm like in binary?
#model.add(Linear(None, output_dims))
#model.add(BatchNormalization(output_dims))
model.build()
chain = Chain(branchweight=branchweight, ent_T=ent_T)
chain.add_sequence(model)
chain.setup_optimizers('adam', lr)
print("Model define Over ! ")
#################################################Training####################################################
print("Training Start !")
trainset, testset = chainer.datasets.get_cifar10(ndim=3)
trainer = Trainer('{}/{}'.format(folder, name),
chain,
trainset,
# y = seq(x)
# print y.data.shape
# train test
x = np.random.normal(scale=1, size=(128, 28 * 28)).astype(np.float32)
x = Variable(x)
seq = Sequential(weight_initializer="GlorotNormal", weight_init_std=0.05)
seq.add(Linear(28 * 28, 500, use_weightnorm=True))
seq.add(BatchNormalization(500))
seq.add(Activation("relu"))
seq.add(Linear(None, 500, use_weightnorm=True))
seq.add(BatchNormalization(500))
seq.add(Activation("relu"))
seq.add(Linear(500, 28 * 28, use_weightnorm=True))
seq.build()
chain = Chain()
chain.add_sequence(seq)
chain.setup_optimizers("adam",
0.001,
momentum=0.9,
weight_decay=0.000001,
gradient_clipping=10)
#trainset, testset = chainer.datasets.get_mnist(ndim=3)
#folder = "_models/test_seq"
#nepochs = int(2)
#name = str("output")
