def main():
args = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
args.add_argument("--model", help="The model to train on")
args = args.parse_args()
if args.model == 'alexnet':
model = models.AlexNet(1)
train(model, args.model)
elif args.model == 'resnet18':
model = models.ResNet(18, 1)
train(model, args.model)
elif args.model == 'resnet34':
model = models.ResNet(34, 1)
train(model, args.model)
elif args.model == 'resnet':
model = models.ResNet(101, 1)
train(model, args.model)
else:
if args.model == 'all':
# model = models.AlexNet()
# train(model, 'AlexNet')
# del model
model = models.create_pretrained_alexnet(1)
train(model,'AlexNetFinetuned')
del model
# model = models.ResNet(34,1)
# train(model, 'ResNet34')
# del model
model = models.ResNet(50,1)
train(model, 'ResNet50')
del model
model = models.ResNet(101,1)
train(model, 'ResNet101')
del model
raise ValueError("Did not provide a valid model")
def testResNet(self):
resolutions = [
[3, 32, 32],
]
blocks = [
[3],
[3, 3],
[3, 3, 3],
[3, 3, 3, 3],
]
normalizations = [True, False]
classes = 10
batch_size = 100
for resolution in resolutions:
for block in blocks:
for normalization in normalizations:
model = models.ResNet(classes,
resolution,
clamp=True,
blocks=block,
normalization=normalization)
output = model(
torch.autograd.Variable(
torch.zeros([batch_size] + resolution)))
self.assertEqual(output.size()[0], batch_size)
self.assertEqual(output.size()[1], classes)
def setUp(self):
self.trainset = torch.utils.data.DataLoader(
common.datasets.SVHNTrainSet(indices=range(10000)),
batch_size=100,
shuffle=True,
num_workers=4)
self.testset = torch.utils.data.DataLoader(
common.datasets.SVHNTestSet(),
batch_size=100,
shuffle=False,
num_workers=4)
self.adversarialset = torch.utils.data.DataLoader(
common.datasets.SVHNTestSet(indices=range(1000)),
batch_size=100,
shuffle=False,
num_workers=4)
self.randomset = torch.utils.data.DataLoader(
common.datasets.RandomTestSet(1000, size=(28, 28, 1)),
batch_size=100,
shuffle=False,
num_workers=4)
self.cuda = True
self.model = models.ResNet(10, [3, 32, 32],
channels=12,
blocks=[3, 3, 3])
if self.cuda:
self.model = self.model.cuda()
def _set_model(self):
print("netType:", self.settings.netType)
if self.settings.dataset in ["cifar10", "cifar100"]:
if self.settings.netType == "DARTSNet":
genotype = md.genotypes.DARTS
self.model = md.DARTSNet(self.settings.init_channels,
self.settings.nClasses,
self.settings.layers,
self.settings.auxiliary, genotype)
elif self.settings.netType == "PreResNet":
self.model = md.PreResNet(depth=self.settings.depth,
num_classes=self.settings.nClasses,
wide_factor=self.settings.wideFactor)
elif self.settings.netType == "CifarResNeXt":
self.model = md.CifarResNeXt(self.settings.cardinality,
self.settings.depth,
self.settings.nClasses,
self.settings.base_width,
self.settings.widen_factor)
elif self.settings.netType == "ResNet":
self.model = md.ResNet(self.settings.depth,
self.settings.nClasses)
else:
assert False, "use %s data while network is %s" % (
self.settings.dataset, self.settings.netType)
else:
assert False, "unsupported data set: " + self.settings.dataset
def get_model(dataset, net_type, depth, n_classes):
"""
Available model
cifar:
preresnet
vgg
imagenet:
resnet
"""
if dataset in ["cifar10", "cifar100"]:
test_input = torch.randn(1, 3, 32, 32).cuda()
if net_type == "preresnet":
model = md.PreResNet(depth=depth, num_classes=n_classes)
else:
assert False, "use {} data while network is {}".format(dataset, net_type)
elif dataset in ["imagenet", "sub_imagenet"]:
test_input = torch.randn(1, 3, 224, 224).cuda()
if net_type == "resnet":
model = md.ResNet(depth=depth, num_classes=n_classes)
else:
assert False, "use {} data while network is {}".format(dataset, net_type)
else:
assert False, "unsupported data set: {}".format(dataset)
return model, test_input
def get_confusion_matrix(weight_path, data):
(x_test, y_test) = data
x_test = x_test[:500]
y_test = y_test[:500]
model = models.ResNet(depth=8)
_ = model(x_test[0:2])
model.load_weights(weight_path)
predictions = model(x_test, training=False).numpy()
predictions = tf.argmax(predictions, axis=1)
labels = tf.argmax(y_test, axis=1)
confusion_matrix = tf.math.confusion_matrix(labels=labels, predictions=predictions, num_classes=10, dtype=tf.float32)
print(confusion_matrix)
confusion_matrix = tf.transpose(tf.divide(tf.transpose(confusion_matrix), tf.reduce_sum(y_test, axis=0)))
print(tf.reduce_sum(y_test, axis=0))
return confusion_matrix.numpy()
def setUp(self):
self.trainset = torch.utils.data.DataLoader(
common.datasets.Cifar10TrainSet(),
batch_size=100,
shuffle=True,
num_workers=4)
self.testset = torch.utils.data.DataLoader(
common.datasets.Cifar10TestSet(),
batch_size=100,
shuffle=False,
num_workers=4)
self.cuda = True
self.model = models.ResNet(10, [3, 32, 32],
channels=12,
blocks=[3, 3, 3])
if self.cuda:
self.model = self.model.cuda()
def testResNet(self):
resolutions = [
[3, 32, 32],
]
blocks = [
[3],
[3, 3, 3, 3],
]
normalizations = [
None,
torch.nn.BatchNorm1d
]
clamps = [
True,
False
]
scales_and_whitens = [
(False, False),
(True, False),
(False, True),
]
classes = 10
for resolution in resolutions:
for block in blocks:
for normalization in normalizations:
for clamp in clamps:
for scale_and_whiten in scales_and_whitens:
original_model = models.ResNet(classes, resolution, clamp=clamp, scale=scale_and_whiten[0], whiten=scale_and_whiten[1], blocks=block, normalization=normalization)
for parameters in original_model.parameters():
parameters.data.zero_()
common.state.State.checkpoint(self.filepath, original_model)
state = common.state.State.load(self.filepath)
loaded_model = state.model
for parameters in loaded_model.parameters():
self.assertEqual(torch.sum(parameters).item(), 0)
def main():
config = get_args()
config.device = torch.device(
"cuda" if torch.cuda.is_available() else "cpu")
# preprocess
if config.preprocess_frames:
preprocess.get_frames(config.train_vid, config.train_frames)
preprocess.get_frames(config.test_vid, config.test_frames)
if config.create_csv:
train_speeds = preprocess.read_speed(config.train_speeds)
preprocess.create_csv(config.train_frames, train_speeds,
config.csv_path)
# dataset creation
dataset = FrameDataset(config.csv_path, config.train_frames)
train_set, val_set = random_split(dataset, [16320, 4080])
# test set creation
transform = transforms.Compose([
transforms.Resize((66, 220)),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
])
test_set = datasets.ImageFolder(config.test_frames, transform=transform)
# model selection
if config.model == 'simpleCNN':
model = models.simpleCNN().to(config.device)
elif config.model == 'ResNet':
model = models.ResNet().to(config.device)
# train/val/test
if config.train:
runner.train(config, model, train_set)
elif config.val:
runner.validate(config, model, val_set)
elif config.test:
runner.test(config, model, test_set)
def test_task1(root_path):
'''
:param root_path: root path of test data, e.g. ./dataset/task1/test/
:return results: a dict of classification results
results = {'audio_0000.pkl': 1, ‘audio_0001’: 3, ...}
class number:
‘061_foam_brick’: 0
'green_basketball': 1
'salt_cylinder': 2
'shiny_toy_gun': 3
'stanley_screwdriver': 4
'strawberry': 5
'toothpaste_box': 6
'toy_elephant': 7
'whiteboard_spray': 8
'yellow_block': 9
'''
preds = []
names = []
ds = my_dataset("test", transform, root_path)
loader = torch.utils.data.DataLoader(ds, 64, False, num_workers=20)
model = models.ResNet(block=models.BasicBlock, num_blocks=[3, 3, 3])
model = nn.DataParallel(model).cuda()
model.load_state_dict(torch.load("task1resnet18.pkl"))
model.eval()
for data in loader:
image, name = data['image'], data['name']
image = image.cuda()
image = torch.autograd.Variable(image)
output = model(image)
pred = torch.argmax(output, 1)
names.extend(name)
preds.extend(pred)
preds = [int(i) for i in preds]
names = [i[-14:] for i in names]
# dirs = os.listdir(os.path.join(root_path))
results = dict(zip(names, preds))
np.save("task1result.npy", results)
return results
def run(args):
# Get the data
train_data = CleanDataset(paths.train_images_file(
args.dataset), paths.train_labels_file(args.dataset))
test_data = CleanDataset(paths.test_images_file(
args.dataset), paths.test_labels_file(args.dataset))
trainset = DataLoader(train_data, batch_size=args.batch_size, shuffle=True)
testset = DataLoader(test_data, batch_size=args.batch_size, shuffle=False)
# Create or load saved model
if args.saved_model_file:
state = State.load(paths.experiment_file(
args.models_dir, args.saved_model_file))
model = state.model
if args.cuda:
model.cuda()
optimizer = torch.optim.SGD(model.parameters(), lr=args.lr,
momentum=args.momentum, weight_decay=args.weight_decay)
scheduler = common.train.get_exponential_scheduler(
optimizer, batches_per_epoch=len(trainset), gamma=args.lr_decay)
optimizer.load_state_dict(state.optimizer)
for st in optimizer.state.values():
for k, v in st.items():
if torch.is_tensor(v):
st[k] = v.cuda()
scheduler.load_state_dict(state.scheduler)
initial_epoch = state.epoch
else:
model = models.ResNet(args.n_classes, [3, 32, 32], channels=12, blocks=[
3, 3, 3], clamp=True)
if args.cuda:
model.cuda()
optimizer = SGD(model.parameters(), lr=args.lr,
momentum=args.momentum, weight_decay=args.weight_decay)
scheduler = common.train.get_exponential_scheduler(
optimizer, batches_per_epoch=len(trainset), gamma=args.lr_decay)
initial_epoch = -1
# Logging
if args.use_tensorboard:
from torch.utils.tensorboard import SummaryWriter
else:
from common.summary import SummaryWriter
writer = SummaryWriter(paths.log_dir(args.log_dir), max_queue=100)
# Augmentation parameters
augmentation_crop = True
augmentation_contrast = True
augmentation_add = False
augmentation_saturation = False
augmentation_value = False
augmentation_flip = args.use_flip
augmentation = common.imgaug.get_augmentation(noise=False, crop=augmentation_crop, flip=augmentation_flip, contrast=augmentation_contrast,
add=augmentation_add, saturation=augmentation_saturation, value=augmentation_value)
# Create attack objects
img_dims = (32, 32)
if args.location == 'random':
mask_gen = MaskGenerator(img_dims, tuple(args.mask_dims),
exclude_list=np.array([args.exclude_box]))
else:
mask_gen = MaskGenerator(img_dims, tuple(args.mask_dims),
include_list=np.array([args.mask_pos + args.mask_dims]))
attack = AdversarialPatch(mask_gen, args.epsilon, args.iterations,
args.optimize_location, args.opt_type, args.stride, args.signed_grad)
attack.norm = LInfNorm()
objective = UntargetedF0Objective()
if args.mode == 'adversarial':
trainer = common.train.AdversarialTraining(model, trainset, testset, optimizer, scheduler,
attack, objective, fraction=args.adv_frac, augmentation=augmentation, writer=writer, cuda=args.cuda)
elif args.mode == 'normal':
trainer = common.train.NormalTraining(
model, trainset, testset, optimizer, scheduler, augmentation=augmentation, writer=writer, cuda=args.cuda)
trainer.summary_gradients = False
# Train model
for e in range(initial_epoch + 1, args.epochs):
trainer.step(e)
writer.flush()
# Save model snapshot
if (e + 1) % args.snapshot_frequency == 0:
State.checkpoint(paths.experiment_file(
args.models_dir, args.model_prefix + '_' + str(e + 1)), model, optimizer, scheduler, e)
# Save final model
State.checkpoint(paths.experiment_file(
args.models_dir, args.model_prefix + '_complete_' + str(e + 1)), model, optimizer, scheduler, args.epochs)
self.fc = nn.Linear(2048 ,5)
def forward(self, x):
out = self.conv1(x)
#out = self.maxpool1(out)
out = self.layer1(out)
out = self.layer2(out)
out = self.layer3(out)
out = self.layer4(out)
out = self.avgpool(out)
out = out.view(out.size(0), -1)
out = self.fc(out)
return out
resnet_model = models.ResNet().to(device)
def adjust_lr(optimizer, epoch):
if epoch < 10:
lr = 0.01
elif epoch < 500:
lr = 0.003
elif epoch < 2000:
lr = 0.001
elif epoch < 2500:
lr = 0.0005
else:
lr = 0.0001
for param_group in optimizer.param_groups:
param_group['lr'] = lr
def main():
summery_writer = tf.summary.create_file_writer(LOG_DIR)
print_every_n = 50
(x_train, y_train), (x_test, y_test) = load_dataset()
n_train = x_train.shape[0]
l2_regularizer = tf.keras.regularizers.l2(LAMBDA)
model = models.ResNet(depth=NUM_LAYERS,
se_block=SE_BLOCKS,
ratios=RATIOS,
regularizer=l2_regularizer)
crossentropy = tf.keras.losses.CategoricalCrossentropy()
adam = tf.keras.optimizers.Adam(learning_rate=lr_scheduler)
global epoch
for epoch in range(EPOCHS):
epoch_loss = 0
loss = 0
acc = 0
print("Epoch learning rate: ", adam.get_config()['learning_rate'])
for i in range(int(np.ceil(n_train // BATCH_SIZE))):
x_batch = x_train[i * BATCH_SIZE:(i + 1) * BATCH_SIZE]
x_batch = preprocess_batch(x_batch)
y_batch = y_train[i * BATCH_SIZE:(i + 1) * BATCH_SIZE]
# (x_batch, y_batch) = shuffle(x_batch, y_batch)
batch_loss, batch_acc = update_step(model,
x_batch,
y_batch,
loss_func=crossentropy,
optimizer=adam)
loss += batch_loss
acc += batch_acc
epoch_loss += batch_loss
if i % print_every_n == 0:
if i != 0:
loss /= print_every_n + 1
acc /= print_every_n + 1
print("Epoch {} Iteration {}/{} Loss {} Acc {}".format(
epoch, i, n_train // BATCH_SIZE, loss, acc))
loss = 0
acc = 0
epoch_loss /= int(np.ceil(n_train // BATCH_SIZE))
y_pred_test = model(x_test, training=False)
test_acc = accuracy(y_test, y_pred_test)
test_loss = crossentropy(
y_test, y_pred_test) #TODO: räknar den loss per batch size?
print("Epoch {}, accuracy: {} loss {}".format(epoch, test_acc,
test_loss))
save_directory = LOG_DIR + "/{}ResNet_{}_weights/".format(
"SE_" if SE_BLOCKS else "", NUM_LAYERS)
try:
os.mkdir(save_directory)
except FileExistsError:
pass
model.save_weights(filepath=save_directory + "checkpoint",
save_format='h5')
with summery_writer.as_default():
tf.summary.scalar('Test Accuracy', test_acc, step=epoch)
tf.summary.scalar('Test Loss', test_loss, step=epoch)
tf.summary.scalar('Training Loss', epoch_loss, step=epoch)
args = parser.parse_args()
np.random.seed(args.seed)
strategy = tf.distribute.MirroredStrategy()
print(f'Number of devices for multigpu strategy: {strategy.num_replicas_in_sync}')
with strategy.scope():
if args.arch == "cnn":
model, input_shape, channels = models.CNN()
elif args.arch == "resnet-head":
model, input_shape, channels = models.ResNetHead()
elif args.arch == "1d-conv":
model, input_shape, channels = models.Conv1D()
elif args.arch == "resnet-full":
model, input_shape, channels = models.ResNet()
else:
raise NotImplementedError("Model type not supported")
# print("trainable count:", len(model.trainable_variables))
optimizer = keras.optimizers.Adam(
learning_rate=args.lr,
# decay=1e-2,
)
model.compile(loss="binary_crossentropy", optimizer=optimizer,
metrics=[keras.metrics.CategoricalAccuracy(), utils.f1_m, utils.precision_m, utils.recall_m])
# Data
data_generator = dataloader.DataGenerator("spectrograms", batch_size=args.batch_size, dim=input_shape,
ax = sns.heatmap(cm, cmap="binary", annot=True, fmt="d")
print(cm)
figure = ax.get_figure()
figure.savefig('{}/result-heatmap.png'.format(output_path), dpi=600)
if __name__ == "__main__":
protocol(
_custom_output_dir='V19_DA1000_LIMIT',
_use_data_augmentation=True,
_limit_dataset=True,
# _network_class=models.EfficientNet(net='b7',
# _network_class=models.MobileNet(net='v1',
# _network_class=models.VGGNet(net='19',
_network_class=models.ResNet(net='50',
use_weights=True,
use_regularization=False,
regularizer=keras.regularizers.l2(0.01)),
_load_data_function=utils.load_covid_dataset,
_number_of_classes=3,
_batch_size=10,
_epochs=20,
_shuffle_in_training=True,
_plot_loss_epochs=2,
_lr=0.001,
_train_portion=0.9,
_model_epochs_checkpoint=200,
_save_intermediate_models=False,
_save_model=True)
alb = denorm(alb)
shade = applyMask(rImg, real_image_mask_test)
shade = shade / alb
utils.save_image(torchvision.utils.make_grid(shade.data, padding=1),
output_path + 'val/test_real_shading.png')
## TRUE SHADING
'''
tmp = next(iter(sirfs_shading_val))
tmp = utils.denorm(tmp)
tmp = applyMask(var(tmp).type(torch.DoubleTensor), real_image_mask_test)
tmp = tmp.data
utils.save_image(torchvision.utils.make_grid(tmp, padding=1), output_path+'images/Validation_SIRFS_SHADING.png')
'''
featureNet = models.ResNet(models.BasicBlock, [2, 2, 2, 2], 27)
#featureNet = models.BaseSimpleFeatureNet()
lightingNet = models.LightingNet()
D = models.Discriminator()
R = models.ResNet(models.BasicBlock, [2, 2, 2, 2], 27) #
#R = models.BaseSimpleFeatureNet()
print(featureNet)
print(lightingNet)
featureNet = featureNet.cuda()
lightingNet = lightingNet.cuda()
D = D.cuda()
R = R.cuda()
dtype = torch.FloatTensor
dtype = torch.cuda.FloatTensor ## UNCOMMENT THIS LINE IF YOU'RE ON A GPU!
def main(net_opt=None):
"""requirements:
apt-get install graphviz
pip install pydot termcolor"""
start_time = time.time()
opt = net_opt or NetOption()
# set torch seed
# init random seed
torch.manual_seed(opt.manualSeed)
torch.cuda.manual_seed(opt.manualSeed)
cudnn.benchmark = True
if opt.nGPU == 1 and torch.cuda.device_count() >= 1:
assert opt.GPU <= torch.cuda.device_count() - 1, "Invalid GPU ID"
torch.cuda.set_device(opt.GPU)
else:
torch.cuda.set_device(opt.GPU)
# create data loader
data_loader = DataLoader(dataset=opt.data_set,
train_batch_size=opt.trainBatchSize,
test_batch_size=opt.testBatchSize,
n_threads=opt.nThreads,
ten_crop=opt.tenCrop)
train_loader, test_loader = data_loader.getloader()
# define check point
check_point = CheckPoint(opt=opt)
# create residual network model
if opt.retrain:
check_point_params = check_point.retrainmodel()
elif opt.resume:
check_point_params = check_point.resumemodel()
else:
check_point_params = check_point.check_point_params
optimizer = check_point_params['opts']
start_epoch = check_point_params['resume_epoch'] or 0
if check_point_params['resume_epoch'] is not None:
start_epoch += 1
if start_epoch >= opt.nEpochs:
start_epoch = 0
if opt.netType == "ResNet":
model = check_point_params['model'] or MD.ResNet(
depth=opt.depth,
num_classes=opt.nClasses,
wide_factor=opt.wideFactor)
model = dataparallel(model, opt.nGPU, opt.GPU)
elif opt.netType == "PreResNet":
model = check_point_params['model'] or MD.PreResNet(
depth=opt.depth,
num_classes=opt.nClasses,
wide_factor=opt.wideFactor)
model = dataparallel(model, opt.nGPU, opt.GPU)
elif opt.netType == "LeNet5":
model = check_point_params['model'] or MD.LeNet5()
model = dataparallel(model, opt.nGPU, opt.GPU)
else:
assert False, "invalid net type"
# create online board
if opt.onlineBoard:
try:
online_board = BoardManager("main")
except:
online_board = None
print "|===> Failed to create online board! Check whether you have ran <python -m visdom.server>"
else:
online_board = None
trainer = Trainer(model=model,
opt=opt,
optimizer=optimizer,
online_board=online_board)
print "|===>Create trainer"
# define visualizer
visualize = Visualization(opt=opt)
visualize.writeopt(opt=opt)
# visualize model
if opt.drawNetwork:
if opt.data_set == "cifar10" or opt.data_set == "cifar100":
rand_input = torch.randn(1, 3, 32, 32)
elif opt.data_set == "mnist":
rand_input = torch.randn(1, 1, 28, 28)
else:
assert False, "invalid data set"
rand_input = Variable(rand_input.cuda())
rand_output = trainer.forward(rand_input)
visualize.gennetwork(rand_output)
visualize.savenetwork()
# test model
if opt.testOnly:
trainer.test(epoch=0, test_loader=test_loader)
return
best_top1 = 100
best_top5 = 100
for epoch in range(start_epoch, opt.nEpochs):
start_epoch = 0
# training and testing
train_error, train_loss, train5_error = trainer.train(
epoch=epoch, train_loader=train_loader)
test_error, test_loss, test5_error = trainer.test(
epoch=epoch, test_loader=test_loader)
# show training information on online board
if online_board is not None:
online_board.updateplot(train_error,
train5_error,
train_loss,
mode="Train")
online_board.updateplot(test_error,
test5_error,
test_loss,
mode="Test")
# write and print result
log_str = "%d\t%.4f\t%.4f\t%.4f\t%.4f\t%.4f\t%.4f\t" % (
epoch, train_error, train_loss, test_error, test_loss,
train5_error, test5_error)
visualize.writelog(log_str)
best_flag = False
if best_top1 >= test_error:
best_top1 = test_error
best_top5 = test5_error
best_flag = True
if online_board is not None:
online_board.updateresult([best_top1, best_top5, test_loss])
print colored(
"==>Best Result is: Top1 Error: %f, Top5 Error: %f\n" %
(best_top1, best_top5), "red")
else:
print colored(
"==>Best Result is: Top1 Error: %f, Top5 Error: %f\n" %
(best_top1, best_top5), "blue")
# save check_point
# save best result and recent state
check_point.savemodel(epoch=epoch,
model=trainer.model,
opts=trainer.optimzer,
best_flag=best_flag)
if (epoch + 1) % opt.drawInterval == 0:
visualize.drawcurves()
end_time = time.time()
time_interval = end_time - start_time
t_string = "Running Time is: " + str(
datetime.timedelta(seconds=time_interval)) + "\n"
print(t_string)
# save experimental results
visualize.writereadme(
"Best Result of all is: Top1 Error: %f, Top5 Error: %f\n" %
(best_top1, best_top5))
visualize.writereadme(t_string)
visualize.drawcurves()
def __init__(self, n_layer):
super(Feature_ResNet, self).__init__()
all_model = models.ResNet(1, n_layer, pretrained=False)
for name, modules in all_model._modules.items():
if name != 'fc':
self.add_module(name, modules)
plot_file_path='./plots/pairSetup_VGGNetLike.svg',
lr=0.0001,
epochs=300,
use_crossentropy=True,
verbose=True,
rounds=10)
print('mean minimum test error : {0:.{1}f} %'.format(test_err_mean, 1))
print('std minimum test error : {0:.{1}f} %'.format(test_err_std, 1))
print('number of trainable parameters : {}'.format(
count_parameters(model)))
if run_PairSetup_ResNet:
torch.manual_seed(random_seed)
print('************ Running ResNet model (for PairSetup) ****************')
in_depth, out_dim = 2, 2
model = models.ResNet(in_depth, out_dim, 8)
test_err_mean, test_err_std, _, _ = training_functions.rounds_train(
model,
'PairSetup',
plot_title='Pair Setup ResNet error history',
plot_file_path='./plots/pairSetup_ResNet.svg',
lr=0.0002,
epochs=300,
use_crossentropy=True,
verbose=True,
rounds=10)
print('mean minimum test error : {0:.{1}f} %'.format(test_err_mean, 1))
print('std minimum test error : {0:.{1}f} %'.format(test_err_std, 1))
print('number of trainable parameters : {}'.format(
count_parameters(model)))
def test_task2(root_path):
'''
:param root_path: root path of test data, e.g. ./dataset/task2/test/0/
:return results: a dict of classification results
results = {'audio_0000.pkl': 23, ‘audio_0001’: 11, ...}
This means audio 'audio_0000.pkl' is matched to video 'video_0023' and ‘audio_0001’ is matched to 'video_0011'.
'''
results = {}
audio_preds = []
audio_names = []
audio_ds = my_dataset("test", transform, root_path)
audio_loader = torch.utils.data.DataLoader(audio_ds,
4,
False,
num_workers=0)
audio_model = models.ResNet(block=models.BasicBlock, num_blocks=[3, 3, 3])
audio_model = nn.DataParallel(audio_model).cuda()
audio_model.load_state_dict(torch.load("task1resnet18.pkl"))
audio_model.eval()
for data in audio_loader:
image, name = data['image'], data['name']
image = image.cuda()
image = torch.autograd.Variable(image)
output = audio_model(image)
pred = torch.argmax(output, 1)
audio_names.extend(name)
audio_preds.extend(pred)
audio_preds = [int(i) for i in audio_preds]
audio_names = [i.split('/')[-1][:-4] for i in audio_names]
audio_results = dict(zip(audio_names, audio_preds))
video_preds = []
video_names = []
video_ds = video_dataset("test", transform, root_path)
video_loader = torch.utils.data.DataLoader(video_ds,
4,
False,
num_workers=0)
video_model = models.ResNet(in_ch=1,
in_stride=(1, 1),
fc_size=64,
block=models.BasicBlock,
num_blocks=[3, 3, 3])
video_model = nn.DataParallel(video_model).cuda()
video_model.load_state_dict(torch.load("new_video_resnet.pkl"))
video_model.eval()
for data in video_loader:
image, name = data['image'], data['name']
image = image.cuda()
image = torch.autograd.Variable(image)
output = video_model(image)
pred = torch.argmax(output, 1)
video_names.extend(name)
video_preds.extend(pred)
video_preds = [int(i) for i in video_preds]
video_names_unique = list(set(video_names))
video_preds_max = []
for name in video_names_unique:
indices = [i for i, x in enumerate(video_names) if x == name]
pred = [video_preds[i] for i in indices]
pred = max(pred, key=pred.count)
video_preds_max.append(pred)
video_results = dict(zip(video_names_unique, video_preds_max))
audio_num = len(audio_names)
for i in range(10):
class_name = classes[i]
matching_resnet_model = models.ResNet(block=models.BasicBlock,
num_blocks=[3, 3, 3])
matching_resnet_model = nn.DataParallel(matching_resnet_model).cuda()
matching_resnet_model.load_state_dict(
torch.load(class_name + "_resnet.pkl"))
matching_resnet_model.eval()
matching_mlp_model = models.MLP()
matching_mlp_model = nn.DataParallel(matching_mlp_model).cuda()
matching_mlp_model.load_state_dict(torch.load(class_name + "_mlp.pkl"))
matching_mlp_model.eval()
audio_i = [k for k, v in audio_results.items() if v == i]
video_i = [k for k, v in video_results.items() if v == i]
print(audio_i)
print(video_i)
matching_ds = matching_dataset(mode="test",
transforms=transform,
test_path=root_path,
test_audio=audio_i,
test_video=video_i)
matching_loader = torch.utils.data.DataLoader(matching_ds,
4,
False,
num_workers=0)
distance_matrix = np.zeros((len(audio_i), len(video_i)))
for data in matching_loader:
raw, name = data['raw'], data['name']
image = raw[0]
video = raw[1]
image = torch.autograd.Variable(image.cuda())
video = torch.autograd.Variable(video.cuda())
video_output = matching_mlp_model(video)
image_output = matching_resnet_model(image)
dist = F.pairwise_distance(video_output, image_output)
for j in range(len(dist)):
audio_num = audio_i.index(name[0][j])
video_num = video_i.index(name[1][j])
distance_matrix[audio_num][video_num] = dist[j]
print(distance_matrix)
row_ind, col_ind = linear_sum_assignment(distance_matrix)
print(row_ind)
print(col_ind)
for j in range(len(row_ind)):
audio_name = audio_i[row_ind[j]]
video_name = video_i[col_ind[j]]
results[audio_name] = video_name
audio_set = list(set(audio_names) - set([k for k, v in results.items()]))
video_set = list(set(video_names) - set([v for k, v in results.items()]))
perm = np.random.permutation(len(audio_set))
for j in perm:
audio_name = audio_set[j]
video_name = video_set[j]
results[audio_name] = video_name
for k, v in results.items():
results[k] = int(v[-4:])
print(results)
return results
def train(self):
"""
Training configuration.
"""
def get_augmentation(crop=True, flip=True):
augmenters = []
if crop:
augmenters.append(iaa.CropAndPad(
px=((0, 4), (0, 4), (0, 4), (0, 4)),
pad_mode='constant',
pad_cval=(0, 0),
))
if flip:
augmenters.append(iaa.Fliplr(0.5))
return iaa.Sequential(augmenters)
writer = common.summary.SummaryPickleWriter('%s/logs/' % self.args.directory, max_queue=100)
if self.args.tensorboard:
writer = torch.utils.tensorboard.SummaryWriter('%s/logs/' % self.args.directory, max_queue=100)
crop = False
flip = False
if self.args.dataset == 'svhn':
crop = True
elif self.args.dataset == 'cifar10':
crop = True
flip = True
epochs = 200
snapshot = 10
model_file = '%s/classifier.pth.tar' % self.args.directory
incomplete_model_file = find_incomplete_state_file(model_file)
load_file = model_file
if incomplete_model_file is not None:
load_file = incomplete_model_file
start_epoch = 0
if os.path.exists(load_file):
state = common.state.State.load(load_file)
self.model = state.model
start_epoch = state.epoch + 1
log('loaded %s' % load_file)
else:
self.model = models.ResNet(10, [self.trainset.images.shape[3], self.trainset.images.shape[1], self.trainset.images.shape[2]],
blocks=[3, 3, 3])
if self.args.cuda:
self.model = self.model.cuda()
augmentation = get_augmentation(crop=crop, flip=flip)
optimizer = torch.optim.SGD(self.model.parameters(), lr=0.075, momentum=0.9)
scheduler = common.train.get_exponential_scheduler(optimizer, batches_per_epoch=len(self.trainloader),
gamma=0.97)
trainer = common.train.NormalTraining(self.model, self.trainloader, self.testloader, optimizer, scheduler,
augmentation=augmentation, writer=writer, cuda=self.args.cuda)
self.model.train()
for epoch in range(start_epoch, epochs):
trainer.step(epoch)
writer.flush()
snapshot_model_file = '%s/classifier.pth.tar.%d' % (self.args.directory, epoch)
common.state.State.checkpoint(snapshot_model_file, self.model, optimizer, scheduler, epoch)
previous_model_file = '%s/classifier.pth.tar.%d' % (self.args.directory, epoch - 1)
if os.path.exists(previous_model_file) and (epoch - 1) % snapshot > 0:
os.unlink(previous_model_file)
previous_model_file = '%s/classifier.pth.tar.%d' % (self.args.directory, epoch - 1)
if os.path.exists(previous_model_file) and (epoch - 1) % snapshot > 0:
os.unlink(previous_model_file)
common.state.State.checkpoint(model_file, self.model, optimizer, scheduler, epoch)
def getModel(cls):
return models.ResNet(10, [1, 28, 28], blocks=[1, 1, 1])
video = torch.autograd.Variable(video.cuda())
label = torch.autograd.Variable(label.cuda())
video_output = video_model(video)
image_output = img_model(image)
dist = F.pairwise_distance(video_output, image_output)
print(dist)
pred = (dist < 10.0)
print(label)
correct += (pred == label).sum().float()
total += len(label)
acc = (100 * correct * 1.0 / total)
return acc
resnet = models.ResNet(block=models.BasicBlock, num_blocks=[3, 3, 3])
cnn3d = models.CNN3D()
cnn = models.CNN()
mlp = models.MLP()
criterion = nn.MSELoss().cuda()
optimizer = torch.optim.Adam(list(mlp.parameters()) +
list(resnet.parameters()),
lr=lr)
# optimizer = torch.optim.SGD(list(cnn3d.parameters()) + list(resnet.parameters()), lr=lr, momentum=0.9, weight_decay=1e-4)
task2_ds = matching_dataset(cat="whiteboard_spray", transforms=transform_train)
val_len = len(task2_ds) // 10
train_len = len(task2_ds) - val_len
train_ds, val_ds = torch.utils.data.random_split(task2_ds,
[train_len, val_len])
train_loader = torch.utils.data.DataLoader(train_ds, 10, False, num_workers=10)
data, holdout_split=0.2)
input_size = col - 1
# * shshshshshs
# print('\nNet: ')
# tt.train_test(models.Net(input_size), X_train_tor,
# X_test_tor, y_train_tor, y_test_tor)
# print('\nResNet: ')
# tt.train_test(models.ResNet(input_size), X_train_tor,
# X_test_tor, y_train_tor, y_test_tor)
# print('\nTDRNN: ')
# tt.train_test(models.TDRNN(input_size), X_train_tor,
# X_test_tor, y_train_tor, y_test_tor)
# print('\nODRNN: ')
# tt.train_test(models.ODRNN(input_size), X_train_tor,
# X_test_tor, y_train_tor, y_test_tor)
print('\nSORNN: ')
# tt.train_test(models.SORNN(input_size), X_train_tor,
# X_test_tor, y_train_tor, y_test_tor)
# tt.train_test(models.SORNN(input_size), cv_data, X_test_tor, y_test_tor)
# ep.error_plot(models.SORNN(input_size), cv_data,
# X_test_tor, y_test_tor, iterations=10)
#
network_list = [models.ResNet(input_size), models.TDRNN(input_size), models.ODRNN(input_size), models.SORNN(input_size)]
name_network = ['ResNet', 'TDRNN', 'ODRNN', 'SORNN']
print(len(network_list))
mc.models_comp(network_list, cv_data, X_test_tor, y_test_tor, name_network, iterations=2)
help='checkpoint saving frequency. N: after every N epochs.')
parser.add_argument("--frm_num", type=int, default=7)
args = parser.parse_args()
log_name = './log/full_model'
cpt_name = '/full_model_'
writer = SummaryWriter(log_name)
print("torch.cuda.is_available: ", torch.cuda.is_available())
print("torch.cuda.device_count: ", torch.cuda.device_count())
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
multiGPUs = [0, 1, 2, 3]
netT = models.ResNet()
sketExt = models.PWCExtractor()
imagExt = models.PWCExtractor()
flowEst = models.Network()
blenEst = models.blendNet()
flowRef = models.UNet(14, 8)
ImagRef = model_deform.DeformUNet(21, 15)
W = 576
H = 384
flowBackWarp = models.backWarp(W, H)
occlusiCheck = models.occlusionCheck(W, H)
if torch.cuda.device_count() >= 1:
netT = nn.DataParallel(netT, device_ids=multiGPUs)
sketExt = nn.DataParallel(sketExt, device_ids=multiGPUs)
elif args.target == 'ip':
if args.arch == 'LeNet_300_100':
cfg = [300, 100]
for i in range(len(cfg)):
cfg[i] = round(cfg[i] * (1 - args.pruning_ratio))
temp_cfg = cfg
pass
# generate the model
if args.arch == 'VGG':
model = models.VGG(num_classes, cfg=cfg)
elif args.arch == 'LeNet_300_100':
model = models.LeNet_300_100(bias_flag=True, cfg=cfg)
elif args.arch == 'ResNet':
model = models.ResNet(int(args.depth_wide), num_classes, cfg=cfg)
elif args.arch == 'WideResNet':
model = models.WideResNet(args.depth_wide[0],
num_classes,
widen_factor=args.depth_wide[1],
cfg=cfg)
else:
pass
if args.cuda:
model.cuda()
# pretrain
best_acc = 0.0
best_epoch = 0
if args.pretrained:
def main():
torch.manual_seed(0)
torch.random.manual_seed(0)
# create results folder, if not already exists
output_directory = misc.get_output_directory(args)
if not os.path.exists(output_directory):
os.makedirs(output_directory)
train_csv = os.path.join(output_directory, 'train.csv')
test_csv = os.path.join(output_directory, 'test.csv')
best_txt = os.path.join(output_directory, 'best.txt')
print("=> creating data loaders ...")
if args.data == 'MNIST':
datadir = './data/'
all_dataset = loader.MNIST(datadir)
train_size = len(all_dataset) // 5 * 4
test_size = len(all_dataset) // 10
val_size = len(all_dataset) - (train_size + test_size)
train_dataset, test_dataset, val_dataset = torch.utils.data.random_split(all_dataset, [train_size, test_size, val_size])
else:
raise RuntimeError('Dataset not found.' +
'The dataset must be either of nyudepthv2 or kitti.')
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=True,
num_workers=args.workers, pin_memory=True, sampler=None)
# set batch size to be 1 for validation
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=1, shuffle=False, num_workers=args.workers, pin_memory=True)
print("=> data loaders created.")
# optionally resume from a checkpoint
if args.start_epoch != 0:
assert os.path.isfile(args.resume), \
"=> no checkpoint found at '{}'".format(args.resume)
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch'] + 1
best_result = checkpoint['best_result']
model = checkpoint['model']
optimizer = checkpoint['optimizer']
print("=> loaded checkpoint (epoch {})".format(checkpoint['epoch']))
# create new model
else:
# define model
print("=> creating Model ({}) ...".format(args.arch))
if args.arch == 'resnet50':
model = models.ResNet(50)
else:
raise RuntimeError("model not found")
print("=> model created.")
# define loss function (criterion) and optimizer
if args.criterion == 'cce':
criterion = criteria.CrossEntropyLoss().cuda()
else:
raise RuntimeError("criterion not found")
if args.optimizer == 'Adam':
optimizer = torch.optim.Adam(model.parameters(), lr = args.lr, weight_decay = args.weight_decay)
elif args.optimizer == 'SGD':
optimizer = torch.optim.SGD(model.parameters(), args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
else:
raise RuntimeError("optimizer not defined")
optimizer_scheduler = lr_scheduler.StepLR(optimizer, args.epochs//3)
model = model.cuda()
print(model)
print("=> model transferred to GPU.")
train_logger, test_logger = None, None
for epoch in range(args.start_epoch, args.epochs):
train_result = train.train(train_loader, model, criterion, optimizer)
if epoch == 0:
train_logger = logger.Logger(train_result, output_directory, train_csv)
else:
train_logger.append(train_result)
optimizer_scheduler.step()
# evaluate on validation set
test_result = test.validate(test_loader, model, criterion, optimizer)
if epoch == 0:
test_logger = logger.Logger(test_result, output_directory, test_csv)
else:
test_logger.append(test_result)
misc.save_checkpoint({
'args': args,
'epoch': epoch,
'arch': args.arch,
'model': model,
'best_result': best_result,
'optimizer': optimizer,
}, is_best, epoch, output_directory)
train_logger.write_into_file('train')
test_logger.write_into_file('test')
image, label = data['image'], data['label']
image, label = image.cuda(), label.cuda()
image, label = torch.autograd.Variable(image), torch.autograd.Variable(
label)
output = model(image)
pred = torch.argmax(output, 1)
correct += (pred == label).sum().float()
total += len(label)
acc = (100 * correct * 1.0 / total)
print("accuracy : %.03f" % (acc))
return acc
resnet = models.ResNet(in_ch=1,
in_stride=(1, 1),
fc_size=64,
block=models.BasicBlock,
num_blocks=[3, 3, 3])
mlp = models.MLP()
criterion = nn.CrossEntropyLoss().cuda()
# optimizer = torch.optim.Adam(resnet.parameters(), lr = lr)
optimizer = torch.optim.SGD(resnet.parameters(),
lr=lr,
momentum=0.9,
weight_decay=1e-4)
ds = video_dataset("train", transform_train)
# print(ds.__len__())
train_ds, val_ds = torch.utils.data.random_split(ds, [50000, 6998])
train_loader = torch.utils.data.DataLoader(train_ds,
128,
False,
resnet = [50, 18]
pretrain = [True, False]
hi_name = ['', '', '', '']
highest_accur = [[0, 0], [0, 0], [0, 0], [0, 0]]
j = 0
for layer in resnet:
plot.show_result_start(title + str(layer) + ')', x1, x2, xd, y1, y2,
yd)
for p_i in pretrain:
print('~~~Resnet%d:' % layer, p_i, '~~~')
if (layer == 18):
TOTAL_EPOCH = EPOCH[0]
else:
TOTAL_EPOCH = EPOCH[1]
net = models.ResNet(layer, p_i).cuda() if (
p_i == True) else models.ResNet_no(layer).cuda()
optimizer = t.optim.SGD(net.parameters(),
lr=LR,
momentum=MOMENTUM,
weight_decay=WEIGHT_DECAY)
# train
train_accuracy = []
test_accuracy = []
for epoch_i in range(1, TOTAL_EPOCH + 1):
print('epoch', epoch_i)
print('START:',
time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()))
right = 0
def create_model(observations,
model_name,
step_size=0.1,
horizon=10,
dim_obs=784,
dim_latent=10,
inf_horizon=1,
infer_qdot=True,
**model_param):
if model_name == 'ResNet':
dynamics = models.ResNet(step_size,
horizon,
name=model_name,
**model_param)
elif model_name == 'VIN_VV':
dynamics = models.VIN_VV(step_size,
horizon,
name=model_name,
**model_param)
elif model_name == 'VIN_SV':
dynamics = models.VIN_SV(step_size,
horizon,
name=model_name,
**model_param)
elif model_name == 'VIN_SO2':
dynamics = models.VIN_SO2(step_size,
horizon,
name=model_name,
**model_param)
elif model_name == 'FeedForward':
dynamics = models.FeedForward(step_size,
1,
name=model_name,
**model_param)
elif model_name in ['VAE', 'LG_VAE']:
dynamics = None
else:
raise NotImplementedError()
if model_name in ['VIN_SV', 'VIN_SO2']:
infer_qdot = False
if observations == 'observed':
model = dynamics
elif observations == 'noisy':
dim_dec_in = dynamics.dim_state
dim_obs = dynamics.dim_state
model = models.NoisyLDDN(dim_obs,
dim_dec_in,
dynamics,
inf_horizon,
name="NoisyLDDN",
infer_qdot=infer_qdot,
**model_param)
elif observations == 'pixels':
if model_name in ['ResNet', 'FeedForward']:
dim_dec_in = dynamics.dim_state
elif 'VIN' in model_name:
dim_dec_in = dynamics.dim_Q
if model_name in ['VIN_SO2', 'LG_VAE']:
dec_inp_fn = lambda x: tf.concat([tf.sin(x), tf.cos(x)], 1)
else:
dec_inp_fn = None
if dynamics is not None:
model = models.PixelLDDN(dim_obs,
dim_dec_in,
dynamics,
inf_horizon,
name="PixelLDDN",
infer_qdot=infer_qdot,
dec_inp_fn=dec_inp_fn,
**model_param)
else:
raise NotImplementedError()
else:
raise NotImplementedError()
return compile_model(model, observations)
