def evaluate_classifier(weights_path):
train_loader, val_loader = dataset.get_classifier_dataloaders(
augment=False, batch_size=10, train_shuffle=False)
test_loader = dataset.get_test_dataloader(batch_size=10, num_channels=3)
model = torchvision.models.resnet34().cuda()
D = torch.load(weights_path)
model.load_state_dict(D)
weights_dir = os.path.dirname(weights_path)
model.eval()
for name, loader in zip(['training', 'validation', 'test'],
[train_loader, val_loader, test_loader]):
ret = {'label': []}
for i, (image, _) in enumerate(loader):
if i % 10 == 0:
print('Processing batch %d' % i)
output = model(image.cuda())
output = output.detach().cpu()
predictions = torch.argmax(output, dim=1)
for prediction in predictions:
prediction_np = np.asscalar(prediction.numpy())
ret['label'].append(prediction_np)
df = pd.DataFrame(ret)
df.to_csv(weights_dir + '/%s_classifier_pred.csv' % name,
index=False)
def evaluate_watershed(weights_path):
'''
Evaluates model on given dataset and saves images as .png. Also saves predicted of number of classes based on watershed predictions in a csv.
'''
for ds in ['train', 'validation', 'test']:
if ds == 'train':
data_loader, _ = dataset.get_dataloaders(
batch_size=10,
augment=False,
skip_no_lenses_frames=False,
train_shuffle=False)
elif ds == 'validation':
_, data_loader = dataset.get_dataloaders(
batch_size=10,
augment=False,
skip_no_lenses_frames=False,
train_shuffle=False)
else:
data_loader = dataset.get_test_dataloader(batch_size=10,
num_channels=1)
model = unet.unet_model.UNet(1, NUM_CLASSES)
D = torch.load(weights_path)
model.load_state_dict(D)
model = model.cuda()
model.eval()
weights_dir = os.path.dirname(weights_path)
os.makedirs(weights_dir + '/%s_prediction/' % ds, exist_ok=True)
ret = {n: [] for n in range(NUM_CLASSES)}
img_no = -1
for i, (image, _) in enumerate(data_loader):
if i % 10 == 0:
print('Processing batch %d' % i)
output = model(image.cuda())
output = output.detach().cpu()
predictions = torch.argmax(output, dim=1)
for prediction in predictions:
img_no += 1
prediction_np = prediction.numpy()
pil = Image.fromarray(
(prediction_np * 255.0 /
np.clip(np.max(prediction_np), 1, None)).astype(np.uint8))
pil.save(weights_dir + '/%s_prediction/%s-%s-prediction.png' %
(ds, ds, str(img_no).zfill(5)))
for n in range(NUM_CLASSES):
ret[n].append(
watershed_to_num_lenses(prediction.numpy(), n))
df = pd.DataFrame(ret)
df.to_csv(os.path.dirname(weights_path) +
'/%s_watershed_pred.csv' % ds,
index=False)
df = pd.DataFrame({'label': df[9]})
df.to_csv(os.path.dirname(weights_path) + '/%s_pred.csv' % ds,
index=False)
def test(l_list, t_list):
start_time = time.time()
test_loader = get_test_dataloader(args)
for batch_index, (ims, labels) in enumerate(test_loader):
if args.gpu:
ims = ims.cuda()
labels = labels.cuda()
size_ratio = labels[:, -1]
outs, att = model(ims, size_ratio)
l_list = np.append(l_list, labels[:, 0:1].detach().cpu().numpy())
t_list = np.append(t_list, outs.detach().cpu().numpy())
end_time = time.time()
time_cost = end_time - start_time
return time_cost, l_list, t_list
#optimizer = torch.optim.Adam(model.parameters(),lr = args.lr, weight_decay = 1e-3)
#optimizer = torch.optim.SGD(model.parameters(),lr = args.lr,momentum = 0.9,weight_decay=5e-4)
optimizer = adabound.AdaBound(model.parameters(), lr=args.lr,
final_lr=0.1) #Adabound: Adaboost+ SGD
criterion = RegressionLoss()
tensorboard_dir = os.path.join(args.runs, args.name)
writer = SummaryWriter(tensorboard_dir)
checkpoint_path = os.path.join(args.checkpoints_dir, args.name)
if not os.path.exists(checkpoint_path):
os.makedirs(checkpoint_path)
checkpoints = os.path.join(checkpoint_path, '{net}-{epoch}-{type}.pth')
best_criterion = -1
lr = args.lr
train_loader, val_loader = get_train_dataloader(args)
test_loader = get_test_dataloader(args)
for epoch in range(1, args.epochs + 1):
y_l = np.array([])
y_p = np.array([])
for param_group in optimizer.param_groups:
current_lr = param_group['lr']
time_cost, y_l, y_p = train(epoch, y_l, y_p)
print(
"====================Epoch:{}==================== Learning Rate:{:.5f}"
.format(epoch, current_lr))
SROCC, KROCC, PLCC, RMSE, Acc = evaluate(y_l, y_p)
writer.add_scalar('Train/SROCC', SROCC, epoch)
print(
"Training Results - Epoch: {} Avg accuracy: {:.3f} RMSE: {:.5f} SROCC: {:.5f} KROCC: {:.5f} PLCC: {:.5f} ***** Time Cost: {:.1f} s"
use_cuda = not args.use_cpu and torch.cuda.is_available()
device = 'cuda' if use_cuda else 'cpu'
bs = args.train_batch_size
dataset_version = args.dataset_version
eval_batch = 2 if dataset_version == 'flip' else (
1 if dataset_version == 'single' else 6)
train_dataloader = get_train_dataloader(args.data_dir,
args.train_batch_size,
dataset_version,
shuffle=True,
use_transforms=args.augmentations)
test_dataloader = get_test_dataloader(args.data_dir,
args.test_batch_size,
dataset_version,
shuffle=True,
use_transforms=args.augmentations)
metrics_train_dataloader = get_train_dataloader(args.data_dir,
eval_batch,
dataset_version,
shuffle=False,
use_transforms=False)
metrics_test_dataloader = get_test_dataloader(args.data_dir,
eval_batch,
dataset_version,
shuffle=False,
use_transforms=False)
model = UNet().to(device)
embeddings = []
if __name__ == '__main__':
args = parse_args()
print(args)
use_cuda = not args.use_cpu and torch.cuda.is_available()
device = 'cuda' if use_cuda else 'cpu'
bs = args.train_batch_size
best_acc = 0
train_dataloader = get_train_dataloader(args.data_dir,
args.train_batch_size,
embedding=args.embedding)
test_dataloader = get_test_dataloader(args.data_dir,
args.train_batch_size,
embedding=args.embedding)
# metrics_train_dataloader = None # et_train_dataloader(args.data_dir, eval_batch, dataset_version, shuffle=False, use_transforms=False)
# metrics_test_dataloader = None # get_test_dataloader(args.data_dir, eval_batch, dataset_version, shuffle=False, use_transforms=False)
model = dispatch_model(args, device)
wandb.init(project=args.project_name, name=args.run_name, config=args)
wandb.watch(model, log='all')
config = wandb.config
loss_function = CrossEntropyLoss(reduction='mean')
optimizer = dispatch_optimizer(model, args)
lr_scheduler = dispatch_lr_scheduler(optimizer, args)
from models import SimpleModel
from training import warmup, dispatch_lr_scheduler, get_lr, dispatch_optimizer
from metrics import compute_accuracy, compute_confusion_matrix, compute_loss
from dataset import get_train_dataloader, get_test_dataloader
from utils import parse_args
if __name__ == '__main__':
args = parse_args()
use_cuda = not args.use_cpu and torch.cuda.is_available()
device = 'cuda' if use_cuda else 'cpu'
bs = args.train_batch_size
train_dataloader = get_train_dataloader(
os.path.join(args.data_dir, 'train/'), args.train_batch_size,
args.augmentation)
test_dataloader = get_test_dataloader(os.path.join(args.data_dir, 'test/'),
args.test_batch_size)
model = SimpleModel(use_bn=args.use_bn).to(device)
wandb.init(project="classifying-celebrities", config=args)
wandb.watch(model, log='all')
config = wandb.config
loss_function = CrossEntropyLoss(reduction='mean')
optimizer = dispatch_optimizer(model, args)
lr_scheduler = dispatch_lr_scheduler(optimizer, args)
iteration = 0
training_accuracy = compute_accuracy(model, train_dataloader, device)
test_accuracy = compute_accuracy(model, test_dataloader, device)
wandb.log({'training accuracy': training_accuracy}, step=iteration * bs)