def create_convolution1d(self, klayer, kclayer):
config = kclayer["config"]
input_shape = klayer.get_input_shape_at(0)
# batch, steps, dim, batch is None here, so you cannot use it directly.
stack_size = int(input_shape[2])
bpadW, bpadH = self.to_bigdl_2d_padding(klayer.border_mode)
seq = BLayer.Sequential()
seq.add(
BLayer.Reshape([int(input_shape[1]), 1,
int(input_shape[2])], True))
blayer = BLayer.SpatialConvolution(
n_input_plane=stack_size,
n_output_plane=klayer.nb_filter,
kernel_w=1,
kernel_h=klayer.filter_length,
stride_w=1,
stride_h=klayer.subsample_length,
pad_w=bpadW,
pad_h=bpadH,
n_group=1,
propagate_back=True,
wRegularizer=self.to_bigdl_reg(config["W_regularizer"]),
bRegularizer=self.to_bigdl_reg(config["b_regularizer"]),
init_weight=None,
init_bias=None,
init_grad_weight=None,
init_grad_bias=None,
with_bias=config["bias"],
data_format="NHWC",
bigdl_type="float")
seq.add(blayer)
seq.add(BLayer.Squeeze(3))
return self.combo_parameter_layer(seq, config)
def create_globalaveragepooling1d(self, klayer, kclayer):
input_shape = klayer.get_input_shape_at(0) # batch, step, dim
b_kw = 1
b_kh = int(input_shape[1])
seq = BLayer.Sequential()
seq.add(
BLayer.View([int(input_shape[1]), 1,
int(input_shape[2])],
num_input_dims=2))
blayer = BLayer.SpatialAveragePooling(kw=b_kw,
kh=b_kh,
dw=0,
dh=0,
pad_w=0,
pad_h=0,
global_pooling=False,
ceil_mode=False,
count_include_pad=False,
divide=True,
format="NHWC",
bigdl_type="float")
seq.add(blayer)
seq.add(BLayer.Squeeze(
2, num_input_dims=2)) # the index start from one but without batch
seq.add(BLayer.Squeeze(1, num_input_dims=1))
return seq
def create_globalmaxpooling2d(self, klayer, kclayer):
bigdl_order = self.get_bdim_order(kclayer)
input_shape = klayer.get_input_shape_at(0)
if bigdl_order == "NCHW":
b_kw = int(input_shape[3])
b_kh = int(input_shape[2])
else:
b_kw = int(input_shape[2])
b_kh = int(input_shape[1])
seq = BLayer.Sequential()
blayer = BLayer.SpatialMaxPooling(kw=b_kw,
kh=b_kh,
dw=b_kw,
dh=b_kh,
pad_w=0,
pad_h=0,
to_ceil=False,
format=bigdl_order,
bigdl_type="float")
seq.add(blayer)
if bigdl_order == "NCHW":
seq.add(BLayer.Squeeze(3, num_input_dims=3))
seq.add(BLayer.Squeeze(2, num_input_dims=2))
else:
seq.add(BLayer.Squeeze(2, num_input_dims=3))
seq.add(BLayer.Squeeze(1, num_input_dims=2))
return seq
def create_embedding(self, klayer, kclayer):
config = kclayer["config"]
input_shape = klayer.get_input_shape_at(0) # batch, seq_len
seq_len = int(input_shape[1])
if klayer.input_length and klayer.input_length != seq_len:
raise Exception("The input_length doesn't match: %s vs %s" %
(seq_len, klayer.input_length))
if (hasattr(klayer, "dropout") and klayer.dropout != 0):
raise Exception("We don't support dropout for now")
if (hasattr(klayer, "mask_zero") and klayer.mask_zero != False):
raise Exception("We don't support mask_zero for now")
bseq = BLayer.Sequential()
blayer = BLayer.LookupTable(n_index=klayer.input_dim,
n_output=klayer.output_dim,
padding_value=0.0,
norm_type=2.0,
should_scale_grad_by_freq=False,
wRegularizer=self.to_bigdl_reg(
config["W_regularizer"]),
bigdl_type="float")
bseq.add(BLayer.AddConstant(
1.0, inplace=True)) # Add 1 as BigDL is one-based index
bseq.add(blayer)
return bseq
def __generate_zeropadding2d(self, dim1, dim2, n_input_dim, pad1, pad2,
pad3, pad4):
model = BLayer.Sequential()
paddinglayer1 = BLayer.Padding(dim=dim1,
pad=pad1,
n_input_dim=n_input_dim,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer2 = BLayer.Padding(dim=dim1,
pad=pad2,
n_input_dim=n_input_dim,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer3 = BLayer.Padding(dim=dim2,
pad=pad3,
n_input_dim=n_input_dim,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer4 = BLayer.Padding(dim=dim2,
pad=pad4,
n_input_dim=n_input_dim,
value=0.0,
n_index=1,
bigdl_type="float")
model.add(paddinglayer1)
model.add(paddinglayer2)
model.add(paddinglayer3)
model.add(paddinglayer4)
return model
def create_globalaveragepooling2d(self, klayer, kclayer):
bigdl_order = self.get_bdim_order(kclayer)
input_shape = klayer.get_input_shape_at(0)
if bigdl_order == "NCHW":
b_kw = int(input_shape[3])
b_kh = int(input_shape[2])
else:
b_kw = int(input_shape[2])
b_kh = int(input_shape[1])
seq = BLayer.Sequential()
blayer = BLayer.SpatialAveragePooling(kw=b_kw,
kh=b_kh,
dw=b_kw,
dh=b_kh,
pad_w=0,
pad_h=0,
global_pooling=False,
ceil_mode=False,
count_include_pad=False,
divide=True,
format=bigdl_order,
bigdl_type="float")
seq.add(blayer)
if bigdl_order == "NCHW":
seq.add(BLayer.Squeeze(3, num_input_dims=3))
seq.add(BLayer.Squeeze(2, num_input_dims=2))
else:
seq.add(BLayer.Squeeze(2, num_input_dims=3))
seq.add(BLayer.Squeeze(1, num_input_dims=2))
return seq
def _construct_bigdl_sequence(self):
bseq = BLayer.Sequential()
layerConverter = LayerConverter()
for layer in self.kmodel.layers:
blayer = layerConverter.create(
layer, self.node_id_to_config_layer[layer.name])
bseq.add(blayer)
return bseq
def __return_sequences(self, return_sequences, blayer):
# For recurrent layers, handle whether to return the last output sentence or the full sequence.
if return_sequences:
return blayer
else:
model = BLayer.Sequential()
model.add(blayer)
model.add(BLayer.Select(2, -1))
return model
def build_model(class_num):
model = layer.Sequential()
model.add(layer.Reshape([1, 28, 28]))
model.add(layer.SpatialConvolution(1, 6, 5, 5))
model.add(layer.Tanh())
model.add(layer.SpatialMaxPooling(2, 2, 2, 2))
model.add(layer.Tanh())
model.add(layer.SpatialConvolution(6, 12, 5, 5))
model.add(layer.SpatialMaxPooling(2, 2, 2, 2))
model.add(layer.Reshape([12 * 4 * 4]))
model.add(layer.Linear(12 * 4 * 4, 100))
model.add(layer.Tanh())
model.add(layer.Linear(100, class_num))
model.add(layer.LogSoftMax())
return model
def create_zeropadding3d(self, klayer, kclayer):
padding = tuple(klayer.padding)
input_shape = klayer.get_input_shape_at(0)
model = BLayer.Sequential()
paddinglayer1 = BLayer.Padding(dim=2,
pad=-padding[0],
n_input_dim=len(input_shape) - 1,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer2 = BLayer.Padding(dim=2,
pad=padding[0],
n_input_dim=len(input_shape) - 1,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer3 = BLayer.Padding(dim=3,
pad=-padding[1],
n_input_dim=len(input_shape) - 1,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer4 = BLayer.Padding(dim=3,
pad=padding[1],
n_input_dim=len(input_shape) - 1,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer5 = BLayer.Padding(dim=4,
pad=-padding[2],
n_input_dim=len(input_shape) - 1,
value=0.0,
n_index=1,
bigdl_type="float")
paddinglayer6 = BLayer.Padding(dim=4,
pad=padding[2],
n_input_dim=len(input_shape) - 1,
value=0.0,
n_index=1,
bigdl_type="float")
model.add(paddinglayer1)
model.add(paddinglayer2)
model.add(paddinglayer3)
model.add(paddinglayer4)
model.add(paddinglayer5)
model.add(paddinglayer6)
return model
def create_maxpooling1d(self, klayer, kclayer):
input_shape = klayer.get_input_shape_at(0) # batch, steps, dim
bpadW, bpadH = self.to_bigdl_2d_padding(klayer.border_mode)
seq = BLayer.Sequential()
seq.add(
BLayer.View([1, int(input_shape[1]),
int(input_shape[2])],
num_input_dims=3))
blayer = BLayer.SpatialMaxPooling(kw=klayer.pool_length,
kh=1,
dw=klayer.stride,
dh=1,
pad_w=bpadW,
pad_h=bpadH,
to_ceil=False,
format="NHWC",
bigdl_type="float")
seq.add(blayer)
return seq
def create_merge(self, klayer, kclayer):
self.__check_is_share_weights(kclayer)
input_shape = klayer.get_input_shape_at(0)
#TODO: dot_axes, node_indices, tensor_indices not supported.
if klayer.output_shape and not isinstance(klayer.output_shape, tuple):
raise Exception(
"Only output_shape=None or a shape tuple is supported for now."
)
if klayer.output_mask:
raise Exception("Argument `output_mask` is not supported for now.")
if klayer.mode == "concat":
blayer = BLayer.JoinTable(dimension=klayer.concat_axis,
n_input_dims=len(input_shape[0]) - 1,
bigdl_type="float")
elif klayer.mode == "sum":
blayer = BLayer.CAddTable(inplace=False, bigdl_type="float")
elif klayer.mode == "mul":
blayer = BLayer.CMulTable(bigdl_type="float")
elif klayer.mode == "max":
blayer = BLayer.CMaxTable(bigdl_type="float")
elif klayer.mode == "dot":
if len(input_shape[0]) >= 3:
raise Exception(
"Merge mode `dot` doesn't support 3D input or above for now."
)
if input_shape[0][0] == None:
raise Exception(
"For merge mode `dot`, please specify `batch_input_shape`."
)
model = BLayer.Sequential()
blayer = model.add(BLayer.DotProduct(bigdl_type="float"))\
.add(BLayer.Reshape([input_shape[0][0], 1]))
elif klayer.mode in ['ave', 'cos']:
raise Exception(
"Merge mode `%s` not supported for now" %
klayer.mode) # TODO: whether to support cosine and average
else: # invalid mode or lambda functions
raise Exception(
"Invalid merge mode: `%s`. Lambda/function as merge mode is not supported for now."
% klayer.mode)
return blayer
def create_globalmaxpooling1d(self, klayer, kclayer):
input_shape = klayer.get_input_shape_at(0) # batch, step, dim
b_kw = 1
b_kh = int(input_shape[1])
seq = BLayer.Sequential()
seq.add(
BLayer.View([int(input_shape[1]), 1,
int(input_shape[2])],
num_input_dims=2))
blayer = BLayer.SpatialMaxPooling(kw=b_kw,
kh=b_kh,
dw=0,
dh=0,
pad_w=0,
pad_h=0,
to_ceil=False,
format="NHWC",
bigdl_type="float")
seq.add(blayer)
seq.add(BLayer.Squeeze(2, num_input_dims=2))
seq.add(BLayer.Squeeze(1, num_input_dims=1))
return seq
def fuse(self, src_blayer, activation): # activation is a string
seq = BLayer.Sequential()
seq.add(src_blayer)
seq.add(activation)
seq.set_name(src_blayer.name())
return seq
