def load_current_model():
global model_name
global SR_model
global cropping_resolution
global continuous_scale_factor
file_folder_path = os.path.dirname(os.path.abspath(__file__))
project_folder_path = os.path.join(file_folder_path, "..")
save_folder = os.path.join(project_folder_path, "SavedModels")
opt = load_options(os.path.join(save_folder, model_name))
opt["device"] = "cuda:0"
opt["save_name"] = model_name
opt['cropping_resolution'] = cropping_resolution
SR_model = load_model(opt,"cuda:0")
SR_model = SR_model.to("cuda:0")
if not SR_model.upscaling_model.continuous:
continuous_scale_factor = round(1/opt['spatial_downscale_ratio'])
return SR_model
def main():
if len(sys.argv) not in (2, 3):
print('Arguments:')
print('1: Name of experiment (must be defined in options.py)')
print('2 (optional): Cuda device number')
print('Example:')
print('python3 test.py dncnn_mag 0')
return
# Parse cmd line arguments
name = sys.argv[1]
save = join('../models', name)
if len(sys.argv) >= 3:
device = int(sys.argv[2])
else:
device = None
print(name, device)
# Load cmd line arguments
options = load_options(name)
train, test = options['dataset']
model = options['model']
# Prepare saving, load model if resuming
print('Loading model:', name)
model.load_state_dict(torch.load(join(save, 'model.pth')))
if device is not None:
torch.cuda.set_device(device)
model.cuda()
# Train the model
print('Generating sample...')
start = time.time()
sample = model.sample() # will be different for each model - update this
np.save(join(save, 'sample.npy'), sample.cpu().detach().numpy())
print('Time elapsed: %.3f' % (time.time() - start))
# Other options can change with every run
parser.add_argument('--batch_size', type=int, default=64, help='Batch size [default: 64]')
parser.add_argument('--fold', type=str, default='train', help='Fold [default: train]')
parser.add_argument('--start_epoch', type=int, help='Epoch to start from (defaults to most recent epoch)')
parser.add_argument('--count', type=int, default=1, help='Number of counterfactuals to generate')
options = vars(parser.parse_args())
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from dataloader import CustomDataloader
import counterfactual
from networks import build_networks
from options import load_options
# TODO: Right now, to edit cf_speed et al, you need to edit params.json
start_epoch = options['start_epoch']
options = load_options(options)
options['epoch'] = start_epoch
dataloader = CustomDataloader(**options)
# Batch size must be large enough to make a square grid visual
options['batch_size'] = dataloader.num_classes + 1
networks = build_networks(dataloader.num_classes, **options)
for i in range(options['count']):
counterfactual.generate_counterfactual(networks, dataloader, **options)
def main():
if len(sys.argv) not in (4, 5, 6):
print('Arguments:')
print('1: Name of experiment (must be defined in options.py)')
print('2: Num epochs')
print('3: Load existing?')
print('4 (optional): Cuda device number')
print('5 (optional): Babysit')
print('Example:')
print('python3 train.py dncnn_mag 3 False 0 False')
return
# Parse cmd line arguments
name = sys.argv[1]
save = join('../models', name)
epochs = int(sys.argv[2])
load = to_boolean(sys.argv[3])
device = int(len(sys.argv) >= 5 and sys.argv[4])
babysit = sys.argv >= 6 and to_boolean(sys.argv[5])
# Load cmd line arguments
options = load_options(name)
train, test = options['dataset']
model = options['model']
criterion = options['criterion']
optimizer = options['optimizer']
# Prepare variables for monitoring
test_i = len(train) // 2
disp_i = len(train) // 10
sys.stdout = Logger(join(save, 'log.txt'))
losses = None
# Load model if resuming
if not exists(save):
mkdir(save)
elif load:
print('Loading model:', name)
if torch.cuda.is_available():
torch.cuda.set_device(device)
map_location = None
model.cuda()
else: # torch.load needs to be altered if model was saved on GPU
map_location = lambda storage, loc: storage
model.load_state_dict(
torch.load(join(save, 'model.pth'), map_location=map_location))
losses = np.load(join(save, 'losses.npy'))
# Train the model
print('Beginning training...')
print('Name:', name)
print('Epochs:', epochs)
print('Examples per epoch:', len(train))
start = time.time()
for e in range(epochs):
train_loss = 0.0
train.shuffle()
for i, example in enumerate(train):
# Load example
image, label = example['image'], example['label']
if torch.cuda.is_available():
image, label = image.cuda(), label.cuda()
# Add batch dimension (1)
image = Variable(image).unsqueeze(0)
label = Variable(label).unsqueeze(0)
# Do one step
optimizer.zero_grad()
output = model(image)
loss = criterion(output, label)
loss.backward()
optimizer.step()
# Monitor progress
train_loss = ((loss.data[0] - train_loss) / (i % disp_i + 1))
if i % disp_i == disp_i - 1:
print('[%d, %d] Train loss: %.3f, Time elapsed: %.3f' %
(e + 1, i + 1, train_loss, time.time() - start))
train_loss = 0.0
if i % test_i == test_i - 1:
test_loss = compute_loss(test, criterion, model)
if losses is None:
losses = np.array([train_loss, test_loss])
else:
losses = np.vstack((losses, [train_loss, test_loss]))
print('[%d, %d] Test loss: %.3f, Time elapsed: %.3f' %
(e + 1, i + 1, test_loss, time.time() - start))
if babysit:
print('[%d, %d] Train loss: %.3f, Time elapsed: %.3f' %
(e + 1, i + 1, train_loss, time.time() - start))
# Save every epoch
torch.save(model.state_dict(), join(save, 'model.pth'))
np.save(join(save, 'losses.npy'), losses)
print('Finished %d epochs.' % (epochs))
print('Time elapsed: %.3f' % (time.time() - start))
def args(args):
import options
import shlex
options.load_options(shlex.split(args))
np.save(join(name, 'pred' + suffix), example['pred'])
if len(sys.argv) not in (2, 3):
print('Arguments:')
print('1: Name of experiment (must be defined in options.py)')
print('2 (optional): Cuda device number')
print('Example:')
print('python3 test.py dncnn_smallm_mag 0')
exit()
name = sys.argv[1]
device = int(len(sys.argv) >= 3 and sys.argv[2])
save = join('../models', name)
options = load_options(name, testing=True)
train, test = options['dataset']
model = options['model']
criterion = options['criterion']
optimizer = options['optimizer']
if torch.cuda.is_available():
torch.cuda.set_device(device)
map_location = None
model.cuda()
else:
map_location = lambda storage, loc: storage
model.load_state_dict(
torch.load(join(save, 'model.pth'), map_location=map_location))
losses = np.load(join(save, 'losses.npy'))
def args(args):
import options
import shlex
options.load_options(shlex.split(args))
