def __init__(self, conf):
"""Initialize the DCGAN.
Args:
conf (dict): loaded configuration file.
"""
super().__init__(conf)
conf_generator = conf["nn_structure"]["generator"]
self.G = load_model("dir")
self.noise_dim = conf["nn_structure"]["generator"]["noise_dim"]
conf_discriminator = conf["nn_structure"]["discriminator"]
self.D = load_model("dir")
self.disc_loss_function = (BinaryCrossentropy(from_logits=True))
self.gen_loss_function = BinaryCrossentropy(from_logits=True)
if self.ttur:
self.D_optimizer = Adam(learning_rate=self.d_lr)
self.G_optimizer = Adam(learning_rate=self.g_lr)
else:
self.D_optimizer = Adam(learning_rate=self.lr)
self.G_optimizer = Adam(learning_rate=self.lr)
self.disc_optimizers = [self.D_optimizer]
self.generator_optimizers = [self.G_optimizer]
def discriminator_loss(real_output, fake_output):
real_loss = BinaryCrossentropy()(tf.ones_like(real_output),
real_output)
fake_loss = BinaryCrossentropy()(tf.zeros_like(fake_output),
fake_output)
total_loss = real_loss + fake_loss
return total_loss
def __init__(self, filter_size, kernel_size, channel):
super(Discriminator, self).__init__()
# Variables
self.filter_size = filter_size
self.kernel_size = kernel_size
self.channel = channel
# Hyperparameters:
self.optimizer = Adam(lr=2e-4, beta_1=0.5)
# Feature
self.discrim_model = Sequential()
self.discrim_model.add(
Conv2D(filters=2 * self.filter_size,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="same",
kernel_initializer=tf.random_normal_initializer(0, 0.02)))
self.discrim_model.add(LeakyReLU(alpha=0.2))
self.discrim_model.add(
Conv2D(filters=4 * self.filter_size,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="same",
kernel_initializer=tf.random_normal_initializer(0, 0.02)))
self.discrim_model.add(BatchNormalization(epsilon=1e-5))
self.discrim_model.add(LeakyReLU(alpha=0.2))
self.discrim_model.add(
Conv2D(filters=8 * self.filter_size,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="same",
kernel_initializer=tf.random_normal_initializer(0, 0.02)))
self.discrim_model.add(BatchNormalization(epsilon=1e-5))
self.discrim_model.add(LeakyReLU(alpha=0.2))
self.discrim_model.add(
Conv2D(filters=8 * self.filter_size,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="valid",
kernel_initializer=tf.random_normal_initializer(0, 0.02)))
self.discrim_model.add(BatchNormalization())
self.discrim_model.add(LeakyReLU(alpha=0.2))
self.discrim_model.add(Flatten())
self.discrim_model.add(Dense(self.channel, activation='sigmoid'))
# Additional Layers to pass through after the sequential model
# self.batch_norm = BatchNormalization(epsilon = 1e-5)
# self.leaky_relu = LeakyReLU(alpha = 0.2)
# self.flatten = Flatten()
# self.dense = Dense(self.channel, activation = 'sigmoid')
# Define loss
self.real_loss = BinaryCrossentropy()
self.fake_loss = BinaryCrossentropy()
def __init__(self, filter_size, kernel_size, channel):
super(Decoder, self).__init__()
# Variables
self.filter_size = filter_size
self.kernel_size = kernel_size
self.channel = channel
# Hyperparameters:
self.optimizer = Adam(lr=2e-4, beta_1=0.5)
# Sequential Decoder Layers:
self.decoder_model = Sequential()
self.decoder_model.add(
Dense(8 * self.filter_size * args.img_width * args.img_height /
16 / 16))
self.decoder_model.add(
Reshape((int(args.img_width / 16), int(args.img_height / 16),
8 * self.filter_size)))
self.decoder_model.add(BatchNormalization(epsilon=1e-5))
self.decoder_model.add(Activation('relu'))
self.decoder_model.add(
Conv2DTranspose(filters=4 * self.filter_size,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="same",
kernel_initializer=tf.random_normal_initializer(
0, 0.02)))
self.decoder_model.add(BatchNormalization(epsilon=1e-5))
self.decoder_model.add(Activation('relu'))
self.decoder_model.add(
Conv2DTranspose(filters=2 * self.filter_size,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="same",
kernel_initializer=tf.random_normal_initializer(
0, 0.02)))
self.decoder_model.add(BatchNormalization(epsilon=1e-5))
self.decoder_model.add(Activation('relu'))
self.decoder_model.add(
Conv2DTranspose(filters=self.filter_size,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="same",
kernel_initializer=tf.random_normal_initializer(
0, 0.02)))
self.decoder_model.add(BatchNormalization(epsilon=1e-5))
self.decoder_model.add(Activation('relu'))
self.decoder_model.add(
Conv2DTranspose(filters=self.channel,
kernel_size=self.kernel_size,
strides=[2, 2],
padding="same",
kernel_initializer=tf.random_normal_initializer(
0, 0.02)))
self.decoder_model.add(Activation('tanh'))
self.fake_loss = BinaryCrossentropy()
self.tilde_loss = BinaryCrossentropy()
def D_loss(D_truth, D_pred):
"""discriminator loss
Args:
D_truth ([type]): [description]
D_pred ([type]): [description]
"""
D_truth_loss = BinaryCrossentropy()(tf.ones_like(D_truth), D_truth)
D_pred_loss = BinaryCrossentropy()(tf.zeros_like(D_pred), D_pred)
return D_truth_loss + D_pred_loss
def get_dis_loss(self, real_img, generated_img):
with self.strategy.scope():
real_loss = BinaryCrossentropy(from_logits=True,
reduction=Reduction.NONE)(
tf.ones_like(real_img),
real_img)
generated_loss = BinaryCrossentropy(
from_logits=True,
reduction=Reduction.NONE)(tf.zeros_like(generated_img),
generated_img)
return (real_loss + generated_loss) * 0.5
def _compile_model(self):
self.model.compile(
optimizer=Adam(),
loss=BinaryCrossentropy(),
metrics=['accuracy', TruePositives(), TrueNegatives(), FalsePositives(), FalseNegatives(), AUC()]
)
self.model.summary()
def knowledge():
model = Sequential([
Dense(64, activation='sigmoid', input_shape=(10,)),
Dense(1)
])
model.compile(optimizer='sgd', loss=BinaryCrossentropy(from_logits=True))
''' save model weights '''
# 1st way: native format
checkpoint = ModelCheckpoint('/save/my_model', save_weights_only=True)
# 3 files:
# checkpoint
# my_model.data-00000-of-00001
# my_model.index
# 2rd way: keras format
checkpoint = ModelCheckpoint('/save/keras_model.h5', save_weights_only=True)
# keras_model.h5
model.fit(X_train, y_train, epochs=10, callbacks=[checkpoint])
# 3rd way: manually save without callback
model.save_weights('my_model')
''' load model '''
model = Sequential([
Dense(64, activation='sigmoid', input_shape=(10,)),
Dense(1)
])
model.load_weights('my_model')
model.load_weights('keras_model.h5')
def custom_loss(y_true, y_pred):
# notice that MeanSquaredError is different from mse, due to their inconsistent usage of K.mean
# class MeanSquaredError, BinaryCrossentropy: their __call__ method will return a scalar
# which coincides with the return type of custom_loss function, i.e. scalar
# to be more precise: (tensor) shape=()
image_loss = MeanSquaredError()(y_true=input_fifth,
y_pred=predicted_img) # scalar
reward_loss = MeanSquaredError()(y_true=reward,
y_pred=predicted_reward) # scalar
done_loss = BinaryCrossentropy()(y_true=done,
y_pred=predicted_done) # scalar
# notice that latent_loss is related to latent_dim
# here we divided it by latent_dim
latent_loss = 1 - K.square(z_mean) - K.exp(
z_log_var) + z_log_var # (?, latent_dim)
latent_loss = K.sum(latent_loss,
axis=-1) # sum along the last axis --> (?,)
latent_loss *= -0.5
# make latent_loss irrelevant to latent_dim, where the latter one may vary as a hyper-parameter
latent_loss /= latent_dim
latent_loss = K.mean(latent_loss) # take mean over batch --> scalar
overall_loss = \
loss_weight['image_loss'] * image_loss + \
loss_weight['reward_loss'] * reward_loss + \
loss_weight['done_loss'] * done_loss + \
loss_weight['latent_loss'] * latent_loss
return overall_loss
def generator_loss(fake_output, apply_label_smoothing=True):
cross_entropy = BinaryCrossentropy(from_logits=False)
if apply_label_smoothing:
fake_output_smooth = smooth_negative_labels(tf.ones_like(fake_output))
return cross_entropy(tf.ones_like(fake_output_smooth), fake_output)
else:
return cross_entropy(tf.ones_like(fake_output), fake_output)
def __init__(self,
encoder,
decoder,
img_size=64,
z_dim=100,
batch_size=16,
n_epochs=51,
shuffle=True):
super(AE, self).__init__()
# Set random seed
random_seed = 42
tf.random.set_seed(random_seed)
np.random.seed(random_seed)
self.encoder = encoder
self.decoder = decoder
self.img_size = img_size
self.z_dim = z_dim
self.batch_size = batch_size
self.n_epochs = n_epochs
self.volume_size = 0
self.shuffle = shuffle
self.cross_entropy = BinaryCrossentropy(from_logits=True)
self.mse = MeanSquaredError()
self.accuracy = BinaryAccuracy()
self.hist = {
"ae_loss": [],
"ae_acc": [],
"dc_loss": [],
"dc_acc": [],
"gen_loss": []
}
self.trainer = None
def get_gen_loss(self, generated_img):
with self.strategy.scope():
generated_loss = BinaryCrossentropy(
from_logits=True,
reduction=Reduction.NONE)(tf.ones_like(generated_img),
generated_img)
return generated_loss
def stacked_lstm(embeddings: np.ndarray) -> (tf.keras.Model, str):
config = nns_config['stacked_lstm']
model_name = config['model_name']
model = Sequential()
model.add(
Embedding(input_dim=embeddings.shape[0],
output_dim=embeddings.shape[1],
embeddings_initializer=Constant(embeddings),
input_length=MAX_LENGTH,
trainable=TRAINABLE_EMBEDDINGS,
mask_zero=True))
for i in range(len(config['lstm_units'])):
model.add(
ResidualRNN(
rnn_type=config['rnn_type'],
units=config['lstm_units'][i],
dropout=config['lstm_dropout'],
residual=config['residual'],
high_init=config['high_init'],
return_sequences=(True if i < len(config['lstm_units']) - 1
else False)))
model.add(Dropout(config['dense_dropout']))
for units in config['dense_units']:
model.add(Dense(units, activation='relu'))
model.add(Dropout(config['dense_dropout']))
model.add(Dense(2, activation='softmax'))
opt = tf.keras.optimizers.Adam(lr=config['lr'])
model.compile(optimizer=opt,
loss=BinaryCrossentropy(),
metrics=['accuracy'])
print(model.summary())
return model, model_name
def __init__(self, img_shape=(256, 256, 3), ngf=64, ndf=64, lamdba_l1=100.0):
self.img_rows, self.img_cols, self.channels = self.img_shape = img_shape
self.ngf, self.ndf = ngf, ndf
self.lamdba_l1 = lamdba_l1
self.generator = self.build_generator()
self.generator_optimizer = Adam(2e-4, beta_1=0.5)
self.discriminator = self.build_discriminator()
self.discriminator_optimizer = Adam(2e-4, beta_1=0.5)
self.loss_obj = BinaryCrossentropy(from_logits=True)
self.disc_patch = tuple(self.discriminator_x.output.shape)[1:]
checkpoint_path = "./checkpoints/train"
ckpt = tf.train.Checkpoint(generator=self.generator,
discriminator=self.discriminator,
generator_optimizer=self.generator_optimizer,
discriminator_optimizer=self.discriminator_optimizer)
self.ckpt_manager = tf.train.CheckpointManager(
ckpt, checkpoint_path, max_to_keep=5)
if self.ckpt_manager.latest_checkpoint:
ckpt.restore(self.ckpt_manager.latest_checkpoint)
print('Latest checkpoint restored!!')
def __init__(self,
util: Utils,
hr_size=96,
log_dir: str = None,
num_resblock: int = 16):
self.vgg = self.vgg(20)
self.learning_rate = 0.00005
self.clipping = 0.01
self.generator_optimizer = RMSprop(learning_rate=self.learning_rate,
clipvalue=self.clipping)
self.discriminator_optimizer = RMSprop(
learning_rate=self.learning_rate, clipvalue=self.clipping)
self.binary_cross_entropy = BinaryCrossentropy(from_logits=True)
self.mean_squared_error = MeanSquaredError()
self.util: Utils = util
self.HR_SIZE = hr_size
self.LR_SIZE = self.HR_SIZE // 4
if log_dir is not None:
self.summary_writer = tf.summary.create_file_writer(log_dir)
if log_dir.startswith('../'):
log_dir = log_dir[len('../'):]
print('open tensorboard with: tensorboard --logdir ' + log_dir)
else:
self.summary_writer = None
self.generator = make_generator_model(num_res_blocks=num_resblock)
self.discriminator = make_discriminator_model(self.HR_SIZE)
self.checkpoint = tf.train.Checkpoint(generator=self.generator,
discriminator=self.discriminator)
def _build_compile_network(self):
self.logger.debug("Building and compiling network...")
network = self.model_factory.build_many_to_many(mask_value=self.mask_value)
network.compile(optimizer=self.optimizer, metrics=["accuracy"],
loss=BinaryCrossentropy(from_logits=True))
network.summary(print_fn=self.logger.debug)
return network
def train_step(inputs):
with tf.GradientTape(persistent=False) as tape:
predicted_img, predicted_reward, predicted_done = vae(inputs,
training=True)
_reconstruction_loss = MeanSquaredError()(predicted_img,
vae.input_fifth_var)
_reward_loss = MeanSquaredError()(predicted_reward, vae.reward_var)
_kl_loss = -0.5 * (K.sum(1 - K.square(vae.z_mean_var) -
K.exp(vae.z_log_var_var) + vae.z_log_var_var,
axis=-1))
_done_loss = BinaryCrossentropy()(predicted_done, vae.done_var)
total_loss = loss_weight['image_loss'] * _reconstruction_loss + \
loss_weight['latent_loss'] * _kl_loss + \
loss_weight['reward_loss'] * _reward_loss + \
loss_weight['done_loss'] * _done_loss
gradients = tape.gradient(total_loss, vae.trainable_variables)
optimizer.apply_gradients(zip(gradients, vae.trainable_variables))
# reward_trainable_vairables = vae.dr1.trainable_variables + vae.dr2.trainable_variables + \
# vae.dr3.trainable_variables + vae.dr4.trainable_variables + \
# vae.dreward.trainable_variables
# print(reward_trainable_vairables)
# gradients_reward = tape.gradient(_reward_loss, reward_trainable_vairables)
# optimizer.apply_gradients((zip(gradients_reward, reward_trainable_vairables)))
train_loss(total_loss)
train_reward_loss(_reward_loss)
train_reconstruction_loss(_reconstruction_loss)
train_kl_loss(_kl_loss)
train_done_loss(_done_loss)
def __init__(
self,
user_size=100,
item_size=100,
representation_layers=[],
embedding_size=16,
matching_layers=[32],
activation="relu",
):
def joinLst(x):
return "_".join([str(_) for _ in x])
self.backup_path = f"./training/deepcf__{joinLst(representation_layers)}__{joinLst([embedding_size]+matching_layers)}/mdl.ckpt"
self.cp_callback = ModelCheckpoint(
filepath=self.backup_path, save_weights_only=True, verbose=0
)
inputs = self._create_inputs(user_size, item_size)
representation_model = self._create_representation_model(
inputs, representation_layers, activation
)
matchingfunction_model = self._create_matchingfunction_model(
inputs, embedding_size, matching_layers, activation
)
fusion_layer = Concatenate()([representation_model, matchingfunction_model])
output = Dense(1, activation="sigmoid")(fusion_layer)
self.model = Model(inputs, output, name="DeepCF")
self.model.compile(
optimizer="adam",
loss=BinaryCrossentropy(),
metrics=[RootMeanSquaredError()],
)
def __init__(self, size1=512, size2=128, gru_length=20):
self.backup_path = f"./training/zeroshot__{size1}__{size2}/mdl.ckpt"
self.cp_callback = ModelCheckpoint(
filepath=self.backup_path, save_weights_only=True, verbose=0
)
user_input = Input(shape=(gru_length, 768))
item_input = Input(shape=(768))
self.inputs = [user_input, item_input]
layer1 = Dense(size1, activation="relu")
layer2 = Dense(size2, activation="relu")
self.layers = [layer1, layer2]
self.gru = GRU(size2)
user_present = self.gru(layer2(layer1(user_input)))
item_present = layer2(layer1(item_input))
output = Activation(activation="sigmoid")(
Dot(axes=1)([user_present, item_present])
)
self.model = Model(self.inputs, output, name="ZeroShot")
self.model.compile(
optimizer="adam",
loss=BinaryCrossentropy(),
metrics=[RootMeanSquaredError()],
)
self._update_models()
self._gen_score_layer(size2)
def __init__(self, conf):
"""Initialize the Pix2Pix model.
Args:
conf (dict): loaded configuration file.
"""
super().__init__(conf)
conf_generator = conf["nn_structure"]["generator"]
self.G = create_generator(conf_generator, self.input_shape, 0)
conf_discriminator = conf["nn_structure"]["discriminator"]
self.D = create_discriminator(conf_discriminator, self.input_shape)
self.disc_loss_function = (BinaryCrossentropy(
from_logits=True) if conf_discriminator["loss_function"] == "BCE"
else MeanSquaredError())
# loss_coeffs
self.DM_loss_coeff = conf["loss_coeffs"]["DM_loss_coeff"]
self.L1_loss_coeff = conf["loss_coeffs"]["L1_loss_coeff"]
self.gan_loss_coeff = conf["loss_coeffs"]["gan_loss_coeff"]
# Optimizers
if self.ttur:
self.D_optimizer = Adam(learning_rate=self.d_lr, beta_1=0.5)
self.G_optimizer = Adam(learning_rate=self.g_lr, beta_1=0.5)
else:
self.D_optimizer = Adam(learning_rate=self.lr, beta_1=0.5)
self.G_optimizer = Adam(learning_rate=self.lr, beta_1=0.5)
self.disc_optimizers = [self.D_optimizer]
self.generator_optimizers = [self.G_optimizer]
def compute_results(train_dataset: PrefetchDataset, test_dataset: PrefetchDataset, model: Sequential) -> History:
"""
Configures and trains the model, then evaluates its accuracy against the test dataset. The trained model is saved
to the outputs folder.
:param train_dataset: A PrefetchDataset that the model will be trained on.
:param test_dataset: A PrefetchDataset that the model's accuracy will be evaluated against.
:param model: The Sequential object to be trained.
:return: A History object containing information about the model's metrics during the training process.
"""
model.compile(loss=BinaryCrossentropy(from_logits=True), optimizer=Adam(), metrics=["accuracy"])
# Here we introduce an early stopping callback function that will cease training once the validation loss
# stops decreasing. This is to minimize over-fitting (i.e. reduce the difference between training loss
# and validation loss).
# Idea retrieved from https://machinelearningmastery.com/early-stopping-to-avoid-overtraining-neural-network-models/
es_callback = EarlyStopping(monitor="val_loss", patience=3)
# Train the model
history = model.fit(train_dataset, validation_data=test_dataset, batch_size=BATCH_SIZE, epochs=EPOCHS,
callbacks=[es_callback])
# Get the loss values and metrics once evaluating the model against the test dataset
test_loss, test_accuracy = model.evaluate(test_dataset)
print(f"Test Loss: {test_loss}")
print(f"Test Accuracy: {test_accuracy}")
model.save(ROOT / "outputs/my_model")
return history
def __init__(self,
generator,
discriminator,
content_loss='VGG54',
learning_rate=PiecewiseConstantDecay(boundaries=[100000],
values=[1e-4, 1e-5])):
if content_loss == 'VGG22':
self.vgg = srgan.vgg_22()
elif content_loss == 'VGG54':
self.vgg = srgan.vgg_54()
else:
raise ValueError("content_loss must be either 'VGG22' or 'VGG54'")
self.content_loss = content_loss
self.generator = generator
self.discriminator = discriminator
self.generator_optimizer = Adam(learning_rate=learning_rate)
self.discriminator_optimizer = Adam(learning_rate=learning_rate)
self.binary_cross_entropy = BinaryCrossentropy(from_logits=False)
self.mean_squared_error = MeanSquaredError()
log_param("Model", "Pre-trained SRGAN")
log_param("Learning rate", learning_rate)
log_param("Content loss", content_loss)
def __init__(self, start_epoch, learning_rate, z_dim):
self.name = 'gan'
self.loss_obj = BinaryCrossentropy(from_logits=True)
self.generator_optimizer = Adam(learning_rate=learning_rate,
beta_1=0.5,
epsilon=1e-6)
self.discriminator_optimizer = Adam(learning_rate=learning_rate,
beta_1=0.5,
epsilon=1e-6)
self.z_dim = z_dim
self.current_time = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
self.train_log_dir = '/Users/mah/Desktop/GAN/logs/Gradient_tape/' + self.current_time + '/train'
self.train_summary_writer = tf.summary.create_file_writer(
self.train_log_dir)
self.weight_init = RandomNormal(mean=0., stddev=0.02)
self.epoch = start_epoch
self.d_total_losses = []
self.g_total_losses = []
self.seed = tf.random.normal([16, self.z_dim])
self._build_discriminator()
self._build_generator()
def _build_distilbert_model(transformer, max_len=512):
input_word_ids = Input(shape=(max_len, ),
dtype=tf.int32,
name="input_word_ids")
sequence_output = transformer(input_word_ids)[0]
cls_token = sequence_output[:, 0, :]
cls_token = Dense(500, activation="elu")(cls_token)
cls_token = Dropout(0.2)(cls_token)
out = Dense(6, activation='sigmoid')(cls_token)
model = Model(inputs=input_word_ids, outputs=out)
model.compile(
Adam(lr=1.5e-5),
loss=size_decorator(
BinaryCrossentropy(reduction=tf.keras.losses.Reduction.NONE,
label_smoothing=0.2)),
#'binary_crossentropy',
metrics=[
size_decorator(binary_accuracy),
size_decorator(matthews_correlation)
])
return model
def compile(self, optimizer, metrics=["accuracy"], *args, **kwargs):
self.model.compile(optimizer=optimizer,
loss=BinaryCrossentropy(from_logits=True),
metrics=metrics,
*args,
**kwargs)
def Sequential_compile_train(X_train,
y_train,
validation_data=None,
epochs=15,
verbose=1,
Adam_learning_rate=0.001):
N_features = X_train.shape[1]
N_labels = y_train.shape[1]
model = Sequential()
model.add(Input(shape=(N_features, )))
# model.add(Dense(units=5000, activation='relu'))
model.add(Dense(units=1000, activation='relu'))
model.add(Dense(units=500, activation='relu'))
# model.add(Dense(units=500, activation='relu'))
model.add(Dense(units=100, activation='relu'))
model.add(Dense(units=N_labels, activation='sigmoid'))
model.summary()
# model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['binary_accuracy'])
model.compile(optimizer=Adam(learning_rate=Adam_learning_rate),
loss=BinaryCrossentropy(),
metrics=['binary_accuracy'])
history = model.fit(X_train,
y_train,
epochs=epochs,
batch_size=32,
verbose=verbose,
validation_data=validation_data)
return model, history
def lstm(embeddings: np.ndarray) -> (tf.keras.Model, str):
model_name = "lstm"
config = nns_config['stacked_lstm']
model_name = '{}_{}_dense{}x2'.format(model_name,
str(config['lstm_units'][0]),
str(config['dense_units'][0]))
model = Sequential()
model.add(
Embedding(input_dim=embeddings.shape[0],
output_dim=embeddings.shape[1],
embeddings_initializer=Constant(embeddings),
input_length=MAX_LENGTH,
trainable=TRAINABLE_EMBEDDINGS,
mask_zero=True))
model.add(
Bidirectional(
LSTM(config['lstm_units'][0], dropout=config['lstm_dropout'])))
model.add(Dropout(config['dense_dropout']))
for units in config['dense_units']:
model.add(Dense(units, activation='relu'))
model.add(Dropout(config['dense_dropout']))
model.add(Dense(2, activation='softmax'))
opt = tf.keras.optimizers.Adam(lr=config['lr'])
model.compile(optimizer=opt,
loss=BinaryCrossentropy(),
metrics=['accuracy'])
print(model.summary())
return model, model_name
def get_model(input_shape):
input = Input(shape=input_shape)
h = Conv2D(filters=32, kernel_size=(3, 3), activation=relu,
padding='SAME')(input)
h = Conv2D(filters=32, kernel_size=(3, 3), activation=relu,
padding='SAME')(h)
h = MaxPooling2D(pool_size=2)(h)
h = Conv2D(filters=64, kernel_size=(3, 3), activation=relu,
padding='SAME')(h)
h = Conv2D(filters=64, kernel_size=(3, 3), activation=relu,
padding='SAME')(h)
h = MaxPooling2D(pool_size=2)(h)
h = Conv2D(filters=128,
kernel_size=(3, 3),
activation=relu,
padding='SAME')(h)
h = Conv2D(filters=128,
kernel_size=(3, 3),
activation=relu,
padding='SAME')(h)
h = MaxPooling2D(pool_size=2)(h)
h = Flatten()(h)
h = Dense(units=128, activation=relu)(h)
h = Dense(units=1, activation=sigmoid)(h)
model = Model(inputs=input, outputs=h)
model.compile(optimizer=RMSprop(learning_rate=0.001),
loss=BinaryCrossentropy(),
metrics=[BinaryAccuracy()])
return model
def __init__(self,
loss=BinaryCrossentropy(from_logits=True),
path_save="DCGAN"):
# parameters
self.path_save = path_save
self.img_rows = 28
self.img_cols = 28
self.channels = 1
self.img_shape = (self.img_rows, self.img_cols, self.channels)
self.latent_dim = 100 # will be split in 2 parts (if we want)
self.discri_optimizer = Adam(1e-4)
self.stacked_optimizer = Adam(1e-4)
self.loss = loss
# discriminator
self.discriminator = self.build_discriminator()
self.discriminator.compile(loss=self.loss,
optimizer=self.discri_optimizer,
metrics=['accuracy'])
# stacked
self.generator = self.build_generator()
z = Input(shape=(self.latent_dim, ))
img = self.generator(z)
self.discriminator.trainable = False
is_valid = self.discriminator(img)
self.stacked = Model(z, is_valid)
self.stacked.compile(loss=self.loss,
optimizer=self.stacked_optimizer,
metrics=['accuracy'])
def create_joint_model(generator, descriminator):
# joint_model = Sequential()
# joint_model.add(generator)
# joint_model.add(descriminator)
descriminator.trainable = False
gen_seed_input, gen_clss_input = generator.input
gen_output = generator.output
gan_output = descriminator([gen_output, gen_clss_input])
joint_model = Model([gen_seed_input, gen_clss_input], gan_output)
optimizer = Adam(learning_rate=GEN_LR, beta_1=0.5)
# loss = CategoricalCrossentropy()
loss = BinaryCrossentropy()
metrics = [
'acc',
BinaryTruePositiveWithNoise(name='GenTP'),
BinaryFalseNegativeWithNoise(name='GenFN'),
# FalseNegatives(name='GenFN', thresholds=0.5),
# TruePositives(name='GenTP', thresholds=0.5)
]
joint_model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
return joint_model
