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()))