# Pre-compute propagation
for i in range(K - 1):
fltr = fltr.dot(fltr)
fltr.sort_indices()
# Model definition
X_in = Input(shape=(F, ))
fltr_in = Input((N, ), sparse=True)
output = GraphConv(n_classes,
activation='softmax',
kernel_regularizer=l2(l2_reg),
use_bias=False)([X_in, fltr_in])
# Build model
model = Model(inputs=[X_in, fltr_in], outputs=output)
optimizer = Adam(lr=learning_rate)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
weighted_metrics=['acc'])
model.summary()
# Train model
validation_data = ([X, fltr], y, val_mask)
model.fit(
[X, fltr],
y,
sample_weight=train_mask,
epochs=epochs,
batch_size=N,
validation_data=validation_data,
shuffle=False, # Shuffling data means shuffling the whole graph
def train(self):
train_img_list = []
train_label_list = []
for file in os.listdir(self.train_folder):
files_img_in_array = self.read_train_images(filename=file)
train_img_list.append(files_img_in_array) #Image list add up
train_label_list.append(int(file.split('_')[0]))
print(train_label_list) #lable list addup
train_label_list = to_categorical(train_label_list, 4)
train_img_list = np.array(train_img_list)
train_label_list = np.array(train_label_list)
print(train_label_list)
#train_label_list = to_categorical(train_label_list,4) #format into binary [0,0,0,0,1,0,0]
train_img_list = train_img_list.astype('float32')
train_img_list /= 255
#-- setup Neural network CNN
model = Sequential()
#CNN Layer - 1
model.add(
Convolution2D(
filters=32, #Output for next later layer output (100,100,32)
kernel_size=(5, 5), #size of each filter in pixel
padding='same', #边距处理方法 padding method
input_shape=(100, 100,
3), #input shape ** channel last(TensorFlow)
))
model.add(Activation('relu'))
model.add(
MaxPooling2D(
pool_size=(2, 2), #Output for next layer (50,50,32)
strides=(2, 2),
padding='same',
))
#CNN Layer - 2
model.add(
Convolution2D(
filters=64, #Output for next layer (50,50,64)
kernel_size=(2, 2),
padding='same',
))
model.add(Activation('relu'))
model.add(
MaxPooling2D( #Output for next layer (25,25,64)
pool_size=(2, 2),
strides=(2, 2),
padding='same',
))
#Fully connected Layer -1
model.add(Flatten())
model.add(Dense(1024))
model.add(Activation('relu'))
# Fully connected Layer -2
model.add(Dense(512))
model.add(Activation('relu'))
# Fully connected Layer -3
model.add(Dense(256))
model.add(Activation('relu'))
# Fully connected Layer -4
model.add(Dense(self.categories))
model.add(Activation('softmax'))
# Define Optimizer
adam = Adam(lr=0.0001)
#Compile the model
model.compile(optimizer=adam,
loss="categorical_crossentropy",
metrics=['accuracy'])
# Fire up the network
model.fit(
train_img_list,
train_label_list,
epochs=self.number_batch,
batch_size=self.batch_size,
verbose=1,
)
#SAVE your work -model
model.save('./cellfinder.h5')
x = Dense(units)(x)
x = LeakyReLU(alpha=0.2)(x)
x = Reshape((32, 5, 8))(x)
x = Conv2D(16, (3, 3), activation='relu', padding='same')(x)
x = Conv2D(32, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(64, (3, 3), activation='relu', padding='same')(x)
x = Conv2D(128, (3, 3), activation='relu', padding='same')(x)
x = UpSampling2D((2, 2))(x)
x = Conv2D(256, (3, 3), activation='relu', padding='same')(x)
x = Conv2D(1, (3, 3), activation='tanh', padding='same')(x)
return x
# Define model training hyperparameters
autoencoder_train = Model(input_img, autoencoder(input_img))
autoencoder_train.compile(loss='mean_squared_error', optimizer = Adam())
autoencoder_train.summary()
# Create a file to save parameter weights
weightname = 'model_weights.h5'
model_saver = tf.keras.callbacks.ModelCheckpoint(weightname ,monitor='val_loss', verbose=1,save_best_only=True, save_weights_only=False, mode='auto')
# Train the Autoencoder
autoencoder_train.load_weights(weightname)
H = autoencoder_train.fit(x_train, x_train, validation_data=(x_test, x_test), epochs=EPOCHS, batch_size=BS, callbacks = [model_saver])
"""#Plotting original and extracted images"""
# Make a prediction using the validation set
extract = autoencoder_train.predict(x_test)
loss = H.history['loss']
movie = Input(shape=(1,))
m = EmbeddingLayer(n_movies, n_factors)(movie)
x = Concatenate()([u, m])
x = Dropout(0.05)(x)
x = Dense(10, kernel_initializer='he_normal')(x)
x = Activation('relu')(x)
x = Dropout(0.5)(x)
x = Dense(1, kernel_initializer='he_normal')(x)
x = Activation('sigmoid')(x)
x = Lambda(lambda x: x * (max_rating - min_rating) + min_rating)(x)
model = Model(inputs=[user, movie], outputs=x)
opt = Adam(lr=0.001)
model.compile(loss='mean_squared_error', optimizer=opt)
print(model.summary())
history = model.fit(x=X_train_array, y=y_train, batch_size=64, epochs=5, verbose=1,
validation_data=(X_test_array, y_test))
plt.xlabel("Epoch Number")
plt.ylabel("Loss Magnidute")
plt.plot(history.history['loss'])
plt.show()
print('user: '******'movie: ', X_test[:10, 1])
print('rate: ', y_test[:10])
# Set channel
channel = x_train.shape[-1]
# It is suggested to use [-1, 1] input for GAN training
x_train = (x_train.astype('float32') - 127.5) / 127.5
x_test = (x_test.astype('float32') - 127.5) / 127.5
# Get image size
img_size = x_train[0].shape
# Get number of classes
n_classes = len(np.unique(y_train))
# %% ---------------------------------- Hyperparameters ----------------------------------------------------------------
optimizer = Adam(lr=0.0002, beta_1=0.5, beta_2=0.9)
latent_dim = 32
# trainRatio === times(Train D) / times(Train G)
# trainRatio = 5
# %% ---------------------------------- Models Setup -------------------------------------------------------------------
# Build Generator with mlp
def generator_fc():
noise = Input(shape=(latent_dim, ))
x = Dense(128, kernel_initializer=weight_init)(noise)
x = BatchNormalization()(x)
x = LeakyReLU(0.2)(x)
x = Dense(256, kernel_initializer=weight_init)(x)
x = BatchNormalization()(x)
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, kernel_size=(3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Flatten())
model.add(Dense(1024, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(26, activation='softmax'))
# If you want to train the same model or try other models, go for this
if mode == "train":
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=0.0001, decay=1e-6),
metrics=['accuracy'])
model_info = model.fit_generator(train_generator,
steps_per_epoch=num_train // batch_size,
epochs=num_epoch,
validation_data=validation_generator,
validation_steps=num_val // batch_size)
model.save_weights('model_mnist.h5')
# emotions will be displayed on your face from the webcam feed
elif mode == "display":
model.load_weights('model_mnist.h5')
# prevents openCL usage and unnecessary logging messages
print(model.summary())
#Parâmetros:
#kernel_size: indica o tamanho da matriz de detector de características (feature detector)
#input_shape: indica o tamanho da imagem a ser utilizada no treinamento
#data_format='channels_last': parâmetro padrão que indica que será adicionada mais uma dimensão da imagem no final da matriz
#kernel_regularizer: indica que irá adicionar uma penalidade quando o erro tiver um determinado valo
"""## Etapa 8 - Compilando o modelo
* Parâmetros Adam: https://arxiv.org/abs/1412.6980
* Artigo sobre parâmetros Adam: https://machinelearningmastery.com/adam-optimization-algorithm-for-deep-learning/
* Parâmetros beta: representam a taxa de decaimento exponencial (por exemplo, 0.9) que está relacionado com a taxa de aprendizagem (learning rate - lr)
"""
#Compilando o modelo
model.compile(loss=categorical_crossentropy,
optimizer=Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=1e-7),
metrics=['accuracy'])
arquivo_modelo = 'modelo_02_expressoes.h5'
arquivo_modelo_json = 'modelo_02_expressoes.json'
lr_reducer = ReduceLROnPlateau(monitor='val_loss',
factor=0.9,
patience=3,
verbose=1)
early_stopper = EarlyStopping(monitor='val_loss',
min_delta=0,
patience=8,
verbose=1,
mode='auto')
checkpointer = ModelCheckpoint(arquivo_modelo,
monitor='val_loss',
verbose=1,
def main(go_file, train_data_file, test_data_file, terms_file, model_file,
out_file, split, batch_size, epochs, load, logger_file, threshold,
device, params_index):
params = {
'max_kernel': 129,
'initializer': 'glorot_normal',
'dense_depth': 0,
'nb_filters': 512,
'optimizer': Adam(lr=3e-4),
'loss': 'binary_crossentropy'
}
# SLURM JOB ARRAY INDEX
pi = params_index
if params_index != -1:
kernels = [33, 65, 129, 257, 513]
dense_depths = [0, 1, 2]
nb_filters = [32, 64, 128, 256, 512]
params['max_kernel'] = kernels[pi % 5]
pi //= 5
params['dense_depth'] = dense_depths[pi % 3]
pi //= 3
params['nb_filters'] = nb_filters[pi % 5]
pi //= 5
out_file = f'data/predictions_{params_index}.pkl'
logger_file = f'data/training_{params_index}.csv'
model_file = f'data/model_{params_index}.h5'
print('Params:', params)
go = Ontology(go_file, with_rels=True)
terms_df = pd.read_pickle(terms_file)
terms = terms_df['terms'].values.flatten()
train_df, valid_df = load_data(train_data_file, terms, split)
test_df = pd.read_pickle(test_data_file)
terms_dict = {v: i for i, v in enumerate(terms)}
nb_classes = len(terms)
with tf.device('/' + device):
test_steps = int(math.ceil(len(test_df) / batch_size))
test_generator = DFGenerator(test_df, terms_dict, nb_classes,
batch_size)
if load:
logging.info('Loading pretrained model')
model = load_model(model_file)
else:
logging.info('Creating a new model')
model = create_model(nb_classes, params)
logging.info("Training data size: %d" % len(train_df))
logging.info("Validation data size: %d" % len(valid_df))
checkpointer = ModelCheckpoint(filepath=model_file,
verbose=1,
save_best_only=True)
earlystopper = EarlyStopping(monitor='val_loss',
patience=6,
verbose=1)
logger = CSVLogger(logger_file)
logging.info('Starting training the model')
valid_steps = int(math.ceil(len(valid_df) / batch_size))
train_steps = int(math.ceil(len(train_df) / batch_size))
train_generator = DFGenerator(train_df, terms_dict, nb_classes,
batch_size)
valid_generator = DFGenerator(valid_df, terms_dict, nb_classes,
batch_size)
model.summary()
model.fit_generator(train_generator,
steps_per_epoch=train_steps,
epochs=epochs,
validation_data=valid_generator,
validation_steps=valid_steps,
max_queue_size=batch_size,
workers=12,
callbacks=[logger, checkpointer, earlystopper])
logging.info('Loading best model')
model = load_model(model_file)
logging.info('Evaluating model')
loss = model.evaluate_generator(test_generator, steps=test_steps)
logging.info('Test loss %f' % loss)
logging.info('Predicting')
valid_generator.reset()
preds = model.predict_generator(valid_generator, steps=valid_steps)
labels = [
'airplane',
'automobile',
'bird',
'cat',
'deer',
'dog',
'frog',
'horse',
'ship',
'truck'
]
### Cell 8 ###
model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=LR, decay=DECAY), metrics=['accuracy'])
print(type(X_train))
print(type(Y_train))
print(type(X_valid))
print(type(Y_valid))
print(len(Y_train[0]))
Y_train[0]
### Cell 10 ###
history = model.fit(X_train / 255.0 , to_categorical(Y_train), batch_size=BATCH_SIZE, shuffle=True, epochs=250,
validation_data=(X_valid/255.0, to_categorical(Y_valid)))
def build_model(self, hp):
"""
Model is responsible of building an RNN model with the decided parameters
:param hp: Keras Tuner Parameters
:return: Sequential Recurrent Neural Network Model
"""
self.log_event(' -> Creating a model.')
model = Sequential()
model.add(self.add_mask_layer())
# Add One LSTM Layer with Batch Normalization
model.add(
LSTM(units=hp.Int(
'first_layer',
min_value=self.hyper_parameters['lstm_units']['min'],
max_value=self.hyper_parameters['lstm_units']['max'],
step=self.hyper_parameters['lstm_units']['step']),
return_sequences=True,
dropout=self.hyper_parameters['lstm_layer_dropout'],
recurrent_dropout=0.1,
activation=self.hyper_parameters['lstm_layer_activation']))
model.add(BatchNormalization())
# Add Dropout
model.add(
Dropout(
hp.Choice('dropout_one',
values=self.hyper_parameters['dropout'])))
# Add the second LSTM Layer with Batch Normalization
model.add(
LSTM(units=hp.Int(
'second_layer',
min_value=self.hyper_parameters['lstm_units']['min'],
max_value=self.hyper_parameters['lstm_units']['max'],
step=self.hyper_parameters['lstm_units']['step']),
return_sequences=False,
dropout=self.hyper_parameters['lstm_layer_dropout'],
recurrent_dropout=0.1,
activation=self.hyper_parameters['lstm_layer_activation']))
model.add(BatchNormalization())
# Add Dropout
model.add(
Dropout(
hp.Choice('dropout_one',
values=self.hyper_parameters['dropout'])))
# Add Output Layer
model.add(
Dense(self.number_of_distinct_items,
activation=self.hyper_parameters['dense_activation']))
# Compile the model
opt = Adam(
hp.Choice('learning_rate',
values=self.hyper_parameters['learning_rate']))
model.compile(loss=self.hyper_parameters['loss'],
optimizer=opt,
metrics=self.hyper_parameters['metric'])
self.log_event(' -> Returning the model.')
return model
decay_rate=0.92,
staircase=True)
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)
for epoch in range(Init_Epoch, Freeze_Epoch):
fit_one_epoch(model, loss, optimizer, epoch, epoch_size,
epoch_size_val, gen, gen_val, Freeze_Epoch,
get_train_step_fn())
else:
gen = Generator(Batch_size, train_lines, inputs_size, num_classes,
dataset_path).generate()
gen_val = Generator(Batch_size, val_lines, inputs_size,
num_classes, dataset_path).generate(False)
model.compile(loss=dice_loss_with_CE() if dice_loss else CE(),
optimizer=Adam(lr=lr),
metrics=[f_score()])
model.fit_generator(gen,
steps_per_epoch=epoch_size,
validation_data=gen_val,
validation_steps=epoch_size_val,
epochs=Freeze_Epoch,
initial_epoch=Init_Epoch,
callbacks=[
checkpoint_period, reduce_lr,
early_stopping, tensorboard, loss_history
])
for i in range(freeze_layers):
model.layers[i].trainable = True
def create_model(self,
filters_number,
network_depth=6,
use_residual=True,
use_bottleneck=True,
max_kernel_size=20,
learning_rate=0.01,
regularization_rate=0.0):
"""
Generate a InceptionTime model. See Fawaz et al. 2019.
The compiled Keras model is returned.
Parameters
----------
input_shape : tuple
Shape of the input dataset: (num_samples, num_timesteps, num_channels)
class_number : int
Number of classes for classification task
filters_number : int
number of filters for each convolutional layer
network_depth : int
Depth of network, i.e. number of Inception modules to stack.
use_residual: bool
If =True, then residual connections are used. Default is True.
use_bottleneck: bool
If=True, bottleneck layer is used at the entry of Inception modules.
Default is true.
max_kernel_size: int,
Maximum kernel size for convolutions within Inception module.
learning_rate : float
learning rate
regularization_rate: float
regularization rate
Returns
-------
model : Keras model
The compiled Keras model
"""
dim_length = self.x_shape[1] # number of samples in a time series
dim_channels = self.x_shape[2] # number of channels
weightinit = 'lecun_uniform' # weight initialization
bottleneck_size = 32
def inception_module(input_tensor, stride=1, activation='linear'):
if use_bottleneck and int(input_tensor.shape[-1]) > 1:
input_inception = Conv1D(filters=bottleneck_size,
kernel_size=1,
padding='same',
activation=activation,
kernel_initializer=weightinit,
use_bias=False)(input_tensor)
else:
input_inception = input_tensor
kernel_sizes = [max_kernel_size // (2**i) for i in range(3)]
conv_list = []
for kernel_size in kernel_sizes:
conv_list.append(
Conv1D(filters=filters_number,
kernel_size=kernel_size,
strides=stride,
padding='same',
activation=activation,
kernel_initializer=weightinit,
use_bias=False)(input_inception))
max_pool_1 = MaxPool1D(pool_size=3, strides=stride,
padding='same')(input_tensor)
conv_last = Conv1D(filters=filters_number,
kernel_size=1,
padding='same',
activation=activation,
kernel_initializer=weightinit,
use_bias=False)(max_pool_1)
conv_list.append(conv_last)
x = Concatenate(axis=2)(conv_list)
x = BatchNormalization()(x)
x = Activation(activation='relu')(x)
return x
def shortcut_layer(input_tensor, out_tensor):
shortcut_y = Conv1D(filters=int(out_tensor.shape[-1]),
kernel_size=1,
padding='same',
kernel_initializer=weightinit,
use_bias=False)(input_tensor)
shortcut_y = BatchNormalization()(shortcut_y)
x = Add()([shortcut_y, out_tensor])
x = Activation('relu')(x)
return x
# Build the actual model:
input_layer = Input((dim_length, dim_channels))
x = BatchNormalization()(
input_layer) # Added batchnorm (not in original paper)
input_res = x
for depth in range(network_depth):
x = inception_module(x)
if use_residual and depth % 3 == 2:
x = shortcut_layer(input_res, x)
input_res = x
gap_layer = GlobalAveragePooling1D()(x)
# Final classification layer
output_layer = Dense(self.number_of_classes,
activation='relu')(gap_layer)
# Create model and compile
model = Model(inputs=input_layer, outputs=output_layer)
model.compile(loss='mean_absolute_error',
optimizer=Adam(lr=learning_rate),
metrics=self.metrics)
return model
class myCallback(Callback):
def on_epoch_end(self, epoch, logs={}):
if logs.get('loss') < 0.1:
print("\nReached loss less than 0.4 so cancelling training!")
self.model.stop_training = True
model = Sequential([
Flatten(input_shape=(28, 28), name="input_layer"),
Dense(512, activation=tf.nn.relu, name="layer1"),
Dense(512, activation=tf.nn.relu, name="layer2"),
Dense(10, activation=tf.nn.softmax, name="output_layer")
])
print(model.weights)
model.compile(optimizer=Adam(),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
print(model.summary())
model.fit(training_images, training_labels, epochs=20, callbacks=myCallback())
print(model.evaluate(test_images, test_labels))
classifications = model.predict(test_images)
print(classifications[0])
print(test_labels[0])
def BuildModel():
field = Input((10, 10, 11), name='field')
#bots = Input((4*MaxNrOfBots,), name='bots')
bots = Input((3,), name='bots')
# f = field
# f = Conv2D(32, 1, strides=1, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv1a')(f)
# f = Conv2D(32, 3, strides=1, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv1b')(f)
# f = Conv2D(32, 3, strides=2, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv1c')(f)
# f = Conv2D(64, 1, strides=1, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv2a')(f)
# f = Conv2D(64, 3, strides=1, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv2b')(f)
# f = Conv2D(64, 3, strides=2, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv2c')(f)
# f = Conv2D(128, 1, strides=1, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv3a')(f)
# f = Conv2D(128, 3, strides=1, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv3b')(f)
# f = Conv2D(128, 3, strides=2, padding='same', activation='relu', kernel_initializer='he_uniform', name='conv3c')(f)
# f = GlobalAveragePooling2D(name='avg')(f)
# b = bots
# b = Dense(128, activation='relu', kernel_initializer='he_uniform', name='pre1')(b)
# h = Concatenate(name='concat')([f, b])
# h = Dense(512, activation='relu', kernel_initializer='he_uniform', name='dense1')(h)
# h = Dense(128, activation='relu', kernel_initializer='he_uniform', name='dense2')(h)
# h = Dense(3, activation='softmax', name='dense3')(h)
f = Flatten(name='flatten')(field)
h = Concatenate(name='concat')([f, bots])
h = Dense(2048, activation='elu', kernel_initializer='he_uniform', name='dense1')(h)
h = Dense(2048, activation='elu', kernel_initializer='he_uniform', name='dense2')(h)
h = Dense(1024, activation='elu', kernel_initializer='he_uniform', name='dense3')(h)
h = Dense(1024, activation='elu', kernel_initializer='he_uniform', name='dense4')(h)
h = Dense(1024, activation='elu', kernel_initializer='he_uniform', name='dense5')(h)
h = Dense(1024, activation='elu', kernel_initializer='he_uniform', name='dense6')(h)
h = Dense(512, activation='elu', kernel_initializer='he_uniform', name='dense7')(h)
h = Dense(3, activation='softmax', name='dense8')(h)
action = h
model_play = Model([field, bots], action)
advantage = Input((1,), name='advantage')
model_train = Model([field, bots, advantage], action)
model_train.compile(loss=CategoricalVanillaPolicyGradientLoss(advantage), optimizer=Adam(lr=LearningRate))
return model_play, model_train
def train(self):
self.logger.info("DnnOptimizer::train")
training_generator = FluctuationDataGenerator(
self.partition['train'],
data_dir=self.dirinput_train,
**self.params)
validation_generator = FluctuationDataGenerator(
self.partition['validation'],
data_dir=self.dirinput_test,
**self.params)
model = u_net(
(self.grid_phi, self.grid_r, self.grid_z, self.dim_input),
depth=self.depth,
batchnorm=self.batch_normalization,
pool_type=self.pooling,
start_channels=self.filters,
dropout=self.dropout)
model.compile(loss=self.lossfun,
optimizer=Adam(lr=self.adamlr),
metrics=[self.metrics]) # Mean squared error
model.summary()
plot_model(model,
to_file='plots/model_%s_nEv%d.png' %
(self.suffix, self.train_events),
show_shapes=True,
show_layer_names=True)
#log_dir = "logs/" + datetime.datetime.now(datetime.timezone.utc).strftime("%Y%m%d_%H%M%S")
log_dir = 'logs/' + '%s_nEv%d' % (self.suffix, self.train_events)
tensorboard_callback = TensorBoard(log_dir=log_dir, histogram_freq=1)
model._get_distribution_strategy = lambda: None
his = model.fit(training_generator,
validation_data=validation_generator,
use_multiprocessing=False,
epochs=self.epochs,
callbacks=[tensorboard_callback])
plt.style.use("ggplot")
plt.figure()
plt.yscale('log')
plt.plot(np.arange(0, self.epochs),
his.history["loss"],
label="train_loss")
plt.plot(np.arange(0, self.epochs),
his.history["val_loss"],
label="val_loss")
plt.plot(np.arange(0, self.epochs),
his.history[self.metrics],
label="train_" + self.metrics)
plt.plot(np.arange(0, self.epochs),
his.history["val_" + self.metrics],
label="val_" + self.metrics)
plt.title("Training Loss and Accuracy on Dataset")
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend(loc="lower left")
plt.savefig("plots/plot_%s_nEv%d.png" %
(self.suffix, self.train_events))
model_json = model.to_json()
with open("%s/model_%s_nEv%d.json" % (self.dirmodel, self.suffix, self.train_events), "w") \
as json_file:
json_file.write(model_json)
model.save_weights("%s/model_%s_nEv%d.h5" %
(self.dirmodel, self.suffix, self.train_events))
self.logger.info("Saved trained model to disk")
model = utils.load_model(args.out)
elif args.mode == "train":
model = getattr(utils.models, args.model)()
else:
raise ValueError("Aucun modèle à l'emplacement donné par --out")
# Affiche une description du réseau : couches, nombres de paramètres
model.summary()
# Instructions exécutées dans le mode 'train'
if args.mode == "train":
# Charge le minimiseur
if args.minimizer == "sgd":
optimizer = SGD(lr=args.lr)
elif args.minimizer == "adam":
optimizer = Adam(lr=args.lr)
else:
raise ValueError("Nom d'optimiseur inconnu")
# Charge les données d'entraînement
x_train, y_train = utils.get_train_data(num_train_examples=args.examples)
# Entraîne le réseau pendant un certain nombre d'epochs
model.compile(loss="categorical_crossentropy",
optimizer=optimizer,
metrics=["accuracy"])
model.fit(x=x_train,
y=y_train,
epochs=args.epochs,
batch_size=args.batch_size)
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.metrics import categorical_crossentropy
#%% Set up model
model = Sequential([
Dense(units=16, input_shape=(1, ), activation='relu'),
# Dense(units=8, activation='relu'),
Dense(units=32, activation='relu'),
# Dense(units=2048, activation='relu'),
Dense(units=2, activation='softmax')
])
model.summary()
model.compile(optimizer=Adam(learning_rate=0.0001),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
import datetime
import os
# log_dir = os.getcwd() + "\\logs\\fit\\"
# log_dir = "logs\fit"
# os.makedirs(log_dir)
# tensorboard_callback = keras.callbacks.TensorBoard(log_dir='./Graph', histogram_freq=1)
# logdir=mylogs:C:\path\to\output\folder
# tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1)
log_dir = "logs/fit/" + datetime.datetime.now().strftime("%Y%m%d-%H%M%S")
def CreateModel(self):
'''
定义CNN/LSTM/CTC模型，使用函数式模型
输入层：200维的特征值序列，一条语音数据的最大长度设为1600（大约16s）
隐藏层：卷积池化层，卷积核大小为3x3，池化窗口大小为2
隐藏层：全连接层
输出层：全连接层，神经元数量为self.MS_OUTPUT_SIZE，使用softmax作为激活函数，
CTC层：使用CTC的loss作为损失函数，实现连接性时序多输出
'''
input_data = Input(name='the_input',
shape=(self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH,
1))
layer_h1 = Conv2D(32, (3, 3),
use_bias=False,
activation='relu',
padding='same',
kernel_initializer='he_normal')(input_data) # 卷积层
#layer_h1 = Dropout(0.05)(layer_h1)
layer_h2 = Conv2D(32, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h1) # 卷积层
layer_h3 = MaxPooling2D(pool_size=2, strides=None,
padding="valid")(layer_h2) # 池化层
#layer_h3 = Dropout(0.05)(layer_h3) # 随机中断部分神经网络连接，防止过拟合
layer_h4 = Conv2D(64, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h3) # 卷积层
#layer_h4 = Dropout(0.1)(layer_h4)
layer_h5 = Conv2D(64, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h4) # 卷积层
layer_h6 = MaxPooling2D(pool_size=2, strides=None,
padding="valid")(layer_h5) # 池化层
#layer_h6 = Dropout(0.1)(layer_h6)
layer_h7 = Conv2D(128, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h6) # 卷积层
#layer_h7 = Dropout(0.15)(layer_h7)
layer_h8 = Conv2D(128, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h7) # 卷积层
layer_h9 = MaxPooling2D(pool_size=2, strides=None,
padding="valid")(layer_h8) # 池化层
#layer_h9 = Dropout(0.15)(layer_h9)
layer_h10 = Conv2D(128, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h9) # 卷积层
#layer_h10 = Dropout(0.2)(layer_h10)
layer_h11 = Conv2D(128, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h10) # 卷积层
layer_h12 = MaxPooling2D(pool_size=1, strides=None,
padding="valid")(layer_h11) # 池化层
#layer_h12 = Dropout(0.2)(layer_h12)
layer_h13 = Conv2D(128, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h12) # 卷积层
#layer_h13 = Dropout(0.3)(layer_h13)
layer_h14 = Conv2D(128, (3, 3),
use_bias=True,
activation='relu',
padding='same',
kernel_initializer='he_normal')(layer_h13) # 卷积层
layer_h15 = MaxPooling2D(pool_size=1, strides=None,
padding="valid")(layer_h14) # 池化层
#test=Model(inputs = input_data, outputs = layer_h12)
#test.summary()
layer_h16 = Reshape((200, 3200))(layer_h15) #Reshape层
#layer_h16 = Dropout(0.3)(layer_h16) # 随机中断部分神经网络连接，防止过拟合
layer_h17 = Dense(128,
activation="relu",
use_bias=True,
kernel_initializer='he_normal')(layer_h16) # 全连接层
inner = layer_h17
#layer_h5 = LSTM(256, activation='relu', use_bias=True, return_sequences=True)(layer_h4) # LSTM层
rnn_size = 128
gru_1 = GRU(rnn_size,
return_sequences=True,
kernel_initializer='he_normal',
name='gru1')(inner)
gru_1b = GRU(rnn_size,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='gru1_b')(inner)
gru1_merged = add([gru_1, gru_1b])
gru_2 = GRU(rnn_size,
return_sequences=True,
kernel_initializer='he_normal',
name='gru2')(gru1_merged)
gru_2b = GRU(rnn_size,
return_sequences=True,
go_backwards=True,
kernel_initializer='he_normal',
name='gru2_b')(gru1_merged)
gru2 = concatenate([gru_2, gru_2b])
layer_h20 = gru2
#layer_h20 = Dropout(0.4)(gru2)
layer_h21 = Dense(128,
activation="relu",
use_bias=True,
kernel_initializer='he_normal')(layer_h20) # 全连接层
#layer_h17 = Dropout(0.3)(layer_h17)
layer_h22 = Dense(self.MS_OUTPUT_SIZE,
use_bias=True,
kernel_initializer='he_normal')(layer_h21) # 全连接层
y_pred = Activation('softmax', name='Activation0')(layer_h22)
model_data = Model(inputs=input_data, outputs=y_pred)
#model_data.summary()
labels = Input(name='the_labels',
shape=[self.label_max_string_length],
dtype='float32')
input_length = Input(name='input_length', shape=[1], dtype='int64')
label_length = Input(name='label_length', shape=[1], dtype='int64')
# Keras doesn't currently support loss funcs with extra parameters
# so CTC loss is implemented in a lambda layer
#layer_out = Lambda(ctc_lambda_func,output_shape=(self.MS_OUTPUT_SIZE, ), name='ctc')([y_pred, labels, input_length, label_length])#(layer_h6) # CTC
loss_out = Lambda(self.ctc_lambda_func, output_shape=(1, ),
name='ctc')(
[y_pred, labels, input_length, label_length])
model = Model(inputs=[input_data, labels, input_length, label_length],
outputs=loss_out)
model.summary()
# clipnorm seems to speeds up convergence
#sgd = SGD(lr=0.0001, decay=1e-6, momentum=0.9, nesterov=True, clipnorm=5)
#ada_d = Adadelta(lr = 0.01, rho = 0.95, epsilon = 1e-06)
opt = Adam(lr=0.001,
beta_1=0.9,
beta_2=0.999,
decay=0.0,
epsilon=10e-8)
#model.compile(loss={'ctc': lambda y_true, y_pred: y_pred}, optimizer=sgd)
model.build((self.AUDIO_LENGTH, self.AUDIO_FEATURE_LENGTH, 1))
model = ParallelModel(model, NUM_GPU)
model.compile(loss={
'ctc': lambda y_true, y_pred: y_pred
},
optimizer=opt)
# captures output of softmax so we can decode the output during visualization
test_func = K.function([input_data], [y_pred])
#print('[*提示] 创建模型成功，模型编译成功')
print('[*Info] Create Model Successful, Compiles Model Successful. ')
return model, model_data
print('x_data.shape: {}, y_data.shape: {}'.format(x_data.shape, y_data.shape))
#input_visualization()
#plt.show()
train_ds = tf.data.Dataset.from_tensor_slices((x_data, y_data))
train_ds = train_ds.shuffle(1000).batch(8)
# Model
model = Sequential()
model.add(Dense(n_class))
model.add(Activation('softmax'))
#model.summary()
loss_object = SparseCategoricalCrossentropy()
optimizer = Adam(learning_rate=0.01)
train_loss = Mean()
train_acc = SparseCategoricalAccuracy()
EPOCHS = 10
## Training
for epoch in range(EPOCHS):
trainer()
training_reporter()
#
x1_test = np.linspace(-1.2, 1.2, 100).astype(np.float32)
x2_test = np.linspace(-1.2, 1.2, 100).astype(np.float32)
def main():
# Gets currect directory path
cdir = os.getcwd()
# Parameters
epochs = 100
batch_size = 1
depth = 3
loss_label = 'GDL'
loss_func = generalized_dice_loss
learning_rate = 1e-4
datasets = ["ds0", "ds1", "ds2", "ds3"]
datasets_label = [
"EvaLady", "AosugiruHaru", "JijiBabaFight", "MariaSamaNihaNaisyo"
]
df = pd.DataFrame(columns=[
'Trained on', 'Tested on', 'Loss', 'Accuracy', 'Precision', 'Recall'
])
for m, ml in enumerate(datasets):
model = UNet(depth)
model.load_weights("unet_{0}.hdf5".format(ml))
for d, ds in enumerate(datasets):
if ds == m:
pass
# Gets all files .jpg
inputs_train = glob.glob(
str(cdir) + "/../../datasets/D1_" + ds + "/input/*.jpg")
# Gets all files .png
targets_train = glob.glob(
str(cdir) + "/../../datasets/D1_" + ds + "/target/*.png")
inputs_val = glob.glob(
str(cdir) + "/../../datasets/TT_" + ds + "/input/*.jpg")
# Gets all files .png
targets_val = glob.glob(
str(cdir) + "/../../datasets/TT_" + ds + "/target/*.png")
# Sort paths
inputs_train.sort()
targets_train.sort()
inputs_val.sort()
targets_val.sort()
opt = Adam(lr=learning_rate)
# Fixes a initial seed for randomness
np.random.seed(RANDOM_SEED)
set_random_seed(RANDOM_SEED)
X_train = []
Y_train = []
X_val = []
Y_val = []
# Iterates through files and extract the patches for training, validation and testing
for i, _ in enumerate(inputs_val):
x = plt.imread(inputs_val[i])
if len(x.shape) == 3:
x = x[:, :, 0]
X_val.append(fix_size(x, depth))
Y_val.append(fix_size(plt.imread(targets_val[i]), depth))
X_val = img_to_normal(np.array(X_val)[..., np.newaxis])
Y_val = img_to_ohe(np.array(Y_val))
# Shuffles both the inputs and targets set
indexes = list(range(0, len(inputs_val)))
np.random.shuffle(indexes)
X_val = X_val[indexes]
Y_val = Y_val[indexes]
inputs_val = np.array(inputs_val)[indexes]
X_val2 = X_val[5:]
Y_val2 = Y_val[5:]
Y_pred = model.predict(X_val2)
test_loss = loss_func(K.constant(Y_val2),
K.constant(Y_pred)).numpy()
Y_pred = ohe_to_img(Y_pred)
Y_val2 = ohe_to_img(Y_val2)
metrics = calc_metrics(Y_val2, Y_pred)
df = df.append(
pd.DataFrame(
data={
'Trained on': [datasets_label[m]],
'Tested on': [datasets_label[d]],
'Loss': [test_loss],
'Accuracy': [metrics['accuracy']],
'Precision': [metrics['precision']],
'Recall': [metrics['recall']]
}))
df.to_csv('results.csv', index=False)
clear_session()
classTotals = trainY.sum(axis=0)
classWeight = classTotals.max() / classTotals
# construct the image generator for data augmentation
aug = ImageDataGenerator(rotation_range=10,
zoom_range=0.15,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.15,
horizontal_flip=False,
vertical_flip=False,
fill_mode="nearest")
# initialize the optimizer and model
print("[INFO] compiling model...")
opt = Adam(lr=INIT_LR, decay=INIT_LR / (NUM_EPOCHS * 0.5))
model = TrafficSignNet.build(width=32, height=32, depth=3, classes=numLabels)
model.compile(loss="categorical_crossentropy",
optimizer=opt,
metrics=["accuracy"])
# compile the model and train the network
print("[INFO] training network...")
H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
validation_data=(testX, testY),
steps_per_epoch=trainX.shape[0] // BS,
epochs=NUM_EPOCHS,
class_weight=classWeight,
verbose=1)
# evaluate the network
# Set the seed for reproducible result np.random.seed(1000) # RandomDim, conventionally 100, author decided 10 randomDim = 10 # Load MNIST data (X_train, _), (_, _) = mnist.load_data() X_train = (X_train.astype(np.float32) - 127.5)/127.5 X_train = X_train.reshape(60000, 784) # In[3]: # Optimizer adam = Adam(lr=0.0002, beta_1=0.5) generator = Sequential() generator.add(Dense(256, input_dim=randomDim)) #, kernel_initializer=initializers.RandomNormal(stddev=0.02))) generator.add(LeakyReLU(0.2)) generator.add(Dense(512)) generator.add(LeakyReLU(0.2)) generator.add(Dense(1024)) generator.add(LeakyReLU(0.2)) generator.add(Dense(784, activation='tanh')) #generator.compile(loss='binary_crossentropy', optimizer=adam) # Generator: # Total params: 1,463,312 # Trainable params: 1,463,312 # Non-trainable params: 0
# v1 does not use BN after last shortcut connection-ReLU
x = AveragePooling2D(pool_size=8)(x)
y = Flatten()(x)
outputs = Dense(num_classes,
activation='softmax',
kernel_initializer='he_normal')(y)
# Instantiate model.
model = Model(inputs=inputs, outputs=outputs)
return model
model = resnet_v1(input_shape=input_shape, depth=20)
model.compile(loss='categorical_crossentropy',
optimizer=Adam(lr=lr_schedule(0)),
metrics=['accuracy'])
model.summary()
# Prepare model model saving directory.
save_dir = os.path.join(os.getcwd(), 'saved_models')
model_name = 'cifar10_%s_model.{epoch:03d}.h5' % model_type
if not os.path.isdir(save_dir):
os.makedirs(save_dir)
filepath = os.path.join(save_dir, model_name)
checkpoint = ModelCheckpoint(filepath=filepath,
monitor='val_acc',
verbose=1,
save_best_only=True)
idx_char[num_chars] = MU
idx_char[num_chars + 1] = END
char_idx = {c: i for i, c in enumerate(wl_chars)}
char_idx[MU] = num_chars
char_idx[END] = num_chars + 1
# モデル構築
if os.path.exists('/content/drive/My Drive/colab/lstm_set.h5'):
# loading the model
print('load model...')
model = load_model('/content/drive/My Drive/colab/lstm_set.h5')
else:
model = lstm_model()
model.summary()
model.compile(loss='categorical_crossentropy',
optimizer=Adam()) # mean_squared_error
m = model
# テキスト文章取得
toots = list([
tmp.strip() for tmp in open(
"/content/drive/My Drive/colab/toot_merge_n.txt").readlines()
])
# d2vモデル ベクトル取得
d2v_vecs = Doc2Vec.load(
"/content/drive/My Drive/colab/d2v.model").docvecs.vectors_docs
# データセット構築
dataset = build_tf_ds(batch_size=batch_size)
# コールバック設定
print_callback = LambdaCallback(on_epoch_end=on_epoch_end)
ES = EarlyStopping(monitor='loss',
min_delta=0.001,
plt.legend()
# Task 5
# ---- Parameters ---- #
img_w = 128 # Witdh of input images
img_h = 128 # Height of input images
img_ch = 1 # Number of channels
base = 32 # Number of neurons in first layer
# Creating a CNN Network
clf = lenet(img_ch, img_w, img_h, base)
# Compiling the layers and setting loss & optimizer function
clf.compile(loss='binary_crossentropy',
optimizer=Adam(lr=0.0001),
metrics=['binary_accuracy'])
# Trains the model for 200 epochs with 8 images in each batch
clf_hist = clf.fit(
x_train,
y_train,
batch_size=8,
epochs=200,
validation_data=(x_test,
y_test)) # Validation data is training data shuffled
# Prints a summary of the network
clf.summary()
# ---- Plotting ---- #
model.add(Dense(1024))
model.add(Activation("relu"))
model.add(Dropout(0.5))
model.add(Dense(256))
model.add(Activation("relu"))
model.add(Dense(128))
model.add(Activation("relu"))
model.add(Dense(2))
model.add(Activation("softmax"))
model.compile(loss='categorical_crossentropy',
optimizer=Adam(learning_rate=1e-3),
metrics=["accuracy"])
model.summary()
checkpoint = ModelCheckpoint(filepath=os.path.join('saved_models', filename,
"model_best.h5"),
monitor='val_accuracy',
verbose=1,
save_best_only=True,
mode='auto',
save_weights_only=False)
csv_logger = CSVLogger(os.path.join('saved_models', filename,
"model_history_log.csv"),
append=True)
steps_per_epoch = n_files_train * (n_events_per_file // batch_size)
def entrenamiento(kfold, etapa, datos, arquitectura, train_epochs,
batch_epochs, early_stopping, iteracion, models_info,
pipeline):
import time
start_model = time.time()
base_model, preprocess_input = get_model(arquitectura, iteracion,
models_info, pipeline)
model_performance = {}
if dataset == 'gleasson':
datagen = ImageDataGenerator(preprocessing_function=preprocess_input,
rotation_range=40,
width_shift_range=0.1,
height_shift_range=0.1,
shear_range=0.01,
zoom_range=[0.9, 1.25],
horizontal_flip=True,
vertical_flip=False,
fill_mode='reflect',
data_format='channels_last')
if etapa == 'train':
train_generator = datagen.flow_from_dataframe(
dataframe=datos['df_train'],
x_col=x_col_name,
y_col=y_col_name,
target_size=(pipeline['img_height'], pipeline['img_width']),
class_mode='categorical',
batch_size=pipeline["batch_size"],
seed=42,
shuffle=True)
if etapa == 'train_EL':
train_generator = datagen.flow_from_dataframe(
dataframe=datos['df_train_EL'],
x_col=x_col_name,
y_col=y_col_name,
target_size=(pipeline['img_height'], pipeline['img_width']),
class_mode='categorical',
batch_size=pipeline["batch_size"],
seed=42,
shuffle=True)
if len(datos['df_val']) > 0:
val_datagen = ImageDataGenerator(
preprocessing_function=preprocess_input)
valid_generator = val_datagen.flow_from_dataframe(
dataframe=datos['df_val'],
x_col=x_col_name,
y_col=y_col_name,
batch_size=pipeline["batch_size"],
seed=42,
shuffle=True,
class_mode="categorical",
target_size=(pipeline['img_height'], pipeline['img_width']))
test_datagen = ImageDataGenerator(preprocessing_function=preprocess_input)
if dataset == 'gleasson':
test1_generator = test_datagen.flow_from_dataframe(
dataframe=datos['df_test1'],
x_col="patch_name1",
y_col="grade_1",
batch_size=pipeline["batch_size"],
seed=42,
shuffle=False,
class_mode="categorical",
target_size=(pipeline['img_height'], pipeline['img_width']))
test2_generator = test_datagen.flow_from_dataframe(
dataframe=datos['df_test2'],
x_col="patch_name2",
y_col="grade_2",
batch_size=pipeline["batch_size"],
seed=42,
shuffle=False,
class_mode="categorical",
target_size=(pipeline['img_height'], pipeline['img_width']))
if etapa == 'train' or etapa == 'train_EL':
finetune_model = transfer_learning_soft(
base_model, pipeline["class_num"],
pipeline["stage_config"][iteracion])
#entrenar modelo
from tensorflow.keras.optimizers import SGD, Adam, RMSprop
if etapa == 'train':
NUM_EPOCHS = train_epochs
num_train_images = len(
datos['df_train']) * pipeline["augmenting_factor"]
datos_entrenamiento = datos['df_train'].copy()
if etapa == 'train_EL':
NUM_EPOCHS = batch_epochs
num_train_images = len(
datos['df_train_EL']) * pipeline["augmenting_factor"]
datos_entrenamiento = datos['df_train_EL'].copy()
STEP_SIZE_TRAIN = num_train_images // train_generator.batch_size
if len(datos['df_val']) > 0:
STEP_SIZE_VALID = valid_generator.n // valid_generator.batch_size
STEP_SIZE_TEST1 = test1_generator.n // test1_generator.batch_size
if dataset == 'gleasson':
STEP_SIZE_TEST2 = test2_generator.n // test2_generator.batch_size
if len(datos['df_val']) > 0:
generator_seguimiento = valid_generator
pasos_seguimiento = STEP_SIZE_VALID
else:
generator_seguimiento = test1_generator
pasos_seguimiento = STEP_SIZE_TEST1
if pipeline["class_num"] > 3:
metrics = ['accuracy']
loss = 'categorical_crossentropy'
peso_clases = {}
total = datos_entrenamiento.shape[0]
weights = (total /
datos_entrenamiento.groupby(y_col_name).count().values) / 4
peso_clases = {
0: weights[0][0],
1: weights[1][0],
2: weights[2][0],
3: weights[3][0]
}
#print(datos_entrenamiento.groupby(y_col_name))
print(datos_entrenamiento.groupby(y_col_name).count())
print(datos_entrenamiento.groupby(y_col_name).count().values)
max_class_num = np.argmax(
datos_entrenamiento.groupby(y_col_name).count().values)
print('id_maximo', max_class_num)
peso_clases = {}
class_num = datos_entrenamiento.groupby(y_col_name).count().values
print('num_maximo', class_num[max_class_num])
weights = class_num[max_class_num] / datos_entrenamiento.groupby(
y_col_name).count().values
print(weights)
peso_clases = {
0: weights[0][0],
1: weights[1][0],
2: weights[2][0],
3: weights[3][0]
}
print(peso_clases)
if pipeline["class_num"] == 3:
metrics = ['accuracy']
# calcular pesos de cada clase
total = datos_entrenamiento.shape[0]
weights = (total /
datos_entrenamiento.groupby(y_col_name).count().values) / 3
peso_clases = {0: weights[0][0], 1: weights[1][0], 2: weights[2][0]}
elif pipeline["class_num"] == 2:
metrics = ['accuracy']
# calcular pesos de cada clase
total = datos_entrenamiento.shape[0]
weights = (total /
datos_entrenamiento.groupby(y_col_name).count().values) / 2
peso_clases = {0: weights[0][0], 1: weights[1][0]}
loss = 'binary_crossentropy'
adam = Adam(lr=pipeline["stage_config"][iteracion]['LR'])
finetune_model.compile(adam, loss=loss, metrics=metrics)
early = EarlyStopping(monitor='val_loss',
min_delta=1e-3,
patience=5,
verbose=1,
restore_best_weights=True)
if len(peso_clases) > 0:
print("\n")
print("ESTOY USANDO PESADO DE CLASES!")
print(peso_clases)
print("##############################")
print("\n")
history = finetune_model.fit(train_generator,
epochs=NUM_EPOCHS,
workers=1,
steps_per_epoch=STEP_SIZE_TRAIN,
validation_data=generator_seguimiento,
validation_steps=pasos_seguimiento,
callbacks=[early],
verbose=1,
class_weight=peso_clases)
else:
history = finetune_model.fit(train_generator,
epochs=NUM_EPOCHS,
workers=1,
steps_per_epoch=STEP_SIZE_TRAIN,
validation_data=generator_seguimiento,
validation_steps=pasos_seguimiento,
verbose=1,
callbacks=[early])
if len(datos['df_val']) > 0:
score1 = finetune_model.evaluate(valid_generator,
verbose=0,
steps=STEP_SIZE_VALID)
score2 = finetune_model.evaluate(test1_generator,
verbose=0,
steps=STEP_SIZE_TEST1)
if dataset == 'gleasson':
score3 = finetune_model.evaluate_generator(generator=test2_generator,
verbose=1,
steps=STEP_SIZE_TEST2)
if len(datos['df_val']) > 0:
print("Val Loss : ", score1[0])
print("Val Accuracy : ", score1[1])
print("\n")
print("Test1 Loss : ", score2[0])
print("Test1 Accuracy : ", score2[1])
print("\n")
if dataset == 'gleasson':
print("Test2 Loss : ", score3[0])
print("Test2 Accuracy : ", score3[1])
logs.append([
kfold, iteracion, arquitectura, score1[0], score1[1], score2[0],
score2[1], score3[0], score3[1]
])
#guardar_logs(ruta,[logs[-1]])
save_logs(logs, 'train', pipeline)
# Plot training & validation accuracy values
#print(history.history)
#print('--- Val acc ---')
#print(history.history['val_acc'])
plt.plot(history.history['acc'])
if len(datos['df_val']) > 0:
plt.plot(history.history['val_acc'])
plt.title('Model accuracy - {}'.format(arquitectura))
plt.ylabel('Accuracy')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
# Plot training & validation loss values
plt.plot(history.history['loss'])
if len(datos['df_val']) > 0:
plt.plot(history.history['val_loss'])
plt.title('Model loss - {}'.format(arquitectura))
plt.ylabel('Loss')
plt.xlabel('Epoch')
plt.legend(['Train', 'Test'], loc='upper left')
plt.show()
end_model = time.time()
time_training = end_model - start_model
print(f"training {arquitectura}", time_training)
if pipeline['save_model']:
save_path_model = os.path.join(
pipeline['save_path_model'],
f'{kfold}_{iteracion}_{arquitectura}.h5')
finetune_model.save(save_path_model)
model_performance['val_acc'] = score1[1]
return save_path_model, model_performance
logs_time.append([kfold, iteracion, arquitectura, time_training])
save_logs(logs_time, 'time', pipeline)
#pipeline['logs_model']
#time_training
model_performance['val_acc'] = score1[1]
model_performance['test1_acc'] = score2[1]
model_performance['test2_acc'] = score3[1]
return finetune_model, model_performance
def SiameseNet(image_shape):
'''
left_input = Input(image_shape)
right_input = Input(image_shape)
convnet = Sequential([
Conv2D(5,3, input_shape=image_shape),
Activation('relu'),
MaxPooling2D(),
Conv2D(5,3),
Activation('relu'),
MaxPooling2D(),
Conv2D(7,2),
Activation('relu'),
MaxPooling2D(),
Conv2D(7,2),
Activation('relu'),
Dropout(.20),
Flatten(),
Dense(18) ,
kernel_regularizer=regularizers.l2(1e-4),
bias_regularizer=regularizers.l2(1e-4),
activity_regularizer=regularizers.l2(1e-5)),
Activation('sigmoid')
])
'''
left_input = Input(image_shape)
right_input = Input(image_shape)
# Embedding Net
convnet = Sequential([
Conv2D(50, 3, input_shape=image_shape),
Activation('relu'),
MaxPooling2D(3),
Conv2D(80, 3),
Activation('relu'),
MaxPooling2D(3),
Conv2D(80, 2),
Activation('relu'),
MaxPooling2D(2),
Conv2D(100, 2),
Activation('relu'),
Dropout(.25),
Flatten(),
Dense(256),
Dense(128,
kernel_regularizer=regularizers.l2(1e-4),
bias_regularizer=regularizers.l2(1e-4),
activity_regularizer=regularizers.l2(1e-5)),
Activation('relu') #linear
])
###################################### --OPTION 2-- ##########################################
def euclidean_distance(vects):
x, y = vects
sum_square = K.sum(K.square(x - y), axis=1, keepdims=True)
return K.sqrt(K.maximum(sum_square, K.epsilon()))
def eucl_dist_output_shape(shapes):
shape1, shape2 = shapes
return (shape1[0], 1)
encoded_l = convnet(left_input)
encoded_r = convnet(right_input)
distance = Lambda(euclidean_distance, output_shape=eucl_dist_output_shape)(
[encoded_l, encoded_r])
predictions = Dense(1, activation='sigmoid')(distance)
siamese_net = Model(inputs=[left_input, right_input], outputs=predictions)
def contrastive_loss(y_true, y_pred):
'''Contrastive loss from Hadsell-et-al.'06
http://yann.lecun.com/exdb/publis/pdf/hadsell-chopra-lecun-06.pdf
'''
margin = 1
square_pred = K.square(y_pred)
margin_square = K.square(K.maximum(margin - y_pred, 0))
return K.mean(y_true * square_pred + (1 - y_true) * margin_square)
def accuracy(y_true, y_pred):
'''Compute classification accuracy with a fixed threshold on distances.
'''
return K.mean(K.equal(y_true, K.cast(y_pred < 0.5, y_true.dtype)))
optimizer = Adam(0.0001, decay=2.5e-4)
siamese_net.compile(loss=contrastive_loss,
optimizer=optimizer,
metrics=[accuracy])
return siamese_net
headModel = Dense(128, activation="relu")(headModel)
headModel = Dropout(0.5)(headModel)
headModel = Dense(2, activation="softmax")(headModel)
# place the head FC model on top of the base model (this will become
# the actual model we will train)
model = Model(inputs=baseModel.input, outputs=headModel)
# loop over all layers in the base model and freeze them so they will
# *not* be updated during the first training process
for layer in baseModel.layers:
layer.trainable = False
# compile our model
print("[INFO] compiling model...")
opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
model.compile(loss="binary_crossentropy", optimizer=opt, metrics=["accuracy"])
# train the head of the network
print("[INFO] training head...")
H = model.fit(aug.flow(trainX, trainY, batch_size=BS),
steps_per_epoch=len(trainX) // BS,
validation_data=(testX, testY),
validation_steps=len(testX) // BS,
epochs=EPOCHS)
# make predictions on the testing set
print("[INFO] evaluating network...")
predIdxs = model.predict(testX, batch_size=BS)
# for each image in the testing set we need to find the index of the
# label with corresponding largest predicted probability
# 预热期
warmup_epoch = int((Freeze_epoch - Init_epoch) * 0.2)
# 总共的步长
total_steps = int(
(Freeze_epoch - Init_epoch) * num_train / batch_size)
# 预热步长
warmup_steps = int(warmup_epoch * num_train / batch_size)
# 学习率
reduce_lr = WarmUpCosineDecayScheduler(
learning_rate_base=learning_rate_base,
total_steps=total_steps,
warmup_learning_rate=1e-4,
warmup_steps=warmup_steps,
hold_base_rate_steps=num_train,
min_learn_rate=1e-6)
model.compile(optimizer=Adam(),
loss={
'yolo_loss': lambda y_true, y_pred: y_pred
})
else:
reduce_lr = ReduceLROnPlateau(monitor='val_loss',
factor=0.5,
patience=2,
verbose=1)
model.compile(optimizer=Adam(learning_rate_base),
loss={
'yolo_loss': lambda y_true, y_pred: y_pred
})
print('Train on {} samples, val on {} samples, with batch size {}.'.
format(num_train, num_val, batch_size))
