def google_vgg16_finetune(classes=3, size=256):
input_layer = Input(shape=(size, size, 3), name='image_input')
base_model = VGG16(weights='imagenet', include_top=False, input_tensor=input_layer)
x = Conv2D(name='squeeze', filters=256, kernel_size=(1, 1))(base_model.output) # squeeze channels
x = Flatten(name='avgpool')(x)
x = Dense(256, name='features', kernel_regularizer=regularizers.l2(0.01))(x)
x = Activation('relu')(x)
x = Dense(classes, activation='softmax', name='out')(x)
model = Model(inputs=base_model.input, outputs=x)
for layer in model.layers:
if layer.name in ['block5_conv1', 'block5_conv2', 'block5_conv3', 'features', 'out']:
layer.trainable = True
else:
layer.trainable = False
print(model.summary())
model.compile(
loss='categorical_crossentropy',
optimizer=tf.keras.optimizers.RMSprop(lr=1e-4),
metrics=['accuracy'])
return model
# but the semantics are unclear, so to be sure we use
# the loss across the entire 2-rank tensor, we reduce it
# to a single scalar with the mean function.
loss_mean = tf.reduce_mean(loss)
return loss_mean
#######################################################################
# Compile the model.
#######################################################################
optimizer = RMSprop(lr=1e-3) ### Adam / Adagrad dosent work well with RNN's
decoder_target = tf.placeholder(dtype='int32', shape=(None, None))
model_train.compile(optimizer=optimizer,
loss=sparse_cross_entropy,
target_tensors=[decoder_target])
# Callbacks
path_checkpoint = '21_checkpoint.keras'
callback_checkpoint = ModelCheckpoint(filepath=path_checkpoint,
monitor='val_loss',
verbose=1,
save_weights_only=True,
save_best_only=True)
callback_early_stopping = EarlyStopping(monitor='val_loss',
patience=3,
verbose=1)
callback_tensorboard = TensorBoard(log_dir='./21_logs/',
histogram_freq=0,
write_graph=False)
class BertModel_for_Simsent(NLUModel):
def __init__(self):
self.model=None
self.bert_model_2()
self.compile_model()
def load_bert(self,ex_name = None):
config_path = os.path.join(config.model_dir, config.bert_config)
ckpt_path = os.path.join(config.model_dir, config.bert_ckpt)
model =build_transformer_model(config_path=config_path,checkpoint_path=ckpt_path,model='bert')
if not ex_name == None:
for index in range(len(model.layers)):
layer = model.get_layer(index=index)
layer._name = '{}_{}'.format(layer._name,ex_name)
self.model = model
return model
def bert_model_2(self):
bert = self.load_bert()
seq, seg = bert.input
bert_out = bert.output
bert_sent = bert_out[:, 0, :]
bert_sent_drop = Dropout(rate=config.dropout, name="bert_sent_drop")(bert_sent)
sent_tc = Dense(config.class_num,activation='softmax',name='sim_classifier')(bert_sent_drop)
self.model = Model(inputs=[seq, seg], outputs=[sent_tc])
pass
# def build_model(self):
# bert1 = self.load_bert(ex_name='sent_1')
# bert2 = self.load_bert(ex_name='sent_2')
#
# seq1,seg1 = bert1.input
# seq2,seg2 = bert2.input
#
# bert_out_1 = bert1.output
# bert_out_2 = bert2.output
#
# bert_sent_1 = bert_out_1[:,0,:]
# bert_sent_2 = bert_out_2[:, 0, :]
#
# bert_sent_drop_1 = Dropout(rate=config.dropout,name="bert_sent1_drop")(bert_sent_1)
# bert_sent_drop_2 = Dropout(rate=config.dropout, name="bert_sent2_drop")(bert_sent_2)
#
# bert_sent_merge = concatenate([bert_sent_drop_1,bert_sent_drop_2], axis=1)
# bert_sent_merge = Dropout(rate=config.dropout, name="bert_sent_merge_drop")(bert_sent_merge)
#
# fc = Dense(300,activation='relu',name='hidden_sim')(bert_sent_merge)
#
# output = Dense(config.class_num,activation='softmax',name='sim_classifier')(fc)
#
# self.model = Model(inputs=[seq1,seg1,seq2,seg2],outputs=[output])
def compile_model(self):
opt = tf.keras.optimizers.Adam(lr=config.learning_rate)
loss = {
'sim_classifier':'sparse_categorical_crossentropy'
}
loss_weight = {'sim_classifier':1.0}
metrics = {'sim_classifier':'acc'}
self.model.compile(optimizer=opt,loss=loss,metrics=metrics,loss_weights=loss_weight)
def fit(self,X,Y,valid_data=None,epochs=6,batch_size=32):
self.model.fit(X,Y,validation_data=valid_data,epochs=epochs,batch_size=batch_size)
def save(self,model_path,model_name):
self.model.save(os.path.join(model_path,'{}.h5'.format(model_name)))
def define_nmt(hidden_size, batch_size, en_timesteps, en_vsize, sp_timesteps, sp_vsize):
""" Defining a NMT model """
# Define an input sequence and process it.
if batch_size:
encoder_inputs = Input(batch_shape=(batch_size, en_timesteps, en_vsize), name='encoder_inputs')
decoder_inputs = Input(batch_shape=(batch_size, sp_timesteps - 1, sp_vsize), name='decoder_inputs')
else:
encoder_inputs = Input(shape=(en_timesteps, en_vsize), name='encoder_inputs')
decoder_inputs = Input(shape=(sp_timesteps - 1, sp_vsize), name='decoder_inputs')
# Encoder GRU
encoder_gru = GRU(hidden_size, return_sequences=True, return_state=True, name='encoder_gru')
encoder_out, encoder_state = encoder_gru(encoder_inputs)
# Set up the decoder GRU, using `encoder_states` as initial state.
decoder_gru = GRU(hidden_size, return_sequences=True, return_state=True, name='decoder_gru')
decoder_out, decoder_state = decoder_gru(decoder_inputs, initial_state=encoder_state)
# Attention layer
attn_layer = AttentionLayer(name='attention_layer')
attn_out, attn_states = attn_layer([encoder_out, decoder_out])
# Concat attention input and decoder GRU output
decoder_concat_input = Concatenate(axis=-1, name='concat_layer')([decoder_out, attn_out])
# Dense layer
dense = Dense(sp_vsize, activation='softmax', name='softmax_layer')
dense_time = TimeDistributed(dense, name='time_distributed_layer')
decoder_pred = dense_time(decoder_concat_input)
# Full model
full_model = Model(inputs=[encoder_inputs, decoder_inputs], outputs=decoder_pred)
full_model.compile(optimizer='adam', loss='categorical_crossentropy', metrics = ['accuracy'])
full_model.summary()
""" Inference model """
batch_size = 1
""" Encoder (Inference) model """
encoder_inf_inputs = Input(batch_shape=(batch_size, en_timesteps, en_vsize), name='encoder_inf_inputs')
encoder_inf_out, encoder_inf_state = encoder_gru(encoder_inf_inputs)
encoder_model = Model(inputs=encoder_inf_inputs, outputs=[encoder_inf_out, encoder_inf_state])
""" Decoder (Inference) model """
decoder_inf_inputs = Input(batch_shape=(batch_size, 1, sp_vsize), name='decoder_word_inputs')
encoder_inf_states = Input(batch_shape=(batch_size, en_timesteps, hidden_size), name='encoder_inf_states')
decoder_init_state = Input(batch_shape=(batch_size, hidden_size), name='decoder_init')
decoder_inf_out, decoder_inf_state = decoder_gru(decoder_inf_inputs, initial_state=decoder_init_state)
attn_inf_out, attn_inf_states = attn_layer([encoder_inf_states, decoder_inf_out])
decoder_inf_concat = Concatenate(axis=-1, name='concat')([decoder_inf_out, attn_inf_out])
decoder_inf_pred = TimeDistributed(dense)(decoder_inf_concat)
decoder_model = Model(inputs=[encoder_inf_states, decoder_init_state, decoder_inf_inputs],
outputs=[decoder_inf_pred, attn_inf_states, decoder_inf_state])
return full_model, encoder_model, decoder_model
inp = Input(shape=img_shape_full)
model = InceptionResNetV2(weights='imagenet',
include_top=False,
input_shape=img_shape_full,
input_tensor=inp)
# Anadir capa para nuestro numero de clases
x = model.output
x = GlobalAveragePooling2D()(x)
predictions = Dense(num_classes, activation='softmax')(x)
model = Model(inputs=model.input, outputs=predictions)
# TOTAL CAPAS = 782
LAYERS_TO_FREEZE = 700
for layer in model.layers[:LAYERS_TO_FREEZE]:
layer.trainable = False
model.compile(optimizer="adam",
loss='categorical_crossentropy',
metrics=['accuracy'])
model.fit(images_train,
labels_train,
batch_size=128,
epochs=1,
verbose=1,
validation_split=0.1)
score = model.evaluate(images_test, labels_test, verbose=0)
print('Testing set accuracy:', score[1])
def main(args):
dataset = args.dataset
data_type = args.data_type
# data dir, image size and batch size
DATA_DIR = 'data'
TRAIN_DIR = os.path.join(DATA_DIR, 'train')
VALID_DIR = os.path.join(DATA_DIR, 'valid')
SIZE = (224, 224)
BATCH_SIZE = 2
# remove files
try:
shutil.rmtree(DATA_DIR)
except:
pass
train_ratio = 0.8 # 80% data for training, the rest for testing
# get the list of filenames and corresponding list of labels for training et validation
train_filenames = []
train_labels = []
val_filenames = []
val_labels = []
# read files into label and frame lists
with open('../data/labels/' + dataset + '_' + data_type +
'_label.csv') as f:
frames_labels = [(line.strip().split(',')[0],
line.strip().split(',')[1]) for line in f]
# re-organize data by labels
file_dir = '../data/' + dataset + '/' + data_type + '/jpg/'
file_format = '.jpeg'
dict_frame = {
} # key: label value, value: a list of indice in the original file
for fr_lb in frames_labels:
fr, lb = fr_lb
if (lb not in dict_frame):
dict_frame[lb] = []
dict_frame[lb].append(file_dir + fr + file_format)
random.seed() # using current time as the seed
# generate filenames and labels for training and validation dataset
for lb in dict_frame:
# pick random indices for training data for lb in dict_frame
train_index = random.sample(range(0, len(dict_frame[lb])),
int(train_ratio * len(dict_frame[lb])))
for index in range(len(dict_frame[lb])):
# training data
if (index in train_index):
train_filenames.append(dict_frame[lb][index])
train_labels.append(int(lb) - 1)
# validation data
else:
val_filenames.append(dict_frame[lb][index])
val_labels.append(int(lb) - 1)
assert set(train_labels) == set(
val_labels), "Train and val labels don't correspond:\n{}\n{}".format(
set(train_labels), set(val_labels))
# create new dir data/train/label_x and data/valid/label_x
for label in set(train_labels):
os.makedirs(os.path.join(TRAIN_DIR, str(label)), exist_ok=True)
os.makedirs(os.path.join(VALID_DIR, str(label)), exist_ok=True)
# copy files
for tr_file, label in zip(train_filenames, train_labels):
shutil.copy2(tr_file, os.path.join(TRAIN_DIR, str(label)))
for val_file, label in zip(val_filenames, val_labels):
shutil.copy2(val_file, os.path.join(VALID_DIR, str(label)))
# train models
num_train_samples = sum([len(files) for r, d, files in os.walk(TRAIN_DIR)])
num_valid_samples = sum([len(files) for r, d, files in os.walk(VALID_DIR)])
num_train_steps = math.floor(num_train_samples / BATCH_SIZE)
num_valid_steps = math.floor(num_valid_samples / BATCH_SIZE)
gen = image.ImageDataGenerator()
val_gen = image.ImageDataGenerator(horizontal_flip=True,
vertical_flip=True)
batches = gen.flow_from_directory(TRAIN_DIR,
target_size=SIZE,
class_mode='categorical',
shuffle=True,
batch_size=BATCH_SIZE)
val_batches = val_gen.flow_from_directory(VALID_DIR,
target_size=SIZE,
class_mode='categorical',
shuffle=True,
batch_size=BATCH_SIZE)
model = ResNet50()
classes = list(iter(batches.class_indices))
model.layers.pop()
for layer in model.layers:
layer.trainable = False
last = model.layers[-1].output
x = Dense(len(classes), activation="softmax")(last)
finetuned_model = Model(model.input, x)
finetuned_model.compile(optimizer=Adam(lr=0.0001),
loss='categorical_crossentropy',
metrics=['accuracy'])
for c in batches.class_indices:
classes[batches.class_indices[c]] = c
finetuned_model.classes = classes
early_stopping = EarlyStopping(patience=450)
checkpointer = ModelCheckpoint('./resnet_model/resnet_50_best.h5',
verbose=1,
save_best_only=True)
finetuned_model.fit_generator(batches,
steps_per_epoch=num_train_steps,
epochs=450,
callbacks=[early_stopping, checkpointer],
validation_data=val_batches,
validation_steps=num_valid_steps)
finetuned_model.save('./resnet_model/resnet_50_final.h5')
def UNet64(input_shape,
n_predictions=1,
lossfunction="mean_squared_error",
simpleclassification=None,
flatten_output=True,
optimizer="adam",
activation_hidden="relu",
activation_output="relu",
metrics=None):
inputs = Input(shape=input_shape)
conv01 = Conv2D(10, kernel_size=(3, 3),
padding="same")(inputs) # 10 x 64x64
conv01 = Activation(activation_hidden)(conv01)
conv01_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv01) # 10 x 32x32
print("0)", conv01_pool.shape, "10 x 32x32")
conv02 = Conv2D(20, kernel_size=(3, 3),
padding="same")(conv01_pool) # 20 x 32x32
conv02 = Activation(activation_hidden)(conv02)
conv02_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv02) # 20 x 16x16
print("1)", conv02_pool.shape, "20 x 16x16")
conv03 = Conv2D(20, kernel_size=(3, 3),
padding="same")(conv02_pool) # 20 x 16x16
conv03 = Activation(activation_hidden)(conv03)
conv03_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv03) # 20 x 8x8
print("2)", conv03_pool.shape, "20 x 8x8")
conv04 = Conv2D(20, kernel_size=(3, 3),
padding="same")(conv03_pool) # 20 x 8x8
conv04 = Activation(activation_hidden)(conv04)
conv04_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv04) # 20 x 4x4
print("3)", conv04_pool.shape, "20 x 4x4")
### UPSAMPLING:
up04 = UpSampling2D((2, 2))(conv04_pool) # 20 x 8x8
up04 = concatenate([conv04, up04], axis=3) # 20+20 x 8x8
print("4)", up04.shape, "40 x 8x8")
up03 = UpSampling2D((2, 2))(up04) # 40 x 16x16
up03 = concatenate([conv03, up03], axis=3) # 20+40 x 16x16
print("5)", up03.shape, "60 x 16x16")
up02 = UpSampling2D((2, 2))(up03) # 60 x 32x32
up02 = concatenate([conv02, up02], axis=3) # 20+60 x 32x32
print("6)", up02.shape, "80 x 32x32")
up01 = UpSampling2D((2, 2))(up02) # 80 x 64x64
up01 = concatenate([conv01, up01], axis=3) # 10+80 x 64x64
print("7)", up01.shape, "90 x 64x64")
output = Conv2D(n_predictions, (1, 1),
activation=activation_output)(up01) # 1 x 64x64
print("8)", output.shape, "{} x 64x64".format(n_predictions))
if flatten_output:
output = Flatten()(output)
print("output flattened to {}".format(output.shape))
if simpleclassification is not None:
output = Dense(simpleclassification, activation='softmax')(output)
print(
"9)", output.shape,
"zur Klassifikation von {} Klassen (mit softmax)".format(
simpleclassification))
model = Model(inputs=inputs, outputs=output)
if metrics is not None:
model.compile(loss=lossfunction, optimizer=optimizer, metrics=metrics)
else:
model.compile(loss=lossfunction, optimizer=optimizer)
return model
def build_autoencoder(self, param):
autoencoder = None
input_img = Input(shape=(param.get('image_size'),
param.get('image_size'),
param.get('image_channels')),
name='input')
x = Conv2D(256,
(param.get('cae_conv_size'), param.get('cae_conv_size')),
activation='relu',
padding='same')(input_img) # tanh?
x = MaxPooling2D(
(param.get('cae_max_pool_size'), param.get('cae_max_pool_size')),
padding='same')(x)
x = Conv2D(128,
(param.get('cae_conv_size'), param.get('cae_conv_size')),
activation='relu',
padding='same')(x)
x = MaxPooling2D(
(param.get('cae_max_pool_size'), param.get('cae_max_pool_size')),
padding='same')(x)
x = Conv2D(128,
(param.get('cae_conv_size'), param.get('cae_conv_size')),
activation='relu',
padding='same')(x)
x = MaxPooling2D(
(param.get('cae_max_pool_size'), param.get('cae_max_pool_size')),
padding='same')(x)
x = Flatten()(x)
encoded = Dense(param.get('code_size'), name='encoded')(x)
print('encoded shape ', encoded.shape)
ims = 8
first = True
x = Dense(int(ims * ims), activation='relu')(encoded)
x = Reshape(target_shape=(ims, ims, 1))(x) # -12
while ims != param.get('image_size'):
x = Conv2D(
int(ims * ims / 2),
(param.get('cae_conv_size'), param.get('cae_conv_size')),
activation='relu',
padding='same')(x)
x = UpSampling2D((param.get('cae_max_pool_size'),
param.get('cae_max_pool_size')))(x)
ims = ims * param.get('cae_max_pool_size')
decoded = Conv2D(
param.get('image_channels'),
(param.get('cae_conv_size'), param.get('cae_conv_size')),
activation='sigmoid',
padding='same',
name='decoded')(x)
print('decoded shape ', decoded.shape)
autoencoder = Model(input_img, decoded)
autoencoder.compile(optimizer='adam', loss='mean_squared_error')
# Create a separate encoder model
encoder = Model(input_img, encoded)
encoder.compile(optimizer='adam', loss='mean_squared_error')
encoder.summary()
# Create a separate decoder model
decoder_inp = Input(shape=(param.get('code_size'), ))
# decoder_inp = Input(shape=encoded.output_shape)
enc_layer_idx = utils.getLayerIndexByName(autoencoder, 'encoded')
print('encoder layer idx ', enc_layer_idx)
decoder_layer = autoencoder.layers[enc_layer_idx + 1](decoder_inp)
for i in range(enc_layer_idx + 2, len(autoencoder.layers)):
decoder_layer = autoencoder.layers[i](decoder_layer)
decoder = Model(decoder_inp, decoder_layer)
decoder.compile(optimizer='adam', loss='mean_squared_error')
decoder.summary()
return autoencoder, encoder, decoder
def init_model(self, input_shape, num_classes, **kwargs):
layers = 5
filters_size = [64, 128, 256, 512, 512]
kernel_size = (3, 3)
pool_size = [(2, 2), (2, 2), (2, 2), (4, 1), (4, 1)]
freq_axis = 2
channel_axis = 3
channel_size = 128
min_size = min(input_shape[:2])
melgram_input = Input(shape=input_shape)
# x = ZeroPadding2D(padding=(0, 37))(melgram_input)
x = Reshape((input_shape[0], input_shape[1], 1))(melgram_input)
x = BatchNormalization(axis=freq_axis, name='bn_0_freq')(x)
# Conv block 1
x = Convolution2D(filters=filters_size[0],
kernel_size=kernel_size,
padding='same',
name='conv1')(x)
x = ELU()(x)
x = BatchNormalization(axis=channel_axis, name='bn1')(x)
x = MaxPooling2D(pool_size=pool_size[0],
strides=pool_size[0],
name='pool1')(x)
x = Dropout(0.1, name='dropout1')(x)
min_size = min_size // pool_size[0][0]
for layer in range(1, layers):
min_size = min_size // pool_size[layer][0]
if min_size < 1:
break
x = Convolution2D(filters=filters_size[layer],
kernel_size=kernel_size,
padding='same',
name=f'conv{layer + 1}')(x)
x = ELU()(x)
x = BatchNormalization(axis=channel_axis, name=f'bn{layer + 1}')(x)
x = MaxPooling2D(pool_size=pool_size[layer],
strides=pool_size[layer],
name=f'pool{layer + 1}')(x)
x = Dropout(0.1, name=f'dropout{layer + 1}')(x)
x = Reshape((-1, channel_size))(x)
gru_units = 32
if num_classes > 32:
gru_units = int(num_classes * 1.5)
# GRU block 1, 2, output
x = CuDNNGRU(gru_units, return_sequences=True, name='gru1')(x)
x = CuDNNGRU(gru_units, return_sequences=False, name='gru2')(x)
x = Dropout(0.3)(x)
outputs = Dense(num_classes, activation='softmax', name='output')(x)
model = TFModel(inputs=melgram_input, outputs=outputs)
optimizer = optimizers.Adam(
# learning_rate=1e-3,
lr=1e-3,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-08,
decay=1e-4,
amsgrad=True)
model.compile(optimizer=optimizer,
loss="sparse_categorical_crossentropy",
metrics=['accuracy'])
model.summary()
self._model = model
self.is_init = True
# negative_context_product = Dense(1, activation = "sigmoid")(negative_context_product)
boost = 1
import sys
if len(sys.argv) > 5:
boost = float(sys.argv[5])
if boost > 1:
negative_context_product = Lambda(lambda x: x * boost)(
negative_context_product)
negative_context_product = Lambda(lambda x: tf.math.sigmoid(x))(
negative_context_product)
# The dot products are outputted
model = Model(inputs=[word_index, context, negative_samples],
outputs=[word_context_product, negative_context_product])
# binary crossentropy is applied on the output
model.compile(optimizer='rmsprop', loss='binary_crossentropy')
print(model.summary())
plot_model(model, to_file='model.png')
print(V_gen.getStepsPerEpoch(sentences, batchSize=1))
# model.fit_generator(V_gen.pretraining_batch_generator(sentences, vocabulary, reverse_vocabulary), samples_per_epoch=G.train_words, nb_epoch=1)
test = next(
V_gen.pretraining_batch_generator(sentences, vocabulary,
reverse_vocabulary))
model.fit_generator(V_gen.pretraining_batch_generator(sentences, vocabulary,
reverse_vocabulary),
epochs=1,
steps_per_epoch=V_gen.getStepsPerEpoch(sentences,
batchSize=1))
# Save the trained embedding
# outputs = [layer.output for layer in model.layers]
# merge feature extractors
merge = Concatenate()([flat1, flat2, flat3])
# interpretation layer
hidden1 = Dense(512, activation='relu')(merge)
# prediction output
hidden2 = Dense(256, activation='relu')(hidden1)
output = Dense(2, activation='softmax')(hidden2)
model = Model(inputs=[input1, input2, input3], outputs=output)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=SGD(lr=0.001),
metrics=['accuracy'])
NAME = 'Late Merging'
# filepathdest_incep = "/content/gdrive/My Drive/Colab Notebooks/Results/BaseCNN.hdf5"
# callback_setting = [ModelCheckpoint(filepath=filepathdest_incep, verbose=1, monitor='val_loss', mode='min', save_best_only=True)]
# log_dir = "logs/fit/" + NAME +' ' + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
# tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1, write_images=False)
history = model.fit_generator(three_inp,
steps_per_epoch=len(X_train1) / 50,
epochs=650,
verbose=1,
def MixModel(input_size=INPUT_SIZE, kernel_size=KERNEL_SIZE,
activation=ACTIVATION,
padding=PADDING,
strides=STRIDES,
kernel_initializer=KERNEL_INITIALIZER,
pool_size=POOL_SIZE,
model_depth=3,
metrics=dice):
inputs = tf.keras.Input(input_size, name="inputs")
layer_list = list()
conv2 = None
current_filters = 32
# down sampling
for depth in range(model_depth):
if depth == 0:
inputs2 = Conv2D(64, 3, padding="same", activation="relu", kernel_initializer="he_normal")(inputs)
continue
# resnet block
if depth > 1:
# cut = pol1
current_filters = current_filters * (2 * depth)
# if depth >1 and depth%2 == 0:
# cut2 = pol1
# print("depth and num_filters:",(depth,current_filters))
if conv2 != None:
conv1 = ConvBlock(pol1,
num_filters=current_filters,
kernel_size=kernel_size,
activation=activation,
padding=padding,
strides=strides,
kernel_initializer=kernel_initializer,
BN=True)
else:
conv1 = ConvBlock(inputs2,
num_filters=current_filters,
kernel_size=kernel_size,
activation=activation,
padding=padding,
strides=strides,
kernel_initializer=kernel_initializer,
BN=True)
# pol1 = MaxPooling2D(pool_size=POOL_SIZE)(conv1)
# current_filters = current_filters * (depth**2)
conv2 = ConvBlock(conv1,
num_filters=current_filters * 2,
kernel_size=kernel_size,
activation=activation,
padding=padding,
strides=strides,
kernel_initializer=kernel_initializer,
BN=True)
# print("conv1:",conv1.shape)
# print("conv2:", conv2.shape)
if depth == model_depth - 1:
conv2 = tf.keras.layers.Dropout(0.5)(conv2)
pol1 = MaxPooling2D(pool_size=POOL_SIZE)(conv2)
# print("polshape:",pol1.shape)
layer_list.append([conv1, conv2, pol1])
# print(layer_list)
current_filters = pol1.shape[3]
conv3 = Conv2D(1024, 3, padding="same", kernel_initializer="he_normal", activation="relu")(pol1)
pol2 = MaxPooling2D(pool_size=POOL_SIZE)(conv3)
conv4 = Conv2D(1024, 3, padding="same", kernel_initializer="he_normal", activation="relu")(pol2)
up1 = UpSampling2D(size=POOL_SIZE)(conv4)
conv5 = Conv2D(512, 3, padding="same", kernel_initializer="he_normal", activation="relu")(up1)
# upsampling
for depth in range(model_depth):
if depth == 0:
continue
if depth == 1:
up1 = UpSampling2D(size=POOL_SIZE)(conv5)
if depth > 1:
current_filters = int(current_filters / (2 * depth))
up1 = UpSampling2D(size=POOL_SIZE)(up_conv2)
# print("up1shape:",up1.shape)
# print("num_filters:",(current_filters,depth))
up_conv1 = upConvBlock(up1,
num_filters=current_filters,
kernel_size=kernel_size,
activation=activation,
padding=padding,
strides=strides,
kernel_initializer=kernel_initializer,
BN=True)
# print(layer_list)
# print("compare:",(up_conv1.shape,layer_list[model_depth-depth-1][1].shape))
merge = tf.keras.layers.concatenate([up_conv1, layer_list[model_depth - depth - 1][0]], axis=3)
up_conv2 = upConvBlock(merge,
num_filters=current_filters,
kernel_size=kernel_size,
activation=activation,
padding=padding,
strides=strides,
kernel_initializer=kernel_initializer,
BN=True)
# if depth>1:
# up_conv2 += cut
# if depth>1 and cut2 != None:
# conv2 += cut2
# cut2 = None
up_conv2 = Conv2D(64, 3, padding="same", kernel_initializer="he_normal", activation="relu")(up_conv2)
up_conv2 = Conv2D(3, 3, padding="same", kernel_initializer="he_normal", activation="relu")(up_conv2)
model = Model(inputs, up_conv2)
if not isinstance(metrics, list):
metrics = [metrics]
# label_wise_dice_metrics = [get_label_dice_coefficient_function(index) for index in range(BATCH_SIZE)]
# if metrics:
# metrics = metrics + label_wise_dice_metrics
# else:
# metrics = label_wise_dice_metrics
# with tf.device('/cpu:0'):
# parallel_model = multi_gpu_model(model, gpus=2)
# model.compile(optimizer="adam",loss=dice_coefficient_loss, metrics=metrics)
model.compile(optimizer="adam", loss=dice_loss, metrics=[dice])
# model.summary()
return model
predictions = (Dense(6,
activation="linear",
name="predictions",
input_shape=(10, )))(input_next)
# Use the Adam method for training the network.
# We want to find the best learning-rate for the Adam method.
optimizer = Adam(lr=1e-4)
model = Model(inputs=[input_first], outputs=predictions)
homepath = os.environ["HOME"]
path_best_model = '{}/10_17_tvweights_LSTM_Regression_Model_SAIL_SPEECH.keras'.format(
homepath)
# model = Model(inputs=[input_first], outputs=predictions)
model = load_model(path_best_model)
# In Keras we need to compile the model so it can be trained.
model.compile(optimizer=optimizer, loss='mean_squared_error', metrics=['mse'])
mfcc = mfccsList[0]
track = trackList[0]
mfccs = (np.load(mfcc))
sixDistances = np.load(track)
mfcc_array = []
sixDistances_array = []
path_stdscaler = '{}/10_17_tvweight_StandardScaler.pkl'.format(homepath)
path_mmscaler = '{}/10_17_tvweight_MinMaxScaler.pkl'.format(homepath)
fitter = joblib.load(path_stdscaler)
scaler = joblib.load(path_mmscaler)
mfccs = fitter.fit_transform(mfccs)
def __init__(self):
self.HOPS = 5
self.DATASET = 'twitter' # 'restaurant', 'laptop'
self.POLARITIES_DIM = 3
self.EMBEDDING_DIM = 200
self.LEARNING_RATE = 0.01
self.LSTM_PARAMS = {
'units':
200,
'activation':
'tanh',
'recurrent_activation':
'sigmoid',
'kernel_initializer':
initializers.RandomUniform(minval=-0.003, maxval=0.003),
'recurrent_initializer':
initializers.RandomUniform(minval=-0.003, maxval=0.003),
'bias_initializer':
initializers.RandomUniform(minval=-0.003, maxval=0.003),
'kernel_regularizer':
regularizers.l2(0.001),
'recurrent_regularizer':
regularizers.l2(0.001),
'bias_regularizer':
regularizers.l2(0.001),
'dropout':
0,
'recurrent_dropout':
0,
}
self.MAX_SEQUENCE_LENGTH = 40
self.MAX_ASPECT_LENGTH = 2
self.ITERATION = 500
self.BATCH_SIZE = 200
self.texts_raw_indices, self.texts_left_indices, self.aspects_indices, self.texts_right_indices, \
self.polarities_matrix, \
self.embedding_matrix, \
self.tokenizer = \
read_dataset(type=self.DATASET,
mode='train',
embedding_dim=self.EMBEDDING_DIM,
max_seq_len=self.MAX_SEQUENCE_LENGTH, max_aspect_len=self.MAX_ASPECT_LENGTH)
if os.path.exists('dmn_saved_model.h5'):
print('loading saved model...')
self.model = load_model('dmn_saved_model.h5')
else:
print('Build model...')
inputs_sentence = Input(shape=(self.MAX_SEQUENCE_LENGTH * 2 +
self.MAX_ASPECT_LENGTH, ),
name='inputs_sentence')
inputs_aspect = Input(shape=(self.MAX_ASPECT_LENGTH, ),
name='inputs_aspect')
memory = Embedding(input_dim=len(self.tokenizer.word_index) + 1,
output_dim=self.EMBEDDING_DIM,
input_length=self.MAX_SEQUENCE_LENGTH * 2 +
self.MAX_ASPECT_LENGTH,
weights=[self.embedding_matrix],
trainable=False,
name='sentence_embedding')(inputs_sentence)
memory = Lambda(self.locationed_memory,
name='locationed_memory')(memory)
aspect = Embedding(input_dim=len(self.tokenizer.word_index) + 1,
output_dim=self.EMBEDDING_DIM,
input_length=self.MAX_ASPECT_LENGTH,
weights=[self.embedding_matrix],
trainable=False,
name='aspect_embedding')(inputs_aspect)
x = Lambda(lambda xin: K.mean(xin, axis=1),
name='aspect_mean')(aspect)
SharedAttention = Attention(name='shared_attention')
for i in range(self.HOPS):
x = SharedAttention((memory, x))
x = Dense(self.POLARITIES_DIM)(x)
predictions = Activation('softmax')(x)
model = Model(inputs=[inputs_sentence, inputs_aspect],
outputs=predictions)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(lr=self.LEARNING_RATE),
metrics=['acc'])
# plot_model(model, to_file='model.png')
self.model = model
class HybridCNN:
def __init__(self, word_embedding_map, code_embedding_map, word_tokenizer, code_tokenizer, model_config):
self.model_config = model_config
self.word_tokenizer = word_tokenizer
self.code_tokenizer = code_tokenizer
self.word_embedding_map = word_embedding_map
self.code_embedding_map = code_embedding_map
self.model = None
def create_model(self):
# Declaration for KimCNN-based word encoder
word_encoder_input = Input(shape=(self.model_config.max_word_len,), dtype='int32')
word_embedding_layer = Embedding(len(self.word_tokenizer.word_index) + 1, self.model_config.word_embedding_dim,
weights=[self.word_embedding_map], input_length=self.model_config.max_word_len,
trainable=False)
embedded_word_sequences = word_embedding_layer(word_encoder_input)
w_conv1 = Conv1D(100, 3, activation='relu', padding='same')(embedded_word_sequences)
w_pool1 = GlobalMaxPool1D()(w_conv1)
w_conv2 = Conv1D(100, 4, activation='relu', padding='same')(embedded_word_sequences)
w_pool2 = GlobalMaxPool1D()(w_conv2)
w_conv3 = Conv1D(100, 5, activation='relu', padding='same')(embedded_word_sequences)
w_pool3 = GlobalMaxPool1D()(w_conv3)
w_concat1 = Concatenate()([w_pool1, w_pool2, w_pool3])
word_encoder = Model(word_encoder_input, w_concat1)
# Declaration for KimCNN-based code encoder
code_encoder_input = Input(shape=(self.model_config.max_code_len,), dtype='int32')
code_embedding_layer = Embedding(len(self.code_tokenizer.word_index) + 1, self.model_config.code_embedding_dim,
weights=[self.code_embedding_map], input_length=self.model_config.max_code_len,
trainable=False)
embedded_code_sequences = code_embedding_layer(code_encoder_input)
c_conv1 = Conv1D(100, 3, activation='relu', padding='same')(embedded_code_sequences)
c_pool1 = GlobalMaxPool1D()(c_conv1)
c_conv2 = Conv1D(100, 4, activation='relu', padding='same')(embedded_code_sequences)
c_pool2 = GlobalMaxPool1D()(c_conv2)
c_conv3 = Conv1D(100, 5, activation='relu', padding='same')(embedded_code_sequences)
c_pool3 = GlobalMaxPool1D()(c_conv3)
c_concat1 = Concatenate()([c_pool1, c_pool2, c_pool3])
code_encoder = Model(code_encoder_input, c_concat1)
# Similarity classifier using the word and code encoders
word_input1 = Input(shape=(self.model_config.max_word_len,), dtype='int32')
word_input2 = Input(shape=(self.model_config.max_word_len,), dtype='int32')
code_input1 = Input(shape=(self.model_config.max_code_len,), dtype='int32')
code_input2 = Input(shape=(self.model_config.max_code_len,), dtype='int32')
l_concat1 = Concatenate()([word_encoder(word_input1), word_encoder(word_input2),
code_encoder(code_input1), code_encoder(code_input2)])
l_dense1 = Dense(self.model_config.hidden_dim, activation='relu')(l_concat1)
l_dropout1 = Dropout(self.model_config.dropout)(l_dense1)
l_dense2 = Dense(self.model_config.hidden_dim, activation='relu')(l_dropout1)
l_dropout2 = Dropout(self.model_config.dropout)(l_dense2)
preds = Dense(self.model_config.num_classes, activation='softmax')(l_dropout2)
self.model = Model([word_input1, word_input2, code_input1, code_input2], preds)
self.model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])
self.model.summary()
def train(self, train_xw1, train_xw2, train_xc1, train_xc2, train_y, evaluate_xw1, evaluate_xw2, evaluate_xc1,
evaluate_xc2, evaluate_y, **kwargs):
iteration = 0
if 'iteration' in kwargs:
iteration = kwargs['iteration']
early_stopping_callback = EarlyStopping(patience=self.model_config.patience, monitor='val_acc')
checkpoint_callback = ModelCheckpoint(filepath="data/checkpoints/hybrid_cnn/%s_%d.hdf5" %
(self.model_config.dataset, iteration),
monitor='val_acc', verbose=1, save_best_only=True)
self.model.fit([train_xw1, train_xw2, train_xc1, train_xc2], train_y,
validation_data=([evaluate_xw1, evaluate_xw2, evaluate_xc1, evaluate_xc2], evaluate_y),
epochs=self.model_config.epochs, batch_size=self.model_config.batch_size,
callbacks=[early_stopping_callback, checkpoint_callback])
self.model.load_weights(filepath="data/checkpoints/hybrid_cnn/%s_%d.hdf5" % (self.model_config.dataset, iteration))
def predict(self, predict_xw1, predict_xw2, predict_xc1, predict_xc2):
return self.model.predict([predict_xw1, predict_xw2, predict_xc1, predict_xc2])
def evaluate(self, evaluate_xw1, evaluate_xw2, evaluate_xc1, evaluate_xc2, evaluate_y):
predict_y = self.predict(evaluate_xw1, evaluate_xw2, evaluate_xc1, evaluate_xc2).argmax(axis=1)
evaluate_y = evaluate_y.argmax(axis=1)
return {"individual": precision_recall_fscore_support(evaluate_y, predict_y),
"micro-average": precision_recall_fscore_support(evaluate_y, predict_y, average="micro")}
def cross_val(self, data_xw1, data_xw2, data_xc1, data_xc2, data_y, n_splits=5):
skf = StratifiedKFold(n_splits, shuffle=False, random_state=157)
print("Performing cross validation (%d-fold)..." % n_splits)
iteration = 1
mean_accuracy = 0
recall_list = [0 for _ in range(self.model_config.num_classes)]
precision_list = [0 for _ in range(self.model_config.num_classes)]
for train_index, test_index in skf.split(data_xw1, data_y.argmax(axis=1)):
self.create_model()
print("Iteration %d of %d" % (iteration, n_splits))
self.train(data_xw1[train_index], data_xw2[train_index], data_xc1[train_index], data_xc2[train_index],
data_y[train_index], data_xw1[test_index], data_xw2[test_index], data_xc1[test_index],
data_xc2[test_index], data_y[test_index], iteration=iteration)
metrics = self.evaluate(data_xw1[test_index], data_xw2[test_index], data_xc1[test_index],
data_xc2[test_index], data_y[test_index])
precision_list = [x + y for x, y in zip(metrics['individual'][0], precision_list)]
recall_list = [x + y for x, y in zip(metrics['individual'][1], recall_list)]
mean_accuracy += metrics['micro-average'][0]
print("Precision, Recall, F_Score, Support")
iteration += 1
print(metrics)
print("Mean accuracy: %s Mean precision: %s, Mean recall: %s" % (mean_accuracy/n_splits,
[precision/n_splits for precision in precision_list],
[recall/n_splits for recall in recall_list]))
from tensorflow.python.keras.models import Model
from tensorflow.python.keras.layers import Dense, Input
from tensorflow.python.keras import optimizers, losses
from tensorflow.python.keras.utils import to_categorical
from modelhelpers import GradientActivationStore
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train = x_train.reshape(60000, 784).astype('float32')
x_test = x_test.reshape(10000, 784).astype('float32')
y_train_hot = to_categorical(y_train, 10)
y_test_hot = to_categorical(y_test, 10)
x_in = Input(shape=(784,))
l = Dense(1000, activation='relu')(x_in)
for i in range(2):
l = Dense(1000, activation='relu')(l)
output = Dense(10, activation='softmax')(l)
model = Model(inputs=x_in, outputs=output)
model.compile(loss=losses.categorical_crossentropy, optimizer=optimizers.SGD(lr=0.001))
cbk = GradientActivationStore(DIR='logs', filename='test', num_classes=10, record_every=1, only_weights=True)
fitting = model.fit(x=x_train[:100], y=y_train_hot[:100], batch_size=32,
epochs=3, callbacks=[cbk], validation_data=(x_test[:100], y_test_hot[:100]), verbose=1)
kernel_size=(3, 3),
padding='same',
activation='relu')(out)
out = Conv2D(filters=128, kernel_size=(3, 3), activation='relu')(out)
out = BatchNormalization()(out)
out = MaxPooling2D(pool_size=(2, 2))(out)
out = Dropout(0.5)(out)
out = Conv2D(filters=256, kernel_size=(3, 3), activation='relu')(out)
out = BatchNormalization()(out)
out = MaxPooling2D(pool_size=(2, 2))(out)
out = Flatten()(out)
out = Dropout(0.5)(out)
out = Dense(1, name='6digit', activation='sigmoid')(out)
model = Model(inputs=inp, outputs=out)
model.compile(loss='binary_crossentropy',
optimizer='adam',
metrics=['accuracy'])
model.summary()
print("Reading training data...")
traincsv = open(TRAINING_DIR + '/data/56_imitate_train_set/len_train.csv',
'r',
encoding='utf8')
train_data = np.stack([
np.array(
Image.open(TRAINING_DIR + "/data/56_imitate_train_set/" + row[0] +
".jpg")) / 255.0 for row in csv.reader(traincsv)
])
traincsv = open(TRAINING_DIR + '/data/56_imitate_train_set/len_train.csv',
'r',
encoding='utf8')
def small_densenet(self,
img_input_shape=(64, 64, 3),
blocks=[6, 12, 24, 16],
weight_decay=1e-4,
kernel_initializer='he_normal',
init_filters=None,
reduction=None,
growth_rate=None,
init_stride=None):
img_input = Input(shape=(img_input_shape))
# x = layers.Conv2D(init_filters, 3, strides=1, use_bias=False,
# kernel_initializer = kernel_initializer,
# kernel_regularizer = l2(weight_decay),
# name='conv1/conv')(img_input)
x = layers.ZeroPadding2D(padding=((3, 3), (3, 3)))(img_input)
x = layers.Conv2D(init_filters,
3,
strides=init_stride,
use_bias=False,
kernel_initializer=kernel_initializer,
kernel_regularizer=l2(weight_decay),
name='conv1/conv')(x)
x = layers.BatchNormalization(axis=3,
epsilon=1.001e-5,
name='conv1/bn')(x)
x = layers.Activation('relu', name='conv1/relu')(x)
x = layers.ZeroPadding2D(padding=((1, 1), (1, 1)))(x)
x = layers.AveragePooling2D(3, strides=2, name='pool1')(x)
for i, block in enumerate(blocks):
scope_num_str = str(i + 2)
x = self.dense_block(x,
block,
name='conv' + scope_num_str,
growth_rate=growth_rate,
weight_decay=weight_decay,
kernel_initializer=kernel_initializer)
if i != len(blocks) - 1:
x = self.transition_block(
x,
reduction,
name='pool' + scope_num_str,
weight_decay=weight_decay,
kernel_initializer=kernel_initializer)
x = layers.BatchNormalization(axis=3, epsilon=1.001e-5, name='bn')(x)
x = layers.Activation('relu', name='relu')(x)
x = layers.GlobalAveragePooling2D(name='avg_pool')(x)
# x = Lambda(lambda x: x, name = 'densenet_features')(x)
# x = self.full_connect_layer(x, self.hidden_dim, weight_decay = weight_decay, kernel_initializer = kernel_initializer)
x = layers.Dense(
self.cat_max,
activation='softmax',
kernel_initializer=kernel_initializer,
# kernel_regularizer = l2(weight_decay),
name='fc')(x)
model = Model(img_input, x)
# print (model.summary())
model.compile(optimizer=Adam(lr=self.lr),
loss='categorical_crossentropy',
metrics=['categorical_accuracy'])
return model
def UNet64_2x2core_large(input_shape):
"""wie UNet64_out_expansed, aber downsampling bis 2x2"""
inputs = Input(shape=input_shape)
conv01 = Conv2D(10, kernel_size=(3, 3),
padding="same")(inputs) # 10 x 64x64
conv01 = Activation('relu')(conv01)
conv01_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv01) # 10 x 32x32
print("0)", conv01_pool.shape, "10 x 32x32")
conv02 = Conv2D(20, kernel_size=(3, 3),
padding="same")(conv01_pool) # 20 x 32x32
conv02 = Activation('relu')(conv02)
conv02_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv02) # 20 x 16x16
print("1)", conv02_pool.shape, "20 x 16x16")
conv03 = Conv2D(20, kernel_size=(3, 3),
padding="same")(conv02_pool) # 20 x 16x16
conv03 = Activation('relu')(conv03)
conv03_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv03) # 20 x 8x8
print("2)", conv03_pool.shape, "20 x 8x8")
conv04 = Conv2D(20, kernel_size=(3, 3),
padding="same")(conv03_pool) # 20 x 8x8
conv04 = Activation('relu')(conv04)
conv04_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv04) # 20 x 4x4
print("3)", conv04_pool.shape, "20 x 4x4")
conv05 = Conv2D(20, kernel_size=(3, 3),
padding="same")(conv04_pool) # 20 x 4x4
conv05 = Activation('relu')(conv05)
conv05_pool = MaxPooling2D((2, 2), strides=(2, 2))(conv05) # 20 x 2x2
print("4)", conv05_pool.shape, "20 x 2x2")
### UPSAMPLING:
up05 = UpSampling2D((2, 2))(conv05_pool) # 20 x 4x4
up05 = concatenate([conv05, up05], axis=3) # 40 x 4x4
print("4)", up05.shape, "40 x 4x4")
up04 = UpSampling2D((2, 2))(up05) # 10 x 8x8
up04 = concatenate([conv04, up04], axis=3) # 20+40 x 8x8
print("4)", up04.shape, "60 x 8x8")
up03 = UpSampling2D((2, 2))(up04) # 30 x 16x16
up03 = concatenate([conv03, up03], axis=3) # 20+60 x 16x16
print("5)", up03.shape, "80 x 16x16")
up02 = UpSampling2D((2, 2))(up03) # 80 x 32x32
up02 = concatenate([conv02, up02], axis=3) # 20+80 x 32x32
print("6)", up02.shape, "100 x 32x32")
up01 = UpSampling2D((2, 2))(up02) # 100 x 64x64
up01 = concatenate([conv01, up01], axis=3) # 10+100 x 64x64
print("7)", up01.shape, "110 x 64x64")
output = Conv2D(1, (3, 3), activation='relu',
padding="same")(up01) # 1 x 64x64
print("8)", output.shape, "1 x 64x64")
output = Flatten()(output)
model = Model(inputs=inputs, outputs=output)
model.compile(loss="mean_squared_error", optimizer='adam')
return model
def __init__(self,
inputs=None,
targets=None,
loss_func="mse",
optimizer="adam",
load_weights_from=None,
plot_to_file=None,
**kwargs):
# strictly check for inputs to be of type variable.
inputs = to_list(inputs)
if not all([is_variable(x) for x in inputs]):
raise ValueError(
'Please provide a `list` of `Variable` or `RadialBasis` objects for inputs. '
)
# prepare input tensors.
input_vars = []
for var in inputs:
input_vars += var.inputs
# check outputs if of correct type.
if targets is None:
if 'constraints' in kwargs:
targets = kwargs.get('constraints')
elif 'conditions' in kwargs:
targets = kwargs.get('conditions')
else:
if 'conditions' in kwargs or 'constraints' in kwargs:
raise TypeError(
'Inconsistent inputs: `constraints`, `conditions`, and `targets` are all equivalent keywords '
'- pass all targets as a list to `SciModel`. ')
# setup constraints.
targets = to_list(targets)
for i, y in enumerate(targets):
if not is_constraint(y):
if is_functional(y):
# Case of Data-type constraint.
targets[i] = Data(y)
elif isinstance(y, tuple) and \
len(y) == 2 and \
is_functional(y[0]) and is_functional(y[1]):
# Case of Tie-type constraint.
targets[i] = Tie(y[0], y[1])
else:
# Not recognised.
raise ValueError(
'The {}th target entry is not of type `Constraint` or `Functional` - '
'received \n ++++++ {} '.format(i, y))
# prepare network outputs.
output_vars = []
for cond in targets:
output_vars += cond().outputs
# prepare loss_functions.
if isinstance(loss_func, str):
loss_func = SciModel.loss_functions(loss_func)
elif not callable(loss_func):
raise TypeError(
'Please provide a valid loss function from ("mse", "mae") ' +
"or a callable function for input of tensor types. ")
# Initialize the Model form super class.
model = Model(inputs=input_vars, outputs=output_vars, **kwargs)
# compile the model.
model.compile(
loss=loss_func,
optimizer=optimizer,
)
# model.train_function = True
# set initial state of the model.
if load_weights_from is not None:
if os.path.exists(load_weights_from):
model.load_weights(load_weights_from)
else:
raise Warning("File not found - load_weights_from: {}".format(
load_weights_from))
# Set the variables.
self._model = model
self._inputs = inputs
self._constraints = targets
self._loss_func = loss_func
# Plot to file if requested.
if plot_to_file is not None:
plot_model(self._model, to_file=plot_to_file)
def fit(self,
learning_rate=1e-4,
epochs=5,
activation='relu',
dropout=0,
hidden_size=1024,
nb_layers=1,
include_class_weight=False,
save_augmented=False,
batch_size=20,
save_model=False,
verbose=True,
fine_tuning=False,
NB_IV3_LAYERS_TO_FREEZE=279,
use_TPU=False,
transfer_model='Inception',
min_accuracy=None,
cutoff_regularization=False,
extract_SavedModel=False):
#if we want stop training when no sufficient improvement in accuracy has been achieved
if min_accuracy is not None:
callback = EarlyStopping(monitor='categorical_accuracy',
baseline=min_accuracy)
callback = [callback]
else:
callback = None
#load the pretrained model, without the classification (top) layers
if transfer_model == 'Xception':
base_model = Xception(weights='imagenet',
include_top=False,
input_shape=(299, 299, 3))
target_size = (299, 299)
elif transfer_model == 'Inception_Resnet':
base_model = InceptionResNetV2(weights='imagenet',
include_top=False,
input_shape=(299, 299, 3))
target_size = (299, 299)
elif transfer_model == 'Resnet':
base_model = ResNet50(weights='imagenet',
include_top=False,
input_shape=(224, 224, 3))
target_size = (224, 224)
else:
base_model = InceptionV3(weights='imagenet',
include_top=False,
input_shape=(299, 299, 3))
target_size = (299, 299)
#We expect the classes to be the name of the folders in the training set
self.categories = os.listdir(TRAIN_DIR)
#Add the classification layers using Keras functional API
x = base_model.output
x = GlobalAveragePooling2D()(x)
for _ in range(nb_layers):
x = Dense(hidden_size, activation=activation)(
x) #Hidden layer for classification
if dropout > 0:
x = Dropout(rate=dropout)(x)
predictions = Dense(len(self.categories),
activation='softmax')(x) #Output layer
model = Model(inputs=base_model.input, outputs=predictions)
#Set only the top layers as trainable (if we want to do fine-tuning,
#we can train the base layers as a second step)
for layer in base_model.layers:
layer.trainable = False
#Define the optimizer and the loss, and compile the model
loss = 'categorical_crossentropy'
if use_TPU:
#if we want to try out the TPU, it looks like we currently need to use
#tensorflow optimizers...see https://stackoverflow.com/questions/52940552/valueerror-operation-utpu-140462710602256-varisinitializedop-has-been-marked
#...and https://www.youtube.com/watch?v=jgNwywYcH4w
optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate)
tpu_optimizer = tf.contrib.tpu.CrossShardOptimizer(optimizer)
model.compile(optimizer=tpu_optimizer,
loss=loss,
metrics=['categorical_accuracy'])
TPU_WORKER = 'grpc://' + os.environ['COLAB_TPU_ADDR']
model = tf.contrib.tpu.keras_to_tpu_model(
model,
strategy=tf.contrib.tpu.TPUDistributionStrategy(
tf.contrib.cluster_resolver.TPUClusterResolver(
TPU_WORKER)))
tf.logging.set_verbosity(tf.logging.INFO)
else:
optimizer = Adam(lr=learning_rate)
model.compile(optimizer=optimizer,
loss=loss,
metrics=['categorical_accuracy'])
datagen_train = ImageDataGenerator(rotation_range=180,
rescale=1. / 255,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.1,
zoom_range=[0.9, 1.5],
horizontal_flip=True,
vertical_flip=True,
fill_mode='nearest')
datagen_val = ImageDataGenerator(rescale=1. / 255)
#Save the augmented images if we want to
if save_augmented:
save_to_dir = AUGMENTED_DIR
else:
save_to_dir = None
self.generator_train = datagen_train.flow_from_directory(
directory=TRAIN_DIR,
target_size=target_size,
batch_size=batch_size,
shuffle=True,
save_to_dir=save_to_dir)
self.generator_val = datagen_val.flow_from_directory(
directory=VAL_DIR,
target_size=target_size,
batch_size=batch_size,
shuffle=False)
steps_per_epoch = self.generator_train.n / batch_size
self.val_steps_per_epoch = self.generator_val.n / batch_size
#if we want to weight the classes given the imbalanced number of images
if include_class_weight:
from sklearn.utils.class_weight import compute_class_weight
cls_train = self.generator_train.classes
class_weight = compute_class_weight(class_weight='balanced',
classes=np.unique(cls_train),
y=cls_train)
else:
class_weight = None
#Fit the model
history = model.fit_generator(
generator=self.generator_train,
epochs=epochs,
steps_per_epoch=steps_per_epoch,
verbose=verbose,
class_weight=class_weight,
validation_data=self.generator_val,
validation_steps=self.val_steps_per_epoch,
callbacks=callback)
#Fine-tune the model, if we wish so
if fine_tuning and not model.stop_training:
print('============')
print('Begin fine-tuning')
print('============')
#declare the first layers as trainable
for layer in model.layers[:NB_IV3_LAYERS_TO_FREEZE]:
layer.trainable = False
for layer in model.layers[NB_IV3_LAYERS_TO_FREEZE:]:
layer.trainable = True
model.compile(optimizer=Adam(lr=learning_rate * 0.1),
loss=loss,
metrics=['categorical_accuracy'])
#Fit the model
history = model.fit_generator(
generator=self.generator_train,
epochs=epochs,
steps_per_epoch=steps_per_epoch,
verbose=verbose,
class_weight=class_weight,
validation_data=self.generator_val,
validation_steps=self.val_steps_per_epoch)
#Evaluate the model, just to be sure
self.fitness = history.history['val_categorical_accuracy'][-1]
#Save the model
if save_model:
if not os.path.exists(parentdir + '/data/trained_models'):
os.makedirs(parentdir + '/data/trained_models')
model.save(parentdir + '/data/trained_models/trained_model.h5')
print('Model saved!')
#save model in production format
if extract_SavedModel:
export_path = "./image_classifier/1/"
with K.get_session() as sess:
tf.saved_model.simple_save(
sess,
export_path,
inputs={'input_image': model.input},
outputs={t.name: t
for t in model.outputs})
else:
self.model = model
del history
del model
def layer_test(layer_cls,
kwargs={},
input_shape=None,
input_dtype=None,
input_data=None,
expected_output=None,
expected_output_dtype=None,
fixed_batch_size=False,
supports_masking=False):
# generate input data
if input_data is None:
if not input_shape:
raise AssertionError()
if not input_dtype:
input_dtype = K.floatx()
input_data_shape = list(input_shape)
for i, e in enumerate(input_data_shape):
if e is None:
input_data_shape[i] = np.random.randint(1, 4)
input_mask = []
if all(isinstance(e, tuple) for e in input_data_shape):
input_data = []
for e in input_data_shape:
input_data.append(
(10 * np.random.random(e)).astype(input_dtype))
if supports_masking:
a = np.full(e[:2], False)
a[:, :e[1] // 2] = True
input_mask.append(a)
else:
input_data = (10 * np.random.random(input_data_shape))
input_data = input_data.astype(input_dtype)
if supports_masking:
a = np.full(input_data_shape[:2], False)
a[:, :input_data_shape[1] // 2] = True
print(a)
print(a.shape)
input_mask.append(a)
else:
if input_shape is None:
input_shape = input_data.shape
if input_dtype is None:
input_dtype = input_data.dtype
if expected_output_dtype is None:
expected_output_dtype = input_dtype
# instantiation
layer = layer_cls(**kwargs)
# test get_weights , set_weights at layer level
weights = layer.get_weights()
layer.set_weights(weights)
try:
expected_output_shape = layer.compute_output_shape(input_shape)
except Exception:
expected_output_shape = layer._compute_output_shape(input_shape)
# test in functional API
if isinstance(input_shape, list):
if fixed_batch_size:
x = [Input(batch_shape=e, dtype=input_dtype) for e in input_shape]
if supports_masking:
mask = [
Input(batch_shape=e[0:2], dtype=bool) for e in input_shape
]
else:
x = [Input(shape=e[1:], dtype=input_dtype) for e in input_shape]
if supports_masking:
mask = [Input(shape=(e[1], ), dtype=bool) for e in input_shape]
else:
if fixed_batch_size:
x = Input(batch_shape=input_shape, dtype=input_dtype)
if supports_masking:
mask = Input(batch_shape=input_shape[0:2], dtype=bool)
else:
x = Input(shape=input_shape[1:], dtype=input_dtype)
if supports_masking:
mask = Input(shape=(input_shape[1], ), dtype=bool)
if supports_masking:
y = layer(Masking()(x), mask=mask)
else:
y = layer(x)
if not (K.dtype(y) == expected_output_dtype):
raise AssertionError()
# check with the functional API
if supports_masking:
model = Model([x, mask], y)
actual_output = model.predict([input_data, input_mask[0]])
else:
model = Model(x, y)
actual_output = model.predict(input_data)
actual_output_shape = actual_output.shape
for expected_dim, actual_dim in zip(expected_output_shape,
actual_output_shape):
if expected_dim is not None:
if not (expected_dim == actual_dim):
raise AssertionError("expected_shape", expected_output_shape,
"actual_shape", actual_output_shape)
if expected_output is not None:
assert_allclose(actual_output, expected_output, rtol=1e-3)
# test serialization, weight setting at model level
model_config = model.get_config()
recovered_model = model.__class__.from_config(model_config)
if model.weights:
weights = model.get_weights()
recovered_model.set_weights(weights)
_output = recovered_model.predict(input_data)
assert_allclose(_output, actual_output, rtol=1e-3)
# test training mode (e.g. useful when the layer has a
# different behavior at training and testing time).
if has_arg(layer.call, 'training'):
model.compile('rmsprop', 'mse')
model.train_on_batch(input_data, actual_output)
# test instantiation from layer config
layer_config = layer.get_config()
layer_config['batch_input_shape'] = input_shape
layer = layer.__class__.from_config(layer_config)
# for further checks in the caller function
return actual_output
def get_model(self, num_keys):
#
encoder_input = Input(shape=(None, ), name='encoder_input')
embedding_size = 128
encoder_embedding = Embedding(input_dim=num_words,
output_dim=embedding_size,
name='encoder_embedding')
state_size = 512
encoder_gru1 = GRU(state_size, name='encoder_gru1',
return_sequences=True)
encoder_gru2 = GRU(state_size, name='encoder_gru2',
return_sequences=True)
encoder_gru3 = GRU(state_size, name='encoder_gru3',
return_sequences=False)
encoder_dense_1 = Dense(state_size,
activation='relu',
name='encoded_output_1')
encoder_dense_2 = Dense(state_size,
activation='relu',
name='encoded_output_2')
encoder_embedding = Embedding(input_dim=state_size,
output_dim=embedding_size,
name='encoded_embedding')
encoder_dense_out = Dense(num_keys,
activation='linear',
name='encoded_output_3')
def connect_encoder():
# Start the neural network with its input-layer.
net = encoder_input
# Connect the embedding-layer.
net = encoder_embedding(net)
# Connect all the GRU-layers.
net = encoder_gru1(net)
net = encoder_gru2(net)
net = encoder_gru3(net)
net = encoder_dense_1(net)
net = encoder_dense_2(net)
# This is the output of the encoder.
emdedding = encoder_embedding(net)
encoder_output = encoder_dense_out(net)
return encoder_output, emdedding
encoder_output, emdedding = connect_encoder()
f_model_train = Model(inputs=[encoder_input],
outputs=[encoder_output])
f_model_encoder = Model(inputs=[encoder_input],
outputs=[emdedding])
optimizer = RMSprop(lr=1e-3)
decoder_target = tf.placeholder(dtype='int32', shape=(None, None))
f_model_train.compile(optimizer=optimizer,
loss=self.sparse_cross_entropy,
target_tensors=[decoder_target])
return f_model_train, f_model_encoder
class Pix2Pix():
def __init__(self):
# Input shape
self.img_rows = 256
self.img_cols = 256
self.channels = 3
self.img_shape = (self.img_rows, self.img_cols, self.channels)
# Configure data loader
self.dataset_name = 'facades'
self.data_loader = DataLoader(dataset_name=self.dataset_name,
img_res=(self.img_rows, self.img_cols))
# Calculate output shape of D (PatchGAN)
patch = int(self.img_rows / 2**4)
self.disc_patch = (patch, patch, 1)
# Number of filters in the first layer of G and D
self.gf = 64
self.df = 64
optimizer = Adam(0.0002, 0.5)
# Build and compile the discriminator
self.discriminator = self.build_discriminator()
self.discriminator.compile(loss='mse',
optimizer=optimizer,
metrics=['accuracy'])
#-------------------------
# Construct Computational
# Graph of Generator
#-------------------------
# Build the generator
self.generator = self.build_generator()
# Input images and their conditioning images
img_A = Input(shape=self.img_shape)
img_B = Input(shape=self.img_shape)
# By conditioning on B generate a fake version of A
fake_A = self.generator(img_B)
# For the combined model we will only train the generator
#self.discriminator.trainable = False
# Discriminators determines validity of translated images / condition pairs
valid = self.discriminator([fake_A, img_B])
self.combined = Model(inputs=[img_A, img_B], outputs=[valid, fake_A])
self.combined.compile(loss=['mse', smoothL1],
loss_weights=[2, 100],
optimizer=optimizer)
################# Perceptual loss and L1 loss ######################
self.vggmodel = VGG19(
weights="vgg19_weights_tf_dim_ordering_tf_kernels_notop.h5",
include_top=False)
#print(vggmodel.get_layer('block4_pool'))
#print(self.combined.output[1])
#print(vggmodel.get_layer('block4_pool').output)
#lossOut = vggmodel(inputs=self.combined.output[1], output = vggmodel.get_layer('block4_pool').output)
lossOut = self.vggmodel(inputs=self.combined.output[1])
self.vggmodel.trainable = False
for l in self.vggmodel.layers:
l.trainable = False
self.vgg_combined = Model(inputs=self.combined.input, outputs=lossOut)
self.vgg_combined.compile(loss='mse',
optimizer='adam',
loss_weights=[10])
valid.trainable = False
def build_generator(self):
layer_per_block = [4, 4, 4, 4, 4, 15, 4, 4, 4, 4, 4]
tiramisu = Tiramisu(layer_per_block)
tiramisu.summary()
#d0 = Input(shape=self.img_shape)
return tiramisu
def build_discriminator(self):
def d_layer(layer_input, filters, f_size=4, bn=True):
"""Discriminator layer"""
d = Conv2D(filters, kernel_size=f_size, strides=2,
padding='same')(layer_input)
d = LeakyReLU(alpha=0.2)(d)
if bn:
d = BatchNormalization(momentum=0.8)(d)
return d
img_A = Input(shape=self.img_shape)
img_B = Input(shape=self.img_shape)
# Concatenate image and conditioning image by channels to produce input
combined_imgs = Concatenate(axis=-1)([img_A, img_B])
d1 = d_layer(combined_imgs, self.df, bn=False)
d2 = d_layer(d1, self.df * 2)
d3 = d_layer(d2, self.df * 4)
d4 = d_layer(d3, self.df * 8)
validity = Conv2D(1, kernel_size=4, strides=1, padding='same')(d4)
return Model([img_A, img_B], validity)
def train(self, epochs, batch_size=1, sample_interval=50):
start_time = datetime.datetime.now()
# Adversarial loss ground truths
valid = np.ones((batch_size, ) + self.disc_patch)
fake = np.zeros((batch_size, ) + self.disc_patch)
for epoch in range(epochs):
for batch_i, (imgs_A, imgs_B) in enumerate(
self.data_loader.load_batch(batch_size)):
# ---------------------
# Train Discriminator
# ---------------------
# Condition on B and generate a translated version
fake_A = self.generator.predict(imgs_B)
# Train the discriminators (original images = real / generated = Fake)
d_loss_real = self.discriminator.train_on_batch(
[imgs_A, imgs_B], valid)
d_loss_fake = self.discriminator.train_on_batch(
[fake_A, imgs_B], fake)
d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
# -----------------
# Train Generator
# -----------------
# Train the generators
g_loss = self.combined.train_on_batch([imgs_A, imgs_B],
[valid, imgs_A])
full_vgg = self.vggmodel.predict(imgs_A)
vgg_loss = self.vgg_combined.train_on_batch([imgs_A, imgs_B],
full_vgg)
elapsed_time = datetime.datetime.now() - start_time
# Plot the progress
print(
"[Epoch %d/%d] [Batch %d/%d] [D loss: %f, acc: %3d%%] [G loss: %f] time: %s"
% (epoch, epochs, batch_i, self.data_loader.n_batches,
d_loss[0], 100 * d_loss[1], g_loss[0], elapsed_time))
# If at save interval => save generated image samples
if batch_i % sample_interval == 0:
self.sample_images(epoch, batch_i)
self.combined.save_weights("Weights/" + str(epoch) + ".h5")
def img_to_frame(self, imgA, imgB, fakeA):
no_images = imgA.shape[0]
img_height = imgA.shape[1]
img_width = imgA.shape[2]
pad = 20
title_pad = 20
pad_top = pad + title_pad
frame = np.zeros((no_images * (img_height + pad_top),
no_images * (img_width + pad), 3))
count = 0
gen_imgs = np.concatenate([imgB, fakeA, imgA])
gen_imgs = 0.5 * gen_imgs + 0.5
titles = ['Condition', 'Generated', 'Original']
for r in range(no_images):
for c in range(no_images):
im = gen_imgs[count]
count = count + 1
y0 = r * (img_height + pad_top) + pad // 2
x0 = c * (img_width + pad) + pad // 2
# print(frame[y0:y0+img_height,x0:x0+img_width,:].shape)
frame[y0:y0 + img_height, x0:x0 + img_width, :] = im * 255
frame = cv2.putText(frame, titles[r],
(x0, y0 - title_pad // 4),
cv2.FONT_HERSHEY_COMPLEX, .5,
(255, 255, 255))
return frame
def sample_images(self, epoch, batch_i):
os.makedirs('images/%s' % self.dataset_name, exist_ok=True)
os.makedirs('images/dehazed', exist_ok=True)
os.makedirs('images/haze', exist_ok=True)
os.makedirs('images/original', exist_ok=True)
r, c = 3, 3
imgs_A, imgs_B, or_A, or_B = self.data_loader.load_data(
batch_size=3, is_testing=True)
fake_A = self.generator.predict(imgs_B)
cv2.imwrite(
"images/dehazed" + "/" + "Img:" + str(epoch) + "_" + str(batch_i) +
".jpg", (fake_A[0] * 0.5 + 0.5) * 255)
cv2.imwrite(
"images/haze" + "/" + "Img:" + str(epoch) + "_" + str(batch_i) +
".jpg", (or_B[0] * 0.5 + 0.5) * 255)
cv2.imwrite(
"images/original" + "/" + "Img:" + str(epoch) + "_" +
str(batch_i) + ".jpg", (or_A[0] * 0.5 + 0.5) * 255)
frame = self.img_to_frame(imgs_A, imgs_B, fake_A)
cv2.imwrite(
"images/" + self.dataset_name + "/" + "Img:" + str(epoch) + "_" +
str(batch_i) + ".png", frame)
color_mode="rgb",
batch_size=32,
class_mode="categorical",
shuffle=False,
seed=42)
if mode == 'training':
from tensorflow.python.keras.optimizers import Adam
from tensorflow.python.keras.losses import categorical_crossentropy
adam = Adam(lr=0.0)
metrics = ['accuracy']
model.compile(optimizer=adam,
metrics=metrics,
loss=categorical_crossentropy)
model.fit_generator(
train_generator,
validation_data=test_generator,
epochs=100,
use_multiprocessing=False,
workers=10,
callbacks=[
ModelCheckpoint(
'%s/model_{epoch:d}_loss{loss:.4f}_acc_{acc:.4f}.h5' %
folder,
monitor='val_loss',
verbose=1,
save_best_only=False,
kernel_regularizer=regularizers.l2(0.01))(x)
x = Dropout(0.4)(x)
x = Dense(units=256,
activation="relu",
kernel_regularizer=regularizers.l2(0.01))(x)
x = Dropout(0.4)(x)
x = Flatten()(x)
output = Dense(units=4, activation="softmax")(x)
model = Model(inputs=model.input, outputs=output)
# summarize
model.summary()
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy']) #optimizer=adam
image_size = 224
data_generator = ImageDataGenerator(
preprocessing_function=
preprocess_input, #Generate batches of tensor image data with real-time data augmentation.
rescale=1. /
255, #we multiply the data by the value provided (after applying all other transformations)
zoom_range=0.2
) # Float...Range for random zoom...If a float, [lower, upper] = [1-zoom_range, 1+zoom_range]
train_generator = data_generator.flow_from_directory(
"D:/PYCodes/Arrow224/train",
target_size=(image_size, image_size),
batch_size=32, #16
# model.add(tf.keras.layers.Dense(64, activation='relu'))
# model.add(tf.keras.layers.Dense(64, activation='relu'))
# model.add(tf.keras.layers.Dense(1, activation='sigmoid'))
# model.compile(loss='mean_squared_error', optimizer='adam', metrics=['binary_accuracy'])
# model.fit(X, Y, batch_size=1, nb_epoch=100, verbose=0)
inputs = Input(shape=INPUT_SHAPE)
x = extractor(inputs)
# x = extractor_new(inputs)
center_output = Dense(units=1, activation='sigmoid', name='center')(x)
model = Model(inputs=inputs, outputs=[center_output], name='CenterNet')
optimizer = Adam(lr=0.001)
model.compile(loss='mean_squared_error', optimizer=optimizer)
model.summary()
checkpoint = ModelCheckpoint('models/' + model_name + '.h5',
monitor='loss',
verbose=1,
save_best_only=True,
mode='min')
early_stopping = EarlyStopping(monitor='loss',
mode='min',
verbose=1,
patience=50)
history = model.fit_generator(generator(X, Y, batch_size),
epochs=epochs,
dropout=dropout_rate))(temporal_input_layer)
# add a dense layer
ts_output = Dense(32, activation="relu")(lstm_1)
# temporal part ends here
# and a softmax layer -- num_classes
predictions = Dense(num_classes, activation='softmax')(ts_output)
optimizer = Adam(lr=learning_rate)
# this is the model we will train
model = Model(inputs=temporal_input_layer, outputs=predictions)
model.compile(loss='categorical_crossentropy',
optimizer=optimizer,
metrics=['accuracy'])
print(model.summary())
## NN ends here
# callbacks
# tensorboard = TensorBoard(log_dir="logs/{}".format(time()))
model_name = str(config[parser_args.task]['MODEL_FOLDER']
) + '_temporal' + curr_time + '.h5'
model_checkpoint = ModelCheckpoint(model_name,
verbose=1,
monitor='val_loss',
save_best_only=True,
mode='auto')
input_img = Input(shape=(784, ))
encoding_dim = 32
encoded = Dense(encoding_dim, activation='relu')(input_img)
decoded = Dense(784, activation='sigmoid')(encoded)
autoencoder = Model(inputs=input_img, outputs=encoded)
encoder = Model(inputs=input_img, outputs=encoded)
encoded_input = Input(shape=(encoding_dim, ))
decoder_layer = autoencoder.layers[-1]
decoder = Model(inputs=encoded_input, outputs=decoder_layer(encoded_input))
autoencoder.compile(optimizer='adam', loss='binary_crossentropy')
autoencoder.fit(x_train,
x_train,
epochs=50,
batch_size=256,
shuffle=True,
validation_data=(x_test, x_test))
encoded_imgs = encoder.predict(x_test)
decoded_imgs = decoder.predict(encoded_imgs)
n = 10
plt.figure(figsize=(20, 4))
for i in range(n):
ax = plt.subplot(2, n, i + 1)
def __init__(self):
self.HOPS = 7
self.SCORE_FUNCTION = 'mlp' # scaled_dot_product / mlp (concat) / bi_linear (general dot)
self.DATASET = 'twitter' # 'twitter', 'restaurant', 'laptop'
self.POLARITIES_DIM = 3
self.EMBEDDING_DIM = 300
self.LEARNING_RATE = 0.01
self.INITIALIZER = initializers.RandomUniform(minval=-0.003,
maxval=0.003)
self.REGULARIZER = regularizers.l2(0.001)
self.MAX_SEQUENCE_LENGTH = 80
self.MAX_ASPECT_LENGTH = 10
self.BATCH_SIZE = 200
self.EPOCHS = 100
self.texts_raw_indices, self.texts_raw_without_aspects_indices, self.texts_left_indices, self.texts_left_with_aspects_indices, \
self.aspects_indices, self.texts_right_indices, self.texts_right_with_aspects_indices, \
self.polarities_matrix, \
self.embedding_matrix, \
self.tokenizer = \
read_dataset(type=self.DATASET,
mode='train',
embedding_dim=self.EMBEDDING_DIM,
max_seq_len=self.MAX_SEQUENCE_LENGTH, max_aspect_len=self.MAX_ASPECT_LENGTH)
if os.path.exists('dmn_saved_model.h5'):
print('loading saved model...')
self.model = load_model('dmn_saved_model.h5')
else:
print('Build model...')
inputs_sentence = Input(shape=(self.MAX_SEQUENCE_LENGTH, ),
name='inputs_sentence')
inputs_aspect = Input(shape=(self.MAX_ASPECT_LENGTH, ),
name='inputs_aspect')
nonzero_count = Lambda(lambda xin: tf.count_nonzero(
xin, dtype=tf.float32))(inputs_aspect)
memory = Embedding(input_dim=len(self.tokenizer.word_index) + 1,
output_dim=self.EMBEDDING_DIM,
input_length=self.MAX_SEQUENCE_LENGTH,
mask_zero=True,
weights=[self.embedding_matrix],
trainable=False,
name='sentence_embedding')(inputs_sentence)
memory = Lambda(self.locationed_memory,
name='locationed_memory')(memory)
aspect = Embedding(input_dim=len(self.tokenizer.word_index) + 1,
output_dim=self.EMBEDDING_DIM,
input_length=self.MAX_ASPECT_LENGTH,
mask_zero=True,
weights=[self.embedding_matrix],
trainable=False,
name='aspect_embedding')(inputs_aspect)
x = Lambda(lambda xin: K.sum(xin[0], axis=1) / xin[1],
name='aspect_mean')([aspect, nonzero_count])
shared_attention = Attention(score_function=self.SCORE_FUNCTION,
initializer=self.INITIALIZER,
regularizer=self.REGULARIZER,
name='shared_attention')
for i in range(self.HOPS):
x = shared_attention((memory, x))
x = Flatten()(x)
x = Dense(self.POLARITIES_DIM)(x)
predictions = Activation('softmax')(x)
model = Model(inputs=[inputs_sentence, inputs_aspect],
outputs=predictions)
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=optimizers.Adam(lr=self.LEARNING_RATE),
metrics=['acc', f1])
# plot_model(model, to_file='model.png')
self.model = model
def layer_test(layer_cls, kwargs={}, input_shape=None, input_dtype=None,
input_data=None, expected_output=None,
expected_output_dtype=None, fixed_batch_size=False):
# generate input data
if input_data is None:
if not input_shape:
raise AssertionError()
if not input_dtype:
input_dtype = K.floatx()
input_data_shape = list(input_shape)
for i, e in enumerate(input_data_shape):
if e is None:
input_data_shape[i] = np.random.randint(1, 4)
if all(isinstance(e, tuple) for e in input_data_shape):
input_data = []
for e in input_data_shape:
input_data.append(
(10 * np.random.random(e)).astype(input_dtype))
else:
input_data = (10 * np.random.random(input_data_shape))
input_data = input_data.astype(input_dtype)
else:
if input_shape is None:
input_shape = input_data.shape
if input_dtype is None:
input_dtype = input_data.dtype
if expected_output_dtype is None:
expected_output_dtype = input_dtype
# instantiation
layer = layer_cls(**kwargs)
# test get_weights , set_weights at layer level
weights = layer.get_weights()
layer.set_weights(weights)
try:
expected_output_shape = layer.compute_output_shape(input_shape)
except Exception:
expected_output_shape = layer._compute_output_shape(input_shape)
# test in functional API
if isinstance(input_shape, list):
if fixed_batch_size:
x = [Input(batch_shape=e, dtype=input_dtype) for e in input_shape]
else:
x = [Input(shape=e[1:], dtype=input_dtype) for e in input_shape]
else:
if fixed_batch_size:
x = Input(batch_shape=input_shape, dtype=input_dtype)
else:
x = Input(shape=input_shape[1:], dtype=input_dtype)
y = layer(x)
if not (K.dtype(y) == expected_output_dtype):
raise AssertionError()
# check with the functional API
model = Model(x, y)
actual_output = model.predict(input_data)
actual_output_shape = actual_output.shape
for expected_dim, actual_dim in zip(expected_output_shape,
actual_output_shape):
if expected_dim is not None:
if not (expected_dim == actual_dim):
raise AssertionError()
if expected_output is not None:
assert_allclose(actual_output, expected_output, rtol=1e-3)
# test serialization, weight setting at model level
model_config = model.get_config()
recovered_model = model.__class__.from_config(model_config)
if model.weights:
weights = model.get_weights()
recovered_model.set_weights(weights)
_output = recovered_model.predict(input_data)
assert_allclose(_output, actual_output, rtol=1e-3)
# test training mode (e.g. useful when the layer has a
# different behavior at training and testing time).
if has_arg(layer.call, 'training'):
model.compile('rmsprop', 'mse')
model.train_on_batch(input_data, actual_output)
# test instantiation from layer config
layer_config = layer.get_config()
layer_config['batch_input_shape'] = input_shape
layer = layer.__class__.from_config(layer_config)
# for further checks in the caller function
return actual_output
def train_top_model_densenet121():
# DesneNet generators
# Set up generators
train_batches = ImageDataGenerator(
preprocessing_function= \
applications.densenet.preprocess_input).flow_from_directory(
train_path,
target_size=(image_size, image_size),
batch_size=train_batch_size)
valid_batches = ImageDataGenerator(
preprocessing_function= \
applications.densenet.preprocess_input).flow_from_directory(
valid_path,
target_size=(image_size, image_size),
batch_size=val_batch_size)
test_batches = ImageDataGenerator(
preprocessing_function= \
applications.densenet.preprocess_input).flow_from_directory(
test_path,
target_size=(image_size, image_size),
batch_size=test_batch_size,
shuffle=False)
input_tensor = Input(shape = (224,224,3))
#Loading the model
model = DenseNet121(input_tensor= input_tensor,weights='imagenet',include_top=False)
# add a global spatial average pooling layer
x = model.output
x = GlobalAveragePooling2D()(x)
# add relu layer
x = Dense(1024, activation='relu')(x)
# and a softmax layer for 7 classes
predictions = Dense(7, activation='softmax')(x)
# this is the model we will train
model = Model(inputs=model.input, outputs=predictions)
def top_3_accuracy(y_true, y_pred):
return top_k_categorical_accuracy(y_true, y_pred, k=3)
def top_2_accuracy(y_true, y_pred):
return top_k_categorical_accuracy(y_true, y_pred, k=2)
model.compile(optimizer=optimizers.SGD(lr=0.001, momentum=0.9, decay=0.0, nesterov=False),
loss="categorical_crossentropy",
metrics=[categorical_accuracy, top_2_accuracy, top_3_accuracy])
print(model.summary())
# Declare a checkpoint to save the best version of the model
checkpoint = ModelCheckpoint("modelDenseNet121.h5", monitor='val_categorical_accuracy', verbose=1,
save_best_only=True, mode='max')
# Reduce the learning rate as the learning stagnates
reduce_lr = ReduceLROnPlateau(monitor='val_categorical_accuracy', factor=0.5, patience=2,
verbose=1, mode='max', min_lr=0.00001)
early_stopping = EarlyStopping(monitor='val_categorical_accuracy', patience=10, verbose=1, mode='max')
callbacks_list = [checkpoint, reduce_lr,
early_stopping
]
history = model.fit_generator(train_batches,
# class_weight = class_weights,
epochs=epochs, shuffle=True, validation_data = valid_batches, steps_per_epoch=train_steps, validation_steps = val_steps, verbose=1, callbacks=callbacks_list)
# # Evaluation of the best epoch
model.load_weights('modelDenseNet.h5')
val_loss, val_cat_acc, val_top_2_acc, val_top_3_acc = \
model.evaluate_generator(valid_batches, steps=val_steps)
print('val_loss:', val_loss)
print('val_cat_acc:', val_cat_acc)
print('val_top_2_acc:', val_top_2_acc)
print('val_top_3_acc:', val_top_3_acc)
