def create_critic_generator_wgan(**kwargs):
#
# Parse settings
#
dropout = kwargs.get("dropout", -1.)
GAN_noise_size = kwargs.get("GAN_noise_size", 3)
leaky_relu = kwargs.get("leaky_relu", 0.2)
num_observables = kwargs.get("num_observables")
num_conditions = kwargs.get("num_conditions")
verbose = kwargs.get("verbose", True)
use_batch_norm = kwargs.get("batch_norm", False)
use_dropout = False
if dropout > 0: use_dropout = True
critic_data_layers = kwargs.get("critic_data_layers", (10, ))
critic_condition_layers = kwargs.get("critic_condition_layers", (10, ))
critic_combined_layers = kwargs.get("critic_combined_layers", (
20,
20,
))
generator_noise_layers = kwargs.get("generator_noise_layers", (20, ))
generator_condition_layers = kwargs.get("generator_condition_layers",
(10, ))
generator_combined_layers = kwargs.get("generator_combined_layers", (
20,
20,
))
#
# Print stage
#
if verbose:
print(
f"Creating WGAN with {num_observables} observables and {num_conditions} conditions"
)
#
# Create input layers
#
data_input = Input((num_observables, ))
condition_input = Input((num_conditions, ))
noise_input = Input((GAN_noise_size, ))
#
# Create initially separate layers for the condition and data (critic)
#
critic_data = data_input
for layer_size in critic_data_layers:
critic_data = Dense(layer_size)(critic_data)
critic_data = LeakyReLU(leaky_relu)(critic_data)
if use_dropout: critic_data = Dropout(dropout)(critic_data)
critic_condition = condition_input
for layer_size in critic_condition_layers:
critic_condition = Dense(layer_size)(critic_condition)
critic_condition = LeakyReLU(leaky_relu)(critic_condition)
if use_dropout: critic_condition = Dropout(dropout)(critic_condition)
#
# Concatenate the condition and data latent states (critic)
#
critic = Concatenate()([critic_data, critic_condition])
#
# Create final critic layers
#
for layer_size in critic_combined_layers:
critic = Dense(layer_size)(critic)
critic = LeakyReLU(leaky_relu)(critic)
if use_dropout: critic = Dropout(dropout)(critic)
#
# Compile critic model
#
critic = Dense(1, activation="linear")(critic)
critic = Model(name="Critic",
inputs=[data_input, condition_input],
outputs=[critic])
critic.compile(loss=wasserstein_loss,
optimizer=RMSprop(learning_rate=5e-5, rho=0))
if verbose: critic.summary()
#
# Create initially separate layers for the noise and data (generator)
#
generator_noise = noise_input
for layer_size in generator_noise_layers:
generator_noise = Dense(layer_size)(generator_noise)
generator_noise = LeakyReLU(leaky_relu)(generator_noise)
if use_batch_norm:
generator_noise = BatchNormalization()(generator_noise)
generator_condition = condition_input
for layer_size in generator_condition_layers:
generator_condition = Dense(layer_size)(generator_condition)
generator_condition = LeakyReLU(leaky_relu)(generator_condition)
if use_batch_norm:
generator_condition = BatchNormalization()(generator_condition)
#
# Concatenate the condition and noise latent states (generator)
#
generator = Concatenate()([generator_noise, generator_condition])
#
# Create final generator layers
#
for layer_size in generator_combined_layers:
generator = Dense(layer_size)(generator)
generator = LeakyReLU(leaky_relu)(generator)
if use_batch_norm: generator = BatchNormalization()(generator)
#
# Compile generator model
#
generator = Dense(num_observables, activation="linear")(generator)
generator = Model(name="Generator",
inputs=[noise_input, condition_input],
outputs=[generator])
if verbose: generator.summary()
#
# Create and compile GAN
#
GAN = critic([generator([noise_input, condition_input]), condition_input])
GAN = Model([noise_input, condition_input], GAN, name="GAN")
critic.trainable = False
GAN.compile(loss=wasserstein_loss,
optimizer=RMSprop(learning_rate=5e-5, rho=0))
if verbose: GAN.summary()
#
# return critic, generator, GAN
#
return critic, generator, GAN
def InceptionResNetV2(include_top=True,
weights='imagenet',
weights_path=None,
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
'''Instantiates the Inception-ResNet v2 architecture.
Optionally loads weights pre-trained on ImageNet.
Note that when using TensorFlow, for best performance you should
set `"image_data_format": "channels_last"` in your Keras config
at `~/.keras/keras.json`.
Note that the default input image size for this model is 299x299, instead
of 224x224 as in the VGG16 and ResNet models. Also, the input preprocessing
function is different (i.e., do not use `imagenet_utils.preprocess_input()`
with this model. Use `preprocess_input()` defined in this module instead).
# Arguments
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization)
or `'imagenet'` (pre-training on ImageNet).
input_tensor: optional Keras tensor (i.e. output of `layers.Input()`)
to use as image input for the model.
input_shape: optional shape tuple, only to be specified
if `include_top` is `False` (otherwise the input shape
has to be `(299, 299, 3)` (with `'channels_last'` data format)
or `(3, 299, 299)` (with `'channels_first'` data format).
It should have exactly 3 inputs channels,
and width and height should be no smaller than 139.
E.g. `(150, 150, 3)` would be one valid value.
pooling: Optional pooling mode for feature extraction
when `include_top` is `False`.
- `None` means that the output of the model will be
the 4D tensor output of the last convolutional layer.
- `'avg'` means that global average pooling
will be applied to the output of the
last convolutional layer, and thus
the output of the model will be a 2D tensor.
- `'max'` means that global max pooling will be applied.
classes: optional number of classes to classify images
into, only to be specified if `include_top` is `True`, and
if no `weights` argument is specified.
# Returns
A Keras `Model` instance.
# Raises
ValueError: in case of invalid argument for `weights`,
or invalid input shape.
RuntimeError: If attempting to run this model with an unsupported backend.
'''
if K.backend() in {'cntk'}:
raise RuntimeError(K.backend() +
' backend is currently unsupported for this model.')
if weights not in {'imagenet', None}:
raise ValueError('The `weights` argument should be either '
'`None` (random initialization) or `imagenet` '
'(pre-training on ImageNet).')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=299,
min_size=139,
data_format=K.image_data_format(),
require_flatten=False,
weights=weights)
if input_tensor is None:
img_input = Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
# Stem block: 35 x 35 x 192
x = conv2d_bn(img_input, 32, 3, strides=2, padding='valid')
x = conv2d_bn(x, 32, 3, padding='valid')
x = conv2d_bn(x, 64, 3)
x = MaxPooling2D(3, strides=2)(x)
x = conv2d_bn(x, 80, 1, padding='valid')
x = conv2d_bn(x, 192, 3, padding='valid')
x = MaxPooling2D(3, strides=2)(x)
# Mixed 5b (Inception-A block): 35 x 35 x 320
branch_0 = conv2d_bn(x, 96, 1)
branch_1 = conv2d_bn(x, 48, 1)
branch_1 = conv2d_bn(branch_1, 64, 5)
branch_2 = conv2d_bn(x, 64, 1)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_2 = conv2d_bn(branch_2, 96, 3)
branch_pool = AveragePooling2D(3, strides=1, padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1)
branches = [branch_0, branch_1, branch_2, branch_pool]
channel_axis = 1 if K.image_data_format() == 'channels_first' else 3
x = Concatenate(axis=channel_axis, name='mixed_5b')(branches)
# 10x block35 (Inception-ResNet-A block): 35 x 35 x 320
for block_idx in range(1, 11):
x = inception_resnet_block(x,
scale=0.17,
block_type='block35',
block_idx=block_idx)
# Mixed 6a (Reduction-A block): 17 x 17 x 1088
branch_0 = conv2d_bn(x, 384, 3, strides=2, padding='valid')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 256, 3)
branch_1 = conv2d_bn(branch_1, 384, 3, strides=2, padding='valid')
branch_pool = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_6a')(branches)
# 20x block17 (Inception-ResNet-B block): 17 x 17 x 1088
for block_idx in range(1, 21):
x = inception_resnet_block(x,
scale=0.1,
block_type='block17',
block_idx=block_idx)
# Mixed 7a (Reduction-B block): 8 x 8 x 2080
branch_0 = conv2d_bn(x, 256, 1)
branch_0 = conv2d_bn(branch_0, 384, 3, strides=2, padding='valid')
branch_1 = conv2d_bn(x, 256, 1)
branch_1 = conv2d_bn(branch_1, 288, 3, strides=2, padding='valid')
branch_2 = conv2d_bn(x, 256, 1)
branch_2 = conv2d_bn(branch_2, 288, 3)
branch_2 = conv2d_bn(branch_2, 320, 3, strides=2, padding='valid')
branch_pool = MaxPooling2D(3, strides=2, padding='valid')(x)
branches = [branch_0, branch_1, branch_2, branch_pool]
x = Concatenate(axis=channel_axis, name='mixed_7a')(branches)
# 10x block8 (Inception-ResNet-C block): 8 x 8 x 2080
for block_idx in range(1, 10):
x = inception_resnet_block(x,
scale=0.2,
block_type='block8',
block_idx=block_idx)
x = inception_resnet_block(x,
scale=1.,
activation=None,
block_type='block8',
block_idx=10)
# Final convolution block: 8 x 8 x 1536
x = conv2d_bn(x, 1536, 1, name='conv_7b')
if include_top:
# Classification block
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='predictions')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = GlobalMaxPooling2D()(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`
if input_tensor is not None:
inputs = get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model
model = Model(inputs, x, name='inception_resnet_v2')
print("Loading Weights")
# Load weights
if weights == 'imagenet':
if K.image_data_format() == 'channels_first':
if K.backend() == 'tensorflow':
warnings.warn('You are using the TensorFlow backend, yet you '
'are using the Theano '
'image data format convention '
'(`image_data_format="channels_first"`). '
'For best performance, set '
'`image_data_format="channels_last"` in '
'your Keras config '
'at ~/.keras/keras.json.')
model.load_weights(weights_path)
print("Weights loaded successfully")
model.layers.pop()
print("Number of layers: ", len(model.layers))
for layer in model.layers:
layer.trainable = True
x = Dense(N_CLASSES, activation='softmax',
name='predictions')(model.layers[-1].output)
x.trainable = True
model = Model(inputs, x)
print("Saving Weights: ")
model.save_weights('saved_weights.h5')
return model