def generator(dataset_name, batch_size, classes):
data_loader = DataManager(dataset_name)
ground_truth_data = data_loader.get_data()
images_path = data_loader.dataset_path
train_keys, val_keys = split_data(ground_truth_data, 0)
image_generator = ImageGenerator(ground_truth_data,
batch_size, [224, 224, 3],
train_keys,
val_keys,
classes,
None,
path_prefix=images_path,
grayscale=False)
train_generator = image_generator.flow(mode='train')
train_num = len(train_keys) / batch_size
return train_generator, train_num
#callbacks
log_base_path = base_path + dataset_name + '_emotion_training.log'
csv_logger = CSVLogger(log_base_path, append=False)
early_stop = EarlyStopping('val_loss', patience=patience)
reduce_lr = ReduceLROnPlateau('val_loss',
factor=0.1,
patience=int(patience / 4),
verbose=1)
trained_models_path = base_path + dataset_name + '_mini_XCEPTION'
model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5'
model_checkpoint = ModelCheckpoint(model_names,
'val_loss',
verbose=1,
save_best_only=True)
callbacks = [model_checkpoint, csv_logger, early_stop, reduce_lr]
# loading dataset
data_loader = DataManager(dataset_name, image_size=input_shape[:2])
faces, emotions = data_loader.get_data()
faces = preprocess_input(faces)
num_samples, num_classes = emotions.shape
train_data, val_data = split_data(faces, emotions, validation_split)
train_faces, train_emotions = train_data
model.fit_generator(data_generator.flow(train_faces, train_emotions,
batch_size),
steps_per_epoch=len(train_faces) / batch_size,
epochs=num_epochs,
verbose=1,
callbacks=callbacks,
validation_data=val_data)
choices=[1, 2],
default=1,
help='lr scheduler type')
ap.add_argument('--decay',
'-d',
type=float,
default=0.001,
help='weight decay')
ap.add_argument('--epochs', default=200, type=int, help='Epochs')
ap.add_argument('--workers', default=0, type=int, help='number of workers')
ap.add_argument('--cuda_id', '-id', type=str, default='0', help='gpu number')
args = ap.parse_args()
############################### preparing dataset ################################
data_object = DataManager(args)
trainloader, valloader, testloader = data_object.prepare_data()
dataloaders = {'train': trainloader, 'val': valloader, "test": testloader}
############################### preparing model ###################################
model = get_model(args.model, 'full', data_object.num_classes,
data_object.insize)
############################## preparing for training #############################
if os.path.exists('logs') == False:
os.mkdir("logs")
if os.path.exists('checkpoints') == False:
os.mkdir("checkpoints")
input_shape = model.input_shape[1:3]
class_threshold = .1
iou_nms_threshold = .45
iou_threshold = .5
num_classes = 21
image_prefix = '../datasets/VOCdevkit/VOC2007/JPEGImages/'
with_difficult_objects = False
split = 'test'
class_names = get_class_names(dataset_name)
class_names = class_names[1:]
average_precisions = []
for class_name in class_names:
selected_classes = ['background'] + [class_name]
data_manager = DataManager(dataset_name, split, selected_classes,
with_difficult_objects)
ground_truth_data = data_manager.load_data()
difficult_data_flags = data_manager.parser.difficult_objects
scores = []
labels = []
num_gt_boxes = 0
for image_name, gt_sample in tqdm(ground_truth_data.items()):
image_path = image_prefix + image_name
reference_size = get_image_size(image_path)
detections = infer_from_path(image_path, model, prior_boxes)
gt_sample = denormalize_boxes(gt_sample, reference_size)
num_gt_boxes = num_gt_boxes + len(gt_sample)
already_detected = np.zeros(shape=len(gt_sample), dtype=bool)
for detection in detections:
ious = calculate_intersection_over_union(detection, gt_sample)
score = np.max(detection[4:])
weights_path = '../trained_models/SSD300_weights.hdf5'
datasets = ['VOC2007', 'VOC2012']
splits = ['trainval', 'trainval']
class_names = 'all'
difficult_boxes = True
model_path = '../trained_models/SSD_scratch_all/'
save_path = model_path + 'weights.{epoch:02d}-{val_loss:.2f}.hdf5'
frozen_layers = ['input_1', 'conv1_1', 'conv1_2', 'pool1',
'conv2_1', 'conv2_2', 'pool2',
'conv3_1', 'conv3_2', 'conv3_3', 'pool3',
'conv4_1', 'conv4_2', 'conv4_3', 'pool4',
'conv5_1', 'conv5_2', 'conv5_3', 'pool5',
'fc6', 'fc7']
dataset_manager = DataManager(datasets, splits, class_names, difficult_boxes)
train_data = dataset_manager.load_data()
val_data = test_data = DataManager('VOC2007', 'test').load_data()
class_names = dataset_manager.class_names
num_classes = len(class_names)
# generator
prior_boxes = to_point_form(create_prior_boxes())
generator = ImageGenerator(train_data, val_data, prior_boxes, batch_size,
box_scale_factors, num_classes)
# model
multibox_loss = MultiboxLoss(num_classes, negative_positive_ratio, batch_size)
model = SSD300(image_shape, num_classes, weights_path,
frozen_layers, randomize_top)
model.compile(optimizer, loss=multibox_loss.compute_loss)
from utils.data_augmentation import ConvertFromInts
from utils.data_augmentation import ToAbsoluteCoords
from utils.data_augmentation import PhotometricDistort2
from utils.data_augmentation import Expand
from utils.data_augmentation import RandomSampleCrop
from utils.data_augmentation import HorizontalFlip
from utils.data_augmentation import ToPercentCoords
from utils.data_augmentation import Resize
from utils.data_augmentation import SubtractMeans
from utils.preprocessing import load_image
from utils.preprocessing import B_MEAN, G_MEAN, R_MEAN
from datasets import DataManager
import matplotlib.pyplot as plt
data_manager = DataManager('VOC2007', 'train')
class_names = data_manager.class_names
train_data = data_manager.load_data()
image_path = sorted(list(train_data.keys()))[7]
box_data = train_data[image_path]
image_array = load_image(image_path, RGB=False).copy()
data = (image_array, box_data[:, :4], box_data[:, 4:])
convert_from_ints = ConvertFromInts()
to_absolute_coords = ToAbsoluteCoords()
photometric_distort = PhotometricDistort2()
expand = Expand((B_MEAN, G_MEAN, R_MEAN))
random_sample_crop = RandomSampleCrop()
horizontal_flip = HorizontalFlip()
to_percent_coords = ToPercentCoords()
resize = Resize(300)
momentum = .9
optimizer = SGD(learning_rate, momentum, decay=weight_decay)
decay = 0.1
step_epochs = [154, 193, 232]
randomize_top = True
weights_path = '../trained_models/VGG16_weights.hdf5'
train_datasets = ['VOC2007', 'VOC2012']
train_splits = ['trainval', 'trainval']
val_dataset = 'VOC2007'
val_split = 'test'
class_names = 'all'
difficult_boxes = True
model_path = '../trained_models/SSD_SGD_scratch_all2/'
save_path = model_path + 'weights.{epoch:02d}-{val_loss:.2f}.hdf5'
train_data_manager = DataManager(train_datasets, train_splits, class_names,
difficult_boxes)
train_data = train_data_manager.load_data()
class_names = train_data_manager.class_names
num_classes = len(class_names)
val_data_manager = DataManager(val_dataset, val_split, class_names, False)
val_data = val_data_manager.load_data()
# generator
prior_boxes = to_point_form(create_prior_boxes())
generator = ImageGenerator(train_data, val_data, prior_boxes, batch_size,
box_scale_factors, num_classes)
# model
multibox_loss = MultiboxLoss(num_classes, negative_positive_ratio, batch_size)
model = SSD300(image_shape, num_classes, weights_path)
model.compile(optimizer, loss=multibox_loss.compute_loss)
datasets = ['fer2013']
for dataset_name in datasets:
print('Training dataset:', dataset_name)
# callbacks
log_file_path = base_path + dataset_name + '_emotion_training.log'
csv_logger = CSVLogger(log_file_path, append=False)
early_stop = EarlyStopping('val_loss', patience=patience)
reduce_lr = ReduceLROnPlateau('val_loss', factor=0.1,
patience=int(patience/4), verbose=1)
trained_models_path = base_path + dataset_name + '_mini_XCEPTION'
model_names = trained_models_path + '.{epoch:02d}-{val_acc:.2f}.hdf5'
model_checkpoint = ModelCheckpoint(model_names, 'val_loss', verbose=1,
save_best_only=True)
callbacks = [model_checkpoint, csv_logger, early_stop, reduce_lr]
# loading dataset
data_loader = DataManager(dataset_name, '../biteam/datasets/fer2013/fer2013.csv', image_size=input_shape[:2])
faces, emotions = data_loader.get_data()
faces = preprocess_input(faces)
num_samples, num_classes = emotions.shape
train_data, val_data = split_data(faces, emotions, validation_split)
train_faces, train_emotions = train_data
model.fit_generator(data_generator.flow(train_faces, train_emotions,
batch_size),
steps_per_epoch=len(train_faces) / batch_size,
epochs=num_epochs, verbose=1, callbacks=callbacks,
validation_data=val_data)
from keras.callbacks import ModelCheckpoint
from keras.callbacks import EarlyStopping
from keras.callbacks import CSVLogger
from datasets import DataManager
from models import MultiboxLoss
from models import SSD300
from keras.optimizers import Adam
from utils.data_augmentation import ImageGenerator
from utils.boxes import create_prior_boxes
batch_size = 3
num_epochs = 2
image_shape = (300, 300, 3)
dataset_manager = DataManager(['VOC2007', 'VOC2012'], ['trainval', 'trainval'])
train_data = dataset_manager.load_data()
val_data = test_data = DataManager('VOC2007', 'test').load_data()
class_names = dataset_manager.class_names
num_classes = len(class_names)
prior_boxes = create_prior_boxes()
generator = ImageGenerator(train_data, val_data, prior_boxes, batch_size)
weights_path = '../trained_models/SSD300_weights.hdf5'
frozen_layers = ['input_1', 'conv1_1', 'conv1_2', 'pool1',
'conv2_1', 'conv2_2', 'pool2',
'conv3_1', 'conv3_2', 'conv3_3', 'pool3']
model = SSD300(image_shape, num_classes, weights_path, frozen_layers, True)
class_threshold = .1
iou_nms_threshold = .45
iou_threshold = .5
num_classes = 21
average_precisions = []
for ground_truth_class_arg in range(1, num_classes):
labels = []
scores = []
class_names = get_class_names(dataset_name)
selected_classes = [class_names[0]] + [class_names[ground_truth_class_arg]]
num_ground_truth_boxes = 0
class_decoder = get_arg_to_class(class_names)
num_classes = len(class_names)
data_manager = DataManager(dataset_name,
split='test',
class_names=selected_classes)
ground_truth_data = data_manager.load_data()
difficult_data_flags = data_manager.parser.difficult_objects
image_names = sorted(list(ground_truth_data.keys()))
for image_name in image_names:
ground_truth_sample = ground_truth_data[image_name]
image_prefix = data_manager.parser.images_path
image_path = image_prefix + image_name
original_image_array = cv2.imread(image_path)
image_array, original_image_size = load_image(image_path, input_shape)
# original_image_size = original_image_size[::-1]
image_array = substract_mean(image_array)
predicted_data = predict(model, image_array, prior_boxes,
original_image_size, num_classes,
def __init__(self):
self.manager = DataManager()
self.extra = {}
import random
import sys
from keras.preprocessing import image
from keras.applications.imagenet_utils import preprocess_input
sys.path.append('../utils')
from data_augmentation_reid import ImageGenerator
from datasets import DataManager
from datasets import split_data
if __name__ == '__main__':
dataset_name = 'market'
batch_size = 32
input_shape = (224, 224, 3)
classes = 751
data_loader = DataManager(dataset_name)
images_path = data_loader.dataset_path
ground_truth_data = data_loader.get_data()
train_keys, val_keys = split_data(ground_truth_data, 0.2)
#print ground_truth_data
f = open('../result/market_ground_truth.txt', 'w')
f.write(str(ground_truth_data))
f.close()
#np.savetxt('../result/market_ground_truth.txt',ground_truth_data)
#print len(ground_truth_data)
#print len(train_keys)
#print train_keys[0]
#print ground_truth_data[train_keys[0]]
#print images_path
#print ground_truth_data[train_keys[1]]
from datasets import DataManager
data_manager = DataManager('VOC2007', split='test')
gt = data_manager.load_data()
print(len(gt.keys()))
from datasets import DataManager
classes = ['background', 'dog']
data_manager = DataManager('VOC2007', 'test', classes, False)
data = data_manager.load_data()
print(len(data.keys()))
