def main():
# training and test sets
train_set_full = get_images_labels(P.dataset_full, P.match_labels)
test_set_full = get_images_labels(P.dataset_full + '/test', P.match_labels)
labels_list = [t[1] for t in train_set_full]
# we have to give a number to each label,
# so we need a list here for the index
labels.extend(sorted(list(set(labels_list))))
log(P, 'Loading and transforming train/test sets.')
train_set, test_train_set, test_set = [], [], []
train_pre_f = P.train_trans if P.train_pre_proc else transforms.Compose([])
test_pre_f = P.test_trans if P.test_pre_proc else transforms.Compose([])
for im, lab in train_set_full:
im_o = imread_rgb(im)
train_set.append((train_pre_f(im_o), lab, im))
test_train_set.append((test_pre_f(im_o), lab, im))
for im, lab in test_set_full:
if lab not in labels:
continue
im_o = imread_rgb(im)
test_set.append((test_pre_f(im_o), lab, im))
siam_net = get_siamese_net()
optimizer = optim.SGD(
(p for p in siam_net.parameters() if p.requires_grad),
lr=P.train_lr,
momentum=P.train_momentum,
weight_decay=P.train_weight_decay)
criterion = TripletLoss(P.triplet_margin, P.train_loss_avg)
criterion2 = nn.CrossEntropyLoss(size_average=P.train_loss2_avg)
testset_tuple = (test_set, test_train_set)
if P.test_upfront:
log(P, 'Upfront testing of descriptor model')
score = test_print_descriptor(train_type, P, siam_net, testset_tuple,
get_embeddings)
else:
score = 0
if P.train:
log(P, 'Starting region-descriptor training')
train_siam_triplets_pos_couples(siam_net,
train_set,
testset_tuple,
criterion,
criterion2,
optimizer,
best_score=score)
log(P, 'Finished region-descriptor training')
if P.test_descriptor_net:
log(P, 'Testing as descriptor')
# set best score high enough such that it will never be saved
test_print_descriptor(train_type,
P,
siam_net,
testset_tuple,
get_embeddings,
best_score=len(test_set) + 1)
def main():
# training and test sets
train_set_full = get_images_labels(P.dataset_full, P.match_labels)
test_set_full = get_images_labels(P.dataset_full + '/test', P.match_labels)
labels_list = [t[1] for t in train_set_full]
# we have to give a number to each label,
# so we need a list here for the index
labels.extend(sorted(list(set(labels_list))))
log(P, 'Loading and transforming train/test sets.')
# open the images (and transform already if possible)
# do that only if it fits in memory !
train_set, test_train_set, test_set = [], [], []
train_pre_f = P.train_trans if P.train_pre_proc else transforms.Compose([])
test_pre_f = P.test_trans if P.test_pre_proc else transforms.Compose([])
for im, lab in train_set_full:
im_o = imread_rgb(im)
train_set.append((train_pre_f(im_o), lab, im))
test_train_set.append((test_pre_f(im_o), lab, im))
for im, lab in test_set_full:
if lab not in labels:
continue
im_o = imread_rgb(im)
test_set.append((test_pre_f(im_o), lab, im))
class_net = get_class_net()
optimizer = optim.SGD(
(p for p in class_net.parameters() if p.requires_grad),
lr=P.train_lr,
momentum=P.train_momentum,
weight_decay=P.train_weight_decay)
criterion = nn.CrossEntropyLoss(size_average=P.train_loss_avg)
testset_tuple = (test_set, test_train_set)
if P.test_upfront:
log(P, 'Upfront testing of classification model')
score = test_print_classif(train_type, P, class_net, testset_tuple,
test_classif_net)
else:
score = 0
if P.train:
log(P, 'Starting classification training')
train_classif(class_net,
train_set,
testset_tuple,
criterion,
optimizer,
best_score=score)
log(P, 'Finished classification training')
if P.test_descriptor_net:
log(P, 'Testing as descriptor')
test_print_descriptor(train_type, P, class_net, testset_tuple,
get_embeddings)
in evaluvate_predict method accordingly
parser.add_argument('--model_json', type=str, help='keras model json file path')
parser.add_argument('--weights_file', type=str, help='hdf5 weights file to load')
parser.add_argument('--weights_dir', type=str, help='If you provide a dir , then it will take latest checkpoint')
'''
return parser.parse_args(argv)
if __name__ == "__main__":
args = parse_arguments(sys.argv[1:])
classify_object = ImageClassifier(args)
if args.mode == 'train':
# create a filenames, labels list
filenames, labels, class_indices = utils.get_images_labels(
args.data_dir)
# split train, val and test set
train_files, val_files, train_labels, val_labels = train_test_split(
filenames,
labels,
test_size=args.val_split_ratio,
random_state=args.seed)
# create tf.data.Dataset for train set and test set
train_dataset = tf.data.Dataset.from_tensor_slices(
(train_files, train_labels))
val_dataset = tf.data.Dataset.from_tensor_slices(
(val_files, val_labels))
# train and validate the images
classify_object.init_train(train_dataset, val_dataset, class_indices)
classify_object.train_validate()
elif args.mode == 'test':
import numpy as np
from utils import get_images_labels, imread_rgb
from utils import match_label_fou_clean2, match_label_video
# create the mean std file needed to normalize images of a dataset
# path to the training images of the dataset
dataset_path = 'data/pre_proc/CLICIDE_video_224sq'
# file to write the mean and std values to
out_path = 'data/CLICIDE_224sq_train_ms.txt'
# function to match labels, this is not necessary here
match_labels = match_label_video
# if the image size is constant, indicate it in format (C, H, W)
# if the image size is not constant, use None here
image_size = (3, 224, 224)
dataset_full = get_images_labels(dataset_path, match_labels)
mean = [0., 0., 0.]
std = [0., 0., 0.]
size = len(dataset_full)
if image_size is not None:
T = torch.Tensor(size, *(image_size))
for i, (im, _) in enumerate(dataset_full):
T[i] = transforms.ToTensor()(imread_rgb(im))
for i in range(3):
mean[i] = T[:, i, :, :].mean()
std[i] = T[:, i, :, :].std()
else:
# cannot take mean/std of whole dataset tensor.
# need to compute mean of all pixels and std afterwards, pixel by pixel
dataset_open = []
from os import path
from utils import get_images_labels, match_label_fou_clean2, match_label_video
# resize all images of a dataset and place them into a new folder
# path to folders containing train and test images
dataset = '/home/mrim/data/collection/GUIMUTEIC/FOURVIERE_CLEAN2/TRAIN_I'
dataset_test = '/home/mrim/data/collection/GUIMUTEIC/FOURVIERE_CLEAN2/TEST_I'
# function to match the labels in image names
match_labels = match_label_fou_clean2
# paths where the resized images are placed
out_path = './data/pre_proc/fourviere_clean2_448'
out_path_test = './data/pre_proc/fourviere_clean2_448/test'
# training and test sets (scaled to 300 on the small side)
dataSetFull = get_images_labels(dataset, match_labels)
testSetFull = get_images_labels(dataset_test, match_labels)
# resize function
def resize(dataset, out_path, max_ar, newsize1, newsize2=None):
for im, lab in dataset:
im_o = cv2.imread(im)
h, w, _ = im_o.shape
if max_ar >= 1. and ((h > w and float(h) / w > max_ar) or
(h < w and float(w) / h > max_ar)):
# force a max aspect ratio of max_ar by padding image with random uniform noise
def pad_rand(vector, pad_width, iaxis, kwargs):
if pad_width[0] > 0:
vector[:pad_width[0]] = np.random.randint(
256, size=pad_width[0])
help='Resize image based on image_size',
action='store_true')
# Output parameters
parser.add_argument('--out_dir',
type=str,
help='Path to the output directory',
default='./data/output')
parser.add_argument('--split_ratio',
type=float,
help='Test/Val split ratio',
default=0.2)
parser.add_argument('--split_type',
type=str,
choices=['TRAIN_TEST', 'FULL'],
help='How to split the data',
default='FULL')
return parser.parse_args(argv)
if __name__ == "__main__":
args = parse_arguments(sys.argv[1:])
# create a filenames, labels list
filenames, labels = utils.get_images_labels(args.data_dir)
# create ImageTFWriter object and process
image_writer = ImageTFWriter(args, filenames, labels)
image_writer.write_tf_records()