from torchvision import transforms
from PIL import Image
IMG_SIZE = 1024
preprocess = transforms.Compose([
transforms.Scale(IMG_SIZE, interpolation=Image.ANTIALIAS),
transforms.CenterCrop(IMG_SIZE),
transforms.ToTensor()
])
from torchvision.datasets import ImageFolder
import csv
import os
import re
import numpy as np
import pandas as pd
from os import getcwd
from os.path import join
from PIL import Image
import torch.utils.data as data
from torchvision import transforms
transform = transforms.Compose([
transforms.Resize(224),
transforms.CenterCrop(224),
transforms.ToTensor()
])
class MuraDataset(data.Dataset):
_patient_re = re.compile(r'patient(\d+)')
_study_re = re.compile(r'study(\d+)')
_image_re = re.compile(r'image(\d+)')
_study_type_re = re.compile(r'XR_(\w+)')
def __init__(self, csv_f, transform=transform, download=False):
self.df = pd.read_csv(csv_f, names=['img', 'label'], header=None)
self.imgs = self.df.img.values.tolist()
self.labels = self.df.label.values.tolist()
# following datasets/folder.py's weird convention here...
self.samples = [tuple(x) for x in self.df.values]
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
EPOCH = 15 #数据集训练几遍
BATCH_SIZE = 50 #一批数据的个数
LR = 0.001
#加载数据集
path1 = "../dataSet/train"
#归一化，使颜色值从0-255变为0-1之间
train_data = torchvision.datasets.ImageFolder(
path1,
transform=transforms.Compose([
transforms.Resize((100, 100)),
transforms.CenterCrop(100),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
]))
#生成训练器
train_loader = Data.DataLoader(dataset=train_data,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2)
#加载测试集
path2 = "../dataSet/test"
test_data = torchvision.datasets.ImageFolder(
path2,
def main_worker(gpu, ngpus_per_node, args):
progress = ProgressMeter(args)
info = ''
for arg in vars(args):
info += arg+': '+str(getattr(args, arg))+'\n'
progress.write(info)
global best_acc1
args.gpu = gpu
# suppress printing if not master
if args.multiprocessing_distributed and args.gpu != 0:
def print_pass(*args):
pass
builtins.print = print_pass
if args.gpu is not None:
progress.write("Use GPU: {} for training".format(args.gpu))
if args.distributed:
if args.dist_url == "env://" and args.rank == -1:
args.rank = int(os.environ["RANK"])
if args.multiprocessing_distributed:
# For multiprocessing distributed training, rank needs to be the
# global rank among all the processes
args.rank = args.rank * ngpus_per_node + gpu
dist.init_process_group(backend=args.dist_backend, init_method=args.dist_url,
world_size=args.world_size, rank=args.rank)
# create model
progress.write("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
# freeze all layers but the last fc
#for name, param in model.named_parameters():
# if name not in ['fc.weight', 'fc.bias']:
# param.requires_grad = False
# init the fc layer
model.fc.weight.data.normal_(mean=0.0, std=0.01)
model.fc.bias.data.zero_()
if args.syncbn:
model = apex.parallel.convert_syncbn_model(model)
# load from pre-trained, before DistributedDataParallel constructor
if args.pretrained:
if os.path.isfile(args.pretrained):
progress.write("=> loading checkpoint '{}'".format(args.pretrained))
checkpoint = torch.load(args.pretrained, map_location="cpu")
# rename pre-trained keys
state_dict = checkpoint['state_dict']
for k in list(state_dict.keys()):
# retain only encoder_q up to before the embedding layer
if k.startswith('module.encoder_q') and not k.startswith('module.encoder_q.fc'):
# remove prefix
state_dict[k[len("module.encoder_q."):]] = state_dict[k]
elif k.startswith('module.encoder') and not k.startswith('module.encoder.fc'):
# remove prefix
state_dict[k[len("module.encoder."):]] = state_dict[k]
# delete renamed or unused k
del state_dict[k]
args.start_epoch = 0
msg = model.load_state_dict(state_dict, strict=False)
print(msg)
assert set(msg.missing_keys) == {"fc.weight", "fc.bias"}
progress.write("=> loaded pre-trained model '{}'".format(args.pretrained))
else:
progress.write("=> no checkpoint found at '{}'".format(args.pretrained))
assert False
if args.distributed:
# For multiprocessing distributed, DistributedDataParallel constructor
# should always set the single device scope, otherwise,
# DistributedDataParallel will use all available devices.
if args.gpu is not None:
torch.cuda.set_device(args.gpu)
model.cuda(args.gpu)
# When using a single GPU per process and per
# DistributedDataParallel, we need to divide the batch size
# ourselves based on the total number of GPUs we have
args.batch_size = int(args.batch_size / ngpus_per_node)
args.workers = int((args.workers + ngpus_per_node - 1) / ngpus_per_node)
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
else:
model.cuda()
# DistributedDataParallel will divide and allocate batch_size to all
# available GPUs if device_ids are not set
model = torch.nn.parallel.DistributedDataParallel(model)
elif args.gpu is not None:
torch.cuda.set_device(args.gpu)
model = model.cuda(args.gpu)
else:
# DataParallel will divide and allocate batch_size to all available GPUs
if args.arch.startswith('alexnet') or args.arch.startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
# optimize only the linear classifier
parameters = list(filter(lambda p: p.requires_grad, model.parameters()))
#assert len(parameters) == 2 # fc.weight, fc.bias
# for semi: set diff lr for fc and backbone
trunk_parameters = []
head_parameters = []
for name, param in model.named_parameters():
if 'fc' in name:
head_parameters.append(param)
else:
trunk_parameters.append(param)
optimizer = torch.optim.SGD(
[{'params': trunk_parameters},
{'params': head_parameters, 'lr': args.lr_last_layer}],
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay,
)
# optimizer = torch.optim.SGD(parameters, args.lr,
# momentum=args.momentum,
# weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
progress.write("=> loading checkpoint '{}'".format(args.resume))
if args.gpu is None:
checkpoint = torch.load(args.resume)
else:
# Map model to be loaded to specified single gpu.
loc = 'cuda:{}'.format(args.gpu)
checkpoint = torch.load(args.resume, map_location=loc)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
if args.gpu is not None:
# best_acc1 may be from a checkpoint from a different GPU
best_acc1 = best_acc1.to(args.gpu)
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
progress.write("=> loaded checkpoint '{}' (epoch {})"
.format(args.resume, checkpoint['epoch']))
else:
progess.write("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
#subset_file = urllib.request.urlopen("https://raw.githubusercontent.com/google-research/simclr/master/imagenet_subsets/" + str(args.labels_perc) + "percent.txt")
#list_imgs = [li.decode("utf-8").split('\n')[0] for li in subset_file]
subset_file = open('imagenet_subset/'+args.labels_perc+'percent.txt', 'r')
list_imgs = [li.split('\n')[0] for li in subset_file]
train_dataset.samples = [(
os.path.join(traindir, li.split('_')[0], li),
train_dataset.class_to_idx[li.split('_')[0]]
) for li in list_imgs]
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=(train_sampler is None),
num_workers=args.workers, pin_memory=True, sampler=train_sampler, drop_last=True)
val_loader = torch.utils.data.DataLoader(
datasets.ImageFolder(valdir, transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size, shuffle=False,
num_workers=args.workers, pin_memory=True)
if args.evaluate:
validate(val_loader, model, criterion, args)
return
st_time = time.time()
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
# evaluate on validation set
if (epoch+1) % 2 == 0:
acc1 = validate(val_loader, model, criterion, args)
# remember best acc@1 and save checkpoint
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
if not args.multiprocessing_distributed or (args.multiprocessing_distributed
and args.rank % ngpus_per_node == 0):
save_checkpoint(args, {
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer' : optimizer.state_dict(),
}, is_best)
#if epoch == args.start_epoch:
# sanity_check(args, model.state_dict(), args.pretrained)
progress.write('Best: '+str(best_acc1))
info = 'Time: ' + format_time(time.time()-st_time) + '\n'\
'Eta: ' + format_time((time.time()-st_time)/(epoch+1)*(args.epochs-epoch-1))
progress.write(info)
from torchvision import transforms, datasets
import torchvision
from torchvision.utils import save_image, make_grid
from PIL import Image
import os
from modules import VectorQuantizedVAE, to_scalar
from vqvae import generate_samples
DEVICE = "cuda:1"
data_folder = "/shared/kgcoe-research/mil/ImageNet/"
#data_folder = "./data/face/"
im_transform = transforms.Compose([ \
transforms.CenterCrop(128), \
transforms.ToTensor()])
#test_dataset = datasets.ImageFolder(root=data_folder, transform=im_transform)
test_dataset = datasets.ImageFolder(root=os.path.join(data_folder, "val"),
transform=im_transform)
test_loader = torch.utils.data.DataLoader(test_dataset,
batch_size=8,
shuffle=False)
def get_recons(loader, hidden_size=256):
model = VectorQuantizedVAE(3, hidden_size, 512).to(DEVICE)
def main(checkpoint=None):
global epoch
# Data augmentation and normalization for training
# Just normalization for validation
data_transforms = {
'train':
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val':
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
data_dir = 'data'
image_datasets = {
x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])
for x in ['train', 'val']
}
dataloaders = {
x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=4,
shuffle=True,
num_workers=0)
for x in ['train', 'val']
}
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
class_names = image_datasets['train'].classes
model_ft = models.resnet18(pretrained=True)
num_ftrs = model_ft.fc.in_features
# Here the size of each output sample is set to 2.
# Alternatively, it can be generalized to nn.Linear(num_ftrs, len(class_names)).
model_ft.fc = nn.Linear(num_ftrs, 2)
if checkpoint is None:
model_ft = model_ft.to(device)
criterion = nn.CrossEntropyLoss()
# Observe that all parameters are being optimized
optimizer_ft = optim.SGD(model_ft.parameters(), lr=0.001, momentum=0.9)
# Decay LR by a factor of 0.1 every 7 epochs
exp_lr_scheduler = lr_scheduler.StepLR(optimizer_ft,
step_size=7,
gamma=0.1)
else:
model_state_dict, criterion, optimizer_ft, exp_lr_scheduler, epoch = utils.load_model(
checkpoint)
model_ft.load_state_dict(model_state_dict)
model_ft = model_ft.to(device)
try:
model_ft = train_model(dataloaders,
dataset_sizes,
model_ft,
criterion,
optimizer_ft,
exp_lr_scheduler,
start_epoch=epoch,
end_epoch=10)
saveToBento = input("Save model to Bento ML (yes/no): ")
if saveToBento.lower() == "yes":
# Add it to BentoML
bento_svc = AntOrBeeClassifier()
bento_svc.pack('model', model_ft)
# Save your Bento Service
saved_path = bento_svc.save()
print('Bento Service saved in ', saved_path)
#Copy Bento Service to git dir
git_dir = "/home/project/AntOrBeeClassifier/my-a-or-b/"
cmd = 'cp -r ' + saved_path + '/. ' + git_dir
os.system(cmd)
except KeyboardInterrupt:
pass
finally:
utils.save_model(model_ft, criterion, optimizer_ft, exp_lr_scheduler,
epoch)
def build_imagenet(model_state_dict, optimizer_state_dict, **kwargs):
valid_ratio = kwargs.pop('valid_ratio', None)
valid_num = kwargs.pop('valid_num', None)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ColorJitter(brightness=0.4,
contrast=0.4,
saturation=0.4,
hue=0.1),
transforms.ToTensor(),
normalize,
])
valid_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])
if args.zip_file:
logging.info('Loading data from zip file')
traindir = os.path.join(args.data, 'train.zip')
if args.lazy_load:
data = utils.ZipDataset(traindir)
else:
logging.info('Loading data into memory')
data = utils.InMemoryZipDataset(traindir,
num_workers=args.num_workers)
else:
logging.info('Loading data from directory')
traindir = os.path.join(args.data, 'train')
if args.lazy_load:
data = dset.ImageFolder(traindir)
else:
logging.info('Loading data into memory')
data = utils.InMemoryDataset(traindir,
num_workers=args.num_workers)
num_data = len(data)
indices = list(range(num_data))
np.random.shuffle(indices)
if valid_ratio is not None:
split = int(np.floor(1 - valid_ratio * num_data))
train_indices = sorted(indices[:split])
valid_indices = sorted(indices[split:])
else:
assert valid_num is not None
train_indices = sorted(indices[valid_num:])
valid_indices = sorted(indices[:valid_num])
train_data = utils.WrappedDataset(data, train_indices, train_transform)
valid_data = utils.WrappedDataset(data, valid_indices, valid_transform)
logging.info('train set = %d', len(train_data))
logging.info('valid set = %d', len(valid_data))
train_queue = torch.utils.data.DataLoader(
train_data,
batch_size=args.batch_size,
sampler=torch.utils.data.sampler.SubsetRandomSampler(train_indices),
pin_memory=True,
num_workers=args.num_workers,
drop_last=False)
valid_queue = torch.utils.data.DataLoader(
valid_data,
batch_size=args.eval_batch_size,
sampler=torch.utils.data.sampler.SubsetRandomSampler(valid_indices),
pin_memory=True,
num_workers=args.num_workers,
drop_last=False)
model = NASNet(args.width_stages, args.n_cell_stages, args.stride_stages,
args.dropout)
model.init_model(args.model_init)
model.set_bn_param(0.1, 0.001)
logging.info("param size = %d", utils.count_parameters(model))
if model_state_dict is not None:
model.load_state_dict(model_state_dict)
if torch.cuda.device_count() > 1:
logging.info("Use %d %s", torch.cuda.device_count(), "GPUs !")
model = nn.DataParallel(model)
model = model.cuda()
if args.no_decay_keys:
keys = args.no_decay_keys.split('#')
net_params = [
model.module.get_parameters(keys, mode='exclude'),
model.module.get_parameters(keys, mode='include')
]
optimizer = torch.optim.SGD(
[
{
'params': net_params[0],
'weight_decay': args.weight_decay
},
{
'params': net_params[1],
'weight_decay': 0
},
],
args.lr,
momentum=0.9,
nesterov=True,
)
else:
optimizer = torch.optim.SGD(
model.parameters(),
args.lr,
momentum=0.9,
weight_decay=args.weight_decay,
nesterov=True,
)
if optimizer_state_dict is not None:
optimizer.load_state_dict(optimizer_state_dict)
scheduler = torch.optim.lr_scheduler.StepLR(optimizer,
args.decay_period,
gamma=args.gamma)
train_criterion = utils.CrossEntropyLabelSmooth(1000,
args.label_smooth).cuda()
eval_criterion = nn.CrossEntropyLoss().cuda()
return train_queue, valid_queue, model, train_criterion, eval_criterion, optimizer, scheduler
def main():
# ------------
# args
# ------------
torch.manual_seed(0)
pl.seed_everything(0)
parser = argparse.ArgumentParser()
parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')
parser.add_argument('--batch-size', type=int, dest='batch_size', default=50, help='mini batch size for training')
parser.add_argument('--epoch', type=int, dest='epoch', default=10, help='epoch size for training')
parser.add_argument('--learning-rate', type=float, dest='learning_rate', default=0.001, help='learning rate')
parser.add_argument('--momentum', type=float, dest='momentum', default=0.9, help='momentum')
parser.add_argument('--model-name', type=str, dest='model_name', default='resnet', help='Fine Turning model name')
parser.add_argument('--optimizer', type=str, dest='optimizer', default='SGD', help='Optimzers to use for training.')
parser.add_argument('--criterion', type=str, dest='criterion', default='cross_entropy', help='Loss Function to use for training.')
parser.add_argument('--feature_extract', type=bool, dest='feature_extract', default=True, help='Flag for feature extracting. When False, we finetune the whole model, when True we only update the reshaped layer params')
args = parser.parse_args()
args.num_workers=8
data_folder = args.data_folder
print('training dataset is stored here:', data_folder)
input_size = 224
if args.model_name == "inception":
input_size = 299
# ---------------------------
# Azure Machnie Learning
# 1) get Azure ML run context and log hyperparameters
# ---------------------------
run = Run.get_context()
run.log('model_name', args.model_name)
run.log('optimizer', args.optimizer)
run.log('criterion', args.criterion)
run.log('lr', np.float(args.learning_rate))
run.log('momentum', np.float(args.momentum))
# For your tagging
# run.tag('description', 'xxx')
# ------------
# data
# ------------
transform = transforms.Compose([
# Augmentation
# transforms.RandomHorizontalFlip(),
# transforms.RandomVerticalFlip(),
transforms.RandomAffine(degrees=[-10, 10], translate=(0.1, 0.1), scale=(0.5, 1.5)),
transforms.RandomRotation(degrees=10),
# Resize
transforms.Resize(int(input_size * 1.3)),
transforms.CenterCrop(input_size),
# Tensor
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])
]
)
dataset = torchvision.datasets.ImageFolder(args.data_folder, transform)
args.num_classes = len(dataset.classes)
n_train = int(len(dataset) * 0.7)
n_val = int(len(dataset) * 0.15)
n_test = len(dataset) - n_train - n_val
train_dataset, val_dataset, test_dataset = torch.utils.data.random_split(dataset, [n_train, n_val, n_test])
train_loader = torch.utils.data.DataLoader(train_dataset, args.batch_size, shuffle=True, drop_last=True, num_workers=args.num_workers)
val_loader = torch.utils.data.DataLoader(val_dataset, args.batch_size, num_workers=args.num_workers)
test_loader = torch.utils.data.DataLoader(test_dataset, args.batch_size)
# Initialize the model for this run
model_ft, input_size = initialize_model(args.model_name, args.num_classes, feature_extract=args.feature_extract , use_pretrained=True)
model = FineTurningModel(args, model_ft)
# GPU Configuration
num_gpu = torch.cuda.device_count()
print('num_gpu:', num_gpu)
accelerator = None
if num_gpu > 1:
accelerator='ddp' # only for Single Machine
# ------------
# training
# ------------
trainer = pl.Trainer(max_epochs=args.epoch, gpus=num_gpu, accelerator=accelerator)
trainer.fit(model, train_loader, val_loader)
# ------------
# Test (Not Validation)
# ------------
test_result = trainer.test(test_dataloaders=test_loader)
test_result
run.log('test_acc', [res["test_acc"] for res in test_result][0])
run.log('test_loss', [res["test_loss"] for res in test_result][0])
run.log('test_acc_epoch', [res["test_acc_epoch"] for res in test_result][0])
run.log('test_loss_epoch', [res["test_loss_epoch"] for res in test_result][0])
# ------------
# save model
# ------------
outputdir = './outputs/model'
os.makedirs(outputdir, exist_ok=True)
torch.save(model.state_dict(), os.path.join(outputdir, 'model.dict'))
torch.save(model, os.path.join(outputdir, 'model.pt'))
def train_imagenet():
print('==> Preparing data..')
img_dim = get_model_property('img_dim')
if FLAGS.fake_data:
train_dataset_len = 1200000 # Roughly the size of Imagenet dataset.
train_loader = xu.SampleGenerator(
data=(torch.zeros(FLAGS.batch_size, 3, img_dim, img_dim),
torch.zeros(FLAGS.batch_size, dtype=torch.int64)),
sample_count=train_dataset_len // FLAGS.batch_size //
xm.xrt_world_size())
test_loader = xu.SampleGenerator(
data=(torch.zeros(FLAGS.test_set_batch_size, 3, img_dim, img_dim),
torch.zeros(FLAGS.test_set_batch_size, dtype=torch.int64)),
sample_count=50000 // FLAGS.batch_size // xm.xrt_world_size())
else:
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = torchvision.datasets.ImageFolder(
os.path.join(FLAGS.datadir, 'train'),
transforms.Compose([
transforms.RandomResizedCrop(img_dim),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
train_dataset_len = len(train_dataset.imgs)
resize_dim = max(img_dim, 256)
test_dataset = torchvision.datasets.ImageFolder(
os.path.join(FLAGS.datadir, 'val'),
# Matches Torchvision's eval transforms except Torchvision uses size
# 256 resize for all models both here and in the train loader. Their
# version crashes during training on 299x299 images, e.g. inception.
transforms.Compose([
transforms.Resize(resize_dim),
transforms.CenterCrop(img_dim),
transforms.ToTensor(),
normalize,
]))
train_sampler = None
test_sampler = None
if xm.xrt_world_size() > 1:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=True)
test_sampler = torch.utils.data.distributed.DistributedSampler(
test_dataset,
num_replicas=xm.xrt_world_size(),
rank=xm.get_ordinal(),
shuffle=False)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=FLAGS.batch_size,
sampler=train_sampler,
drop_last=FLAGS.drop_last,
shuffle=False if train_sampler else True,
num_workers=FLAGS.num_workers)
test_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=FLAGS.test_set_batch_size,
sampler=test_sampler,
drop_last=FLAGS.drop_last,
shuffle=False,
num_workers=FLAGS.num_workers)
torch.manual_seed(42)
devices = (xm.get_xla_supported_devices(
max_devices=FLAGS.num_cores) if FLAGS.num_cores != 0 else [])
# Pass [] as device_ids to run using the PyTorch/CPU engine.
torchvision_model = get_model_property('model_fn')
model_parallel = dp.DataParallel(torchvision_model, device_ids=devices)
def train_loop_fn(model, loader, device, context):
loss_fn = nn.CrossEntropyLoss()
optimizer = context.getattr_or(
'optimizer', lambda: optim.SGD(model.parameters(),
lr=FLAGS.lr,
momentum=FLAGS.momentum,
weight_decay=1e-4))
lr_scheduler = context.getattr_or(
'lr_scheduler', lambda: schedulers.wrap_optimizer_with_scheduler(
optimizer,
scheduler_type=getattr(FLAGS, 'lr_scheduler_type', None),
scheduler_divisor=getattr(FLAGS, 'lr_scheduler_divisor', None),
scheduler_divide_every_n_epochs=getattr(
FLAGS, 'lr_scheduler_divide_every_n_epochs', None),
num_steps_per_epoch=num_training_steps_per_epoch,
summary_writer=writer if xm.is_master_ordinal() else None))
tracker = xm.RateTracker()
model.train()
for x, (data, target) in enumerate(loader):
optimizer.zero_grad()
output = model(data)
loss = loss_fn(output, target)
loss.backward()
xm.optimizer_step(optimizer)
tracker.add(FLAGS.batch_size)
if x % FLAGS.log_steps == 0:
test_utils.print_training_update(device, x, loss.item(),
tracker.rate(),
tracker.global_rate())
if lr_scheduler:
lr_scheduler.step()
def test_loop_fn(model, loader, device, context):
total_samples = 0
correct = 0
model.eval()
for data, target in loader:
output = model(data)
pred = output.max(1, keepdim=True)[1]
correct += pred.eq(target.view_as(pred)).sum().item()
total_samples += data.size()[0]
accuracy = 100.0 * correct / total_samples
test_utils.print_test_update(device, accuracy)
return accuracy
accuracy = 0.0
writer = test_utils.get_summary_writer(FLAGS.logdir)
num_devices = len(
xm.xla_replication_devices(devices)) if len(devices) > 1 else 1
num_training_steps_per_epoch = train_dataset_len // (FLAGS.batch_size *
num_devices)
for epoch in range(1, FLAGS.num_epochs + 1):
model_parallel(train_loop_fn, train_loader)
accuracies = model_parallel(test_loop_fn, test_loader)
accuracy = mean(accuracies)
print('Epoch: {}, Mean Accuracy: {:.2f}%'.format(epoch, accuracy))
global_step = (epoch - 1) * num_training_steps_per_epoch
test_utils.add_scalar_to_summary(writer, 'Accuracy/test', accuracy,
global_step)
if FLAGS.metrics_debug:
print(met.metrics_report())
test_utils.close_summary_writer(writer)
return accuracy
"WARNING: You have a CUDA device, so you should probably run with --cuda"
)
if opt.dataset in ['folder']:
# folder dataset
data_path = '/work/04381/ymarathe/maverick/yearbook/keras_yearbook_less/train'
for gender in os.listdir(data_path):
datapath = data_path + "/" + gender
for year in os.listdir(datapath):
buffer = Buffer(25600, 32, 64, 64, 1)
dataset = dset.ImageFolder(
root=datapath + "/" + year,
transform=transforms.Compose([
transforms.Scale(opt.imageSize),
transforms.CenterCrop(opt.imageSize),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
assert dataset
dataloader = torch.utils.data.DataLoader(dataset,
batch_size=opt.batchSize,
shuffle=True,
num_workers=int(
opt.workers))
ngpu = int(opt.ngpu)
nz = int(opt.nz)
ngf = int(opt.ngf)
ndf = int(opt.ndf)
# Parse arguments & log
args = parse_args()
logger.update_args(args)
# Create output directory
if not os.path.exists(args.output_dir):
os.mkdir(args.output_dir)
os.mkdir(args.output_dir + '/train/')
os.mkdir(args.output_dir + '/valid/')
else:
print('WARNING: Output directory already exists and will be overwriting (if not resuming)')
# Create transforms
default_transform = transforms.Compose([
transforms.CenterCrop(args.image_size),
transforms.Resize(args.image_size),
transforms.ToTensor()
])
# Create train dataset
train_dataset = dset.ImageFolder(root=args.train_dir, transform=default_transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=args.batch_size,
shuffle=False, num_workers=args.workers,
pin_memory=True, drop_last=True)
# Create validation dataset
valid_dataset = dset.ImageFolder(root=args.valid_dir, transform=default_transform)
valid_loader = torch.utils.data.DataLoader(valid_dataset, batch_size=args.batch_size,
net = ptcv_get_model(model_name, pretrained=True)
error, checksum, repo_release_tag, caption, paper, ds, img_size, scale, batch, rem = model_metainfo
if (ds != "in1k") or (img_size == 0):
continue
paper_model_name = caption
paper_arxiv_id = paper
input_image_size = img_size
resize_inv_factor = scale
batch_size = batch
model_description = "pytorch" + (rem if rem == "" else ", " + rem)
assert (not hasattr(net, "in_size")) or (input_image_size
== net.in_size[0])
ImageNet.benchmark(
model=net,
model_description=model_description,
paper_model_name=paper_model_name,
paper_arxiv_id=paper_arxiv_id,
input_transform=transforms.Compose([
transforms.Resize(
int(math.ceil(float(input_image_size) / resize_inv_factor))),
transforms.CenterCrop(input_image_size),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225]),
]),
batch_size=batch_size,
num_gpu=1,
# data_root=os.path.join("..", "imgclsmob_data", "imagenet")
)
torch.cuda.empty_cache()
data_dir = 'flowers'
train_dir = data_dir + '/train'
valid_dir = data_dir + '/valid'
test_dir = data_dir + '/test'
# In[3]:
# TODO: Define your transforms for the training, validation, and testing sets
data_transforms = transforms.Compose([transforms.RandomRotation(40), transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(), transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
data_transforms_valid = transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
data_transforms_test = transforms.Compose([transforms.Resize(256), transforms.CenterCrop(224), transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])])
# TODO: Load the datasets with ImageFolder
image_datasets = datasets.ImageFolder(train_dir, data_transforms)
image_datasets_valid = datasets.ImageFolder(valid_dir, data_transforms_valid)
image_datasets_test = datasets.ImageFolder(test_dir, data_transforms_test)
# TODO: Using the image datasets and the trainforms, define the dataloaders
dataloaders = torch.utils.data.DataLoader(image_datasets,batch_size = 64)
dataloaders_valid = torch.utils.data.DataLoader(image_datasets_valid,batch_size = 64)
dataloaders_test = torch.utils.data.DataLoader(image_datasets_test, batch_size = 64)
def main():
args = parse_args()
print(colored("Setting default tensor type to cuda.FloatTensor", "cyan"))
torch.multiprocessing.set_start_method('spawn')
torch.set_default_tensor_type('torch.cuda.FloatTensor')
logger, final_output_dir, tb_log_dir = create_logger(
config, args.cfg, 'train')
logger.info(pprint.pformat(args))
logger.info(pprint.pformat(config))
# cudnn related setting
cudnn.benchmark = config.CUDNN.BENCHMARK
cudnn.deterministic = config.CUDNN.DETERMINISTIC
cudnn.enabled = config.CUDNN.ENABLED
gpus = list(config.GPUS)
distributed = len(gpus) > 1
#device = torch.device('cuda:{}'.format(args.local_rank))
model = eval('models.' + config.MODEL.NAME +
'.get_contrastive_net')(config).cuda()
dump_input = torch.rand(config.TRAIN.BATCH_SIZE_PER_GPU, 3,
config.MODEL.IMAGE_SIZE[1],
config.MODEL.IMAGE_SIZE[0]).cuda()
logger.info(get_model_summary(model, dump_input))
if config.TRAIN.MODEL_FILE:
model.load_state_dict(torch.load(config.TRAIN.MODEL_FILE))
logger.info(
colored('=> loading model from {}'.format(config.TRAIN.MODEL_FILE),
'red'))
#if args.local_rank == 0:
# copy model file
this_dir = os.path.dirname(__file__)
models_dst_dir = os.path.join(final_output_dir, 'models')
if os.path.exists(models_dst_dir):
shutil.rmtree(models_dst_dir)
shutil.copytree(os.path.join(this_dir, '../lib/models'), models_dst_dir)
"""
if distributed:
torch.cuda.set_device(args.local_rank)
torch.distributed.init_process_group(
backend="nccl", init_method="env://",
)
"""
torch.cuda.empty_cache()
writer_dict = {
'writer': SummaryWriter(log_dir=tb_log_dir),
'train_global_steps': 0,
'valid_global_steps': 0,
}
gpus = list(config.GPUS)
model = nn.DataParallel(model, device_ids=gpus).cuda()
print("Finished constructing encoder!")
# define loss function (criterion) and optimizer
info_nce = InfoNCE(config.CONTRASTIVE.TAU, config.CONTRASTIVE.NORMALIZE,
config.CONTRASTIVE.NUM_SAMPLES)
criterion = torch.nn.CrossEntropyLoss()
optimizer = get_optimizer(config, model)
lr_scheduler = None
best_perf = 0.0
best_model = False
last_epoch = config.TRAIN.BEGIN_EPOCH
if config.TRAIN.RESUME:
model_state_file = os.path.join(final_output_dir, 'checkpoint.pth.tar')
if os.path.isfile(model_state_file):
checkpoint = torch.load(model_state_file)
last_epoch = checkpoint['epoch']
best_perf = checkpoint['perf']
model.module.load_state_dict(checkpoint['state_dict'])
# Update weight decay if needed
checkpoint['optimizer']['param_groups'][0][
'weight_decay'] = config.TRAIN.WD
optimizer.load_state_dict(checkpoint['optimizer'])
if 'lr_scheduler' in checkpoint:
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer,
1e5,
last_epoch=checkpoint['lr_scheduler']['last_epoch'])
lr_scheduler.load_state_dict(checkpoint['lr_scheduler'])
logger.info("=> loaded checkpoint (epoch {})".format(
checkpoint['epoch']))
best_model = True
# Data loading code
dataset_name = config.DATASET.DATASET
if dataset_name == 'imagenet':
# implement imagenet later, this is not supported right now
traindir = os.path.join(config.DATASET.ROOT + '/',
config.DATASET.TRAIN_SET)
valdir = os.path.join(config.DATASET.ROOT + '/',
config.DATASET.TEST_SET)
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
transform_train = MultiSample(aug_transform(
config.MODEL.IMAGE_SIZE[0],
base_transform((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
config.DATASET.AUGMENTATIONS),
n=config.CONTRASTIVE.NUM_SAMPLES)
transform_valid = transforms.Compose([
transforms.Resize(int(config.MODEL.IMAGE_SIZE[0] / 0.875)),
transforms.CenterCrop(config.MODEL.IMAGE_SIZE[0]),
base_transform((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
])
train_dataset = datasets.ImageFolder(traindir, transform_train)
valid_dataset = datasets.ImageFolder(valdir, transform_valid)
else:
# only cifar10 runs right now
#assert dataset_name == "cifar10", "Only CIFAR-10 is supported at this phase"
#classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # For reference
# train transform should build contrastive batch
transform_train = MultiSample(aug_transform(
32, base_transform(), config['DATASET']['AUGMENTATIONS']),
n=config['CONTRASTIVE']['NUM_SAMPLES'])
transform_valid = base_transform()
if dataset_name == 'cifar10':
train_dataset = datasets.CIFAR10(root=f'{config.DATASET.ROOT}',
train=True,
download=True,
transform=transform_train)
valid_dataset = datasets.CIFAR10(root=f'{config.DATASET.ROOT}',
train=False,
download=True,
transform=transform_valid)
elif dataset_name == 'cifar100':
train_dataset = datasets.CIFAR100(root=f'{config.DATASET.ROOT}',
train=True,
download=True,
transform=transform_train)
valid_dataset = datasets.CIFAR100(root=f'{config.DATASET.ROOT}',
train=False,
download=True,
transform=transform_valid)
train_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=config.TRAIN.BATCH_SIZE_PER_GPU * len(gpus),
shuffle=True,
num_workers=config.WORKERS,
pin_memory=True)
valid_loader = torch.utils.data.DataLoader(
valid_dataset,
batch_size=config.TEST.BATCH_SIZE_PER_GPU * len(gpus),
shuffle=False,
num_workers=config.WORKERS,
pin_memory=True)
# Learning rate scheduler
if lr_scheduler is None:
if config.TRAIN.LR_SCHEDULER != 'step':
lr_scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer,
len(train_loader) * config.TRAIN.END_EPOCH,
eta_min=1e-6)
elif isinstance(config.TRAIN.LR_STEP, list):
lr_scheduler = torch.optim.lr_scheduler.MultiStepLR(
optimizer, config.TRAIN.LR_STEP, config.TRAIN.LR_FACTOR,
last_epoch - 1)
else:
lr_scheduler = torch.optim.lr_scheduler.StepLR(
optimizer, config.TRAIN.LR_STEP, config.TRAIN.LR_FACTOR,
last_epoch - 1)
# Training code
for epoch in range(last_epoch, config.TRAIN.END_EPOCH):
topk = (1, 5) if dataset_name == 'imagenet' else (1, )
if config.TRAIN.LR_SCHEDULER == 'step':
lr_scheduler.step()
# train for one epoch
train(config, train_loader, model, info_nce, criterion, optimizer,
lr_scheduler, epoch, final_output_dir, tb_log_dir)
torch.cuda.empty_cache()
# evaluate on validation set
#perf_indicator = validate(config, valid_loader, model, criterion, lr_scheduler, epoch,
#final_output_dir, tb_log_dir)
torch.cuda.empty_cache()
writer_dict['writer'].flush()
"""
if perf_indicator > best_perf:
best_perf = perf_indicator
best_model = True
else:
best_model = False
"""
best_model = True
logger.info('=> saving checkpoint to {}'.format(final_output_dir))
save_checkpoint(
{
'epoch': epoch + 1,
'model': config.MODEL.NAME,
'state_dict': model.module.state_dict(),
#'perf': perf_indicator,
'optimizer': optimizer.state_dict(),
'lr_scheduler': lr_scheduler.state_dict(),
},
best_model,
final_output_dir,
filename='checkpoint.pth.tar')
final_model_state_file = os.path.join(final_output_dir,
'final_state.pth.tar')
logger.info(
'saving final model state to {}'.format(final_model_state_file))
torch.save(model.module.state_dict(), final_model_state_file)
writer_dict['writer'].close()
normalize = transforms.Normalize(mean=[0.5] * 3, std=[0.25] * 3)
if args.in_dataset in ['mnist', 'svhn'] and not args.no_flip:
print('Horizontal flip disabled for', args.in_dataset)
args.no_flip = True
flip_prob = 0 if args.no_flip else 0.5
pad = args.crop // 8
train_transform = transforms.Compose([
transforms.Resize(args.scale),
transforms.RandomCrop(args.crop, padding=pad),
transforms.RandomHorizontalFlip(flip_prob),
transforms.ToTensor(), normalize
])
val_transform = transforms.Compose([
transforms.Resize(args.scale),
transforms.CenterCrop(args.crop),
transforms.ToTensor(), normalize
])
train_in_dataset, n_class = datasets.__dict__[args.in_dataset](
train=True, transform=train_transform)
train_out_dataset, _ = datasets.__dict__[args.out_dataset](
train=True, transform=train_transform)
val_in_dataset, _ = datasets.__dict__[args.in_dataset](train=False,
transform=val_transform)
val_out_dataset, _ = datasets.__dict__[args.out_dataset](
train=False, transform=val_transform)
if args.resample:
if args.resample == 'random':
w = torch.rand(len(train_out_dataset))
def __init__(self,
data_path,
preprocessor,
split,
splits={
"train": ["train", "val"],
"validation": ["val"],
"test": ["test"],
},
augment=False,
use_segment=False,
audio_feature="mfcc",
image_feature="image",
phone_label="multilingual",
ds_method="average",
sample_rate=16000,
min_class_size=50,
debug=False):
self.preprocessor = preprocessor
self.splits = splits[split]
self.data_path = data_path
self.use_segment = use_segment
self.ds_method = ds_method
self.sample_rate = sample_rate
self.max_feat_len = 100
self.max_word_len = 100
self.max_phone_num = 50
self.max_segment_num = 5 # XXX
self.max_segment_len = 10
self.debug = debug
data = []
for sp in self.splits:
# Load data paths to audio and visual features
examples = load_data_split(data_path,
sp,
min_class_size=min_class_size,
audio_feature=audio_feature,
image_feature=image_feature,
phone_label=phone_label,
debug=debug)
data.extend(examples)
print("Number of {} audio files = {}".format(split, len(examples)))
# Set up transforms
self.audio_transforms = [
torchaudio.transforms.MelSpectrogram(
sample_rate=sample_rate,
win_length=sample_rate * 25 // 1000,
n_mels=preprocessor.num_features,
hop_length=sample_rate * 10 // 1000,
),
torchvision.transforms.Lambda(log_normalize),
]
if augment:
augmentation = [
torchaudio.transforms.FrequencyMasking(27, iid_masks=True),
torchaudio.transforms.FrequencyMasking(27, iid_masks=True),
torchaudio.transforms.TimeMasking(100, iid_masks=True),
torchaudio.transforms.TimeMasking(100, iid_masks=True),
]
self.audio_transforms.extend(augmentation)
self.audio_transforms = torchvision.transforms.Compose(
self.audio_transforms)
self.image_transforms = transforms.Compose([
transforms.Scale(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
])
# Load each image-caption pairs
audio = [example["audio"] for example in data]
image = [example["image"] for example in data]
boxes = [example["box"] for example in data]
text = [example["text"] for example in data]
phonemes = [example["phonemes"] for example in data]
feat_idxs = [example["box_idx"] for example in data]
self.dataset = list(zip(audio, image, text, phonemes, boxes,
feat_idxs))
self.image_feature_type = image_feature
self.image_feats = np.load(
os.path.join(data_path, f"../flickr8k_{image_feature}.npz")
) # XXX np.load(os.path.join(data_path, "flickr8k_res34.npz"))
self.image_to_feat = {
'_'.join(feat_id.split('_')[:-1]): feat_id
for feat_id in self.image_feats
}
self.audio_feature_type = audio_feature
def main():
global args, best_acc
args = parser.parse_args()
args.cuda = args.cuda and torch.cuda.is_available()
torch.manual_seed(args.seed)
if args.cuda:
torch.cuda.manual_seed(args.seed)
torch.cuda.set_device(0)
global plotter
plotter = VisdomLinePlotter(env_name=args.name)
kwargs = {'num_workers': 20, 'pin_memory': True} if args.cuda else {}
print('==>Preparing data...')
base_path = "./data/handpose_data/"
train_loader = torch.utils.data.DataLoader(
SimpleImageLoader(
base_path,
train=True,
transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ColorJitter(0.05, 0.05, 0.05, 0.05),
transforms.ToTensor(),
Lighting(0.1, _imagenet_pca['eigval'],
_imagenet_pca['eigvec']),
# transforms.Normalize(mean=[0.485, 0.456, 0.406],std=[0.229, 0.224, 0.225])
])),
batch_size=args.batch_size,
shuffle=True,
drop_last=False,
**kwargs)
test_loader = torch.utils.data.DataLoader(
SimpleImageLoader(
base_path,
False,
transform=transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
# transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])),
batch_size=args.batch_size,
drop_last=False,
**kwargs)
jnet = SimpleRegression()
if args.cuda:
jnet.cuda()
if torch.cuda.device_count() > 1 and args.parallel:
jnet = nn.DataParallel(jnet, device_ids=[0, 1]) # dataParallel
# This flag allows you to enable the inbuilt cudnn auto-tuner to
# find the best algorithm to use for your hardware.
cudnn.benchmark = True
criterion = torch.nn.MSELoss()
optimizer = optim.SGD(jnet.parameters(),
lr=args.lr,
momentum=args.momentum)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("==> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_prec1 = checkpoint['best_prec1']
jnet.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("==> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("==> no checkpoint found at '{}'".format(args.resume))
for epoch in range(1, args.epochs + 1):
# train for one epoch
adjust_learning_rate(jnet, optimizer, epoch)
train(train_loader, jnet, criterion, optimizer, epoch)
# evaluate on validation set
acc = test(test_loader, jnet, criterion, epoch)
# remember best acc and save checkpoint
is_best = acc > best_acc
best_acc = max(acc, best_acc)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': jnet.state_dict(),
'best_prec1': best_acc,
'optimizer': optimizer.state_dict(),
}, is_best)
import torchvision.transforms as transforms
from torchvision.datasets import ImageFolder
from torch.utils.data import DataLoader
import torch
import torch.nn as nn
from torch.autograd import Variable
from sklearn.metrics import confusion_matrix
import matplotlib.pyplot as plt
import numpy as np
import time
import torchvision
# https://towardsdatascience.com/a-beginners-tutorial-on-building-an-ai-image-classifier-using-pytorch-6f85cb69cba7
transformations = transforms.Compose([
transforms.Resize(800),
transforms.CenterCrop(800),
transforms.ToTensor(),
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
import os
base_path = os.getcwd()
print("The current working directory is %s" % base_path)
train_data = ImageFolder(os.path.join(base_path, 'train_data'),
transform=transformations)
test_data = ImageFolder(os.path.join(base_path, 'test_data'),
transform=transformations)
batch_size = 4
train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
# ======================= Data Setings =====================================
dataset_root_train = '/research/prip-gongsixu/datasets/RFW'
dataset_root_test = None
# input data size
image_height = 112
image_width = 112
image_size = (image_height, image_width)
# normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
# std=[0.229, 0.224, 0.225])
normalize = transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
# preprocessing
preprocess_train = transforms.Compose([ \
transforms.CenterCrop(image_size), \
transforms.Resize(image_size), \
# transforms.RandomResizedCrop(image_size, scale=(0.2, 1.)), \
# transforms.RandomApply([
# transforms.ColorJitter(0.4, 0.4, 0.4, 0.1) # not strengthened
# ], p=0.8),
# transforms.RandomGrayscale(p=0.2), \
# transforms.RandomApply([datasets.loaders.GaussianBlur([.1, 2.])], p=0.5), \
transforms.RandomHorizontalFlip(), \
# transforms.RandomVerticalFlip(), \
# transforms.RandomRotation(10), \
transforms.ToTensor(), \
normalize \
])
preprocess_test = transforms.Compose([ \
def train(data_dir='flower_data', model=None):
train_transforms = transforms.Compose([
transforms.RandomRotation(30),
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
test_transforms = train_transforms = transforms.Compose([
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
])
train_data = datasets.ImageFolder(data_dir + '/train',
transform=train_transforms)
test_data = datasets.ImageFolder(data_dir + '/test',
transform=test_transforms)
valid_data = datasets.ImageFolder(data_dir + '/valid',
transform=test_transforms)
trainloader = torch.utils.data.DataLoader(train_data,
batch_size=64,
shuffle=True)
testloader = torch.utils.data.DataLoader(test_data, batch_size=64)
validloader = torch.utils.data.DataLoader(valid_data, batch_size=64)
if not model:
print("1: vgg16, 2: vgg19")
inp = input("Which Model do you want?")
if inp == '1':
print("VGG16 selected")
model = models.vgg16(pretrained=True)
for param in model.parameters():
param.requires_grad = False
classifier = nn.Sequential(
OrderedDict([('fc1', nn.Linear(25088, 4096)),
('relu', nn.ReLU()), ('drop1', nn.Dropout(p=0.3)),
('fc2', nn.Linear(4096, 1000)),
('relu2', nn.ReLU()),
('drop2', nn.Dropout(p=0.3)),
('fc3', nn.Linear(1000,
512)), ('relu3', nn.ReLU()),
('drop3', nn.Dropout(p=0.3)),
('fc4', nn.Linear(512, 102)),
('output', nn.LogSoftmax(dim=1))]))
model.classifier = classifier
elif inp == '2':
print("vgg19 selected")
model = models.vgg19(pretrained=True)
for param in model.parameters():
param.requires_grad = False
classifier = nn.Sequential(
OrderedDict([('fc1', nn.Linear(25088, 4096)),
('relu', nn.ReLU()), ('drop1', nn.Dropout(p=0.3)),
('fc2', nn.Linear(4096, 1000)),
('relu2', nn.ReLU()),
('drop2', nn.Dropout(p=0.3)),
('fc3', nn.Linear(1000,
512)), ('relu3', nn.ReLU()),
('drop3', nn.Dropout(p=0.3)),
('fc4', nn.Linear(512, 102)),
('output', nn.LogSoftmax(dim=1))]))
model.classifier = classifier
else:
exit()
criterion = nn.NLLLoss()
epochs = int(input("How many Epochs?"))
lr = float(input("How much learning rate?"))
optimizer = optim.Adam(model.classifier.parameters(), lr)
device = input("'cpu' or 'cuda'?")
model = model.to(device)
device = torch.device(device)
steps = 0
print_every = 20
for epoch in range(epochs):
running_loss = 0
for inputs, labels in trainloader:
steps += 1
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad()
log_ps = model.forward(inputs)
loss = criterion(log_ps, labels)
loss.backward()
optimizer.step()
running_loss += loss.item()
if steps % print_every == 0:
test_loss = 0
accuracy = 0
model.eval()
with torch.no_grad():
for inputs, labels in validloader:
inputs, labels = inputs.to(device), labels.to(device)
log_ps = model.forward(inputs)
batch_loss = criterion(log_ps, labels)
test_loss += batch_loss.item()
ps = torch.exp(log_ps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += torch.mean(equals.type(
torch.FloatTensor)).item()
print(f"Epoch {epoch+1}/{epochs}.. "
f"Train loss: {running_loss/print_every:.3f}.. "
f"Test loss: {test_loss/len(validloader):.3f}.. "
f"Test accuracy: {accuracy/len(validloader):.3f}")
running_loss = 0
model.train()
print("------------------------")
accuracy = 0
total = 0
model.eval()
with torch.no_grad():
for inputs, labels in testloader:
inputs, labels = inputs.to(device), labels.to(device)
log_ps = model.forward(inputs)
ps = torch.exp(log_ps)
top_p, top_class = ps.topk(1, dim=1)
equals = top_class == labels.view(*top_class.shape)
accuracy += sum(equals).item()
total += len(labels)
print("Accuracy is : ", accuracy / total)
model.class_to_idx = train_data.class_to_idx
checkpoint = {
'model': model,
'state_dict': model.state_dict(),
'class_to_idx': model.class_to_idx
}
torch.save(checkpoint, 'checkpoint' + str(inp) + '.pth')
from model.efnet import efficientnet
from PIL import ImageFile, Image
from torchvision import transforms
import torch
import glob
import numpy as np
trans = transforms.Compose([
transforms.Resize(280),
transforms.CenterCrop(260),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
label_id_name_dict = \
{
"0": "其他垃圾/一次性快餐盒",
"1": "其他垃圾/污损塑料",
"2": "其他垃圾/烟蒂",
"3": "其他垃圾/牙签",
"4": "其他垃圾/破碎花盆及碟碗",
"5": "其他垃圾/竹筷",
"6": "厨余垃圾/剩饭剩菜",
"7": "厨余垃圾/大骨头",
"8": "厨余垃圾/水果果皮",
"9": "厨余垃圾/水果果肉",
"10": "厨余垃圾/茶叶渣",
"11": "厨余垃圾/菜叶菜根",
"12": "厨余垃圾/蛋壳",
"13": "厨余垃圾/鱼骨",
"14": "可回收物/充电宝",
"15": "可回收物/包",
"16": "可回收物/化妆品瓶",
def main():
global args, best_acc1
args = parser.parse_args()
if args.seed is not None:
random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.deterministic = True
warnings.warn('You have chosen to seed training. '
'This will turn on the CUDNN deterministic setting, '
'which can slow down your training considerably! '
'You may see unexpected behavior when restarting '
'from checkpoints.')
if args.gpu is not None:
warnings.warn('You have chosen a specific GPU. This will completely '
'disable data parallelism.')
args.distributed = args.world_size > 1
if args.distributed:
dist.init_process_group(backend=args.dist_backend,
init_method=args.dist_url,
world_size=args.world_size)
# create model
if args.pretrained:
print("=> using pre-trained model '{}'".format(args.arch))
model = models.__dict__[args.arch](pretrained=True)
else:
print("=> creating model '{}'".format(args.arch))
model = models.__dict__[args.arch]()
print(model)
if args.gpu is not None:
model = model.cuda(args.gpu)
elif args.distributed:
model.cuda()
model = torch.nn.parallel.DistributedDataParallel(model)
else:
if args.arch.startswith('alexnet') or args.arch.startswith('vgg'):
model.features = torch.nn.DataParallel(model.features)
model.cuda()
else:
model = torch.nn.DataParallel(model).cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda(args.gpu)
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
checkpoint = torch.load(args.resume)
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'train')
valdir = os.path.join(args.data, 'val')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
if args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(
train_dataset)
else:
train_sampler = None
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=(train_sampler is None),
num_workers=args.workers,
pin_memory=True,
sampler=train_sampler)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
if args.evaluate:
validate(val_loader, model, criterion)
return
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
train_sampler.set_epoch(epoch)
adjust_learning_rate(optimizer, epoch)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch)
# evaluate on validation set
acc1 = validate(val_loader, model, criterion)
# remember best acc@1 and save checkpoint
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
save_checkpoint(
{
'epoch': epoch + 1,
'arch': args.arch,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
}, is_best)
def main():
global args, best_acc
args = parser.parse_args()
init_distributed_mode(args)
fix_random_seeds(args.seed)
logger, training_stats = initialize_exp(
args,
"epoch",
"loss",
"prec1",
"prec5",
"loss_val",
"prec1_val",
"prec5_val",
)
# build data
train_data_path = os.path.join(args.data_path, "train")
train_dataset = datasets.ImageFolder(train_data_path)
# take either 1% or 10% of images
subset_file = urllib.request.urlopen(
"https://raw.githubusercontent.com/google-research/simclr/master/imagenet_subsets/"
+ str(args.labels_perc) + "percent.txt")
list_imgs = [li.decode("utf-8").split("\n")[0] for li in subset_file]
train_dataset.samples = [(
os.path.join(train_data_path,
li.split("_")[0], li),
train_dataset.class_to_idx[li.split("_")[0]],
) for li in list_imgs]
val_dataset = datasets.ImageFolder(os.path.join(args.data_path, "val"))
tr_normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.228, 0.224, 0.225])
train_dataset.transform = transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
tr_normalize,
])
val_dataset.transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
tr_normalize,
])
sampler = torch.utils.data.distributed.DistributedSampler(train_dataset)
train_loader = torch.utils.data.DataLoader(
train_dataset,
sampler=sampler,
batch_size=args.batch_size,
num_workers=args.workers,
pin_memory=True,
)
val_loader = torch.utils.data.DataLoader(
val_dataset,
batch_size=args.batch_size,
num_workers=args.workers,
pin_memory=True,
)
logger.info("Building data done with {} images loaded.".format(
len(train_dataset)))
# build model
model = resnet_models.__dict__[args.arch](output_dim=1000)
# convert batch norm layers
model = nn.SyncBatchNorm.convert_sync_batchnorm(model)
# load weights
if os.path.isfile(args.pretrained):
state_dict = torch.load(args.pretrained,
map_location="cuda:" +
str(args.gpu_to_work_on))
if "state_dict" in state_dict:
state_dict = state_dict["state_dict"]
# remove prefixe "module."
state_dict = {
k.replace("module.", ""): v
for k, v in state_dict.items()
}
for k, v in model.state_dict().items():
if k not in list(state_dict):
logger.info(
'key "{}" could not be found in provided state dict'.
format(k))
elif state_dict[k].shape != v.shape:
logger.info(
'key "{}" is of different shape in model and provided state dict'
.format(k))
state_dict[k] = v
msg = model.load_state_dict(state_dict, strict=False)
logger.info("Load pretrained model with msg: {}".format(msg))
else:
logger.info(
"No pretrained weights found => training from random weights")
# model to gpu
model = model.cuda()
model = nn.parallel.DistributedDataParallel(
model, device_ids=[args.gpu_to_work_on], find_unused_parameters=True)
# set optimizer
trunk_parameters = []
head_parameters = []
for name, param in model.named_parameters():
if "head" in name:
head_parameters.append(param)
else:
trunk_parameters.append(param)
optimizer = torch.optim.SGD(
[
{
"params": trunk_parameters
},
{
"params": head_parameters,
"lr": args.lr_last_layer
},
],
lr=args.lr,
momentum=0.9,
weight_decay=0,
)
# set scheduler
scheduler = torch.optim.lr_scheduler.MultiStepLR(optimizer,
args.decay_epochs,
gamma=args.gamma)
# Optionally resume from a checkpoint
to_restore = {"epoch": 0, "best_acc": (0.0, 0.0)}
restart_from_checkpoint(
os.path.join(args.dump_path, "checkpoint.pth.tar"),
run_variables=to_restore,
state_dict=model,
optimizer=optimizer,
scheduler=scheduler,
)
start_epoch = to_restore["epoch"]
best_acc = to_restore["best_acc"]
cudnn.benchmark = True
for epoch in range(start_epoch, args.epochs):
# train the network for one epoch
logger.info("============ Starting epoch %i ... ============" % epoch)
# set samplers
train_loader.sampler.set_epoch(epoch)
scores = train(model, optimizer, train_loader, epoch)
scores_val = validate_network(val_loader, model)
training_stats.update(scores + scores_val)
scheduler.step()
# save checkpoint
if args.rank == 0:
save_dict = {
"epoch": epoch + 1,
"state_dict": model.state_dict(),
"optimizer": optimizer.state_dict(),
"scheduler": scheduler.state_dict(),
"best_acc": best_acc,
}
torch.save(save_dict,
os.path.join(args.dump_path, "checkpoint.pth.tar"))
logger.info("Fine-tuning with {}% of labels completed.\n"
"Test accuracies: top-1 {acc1:.1f}, top-5 {acc5:.1f}".format(
args.labels_perc, acc1=best_acc[0], acc5=best_acc[1]))
def main_worker(args):
global best_acc1
# create model
if args.pretrained:
print("=> using pre-trained model resnet18 ")
model = resnet18(pretrained=True)
# no need for update parameter
for param in model.parameters():
param.requires_grad = False
# update parameter and modify num of classes
num_classes = 2
model.fc = nn.Linear(512, num_classes)
else:
print("=> creating resnet 18 model")
model = resnet18()
if torch.cuda.is_available():
model = model.cuda()
# define loss function (criterion) and optimizer
criterion = nn.CrossEntropyLoss().cuda()
optimizer = torch.optim.SGD(model.parameters(),
args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
# optionally resume from a checkpoint
if args.resume:
if os.path.isfile(args.resume):
print("=> loading checkpoint '{}'".format(args.resume))
if torch.cuda.is_available():
checkpoint = torch.load(args.resume).cuda()
else:
# Map model to be loaded to specified single gpu.
checkpoint = torch.load(args.resume, map_location="cpu")
args.start_epoch = checkpoint['epoch']
best_acc1 = checkpoint['best_acc1']
if torch.cuda.is_available():
# best_acc1 may be from a checkpoint from a different GPU
best_acc1 = best_acc1.to('cuda:0')
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(
args.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(args.resume))
cudnn.benchmark = True
# Data loading code
traindir = os.path.join(args.data, 'TRAIN')
valdir = os.path.join(args.data, 'TEST')
normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
std=[0.229, 0.224, 0.225])
train_dataset = datasets.ImageFolder(
traindir,
transforms.Compose([
transforms.RandomResizedCrop(224),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
normalize,
]))
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=args.batch_size,
shuffle=True,
num_workers=args.workers,
pin_memory=True)
val_loader = torch.utils.data.DataLoader(datasets.ImageFolder(
valdir,
transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
normalize,
])),
batch_size=args.batch_size,
shuffle=False,
num_workers=args.workers,
pin_memory=True)
if args.evaluate:
validate(val_loader, model, criterion, args)
return
for epoch in range(args.start_epoch, args.epochs):
adjust_learning_rate(optimizer, epoch, args)
# train for one epoch
train(train_loader, model, criterion, optimizer, epoch, args)
# evaluate on validation set
acc1 = validate(val_loader, model, criterion, args)
# remember best acc@1 and save checkpoint
is_best = acc1 > best_acc1
best_acc1 = max(acc1, best_acc1)
save_checkpoint(
{
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_acc1': best_acc1,
'optimizer': optimizer.state_dict(),
}, is_best)
from data_helper import UnlabeledDataset, LabeledDataset, LabeledDataset_task2
from helper import collate_fn, draw_filled_box
# You shouldn't change the unlabeled_scene_index
# The first 106 scenes are unlabeled (80,136 unlabeled images)
unlabeled_scene_index = np.arange(106)
# The scenes from 106 - 133 are labeled (20,412 labeled images)
# You should devide the labeled_scene_index into two subsets (training and validation)
labeled_scene_index = np.arange(106, 134)
image_folder = 'data'
annotation_csv = 'data/annotation.csv'
labeled_scene_index = np.arange(106, 134)
img_transform = transforms.Compose([
transforms.CenterCrop(256),
transforms.ToTensor(),
transforms.Normalize(mean=(0.5, ), std=(0.5, ))
])
map_transform = transforms.Compose(
[transforms.Resize(256), transforms.ToTensor()])
transform = torchvision.transforms.ToTensor()
unlabeled_trainset = UnlabeledDataset(image_folder=image_folder,
scene_index=labeled_scene_index,
first_dim='sample',
transform=img_transform)
trainloader = torch.utils.data.DataLoader(unlabeled_trainset,
batch_size=16,
ALTURA = 64
DATA_PATH = 'data3'
BATCH_SIZE = 2
# novo
nz = 100 #latent vector (gen input) era 100
ngf = 64 #feature map gen
ndf = 64 #feature map disc
beta1 = 0.5
ngpu = 1
dataset = torchvision.datasets.ImageFolder(root=DATA_PATH,
transform=transforms.Compose([
transforms.Resize(LARGURA),
transforms.CenterCrop(LARGURA),
transforms.ToTensor(),
transforms.Normalize(
(0.5, 0.5, 0.5),
(0.5, 0.5, 0.5)),
]))
train_loader = torch.utils.data.DataLoader(dataset,
batch_size=BATCH_SIZE,
shuffle=True,
num_workers=2)
device = torch.device("cuda:0" if (
torch.cuda.is_available() and ngpu > 0) else "cpu")
def main():
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
data_transform = transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
])
# load image
img_path = "a.jpg"
assert os.path.exists(img_path), "file: '{}' dose not exist.".format(
img_path)
img = Image.open(img_path)
plt.imshow(img)
# [N, C, H, W]
img = data_transform(img)
# expand batch dimension
img = torch.unsqueeze(img, dim=0)
print('input shape is: ', img.shape)
# read class_indict
json_path = './class_indices.json'
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(
json_path)
json_file = open(json_path, "r")
class_indict = json.load(json_file)
# create model
model = shufflenet_v2_x1_0(num_classes=5).to(device)
# load model weights
model_weight_path = "./weights/model-29.pth"
model.load_state_dict(torch.load(model_weight_path, map_location=device))
model.eval()
print('=================================')
dummy_input = torch.randn(1, 3, 224, 224).to(device)
torch.onnx.export(model,
dummy_input,
'shufflenetv2.onnx',
dynamic_axes={
'image': {
0: 'B'
},
'outputs': {
0: 'B'
}
},
input_names=['image'],
output_names=['outputs'],
opset_version=9)
print('=================================')
with torch.no_grad():
# predict class
output = torch.squeeze(model(img.to(device))).cpu()
predict = torch.softmax(output, dim=0)
predict_cla = torch.argmax(predict).numpy()
print_res = "class: {} prob: {:.3}".format(
class_indict[str(predict_cla)], predict[predict_cla].numpy())
plt.title(print_res)
print(print_res)
plt.show()
def main(args: argparse.Namespace):
logger = CompleteLogger(args.log, args.phase)
if args.seed is not None:
random.seed(args.seed)
torch.manual_seed(args.seed)
cudnn.deterministic = True
warnings.warn('You have chosen to seed training. '
'This will turn on the CUDNN deterministic setting, '
'which can slow down your training considerably! '
'You may see unexpected behavior when restarting '
'from checkpoints.')
cudnn.benchmark = True
# Data loading code
normalize = T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
if args.center_crop:
train_transform = T.Compose([
ResizeImage(256),
T.CenterCrop(224),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalize
])
else:
train_transform = T.Compose([
ResizeImage(256),
T.RandomCrop(224),
T.RandomHorizontalFlip(),
T.ToTensor(),
normalize
])
val_transform = T.Compose([
ResizeImage(256),
T.CenterCrop(224),
T.ToTensor(),
normalize
])
dataset = datasets.__dict__[args.data]
train_source_dataset = dataset(root=args.root, task=args.source, download=True, transform=train_transform)
train_source_loader = DataLoader(train_source_dataset, batch_size=args.batch_size,
shuffle=True, num_workers=args.workers, drop_last=True)
train_target_dataset = dataset(root=args.root, task=args.target, download=True, transform=train_transform)
train_target_loader = DataLoader(train_target_dataset, batch_size=args.batch_size,
shuffle=True, num_workers=args.workers, drop_last=True)
val_dataset = dataset(root=args.root, task=args.validation, download=True, transform=val_transform)
val_loader = DataLoader(val_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers)
if args.data == 'DomainNet':
test_dataset = dataset(root=args.root, task=args.target, split='test', download=True, transform=val_transform)
test_loader = DataLoader(test_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers)
else:
test_loader = val_loader
train_source_iter = ForeverDataIterator(train_source_loader)
train_target_iter = ForeverDataIterator(train_target_loader)
# create model
print("=> using pre-trained model '{}'".format(args.arch))
backbone = models.__dict__[args.arch](pretrained=True)
classifier = ImageClassifier(backbone, train_source_dataset.num_classes, args.num_blocks,
bottleneck_dim=args.bottleneck_dim, dropout_p=args.dropout_p).to(device)
adaptive_feature_norm = AdaptiveFeatureNorm(args.delta).to(device)
# define optimizer
# the learning rate is fixed according to origin paper
optimizer = SGD(classifier.get_parameters(), args.lr, weight_decay=args.weight_decay)
# resume from the best checkpoint
if args.phase != 'train':
checkpoint = torch.load(logger.get_checkpoint_path('best'), map_location='cpu')
classifier.load_state_dict(checkpoint)
# analysis the model
if args.phase == 'analysis':
# extract features from both domains
feature_extractor = nn.Sequential(classifier.backbone, classifier.bottleneck).to(device)
source_feature = collect_feature(train_source_loader, feature_extractor, device)
target_feature = collect_feature(train_target_loader, feature_extractor, device)
# plot t-SNE
tSNE_filename = osp.join(logger.visualize_directory, 'TSNE.png')
tsne.visualize(source_feature, target_feature, tSNE_filename)
print("Saving t-SNE to", tSNE_filename)
# calculate A-distance, which is a measure for distribution discrepancy
A_distance = a_distance.calculate(source_feature, target_feature, device)
print("A-distance =", A_distance)
return
if args.phase == 'test':
acc1 = validate(test_loader, classifier, args)
print(acc1)
return
# start training
best_acc1 = 0.
for epoch in range(args.epochs):
# train for one epoch
train(train_source_iter, train_target_iter, classifier, adaptive_feature_norm, optimizer, epoch, args)
# evaluate on validation set
acc1 = validate(val_loader, classifier, args)
# remember best acc@1 and save checkpoint
torch.save(classifier.state_dict(), logger.get_checkpoint_path('latest'))
if acc1 > best_acc1:
shutil.copy(logger.get_checkpoint_path('latest'), logger.get_checkpoint_path('best'))
best_acc1 = max(acc1, best_acc1)
print("best_acc1 = {:3.1f}".format(best_acc1))
# evaluate on test set
classifier.load_state_dict(torch.load(logger.get_checkpoint_path('best')))
acc1 = validate(test_loader, classifier, args)
print("test_acc1 = {:3.1f}".format(acc1))
logger.close()
# line = fileDescriptor.readline()
# # print (line)
# if line:
# lineItems = line.split()
# print(lineItems[0].split('/')[-1])
# print(i)
#-------------------- SETTINGS: DATASET BUILDERS
trBatchSize = 1
normalize = transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
transformList_test_val = []
transformList_test_val.append(transforms.Resize(256))
transformList_test_val.append(transforms.CenterCrop(224))
transformList_test_val.append(transforms.ToTensor())
transformList_test_val.append(normalize)
transformSequence_test_val = transforms.Compose(transformList_test_val)
datasetTest = DatasetGenerator(pathImageDirectory='../chest-image/images',
pathDatasetFile='./dataset/bbox.txt',
transform=transformSequence_test_val)
dataLoaderTest = DataLoader(dataset=datasetTest,
batch_size=trBatchSize,
shuffle=False,
num_workers=2,
pin_memory=True)
#---- TEST THE NETWORK
data_transforms = {
'train': transforms.Compose([
transforms.Pad((0, pad_size)),
transforms.RandomResizedCrop(299),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
]),
'finetune': transforms.Compose([transforms.Pad((0, pad_size)), transforms.Resize((299, 299)),
transforms.ToTensor()
]),
}
else:
data_transforms = {
'train': transforms.Compose([
transforms.CenterCrop(crop_size),
transforms.RandomResizedCrop(299),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
]),
'finetune': transforms.Compose([transforms.CenterCrop(crop_size), transforms.Resize((299, 299)),
transforms.ToTensor()
]),
}
# test_dataset = datasets.ImageFolder(test_data_dir, data_transforms['finetune'])
test_dataset = ImageFolderWithPaths(test_data_dir, data_transforms['finetune'])
