def compute_feature_extractor(feature, shape):
if feature == 'appearance':
# This should not stay: channels_first/last should be used to
# dictate size (1 works for either right now)
N_layers = np.int(np.floor(np.log2(input_shape[1])))
feature_extractor = Sequential()
feature_extractor.add(InputLayer(input_shape=shape))
# feature_extractor.add(ImageNormalization2D('std', filter_size=32))
for layer in range(N_layers):
feature_extractor.add(
Conv3D(64, (1, 3, 3),
kernel_initializer=init,
padding='same',
kernel_regularizer=l2(reg)))
feature_extractor.add(BatchNormalization(axis=channel_axis))
feature_extractor.add(Activation('relu'))
feature_extractor.add(MaxPool3D(pool_size=(1, 2, 2)))
feature_extractor.add(Reshape((-1, 64)))
return feature_extractor
elif feature == 'distance':
return None
elif feature == 'neighborhood':
N_layers_og = np.int(
np.floor(np.log2(2 * neighborhood_scale_size + 1)))
feature_extractor_neighborhood = Sequential()
feature_extractor_neighborhood.add(
InputLayer(input_shape=(None, 2 * neighborhood_scale_size + 1,
2 * neighborhood_scale_size + 1, 1)))
for layer in range(N_layers_og):
feature_extractor_neighborhood.add(
Conv3D(64, (1, 3, 3),
kernel_initializer=init,
padding='same',
kernel_regularizer=l2(reg)))
feature_extractor_neighborhood.add(
BatchNormalization(axis=channel_axis))
feature_extractor_neighborhood.add(Activation('relu'))
feature_extractor_neighborhood.add(
MaxPool3D(pool_size=(1, 2, 2)))
feature_extractor_neighborhood.add(Reshape((-1, 64)))
return feature_extractor_neighborhood
elif feature == 'regionprop':
return None
else:
raise ValueError('siamese_model.compute_feature_extractor: '
'Unknown feature `{}`'.format(feature))
def __init__(self,
name=None,
units=1,
tensor=None,
dtype=None):
if not dtype:
dtype = K.floatx()
elif not dtype == K.floatx():
K.set_floatx(dtype)
if units < 1:
raise ValueError(
'Expected at least one unit size - was provided `units`={:d}'.format(units)
)
layer = InputLayer(
batch_input_shape=(None, units),
input_tensor=tensor,
name=name,
dtype=dtype
)
super(RadialBasisBase, self).__init__(
layers=to_list(layer),
inputs=to_list(layer.input),
outputs=to_list(layer.output),
)
def keras_sequential_model():
model = Sequential()
model.add(InputLayer(input_shape=(img_size_flat, )))
model.add(Reshape(img_shape_full))
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation='relu',
name='layer_conv1'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=36,
padding='same',
activation='relu',
name='layer_conv2'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
optimizer = Adam(lr=1e-4)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def __init__(self,
units,
name=None,
tensor=None,
dtype=None):
if not dtype:
dtype = floatx()
elif not dtype == floatx():
set_floatx(dtype)
assert isinstance(units, int) and units>=2, \
'RNN needs a minimum of 2 time units. '
layer = InputLayer(
batch_input_shape=(None, units, 1),
input_tensor=tensor,
name=name,
dtype=dtype
)
super(RNNVariable, self).__init__(
layers=to_list(layer),
inputs=to_list(layer.input),
outputs=to_list(layer.output),
)
def make_model(meta):
'create model based on meta definition'
model = Sequential()
model.add(InputLayer(input_shape=(width, height, 1)))
model.add(Conv2D(1, ))
for l in range(meta[0]):
print("LSTM({})".format(meta[1 + l * 2]))
model.add(LSTM(meta[1 + l * 2]))
if meta[2 + l * 2] > 0:
print("DROPOUT(0.75)")
model.add(Dropout(0.75))
print("Dense({})".format(meta[-1]))
model.add(Dense(meta[-1], activation='relu'))
model.add(Dropout(0.75))
model.add(Dense(2, activation='softmax'))
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
#randomize weights
weights = model.get_weights()
weights = [np.random.normal(size=w.shape) for w in weights]
model.set_weights(weights)
return model
def create_model(learning_rate, num_dense_layers, num_dense_nodes):
'''This function takes in values for learning rate, number of layers and number of nodes in each layer, and creates,compiles and returns a Keras model
with those hyperparameters
Parameters
-------
learning_rate: float32
The learning rate for the optimization technique for the neural network
num_dense_layers: int32
The number of hidden layers to be implemented in the neural network
num_dense_nodes: int32
The number of hidden units per layer of the neural network
Returns
-------
model: Keras model'''
model = Sequential()
model.add(InputLayer(input_shape=(np.shape(train_data)[0], )))
for i in range(num_dense_layers):
model.add(Dense(num_dense_nodes, activation='selu'))
model.add(Dense(np.shape(train_data)[0], activation='linear'))
optimizer = RMSprop(lr=learning_rate)
model.compile(optimizer=optimizer, loss='mmse', metrics=['accuracy'])
return model
def __init__(self, raanan_architecture=False, sigmoid_activation=True):
super(Decoder, self).__init__()
self.input_layer = InputLayer()
self.fully_connected3 = Dense(512)
self.fully_connected4 = Dense(7 * 7 * 64)
self.reshape = Reshape((7, 7, 64))
self.conv_transpose1 = Conv2DTranspose(32,
3,
padding="same",
strides=2)
self.conv_transpose2 = Conv2DTranspose(1, 3, padding="same", strides=2)
self.relu1 = ReLU()
self.relu2 = ReLU()
self.relu3 = ReLU()
self.last_activation = sigmoid if sigmoid_activation else tanh
if raanan_architecture:
self.relu1 = LeakyReLU()
self.relu2 = LeakyReLU()
self.relu3 = LeakyReLU()
print("Decoder network created with raanan architecture={}".format(
raanan_architecture))
def best_model():
epochs = [5, 10, 15, 20]
dropout_rate = [0.1, 0.2, 0.3]
list_of_all_scores = list()
list_of_scores = list()
list_of_dropout = list()
list_of_all_dropouts = list()
list_of_epochs = list()
for i in dropout_rate:
model = Sequential()
model.add(InputLayer(input_shape=(MAX_LENGTH, )))
model.add(Embedding(length_word_index, 128))
model.add(LSTM(256, return_sequences=True))
model.add(Dropout(i))
model.add(TimeDistributed(Dense(length_tag_index)))
model.add(Activation('softmax'))
model.compile(loss='categorical_crossentropy',
optimizer=Adam(0.001),
metrics=['acc'])
# metrics=['accuracy', ignore_class_accuracy(0)])
# model.summary()
list_of_dropout.append(i)
# One hot encode the tags
def onehot_encode_tags(sequences, categories):
cat_sequences = []
for seq in sequences:
cats = []
for item in seq:
cats.append(np.zeros(categories))
cats[-1][item] = 1.0
cat_sequences.append(cats)
return np.array(cat_sequences)
cat_train_tags_y = onehot_encode_tags(y_train, length_tag_index)
for e in epochs:
list_of_all_dropouts.append(i)
list_of_epochs.append(e)
model.fit(X_train, onehot_encode_tags(y_train, length_tag_index), batch_size=128, epochs=e, validation_split=0.2)
score = model.evaluate(X_test, onehot_encode_tags(y_test, length_tag_index))
list_of_all_scores.append(score)
if score not in list_of_scores:
list_of_scores.append(score)
#print('Dropout:', i, '\n', 'Epoch:', e, '\n', 'Score:', float(score))
lowest = min(list_of_all_scores)
num = list_of_scores.index(lowest)
epoch = list_of_epochs[num]
dropout = list_of_all_dropouts[num]
print('Lowest score:', lowest, 'Epoch:', epoch, 'Dropout', dropout)
return epoch, dropout
def create_model(input_width, input_height):
m = tf.keras.models.Sequential()
m.add(InputLayer(input_shape=(input_width, input_height, 6)))
m.add(Conv2D(filters=32, kernel_size=(4, 4), activation='relu'))
m.add(GaussianNoise(0.01))
m.add(MaxPool2D(pool_size=(2, 2)))
m.add(Conv2D(filters=48, kernel_size=(4, 4), activation='relu'))
m.add(GaussianNoise(0.01))
m.add(MaxPool2D(pool_size=(2, 2)))
m.add(Conv2D(filters=64, kernel_size=(4, 4), activation='relu'))
m.add(GaussianNoise(0.01))
m.add(MaxPool2D(pool_size=(2, 2)))
m.add(Conv2D(filters=64, kernel_size=(4, 4), activation='relu'))
m.add(GaussianNoise(0.01))
m.add(MaxPool2D(pool_size=(2, 2)))
m.add(Conv2D(filters=64, kernel_size=(4, 4), activation='relu'))
m.add(GaussianNoise(0.01))
m.add(MaxPool2D(pool_size=(2, 2)))
m.add(Conv2D(filters=64, kernel_size=(4, 4), activation='relu'))
m.add(GaussianNoise(0.01))
m.add(MaxPool2D(pool_size=(2, 2)))
m.add(Flatten())
m.add(Dense(128, activation='relu'))
m.add(Dropout(0.1))
m.add(Dense(2, activation='softmax'))
m.compile(optimizer='adam', loss='categorical_crossentropy')
return m
def _cnn_maxpool(self, name: str) -> Model:
"""https://richliao.github.io/supervised/classification/2016/11/26/textclassifier-convolutional/
"""
return Sequential([
InputLayer(input_shape=(self.maxlen, ), name='input'),
Embedding(input_dim=self.input_dim,
output_dim=self.embed_dim,
input_length=self.maxlen,
name='embedding'),
Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu'),
MaxPool1D(pool_size=self.conv_pool_size),
Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu'),
MaxPool1D(pool_size=self.conv_pool_size),
Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
activation='relu'),
GlobalMaxPool1D(),
Flatten(),
Dense(self.units, activation='relu'),
Dense(self.classes, activation='sigmoid', name='fc1'),
],
name=name)
def svhn_model2(n_classes: int, input_shape=None, input_tensor=None,
weights_path: Union[None, str] = None) -> Sequential:
"""
Defines a svhn network.
:param n_classes: the number of classes.
We use this parameter even though we know its value,
in order to be able to use the model in order to predict some of the classes.
:param input_shape: the input shape of the network. Can be omitted if input_tensor is used.
:param input_tensor: the input tensor of the network. Can be omitted if input_shape is used.
:param weights_path: a path to a trained custom network's weights.
:return: Keras Sequential Model.
"""
if input_shape is None and input_tensor is None:
raise ValueError('You need to specify input shape or input tensor for the network.')
# Create a Sequential model.
model = Sequential(name='svhn_model2')
if input_shape is None:
# Create an InputLayer using the input tensor.
model.add(InputLayer(input_tensor=input_tensor))
# Block1
if input_tensor is None:
first_conv = Conv2D(32, (3, 3), padding='same', activation='elu', name='block1_conv1', input_shape=input_shape)
else:
first_conv = Conv2D(32, (3, 3), padding='same', activation='elu', name='block1_conv1')
model.add(first_conv)
model.add(BatchNormalization(name='block1_batch-norm1'))
model.add(Conv2D(32, (3, 3), padding='same', activation='elu', name='block1_conv2'))
model.add(BatchNormalization(name='block1_batch-norm2'))
model.add(MaxPooling2D(pool_size=(2, 2), name='block1_pool'))
model.add(Dropout(0.2, name='block1_dropout', seed=0))
# Block2
model.add(Conv2D(64, (3, 3), padding='same', activation='elu', name='block2_conv1'))
model.add(BatchNormalization(name='block2_batch-norm1'))
model.add(Conv2D(64, (3, 3), padding='same', activation='elu', name='block2_conv2'))
model.add(BatchNormalization(name='block2_batch-norm2'))
model.add(MaxPooling2D(pool_size=(2, 2), name='block2_pool'))
model.add(Dropout(0.4, name='block2_dropout', seed=0))
# Block3
model.add(Conv2D(256, (3, 3), padding='same', activation='elu', name='block3_conv1'))
model.add(BatchNormalization(name='block3_batch-norm1'))
model.add(MaxPooling2D(pool_size=(2, 2), name='block3_pool'))
model.add(Dropout(0.6, name='block3_dropout', seed=0))
# Add top layers.
model.add(Flatten())
model.add(Dense(n_classes, activation='softmax'))
# Load weights, if they exist.
load_weights(weights_path, model)
return model
def _lstm_simple(self, name: str) -> Model:
return Sequential([
InputLayer(input_shape=(self.maxlen, ), name='input'),
Embedding(input_dim=self.input_dim,
output_dim=self.embed_dim,
input_length=self.maxlen,
name='embedding'),
LSTM(units=self.units, name='lstm'),
Dense(self.classes, activation='sigmoid', name='fc1'),
],
name=name)
def init_model():
model = Sequential()
model.add(InputLayer(input_shape=(28, 28, 1)))
model.add(Conv2D(filters=6, kernel_size=5, activation='relu'))
# model.add(Conv2D(filters=16, kernel_size=6, activation='relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Flatten())
model.add(Dense(300, activation='relu'))
model.add(Dense(10, activation='softmax'))
print(model.summary())
return model
def build_cnn_model(img_size, num_classes):
#img_size = 48
img_size_flat = img_size * img_size
img_shape = (img_size, img_size, 1)
#num_channels = 1
#num_classes = 8
# Start construction of the Keras.
model = Sequential()
model.add(InputLayer(input_shape=(img_size_flat,)))
#model.add(input_shape=(img_size_flat,))
model.add(Reshape(img_shape))
#model.add(Dropout(0.5, input_shape=(48, 48, 1)))
model.add(Conv2D(kernel_size=5, strides=1, filters=32, padding='same',
activation='relu'))
model.add(Conv2D(kernel_size=5, strides=1, filters=32, padding='same',
activation='relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Conv2D(kernel_size=10, strides=1, filters=64, padding='same',
activation='relu'))
model.add(Conv2D(kernel_size=10, strides=1, filters=64, padding='same',
activation='relu'))
model.add(Conv2D(kernel_size=10, strides=1, filters=64, padding='same',
activation='relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Conv2D(kernel_size=15, strides=1, filters=128, padding='same',
activation='relu'))
model.add(Conv2D(kernel_size=15, strides=1, filters=128, padding='same',
activation='relu'))
model.add(Conv2D(kernel_size=15, strides=1, filters=128, padding='same',
activation='relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Conv2D(kernel_size=20, strides=1, filters=256, padding='same',
activation='relu'))
model.add(Conv2D(kernel_size=20, strides=1, filters=256, padding='same',
activation='relu'))
model.add(Conv2D(kernel_size=20, strides=1, filters=256, padding='same',
activation='relu'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Flatten())
model.add(Dense(256, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(64, activation='relu'))
# Last fully-connected / dense layer with softmax-activation
# for use in classification.
model.add(Dense(num_classes, activation='softmax'))
return model
def _bilstm_dropout(self, name: str) -> Model:
return Sequential([
InputLayer(input_shape=(self.maxlen, ), name='input'),
Embedding(input_dim=self.input_dim,
output_dim=self.embed_dim,
input_length=self.maxlen,
name='embedding'),
Dropout(0.2, name='input_dropout'),
Bidirectional(LSTM(units=self.units, name='bilstm')),
Dropout(0.5, name='hidden_dropout'),
Dense(self.classes, activation='sigmoid', name='fc1'),
],
name=name)
def __init__(self,
original_dim,
intermediate_dim=64,
name="image",
**kwargs):
super(OSIC_Image, self).__init__(name=name, **kwargs)
self.layers = []
self.layers.append(InputLayer(input_shape=original_dim))
self.layers.append(
Conv3D(filters=8,
kernel_size=5,
strides=3,
padding="same",
kernel_initializer=GlorotUniform(seed=0),
input_shape=original_dim))
self.layers.append(LayerNormalization())
self.layers.append(Activation('elu'))
self.layers.append(
Conv3D(filters=16,
kernel_size=2,
strides=2,
padding="same",
kernel_initializer=GlorotUniform(seed=0)))
self.layers.append(LayerNormalization())
self.layers.append(Activation('elu'))
self.layers.append(
Conv3D(filters=32,
kernel_size=2,
strides=1,
padding="same",
kernel_initializer=GlorotUniform(seed=0)))
self.layers.append(LayerNormalization())
self.layers.append(Activation('elu'))
self.layers.append(
Conv3D(filters=64,
kernel_size=2,
strides=1,
padding="same",
kernel_initializer=GlorotUniform(seed=0)))
self.layers.append(LayerNormalization())
self.layers.append(Activation('elu'))
# self.layers.append(Conv3DTranspose(32, 2, 1))
# self.layers.append(LayerNormalization())
# self.layers.append(Activation('elu'))
# self.layers.append(Conv3DTranspose(16, 2, 1))
# self.layers.append(LayerNormalization())
#self.layers.append(Conv3D(filters=1,kernel_size=5,strides=4,kernel_initializer=GlorotUniform(seed=0)))
# self.layers.append(Conv3D(filters=2,kernel_size=1,activation="softmax", kernel_initializer=GlorotUniform(seed=0)))
self.layers.append(Dense(64))
self.layers.append(LayerNormalization())
def init_lenet5():
model = Sequential()
model.add(InputLayer(input_shape=(28, 28, 1)))
model.add(Conv2D(filters=6, kernel_size=3, activation='relu', padding='same'))
# model.add(Dropout(rate=0.8))
model.add(AveragePooling2D())
model.add(Conv2D(filters=16, kernel_size=3, activation='relu'))
# model.add(Dropout(rate=0.8))
model.add(AveragePooling2D())
model.add(Flatten())
model.add(Dense(120, activation='relu'))
model.add(Dense(84, activation='relu'))
model.add(Dense(10, activation='softmax'))
print(model.summary())
return model
def __init__(self, state_size, action_size):
super().__init__()
self.state_input = InputLayer((state_size, ))
self.action_batch_1 = BatchNormalization()
self.action_dense_1 = Dense(units=50, activation='elu')
self.action_batch_2 = BatchNormalization()
self.action_dense_2 = Dense(units=10, activation='elu')
self.value_batch_1 = BatchNormalization()
self.value_dense_1 = Dense(units=50, activation='elu')
self.value_batch_2 = BatchNormalization()
self.value_dense_2 = Dense(units=10, activation='elu')
self.action_out = Dense(units=action_size, activation='linear')
self.value_out = Dense(units=1)
self.opt_actor = tf.keras.optimizers.Adam(lr=1e-4)
self.opt_critic = tf.keras.optimizers.Adam(lr=3e-4)
def __init__(self, latent_dim=6):
super().__init__()
self.latent_dim = latent_dim
self.encoder_conv = tf.keras.Sequential([
# shape: [batch_size, 56, 56, 1]
InputLayer(input_shape=(56, 56, 1)),
# shape: [batch_size, 28, 28, 64 ]
Conv2D(filters=64,
kernel_size=4,
strides=2,
padding="same",
activation='relu'),
# shape: [batch_size, 14, 14, 64]
Conv2D(filters=64,
kernel_size=4,
strides=2,
padding="same",
activation='relu'),
# shape: [batch_size, 7, 7, 64]
Conv2D(filters=64,
kernel_size=4,
strides=2,
padding="same",
activation='relu'),
# shape: [batch_size, 4, 4, 64]
Conv2D(filters=64,
kernel_size=4,
strides=2,
padding="same",
activation='relu'),
# shape: [batch_size, 1024]
Flatten(),
# shape: [batch_size, 256]
Dense(256),
ReLU()
])
# shape: [batch_size, self.latent_dim]
self.fc_mu = tf.keras.Sequential(Dense(self.latent_dim), )
self.fc_log_var = tf.keras.Sequential(Dense(self.latent_dim), )
def keras_model_fn(hyperparameters):
"""keras_model_fn receives hyperparameters from the training job and returns a compiled keras model.
The model will be transformed into a TensorFlow Estimator before training and it will be saved in a
TensorFlow Serving SavedModel at the end of training.
Args:
hyperparameters: The hyperparameters passed to the SageMaker TrainingJob that runs your TensorFlow
training script.
Returns: A compiled Keras model
"""
model = Sequential()
# TensorFlow Serving default prediction input tensor name is PREDICT_INPUTS.
# We must conform to this naming scheme.
model.add(
InputLayer(input_shape=(HEIGHT, WIDTH, DEPTH), name=PREDICT_INPUTS))
model.add(Conv2D(32, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Conv2D(64, (3, 3), padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64, (3, 3)))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(NUM_CLASSES))
model.add(Activation('softmax'))
_model = tf.keras.Model(inputs=model.input, outputs=model.output)
opt = RMSprop(lr=hyperparameters['learning_rate'],
decay=hyperparameters['decay'])
_model.compile(loss='categorical_crossentropy',
optimizer=opt,
metrics=['accuracy'])
return _model
def __init__(self, name=None, units=1, tensor=None, dtype=None):
if not dtype:
dtype = floatx()
elif not dtype == floatx():
set_floatx(dtype)
layer = InputLayer(batch_input_shape=(None, units),
input_tensor=tensor,
name=name,
dtype=dtype)
super(Variable, self).__init__(
layers=to_list(layer),
inputs=to_list(layer.input),
outputs=to_list(layer.output),
)
def __init__(self):
super(Generator, self).__init__()
self.input_layer = InputLayer(dtype=tf.float32)
self.fully_connected1 = Dense(1024, dtype=tf.float32)
self.bn1 = BatchNormalization(dtype=tf.float32)
self.relu1 = ReLU(dtype=tf.float32)
self.fully_connected2 = Dense(7 * 7 * 128, dtype=tf.float32)
self.bn2 = BatchNormalization(dtype=tf.float32)
self.relu2 = ReLU(dtype=tf.float32)
self.reshape = Reshape((7, 7, 128), dtype=tf.float32)
self.conv_transpose1 = Conv2DTranspose(64,
4,
padding="same",
strides=2,
dtype=tf.float32)
self.bn3 = BatchNormalization(dtype=tf.float32)
self.relu3 = ReLU(dtype=tf.float32)
self.conv_transpose2 = Conv2DTranspose(1,
4,
padding="same",
strides=2,
activation='tanh',
dtype=tf.float32)
# self.relu4 = ReLU(dtype=tf.float32)
# self.input_layer = InputLayer(dtype=tf.float32)
# self.fully_connected1 = Dense(7 * 7 * 256, use_bias=False)
# self.bn1 = BatchNormalization()
# self.relu1 = LeakyReLU()
#
# self.reshape = Reshape((7, 7, 256))
#
# self.conv_transpose1 = Conv2DTranspose(128, (5, 5), strides=(1, 1), padding='same', use_bias=False)
# self.bn3 = BatchNormalization()
# self.relu3 = LeakyReLU()
#
# self.conv_transpose2 = Conv2DTranspose(64, (5, 5), strides=(2, 2), padding='same', use_bias=False)
# self.bn4 = BatchNormalization()
# self.relu4 = layers.LeakyReLU()
#
# model.add(layers.Conv2DTranspose(1, (5, 5), strides=(2, 2), padding='same', use_bias=False, activation='tanh'))
# assert model.output_shape == (None, 28, 28, 1)
print("Generator network created")
def simpleModel():
#withh the following parameter accuracy found to be
#acc_test = .446
#acc_train = .4464
model = Sequential()
model.add(InputLayer(input_shape=(img_size_flat, )))
model.add(Reshape(img_shape_full))
model.add(
Conv2D(filters=32,
kernel_size=5,
strides=(1, 1),
activation='relu',
padding='same',
name='layer_conv1'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Conv2D(filters=64,
kernel_size=5,
strides=(2, 2),
activation='relu',
padding='same',
name='layer_conv2'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
model.add(
Conv2D(filters=36,
kernel_size=3,
strides=(2, 2),
activation='relu',
padding='same',
name='layer_conv3'))
#model.add(MaxPooling2D(pool_size = (2,2),strides = (2,2)))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dense(num_classes, activation='softmax'))
optimizer = Adam(.001)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(x=train_data, y=train_label, epochs=3, batch_size=64)
result = model.evaluate(x=validation_data, y=validation_label)
for name, value in zip(model.metrics_names, result):
print('{0}: {1}'.format(name, value))
def _cnn_bilstm_dropout(self, name: str) -> Model:
return Sequential([
InputLayer(input_shape=(self.maxlen, ), name='input'),
Embedding(input_dim=self.input_dim,
output_dim=self.embed_dim,
input_length=self.maxlen,
name='embedding'),
Dropout(0.2, name='input_dropout'),
Conv1D(filters=self.conv_filters,
kernel_size=self.conv_kernel_size,
padding='same',
activation='relu'),
MaxPool1D(pool_size=self.conv_pool_size),
Bidirectional(LSTM(units=self.units, name='bilstm')),
Dropout(0.5, name='hidden_dropout'),
Dense(self.classes, activation='sigmoid', name='fc1'),
],
name=name)
def build_model(self):
img_size_flat = self.image_size * self.image_size
img_shape = (self.image_size, self.image_size, self.num_channels)
model = Sequential()
model.add(InputLayer(input_shape=(img_size_flat, )))
model.add(Reshape(img_shape))
# model.add(Dropout(0.5, input_shape=(48, 48, 1)))
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation='elu',
name='layer_conv1'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=32,
padding='same',
activation='elu',
name='layer_conv2'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=64,
padding='same',
activation='elu',
name='layer_conv3'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Flatten())
model.add(Dense(128, activation='elu'))
model.add(Dense(32, activation='elu'))
# Last fully-connected / dense layer with softmax-activation
# for use in classification.
model.add(Dense(self.num_classes, activation='softmax'))
self.model = model
def made_model():
model = Sequential()
model.add(InputLayer(input_shape=(4, 50, 600, 800, 3)))
model.add(
TimeDistributed(TimeDistributed(MaxPooling2D(pool_size=2, strides=2))))
model.add(
TimeDistributed(
TimeDistributed(
Conv2D(kernel_size=3,
strides=1,
filters=5,
padding='same',
activation='relu',
name='layer_conv1'))))
model.add(
TimeDistributed(TimeDistributed(MaxPooling2D(pool_size=2, strides=2))))
model.add(
TimeDistributed(
TimeDistributed(
Conv2D(kernel_size=5,
strides=1,
filters=20,
padding='same',
activation='relu',
name='layer_conv2'))))
model.add(
TimeDistributed(TimeDistributed(MaxPooling2D(pool_size=2, strides=2))))
model.add(TimeDistributed(TimeDistributed(Flatten())))
model.add(TimeDistributed(TimeDistributed(Dense(128, activation='relu'))))
model.add(
TimeDistributed(SimpleRNN(64, return_sequences=False, stateful=False)))
model.add(SimpleRNN(64, return_sequences=False, stateful=False))
model.add(Dense(6, activation='softmax'))
optimizer = Adam(lr=1e-4)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
return model
def __init__(self):
super(Discrimnator, self).__init__()
self.input_layer = InputLayer(dtype=tf.float32)
self.conv1 = Conv2D(64, 4, padding="same", strides=2, dtype=tf.float32)
self.lrelu1 = LeakyReLU(dtype=tf.float32)
self.conv2 = Conv2D(128,
4,
padding="same",
strides=2,
dtype=tf.float32)
self.bn1 = BatchNormalization(dtype=tf.float32)
self.lrelu2 = LeakyReLU(dtype=tf.float32)
self.flatten = Flatten(dtype=tf.float32)
self.fully_connected1 = Dense(1024, dtype=tf.float32)
self.bn2 = BatchNormalization(dtype=tf.float32)
self.lrelu3 = LeakyReLU(dtype=tf.float32)
self.fully_connected2 = Dense(1, dtype=tf.float32)
print("Discrimnator network created")
def start_model(self):
"""Define the necessary structure"""
self.add(InputLayer(input_shape=(
self.image_setting.img_size_flat, ))) # Add an input layer
self.add(
Reshape(self.image_setting.img_shape_full)
) # convolutional layers expect images with shape (28, 28, 1), so we reshape
self.add(
Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation='relu',
name='layer_conv1')) # First convolutional layer
self.add(MaxPooling2D(pool_size=2, strides=2))
self.add(
Conv2D(kernel_size=5,
strides=1,
filters=36,
padding='same',
activation='relu',
name='layer_conv2')) # Second convolutional layer
self.add(MaxPooling2D(pool_size=2, strides=2))
self.add(
Flatten()
) # Flatten the 4-level output of convolutional layers to 2-rank that can be entered into a fully connected layer
self.add(Dense(128, activation='relu')) # Fully connected first layer
self.add(
Dense(self.image_setting.num_classes, activation='softmax')
) # last fully connected layer from which the classification is derived
# compile the model
optimizer = Adam(lr=1e-3)
self.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
def make_model(meta):
'create model based on meta definition'
model = Sequential()
model.add(InputLayer(input_shape=(width, height, 1)))
for l in range(meta[0]):
print("Conv2D({},{},{})".format(meta[1+l*5],
meta[2+l*5],
meta[3+l*5]))
model.add(Conv2D(meta[1+l*5],
kernel_size=meta[2+l*5],
strides=meta[3+l*5],
activation='relu'))
if meta[4+l*5] > 0:
print("MaxPooling2D({},{})".format(meta[4+l*5],
meta[5+l*5]))
model.add(MaxPooling2D(pool_size=meta[4+l*5],
strides=meta[5+l*5]))
model.add(Dropout(0.1))
model.add(Flatten())
if meta[-1]>0:
print("Dense({})".format(meta[-1]))
model.add(Dense(meta[-1], activation='relu'))
model.add(Dropout(0.3))
model.add(Dense(2, activation='softmax'))
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=tf.keras.optimizers.Adam(),
metrics=['accuracy'])
#randomize weights
weights = model.get_weights()
weights = [np.random.normal(size=w.shape) for w in weights]
model.set_weights(weights)
return model
return args
#%%
if __name__ == '__main__':
# Get input arguments
args = _argument_parser()
# Get some data
X_train, y_train, X_test, y_test = get_mnist_distorted()
# Data format
input_shape=(60,60,1)
# Keras model
model = Sequential()
model.add(InputLayer(input_shape=input_shape))
if args['transformer_type'] != 'no': # only construct if we want to use transformers
# Construct localization network
loc_net = get_loc_net(input_shape=input_shape,
transformer_name=args['transformer_type'])
# Add localization network and transformer layer
transformer_layer = get_keras_layer(args['transformer_type'])
model.add(transformer_layer(localization_net=loc_net,
output_size=input_shape))
else:
model.add(Lambda(lambda x: x)) # identity layer -> same model structure
# Construct feature extraction network
model.add(Conv2D(32, (3,3), activation='relu'))