def form_gan():
G = form_generator()
D = form_discriminator()
D.compile(optimizer=adam1, loss='binary_crossentropy')
D.trainable = False
GAN = Sequential([G, D])
GAN.compile(optimizer=adam1, loss='binary_crossentropy')
GAN.summary()
model_json = GAN.to_json()
with open('{0}/model_gan.json'.format(filepath), 'w') as f:
f = json.dump(model_json, f)
if ngpus > 1:
print("call parallel")
G_para = make_parallel(G, ngpus)
D_para = make_parallel(D, ngpus)
GAN_para = make_parallel(GAN, ngpus)
return G, D, GAN
def __create_RNN_siamese_network(self, loss_function, siamese_joint_method):
"""
:param loss_function: Name of loss function
:param siamese_joint_method: Layer of the joint of the Siamese neural network
:type loss_function: str
:type siamese_joint_method: str
:return: Keras Deep RNN Siamese network
:rtype: keras.models.Model
"""
base_network = super().create_RNN_base_network()
input_a = Input(shape=self.input_shape)
input_b = Input(shape=self.input_shape)
processed_a = base_network(input_a)
processed_b = base_network(input_b)
print("batchnormalization:" + str(self.batchnormalization))
if siamese_joint_method == "dense":
con = Concatenate()([processed_a, processed_b])
parent = Dense(units=1, use_bias=False if self.batchnormalization else True)(con)
if self.batchnormalization:
parent = BatchNormalization()(parent)
out = Activation('sigmoid')(parent)
elif siamese_joint_method == "dot_product":
dot = Lambda(batch_dot)([processed_a, processed_b])
parent = dot
if self.batchnormalization:
parent = BatchNormalization()(parent)
out = parent
elif siamese_joint_method == "weighted_dot_product":
dot = Lambda(product)([processed_a, processed_b])
parent = Dense(units=1)(dot)
if self.batchnormalization:
parent = BatchNormalization()(parent)
parent = Activation('sigmoid')(parent)
out = parent
else:
assert False, ("Non-supported siamese_joint_method %s" % siamese_joint_method)
model = Model([input_a, input_b], out)
#optimizer = Adam(clipnorm=1.)
optimizer = RMSprop(clipnorm=1.)
if self.gpu_count > 1:
model = multi_gpu.make_parallel(model, self.gpu_count)
loss_weights = None
model.compile(loss=loss_function, loss_weights=loss_weights, optimizer=optimizer)
# for linear_svm
self.processed_a = processed_a
self.input_a = input_a
return model
def __create_RNN_unsupervised_alpha_prediction_network(
self, gram, size_groups):
"""
:return: Keras Deep RNN Siamese network
:rtype: keras.models.Model
"""
self.num_repeat_in_smallest = 100
self.sparse_rate_callback = LambdaRateScheduler(
start=self.hyperparams['lambda_start'],
end=self.hyperparams['lambda_end'],
end_epoch=self.hyperparams['end_epoch'],
dtype='float32',
num_repeat_in_smallest=self.num_repeat_in_smallest)
base_network = self.create_RNN_base_network()
input_ = Input(shape=self.input_shape)
processed = base_network(input_)
parent = Dense(units=gram.shape[0], use_bias=False)(processed)
if self.batchnormalization:
parent = BatchNormalization()(parent)
#out = Lambda(lambda x: K.sign(x) * x ** 2)(parent)
#out = Lambda(lambda x: x ** 3)(parent)
#out = Activation('tanh')(parent)
out = GroupSoftThresholdingLayer(size_groups)(parent)
#out = SoftThresholdingLayer()(parent)
#out = SoftThresholdingActivation()(parent)
model = Model(input_, out)
optimizer = Adam(clipnorm=1.)
if self.gpu_count > 1:
model = multi_gpu.make_parallel(model, self.gpu_count)
self.loss_function = KSS_Loss(self.sparse_rate_callback.var, gram,
size_groups)
model.compile(loss=self.loss_function, optimizer=optimizer)
return model
input_shape=input_shape))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=pool_size))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
if ngpus > 1:
model = make_parallel(model, ngpus)
model.compile(loss='categorical_crossentropy',
optimizer='adadelta',
metrics=['accuracy'])
model.fit(X_train,
Y_train,
batch_size=batch_size,
nb_epoch=nb_epoch,
verbose=1,
validation_data=(X_test, Y_test))
score = model.evaluate(X_test, Y_test, verbose=0)
print('Test score:', score[0])
print('Test accuracy:', score[1])
parser.add_argument('--batch_size', default=1, type=int, help='batch size')
parser.add_argument('--num_gpus', default=1, type=int, help='num of gpus')
args = parser.parse_args()
if( not args.train and not args.test):
parser.error('Refer to the usage of API')
data = get_raw_data(args.data_dir, args.data_ext)
X, Y, x, y = get_training_data(data, args.seq_length)
X = X[:len(X)-len(X)%args.num_gpus]
model = create_network(x,y, network_specs)
if args.num_gpus != 1:
model = make_parallel(model, args.num_gpus)
batch_size = args.batch_size * args.num_gpus
checkpoint_file = select_best_weight(args.checkpoint_dir)
epochs_done = 0
compile_model(model)
if checkpoint_file is not None:
print("Loading checkpoint file", checkpoint_file)
model.load_weights(checkpoint_file)
epochs_done = int(re.findall(r'\d+', checkpoint_file)[0])
if args.train == True:
print("Training from epoch", epochs_done + 1)
model = Sequential()
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1],
border_mode='valid',
input_shape=input_shape))
model.add(Activation('relu'))
model.add(Convolution2D(nb_filters, kernel_size[0], kernel_size[1]))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=pool_size))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(nb_classes))
model.add(Activation('softmax'))
if ngpus > 1:
model = make_parallel(model,ngpus)
model.compile(loss='categorical_crossentropy',
optimizer='adadelta',
metrics=['accuracy'])
model.fit(X_train, Y_train, batch_size=batch_size, nb_epoch=nb_epoch,
verbose=1, validation_data=(X_test, Y_test))
score = model.evaluate(X_test, Y_test, verbose=0)
print('Test score:', score[0])
print('Test accuracy:', score[1])
def build_model(self, embeds, passage_maxlength, query_maxlength, DIM,
lstm_num, dropout):
passage = Input(shape=(passage_maxlength, ), dtype='int32')
passage_embedding = Embedding(len(embeds),
len(embeds[0]),
weights=[embeds],
input_length=passage_maxlength,
trainable=False)(passage)
# passage_lstm_layers = LSTM(50, return_sequences=True)(passage_embedding)
passage_lstm_layers = passage_embedding
for i in range(lstm_num):
passage_lstm_layers = LSTM(
DIM, return_sequences=True)(passage_lstm_layers)
if dropout:
passage_lstm_layers = Dropout(0.5)(passage_lstm_layers)
query = Input(shape=(query_maxlength, ), dtype='int32')
query_embedding = Embedding(len(embeds),
len(embeds[0]),
weights=[embeds],
input_length=query_maxlength,
trainable=False)(query)
query_lstm_layers = query_embedding
for i in range(lstm_num - 1):
query_lstm_layers = LSTM(DIM,
return_sequences=True)(query_lstm_layers)
if dropout:
query_lstm_layers = Dropout(0.5)(query_lstm_layers)
query_lstm_layers = LSTM(DIM,
return_sequences=False)(query_lstm_layers)
query_lstm_repeat = RepeatVector(passage_maxlength)(query_lstm_layers)
# query_passage_dot=TimeDistributed(Dot(2))([query_lstm_repeat,passage_lstm_layers])
query_passage_mul = Multiply()(
[query_lstm_repeat, passage_lstm_layers])
query_passage_dot = Lambda(lambda x: K.sum(x, axis=2))(
query_passage_mul)
# query_passage_dot_rep = RepeatVector(DIM)(query_passage_dot)
# query_passage_dot_rep_trans = Lambda(transpose021_fun, output_shape=(passage_maxlength, DIM))(query_passage_dot_rep)
# attended_layer = Multiply()([passage_lstm_layers, query_passage_dot_rep_trans])
start_point = Dense(passage_maxlength,
activation='softmax')(query_passage_dot)
end_point = Dense(passage_maxlength, activation='softmax')(start_point)
# start_point = Dense(1, activation='softmax')(attended_layer)
# end_point=Dense(1, activation='softmax')(attended_layer)
# start_point_reshape=Reshape((passage_maxlength,), input_shape=(passage_maxlength,1,))(start_point)
# end_point_reshape=Reshape((passage_maxlength,), input_shape=(passage_maxlength,1,))(end_point)
model = Model(inputs=[passage, query],
outputs=[start_point, end_point])
model = make_parallel(model, 4)
model.compile(optimizer='adagrad',
loss='categorical_crossentropy',
metrics=['accuracy'])
self.model = model
print(model.summary())