def nature_dqn(num_actions):
model = tf.keras.Sequential()
model.add(
layers.Conv2D(32, [8, 8],
strides=4,
input_shape=(84, 84, 4),
activation="relu"))
model.add(layers.Conv2D(64, [4, 4], strides=2, activation="relu"))
model.add(layers.Conv2D(64, [3, 3], strides=1, activation="relu"))
model.add(layers.Flatten())
model.add(layers.Dense(512, activation="relu"))
model.add(layers.Dense(num_actions))
model.compile(optimizer=tf.train.RMSPropOptimizer(0.001),
loss="mse",
metrics=["mae"])
model_target = tf.keras.Sequential()
model_target.add(
layers.Conv2D(32, [8, 8],
strides=4,
input_shape=(84, 84, 4),
activation="relu"))
model_target.add(layers.Conv2D(64, [4, 4], strides=2, activation="relu"))
model_target.add(layers.Conv2D(64, [3, 3], strides=1, activation="relu"))
model_target.add(layers.Flatten())
model_target.add(layers.Dense(512, activation="relu"))
model_target.add(layers.Dense(num_actions))
return model, model_target
def create_model(self):
input_text = Input(shape=self.max_sequence_length)
input_image = Input(shape=(self.img_height, self.img_width,
self.num_channels))
embedded_id = layers.Embedding(self.vocab_size,
self.embedding_size)(input_text)
embedded_id = layers.Flatten()(embedded_id)
embedded_id = layers.Dense(units=input_image.shape[1] *
input_image.shape[2])(embedded_id)
embedded_id = layers.Reshape(target_shape=(input_image.shape[1],
input_image.shape[2],
1))(embedded_id)
x = layers.Concatenate(axis=3)([input_image, embedded_id])
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(0.3)(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(rate=0.3)(x)
# x = layers.Conv2D(filters=64, kernel_size=(3, 3), strides=(2, 2), padding='same')(x)
# x = layers.LeakyReLU()(x)
# x = layers.Dropout(rate=0.3)(x)
#
# x = layers.Conv2D(filters=128, kernel_size=(3, 3), strides=(2, 2), padding='same')(x)
# x = layers.LeakyReLU()(x)
# x = layers.Dropout(rate=0.3)(x)
x = layers.Conv2D(filters=128,
kernel_size=(3, 3),
strides=(2, 2),
padding='same')(x)
x = layers.LeakyReLU()(x)
x = layers.Dropout(rate=0.3)(x)
x = layers.Flatten()(x)
x = layers.Dense(units=1000)(x)
x = layers.LeakyReLU()(x)
x = layers.Dense(units=1)(x)
model = Model(name='discriminator',
inputs=[input_text, input_image],
outputs=x)
return model
def make_discriminator_model():
""" Discriminator network structure.
Returns:
Sequential model.
"""
model = tf.keras.Sequential()
model.add(layers.InputLayer(input_shape=(28, 28, 1)))
model.add(
layers.Conv2D(64,
3,
strides=(2, 2),
padding='same',
activation=tf.nn.relu))
model.add(
layers.Conv2D(128,
3,
strides=(2, 2),
activation=tf.nn.relu,
padding='same'))
model.add(layers.Flatten())
model.add(layers.Dense(1, activation=tf.nn.sigmoid))
return model
def define_discriminator(in_shape=(28, 28, 1), nclasses=10):
img = layers.Input(shape=in_shape)
x = layers.Conv2D(filters=16, kernel_size=3, strides=2, padding="same")(img)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Dropout(0.25)(x)
x = layers.Conv2D(filters=32, kernel_size=3, strides=2, padding="same")(x)
x = layers.ZeroPadding2D(padding=((0, 1), (0, 1)))(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Dropout(0.25)(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.Conv2D(filters=64, kernel_size=3, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Dropout(0.25)(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.Conv2D(filters=128, kernel_size=3, strides=2, padding="same")(x)
x = layers.LeakyReLU(alpha=0.2)(x)
x = layers.Dropout(0.25)(x)
x = layers.Flatten()(x)
out = layers.Dense(1, activation="sigmoid")(x)
label = layers.Dense(nclasses+1, activation="softmax")(out)
model = tf.keras.Model(img, [out, label])
return model
def create_classifier():
with tf.name_scope("Disc"):
X = kl.Input((28, 28, 1), name="X")
layer = X
for l in range(3):
layer = kl.Conv2D(filters=64 * (2**l),
kernel_size=3,
padding="same",
use_bias=False,
activation="relu",
kernel_regularizer=kr.l2())(layer)
layer = kl.Conv2D(filters=64 * (2**l),
kernel_size=3,
padding="same",
use_bias=False,
activation="relu",
kernel_regularizer=kr.l2())(layer)
layer = kl.MaxPool2D()(layer)
layer = kl.BatchNormalization()(layer)
layer = kl.Flatten()(layer)
layer = kl.Dense(256, kernel_regularizer=kr.l2())(layer)
layer = kl.LeakyReLU()(layer)
D_out = kl.Dense(10, activation="softmax",
kernel_regularizer=kr.l2())(layer)
model = k.Model(inputs=X, outputs=D_out)
fidmodel = k.Model(inputs=X, outputs=layer)
return model, fidmodel
def ResNet50(input_tensor=None,
pooling=None,
**kwargs):
"""Instantiates the ResNet50 architecture.
# Arguments
# Returns
A Keras model instance.
"""
# Input arguments
include_top = get_varargin(kwargs, 'include_top', True)
nb_classes = get_varargin(kwargs, 'nb_classes', 1000)
default_input_shape = _obtain_input_shape(None,
default_size=224,
min_size=197,
data_format=K.image_data_format(),
require_flatten=include_top)
input_shape = get_varargin(kwargs, 'input_shape', default_input_shape)
if input_tensor is None:
img_input = KL.Input(shape=input_shape)
else:
if not K.is_keras_tensor(input_tensor):
img_input = KL.Input(tensor=input_tensor, shape=input_shape)
else:
img_input = input_tensor
bn_axis = 3 if K.image_data_format() == 'channels_last' else 1
x = KL.ZeroPadding2D((3, 3))(img_input)
x = KL.Conv2D(64, (7, 7), strides=(2, 2), name='conv1')(x)
x = KL.BatchNormalization(axis=bn_axis, name='bn_conv1')(x)
x = KL.Activation('relu')(x)
x = KL.MaxPooling2D((3, 3), strides=(2, 2))(x)
for stage, nb_block in zip([2,3,4,5], [3,4,6,3]):
for blk in range(nb_block):
conv_block = True if blk == 0 else False
strides = (2,2) if stage>2 and blk==0 else (1,1)
x = identity_block(x, stage = stage, block_id = blk + 1,
conv_block = conv_block, strides = strides)
x = KL.AveragePooling2D((7, 7), name='avg_pool')(x)
if include_top:
x = KL.Flatten()(x)
x = KL.Dense(nb_classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = KL.GlobalAveragePooling2D()(x)
elif pooling == 'max':
x = KL.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='resnet50')
return model
def get_convolutional_network(shape, use_periodic_pad=False):
inputs = Input(shape=(shape, shape, 1))
x = inputs
if use_periodic_pad:
x = layers.Lambda(periodic_pad)(x)
x = layers.Conv2D(PARAMS["conv_start_filters"], (3, 3),
activation="relu")(x)
x = layers.MaxPooling2D((2, 2))(x)
for i in range(1, PARAMS["conv_depth"]):
x_1 = layers.Conv2D(PARAMS["conv_start_filters"] +
i * PARAMS["conv_increment"], (3, 3),
activation='relu')(x)
x = layers.add([
layers.Conv2D(
PARAMS["conv_start_filters"] + i * PARAMS["conv_increment"],
(3, 3))(x), x_1
])
x = layers.MaxPooling2D((2, 2))(x)
x = layers.Flatten()(x)
x = layers.Dense(128, activation='relu')(x)
x = layers.Dropout(0.25)(x)
x = layers.Dense(1, activation='sigmoid')(x)
model = models.Model(inputs=inputs, outputs=x)
return model
def create_model():
dropout = 0.5
reg = l2(0.01)
opt = Adam(lr=LEARN_RATE)
conv_base = ResNet50(weights='imagenet',
include_top=False,
input_shape=INPUT_SHAPE)
conv_base.trainable = False
model = models.Sequential()
model.add(conv_base)
model.add(AveragePooling2D(pool_size=(2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(dropout))
model.add(
layers.Dense(512,
activation='relu',
kernel_initializer='uniform',
kernel_regularizer=reg))
model.add(layers.Dropout(dropout))
model.add(
layers.Dense(512,
activation='relu',
kernel_initializer='uniform',
kernel_regularizer=reg))
model.add(layers.Dropout(dropout))
model.add(layers.Dense(1, activation='sigmoid'))
model.compile(loss='binary_crossentropy',
optimizer=opt,
metrics=['accuracy'])
model.summary()
# tf.keras.utils.plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
return model
def make_discriminator_model():
model = tf.keras.Sequential()
model.add(layers.Conv2D(64, (5, 5), strides=(2, 2), padding='same',
use_bias=False, input_shape=(64, 64, 3), kernel_initializer=weights_initializer))
assert model.output_shape == (None, 32, 32, 64)
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(128, (5, 5), strides=(2, 2), padding='same',
use_bias=False, kernel_initializer=weights_initializer))
assert model.output_shape == (None, 16, 16, 128)
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(256, (5, 5), strides=(2, 2), padding='same',
use_bias=False, kernel_initializer=weights_initializer))
assert model.output_shape == (None, 8, 8, 256)
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(layers.Conv2D(512, (5, 5), strides=(2, 2), padding='same',
use_bias=False, kernel_initializer=weights_initializer))
assert model.output_shape == (None, 4, 4, 512)
# model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(alpha=0.2))
model.add(layers.BatchNormalization())
model.add(layers.Flatten())
model.add(layers.Dense(1, kernel_initializer=weights_initializer, activation='sigmoid'))
return model
def make_encoder_model():
""" Encoder network structure.
Returns:
tf.keras.Model.
"""
model = tf.keras.Sequential()
model.add(layers.InputLayer(input_shape=(28, 28, 1)))
model.add(
layers.Conv2D(32, (3, 3),
strides=(2, 2),
padding='same',
activation=tf.nn.relu))
model.add(
layers.Conv2D(64, (3, 3),
strides=(2, 2),
activation=tf.nn.relu,
padding='same'))
model.add(layers.Flatten())
model.add(layers.Dense(64))
return model
def fully_connected_net(args):
window_len = args[0]
input_state_shape = (10, )
pre_int_shape = (window_len, 3)
imu_input_shape = (window_len, 7, 1)
# Input layers. Don't change names
imu_in = layers.Input(imu_input_shape, name="imu_input")
state_in = layers.Input(input_state_shape, name="state_input")
_, _, dt_vec = custom_layers.PreProcessIMU()(imu_in)
x = layers.Flatten()(imu_in)
x = layers.Dense(200)(x)
x = norm_activate(x, 'relu')
x = layers.Dense(400)(x)
x = norm_activate(x, 'relu')
x = layers.Dense(400)(x)
feat_vec = norm_activate(x, 'relu')
r_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x)
rot_prior = layers.Reshape(pre_int_shape, name="pre_integrated_R")(r_flat)
x = layers.Concatenate()([feat_vec, r_flat])
v_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x)
v_prior = layers.Reshape(pre_int_shape, name="pre_integrated_v")(v_flat)
x = layers.Concatenate()([feat_vec, r_flat, v_flat])
p_flat = layers.Dense(tf.reduce_prod(pre_int_shape))(x)
p_prior = layers.Reshape(pre_int_shape, name="pre_integrated_p")(p_flat)
return Model(inputs=(imu_in, state_in),
outputs=(rot_prior, v_prior, p_prior))
def vel_cnn(window_len):
input_s = (window_len, 6, 1)
inputs = layers.Input(input_s, name="imu_input")
x = layers.Conv2D(filters=60,
kernel_size=(3, 6),
padding='same',
activation='relu',
input_shape=input_s)(inputs)
x = layers.Conv2D(filters=120,
kernel_size=(3, 6),
padding='same',
activation='relu')(x)
x = layers.Conv2D(filters=240,
kernel_size=(3, 1),
padding='valid',
activation='relu')(x)
x = layers.MaxPooling2D(pool_size=(10, 1), strides=(6, 1))(x)
x = layers.Flatten()(x)
x = layers.Dense(400, activation='relu')(x)
x = layers.Dense(100, activation='relu')(x)
x = layers.Dense(1, name="state_output")(x)
model = Model(inputs, x)
return model
def __init__(self, height, width, channels, condition_dim):
# prepare real images
discriminator_input1 = layers.Input(shape=(height, width, channels))
x1 = layers.Conv2D(64, 5, padding='same')(discriminator_input1)
x1 = layers.Activation('tanh')(x1)
x1 = layers.MaxPooling2D(pool_size=(2, 2))(x1)
x1 = layers.Conv2D(128, 5)(x1)
x1 = layers.Activation('tanh')(x1)
x1 = layers.MaxPooling2D(pool_size=(2, 2))(x1)
# condition input from generator
discriminator_input2 = layers.Input(shape=(condition_dim, ))
x2 = layers.Dense(1024)(discriminator_input2)
x2 = layers.Activation('tanh')(x2)
x2 = layers.Dense(5 * 5 * 128)(x2)
x2 = layers.BatchNormalization()(x2)
x2 = layers.Activation('tanh')(x2)
x2 = layers.Reshape((5, 5, 128))(x2)
# concatenate 2 inputs
discriminator_input = layers.concatenate([x1, x2])
x = layers.Flatten()(discriminator_input)
x = layers.Dense(1024)(x)
x = layers.Activation('tanh')(x)
x = layers.Dense(1, activation='sigmoid')(x)
self.discriminator = tf.keras.models.Model(inputs=[discriminator_input1, discriminator_input2], outputs=x)
def create_layers(self):
model = Sequential()
model.add(layers.Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=(IMAGE_SIZE, IMAGE_SIZE, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64,
kernel_size=(3, 3),
activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128,
kernel_size=(3, 3),
activation='relu'))
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(self.number_of_classes, activation='softmax'))
model.compile(loss=keras.losses.categorical_crossentropy,
optimizer='adam',
metrics=['accuracy'])
debug(model.summary())
return model
def make_model(env):
num_frames = len(env.observation_space.spaces)
height, width = env.observation_space.spaces[0].shape
input_shape = height, width, num_frames
# input state
ph_state = layers.Input(shape=input_shape)
# convolutional layers
conv1 = layers.Conv2D(32, (8, 8), strides=(4, 4))(ph_state)
conv1 = layers.Activation('relu')(conv1)
conv2 = layers.Conv2D(64, (4, 4), strides=(2, 2))(conv1)
conv2 = layers.Activation('relu')(conv2)
conv3 = layers.Conv2D(64, (3, 3), strides=(1, 1))(conv2)
conv3 = layers.Activation('relu')(conv3)
conv_flat = layers.Flatten()(conv3)
feature = layers.Dense(512)(conv_flat)
feature = layers.Activation('relu')(feature)
# actor (policy) and critic (value) streams
size_logits = size_value = env.action_space.n
logits_init = initializers.RandomNormal(stddev=1e-3)
logits = layers.Dense(size_logits, kernel_initializer=logits_init)(feature)
value = layers.Dense(size_value)(feature)
return models.Model(inputs=ph_state, outputs=[logits, value])
def make_model(env):
num_frames = len(env.observation_space.spaces)
height, width = env.observation_space.spaces[0].shape
input_shape = height, width, num_frames
# input state
ph_state = layers.Input(shape=input_shape)
# convolutional layers
conv1 = layers.Conv2D(32, (8, 8), strides=(4, 4))(ph_state)
conv1 = layers.Activation('relu')(conv1)
conv2 = layers.Conv2D(64, (4, 4), strides=(2, 2))(conv1)
conv2 = layers.Activation('relu')(conv2)
conv3 = layers.Conv2D(64, (3, 3), strides=(1, 1))(conv2)
conv3 = layers.Activation('relu')(conv3)
conv_flat = layers.Flatten()(conv3)
feature = layers.Dense(512)(conv_flat)
feature = layers.Activation('relu')(feature)
# actor (policy) and critic (value) streams
size_value = env.action_space.n
value = NoisyDenseFG(size_value)(feature)
value = layers.Activation('linear')(value)
return models.Model(inputs=ph_state, outputs=value)
def lenet(network_input: NetworkInput) -> KerasModel:
model = Sequential()
input_shape = network_input.input_shape
if len(network_input.input_shape) < 3:
model.add(
layers.Lambda(lambda x: tf.expand_dims(x, -1),
input_shape=input_shape))
input_shape = (input_shape[0], input_shape[1], 1)
if network_input.mean is not None and network_input.std is not None:
model.add(
layers.Lambda(
lambda x: norm(x, network_input.mean, network_input.std),
input_shape=input_shape))
model.add(
layers.Conv2D(32,
kernel_size=(3, 3),
input_shape=input_shape,
activation='relu'))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D(pool_size=(2, 2)))
model.add(layers.Dropout(0.2))
model.add(layers.Flatten())
model.add(layers.Dense(128, activation='relu'))
model.add(layers.Dropout(0.2))
model.add(
layers.Dense(network_input.number_of_classes, activation='softmax'))
return model
def TrongNet(input_shape, num_classes, pretrained_weights=None):
input_image = layers.Input(shape=input_shape, name='input_1')
x = layers.Conv2D(filters=16,
kernel_size=(3, 3),
activation=activations.relu)(input_image)
x = layers.MaxPool2D(pool_size=(2, 2))(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
activation=activations.relu)(x)
x = layers.MaxPool2D(pool_size=(2, 2))(x)
x = layers.Conv2D(filters=64,
kernel_size=(3, 3),
activation=activations.relu)(x)
x = layers.MaxPool2D(pool_size=(2, 2))(x)
x = layers.Conv2D(filters=128,
kernel_size=(3, 3),
activation=activations.relu)(x)
x = layers.MaxPool2D(pool_size=(2, 2))(x)
x = layers.BatchNormalization()(x)
x = layers.Flatten()(x)
x = layers.Dense(units=256, activation=activations.relu)(x)
x = layers.Dropout(0.3)(x)
x = layers.Dense(units=64, activation=activations.relu)(x)
x = layers.Dense(units=num_classes,
activation=activations.softmax,
name='predictions')(x)
model = models.Model(input_image, x, name='trongnet')
if pretrained_weights:
model.load_weights(pretrained_weights)
return model
def discriminator(input_shape=(28, 28, 1)):
model = tf.keras.Sequential()
model.add(
layers.Conv2D(16, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02),
input_shape=input_shape))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(0.2))
model.add(
layers.Conv2D(32, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(0.2))
model.add(
layers.Conv2D(64, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)))
model.add(layers.BatchNormalization())
model.add(layers.LeakyReLU(0.2))
model.add(
layers.Conv2D(128, (5, 5),
strides=(2, 2),
padding='same',
kernel_initializer=tf.keras.initializers.TruncatedNormal(stddev=0.02)))
model.add(layers.LeakyReLU(0.2))
model.add(layers.Flatten())
model.add(layers.Dense(1, activation="sigmoid"))
return model
def LeNet5(input_shape, num_classes, pretrained_weights=None):
input_image = layers.Input(shape=input_shape, name='input_1')
x = layers.Conv2D(filters=6,
kernel_size=(3, 3),
activation=activations.relu)(input_image)
x = layers.AveragePooling2D(pool_size=(2, 2))(x)
x = layers.Conv2D(filters=16,
kernel_size=(3, 3),
activation=activations.relu)(x)
x = layers.AveragePooling2D(pool_size=(2, 2))(x)
x = layers.Conv2D(filters=16,
kernel_size=(3, 3),
activation=activations.relu)(x)
x = layers.AveragePooling2D(pool_size=(2, 2))(x)
x = layers.Flatten()(x)
x = layers.Dense(units=120, activation=activations.relu)(x)
x = layers.Dropout(0.5)(x)
x = layers.Dense(units=84, activation=activations.relu)(x)
x = layers.Dense(units=num_classes,
activation=activations.softmax,
name='predictions')(x)
model = models.Model(input_image, x, name='lenet5')
if pretrained_weights:
model.load_weights(pretrained_weights)
return model
def flatten(x, reshape=False):
"""
Flattens the input to two dimensional.
Parameters:
----------
x : keras.backend tensor/variable/symbol
Input tensor/variable/symbol.
reshape : bool, default False
Whether do reshape instead of flatten.
Returns
-------
keras.backend tensor/variable/symbol
Resulted tensor/variable/symbol.
"""
if not is_channels_first():
def channels_last_flatten(z):
z = K.permute_dimensions(z, pattern=(0, 3, 1, 2))
z = K.reshape(z, shape=(-1, np.prod(K.int_shape(z)[1:])))
updateshape(z)
return z
return nn.Lambda(channels_last_flatten)(x)
else:
if reshape:
x = nn.Reshape((-1, ))(x)
else:
x = nn.Flatten()(x)
return x
def build_cnn_model():
#Instantiate a Keras tensor
sequences= layers.Input(shape = (max_length, ))
#Turns positive integers (indexes) into dense vectors of fixed size
embedded = layers.Embedding(12000, 64) (sequences)
#Convolution kernel is convoled with the layer to produce a tensor of outputs
#(output_space, kernel_size, linear_unit_activation_function)
x = layers.Conv1D(64, 3, activation='relu') (embedded)
#Normalize and scale inputs or activations
x = layers.BatchNormalization() (x)
#Downsamples the input representation by taking the maximum value over the window
x = layers.MaxPool1D(3) (x)
x = layers.Conv1D(64, 5, activation='relu') (x)
x = layers.BatchNormalization() (x)
x = layers.MaxPool1D(5) (x)
x = layers.Conv1D(64, 5, activation='relu') (x)
#Downsamples the input representation by taking the maximum value over the time dimension
x = layers.GlobalMaxPool1D() (x)
x = layers.Flatten() (x)
#First parameter represents the dimension of the output space
x = layers.Dense(100, activation='relu') (x)
#Sigmoid function: values <-5 => value close to 0; values >5 => values close to 1
predictions = layers.Dense(1, activation='sigmoid') (x)
model = models.Model(inputs = sequences, outputs = predictions)
model.compile(
optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['binary_accuracy']
)
return model
def my_model():
# prep layers
inp = layers.Input(shape=(32, 32, 3))
x = layers.Conv2D(64, 3, padding='same')(inp)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer1
x = layers.Conv2D(128, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 128)])
# layer2
x = layers.Conv2D(256, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
# layer3
x = layers.Conv2D(512, 3, padding='same')(x)
x = layers.MaxPool2D()(x)
x = layers.BatchNormalization(momentum=0.8)(x)
x = layers.LeakyReLU(alpha=0.1)(x)
x = layers.Add()([x, residual(x, 512)])
# layers4
x = layers.GlobalMaxPool2D()(x)
x = layers.Flatten()(x)
x = layers.Dense(10)(x)
x = layers.Activation('softmax', dtype='float32')(x)
model = tf.keras.Model(inputs=inp, outputs=x)
return model
def create_classifier():
print("Building model")
inp = kl.Input((32, 32, 3))
layer = kl.Conv2D(64, (3, 3), padding='same')(inp)
layer = kl.Activation('relu')(layer)
layer = kl.Conv2D(64, (3, 3))(layer)
layer = kl.Activation('relu')(layer)
layer = kl.MaxPooling2D(pool_size=(2, 2))(layer)
layer = kl.Dropout(0.25)(layer)
layer = kl.Conv2D(128, (3, 3), padding='same')(layer)
layer = kl.Activation('relu')(layer)
layer = kl.Conv2D(128, (3, 3))(layer)
layer = kl.Activation('relu')(layer)
layer = kl.MaxPooling2D(pool_size=(2, 2))(layer)
layer = kl.Dropout(0.25)(layer)
layer = kl.Flatten()(layer)
layer = kl.Dense(512)(layer)
layer = kl.Activation('relu')(layer)
fidmodel = k.Model(inp, layer)
layer = kl.Dropout(0.5)(layer)
layer = kl.Dense(47)(layer)
layer = kl.Activation('softmax')(layer)
model = k.models.Model(inp, layer)
return model, fidmodel
def discriminator():
"""
Purpose of the Discriminator model is to learn to tell real images
apart from fakes. During training, the Discriminator progressively
becomes better at telling fake images from real ones. The process
reaches equilibrium when the Discriminator can no longer distinguish
real images from fakes.
The Discriminator is a simple CNN-based image classifier. It outputs
positive values for real images, and negative values for fake images.
:return: The Discriminator model.
"""
model = keras.Sequential([
layers.Conv2D(filters=64, kernel_size=(5, 5), strides=(2, 2), padding='same', input_shape=[28, 28, 1]),
layers.LeakyReLU(),
layers.Dropout(rate=0.3),
layers.Conv2D(filters=128, kernel_size=(5, 5), strides=(2, 2), padding='same'),
layers.LeakyReLU(),
layers.Dropout(rate=0.3),
layers.Flatten(),
layers.Dense(units=1),
])
return model
def cnn_mnist(input_shape=(28, 28, 1), nb_classes=10):
"""
Defines a CNN model using Keras sequential model
:param input_shape:
:param nb_classes:
:return:
"""
MODEL.set_architecture('cnn')
img_rows, img_cols, nb_channels = input_shape
# Define the layers successively (convolution layers are version dependent)
if tf.keras.backend.image_data_format() == 'channels_first':
input_shape = (nb_channels, img_rows, img_cols)
struct = [
layers.Conv2D(filters=32, kernel_size=(3, 3), input_shape=input_shape),
layers.Activation('relu'),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(filters=64, kernel_size=(3, 3)),
layers.Activation('relu'),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dense(64 * 64),
layers.Dropout(rate=0.4),
layers.Dense(nb_classes),
layers.Activation('softmax')
]
# construct the cnn model
model = models.Sequential()
for layer in struct:
model.add(layer)
if MODE.DEBUG:
print(model.summary())
return model
def discriminator():
"""
Purpose of the Discriminator model is to learn to tell real images
apart from fakes. During training, the Discriminator progressively
becomes better at telling fake images from real ones. The process
reaches equilibrium when the Discriminator can no longer distinguish
real images from fakes.
The Discriminator is a simple CNN-based image classifier. It outputs
positive values for real images, and negative values for fake images.
Returns:
The Discriminator model.
"""
start = time.time()
model = keras.Sequential([
layers.Conv2D(filters=64, kernel_size=(5, 5), strides=(2, 2), padding='same',
input_shape=[IMG_SHAPE[0], IMG_SHAPE[1], N_CHANNELS]),
layers.LeakyReLU(),
layers.Dropout(rate=0.3),
layers.Conv2D(filters=128, kernel_size=(5, 5), strides=(2, 2), padding='same'),
layers.LeakyReLU(),
layers.Dropout(rate=0.3),
layers.Flatten(),
layers.Dense(units=1),
])
end = time.time()
if DEBUG_LOG:
print("Execution time: {:.9f}s (discriminator)".format(end - start))
return model
def __init__(self):
super(Network, self).__init__()
self.mylayers = [
# unit1
layers.Conv2D(filters=32,
kernel_size=[5, 5],
padding='same',
activation=nn.relu),
layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'),
# unit2
layers.Conv2D(filters=64,
kernel_size=[5, 5],
padding='same',
activation=nn.relu),
layers.MaxPool2D(pool_size=[2, 2], strides=2, padding='same'),
# flatten the tensor
layers.Flatten(),
# 2 full-connected layers
layers.Dense(512, activation=nn.relu),
layers.Dense(10, activation=nn.softmax)
# layers.Dense(10, activation=None)
]
# 根据tensorflow的版本确定网络的最后一层要不要加activation=nn.softmax
# 如果tf版本低于1.13:
# 则需要添加,
# 训练时在model.compile中设置loss=keras.losses.categorical_crossentropy
# 如果tf版本等于或者高于1.13:
# 则不需要添加,
# 训练时在model.compile中设置loss=keras.losses.CategoricalCrossentropy(from_logits=True)
self.net = Sequential(self.mylayers)
def __init__(self, action_size, ip_shape=(84, 84, 3)):
super(CNN, self).__init__()
self.action_size = action_size
self.ip_shape = ip_shape
self.conv1 = layers.Conv2D(filters=16,
kernel_size=(8, 8),
strides=(4, 4),
activation=tf.keras.activations.relu,
data_format='channels_last',
input_shape=self.ip_shape
)
self.conv2 = layers.Conv2D(filters=32,
kernel_size=(4, 4),
strides=(2, 2),
activation=tf.keras.activations.relu,
data_format='channels_last'
)
# reshape
self.flatten = layers.Flatten()
self.fc1 = layers.Dense(units=256,
activation=tf.keras.activations.relu
)
# policy output layer (Actor)
self.policy_logits = layers.Dense(units=self.action_size, activation=tf.nn.softmax, name='policy_logits')
# value output layer (Critic)
self.values = layers.Dense(units=1, name='value')
def create_model(input_shape=(28, 28, 1), nb_classes=10):
MODEL.set_architecture('cnn')
# define model architecture
struct = [
layers.Conv2D(filters=32, kernel_size=(3, 3), input_shape=input_shape),
layers.Activation('relu'),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Conv2D(filters=64, kernel_size=(3, 3)),
layers.Activation('relu'),
layers.MaxPooling2D(pool_size=(2, 2)),
layers.Flatten(),
layers.Dense(64 * 64),
layers.Dropout(rate=0.4),
layers.Dense(nb_classes),
layers.Activation('softmax'),
]
# construct the model
model = models.Sequential()
for layer in struct:
model.add(layer)
logger.info(model.summary())
return model
