def create_model(
self,
rho=0.9,
decay=0.0,
):
inputs = Input(shape=(self.max_length, self.max_index))
char_embedding = TimeDistributed(
Dense(self.char_embedding_size, use_bias=False,
activation='tanh'))(inputs)
char_embedding = Reshape(
(self.max_length, self.char_embedding_size, 1))(char_embedding)
masked_embedding = MaskConv(0.0)(char_embedding)
masked_seq = MaskToSeq(layer=MaskConv(0.0),
time_axis=1)(char_embedding)
char_feature = MaskConvNet(
Conv2D(
self.channel_size,
(2, self.conv_size),
strides=(1, self.conv_size),
activation='tanh',
padding='same',
use_bias=False,
))(masked_embedding)
mask_feature = MaskPooling(MaxPool2D((self.max_length, 1),
padding='same'),
pool_mode='max')(char_feature)
encoded_feature = ConvEncoder()([mask_feature, masked_seq])
dense_input = RNNDecoder(
RNNCell(LSTM(
units=self.latent_size,
return_sequences=True,
implementation=2,
unroll=False,
dropout=0.,
recurrent_dropout=0.,
),
Dense(units=self.encoding_size, activation='tanh'),
dense_dropout=0.))(encoded_feature)
outputs = TimeDistributed(
Dense(self.word_embedding_size, activation='tanh'))(dense_input)
model = Model(inputs, outputs)
picked = Pick()(encoded_feature)
encoder = Model(inputs, picked)
optimizer = RMSprop(
lr=self.learning_rate,
rho=rho,
decay=decay,
)
model.compile(loss='cosine_proximity', optimizer=optimizer)
return model, encoder
def create_model(self):
inputs = Input(shape=(self.x, self.y, self.z, self.channel_size))
masked_inputs = MaskConv(self.mask_value)(inputs)
outputs = MaskPooling(AvgPool3D(self.pool_size, self.strides,
self.padding),
pool_mode='avg')(masked_inputs)
model = Model(inputs, outputs)
model.compile('sgd', 'mean_squared_error')
return model
def create_model(self):
inputs = Input(shape=(self.x, self.y, self.z, self.channel_size))
masked_inputs = MaskConv(self.mask_value)(inputs)
outputs = MaskConvNet(
Conv3D(self.filters, self.kernel,
strides=self.strides))(masked_inputs)
model = Model(inputs, outputs)
model.compile('sgd', 'mean_squared_error')
return model
def create_model(self):
inputs = Input(shape=(self.x, self.y, self.channel_size))
masked_inputs = MaskConv(self.mask_value)(inputs)
masked_seq = MaskToSeq(MaskConv(self.mask_value))(inputs)
conv_outputs = MaskConvNet(
Conv2D(
self.filters,
self.kernel,
strides=self.strides,
))(masked_inputs)
pooling_outputs = MaskPooling(
MaxPool2D(
self.mask_kernel,
self.mask_strides,
self.padding,
))(conv_outputs)
outputs = ConvEncoder()([pooling_outputs, masked_seq])
model = Model(inputs, outputs)
model.compile('sgd', 'mean_squared_error')
return model
def create_model(self):
inputs = Input(shape=(self.x, self.y, self.channel_size))
outputs = MaskToSeq(MaskConv(self.mask_value))(inputs)
model = Model(inputs, outputs)
model.compile('sgd', 'mean_squared_error')
return model