def run(self):
# set enviornment
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpuid)
print("InferenceWorker init, GPU ID: {}".format(self.gpuid))
# load models
model = load_model(get_best_model(backbone_type),
custom_objects={'triplet_loss': triplet_loss})
# sgd = keras.optimizers.SGD(lr=1e-5, momentum=0.9, nesterov=True, decay=1e-6)
# adam = keras.optimizers.Adam(lr=0.001)
# model.compile(optimizer=sgd, loss=triplet_loss)
while True:
try:
sample = {}
try:
sample['a'] = self.in_queue.get(block=False)
sample['p'] = self.in_queue.get(block=False)
sample['n'] = self.in_queue.get(block=False)
except queue.Empty:
break
batch_inputs = np.empty((3, 1, img_size, img_size, channel),
dtype=np.float32)
for j, role in enumerate(['a', 'p', 'n']):
image_name = sample[role]
filename = os.path.join(manga_dir, 'test', image_name)
image = cv.imread(filename)
image = image[:, :, ::-1] # RGB
image = cv.resize(image, (img_size, img_size),
cv.INTER_CUBIC)
batch_inputs[j, 0] = preprocess_input(image)
y_pred = model.predict(
[batch_inputs[0], batch_inputs[1], batch_inputs[2]])
a = y_pred[0, 0:128]
p = y_pred[0, 128:256]
n = y_pred[0, 256:384]
self.out_queue.put({'image_name': sample['a'], 'embedding': a})
self.out_queue.put({'image_name': sample['p'], 'embedding': p})
self.out_queue.put({'image_name': sample['n'], 'embedding': n})
self.signal_queue.put(SENTINEL)
if self.in_queue.qsize() == 0:
break
except Exception as e:
print(e)
import keras.backend as K
K.clear_session()
print('InferenceWorker done, GPU ID {}'.format(self.gpuid))
def load_pretrained_models(args, dataset):
models = []
if args.pretrained_dir is not None:
for p in args.pretrained_dir.iterdir():
if "cnn" in p.name:
args.model = "CNN"
else:
args.model = "LSTM"
path = utils.get_best_model(p)[0]
checkpoint = torch.load(path, map_location="cpu")
lstm_model, _ = create_model_and_optimizer(
args, dataset, params=checkpoint["model"])
models.append(lstm_model)
LOGGER.info(f"Loaded: {path}")
else:
if args.pretrained_lstm is not None:
assert len(args.pretrained_lstm) > 0
args.model = "LSTM"
for path in args.pretrained_lstm:
# model is put to gpu when constructed
path = utils.get_best_model(path)[0]
checkpoint = torch.load(path, map_location="cpu")
lstm_model, _ = create_model_and_optimizer(
args, dataset, params=checkpoint["model"])
models.append(lstm_model)
LOGGER.info("Loaded: {path}")
if args.pretrained_cnn is not None:
assert len(args.pretrained_cnn) > 0
args.model = "CNN"
for path in args.pretrained_cnn:
path = utils.get_best_model(path)[0]
checkpoint = torch.load(path, map_location="cpu")
cnn_model, _ = create_model_and_optimizer(
args, dataset, params=checkpoint["model"])
models.append(cnn_model)
LOGGER.info("Loaded: {path}")
return models
def main():
"""Task 0 - Split training and evaluation data"""
# Read data
X, y = utils.read_documents('../input/all_sentiment_shuffled.txt')
count_vect = CountVectorizer(analyzer=lambda x: x)
X_vectorized = count_vect.fit_transform(X)
# Split point between training and evaluation
X_train, X_test, y_train, y_test, indices_train, indices_test = train_test_split(X_vectorized, y, np.arange(1, len(X)+1), test_size=0.2)
"""Task 1 - Plot label distribution"""
# Get label distribution
train_label_distribution = utils.get_label_distribution(y_train, save_plot_as='training_label_distribution')
test_label_distribution = utils.get_label_distribution(y_test, save_plot_as='test_label_distribution')
"""Task 2 - Naive Bayes Classifier"""
multiNB = MultinomialNB()
multiNB.fit(X_train, y_train)
multiNB_pred = multiNB.predict(X_test)
multiNB_pred_prob = multiNB.predict_proba(X_test)
utils.generate_wrong_pred("NaiveBayes", indices_test, y_test, multiNB_pred, multiNB.classes_, multiNB_pred_prob)
utils.save_graphical_confusion_matrix(multiNB, X_test, y_test, "NB")
"""Task 2 - Base-DT"""
baseDT = DecisionTreeClassifier(criterion='entropy', random_state=0)
baseDT.fit(X_train, y_train)
baseDT_pred = baseDT.predict(X_test)
utils.save_graphical_confusion_matrix(baseDT, X_test, y_test, "DT-base")
"""Task 2 - Best-DT"""
# The following function Analyses the relationship between the ccp_alphas parameter and accuracy
# for Decision Trees. It is not active when we run the code because it takes to long to complete.
# It is present here to show where it would be used and for completeness only.
# utils.analyze_ccp_alpha(X_train, X_test, y_train, y_test)
bestDT = DecisionTreeClassifier(random_state=0)
bestDT = utils.get_best_model(X_train, y_train, bestDT, {"criterion": ["entropy", "gini"], "splitter": ["best", "random"]})
bestDT.fit(X_train, y_train)
bestDT_pred = bestDT.predict(X_test)
utils.save_graphical_confusion_matrix(bestDT, X_test, y_test, "DT-best")
"""Task 3 - Generate output"""
labels = sorted(set(y))
models = [('NaiveBayes', multiNB_pred),
('BaseDT', baseDT_pred),
('BestDT', bestDT_pred)]
utils.generate_output(indices_test, y_test, labels, models)
def run(self):
# set enviornment
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpuid)
print("InferenceWorker init, GPU ID: {}".format(self.gpuid))
from model import build_model
# load models
model = build_model()
model.load_weights(get_best_model())
while True:
try:
sample = {}
try:
sample['a'] = self.in_queue.get(block=False)
sample['p'] = self.in_queue.get(block=False)
sample['n'] = self.in_queue.get(block=False)
except queue.Empty:
break
batch_inputs = np.empty((3, 1, img_size, img_size, channel), dtype=np.float32)
for j, role in enumerate(['a', 'p', 'n']):
image_name = sample[role]
filename = os.path.join(image_folder, image_name)
image_bgr = cv.imread(filename)
image_bgr = cv.resize(image_bgr, (img_size, img_size), cv.INTER_CUBIC)
image_rgb = cv.cvtColor(image_bgr, cv.COLOR_BGR2RGB)
batch_inputs[j, 0] = preprocess_input(image_rgb)
y_pred = model.predict([batch_inputs[0], batch_inputs[1], batch_inputs[2]])
a = y_pred[0, 0:128]
p = y_pred[0, 128:256]
n = y_pred[0, 256:384]
self.out_queue.put({'image_name': sample['a'], 'embedding': a})
self.out_queue.put({'image_name': sample['p'], 'embedding': p})
self.out_queue.put({'image_name': sample['n'], 'embedding': n})
self.signal_queue.put(SENTINEL)
if self.in_queue.qsize() == 0:
break
except Exception as e:
print(e)
import keras.backend as K
K.clear_session()
print('InferenceWorker done, GPU ID {}'.format(self.gpuid))
def restore_weights(model):
"""
Restores weights from the checkpoint file if exists or
preloads the first layers with VGG19 weights
:param weights_best_file:
:return: epoch number to use to continue training. last epoch + 1 or 0
"""
# load previous weights or vgg19 if this is the first run
if get_best_model():
print("Loading the best weights...")
model.load_weights(get_best_model())
else:
print("Loading vgg19 weights...")
vgg_model = VGG19(include_top=False, weights='imagenet')
for layer in model.layers:
if layer.name in from_vgg:
vgg_layer_name = from_vgg[layer.name]
layer.set_weights(
vgg_model.get_layer(vgg_layer_name).get_weights())
print("Loaded VGG19 layer: " + vgg_layer_name)
def main(hparams):
""" Main Function """
model = ImageCaptioning(hparams)
checkpoint_callback = ModelCheckpoint(filepath="models/{epoch}-{val_loss:.2f}")
trainer = pl.Trainer(
checkpoint_callback=checkpoint_callback,
max_epochs=hparams.epochs,
gpus=hparams.gpus,
distributed_backend=hparams.distributed_backend,
fast_dev_run=True,
)
if not hparams.test:
trainer.fit(model)
# trainer.test(model)
else:
checkpoint_path = get_best_model("models/")
model = ImageCaptioning.load_from_checkpoint(checkpoint_path=checkpoint_path)
trainer.test(model)
def main(params):
log_dir = os.path.join(MAIN_LOG_DIR, params.log_dir)
if tf.gfile.Exists(log_dir):
tf.gfile.DeleteRecursively(log_dir)
tf.gfile.MakeDirs(log_dir)
tf.set_random_seed(seed=42)
print("... creating a TensorFlow session ...\n")
config = tf.ConfigProto()
config.allow_soft_placement = True
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
print("... loading CIFAR10 dataset ...")
(x_train, y_train), (x_test, y_test) = load_data(data_dir)
y_train = np.squeeze(y_train)
y_test = np.squeeze(y_test)
x_train, y_train = shuffle(x_train, y_train)
x_train, x_val, y_train, y_val = train_test_split(x_train, y_train,
test_size=0.2,
stratify=y_train,
random_state=51)
# cast samples and labels
x_train = x_train.astype(np.float32)
x_val = x_val.astype(np.float32)
x_test = x_test.astype(np.float32)
y_train = y_train.astype(np.int32)
y_val = y_val.astype(np.int32)
y_test = y_test.astype(np.int32)
print("\tTRAIN - images {} | {} - labels {} - {}".format(x_train.shape, x_train.dtype, y_train.shape, y_train.dtype))
print("\tVAL - images {} | {} - labels {} - {}".format(x_val.shape, x_val.dtype, y_val.shape, y_val.dtype))
print("\tTEST - images {} | {} - labels {} - {}\n".format(x_test.shape, x_test.dtype, y_test.shape, y_test.dtype))
print('... creating TensorFlow datasets ...\n')
batch_x, batch_y, handle, handle_train, handle_val, handle_test \
= build_dataset(sess, x_train, x_val, x_test, y_train, y_val, y_test,
batch_size=params.batch_size,
buffer_size=x_train.shape[0])
nb_batches_per_epoch_train = int(ceil(x_train.shape[0]/params.batch_size))
nb_batches_per_epoch_val = int(ceil(x_val.shape[0]/params.batch_size))
nb_batches_per_epoch_test = int(ceil(x_test.shape[0]/params.batch_size))
print('\tnb_batches_per_epoch_train : {}'.format(nb_batches_per_epoch_train))
print('\tnb_batches_per_epoch_val : {}'.format(nb_batches_per_epoch_val))
print('\tnb_batches_per_epoch_test : {}\n'.format(nb_batches_per_epoch_test))
print('... building model ...\n')
with tf.name_scope('INPUTS'):
learning_rate = tf.placeholder(shape=[], dtype=tf.float32, name='learning_rate')
is_training_bn = tf.placeholder(shape=[], dtype=tf.bool, name='is_training_bn')
use_moving_statistics = tf.placeholder(shape=[], dtype=tf.bool, name='use_moving_statistics')
global_step = tf.train.get_or_create_global_step()
logits = build_model(batch_x, is_training_bn=is_training_bn)
model_vars = tf.trainable_variables()
with tf.name_scope('LOSS'):
loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(logits=logits, labels=batch_y))
acc = tf.reduce_mean(tf.cast(tf.equal(batch_y, tf.argmax(logits, axis=1)), dtype=tf.float32))
with tf.name_scope('OPTIMIZER'):
if params.opt == "adam":
opt = tf.train.AdamOptimizer(learning_rate=learning_rate)
elif params.opt == "momentum":
opt = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=params.momentum)
elif params.opt == "adamW":
opt = tf.contrib.opt.AdamWOptimizer(weight_decay=params.weight_decay, learning_rate=learning_rate,
beta1=0.9, beta2=0.999, epsilon=1e-8)
elif params.opt == "momentumW":
opt = tf.contrib.opt.MomentumWOptimizer(weight_decay=params.weight_decay, learning_rate=learning_rate,
momentum=params.momentum)
else:
raise ValueError('Invalid --opt argument : {}'.format(params.opt))
if 'W' in params.opt:
# when using AdamW or MomentumW
if params.weight_decay_on == "all":
decay_var_list = tf.trainable_variables()
elif params.weight_decay_on == "kernels":
decay_var_list = []
for var in tf.trainable_variables():
if 'kernel' in var.name:
decay_var_list.append(var)
else:
raise ValueError('Invalid --weight_decay_on : {}'.format(params.weight_decay_on))
# force updates of moving averages in BN before optimizing the network
with tf.control_dependencies(tf.get_collection(tf.GraphKeys.UPDATE_OPS)):
grads_and_vars = opt.compute_gradients(loss, var_list=tf.trainable_variables())
if 'W' in params.opt:
# add decay_var_list argument for decoupled optimizers
train_op = opt.apply_gradients(grads_and_vars, global_step=global_step,
decay_var_list=decay_var_list, name='train_op')
else:
# without weight decay
train_op = opt.apply_gradients(grads_and_vars, global_step=global_step, name='train_op')
with tf.name_scope('METRICS'):
acc_mean, acc_update_op = tf.metrics.mean(acc)
loss_mean, loss_update_op = tf.metrics.mean(loss)
# summaries which track loss/acc per batch
acc_summary = tf.summary.scalar('TRAIN/acc', acc)
loss_summary = tf.summary.scalar('TRAIN/loss', loss)
# summaries which track accumulated loss/acc
acc_mean_summary = tf.summary.scalar('MEAN/acc', acc_mean)
loss_mean_summary = tf.summary.scalar('MEAN/loss', loss_mean)
# summaries to plot at each epoch
summaries_mean = tf.summary.merge([acc_mean_summary, loss_mean_summary], name='summaries_mean')
# summaries to plot regularly
summaries = [acc_summary, loss_summary]
summaries = tf.summary.merge(summaries, name='summaries')
with tf.name_scope('INIT_OPS'):
# local init_ops contains operations to reset to zero accumulators of 'acc' and 'loss'
global_init_op = tf.global_variables_initializer()
local_init_op = tf.local_variables_initializer()
sess.run(global_init_op)
sess.run(local_init_op)
with tf.name_scope('SAVERS'):
best_saver = tf.train.Saver(tf.global_variables(), max_to_keep=1)
with tf.name_scope('FILE_WRITERS'):
writer_train = tf.summary.FileWriter(os.path.join(log_dir, 'train'), graph=sess.graph)
writer_val = tf.summary.FileWriter(os.path.join(log_dir, 'val'))
writer_val_bn = tf.summary.FileWriter(os.path.join(log_dir, 'val_bn'))
writer_test = tf.summary.FileWriter(os.path.join(log_dir, 'test'))
if params.strategy_lr == "constant":
def get_learning_rate(step, epoch, steps_per_epoch):
return params.init_lr
else:
raise ValueError('Invalid --strategy_lr : {}'.format(params.strategy_lr))
def inference(epoch, step, best_acc, best_step, best_epoch):
sess.run(local_init_op)
feed_dict = {is_training_bn: False, handle: handle_val}
for _ in tqdm(range(nb_batches_per_epoch_val),
desc='VALIDATION @ EPOCH {}'.format(epoch)):
sess.run([acc_update_op, loss_update_op], feed_dict=feed_dict)
acc_v, loss_v, s = sess.run([acc_mean, loss_mean, summaries_mean])
writer_val.add_summary(s, global_step=step)
writer_val.flush()
if acc_v > best_acc:
color = COLORS['green']
best_acc = acc_v
best_step = step
best_epoch = epoch
ckpt_path = os.path.join(log_dir, 'best_model.ckpt')
best_saver.save(sess, ckpt_path, global_step=step)
else:
color = COLORS['red']
print("VALIDATION @ EPOCH {} : {}acc={:.4f}{} loss={:.5f}".format(epoch, color[0], acc_v, color[1], loss_v))
return best_acc, best_step, best_epoch
feed_dict_train = {is_training_bn: True, handle: handle_train}
best_acc = 0.
best_step = 0
best_epoch = 0
step = -1
# inference with trained variables
best_acc, best_step, best_epoch = inference(0, 0, best_acc, best_step, best_epoch)
for epoch in range(1, params.epochs+1):
# ####################################### TRAIN 1 EPOCH ######################################################
# re-initialize local variables
sess.run(local_init_op)
for _ in tqdm(range(nb_batches_per_epoch_train), desc='TRAIN @ EPOCH {}'.format(epoch)):
step += 1
feed_dict_train[learning_rate] = get_learning_rate(step, epoch, nb_batches_per_epoch_train)
if step % PLOT_PERIOD == 0:
_, s, _, _ = sess.run([train_op, summaries, acc_update_op, loss_update_op], feed_dict=feed_dict_train)
writer_train.add_summary(s, global_step=step)
else:
sess.run([train_op, acc_update_op, loss_update_op], feed_dict=feed_dict_train)
acc_v, loss_v, s = sess.run([acc_mean, loss_mean, summaries_mean])
writer_train.add_summary(s, global_step=step)
writer_train.flush()
print("TRAIN @ EPOCH {} | : acc={:.4f} loss={:.5f}".format(epoch, acc_v, loss_v))
# ############################################################################################################
# ###################################### INFERENCE ###########################################################
# perform inference with trained variables and moving statistics
best_acc, best_step, best_epoch = inference(epoch, step, best_acc, best_step, best_epoch)
# Inference on test set with trained weights
if best_acc > 0.:
print("Load best model | ACC={:.5f} form epoch={}".format(best_acc, best_epoch))
model_to_restore = get_best_model(log_dir, model='best_model')
if model_to_restore is not None:
best_saver.restore(sess, model_to_restore)
else:
print("Impossible to load best model .... ")
sess.run(local_init_op)
feed_dict = {is_training_bn: False, handle: handle_test}
for _ in tqdm(range(nb_batches_per_epoch_test), desc='TEST'):
sess.run([acc_update_op, loss_update_op], feed_dict=feed_dict)
acc_v, loss_v, s = sess.run([acc_mean, loss_mean, summaries_mean])
writer_test.add_summary(s, global_step=best_step)
writer_test.flush()
print("TEST @ EPOCH {} : acc={:.4f} loss={:.5f}".format(best_epoch, acc_v, loss_v))
sess.close()
parser = argparse.ArgumentParser()
parser.add_argument('--config', type=str, required=True, help='path of config file')
opt = parser.parse_args()
# get config
config = utils.get_config(opt.config)
if torch.cuda.is_available() and not config['cuda']['using_cuda']:
print("WARNING: You have a CUDA device, so you should probably run with --cuda")
# set device
cuda_str = 'cuda:' + str(config['cuda']['gpu_id'])
device = torch.device(cuda_str if config['cuda']['using_cuda'] else "cpu")
# get best model
best_model_path = utils.get_best_model(config['model']['exp_path'])
if best_model_path is None:
raise FileNotFoundError('Not found ckpt file')
# set output path
ckpt_filename = best_model_path.split("/")[-1]
result_dir = best_model_path.replace(ckpt_filename, 'results')
correct_dir = os.path.join(result_dir, 'correct')
incorrect_dir = os.path.join(result_dir, 'incorrect')
if not os.path.exists(result_dir):
os.mkdir(result_dir)
os.mkdir(correct_dir)
os.mkdir(incorrect_dir)
from data_generator import MangaDataGenSequence
from model import build_model
from utils import get_available_gpus, get_available_cpus, ensure_folder, triplet_loss, get_smallest_loss, get_best_model
if __name__ == '__main__':
os.environ["CUDA_VISIBLE_DEVICES"] = "3"
# Parse arguments
ap = argparse.ArgumentParser()
ap.add_argument('--backbone', default='vgg19', type=str, required=False)
args = ap.parse_args()
if args.backbone:
backbone_type = args.backbone
checkpoint_models_path = backbone_type + '/models/'
pretrained_path = get_best_model(backbone_type)
ensure_folder(backbone_type + '/models/')
# Callbacks
tensor_board = keras.callbacks.TensorBoard(log_dir='./' + backbone_type +
'/logs',
histogram_freq=0,
write_graph=True,
write_images=True)
model_names = checkpoint_models_path + 'model.{epoch:02d}-{val_loss:.4f}.hdf5'
model_checkpoint = ModelCheckpoint(model_names,
monitor='val_loss',
mode='min',
verbose=1,
save_best_only=True,
save_weights_only=False)
# import the necessary packages
import json
import os
import random
import cv2 as cv
import keras.backend as K
import numpy as np
from keras.applications.inception_resnet_v2 import preprocess_input
from config import train_data, test_a_image_folder, img_height, img_width
from model import build_model
from utils import get_best_model
if __name__ == '__main__':
best_model, epoch = get_best_model()
model = build_model()
model.load_weights(best_model)
labels = [folder for folder in os.listdir(train_data) if os.path.isdir(os.path.join(train_data, folder))]
test_images = [f for f in os.listdir(test_a_image_folder) if
os.path.isfile(os.path.join(test_a_image_folder, f)) and f.endswith('.jpg')]
num_samples = 20
samples = random.sample(test_images, num_samples)
if not os.path.exists('images'):
os.makedirs('images')
results = []
for i in range(len(samples)):
from keras.callbacks import ModelCheckpoint, EarlyStopping, ReduceLROnPlateau
from keras.utils import multi_gpu_model
from config import patience, epochs, batch_size
from data_generator import train_gen, valid_gen
from model import build_model
from utils import get_available_gpus, ensure_folder, get_example_numbers, get_best_model
if __name__ == '__main__':
# Parse arguments
ap = argparse.ArgumentParser()
args = vars(ap.parse_args())
checkpoint_models_path = 'models/'
ensure_folder(checkpoint_models_path)
filename, epoch = get_best_model()
if filename is None:
initial_epoch = 0
else:
initial_epoch = epoch + 1
# Callbacks
tensor_board = keras.callbacks.TensorBoard(log_dir='./logs',
histogram_freq=0,
write_graph=True,
write_images=True)
model_names = checkpoint_models_path + 'model.{epoch:02d}-{val_loss:.4f}.hdf5'
model_checkpoint = ModelCheckpoint(model_names,
monitor='val_loss',
verbose=1,
save_best_only=True)
def run():
args = LMArguments()
# Seed RNGs for reproducibility
if args.seed > 0:
print(f"Random seed set to {args.seed}")
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# Configure logging
if args.save:
logfile = utils.create_exp_dir(args.exp,
args.script,
overwrite=args.overwrite)
else:
logfile = None
# must init logging before SummaryWriter, otherwise it adds handler to root logger so basicConfig does not work
logging.basicConfig(
datefmt="%m-%d %H:%M:%S",
format="%(asctime)s %(levelname)s %(name)s: %(message)s",
level=logging.getLevelName(args.logging_level),
filename=logfile,
)
# Print out all the arguments set.
LOGGER.info("Arguments passed: " + args.to_string(max_width=80))
print(args.exp, flush=True)
LOGGER.info(f"Running the model on {'GPU (CUDA)' if args.cuda else 'CPU'}")
if args.cuda:
props = torch.cuda.get_device_properties(0)
LOGGER.info(
f"GPU name: {props.name}, CUDA version {props.major}.{props.minor}, "
f"available memory: {props.total_memory / 1024 / 1024:.2f}MB.")
# Create dataset
dataset = create_dataset(args)
# Create model
model, optimizer = create_model_and_optimizer(args, dataset)
# Print model parameter info
n_params = sum(p.nelement() for p in model.parameters())
LOGGER.info(f"Model parameters: {n_params}")
LOGGER.info(f"Model structure:\n{str(model)}")
if args.repl:
# REPL mode
repl(dataset, model)
sys.exit(0)
if args.mode == "train":
# Training mode
try:
train_model(model, dataset, optimizer, args, writer=None)
except KeyboardInterrupt:
LOGGER.info("Training halted.")
# load best model
best_path, best_epoch = utils.get_best_model(args.exp)
model.load_state_dict(torch.load(best_path)['model'])
LOGGER.info(f"Loaded best model (epoch {best_epoch})")
# Evaluate AND dump the avg logprobs of each word
evaluate_model(model, dataset, args, split="train", writer=None)
evaluate_model(model, dataset, args, split="valid", writer=None)
evaluate_model(model, dataset, args, split="test", writer=None)
postprocess_probdump(dataset, args.exp)
else:
# Evaluation mode
for split in ['train', 'valid', 'test']:
evaluate_model(model, dataset, args, split=split, writer=None)
def main(args):
# Seed RNGs for reproducibility
if args.seed > 0:
print(f"Random seed set to {args.seed}")
random.seed(args.seed)
np.random.seed(args.seed)
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
# Configure logging
if args.save:
logfile = utils.create_exp_dir(args.exp,
args.script,
overwrite=args.overwrite)
else:
logfile = None
logging.basicConfig(
datefmt="%m-%d %H:%M:%S",
format="%(asctime)s %(levelname)s: %(message)s",
level=logging.getLevelName(args.logging_level),
filename=logfile,
)
n_gpus = torch.cuda.device_count()
LOGGER.debug("Running the model on " +
(f"CUDA with {n_gpus} GPU(s)" if args.cuda else "CPU"))
for device in range(n_gpus):
props = torch.cuda.get_device_properties(device)
LOGGER.debug(
f"GPU ({device}) name: {props.name}, CUDA version {props.major}.{props.minor}, "
f"available memory: {props.total_memory / 1024 / 1024:.2f}MB.")
if args.eval or args.output is not None:
evaluate(args)
else:
# Create dataset
dataset = IEDataset(args)
# Create model
model, optimizer = create_model_and_optimizer(args, dataset)
# Print model parameter info
n_params = sum(p.nelement() for p in model.parameters())
LOGGER.info(f"Model parameters: {n_params}")
LOGGER.info(f"Model structure:\n{str(model)}")
if args.pretrained:
path, _ = utils.get_best_model(args.pretrained)
states = torch.load(path, map_location="cuda")
model.load_state_dict(states["model"])
try:
train_model(args, dataset, model, optimizer)
except KeyboardInterrupt:
LOGGER.info("Training halted.")
path, _ = utils.get_best_model(args.exp)
states = torch.load(path, map_location="cuda")
model.load_state_dict(states["model"])
test_model(args, dataset, model)
# import the necessary packages
import os
import random
import cv2 as cv
import keras.backend as K
import numpy as np
from config import img_rows, img_cols, num_classes, test_folder, original_images_key, gray_values
from model import build_model
from utils import get_best_model, preprocess_input
if __name__ == '__main__':
model = build_model()
model.load_weights(get_best_model())
print(model.summary())
test_dir = os.path.join(test_folder, original_images_key)
test_dir = os.path.join(
test_dir,
'P0089_MacularCube512x128_4-25-2013_9-32-13_OD_sn2218_cube_z.img')
test_images = [
os.path.join(test_dir, f) for f in os.listdir(test_dir)
if f.lower().endswith('.bmp')
]
samples = random.sample(test_images, 10)
for i, filename in enumerate(samples):
print('Start processing image: {}'.format(filename))
def run(self):
# set enviornment
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = str(self.gpuid)
print("InferenceWorker init, GPU ID: {}".format(self.gpuid))
from model import build_model
# load models
model = build_model()
model.load_weights(get_best_model())
while True:
try:
sample = {}
try:
sample['a'] = self.in_queue.get(block=False)
sample['p'] = self.in_queue.get(block=False)
sample['n'] = self.in_queue.get(block=False)
except queue.Empty:
break
batch_inputs = np.empty((3, 1, img_size, img_size, channel),
dtype=np.float32)
for j, role in enumerate(['a', 'p', 'n']):
image_name = sample[role]
filename = os.path.join(lfw_folder, image_name)
image = cv.imread(filename)
image = image[:, :, ::-1] # RGB
dets = self.detector(image, 1)
num_faces = len(dets)
if num_faces > 0:
# Find the 5 face landmarks we need to do the alignment.
faces = dlib.full_object_detections()
for detection in dets:
faces.append(self.sp(image, detection))
image = dlib.get_face_chip(image,
faces[0],
size=img_size)
else:
image = cv.resize(image, (img_size, img_size),
cv.INTER_CUBIC)
batch_inputs[j, 0] = preprocess_input(image)
y_pred = model.predict(
[batch_inputs[0], batch_inputs[1], batch_inputs[2]])
a = y_pred[0, 0:128]
p = y_pred[0, 128:256]
n = y_pred[0, 256:384]
self.out_queue.put({'image_name': sample['a'], 'embedding': a})
self.out_queue.put({'image_name': sample['p'], 'embedding': p})
self.out_queue.put({'image_name': sample['n'], 'embedding': n})
self.signal_queue.put(SENTINEL)
if self.in_queue.qsize() == 0:
break
except Exception as e:
print(e)
import keras.backend as K
K.clear_session()
print('InferenceWorker done, GPU ID {}'.format(self.gpuid))
from data_generator import train_gen, valid_gen
from model import build_model
from utils import get_available_cpus, get_available_gpus, get_highest_acc, get_best_model, focal_loss
if __name__ == '__main__':
# Parse arguments
ap = argparse.ArgumentParser()
ap.add_argument("-p",
"--pretrained",
help="path to save pretrained model files")
args = vars(ap.parse_args())
pretrained_path = args["pretrained"]
checkpoint_models_path = 'models/'
if pretrained_path is None:
pretrained_path = get_best_model()
# Callbacks
tensor_board = keras.callbacks.TensorBoard(log_dir='./logs',
histogram_freq=0,
write_graph=True,
write_images=True)
model_names = checkpoint_models_path + 'model.{epoch:02d}-{val_loss:.4f}.hdf5'
model_checkpoint = ModelCheckpoint(model_names,
monitor='val_loss',
verbose=1,
save_best_only=True)
early_stop = EarlyStopping('val_loss', patience=patience)
reduce_lr = ReduceLROnPlateau('val_loss',
factor=0.1,
patience=int(patience / 4),
import utils predictors, response = utils.get_data() x_train, x_test, y_train, y_test = utils.split_data(predictors, response) # Models comparison utils.get_best_model(x_train, x_test, y_train, y_test)
