def main(args):
model = models.get_model(args.model, args.dataset)
dataset = model.dataset
train, test = datasets.load_data(dataset)
train, validation = datasets.split_data(train, fractions=[0.8, 0.2])
trainer.train(model, train, validation, args.epochs, args.batch_size,
args.learning_rate,
dataset_update=args.dataset_update, increments=args.splits,
use_ewc=args.ewc, ewc_lambda=args.ewc_lambda,
ewc_samples=args.ewc_samples,
use_fim=args.fim, fim_threshold=args.fim_threshold,
fim_samples=args.fim_samples,
use_incdet=args.incdet,
incdet_threshold=args.incdet_threshold)
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
def generate_data(size, test_part):
radius = 5
noise = 0
positive_num = int(size / 2)
negative_num = size - positive_num
positive_data = _generate_region(positive_num, radius, noise, 0,
radius * 0.5)
negative_data = _generate_region(negative_num, radius, noise, radius,
radius * 0.7)
x = np.hstack((positive_data[0], negative_data[0])).reshape(1, size)
y = np.hstack((positive_data[1], negative_data[1])).reshape(1, size)
labels = np.hstack((positive_data[2], negative_data[2])).reshape(1, size)
all_data = np.vstack((x, y, labels))
all_data_t = all_data.T
np.random.shuffle(all_data_t)
shuffled_t = all_data_t.T
points = np.vstack((shuffled_t[0], shuffled_t[1]))
train, test = ds.split_data(points, shuffled_t[2].reshape(1, size),
test_part)
return train, test
#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)
log_file_path = base_path + 'cew_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 + 'cew_blink_detect'
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 = DataLoader('cew')
faces, eyestates = data_loader.get_data()
print("out shapes: ", faces.shape, eyestates.shape)
faces = preprocess_input(faces)
num_samples, num_classes = eyestates.shape
train_data, val_data = split_data(faces, eyestates, validation_split)
train_faces, train_eyestates = train_data
model.fit_generator(data_generator.flow(train_faces, train_eyestates,
batch_size),
steps_per_epoch=len(train_faces) / batch_size,
epochs=num_epochs,
verbose=1,
callbacks=callbacks,
validation_data=val_data)
def main():
#Folder for images
DATA_PATH = '/home/sunny/work/fridgeObjects'
IMAGE_SIZE = 300
BATCH_SIZE = 16
LR = 0.0001
EPOCHS = 10
RANDOM_STATE = 19
#define argument parser
parser = argparse.ArgumentParser(description='Image classfication.')
parser.add_argument('-fp',
'--filepath',
help='Base directory for the dataset')
parser.add_argument('-i', '--image_size', help='Image size', type=int)
parser.add_argument('-b', '--batch_size', help='Batch size', type=int)
parser.add_argument('-lr', '--lr', help='Learning rate', type=float)
parser.add_argument('-e', '--epochs', help='Number of epochs', type=int)
parser.add_argument('-rs',
'--random_state',
help='Random state for datasplit')
args = vars(parser.parse_args())
if args['filepath']:
DATA_PATH = args['filepath']
if args['image_size']:
IMAGE_SIZE = args['image_size']
if args['batch_size']:
BATCH_SIZE = args['batch_size']
if args['lr']:
LR = args['lr']
if args['epochs']:
EPOCHS = args['epochs']
if args['random_state']:
RANDOM_STATE = args['random_state']
#load annotations
image_ids, labels, class_names = load_annotations_from_folder(DATA_PATH)
assert len(image_ids) == len(labels)
print(f'Total images: {len(image_ids)}')
print(f'Classes: {class_names}')
#split data into train and validation set
train_img_ids, val_img_ids, train_labels, val_labels = split_data(
image_ids,
labels,
test_size=0.2,
shuffle=True,
stratify=labels,
random_state=RANDOM_STATE)
assert len(train_img_ids) == len(train_labels)
assert len(val_img_ids) == len(val_labels)
print(f'Train samples: {len(train_img_ids)}')
print(f'Validation samples: {len(val_img_ids)}')
#calculate and display number of samples per class in train and test set
print()
print('Class distribution:')
print('Train set:')
train_classes, train_counts = np.unique(train_labels, return_counts=True)
assert len(train_classes) == len(class_names)
viz_utils.print_table(class_names, train_counts, header=['class', 'count'])
print()
print('validation set:')
val_classes, val_counts = np.unique(val_labels, return_counts=True)
assert len(val_classes) == len(class_names)
viz_utils.print_table(class_names, val_counts, header=['class', 'count'])
#define transforms for train and val dataset
#imagenet stats
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
train_transforms = T.Compose([
T.Resize((IMAGE_SIZE, IMAGE_SIZE)),
T.ToTensor(),
T.Normalize(mean, std)
])
val_transforms = T.Compose([
T.Resize((IMAGE_SIZE, IMAGE_SIZE)),
T.ToTensor(),
T.Normalize(mean, std)
])
#create train and validation dataset
train_dataset = ImageClassificationDataset(DATA_PATH, train_img_ids,
train_labels, train_transforms)
val_dataset = ImageClassificationDataset(DATA_PATH, val_img_ids,
val_labels, val_transforms)
#checks
assert len(train_dataset) == len(train_img_ids)
assert len(val_dataset) == len(val_img_ids)
ti, tl = train_dataset[0]
assert ti.shape == torch.Size((3, IMAGE_SIZE, IMAGE_SIZE))
assert type(tl) == int
#create dataloaders
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=BATCH_SIZE,
shuffle=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=BATCH_SIZE,
shuffle=False)
batch_inputs, batch_labels = next(iter(train_loader))
assert batch_inputs.shape == torch.Size(
(BATCH_SIZE, 3, IMAGE_SIZE, IMAGE_SIZE))
assert batch_labels.shape == torch.Size((BATCH_SIZE, ))
out = torchvision.utils.make_grid(batch_inputs)
viz_utils.imshow(out,
mean,
std,
title=[class_names[x] for x in batch_labels])
batch_inputs, batch_labels = next(iter(val_loader))
out = torchvision.utils.make_grid(batch_inputs)
viz_utils.imshow(out,
mean,
std,
title=[class_names[x] for x in batch_labels])
#create model
model = torchvision.models.resnet18(pretrained=True)
in_features = model.fc.in_features
model.fc = torch.nn.Linear(in_features, len(class_names))
#select gpu device if available
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
#move model to right device
model.to(device)
#create loss criterion
criterion = torch.nn.CrossEntropyLoss()
#create optimizer
optimizer = torch.optim.Adam(model.parameters(), lr=LR)
#create recorder to record metrics during training
recorder = TrainMetricRecorder(
['accuracy', 'precision', 'recall', 'f1_score'])
print("Training:")
fit(model, train_loader, val_loader, optimizer, criterion, EPOCHS, device,
recorder)
history = recorder.history
header = ['train_loss', 'val_loss', 'train_accuracy', 'val_accuracy']
viz_utils.print_table(history[header[0]],
history[header[1]],
history[header[2]],
history[header[3]],
header=header)
def train(model,
train_data,
valid_data,
epochs,
batch_size,
learning_rate,
dataset_update="full",
increments=1,
use_ewc=False,
ewc_lambda=1,
ewc_samples=100,
use_fim=False,
fim_threshold=1e-3,
fim_samples=100,
use_incdet=False,
incdet_threshold=None):
"""
Train a model using a complete dataset.
:param model: Model to be trained.
:param train_data: Training dataset.
:param valid_data: Validation dataset.
:param epochs: Number of epochs to train for.
:param batch_size: Number of inputs to process simultaneously.
:param learning_rate: Initial learning rate for Adam optimiser.
:param increments: Number of times to update the dataset (default 1).
:param dataset_update: Style of dataset update (full, increment, switch).
:param use_ewc: Should EWC be used?
:param ewc_lambda: Relative weighting of EWC loss vs normal loss.
:param ewc_samples: Samples of dataset to take when initialising EWC.
:param use_fim: Should Fisher information masking be used?
:param fim_threshold: How important a parameter must be to stop training.
:param fim_samples: Samples of dataset to take when initialising FIM.
:param use_incdet: Should IncDet (incremental detection) be used?
:param incdet_threshold: Threshold for IncDet gradient clipping.
"""
compile_model(model, learning_rate)
all_classes = np.unique(valid_data[1])
class_sets = np.array_split(all_classes, increments)
if dataset_update == "permute":
train_sets, perms = datasets.permute_pixels(train_data, increments)
valid_sets, _ = datasets.permute_pixels(valid_data, increments, perms)
else:
train_sets = datasets.split_data(train_data, classes=class_sets)
valid_sets = datasets.split_data(valid_data, classes=class_sets)
epochs_per_step = epochs // increments
regularisers = []
gradient_mask = None
if not use_incdet:
incdet_threshold = None
for step in range(increments):
# Get a training dataset for this step.
inputs, labels = dataset_selector[dataset_update](train_sets, step)
current_epoch = step * epochs_per_step
for epoch in range(current_epoch, current_epoch + epochs_per_step):
train_epoch(model, (inputs, labels),
batch_size,
gradient_mask=gradient_mask,
incdet_threshold=incdet_threshold)
report(model, epoch, valid_sets, batch_size)
# If we're using EWC, generate a loss function which adds a penalty if
# the model strays from the current state. This aims to preserve
# performance on the current dataset, which may not be seen again.
if use_ewc:
loss_fn = ewc.ewc_loss(ewc_lambda, model, (inputs, labels),
ewc_samples)
regularisers.append(loss_fn)
compile_model(model, learning_rate, extra_losses=regularisers)
# If using FIM, determine which weights must be frozen to preserve
# performance on the current dataset.
elif use_fim:
new_mask = ewc.fim_mask(model, (inputs, labels), fim_samples,
fim_threshold)
gradient_mask = ewc.combine_masks(gradient_mask, new_mask)
def generate_data(size, test_part):
points = ds.get_random_uniform(2, size, -5, 5)
points = _add_padding(points, 0.3)
labels = _get_xor_labels(points)
train, test = ds.split_data(points, labels, test_part)
return train, test
model_path = os.path.join(pargs.models_home, model_path)
if not os.path.exists(model_path):
os.makedirs(model_path)
if hasattr(params, 'model_dir'):
params.set_hparam('model_dir', model_path)
else:
params.add_hparam('model_dir', model_path)
logging.info('\nPARAMETERS:\n--------------\n{}\n--------------\n'.format(
params.to_json()))
# split data into train/valid/test
train_interactions, valid_interactions, test_interactions = split_data(
interactions=dataset['interactions'],
split_ratio=(3, 1, 1),
random_seed=RANDOM_SEED)
eval_users = np.array(
np.random.choice(np.arange(len(dataset['user_ids'])),
size=params.n_users_in_validation,
replace=False))
if params.mode == 'train':
train_model(params, train_interactions, valid_interactions, eval_users)
else:
logging.info('Get item popularities')
item_popularities = get_item_popularity(train_interactions)
mmr = get_median_rank_recommended_items(train_interactions, eval_users,
item_popularities,
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]]
#print ground_truth_data[train_keys[0]][0]
#print ground_truth_data[train_keys[1]][0]
#print ground_truth_data
