def ejer_3_1():
#fig1, ax1 = plt.subplots()
fig2, ax2 = plt.subplots()
# ax1.set_title('Exactitud')
# ax1.set_xlabel('Épocas')
# ax1.set_ylabel('Exactitud')
ax2.set_title(' Entrenamiento (-), Validación ($\\cdot\\cdot$)')
ax2.set_xlabel('Épocas')
ax2.set_ylabel('Pérdida Normalizada')
plot_num = 6
epochs_total = 200
ej_vec = np.array([10, 24, 50], dtype=np.int)
training_data, target_data = logistic_training(120)
ejemplos_color = ['red', 'black', 'blue', 'orange']
for y in range(len(ej_vec)):
inp1 = layers.Input(shape=(1, ))
x = layers.Dense(5,
activation='tanh',
use_bias=True,
bias_initializer='random_uniform')(inp1)
x = layers.Concatenate()([inp1, x])
output = layers.Dense(1,
activation='linear',
use_bias=True,
bias_initializer='random_uniform')(x)
model = models.Model(inputs=inp1, outputs=output)
#model.summary()
sgd = optimizers.SGD(lr=0.008)
#print(y)ss
model.compile(optimizer=sgd, loss='MSE', metrics=['mse'])
size_vec = ej_vec[y]
test_size = int(size_vec * 0.5)
x_train = training_data[:size_vec]
y_train = target_data[:size_vec]
x_test = training_data[size_vec:size_vec + test_size]
y_test = target_data[size_vec:size_vec + test_size]
history = model.fit(x_train,
y_train,
validation_data=(x_test, y_test),
epochs=epochs_total)
loss = np.array(history.history['loss'])
val_loss = np.array(history.history['val_loss'])
epocas = np.arange(len(loss))
#ax1.plot(epocas, acc, label=str(size_vec), color=ejemplos_color[y])
ax2.plot(epocas,
val_loss / np.max(val_loss),
':',
label=str(test_size),
alpha=0.6,
color=ejemplos_color[y])
ax2.plot(epocas,
loss / np.max(loss),
'-',
label=str(size_vec),
alpha=0.6,
color=ejemplos_color[y])
tf.keras.backend.clear_session()
ax2.legend(loc=0, title="Ejemplos", ncol=3)
#ax1.legend(loc='lower right', title="Ejemplos", ncol=3)
#fig1.savefig('../docs/Figs/ejer_5_acc.pdf')
fig2.savefig('../docs/Figs/ejer_5_los_gen.pdf')
plt.show()
def train():
BATCH_SIZE = 128
EPOCHS = 50
data_train = get_dataset(tfds.Split.TRAIN, BATCH_SIZE)
data_test = get_dataset(tfds.Split.TEST, BATCH_SIZE)
train_loss = tf.keras.metrics.Mean(name='train_loss')
train_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
name='train_accuracy')
test_loss = tf.keras.metrics.Mean(name='test_loss')
test_accuracy = tf.keras.metrics.SparseCategoricalAccuracy(
name='test_accuracy')
train_writer = tf.summary.create_file_writer(str(tb_path / 'train'))
test_writer = tf.summary.create_file_writer(str(tb_path / 'test'))
tf.summary.trace_on(graph=True)
model = get_model()
loss_function = tf.keras.losses.SparseCategoricalCrossentropy()
optimizer = optimizers.SGD(lr=0.01, momentum=0.9, nesterov=True)
@tf.function
def train_one_step(x, y):
with tf.GradientTape() as tape:
y_pred = model(x)
loss = loss_function(y_true=y, y_pred=y_pred)
gradients = tape.gradient(loss, model.trainable_variables)
optimizer.apply_gradients(zip(gradients, model.trainable_variables))
train_loss(loss)
train_accuracy(y, y_pred)
@tf.function
def test_one_step(x, y):
y_pred = model(x)
loss = loss_function(y_true=y, y_pred=y_pred)
test_loss(loss)
test_accuracy(y, y_pred)
for num_epoch in range(EPOCHS):
train_loss.reset_states()
train_accuracy.reset_states()
for batch_num, (images, labels) in enumerate(data_train):
train_one_step(images, labels)
print(f'Batch {batch_num}', end='\r')
with train_writer.as_default():
tf.summary.scalar("loss", train_loss.result(), step=num_epoch)
tf.summary.scalar("accuracy",
train_accuracy.result(),
step=num_epoch)
print('Epoch {}, Loss: {}, Accuracy: {}'.format(
num_epoch + 1, train_loss.result(),
train_accuracy.result() * 100))
if (num_epoch + 1) % 2 == 0:
test_loss.reset_states()
test_accuracy.reset_states()
for batch_num, (images, labels) in enumerate(data_test):
test_one_step(images, labels)
print(f'Test Batch {batch_num}', end='\r')
with test_writer.as_default():
tf.summary.scalar("loss", test_loss.result(), step=num_epoch)
tf.summary.scalar("accuracy",
test_accuracy.result(),
step=num_epoch)
print('Test Loss: {}, Test Accuracy: {}'.format(
test_loss.result(),
test_accuracy.result() * 100))
with train_writer.as_default():
tf.summary.trace_export(name='model_graph', step=0)
return model
def get_optimizer(opts):
if opts.optimizer == "sgd":
return optimizers.SGD(lr=opts.lr)
raise Exception("unknown optimizer")
#定义模型，初始化参数
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow import initializers
model = keras.Sequential()
model.add(
layers.Dense(1, kernel_initializer=initializers.RandomNormal(stddev=0.01)))
#定义损失函数
from tensorflow import losses
loss = losses.MeanSquaredError()
#定义优化算法
from tensorflow.keras import optimizers
trainer = optimizers.SGD(learning_rate=0.01)
#训练模型
num_epochs = 3
for epoch in range(1, num_epochs + 1):
for (batch, (X, y)) in enumerate(dataset):
with tf.GradientTape(persistent=True) as t:
l = loss(model(X, training=True), y)
grads = t.gradient(l, model.trainable_variables)
trainer.apply_gradients(zip(grads, model.trainable_variables))
l = loss(model(features), labels)
print('epoch %d, loss: %f' % (epoch, l.numpy().mean()))
print(model.get_weights())
model = tf.keras.Sequential([
layers.Reshape(target_shape=[28, 28, 1], input_shape=(
28,
28,
)),
layers.Conv2D(2, 5, padding='same', activation=tf.nn.relu),
layers.MaxPooling2D((2, 2), (2, 2), padding='same'),
layers.Conv2D(4, 5, padding='same', activation=tf.nn.relu),
layers.MaxPooling2D((2, 2), (2, 2), padding='same'),
layers.Flatten(),
layers.Dense(32, activation=tf.nn.relu),
layers.Dropout(rate=0.4),
layers.Dense(10)
])
optimizer = optimizers.SGD(learning_rate=0.01, momentum=0.5)
def mnist_datasets():
(x_train, y_train), (x_test, y_test) = datasets.mnist.load_data()
# Numpy defaults to dtype=float64; TF defaults to float32. Stick with float32.
x_train, x_test = x_train / np.float32(255), x_test / np.float32(255)
y_train, y_test = y_train.astype(np.int64), y_test.astype(np.int64)
train_dataset = tf.data.Dataset.from_tensor_slices((x_train, y_train))
test_dataset = tf.data.Dataset.from_tensor_slices((x_test, y_test))
return train_dataset, test_dataset
train_ds, test_ds = mnist_datasets()
train_ds = train_ds.shuffle(60000).batch(100)
test_ds = test_ds.batch(100)
print(e)
# classes = ['111', '112', '113', '114', '115',
# '221', '222', '223', '224', '225']
classes = ['desert', 'sunset', 'trees', 'mountains', 'sea']
print(classes)
model = Sequential()
model.add(
InceptionResNetV2(include_top=False, pooling='avg', weights='imagenet'))
# model.add(Dense(10, activation='sigmoid'))
model.add(Dense(len(classes), activation='sigmoid'))
model.layers[0].trainable = True
model.summary()
optimizer = optimizers.SGD(lr=0.01, decay=1e-6, momentum=0.9, nesterov=True)
# optimizer = optimizers.Adam()
model.compile(optimizer=optimizer,
loss='binary_crossentropy',
metrics=['accuracy'])
# model.load_weights('/data/backup/pervinco_2020/model/multi_label/2020.05.07_17:27_keras/08-1.00.hdf5')
model.load_weights(
'/data/backup/pervinco_2020/model/multi_label_cls/2020.05.11_10:33_keras/10-1.00.hdf5'
)
# model = tf.keras.models.load_model('/data/backup/pervinco_2020/model/multi_label/test.h5')
test_imgs = sorted(
glob.glob(
'/data/backup/pervinco_2020/datasets/multi_label_cls/test_imgs/*.jpg'))
def run_k_fold(multi_data, X, Y, CLASSES, epoch, MODEL, BATCH_SIZE, num_folds):
VALIDATION_ACCURACY = []
VALIDATION_LOSS = []
HISTORY = []
MODEL_NAME = MODEL
FOLDS = num_folds
EPOCHS = epoch
save_dir = os.path.join(os.getcwd(), 'models/')
VERBOSE = 1
skf = StratifiedKFold(n_splits=FOLDS, random_state=7, shuffle=True)
fold_var = 1
for train_index, val_index in skf.split(X, Y):
print("=======EPOCHS ", EPOCHS, " Start--k: ", fold_var)
training_data = multi_data.iloc[train_index]
validation_data = multi_data.iloc[val_index]
print(training_data.shape)
print(validation_data.shape)
# directory_mover(training_data,"training_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var))
# directory_mover(validation_data,"validation_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var))
# flow_from_dataframe
train_data_generator = dataTrainAugmentation().flow_from_dataframe(
dataframe=training_data,
directory=os.path.join(
os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'),
target_size=(250, 250),
x_col="image_path",
y_col="name",
batch_size=BATCH_SIZE,
class_mode="categorical",
shuffle=False)
valid_data_generator = dataTrainAugmentation().flow_from_dataframe(
dataframe=validation_data,
directory=os.path.join(
os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'),
target_size=(250, 250),
x_col="image_path",
y_col="name",
batch_size=BATCH_SIZE,
class_mode="categorical",
shuffle=False)
model = get_model(MODEL, CLASSES)
# rmsprop = RMSprop(lr=1e-3, decay=1e-6)
sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['acc'])
# CREATE CALLBACKS
checkpoint = tf.keras.callbacks.ModelCheckpoint(
save_dir + get_model_name(MODEL_NAME, fold_var, BATCH_SIZE),
monitor='val_acc',
verbose=VERBOSE,
save_best_only=True,
mode='max')
earlystopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss',
mode='min',
verbose=VERBOSE,
patience=200)
callbacks_list = [checkpoint, earlystopping]
'''
STEP_SIZE_TRAIN=train_data_generator.n//train_data_generator.batch_size
STEP_SIZE_VALID=valid_data_generator.n//valid_data_generator.batch_size
print("STEP_SIZE_TRAIN ",STEP_SIZE_TRAIN)
print("STEP_SIZE_VALID ",STEP_SIZE_VALID)
history = model.fit_generator(generator=train_data_generator,
steps_per_epoch=STEP_SIZE_TRAIN,
#steps_per_epoch=training_data.shape[0],
validation_data=valid_data_generator,
validation_steps=STEP_SIZE_VALID,
#validation_steps=validation_data.shape[0],
epochs=EPOCHS,
#callbacks=callbacks_list,
verbose=VERBOSE)
'''
history = model.fit(train_data_generator,
epochs=EPOCHS,
steps_per_epoch=train_data_generator.n //
train_data_generator.batch_size,
callbacks=callbacks_list,
validation_data=valid_data_generator,
validation_steps=valid_data_generator.n //
valid_data_generator.batch_size,
verbose=VERBOSE)
HISTORY.append(history)
# LOAD BEST MODEL to evaluate the performance of the model model_"+MODEL_NAME+"_"+str(fold_var)+".h5"
model.load_weights(os.getcwd() + "/models/model_main2" + MODEL_NAME +
"_" + str(fold_var) + '_' + str(BATCH_SIZE) + ".h5")
results = model.evaluate(valid_data_generator)
# results = model.evaluate_generator(valid_data_generator)
results = dict(zip(model.metrics_names, results))
VALIDATION_ACCURACY.append(results['acc'])
VALIDATION_LOSS.append(results['loss'])
write_results(
get_current_time_str() + 'main2_k_fold_' + str(CLASSES) + '_' +
MODEL_NAME + '_' + str(EPOCHS) + '_' + str(BATCH_SIZE) + '.txt',
VALIDATION_ACCURACY, VALIDATION_LOSS, HISTORY)
del history
del model
tf.keras.backend.clear_session()
gc.collect()
fold_var += 1
def defineModel(self):
verbose = False
latentDim = self.latentDim
#define encoder model
encoder_inputLayer_s = ActorCritic_general.generateActionInputLayer(
self.actionSpace)
if len(encoder_inputLayer_s) > 1:
encoder_inputLayer = concatenate(encoder_inputLayer_s,
name='concattenated_input')
else:
encoder_inputLayer = encoder_inputLayer_s[0]
#encoder_intLayer = Dense(latentDim*4,activation='relu')(encoder_inputLayers)
encoder_intLayer_last = Dense(latentDim * 2,
activation='relu',
name='encoding')(encoder_inputLayer)
encoder_meanLayer = Dense(latentDim,
activation='relu',
name='latent_means')(encoder_intLayer_last)
encoder_logVarianceLayer = Dense(
latentDim,
activation='relu',
bias_initializer=Constant(value=0),
name='latent_log_variance')(encoder_intLayer_last)
#encoder_outputLayer = Dense(latentDim)(concatenate([encoder_meanLayer,encoder_logVarianceLayer]))
encoder_outputLayer = Lambda(VAE_sampling,
output_shape=(latentDim, ),
name='sampling_latent_action')([
encoder_meanLayer,
encoder_logVarianceLayer
])
#encoder_outputLayers = [encoder_meanLayer,encoder_logVarianceLayer,encoder_outputLayer]
encoder_Model = Model(encoder_inputLayer_s,
encoder_outputLayer,
name='encoder')
if verbose:
encoder_Model.summary()
#plot_model(encoder_Model, to_file='vae_encoder.png', show_shapes=True)
#define decoder model
decoder_inputLayerLatentAction = Input(shape=(latentDim, ),
name='latentLayer')
#decoder_intLayer = Dense(latentDim*2,activation='relu')(decoder_inputLayerLatentAction)
decoder_intLayer_last = Dense(
latentDim * 2, activation='relu',
name='decoding')(decoder_inputLayerLatentAction)
decoder_outputLayer, losses_reconstruction = ActorCritic_general.generateActionOutputLayer(
self.actionSpace, decoder_intLayer_last)
decoder_Model = Model(decoder_inputLayerLatentAction,
decoder_outputLayer,
name='decoder')
if verbose:
decoder_Model.summary()
sgd = optimizers.SGD(lr=1)
decoder_Model.compile(optimizer=sgd,
loss='mean_squared_error',
metrics=['accuracy'])
#plot_model(decoder_Model, to_file='vae_decoder.png', show_shapes=True)
#define VAE model
outputs = decoder_Model(encoder_Model(encoder_inputLayer_s))
vae_model = Model(encoder_inputLayer_s, outputs, name='vae')
if verbose:
vae_model.summary()
plot_model(vae_model,
to_file='vae_model.png',
show_shapes=True,
expand_nested=True)
#add KL-divergence to losses
kl_loss = 1 + encoder_logVarianceLayer - K.square(
encoder_meanLayer) - K.exp(encoder_logVarianceLayer)
kl_loss = K.sum(kl_loss, axis=-1)
kl_loss *= -0.5
losses = []
for i, loss_recon_str in enumerate(losses_reconstruction):
loss = self.lossWrapper(kl_loss, loss_recon_str)
losses.append(loss)
#vae_model.add_loss(losses)
#define model
sgd = optimizers.SGD(lr=1)
vae_model.compile(optimizer=sgd,
loss=losses_reconstruction,
metrics=['accuracy'])
#save models
self.model = vae_model
def parameter_update(theta_0,
ln_q,
ln_1_q,
ln_s,
mu,
sigma,
n_u,
n_y,
jitter,
sample_size_w=1024,
batch_size=None,
val_size=None,
optimizer_choice='adam',
lr=1e-3,
max_batch=int(4096),
tol=8,
factr=1e-3,
plot_loss=True,
print_info=True):
batch_L = []
gap = []
if optimizer_choice == 'adam':
optimizer = optimizers.Adam(lr=lr)
elif optimizer_choice == 'adadelta':
optimizer = optimizers.Adadelta(lr=lr)
elif optimizer_choice == 'adagrad':
optimizer = optimizers.Adagrad(lr=lr)
elif optimizer_choice == 'adamax':
optimizer = optimizers.Adamax(lr=lr)
elif optimizer_choice == 'ftrl':
optimizer = optimizers.Ftrl(lr=lr)
elif optimizer_choice == 'nadam':
optimizer = optimizers.Nadam(lr=lr)
elif optimizer_choice == 'rmsprop':
optimizer = optimizers.RMSprop(lr=lr)
elif optimizer_choice == 'sgd':
optimizer = optimizers.SGD(lr=lr)
else:
optimizer = None
theta = tf.Variable(theta_0)
fin_theta = theta_0.copy()
if val_size is not None:
if val_size > n_y:
val_size = n_y
val_idx = numpy.arange(0, n_y)
else:
val_idx = numpy.random.choice(numpy.arange(0, n_y),
val_size,
replace=False)
else:
val_idx = None
for i in range(0, int(1e8)):
if batch_size is None:
tmp_idx = numpy.arange(0, n_y)
else:
tmp_idx = numpy.random.choice(numpy.arange(0, n_y),
batch_size,
replace=False)
raw_sample_w = tf.random.normal((sample_size_w, 3 * len(tmp_idx)),
dtype='float64')
L_t, g_t = get_obj_g(theta, ln_q[tmp_idx], ln_1_q[tmp_idx],
ln_s[tmp_idx], mu[tmp_idx], sigma[tmp_idx], n_u,
len(tmp_idx), n_y, raw_sample_w, jitter)
optimizer.apply_gradients(zip([g_t], [theta]))
theta = theta.numpy()
theta[:2] = numpy.abs(theta[:2])
theta[:2][theta[:2] <= 1e-8] = 1e-8
theta[5:8][theta[5:8] <= 1e-8] = 1e-8
if val_size is not None:
if numpy.mod(i, numpy.min([numpy.floor(tol / 2), 8])) == 0:
raw_sample_w = tf.random.normal((sample_size_w, 3 * val_size),
dtype='float64')
tmp_L_t = vi_obj(theta, ln_q[val_idx], ln_1_q[val_idx],
ln_s[val_idx], mu[val_idx], sigma[val_idx],
n_u, val_size, n_y, raw_sample_w, jitter)
tmp_L = (tmp_L_t.numpy() / n_y)
else:
tmp_L = (L_t.numpy() / n_y)
batch_L.append(numpy.min(tmp_L))
if len(batch_L) >= 2:
if tmp_L < numpy.min(batch_L[:-1]):
fin_theta = theta.copy()
theta = tf.Variable(theta)
if (numpy.mod(len(batch_L), tol) == 0) & print_info:
print(
'============================================================================='
)
print(theta[:8])
print(theta[-6:])
print('Batch: ' + str(len(batch_L)) + ', optimiser: ' +
optimizer_choice + ', Loss: ' + str(tmp_L))
print(
'============================================================================='
)
if len(batch_L) > tol:
previous_opt = numpy.min(batch_L.copy()[:-tol])
current_opt = numpy.min(batch_L.copy()[-tol:])
gap.append(previous_opt - current_opt)
if (numpy.mod(len(batch_L), tol) == 0) & print_info:
print('Previous And Recent Top Averaged Loss Is:')
print(numpy.hstack([previous_opt, current_opt]))
print('Current Improvement, Initial Improvement * factr')
print(numpy.hstack([gap[-1], gap[0] * factr]))
if (len(gap) >= 2) & (gap[-1] <= (gap[0] * factr)):
print('Total batch number: ' + str(len(batch_L)))
print('Initial Loss: ' + str(batch_L[0]))
print('Final Loss: ' + str(numpy.min(batch_L)))
print('Current Improvement, Initial Improvement * factr')
print(numpy.hstack([gap[-1], gap[0] * factr]))
break
if len(batch_L) >= max_batch:
break
if plot_loss:
fig = matplotlib.pyplot.figure(figsize=(16, 9))
matplotlib.pyplot.plot(numpy.arange(0, len(batch_L)),
numpy.array(batch_L))
matplotlib.pyplot.xlabel('Batches')
matplotlib.pyplot.ylabel('Loss')
matplotlib.pyplot.title('Learning Rate: ' + str(lr))
matplotlib.pyplot.grid(True)
try:
fig.savefig('./' + str(n_y) + '_' + str(n_u) + '_' +
optimizer_choice + '_' + str(lr) + '.png',
bbox_inches='tight')
except PermissionError:
pass
except OSError:
pass
matplotlib.pyplot.close(fig)
return fin_theta
def mdelvgg_build(img_resolucion, cfg, red_name=DEFAULT_NAME, save_model=True):
""" Construccion del modelo
"""
ke_vec = [4, 8, 16, 32]
fc_vec = [256, 256]
# input
x_in = Input(img_resolucion)
# bloque 0
kernelnum = ke_vec[0]
kernelsze = (3, 3)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_01',
padding='same',
activation='relu')(x_in)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_02',
padding='same',
activation='relu')(x)
x = MaxPooling2D(pool_size=(2, 2), name='max_pooling_0', strides=(2, 2))(x)
# bloque 1
kernelnum = ke_vec[1]
kernelsze = (3, 3)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_11',
padding='same',
activation='relu')(x_in)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_12',
padding='same',
activation='relu')(x)
x = AveragePooling2D(pool_size=(2, 2), name='Avg_pol_1', strides=(2, 2))(x)
# bloque 2
kernelnum = ke_vec[2]
kernelsze = (3, 3)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_21',
padding='same',
activation='relu')(x_in)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_22',
padding='same',
activation='relu')(x)
x = AveragePooling2D(pool_size=(2, 2), name='Avg_pol_2', strides=(2, 2))(x)
# # Bloque 3
kernelnum = ke_vec[3]
kernelsze = (3, 3)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_31',
padding='same',
activation='relu')(x_in)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_32',
padding='same',
activation='relu')(x)
x = Conv2D(kernelnum,
kernelsze,
strides=cfg['stride'],
name='conv3_33',
padding='same',
activation='relu')(x)
x = AveragePooling2D(pool_size=(2, 2), name='Avg_pol_3', strides=(2, 2))(x)
# # bloque 3
# kernelnum = int(256*preescaler)
# kernelsze = (3, 3)
# x = ZeroPadding2D(cfg['padding'])(x)
# x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'],
# name='conv3_31')(x)
# x = Conv2D(kernelnum, kernelsze, strides=cfg['stride'],
# name='conv3_32')(x)
# # x = BatchNormalization(axis=cfg['norm_ejes'], name='batch_normal_3')(x)
# x = Activation(cfg['l1_act'])(x)
# x = MaxPooling2D(cfg['maxpool_sze'], name='max_pooling_3')(x)
# Flatten
x = Flatten()(x)
# Fullyconected 0
x = Dense(fc_vec[0], activation=cfg['l1_act'], name='fully_conected_0')(x)
x = Dropout(0.5)(x)
# Fullyconected 1
x = Dense(fc_vec[1], activation=cfg['l1_act'], name='fully_conected_1')(x)
x = Dropout(0.2)(x)
# output0
x = Dense(2, activation=cfg['fc_act'], name='Salida')(x)
# Compilacion:
model_nc = Model(inputs=x_in, outputs=x, name='red_uno')
# compilación del modelo
model_cp = model_nc
opt = opti.SGD(lr=0.08, decay=1e-6, momentum=0.9, nesterov=True)
#opt = tfopti.Adam(learning_rate=0.001)
model_cp.compile(loss='sparse_categorical_crossentropy',
optimizer=opt,
metrics=cfg['metrica'])
# Graficando el modelo
os.makedirs(savepath, exist_ok=True)
print('Generando imagen del modelo')
plot_model(model_cp, to_file=os.path.join(savepath, red_name + '.png'))
if save_model:
model_cp.save(os.path.join(savepath, red_name + '.h5'))
return model_cp, model_nc
#Forward Pass and Generalisation
preds = model.predict_classes(X_test)
print("test acc: %0.4f" % np.mean(preds == y_test))
# One can use Tesorboard for visualising the loss in various models
%load_ext tensorboard
import datetime
from tensorflow.keras.callbacks import TensorBoard
model = Sequential()
model.add(Dense(hidden_dim, input_dim = input_dim, activation='tanh'))
model.add(Dense(hidden_dim, activation='tanh'))
model.add(Dense(output_dim, activation='softmax'))
model.compile(optimizer = optimizers.SGD(learning_rate=0.1), loss = 'categorical_crossentropy', metrics=['accuracy'] )
timestamp = datetime.datetime.now().strftime("Y%m%d-%H%M%S")
log_dir = "tensorboard_logs/" + timestamp
tensorboard_callback = TensorBoard(log_dir=log_dir, histogram_freq=1, write_graph=True)
model.fit(x=X_train, y=Y_train, validation_split=0.2, epochs=15, callbacks=[tensorboard_callback])
# Run the commmand below from command line rather than atom
!tensorboard --logdir tensorboard_logs
# Analysis of the exercise
# Setting the learning rate value to a small value (e.g. lr=0.001 on
# this dataset) makes the model train much slower (it has not
# converged yet after 15 epochs).
def create_model_cnn(self, params, input_shape):
'''
Create CCN model
'''
for layer in params['layers']:
neurons = layer['neurons'] if 'neurons' in layer else None
dropout_rate = layer['rate'] if 'rate' in layer else None
activation = layer['activation'] if 'activation' in layer else None
return_seq = layer['return_seq'] if 'return_seq' in layer else None
input_timesteps = layer[
'input_timesteps'] if 'input_timesteps' in layer else None
input_dim = layer['input_dim'] if 'input_dim' in layer else None
kernel_size = layer[
'kernel_size'] if 'kernel_size' in layer else None
strides = layer['strides'] if 'strides' in layer else None
padding = layer['padding'] if 'padding' in layer else None
use_bias = layer['use_bias'] if 'use_bias' in layer else None
pool_size = layer['pool_size'] if 'pool_size' in layer else None
if layer['type'] == 'dense':
if input_dim:
self.model.add(
Dense(neurons,
activation=activation,
input_shape=(input_dim, )))
else:
self.model.add(Dense(neurons, activation=activation))
if layer['type'] == 'lstm':
self.model.add(
LSTM(neurons,
input_shape=(input_timesteps, input_dim),
return_sequences=return_seq))
if layer['type'] == 'Conv2D':
self.model.add(
Conv2D(neurons,
kernel_size,
strides=strides,
input_shape=input_shape,
padding=padding,
activation=activation,
use_bias=use_bias,
kernel_initializer=RandomNormal(mean=0.0,
stddev=1e-2,
seed=None),
kernel_regularizer=l2(2e-4)))
if layer['type'] == 'MaxPool2D':
self.model.add(MaxPool2D(pool_size=pool_size))
if layer['type'] == 'BatchNormalization':
self.model.add(BatchNormalization())
if layer['type'] == 'flatten':
self.model.add(Flatten())
if layer['type'] == 'dropout':
self.model.add(Dropout(dropout_rate))
# Optimizer
if params["optimizer"] == 'rmsprop':
optimizer = optimizers.RMSprop(lr=params["lr"])
elif params["optimizer"] == 'sgd':
optimizer = optimizers.SGD(lr=params["lr"],
decay=1e-6,
momentum=0.9,
nesterov=True)
elif params["optimizer"] == 'adam':
optimizer = optimizers.Adam(learning_rate=params["lr"],
beta_1=0.9,
beta_2=0.999,
amsgrad=False)
metrics = []
for metric in params['metrics']:
if metric == 'accuracy': metrics.append(metric)
if metric == 'f1_score': metrics.append(f1_score)
if metric == 'precision': metrics.append(keras_metrics.precision())
if metric == 'recall': metrics.append(keras_metrics.recall())
self.model.compile(loss=params['loss'],
optimizer=optimizer,
metrics=metrics)
self.model.summary()
# ======================================
# Build, train, and use the classifier
# ======================================
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras import optimizers
from keras.utils import np_utils
input_layer = keras.Input(shape=(2,))
# hidden_layer_1 = layers.Dense(2, activation='relu')(input_layer)
output_layer = layers.Dense(1, activation='sigmoid')(input_layer)
optim = optimizers.SGD(lr=1.0)
model = keras.Model(inputs=input_layer, outputs=output_layer)
model.compile(optimizer=optim,
loss='binary_crossentropy',
metrics=['acc', 'mse'])
if (LoadModel==True):
# Load the trained model from disk
model.load_weights("2d_points_clas_model.h5")
else:
# Train
history = model.fit(x_train,
y_train,
batch_size=100,
print('INPUT_SHAPE = ', INPUT_SHAPE)
print('NUMBER_FEATURES_CONV =', NUMBER_FEATURES_CONV)
print('NUMBER_FEATURES_DENSE = ', NUMBER_FEATURES_DENSE)
print()
# load the model
print('loading the model ...')
model = build_model(NUMBER_FEATURES_CONV,
input_shape=INPUT_SHAPE,
n_features_dense=NUMBER_FEATURES_DENSE)
print()
# set optimizer and loss
opt = None
if optimizer == 'SGD':
opt = optimizers.SGD(lr=lrate, momentum=0.9, nesterov=True)
elif optimizer == 'Adam':
opt = optimizers.Adam(lr=0.0001, decay=1e-6)
else:
print('Specify the optimizer from [' 'Adam' ', ' 'SGD' ']')
print('compiling the model ...')
model.compile(loss='binary_crossentropy',
optimizer=opt,
metrics=['accuracy'])
print()
# model info
print('Model summary: ')
print(model.summary())
print()
# -print('images', len(images), images)
# -print('labels', len(labels), labels)
# -print(table)
# images:string path，labels:number
db = tf.data.Dataset.from_tensor_slices((images, labels))
db = db.shuffle(1000).map(preprocess).batch(32).repeat(20)
# Set the global constant as 150
num_classes = 150
model = AlexNet((227, 227, 3), num_classes)
model.summary()
# Train the model: compute gradients and update network parameters
optimizer = optimizers.SGD(lr=0.01)
acc_meter = metrics.Accuracy()
x_step = []
y_accuracy = []
# Input the batch for the training
for step, (x, y) in enumerate(db):
# Buld the gradient records
with tf.GradientTape() as tape:
# Flatten the input such as [b,28,28]->[b,784]
x = tf.reshape(x, (-1, 227, 227, 3))
output = model(x)
y_onehot = tf.one_hot(y, depth=150)
loss = tf.square(output - y_onehot)
loss = tf.reduce_sum(loss) / 32
# Compute the gradients of each parameter
grads = tape.gradient(loss, model.trainable_variables)
y = tf.one_hot(y, depth=10)
print(x.shape, y.shape)
train_dataset = tf.data.Dataset.from_tensor_slices((x, y))
train_dataset = train_dataset.batch(200)#一次返回200张图片一起计算
# for step,(x,y) in enumerate(train_dataset):
# print(step,x.shape,y,y.shape)
model = keras.Sequential([
layers.Dense(512, activation='relu'),#512指的是输出512
layers.Dense(256, activation='relu'),
layers.Dense(10)])
optimizer = optimizers.SGD(learning_rate=0.001)#随机梯度下降
def train_epoch(epoch):
# Step4.loop
for step, (x, y) in enumerate(train_dataset):
with tf.GradientTape() as tape:
# [b, 28, 28] => [b, 784]
x = tf.reshape(x, (-1, 28*28))
# Step1. compute output
# [b, 784] => [b, 10]
out = model(x)
# Step2. compute loss
x = tf.nn.relu(x)
# [b, 128] => [b, 64]
x = self.fc3(x)
x = tf.nn.relu(x)
# [b, 64 => [b, 32]
x = self.fc4(x)
x = tf.nn.relu(x)
# [b, 32] => [b, 10]
x = self.fc5(x)
return x
network = MyNetwork()
network.compile(
optimizer=optimizers.SGD(learning_rate=0.02, momentum=0.9),
# optimizer=optimizers.Adam(lr=1e-3),
loss=tf.losses.CategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
network.fit(train_db, epochs=15, validation_data=test_db, validation_freq=1)
network.evaluate(test_db)
network.save_weights('keras_train.ckpt')
del network
print('save to keras_train.ckpt')
network = MyNetwork()
network.compile(optimizer=optimizers.Adam(lr=1e-3),
loss=tf.losses.CategoricalCrossentropy(from_logits=True),
metrics=['accuracy'])
def cnn2d(input_shape, num_classes, args):
model = tf.keras.Sequential(name='CNN_2D')
# LFLB1
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
input_shape=input_shape,
kernel_regularizer=tf.keras.regularizers.l2(0.005)))
model.add(BatchNormalization(axis=1))
model.add(Activation('elu'))
model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
# LFLB2
model.add(
Conv2D(filters=64,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
kernel_regularizer=tf.keras.regularizers.l2(0.005)))
model.add(BatchNormalization(axis=1))
model.add(Activation('elu'))
model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4)))
# LFLB3
model.add(
Conv2D(filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
kernel_regularizer=tf.keras.regularizers.l2(0.005)))
model.add(BatchNormalization(axis=1))
model.add(Activation('elu'))
model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4)))
# LFLB4
model.add(
Conv2D(filters=128,
kernel_size=(3, 3),
strides=(1, 1),
padding='same',
kernel_regularizer=tf.keras.regularizers.l2(0.005)))
model.add(BatchNormalization(axis=1))
model.add(Activation('elu'))
model.add(MaxPooling2D(pool_size=(4, 4), strides=(4, 4)))
# LSTM
model.add(Reshape((1, 128)))
#model.add(Reshape((1, 384)))
#model.add(LSTM(units=256))
model.add(
LSTM(units=args.num_fc,
kernel_regularizer=tf.keras.regularizers.l2(0.005)))
# FC
model.add(Dense(units=num_classes, activation='softmax'))
# Model compilation
#opt = optimizers.SGD(lr=args.learning_rate, decay=args.decay,momentum=args.momentum, nesterov=True)
#opt = optimizers.Adam(lr=args.learning_rate)
opt = optimizers.SGD(lr=0.01, decay=1e-3, momentum=0.8)
model.compile(optimizer=opt,
loss='categorical_crossentropy',
metrics=['categorical_accuracy'])
return model
rec_len = X_train.shape[1]
num_classes = len(set(All_ECG_annotation[0]))
model = lstm_raw(rec_len, num_classes)
# build a learning decay schedule, use this during optimizer building.
lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay( # use exponetial learning rate decay during training
initial_learning_rate= 0.01,
decay_steps=100, # decay the learning rate every given decay_steps
decay_rate=0.96, # every time for decay learning rate, decay with decay_rate of exponential decay base.
staircase=False)
model.compile(
optimizer=optimizers.SGD(learning_rate=lr_schedule, momentum=0.9, nesterov=True), #decay=1e-6,
loss='sparse_categorical_crossentropy',
metrics=[tf.keras.metrics.sparse_categorical_accuracy])
tensorboard_cbk = tf.keras.callbacks.TensorBoard(
log_dir=directory, # directory where to write logs
histogram_freq=0, # How often to log histogram visualizations
embeddings_freq=0, # How often to log embedding visualizations
update_freq='epoch') # How often to write logs (default: once per epoch)
num_epoches = 4
model.fit(X_train, y_train, batch_size=32, epochs=num_epoches, shuffle=True,
callbacks=[tensorboard_cbk], # use tensorboard call back to visualize the training process
validation_data=(X_val, y_val))
plt.imshow(train_images[i], cmap='gray')
plt.title(train_labels[i])
plt.axis('off')
myInput = layers.Input(shape=(28, 28, 1))
conv1 = layers.Conv2D(16, 3, activation='relu', padding='same',
strides=2)(myInput)
conv2 = layers.Conv2D(32, 3, activation='relu', padding='same',
strides=2)(conv1)
flat = layers.Flatten()(conv2)
out_layer = layers.Dense(10, activation='softmax')(flat)
myModel = models.Model(myInput, out_layer)
myModel.summary()
myModel.compile(optimizer=optimizers.SGD(lr=0.001),
loss=losses.categorical_crossentropy)
# Train our model
history = myModel.fit(X_train,
Y_train,
batch_size=128,
epochs=20,
validation_split=0.2)
losses = history.history['loss']
val_losses = history.history['val_loss']
plt.plot(losses)
plt.plot(val_losses)
plt.xlabel('Epochs')
def run_hold_out(multi_data, X, Y, CLASSES, epoch, MODEL, BATCH_SIZE=32):
VALIDATION_ACCURACY = []
VALIDATION_LOSS = []
HISTORY = []
MODEL_NAME = MODEL
FOLDS = 2
EPOCHS = epoch
save_dir = os.path.join(os.getcwd(), 'models/')
VERBOSE = 1
fold_var = 7030
# directory_mover(multi_data,"multi_data_"+MODEL_NAME+str(BATCH_SIZE)+'_'+str(EPOCHS)+'_'+str(fold_var))
# no hold out da algum erro no flow_from_dataframe
train_data_generator = dataHoldOutAugmentation().flow_from_dataframe(
# training_data,
dataframe=multi_data,
directory=os.path.join(
os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'),
target_size=(250, 250),
x_col="image_path",
y_col="name",
batch_size=BATCH_SIZE,
subset="training",
class_mode="categorical",
# modificado apenas para verificar o hold out
shuffle=True)
valid_data_generator = dataHoldOutAugmentation().flow_from_dataframe(
# training_data,
dataframe=multi_data,
directory=os.path.join(
os.getcwd(), 'lfw-dataset/lfw-deepfunneled/lfw-deepfunneled/'),
target_size=(250, 250),
x_col="image_path",
y_col="name",
batch_size=BATCH_SIZE,
class_mode="categorical",
subset="validation",
# modificado apenas para verificar o hold out
shuffle=True)
model = get_model(MODEL, CLASSES)
sgd = optimizers.SGD(lr=1e-3, decay=1e-6, momentum=0.9, nesterov=True)
model.compile(optimizer=sgd,
loss='categorical_crossentropy',
metrics=['acc'])
# CREATE CALLBACKS
checkpoint = tf.keras.callbacks.ModelCheckpoint(
save_dir + get_model_name(MODEL_NAME, fold_var, BATCH_SIZE),
monitor='val_acc',
verbose=VERBOSE,
save_best_only=True,
mode='max')
earlystopping = tf.keras.callbacks.EarlyStopping(monitor='val_loss',
mode='min',
verbose=VERBOSE,
patience=500)
callbacks_list = [checkpoint, earlystopping]
history = model.fit(train_data_generator,
epochs=EPOCHS,
steps_per_epoch=train_data_generator.n //
train_data_generator.batch_size,
callbacks=callbacks_list,
validation_data=valid_data_generator,
validation_steps=valid_data_generator.n //
valid_data_generator.batch_size,
verbose=VERBOSE)
HISTORY.append(history)
# LOAD BEST MODEL to evaluate the performance of the model
model.load_weights(os.getcwd() + "/models/model_" + MODEL_NAME + "_" +
str(fold_var) + '_' + str(BATCH_SIZE) + ".h5")
results = model.evaluate(valid_data_generator)
# results = model.evaluate_generator(valid_data_generator)
results = dict(zip(model.metrics_names, results))
VALIDATION_ACCURACY.append(results['acc'])
VALIDATION_LOSS.append(results['loss'])
write_results(
get_current_time_str() + '_holdout_' + str(CLASSES) + '_' +
MODEL_NAME + '_' + str(EPOCHS) + '_' + str(BATCH_SIZE) + '.txt',
VALIDATION_ACCURACY, VALIDATION_LOSS, HISTORY)
# print('1st convolutional layer, 1st kernel weights:')
# print(np.squeeze(model.get_weights()[0][:,:,0,0]))
# print('1st convolutional layer, 1st kernel bias:')
# print(np.squeeze(model.get_weights()[1][0]))
# print('1st convolutional layer, 2nd kernel weights:')
# print(np.squeeze(model.get_weights()[0][:,:,0,1]))
# print('1st convolutional layer, 2nd kernel bias:')
# print(np.squeeze(model.get_weights()[1][1]))
# print('fully connected layer weights:')
# print(np.squeeze(model.get_weights()[2]))
# print('fully connected layer bias:')
# print(np.squeeze(model.get_weights()[3][0]))
sgd = optimizers.SGD(lr=1)
model.compile(loss='MSE', optimizer=sgd, metrics=['accuracy'])
history = model.fit(img, output, batch_size=1, epochs=1)
print('model output after:')
print(model.predict(img))
print('1st convolutional layer, 1st kernel weights:')
print(np.squeeze(model.get_weights()[0][:, :, 0, 0]))
print('1st convolutional layer, 1st kernel bias:')
print(np.squeeze(model.get_weights()[1][0]))
print('1st convolutional layer, 2nd kernel weights:')
print(np.squeeze(model.get_weights()[0][:, :, 0, 1]))
print('1st convolutional layer, 2nd kernel bias:')
print(np.squeeze(model.get_weights()[1][1]))
layers.MaxPooling2D(pool_size=2, strides=2), # 池化层，卷积核2*2，步长2
layers.ReLU(), # 激活函数
layers.Conv2D(16, kernel_size=3, strides=1), # 第二个卷积层，16个3*3*6卷积核
layers.MaxPooling2D(pool_size=2, strides=2), # 池化层
layers.ReLU(), # 激活函数
layers.Flatten(), # 拉直，方便全连接层处理
layers.Dense(120, activation='relu'), # 全连接层，120个节点
layers.Dense(84, activation='relu'), # 全连接层，84个节点
layers.Dense(10) # 输出层，10个节点
])
network.build(input_shape=(None, 28, 28,
1)) # 定义输入,batch_size=32,输入图片大小是28*28,通道数为1。
network.summary() # 显示出每层的待优化参数量
# 3.模型训练（计算梯度，迭代更新网络参数）
optimizer = optimizers.SGD(lr=0.01) # 声明采用批量随机梯度下降方法，学习率=0.01
acc_meter = metrics.Accuracy() # 新建accuracy测量器
for step, (x, y) in enumerate(train_dataset): # 一次输入batch组数据进行训练
with tf.GradientTape() as tape: # 构建梯度记录环境
x = tf.reshape(x, (32, 28, 28, 1)) # 将输入拉直，[b,28,28]->[b,784]
# x = tf.extand_dims(x, axis=3)
out = network(x) # 输出[b, 10]
y_onehot = tf.one_hot(y, depth=10) # one-hot编码
loss = tf.square(out - y_onehot)
loss = tf.reduce_sum(loss) / 32 # 定义均方差损失函数，注意此处的32对应为batch的大小
grads = tape.gradient(loss,
network.trainable_variables) # 计算网络中各个参数的梯度
optimizer.apply_gradients(zip(grads,
network.trainable_variables)) # 更新网络参数
acc_meter.update_state(tf.argmax(out, axis=1),
y) # 比较预测值与标签，并计算精确度（写入数据，进行求精度）
model.add(
layers.Conv2D(16, (3, 3), activation='relu', input_shape=(150, 225, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(16, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(16, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dropout(0.5))
model.add(layers.Dense(8, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
sgd = optimizers.SGD(lr=1e-2, decay=1e-6, momentum=0.9, nesterov=True)
# rmsprop = optimizers.RMSprop(lr=1e-2, decay=1e-6)
model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['acc'])
from tensorflow.keras.preprocessing.image import ImageDataGenerator
# All images will be rescaled by 1./255
train_datagen = ImageDataGenerator(rescale=1. / 255)
test_datagen = ImageDataGenerator(rescale=1. / 255)
# decreased batch size from 10 to 5
train_generator = train_datagen.flow_from_directory(
# This is the target directory
train_dir,
# All images will be resized to 150x225
target_size=(150, 225),
val_dataset = val_dataset.batch(200)
# 利用正态分布初始化
w = tf.Variable(initial_value=tf.random.normal((784, 10)))
b = tf.Variable(initial_value=tf.random.normal((10, )))
# 利用均匀分布初始化初始化
# w = tf.Variable(initial_value=tf.random.uniform((784, 10)))
# b = tf.Variable(initial_value=tf.random.uniform((10,)))
# 利用Glorot(Xavier)正太分布初始化
# w = tf.Variable(initial_value=tf.initializers.GlorotNormal()((784, 10)))
# b = tf.Variable(initial_value=tf.initializers.GlorotNormal()((10,)))
# 利用Glorot(Xavier)均匀分布初始化
# w = tf.Variable(initial_value=tf.initializers.GlorotUniform()((784, 10)))
# b = tf.Variable(initial_value=tf.initializers.GlorotUniform()((10,)))
optimizer = optimizers.SGD(learning_rate=0.02)
def train_epoch(epoch):
# Step4.loop
for step, (x, y) in enumerate(train_dataset):
with tf.GradientTape() as tape:
# [b, 28, 28] => [b, 784]
x = tf.reshape(x, (-1, 28 * 28))
# Step1. compute output
# [b, 784] => [b, 10]
out = model(x, w, b)
# Step2. compute loss
loss = tf.reduce_sum(tf.square(out - y)) / x.shape[0]
# 训练集测试准确度
def main(args):
# Print settings
for k, v in vars(args).items():
print(f'{k}: {v}')
num_classes = 8
size = (224, 224, 3) # size of images
# Runtime initialization will not allocate all memory on GPU
physical_devices = tf.config.list_physical_devices('GPU')
try:
tf.config.experimental.set_memory_growth(physical_devices[0], True)
except:
# Invalid device or cannot modify virtual devices once initialized.
pass
# Create checkpoints dir
os.makedirs('saved_models', exist_ok=True)
optimizer = optimizers.SGD(learning_rate=args.learning_rate, momentum=0.9)
loss = keras.losses.SparseCategoricalCrossentropy(from_logits=False)
metrics = [keras.metrics.SparseCategoricalAccuracy()]
# model = models.vgg16(input_shape=size, num_classes=num_classes, classifier_activation='softmax')
model = models.resnet50(input_shape=size, num_classes=num_classes, classifier_activation='softmax')
model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
model.summary()
if args.checkpoints:
if os.path.exists(args.checkpoints):
print(f'Loading checkpoints: {args.checkpoints}')
model.load_weights(args.checkpoints)
else:
print(f'Checkpoints `{args.checkpoints}` not found', file=sys.stderr)
os.makedirs("logs/scalars/", exist_ok=True)
logdir = "logs/scalars/" + datetime.now().strftime("%Y%m%d-%H%M%S")
# Log loss/metrics for training and validation
tensorboard = keras.callbacks.TensorBoard(log_dir=logdir)
if args.train:
# Same augs as C++
train_aug = iaa.Sequential([
iaa.Resize(size=size[:-1], interpolation='cubic'),
iaa.Fliplr(p=0.5),
iaa.Flipud(p=0.5),
iaa.Rotate(rotate=(-180, 180)),
iaa.AdditivePoissonNoise(lam=(0, 10)),
iaa.GammaContrast(gamma=(.8, 1.5)),
iaa.GaussianBlur(sigma=(.0, .8)),
iaa.CoarseDropout(p=(.02, .1), size_px=(0.02, 0.05), size_percent=0.5),
])
val_aug = iaa.Sequential([iaa.Resize(size=size[:-1], interpolation='cubic')])
training_dataset = ISICClassification(args.dataset, 'training', args.batch_size, train_aug)
training_tfdata = training_dataset.map_samples(args.epochs)
validation_dataset = ISICClassification(args.dataset, 'validation', args.batch_size, val_aug, shuffle=False)
validation_tfdata = validation_dataset.map_samples(args.epochs)
# Save checkpoints
checkpoint = ModelCheckpoint(f'saved_models/{args.name}.h5', monitor='val_sparse_categorical_accuracy',
verbose=1,
save_best_only=True, save_weights_only=False, mode='auto', save_freq='epoch')
# Stop training after 20 epochs of no improvement
early = EarlyStopping(monitor='val_sparse_categorical_accuracy', min_delta=0, patience=args.epochs // 4,
verbose=1,
mode='auto')
# Train the model
model.fit(
x=training_tfdata,
epochs=args.epochs,
verbose=1,
callbacks=[checkpoint, early, tensorboard],
validation_data=validation_tfdata,
steps_per_epoch=len(training_dataset),
validation_steps=len(validation_dataset),
)
if args.test:
# Test model on test set
test_aug = iaa.Sequential([iaa.Resize(size=size[:-1], interpolation='cubic')])
test_dataset = ISICClassification(args.dataset, 'test', args.batch_size, test_aug)
test_tfdata = test_dataset.map_samples(1)
results = model.evaluate(test_tfdata, verbose=1, callbacks=[tensorboard])
print("Test set loss and accuracy:", results)
max_lr = base_lr * 10
max_m = MAX_MOMENTUM
base_m = BASE_MOMENTUM
cyclical_momentum = CYCLICAL_MOMENTUM
augment = AUGMENT
cycles = CYCLES
# Расчет количества итерация и шага изменения learning rate
iterations = round(train_generator.samples // train_generator.batch_size *
EPOCHS_STEP1)
iterations = list(range(0, iterations + 1))
step_size = len(iterations) / (cycles)
model.compile(loss="categorical_crossentropy",
optimizer=optimizers.SGD(lr=base_lr, momentum=BASE_MOMENTUM),
metrics=["accuracy"])
clr1 = CyclicLR(base_lr=LR_STEP1,
max_lr=LR_STEP1 * 10,
step_size=step_size,
max_m=MAX_MOMENTUM,
base_m=BASE_MOMENTUM,
cyclical_momentum=CYCLICAL_MOMENTUM)
# Добавим ModelCheckpoint чтоб сохранять прогресс обучения модели и можно было потом подгрузить и дообучить модель.
checkpoint = ModelCheckpoint('best_model.hdf5',
monitor=['accuracy'],
verbose=1,
mode='max')
earlystop = EarlyStopping(monitor='accuracy',
def main():
"""
主函数
:return:
"""
# 输入：[b, 32, 32, 3]
model = ResNet18()
model.build(input_shape=(None, 32, 32, 3))
model.summary()
mydense = layers.Dense(100,
activation=None,
kernel_regularizer=regularizers.l2(5e-4))
fc_net = Sequential([mydense])
fc_net.build(input_shape=(None, 512))
fc_net.summary()
optimizer = optimizers.SGD(lr=0.1, momentum=0.9, decay=5e-4)
variables = model.trainable_variables + fc_net.trainable_variables
for epoch in range(500):
for step, (x, y) in enumerate(train_db):
with tf.GradientTape() as tape:
out = model(x, training=True)
avgpool = layers.GlobalAveragePooling2D()(out)
logits = fc_net(avgpool)
y_onehot = tf.one_hot(y, depth=100)
loss = tf.reduce_mean(
tf.losses.categorical_crossentropy(y_onehot,
logits,
from_logits=True))
loss = loss + tf.add_n(model.losses) + tf.add_n(fc_net.losses)
# 梯度求解
grads = tape.gradient(loss, variables)
# 梯度更新
optimizer.apply_gradients(zip(grads, variables))
# 学习率动态调整
optimizer.lr = lr_schedule_300ep(epoch)
# 每100个step打印一次
if step % 100 == 0:
print('epoch:', epoch, 'step:', step, 'loss:', float(loss),
'lr:', optimizer.lr.numpy())
# 做测试
total_num, total_correct = 0, 0
for x, y in test_db:
out = model(x, training=False)
avgpool = layers.GlobalAveragePooling2D()(out)
output = fc_net(avgpool)
# 预测可能性。
prob = tf.nn.softmax(output, axis=1)
pred = tf.argmax(prob, axis=1) # 还记得吗pred类型为int64,需要转换一下。
pred = tf.cast(pred, dtype=tf.int32)
# 拿到预测值pred和真实值比较。
correct = tf.cast(tf.equal(pred, y), dtype=tf.int32)
correct = tf.reduce_sum(correct)
total_num += x.shape[0]
total_correct += int(correct) # 转换为numpy数据
acc = total_correct / total_num
print('epoch:', epoch, 'test_acc:', acc)
print('====================================================')
modified_ResNet50_output = GlobalAveragePooling2D()(modified_ResNet50_output)
modified_ResNet50_output = Dense(512,
activation='relu')(modified_ResNet50_output)
modified_ResNet50_output = Dropout(0.5)(modified_ResNet50_output)
modified_ResNet50_output = Dense(
num_classes, activation='softmax')(modified_ResNet50_output)
# Create the new model by using Input and Output layers
new_ResNet50_model = Model(inputs=base_model.input,
outputs=modified_ResNet50_output)
new_ResNet50_model.summary()
# Compile the model with categorical crossentropy loss function and SGD optimizer
new_ResNet50_model.compile(loss='categorical_crossentropy',
optimizer=optimizers.SGD(lr, momentum),
metrics=['accuracy'])
# Train the model
print("[INFO] Train the model on training data")
history = new_ResNet50_model.fit(train_generator,
validation_data=validation_generator,
epochs=epochs,
verbose=1)
#new_VGG16_model.save('ResNet50_TransferLearning_NDDA.h5')
# Plot training curves
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
pyplot.plot(history.history['accuracy'])
# (train_images, train_labels, test_images, test_labels) = load_CIFAR('/home/user/Documents/dataset/Cifar-10')
(train_images,
train_labels), (test_images,
test_labels) = tf.keras.datasets.cifar10.load_data()
train_labels = tf.keras.utils.to_categorical(train_labels, 10)
test_labels = tf.keras.utils.to_categorical(test_labels, 10)
train_images = np.array(train_images, dtype=np.float32)
test_images = np.array(test_images, dtype=np.float32)
train_images, test_images = color_normalize(train_images, test_images)
# get model
img_input = Input(shape=(32, 32, 3))
output = ResNet(img_input)
model = models.Model(img_input, output)
# show
model.summary()
# train
learning_rate_schedules = optimizers.schedules.PiecewiseConstantDecay(
boundaries, learning_rate)
optimizer = optimizers.SGD(learning_rate=learning_rate_schedules,
momentum=0.9,
nesterov=True)
for epoch in range(epoch_num):
print('epoch %d' % epoch)
train(model, optimizer, train_images, train_labels)
test(model, test_images, test_labels)
