def DenseNet121(nb_dense_block=4,
growth_rate=32,
nb_filter=64,
reduction=0.0,
dropout_rate=0.0,
weight_decay=1e-4,
classes=1000,
weights_path=None):
'''Instantiate the DenseNet 121 architecture,
# Arguments
nb_dense_block: number of dense blocks to add to end
growth_rate: number of filters to add per dense block
nb_filter: initial number of filters
reduction: reduction factor of transition blocks.
dropout_rate: dropout rate
weight_decay: weight decay factor
classes: optional number of classes to classify images
weights_path: path to pre-trained weights
# Returns
A Keras model instance.
'''
eps = 1.1e-5
# compute compression factor
compression = 1.0 - reduction
# Handle Dimension Ordering for different backends
global concat_axis
if K.image_dim_ordering() == 'tf':
concat_axis = 3
img_input = Input(shape=(224, 224, 3), name='data')
else:
concat_axis = 1
img_input = Input(shape=(3, 224, 224), name='data')
# From architecture for ImageNet (Table 1 in the paper)
nb_filter = 64
nb_layers = [6, 12, 24, 16] # For DenseNet-121
# Initial convolution
x = ZeroPadding2D((3, 3), name='conv1_zeropadding')(img_input)
x = Convolution2D(nb_filter,
7,
7,
subsample=(2, 2),
name='conv1',
bias=False)(x)
x = BatchNormalization(epsilon=eps, axis=concat_axis, name='conv1_bn')(x)
x = Scale(axis=concat_axis, name='conv1_scale')(x)
x = Activation('relu', name='relu1')(x)
x = ZeroPadding2D((1, 1), name='pool1_zeropadding')(x)
x = MaxPooling2D((3, 3), strides=(2, 2), name='pool1')(x)
# Add dense blocks
for block_idx in range(nb_dense_block - 1):
stage = block_idx + 2
x, nb_filter = dense_block(x,
stage,
nb_layers[block_idx],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
# Add transition_block
x = transition_block(x,
stage,
nb_filter,
compression=compression,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
nb_filter = int(nb_filter * compression)
final_stage = stage + 1
x, nb_filter = dense_block(x,
final_stage,
nb_layers[-1],
nb_filter,
growth_rate,
dropout_rate=dropout_rate,
weight_decay=weight_decay)
x = BatchNormalization(epsilon=eps,
axis=concat_axis,
name='conv' + str(final_stage) + '_blk_bn')(x)
x = Scale(axis=concat_axis,
name='conv' + str(final_stage) + '_blk_scale')(x)
x = Activation('relu', name='relu' + str(final_stage) + '_blk')(x)
x = GlobalAveragePooling2D(name='pool' + str(final_stage))(x)
x = Dense(classes, name='fc6')(x)
x = Activation('softmax', name='prob')(x)
model = Model(img_input, x, name='densenet')
if weights_path is not None:
model.load_weights(weights_path)
return model
def build_model2(self):
vae_input = Input(shape=self.input_dim)
#print("vae_input shape " + str(vae_input.shape))
vae_c1 = Conv2D(filters=32,
kernel_size=3,
padding='same',
activation='relu',
trainable=True)(vae_input)
vae_m1 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c1)
vae_c2 = Conv2D(filters=16,
kernel_size=3,
padding='same',
activation='relu',
trainable=True)(vae_m1)
vae_m2 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c2)
vae_c3 = Conv2D(filters=16,
kernel_size=3,
padding='same',
activation='relu',
trainable=True)(vae_m2)
vae_m3 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c3)
vae_c4 = Conv2D(filters=16,
kernel_size=3,
padding='same',
activation='relu',
trainable=True)(vae_m3)
vae_m4 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c4)
vae_c5 = Conv2D(filters=16,
kernel_size=3,
padding='same',
activation='relu',
trainable=True)(vae_m4)
vae_m5 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c5)
vae_c6 = Conv2D(filters=4,
kernel_size=3,
padding='same',
activation='relu',
trainable=True)(vae_m5)
vae_m6 = MaxPooling2D((2, 2), padding='same', trainable=True)(vae_c6)
vae_z_in = Flatten()(vae_m6)
print("vae_z_in shape " + str(vae_z_in.shape))
vae_z = Dense(25, trainable=True)(vae_z_in)
print("vae_z shape " + str(vae_z.shape))
vae_z_input = Input(shape=(25, ))
print("vae_z_input shape " + str(vae_z_input.shape))
vae_z_out = Reshape((5, 5, 1))
vae_z_out_model = vae_z_out(vae_z)
print("vae_z_out_model shape " + str(vae_z_out_model.shape))
#vae_d1 = Conv2D( filters=8, kernel_size=(3, 3), padding='same', activation='relu')
vae_u1 = UpSampling2D((3, 4))
vae_d2 = Conv2D(filters=32,
kernel_size=(3, 3),
padding='same',
activation='relu')
vae_u2 = UpSampling2D((2, 2))
vae_d3 = Conv2D(filters=32,
kernel_size=(3, 3),
padding='same',
activation='relu')
vae_u3 = UpSampling2D((2, 2))
vae_d4 = Conv2D(filters=16,
kernel_size=(3, 3),
padding='same',
activation='relu')
vae_u4 = UpSampling2D((2, 2))
vae_d5 = Conv2D(filters=8,
kernel_size=(3, 3),
padding='same',
activation='relu')
vae_u5 = UpSampling2D((2, 2))
vae_d6 = Conv2D(filters=1,
kernel_size=(3, 3),
padding='same',
activation='sigmoid')
# vae_d1_model = vae_d1(vae_z_out_model)
vae_u1_model = vae_u1(vae_z_out_model)
vae_d2_model = vae_d2(vae_u1_model)
vae_u2_model = vae_u2(vae_d2_model)
vae_d3_model = vae_d3(vae_u2_model)
vae_u3_model = vae_u3(vae_d3_model)
vae_d4_model = vae_d4(vae_u3_model)
vae_u4_model = vae_u4(vae_d4_model)
vae_d5_model = vae_d5(vae_u4_model)
vae_u5_model = vae_u5(vae_d5_model)
vae_d6_model = vae_d6(vae_u5_model)
#print("vae_d1_model shape " + str(vae_d1_model.shape))
#print("vae_u1_model shape " + str(vae_u1_model.shape))
#print("vae_d2_model shape " + str(vae_d2_model.shape))
#print("vae_u2_model shape " + str(vae_u2_model.shape))
#print("vae_d3_model shape " + str(vae_d3_model.shape))
#print("vae_u3_model shape " + str(vae_u3_model.shape))
#print("vae_d4_model shape " + str(vae_d4_model.shape))
#print("vae_u4_model shape " + str(vae_u4_model.shape))
#print("vae_d5_model shape " + str(vae_d5_model.shape))
#240 120 60 30 15
#320 160 80 40 20
vae_dense_decoder = vae_z_input
vae_z_out_decoder = vae_z_out(vae_dense_decoder)
#vae_d1_decoder = vae_d1(vae_z_out_decoder)
vae_u1_decoder = vae_u1(vae_z_out_decoder)
vae_d2_decoder = vae_d2(vae_u1_decoder)
vae_u2_decoder = vae_u2(vae_d2_decoder)
vae_d3_decoder = vae_d3(vae_u2_decoder)
vae_u3_decoder = vae_u3(vae_d3_decoder)
vae_d4_decoder = vae_d4(vae_u3_decoder)
vae_u4_decoder = vae_u4(vae_d4_decoder)
vae_d5_decoder = vae_d5(vae_u4_decoder)
vae_u5_decoder = vae_u5(vae_d5_decoder)
vae_d6_decoder = vae_d6(vae_u5_decoder)
print("vae_d1_decoder shape " + str(vae_u1_decoder.shape))
print("vae_d2_decoder shape " + str(vae_d2_decoder.shape))
print("vae_d3_decoder shape " + str(vae_d3_decoder.shape))
print("vae_d4_decoder shape " + str(vae_d4_decoder.shape))
print("vae_d5_decoder shape " + str(vae_d5_decoder.shape))
# Models
vae = Model(vae_input, vae_d6_model)
vae_encoder = Model(vae_input, vae_z)
vae_decoder = Model(vae_z_input, vae_d6_decoder)
#vae.compile(optimizer='rmsprop', loss = vae_loss, metrics = [vae_r_loss, vae_kl_loss])
#vae.compile(optimizer='rmsprop', loss='binary_crossentropy')
#optimizer = Adam(lr=0.001)
vae.compile(optimizer=Adam(lr=0.0001), loss='binary_crossentropy')
vae.summary()
return (vae, vae_encoder, vae_decoder)
def create_model(learning_rate, num_dense_layers, num_dense_nodes, activation):
"""
Hyper-parameters:
learning_rate: Learning-rate for the optimizer.
num_dense_layers: Number of dense layers.
num_dense_nodes: Number of nodes in each dense layer.
activation: Activation function for all layers.
"""
# Start construction of a Keras Sequential model.
model = Sequential()
# Add an input layer which is similar to a feed_dict in TensorFlow.
# Note that the input-shape must be a tuple containing the image-size.
model.add(InputLayer(input_shape=(img_size_flat, )))
# The input from MNIST is a flattened array with 784 elements,
# but the convolutional layers expect images with shape (28, 28, 1)
model.add(Reshape(img_shape_full))
# First convolutional layer.
# There are many hyper-parameters in this layer, but we only
# want to optimize the activation-function in this example.
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=16,
padding='same',
activation=activation,
name='layer_conv1'))
model.add(MaxPooling2D(pool_size=2, strides=2))
# Second convolutional layer.
# Again, we only want to optimize the activation-function here.
model.add(
Conv2D(kernel_size=5,
strides=1,
filters=36,
padding='same',
activation=activation,
name='layer_conv2'))
model.add(MaxPooling2D(pool_size=2, strides=2))
# Flatten the 4-rank output of the convolutional layers
# to 2-rank that can be input to a fully-connected / dense layer.
model.add(Flatten())
# Add fully-connected / dense layers.
# The number of layers is a hyper-parameter we want to optimize.
for i in range(num_dense_layers):
# Name of the layer. This is not really necessary
# because Keras should give them unique names.
name = 'layer_dense_{0}'.format(i + 1)
# Add the dense / fully-connected layer to the model.
# This has two hyper-parameters we want to optimize:
# The number of nodes and the activation function.
model.add(Dense(num_dense_nodes, activation=activation, name=name))
# Last fully-connected / dense layer with softmax-activation
# for use in classification.
model.add(Dense(num_classes, activation='softmax'))
# Use the Adam method for training the network.
# We want to find the best learning-rate for the Adam method.
optimizer = Adam(lr=learning_rate)
# In Keras we need to compile the model so it can be trained.
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
def build_model(input_shape=None):
input_shape = _obtain_input_shape(input_shape,
default_size=im_size,
min_size=24,
data_format=K.image_data_format(),
require_flatten=False,
weights='None')
img_input = Input(shape=input_shape)
reg = regularizers.l2(0.001)
# first block
x = Conv2D(32, (3, 3),
strides=(2, 2),
use_bias=False,
name='block1_conv1',
kernel_regularizer=reg)(img_input)
x = BatchNormalization(name='block1_conv1_bn')(x)
x = Activation('relu', name='block1_conv1_act')(x)
x = Conv2D(64, (3, 3),
use_bias=False,
name='block1_conv2',
kernel_regularizer=reg)(x)
x = BatchNormalization(name='block1_conv2_bn')(x)
x = Activation('relu', name='block1_conv2_act')(x)
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False,
name='residual_conv2d_1',
kernel_regularizer=reg)(x)
residual = BatchNormalization()(residual)
# second block
x = SeparableConv2D(128, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv1',
kernel_regularizer=reg)(x)
x = BatchNormalization(name='block2_sepconv1_bn')(x)
x = Activation('relu', name='block2_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name='block2_sepconv2',
kernel_regularizer=reg)(x)
x = BatchNormalization(name='block2_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block2_pool')(x)
x = layers.add([x, residual])
# second residual
residual = Conv2D(256, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False,
name='residual_conv2d_2',
kernel_regularizer=reg)(x)
residual = BatchNormalization()(residual)
for i in range(2):
residual = x
prefix = 'block' + str(i + 3)
x = Activation('relu', name=prefix + '_sepconv1_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv1',
kernel_regularizer=reg)(x)
x = BatchNormalization(name=prefix + '_sepconv1_bn')(x)
x = Activation('relu', name=prefix + '_sepconv2_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv2',
kernel_regularizer=reg)(x)
x = BatchNormalization(name=prefix + '_sepconv2_bn')(x)
x = Activation('relu', name=prefix + '_sepconv3_act')(x)
x = SeparableConv2D(256, (3, 3),
padding='same',
use_bias=False,
name=prefix + '_sepconv3',
kernel_regularizer=reg)(x)
x = BatchNormalization(name=prefix + '_sepconv3_bn')(x)
x = layers.add([x, residual])
residual = Conv2D(384, (1, 1),
strides=(2, 2),
padding='same',
use_bias=False)(x)
residual = BatchNormalization()(residual)
# output blocks - block 21
x = Activation('relu', name='block21_sepconv1_act')(x)
x = SeparableConv2D(384, (3, 3),
padding='same',
use_bias=False,
name='block21_sepconv1',
kernel_regularizer=reg)(x)
x = BatchNormalization(name='block21_sepconv1_bn')(x)
x = Activation('relu', name='block21_sepconv2_act')(x)
x = SeparableConv2D(384, (3, 3),
padding='same',
use_bias=False,
name='block21_sepconv2',
kernel_regularizer=reg)(x)
x = BatchNormalization(name='block21_sepconv2_bn')(x)
x = MaxPooling2D((3, 3),
strides=(2, 2),
padding='same',
name='block13_pool')(x)
x = layers.add([x, residual])
# block 22
x = SeparableConv2D(512, (3, 3),
padding='same',
use_bias=False,
name='block22_sepconv1',
kernel_regularizer=reg)(x)
x = BatchNormalization(name='block22_sepconv1_bn')(x)
x = Activation('relu', name='block22_sepconv1_act')(x)
x = SeparableConv2D(768, (3, 3),
padding='same',
use_bias=False,
name='block22_sepconv2',
kernel_regularizer=reg)(x)
x = BatchNormalization(name='block22_sepconv2_bn')(x)
x = Activation('relu', name='block22_sepconv2_act')(x)
# model finish
x = GlobalMaxPooling2D()(x)
x = Flatten()(x)
x = Dense(256, activation='relu', kernel_regularizer=reg)(x)
x = Dense(64, activation='relu', kernel_regularizer=reg)(x)
x = Dense(num_classes, activation='softmax')(x)
model = Model(img_input, x, name='micro_xception_bn_v1')
opt = optimizers.Adam(lr=0.0008, decay=0.001)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model
input_shape = (w, h, c)
learning_rate = 0.00001
regularization_rate = 0.000001
category_count = 30 + 1
model = Sequential()
# Layer 1
model.add(
Conv2D(32,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu',
input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4)))
# Layer 2
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.1))
# Layer 3
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
# Layer 4
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.2))
input_shape = (img_width, img_height, 3)
PWD = '.'
MODEL = "{}/cnn_model.h5".format(PWD)
if os.path.isfile(MODEL):
model = keras.models.load_model(MODEL)
else:
model = Sequential()
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(
Conv2D(32,
kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(16, activation='relu'))
model.add(Dropout(0.25))
model.add(Dense(6, activation='softmax'))
model.compile(loss='categorical_crossentropy',
optimizer='rmsprop',
metrics=['accuracy'])
def VGG_16(spatial_size,
classes,
channels,
channel_first=True,
weights_path=None):
model = Sequential()
if channel_first:
model.add(
ZeroPadding2D((1, 1),
input_shape=(channels, spatial_size, spatial_size)))
else:
model.add(
ZeroPadding2D((1, 1),
input_shape=(spatial_size, spatial_size, channels)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(128, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(256, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(ZeroPadding2D((1, 1)))
model.add(Conv2D(512, (3, 3), activation='relu'))
model.add(MaxPooling2D((2, 2), strides=(2, 2))) # 33
model.add(Flatten())
model.add(Dense(4096, activation='relu')) # 34
model.add(Dropout(0.5))
model.add(Dense(4096, activation='relu')) # 35
model.add(Dropout(0.5))
model.add(Dense(2622, activation='softmax')) # Dropped
if weights_path:
model.load_weights(weights_path)
model.pop()
model.add(Dense(classes, activation='softmax')) # 36
return model
from tensorflow.python.keras.models import Sequential
from tensorflow.python.keras.layers import InputLayer
from tensorflow.python.keras.layers import MaxPooling2D
from tensorflow.python.keras.layers import Conv2D, Dense, Flatten
from tensorflow.python.keras.optimizers import Adam
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets('data/MNIST/', one_hot=True, reshape=False)
model = Sequential()
model.add(InputLayer(input_shape=(28, 28, 1)))
model.add(Conv2D(kernel_size=5, strides=1, filters=32, padding='same', activation='relu', name='conv1'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Conv2D(kernel_size=5, strides=1, filters=64, padding='same', activation='relu', name='conv2'))
model.add(MaxPooling2D(pool_size=2, strides=2))
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dense(10, activation='softmax'))
optimizer = Adam(lr=1e-3)
model.compile(optimizer=optimizer, loss='categorical_crossentropy', metrics=['accuracy'])
model.fit(x=mnist.train.images, y=mnist.train.labels, epochs=5, batch_size=128)
result = model.evaluate(x=mnist.train.images, y=mnist.train.labels)
print('\n\nAccuracy:', result[1])
data_validacion,
target_size=(altura, longitud),
batch_size=batch_size,
class_mode='categorical')
#Crear la red CNN
cnn = Sequential()
cnn.add(
Convolution2D(filtrosConv1,
tamano_filtro1,
padding='same',
input_shape=(altura, longitud, 3),
activation='relu'))
cnn.add(MaxPooling2D(pool_size=tamano_pool))
cnn.add(
Convolution2D(filtrosConv2,
tamano_filtro2,
padding='same',
activation='relu'))
cnn.add(MaxPooling2D(pool_size=tamano_pool))
cnn.add(Flatten())
cnn.add(Dense(256, activation='relu'))
cnn.add(Dropout(0.5))
cnn.add(Dense(clases, activation='softmax'))
cnn.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(lr=lr),
def train(run_name,
start_epoch,
stop_epoch,
img_w,
img_h,
build_word_count,
max_string_len,
save_model_path=None):
# Input Parameters
words_per_epoch = 96000
val_split = 0.2
val_words = int(words_per_epoch * (val_split))
# Network parameters
pool_size = 2
minibatch_size = 32
if K.image_data_format() == 'channels_first':
input_shape = (1, img_w, img_h)
else:
input_shape = (img_w, img_h, 1)
img_gen = TextImageGenerator(minibatch_size=minibatch_size,
img_w=img_w,
img_h=img_h,
val_split=words_per_epoch - val_words,
build_word_count=build_word_count,
max_string_len=max_string_len)
act = 'relu'
kernel_init = 'glorot_uniform'
input_data = Input(name='the_input', shape=input_shape, dtype='float32')
inner = Conv2D(64, (3, 3),
padding='same',
activation=None,
kernel_initializer=kernel_init,
name='conv1')(input_data)
inner = BatchNormalization(axis=3, scale=False, name='bn1')(inner)
inner = Activation(activation=act)(inner)
inner = MaxPooling2D(pool_size=(pool_size, pool_size), name='max1')(inner)
inner = identity_block(inner,
3, [16, 16, 64],
stage=2,
block='a',
train_bn=True)
inner = conv_block(inner,
3, [32, 32, 128],
stage=3,
block='a',
train_bn=True)
inner = conv_block(inner,
3, [64, 64, 256],
stage=4,
block='a',
train_bn=True)
inner = Flatten(name='reshape')(inner)
inner = Dense(512, activation=act, name='dense1')(inner)
outputs = []
for i in range(max_string_len):
output = Dense(img_gen.get_output_size(),
activation='softmax',
kernel_initializer=kernel_init,
name='output{}'.format(i))(inner)
outputs.append(output)
output = Dense(max_string_len + 1,
activation='softmax',
kernel_initializer=kernel_init,
name='output{}'.format(max_string_len))(inner)
outputs.append(output)
# clipnorm seems to speeds up convergence
sgd = SGD(lr=0.005, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
model = Model(inputs=[input_data], outputs=outputs)
# the loss calc occurs elsewhere, so use a dummy lambda func for the loss
model.compile(loss=['sparse_categorical_crossentropy'] *
(max_string_len + 1),
optimizer=sgd,
metrics=['accuracy'] * (max_string_len + 1))
if start_epoch > 0:
weight_file = os.path.join(
OUTPUT_DIR,
os.path.join(run_name, 'weights%02d.h5' % (start_epoch - 1)))
model.load_weights(weight_file)
print("load_weight: ", weight_file)
# captures output of softmax so we can decode the output during visualization
test_func = K.function([input_data], outputs)
viz_cb = VizCallback(run_name, test_func, img_gen.next_val())
model.fit_generator(generator=img_gen.next_train(),
steps_per_epoch=(words_per_epoch - val_words) //
minibatch_size,
epochs=stop_epoch,
validation_data=img_gen.next_val(),
validation_steps=val_words // minibatch_size,
callbacks=[viz_cb, img_gen],
initial_epoch=start_epoch,
verbose=1)
if save_model_path:
model.save(save_model_path)
def DenseNet(blocks,
include_top=True,
weights='imagenet',
input_tensor=None,
input_shape=None,
pooling=None,
classes=1000):
"""Instantiates the DenseNet 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.
The model and the weights are compatible with
TensorFlow, Theano, and CNTK. The data format
convention used by the model is the one
specified in your Keras config file.
Arguments:
blocks: numbers of building blocks for the four dense layers.
include_top: whether to include the fully-connected
layer at the top of the network.
weights: one of `None` (random initialization),
'imagenet' (pre-training on ImageNet),
or the path to the weights file to be loaded.
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 `(224, 224, 3)` (with `channels_last` data format)
or `(3, 224, 224)` (with `channels_first` data format).
It should have exactly 3 inputs channels.
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.
"""
if not (weights in {'imagenet', None} or os.path.exists(weights)):
raise ValueError('The `weights` argument should be either '
'`None` (random initialization), `imagenet` '
'(pre-training on ImageNet), '
'or the path to the weights file to be loaded.')
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
# Determine proper input shape
input_shape = _obtain_input_shape(input_shape,
default_size=224,
min_size=221,
data_format=K.image_data_format(),
require_flatten=include_top,
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
bn_axis = 3 if K.image_data_format() == 'channels_last' else 1
x = ZeroPadding2D(padding=((3, 3), (3, 3)))(img_input)
x = Conv2D(64, 7, strides=2, use_bias=False, name='conv1/conv')(x)
x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='conv1/bn')(x)
x = Activation('relu', name='conv1/relu')(x)
x = ZeroPadding2D(padding=((1, 1), (1, 1)))(x)
x = MaxPooling2D(3, strides=2, name='pool1')(x)
x = dense_block(x, blocks[0], name='conv2')
x = transition_block(x, 0.5, name='pool2')
x = dense_block(x, blocks[1], name='conv3')
x = transition_block(x, 0.5, name='pool3')
x = dense_block(x, blocks[2], name='conv4')
x = transition_block(x, 0.5, name='pool4')
x = dense_block(x, blocks[3], name='conv5')
x = BatchNormalization(axis=bn_axis, epsilon=1.001e-5, name='bn')(x)
if include_top:
x = GlobalAveragePooling2D(name='avg_pool')(x)
x = Dense(classes, activation='softmax', name='fc1000')(x)
else:
if pooling == 'avg':
x = GlobalAveragePooling2D(name='avg_pool')(x)
elif pooling == 'max':
x = GlobalMaxPooling2D(name='max_pool')(x)
# Ensure that the model takes into account
# any potential predecessors of `input_tensor`.
if input_tensor is not None:
inputs = layer_utils.get_source_inputs(input_tensor)
else:
inputs = img_input
# Create model.
if blocks == [6, 12, 24, 16]:
model = Model(inputs, x, name='densenet121')
elif blocks == [6, 12, 32, 32]:
model = Model(inputs, x, name='densenet169')
elif blocks == [6, 12, 48, 32]:
model = Model(inputs, x, name='densenet201')
else:
model = Model(inputs, x, name='densenet')
# Load weights.
if weights == 'imagenet':
if include_top:
if blocks == [6, 12, 24, 16]:
weights_path = get_file(
'densenet121_weights_tf_dim_ordering_tf_kernels.h5',
DENSENET121_WEIGHT_PATH,
cache_subdir='models',
file_hash='0962ca643bae20f9b6771cb844dca3b0')
elif blocks == [6, 12, 32, 32]:
weights_path = get_file(
'densenet169_weights_tf_dim_ordering_tf_kernels.h5',
DENSENET169_WEIGHT_PATH,
cache_subdir='models',
file_hash='bcf9965cf5064a5f9eb6d7dc69386f43')
elif blocks == [6, 12, 48, 32]:
weights_path = get_file(
'densenet201_weights_tf_dim_ordering_tf_kernels.h5',
DENSENET201_WEIGHT_PATH,
cache_subdir='models',
file_hash='7bb75edd58cb43163be7e0005fbe95ef')
else:
if blocks == [6, 12, 24, 16]:
weights_path = get_file(
'densenet121_weights_tf_dim_ordering_tf_kernels_notop.h5',
DENSENET121_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='4912a53fbd2a69346e7f2c0b5ec8c6d3')
elif blocks == [6, 12, 32, 32]:
weights_path = get_file(
'densenet169_weights_tf_dim_ordering_tf_kernels_notop.h5',
DENSENET169_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='50662582284e4cf834ce40ab4dfa58c6')
elif blocks == [6, 12, 48, 32]:
weights_path = get_file(
'densenet201_weights_tf_dim_ordering_tf_kernels_notop.h5',
DENSENET201_WEIGHT_PATH_NO_TOP,
cache_subdir='models',
file_hash='1c2de60ee40562448dbac34a0737e798')
model.load_weights(weights_path)
elif weights is not None:
model.load_weights(weights)
return model
trainX = inputX[:70000]
trainY = inputY[:70000]
valX = inputX[70000:]
valY = inputY[70000:]
es = EarlyStopping(monitor='val_mae', mode='min', verbose=1, patience=150)
# design network
model = Sequential()
model.add(
Conv2D(32, (3, 3),
activation='relu',
input_shape=(84, 84, 1),
padding='same'))
model.add(MaxPooling2D((2, 2), padding='same'))
model.add(Conv2D(16, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D((2, 2), padding='same'))
model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))
model.add(MaxPooling2D((2, 2), padding='same'))
model.add(Conv2D(8, (3, 3), activation='relu', padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2D(16, (3, 3), activation='relu', padding='same'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2D(32, (3, 3), activation='relu'))
model.add(UpSampling2D((2, 2)))
model.add(Conv2D(1, (3, 3), padding='same'))
model.compile(loss='mse', optimizer='rmsprop', metrics=['mae'])
def FCN(input_shape=None, batch_shape=None):
if batch_shape:
img_input = Input(batch_shape=batch_shape)
image_size = batch_shape[1:3]
else:
img_input = Input(shape=input_shape)
image_size = input_shape[0:2]
bn_axis = 3
# just one class, unpickable
classes = 1
x = Conv2D(256, (10, 10), strides=(1, 1), padding='same',
name='conv1')(img_input)
x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=0.9)(x)
x = Activation('relu')(x)
x = MaxPooling2D((2, 2), strides=(2, 2))(x)
x = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv1')(x)
x = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv2')(x)
x = Conv2D(256, (3, 3),
activation='relu',
padding='same',
name='block3_conv3')(x)
x = BatchNormalization(axis=bn_axis, name='bn_conv2', momentum=0.9)(x)
x = Activation('relu')(x)
x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x)
#x = MaxPooling2D((2, 2), strides=(2, 2))(x)
# x = Conv2D(128, (5, 5), strides=(1, 1), padding='same', name='conv3')(x)
# x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x)
# x = Activation('relu')(x)
#x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#x = Conv2D(128, (3, 3), strides=(2, 2), padding='same', name='conv4')(x)
#x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x)
#x = Activation('relu')(x)
#x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#x = Conv2D(128, (5, 5), strides=(2, 2), padding='same', name='conv3')(img_input)
#x = BatchNormalization(axis=bn_axis, name='bn_conv1', momentum=batch_momentum)(x)
#x = Activation('relu')(x)
#x = MaxPooling2D((2, 2), strides=(2, 2))(x)
#classifying layer
#x = Conv2D(classes, (3, 3), dilation_rate=(2, 2), kernel_initializer='normal', activation='linear', padding='same', strides=(1, 1), kernel_regularizer=l2(weight_decay))(x)
x = Conv2D(classes, (1, 1),
kernel_initializer='he_normal',
activation='sigmoid',
padding='same',
strides=(1, 1))(x)
# = BilinearUpSampling2D(target_size=tuple(image_size))(x)
#x = tf.image.resize_images(x, [image_size[0], image_size[1]])
x = UpSampling2D(size=(4, 4), data_format=None)(x)
model = Model(img_input, x)
# weights_path = os.path.expanduser(os.path.join('~', '.keras/models/fcn_resnet50_weights_tf_dim_ordering_tf_kernels.h5'))
# model.load_weights(weights_path, by_name=True)
return model
def UNet(input_size: Tuple[int, int, int] = (128, 128, 1)) -> tf.keras.Model:
"""A standard UNet implementation in pytorch
Args:
input_size: The size of the input tensor (height, width, channels).
Raises:
ValueError: Length of `input_size` is not 3.
ValueError: `input_size`[0] or `input_size`[1] is not a multiple of 16.
Returns:
A TensorFlow UNet model.
"""
_check_input_size(input_size)
conv_config = {
'activation': 'relu',
'padding': 'same',
'kernel_initializer': 'he_normal'
}
up_config = {'size': (2, 2), 'interpolation': 'bilinear'}
inputs = Input(input_size)
conv1 = Conv2D(64, 3, **conv_config)(inputs)
conv1 = Conv2D(64, 3, **conv_config)(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)
conv2 = Conv2D(128, 3, **conv_config)(pool1)
conv2 = Conv2D(128, 3, **conv_config)(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)
conv3 = Conv2D(256, 3, **conv_config)(pool2)
conv3 = Conv2D(256, 3, **conv_config)(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)
conv4 = Conv2D(512, 3, **conv_config)(pool3)
conv4 = Conv2D(512, 3, **conv_config)(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)
conv5 = Conv2D(1024, 3, **conv_config)(pool4)
conv5 = Conv2D(1024, 3, **conv_config)(conv5)
drop5 = Dropout(0.5)(conv5)
up6 = Conv2D(512, 3, **conv_config)(UpSampling2D(**up_config)(drop5))
merge6 = concatenate([drop4, up6], axis=-1)
conv6 = Conv2D(512, 3, **conv_config)(merge6)
conv6 = Conv2D(512, 3, **conv_config)(conv6)
up7 = Conv2D(256, 3, **conv_config)(UpSampling2D(**up_config)(conv6))
merge7 = concatenate([conv3, up7], axis=-1)
conv7 = Conv2D(256, 3, **conv_config)(merge7)
conv7 = Conv2D(256, 3, **conv_config)(conv7)
up8 = Conv2D(128, 3, **conv_config)(UpSampling2D(**up_config)(conv7))
merge8 = concatenate([conv2, up8], axis=-1)
conv8 = Conv2D(128, 3, **conv_config)(merge8)
conv8 = Conv2D(128, 3, **conv_config)(conv8)
up9 = Conv2D(64, 3, **conv_config)(UpSampling2D(**up_config)(conv8))
merge9 = concatenate([conv1, up9], axis=-1)
conv9 = Conv2D(64, 3, **conv_config)(merge9)
conv9 = Conv2D(64, 3, **conv_config)(conv9)
conv10 = Conv2D(1, 1, activation='sigmoid')(conv9)
model = Model(inputs=inputs, outputs=conv10)
return model
def cifar100_complicated_ensemble_submodel3(
input_shape=None,
input_tensor=None,
n_classes=None,
weights_path: Union[None, str] = None) -> Model:
"""
Defines a cifar100 network.
:param n_classes: used in order to be compatible with the main script.
: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 functional API Model.
"""
inputs = create_inputs(input_shape, input_tensor)
# Define a weight decay for the regularisation.
weight_decay = 1e-7
# Block 1.
x = Conv2D(32, (3, 3),
padding='same',
activation='relu',
name='block1_conv1',
kernel_regularizer=l2(weight_decay))(inputs)
x = BatchNormalization(name='block1_batch-norm1')(x)
x = Conv2D(32, (3, 3),
padding='same',
activation='relu',
name='block1_conv2',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(name='block1_batch-norm2')(x)
x = MaxPooling2D(pool_size=(2, 2), name='block1_pool')(x)
x = Dropout(0.2, name='block1_dropout', seed=0)(x)
# Block 2.
x = Conv2D(64, (3, 3),
padding='same',
activation='relu',
name='block2_conv1',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(name='block2_batch-norm1')(x)
x = Conv2D(64, (3, 3),
padding='same',
activation='relu',
name='block2_conv2',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(name='block2_batch-norm2')(x)
x = MaxPooling2D(pool_size=(2, 2), name='block2_pool')(x)
x = Dropout(0.3, name='block2_dropout', seed=0)(x)
# Block 3.
x = Conv2D(128, (3, 3),
padding='same',
activation='relu',
name='block3_conv1',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(name='block3_batch-norm1')(x)
x = Conv2D(128, (3, 3),
padding='same',
activation='relu',
name='block3_conv2',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(name='block3_batch-norm2')(x)
x = MaxPooling2D(pool_size=(2, 2), name='block3_pool')(x)
x = Dropout(0.4, name='block3_dropout', seed=0)(x)
# Block 4.
x = Conv2D(256, (3, 3),
padding='same',
activation='relu',
name='block4_conv1',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(name='block4_batch-norm1')(x)
x = Conv2D(256, (3, 3),
padding='same',
activation='relu',
name='block4_conv2',
kernel_regularizer=l2(weight_decay))(x)
x = BatchNormalization(name='block4_batch-norm2')(x)
x = MaxPooling2D(pool_size=(2, 2), name='block4_pool')(x)
x = Dropout(0.5, name='block4_dropout', seed=0)(x)
# Add top layers.
x = Flatten(name='flatten')(x)
outputs = Dense(n_classes, activation='softmax', name='softmax_outputs')(x)
# Create Submodel 3.
model = Model(inputs,
outputs,
name='cifar100_complicated_ensemble_submodel3')
# Load weights, if they exist.
load_weights(weights_path, model)
return model
def InceptionV3(include_top=True,
weights='imagenet',
input_tensor=None,
model_input=None,
pooling=None,
classes=1000, model_path=""):
"""Instantiates the Inception v3 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.
The model and the weights are compatible with both
TensorFlow and Theano. The data format
convention used by the model is the one
specified in your Keras config file.
Note that the default input image size for this model is 299x299.
# 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.
"""
if weights == 'imagenet' and include_top and classes != 1000:
raise ValueError('If using `weights` as imagenet with `include_top`'
' as true, `classes` should be 1000')
img_input = model_input
channel_axis = 3
x = conv2d_bn(img_input, 32, 3, 3, strides=(2, 2), padding='valid')
x = conv2d_bn(x, 32, 3, 3, padding='valid')
x = conv2d_bn(x, 64, 3, 3)
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = conv2d_bn(x, 80, 1, 1, padding='valid')
x = conv2d_bn(x, 192, 3, 3, padding='valid')
x = MaxPooling2D((3, 3), strides=(2, 2))(x)
# mixed 0, 1, 2: 35 x 35 x 256
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 32, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed0')
# mixed 1: 35 x 35 x 256
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed1')
# mixed 2: 35 x 35 x 256
branch1x1 = conv2d_bn(x, 64, 1, 1)
branch5x5 = conv2d_bn(x, 48, 1, 1)
branch5x5 = conv2d_bn(branch5x5, 64, 5, 5)
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 64, 1, 1)
x = layers.concatenate(
[branch1x1, branch5x5, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed2')
# mixed 3: 17 x 17 x 768
branch3x3 = conv2d_bn(x, 384, 3, 3, strides=(2, 2), padding='valid')
branch3x3dbl = conv2d_bn(x, 64, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 96, 3, 3)
branch3x3dbl = conv2d_bn(
branch3x3dbl, 96, 3, 3, strides=(2, 2), padding='valid')
branch_pool = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate(
[branch3x3, branch3x3dbl, branch_pool], axis=channel_axis, name='mixed3')
# mixed 4: 17 x 17 x 768
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 128, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 128, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 128, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 128, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed4')
# mixed 5, 6: 17 x 17 x 768
for i in range(2):
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 160, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 160, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 160, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 160, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(5 + i))
# mixed 7: 17 x 17 x 768
branch1x1 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(x, 192, 1, 1)
branch7x7 = conv2d_bn(branch7x7, 192, 1, 7)
branch7x7 = conv2d_bn(branch7x7, 192, 7, 1)
branch7x7dbl = conv2d_bn(x, 192, 1, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 7, 1)
branch7x7dbl = conv2d_bn(branch7x7dbl, 192, 1, 7)
branch_pool = AveragePooling2D((3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch7x7, branch7x7dbl, branch_pool],
axis=channel_axis,
name='mixed7')
# mixed 8: 8 x 8 x 1280
branch3x3 = conv2d_bn(x, 192, 1, 1)
branch3x3 = conv2d_bn(branch3x3, 320, 3, 3,
strides=(2, 2), padding='valid')
branch7x7x3 = conv2d_bn(x, 192, 1, 1)
branch7x7x3 = conv2d_bn(branch7x7x3, 192, 1, 7)
branch7x7x3 = conv2d_bn(branch7x7x3, 192, 7, 1)
branch7x7x3 = conv2d_bn(
branch7x7x3, 192, 3, 3, strides=(2, 2), padding='valid')
branch_pool = MaxPooling2D((3, 3), strides=(2, 2))(x)
x = layers.concatenate(
[branch3x3, branch7x7x3, branch_pool], axis=channel_axis, name='mixed8')
# mixed 9: 8 x 8 x 2048
for i in range(2):
branch1x1 = conv2d_bn(x, 320, 1, 1)
branch3x3 = conv2d_bn(x, 384, 1, 1)
branch3x3_1 = conv2d_bn(branch3x3, 384, 1, 3)
branch3x3_2 = conv2d_bn(branch3x3, 384, 3, 1)
branch3x3 = layers.concatenate(
[branch3x3_1, branch3x3_2], axis=channel_axis, name='mixed9_' + str(i))
branch3x3dbl = conv2d_bn(x, 448, 1, 1)
branch3x3dbl = conv2d_bn(branch3x3dbl, 384, 3, 3)
branch3x3dbl_1 = conv2d_bn(branch3x3dbl, 384, 1, 3)
branch3x3dbl_2 = conv2d_bn(branch3x3dbl, 384, 3, 1)
branch3x3dbl = layers.concatenate(
[branch3x3dbl_1, branch3x3dbl_2], axis=channel_axis)
branch_pool = AveragePooling2D(
(3, 3), strides=(1, 1), padding='same')(x)
branch_pool = conv2d_bn(branch_pool, 192, 1, 1)
x = layers.concatenate(
[branch1x1, branch3x3, branch3x3dbl, branch_pool],
axis=channel_axis,
name='mixed' + str(9 + i))
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`.
inputs = img_input
# Create model.
model = Model(inputs, x, name='inception_v3')
# 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.')
if include_top:
weights_path = model_path
model.load_weights(weights_path)
else:
weights_path = ""
elif (weights == "trained"):
weights_path = model_path
model.load_weights(weights_path)
return model
def DeepConvNet(nb_classes, Chans=64, Samples=256, dropoutRate=0.5):
""" Keras implementation of the Deep Convolutional Network as described in
Schirrmeister et. al. (2017), Human Brain Mapping.
This implementation assumes the input is a 2-second EEG signal sampled at
128Hz, as opposed to signals sampled at 250Hz as described in the original
paper. We also perform temporal convolutions of length (1, 5) as opposed
to (1, 10) due to this sampling rate difference.
Note that we use the max_norm constraint on all convolutional layers, as
well as the classification layer. We also change the defaults for the
BatchNormalization layer. We used this based on a personal communication
with the original authors.
ours original paper
pool_size 1, 2 1, 3
strides 1, 2 1, 3
conv filters 1, 5 1, 10
Note that this implementation has not been verified by the original
authors.
"""
# start the model
input_main = Input((1, Chans, Samples))
block1 = Conv2D(25, (1, 5),
input_shape=(1, Chans, Samples),
kernel_constraint=max_norm(2., axis=(0, 1, 2)))(input_main)
block1 = Conv2D(25, (Chans, 1),
kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block1)
block1 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block1)
block1 = Activation('elu')(block1)
block1 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block1)
block1 = Dropout(dropoutRate)(block1)
block2 = Conv2D(50, (1, 5),
kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block1)
block2 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block2)
block2 = Activation('elu')(block2)
block2 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block2)
block2 = Dropout(dropoutRate)(block2)
block3 = Conv2D(100, (1, 5),
kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block2)
block3 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block3)
block3 = Activation('elu')(block3)
block3 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block3)
block3 = Dropout(dropoutRate)(block3)
block4 = Conv2D(200, (1, 5),
kernel_constraint=max_norm(2., axis=(0, 1, 2)))(block3)
block4 = BatchNormalization(axis=1, epsilon=1e-05, momentum=0.1)(block4)
block4 = Activation('elu')(block4)
block4 = MaxPooling2D(pool_size=(1, 2), strides=(1, 2))(block4)
block4 = Dropout(dropoutRate)(block4)
flatten = Flatten()(block4)
dense = Dense(nb_classes, kernel_constraint=max_norm(0.5))(flatten)
softmax = Activation('softmax')(dense)
return Model(inputs=input_main, outputs=softmax)
def main():
parser = argparse.ArgumentParser(description='Tensorflow MNIST Example')
parser.add_argument('--batch-size', type=int, default=100, metavar='N',
help='input batch size for training (default: 100)')
parser.add_argument('--epochs', type=int, default=10, metavar='N',
help='number of epochs to train (default: 10)')
parser.add_argument('--lr', type=float, default=0.01, metavar='LR',
help='learning rate (default: 0.01)')
parser.add_argument('--no-cuda', action='store_true', default=False,
help='disables CUDA training')
args = parser.parse_args()
print(args)
use_cuda = not args.no_cuda
num_classes = 10
# input image dimensions
img_rows, img_cols = 28, 28
# the data, shuffled and split between train and test sets
(x_train, y_train), (x_test, y_test) = mnist.load_data(path=str(PurePath(data_dir, "mnist.npz")))
if K.image_data_format() == 'channels_first':
x_train = x_train.reshape(x_train.shape[0], 1, img_rows, img_cols)
x_test = x_test.reshape(x_test.shape[0], 1, img_rows, img_cols)
input_shape = (1, img_rows, img_cols)
else:
x_train = x_train.reshape(x_train.shape[0], img_rows, img_cols, 1)
x_test = x_test.reshape(x_test.shape[0], img_rows, img_cols, 1)
input_shape = (img_rows, img_cols, 1)
x_train = x_train.astype('float32')
x_test = x_test.astype('float32')
x_train /= 255
x_test /= 255
print('x_train shape:', x_train.shape)
print(x_train.shape[0], 'train samples')
print(x_test.shape[0], 'test samples')
# convert class vectors to binary class matrices
y_train = tf.keras.utils.to_categorical(y_train, num_classes)
y_test = tf.keras.utils.to_categorical(y_test, num_classes)
cp_callback = MyCallback.get_cp_callback(checkpoint_dir)
mq_callback = MyCallback.get_mq_callback()
with strategy.scope():
model = Sequential()
model.add(Conv2D(32, kernel_size=(3, 3),
activation='relu',
input_shape=input_shape))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(128, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(num_classes, activation='softmax'))
model.compile(loss=tf.keras.losses.categorical_crossentropy,
optimizer=tf.keras.optimizers.Adadelta(lr=args.lr),
metrics=['accuracy'])
start_time = time.time()
model.fit(x_train, y_train,
batch_size=args.batch_size,
epochs=args.epochs,
verbose=1,
validation_data=(x_test, y_test),
callbacks=[cp_callback, mq_callback])
duration = (time.time() - start_time) / 60
print("Train finished. Time cost: %.2f minutes" % (duration))
score = model.evaluate(x_test, y_test, batch_size=args.batch_size, verbose=0)
print('Test loss:', score[0])
print('Test accuracy:', score[1])
#CAEモデル構築
autoencoder = Sequential()
#encoder畳み込み層
autoencoder.add(
Conv2D(filters=16,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu',
padding='same',
input_shape=(28, 28, 1)))
autoencoder.add(MaxPooling2D(
pool_size=(2, 2),
#strides=1,
padding='same'))
autoencoder.add(
Conv2D(
filters=8,
kernel_size=(3, 3),
strides=(1, 1),
activation='relu',
padding='same',
))
autoencoder.add(MaxPooling2D(
pool_size=(2, 2),
#strides=1,
padding='same'))
help="dimension of model ouput")
args = parser.parse_args()
dataloader = Dataloader(args)
p = PointEmbedding(args)
p_model = p.build()
loss_func = p.custom_loss()
x1 = Input((28, 28))
x2 = Input((28, 28))
x1_r = K.reshape(x1, (-1, 28, 28, 1))
x2_r = K.reshape(x2, (-1, 28, 28, 1))
pair1 = K.concatenate([x1_r, x2_r], axis=2)
x3 = Input((28, 28))
x4 = Input((28, 28))
x3_r = K.reshape(x3, (-1, 28, 28, 1))
x4_r = K.reshape(x4, (-1, 28, 28, 1))
pair2 = K.concatenate([x3_r, x4_r], axis=2)
output = Conv2D(1, (5, 5), (2, 2))(pair1)
output = MaxPooling2D((2, 2), (1, 1))(output)
output = Conv2D(1, (5, 5), (2, 2))(output)
output = MaxPooling2D((2, 2), (1, 1))(output)
output = Flatten()(output)
output = Dense(2)(output)
print(K.square(output))
print(K.sum(K.square(output), axis=-1))
print(K.sigmoid(K.sum(K.square(output), axis=-1)))
