def my_inference(model, opt, img_path):
print(img_path)
assert (os.path.exists(img_path) and os.path.isfile(img_path))
A_dir = "./tmp/testA"
B_dir = "./tmp/testB"
if os.path.exists(A_dir):
shutil.rmtree(A_dir)
if os.path.exists(B_dir):
shutil.rmtree(B_dir)
os.makedirs(A_dir)
os.makedirs(B_dir)
img_name = os.path.basename(img_path)
des1 = os.path.join(A_dir, img_name)
des2 = os.path.join(B_dir, img_name)
shutil.copyfile(img_path, des1)
shutil.copyfile(img_path, des2)
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
for i, data in enumerate(dataset):
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
save_path = my_save_images(visuals,
img_path,
aspect_ratio=opt.aspect_ratio,
width=opt.display_winsize)
break # only test one image
return save_path
def generate_img(self, data_folder):
# test
self.opt.dataroot = data_folder
data_loader = CreateDataLoader(self.opt)
dataset = data_loader.load_data()
d_loss = []
g_loss = []
for i, data in enumerate(dataset):
#if i >= self.opt.how_many:
# break
self.model.set_input(data)
self.model.no_optimisation_run_through()
d = self.model.get_D_loss()
g = self.model.get_G_loss()
d_loss.append(d)
g_loss.append(g)
#TODO get loss and return it
visuals = self.model.get_current_visuals()
img_path = self.model.get_image_paths()
#if i % 5 == 0:
# print('processing (%04d)-th image... %s' % (i, img_path))
save_images(self.webpage,
visuals,
img_path,
aspect_ratio=self.opt.aspect_ratio,
width=self.opt.display_winsize)
self.webpage.save()
return g_loss, d_loss
def main():
# step1: opt
opt = TestOptions().parse()
# step2: data
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
# step3: model
model = create_model(opt)
model.setup(opt)
# step4: web ,在test中不使用visdom,而是使用html
web_dir = os.path.join(opt.results_dir, opt.name,
'{}_{}'.format(opt.phase, opt.epoch))
title = 'Experiment = {}, Phase = {}, Epoch = {}'.format(
opt.name, opt.phase, opt.epoch)
webpage = HTML(web_dir, title=title)
# test with eval mode. This only affects layers like batchnorm and dropout.
# pix2pix: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# CycleGAN: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
model.eval()
for i, data in enumerate(dataset):
if i > opt.num_test:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_images_paths()
if i % 5 == 0:
print('processing {:0>4d}-th image...{}'.format(i, img_path))
save_images(webpage,
visuals,
img_path,
aspect_ratio=opt.aspect_ratio,
width=opt.display_winsize)
webpage.save()
def my_batch_inference(model, opt, img_path):
###input : M*N*3*256
print(img_path)
assert (os.path.exists(img_path) and os.path.isfile(img_path))
A_dir = "./tmp/testA"
B_dir = "./tmp/testB"
if os.path.exists(A_dir):
shutil.rmtree(A_dir)
if os.path.exists(B_dir):
shutil.rmtree(B_dir)
os.makedirs(A_dir)
os.makedirs(B_dir)
batchdata = sio.loadmat(img_path)['batch']
orisize = batchdata.shape[0]
for i in range(0, batchdata.shape[3]):
img = batchdata[:, :, :, i]
cv2.imwrite(os.path.join(A_dir, str(i) + ".jpg"), img)
cv2.imwrite(os.path.join(B_dir, str(i) + ".jpg"), img)
img_name = os.path.basename(img_path)
des1 = os.path.join(A_dir, img_name)
des2 = os.path.join(B_dir, img_name)
shutil.copyfile(img_path, des1)
shutil.copyfile(img_path, des2)
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
imgnamelist = []
for i, data in enumerate(dataset):
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
save_path = my_save_images(visuals,
img_path,
aspect_ratio=opt.aspect_ratio,
width=opt.display_winsize)
imgnamelist.append(save_path)
# imgdict['name']=save_path
# break # only test one image
x_data = []
for img in imgnamelist:
image = cv2.imread(img)
image = cv2.resize(image, (orisize, orisize))
x_data.append(image)
x_data = numpy.array(x_data)
x_data = x_data.transpose([1, 2, 3, 0])
save_path = 'temp/batch.mat'
sio.savemat(save_path, {'batch': x_data})
return save_path
def on_created(self, event): # when file is created
# do something, eg. call your function to process the image
print("Got E event for file %s" % event.src_path)
try:
go = os.path.abspath(os.path.join(event.src_path, os.pardir, "go"))
if not os.path.isfile(go):
return
with open(go) as f:
name = f.readlines()[0]
print("starting to process %s" % self.opt.name)
self.model.opt = self.opt
data_loader = CreateDataLoader(self.opt)
dataset = data_loader.load_data()
for i, data in enumerate(dataset):
basename = os.path.basename(data['A_paths'][0])[:-4]
self.model.set_input(data)
z = self.model.encode_real_B()
img_path = self.model.get_image_paths()
print('%04d: process image... %s' % (i, img_path))
outfile = "./output/%s/%s/%s@%s" % (self.directory, name,
basename, "_".join(
[str(s)
for s in z[0]]))
try:
os.makedirs(os.path.dirname(outfile), exist_ok=True)
except:
pass
touch(outfile)
except Exception as e:
traceback.print_exc()
print(e)
try:
rmrf('./input/%s/val/*' % self.directory)
if os.path.isfile(go):
os.remove(go)
except Exception as e:
traceback.print_exc()
print(e)
def eval_test(model,epoch,isTest=False,testOpt=None):
if not isTest:
opt = get_val_opt()
#save image result of validation set in last iteration, otherwise compute ssim and psnr only
if epoch >= opt.saveimg_epoch:
opt.saveimg=True
if isTest:
opt=testOpt
set_name=opt.setname
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
print("Current test set is "+set_name+" size:"+str(len(dataset)))
psnr,ssim=model_test_val(opt,dataset,model,epoch)
return psnr,ssim
def test():
import sys
sys.argv = args
import os
from options.test_options import TestOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
from util import html
opt = TestOptions().parse()
opt.nThreads = 1 # test code only supports nThreads = 1
opt.batchSize = 1 # test code only supports batchSize = 1
opt.serial_batches = True # no shuffle
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
model = create_model(opt)
visualizer = Visualizer(opt)
# create website
web_dir = os.path.join(opt.results_dir, opt.name,
'%s_%s' % (opt.phase, opt.which_epoch))
webpage = html.HTML(
web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' %
(opt.name, opt.phase, opt.which_epoch))
# test
for i, data in enumerate(dataset):
if i >= opt.how_many:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
img_path[0] = img_path[0] + str(i)
print('%04d: process image... %s' % (i, img_path))
visualizer.save_images(webpage,
visuals,
img_path,
aspect_ratio=opt.aspect_ratio)
webpage.save()
def loadmodel():
opt = TestOptions().parse()
# hard-code some parameters for test
opt.num_threads = 1 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
opt.display_id = -1 # no visdom display
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
model = create_model(opt)
model.setup(opt)
# create a website
web_dir = os.path.join(opt.results_dir, opt.name,
'%s_%s' % (opt.phase, opt.epoch))
# webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.epoch))
# test with eval mode. This only affects layers like batchnorm and dropout.
# pix2pix: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# CycleGAN: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
if opt.eval:
model.eval()
return model
def __init__(self, gpu_ids=[]):
opt = TestOptions() #.parse()
opt.nThreads = 1 # test code only supports nThreads = 1
opt.batchSize = 1 # test code only supports batchSize = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
opt.display_id = -1 # no visdom display
opt.dataset_mode = "single"
opt.dataroot = "."
opt.phase = "test"
opt.loadSize = 256
opt.fineSize = 256
opt.isTrain = False
opt.input_nc = 3
opt.output_nc = 3
opt.gpu_ids = gpu_ids
opt.name = "NU_SEG"
opt.model_suffix = ""
opt.checkpoints_dir = "../../NucleiSegmentation/checkpoints/"
opt.model = "test"
opt.ngf = 64
opt.norm = "instance"
opt.which_model_netG = "unet_256"
opt.resize_or_crop = "resize_and_crop"
opt.which_epoch = "latest"
opt.no_dropout = "store_true"
opt.init_type = "normal"
opt.init_gain = 0.02
opt.verbose = ""
opt.which_direction = "BtoA"
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
model = create_model(opt)
model.setup(opt)
self.model = model
import time
from options.train_options import TrainOptions
from options.val_options import ValOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
import numpy as np
import math
from skimage.measure import compare_ssim
if __name__ == '__main__':
opt = TrainOptions().parse()
val = ValOptions().parse()
data_loader = CreateDataLoader(opt)
data_loader_val = CreateDataLoader(val)
dataset = data_loader.load_data()
dataset_val = data_loader_val.load_data()
dataset_size = len(data_loader)
dataset_val_size = len(data_loader_val)
print('#training images = %d' % dataset_size)
print('#validation images = %d' % dataset_val_size)
val.nThreads = 1
val.batchSize = 1
model = create_model(opt)
model_val = create_model(val)
model.setup(opt)
visualizer = Visualizer(opt)
total_steps = 0
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
config.num_test = 50
config.phase = 'test'
config.model = 'test'
config.loadSize = config.fineSize
config.num_threads = 1 # test code only supports num_threads = 1
config.batch_size = 1 # test code only supports batch_size = 1
config.serial_batches = True # no shuffle
config.no_flip = True # no flip
config.display_id = -1 # no visdom display
model = CycleGANModel()
model.initialize(config)
model.setup(config)
print("Network Model Created")
data_loader = CreateDataLoader(config)
dataset = data_loader.load_data()
# create a website
web_dir = os.path.join(config.results_dir, config.name,
'%s_%s' % (config.phase, config.epoch))
webpage = html.HTML(
web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' %
(config.name, config.phase, config.epoch))
# test with eval mode. This only affects layers like batchnorm and dropout.
# CycleGAN: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
# model.eval()
for i, data in enumerate(dataset):
if i >= config.num_test:
break
model.set_input(data)
opt.gpu_ids) > 0 else "cpu"
if os.path.exists(abort_file):
os.remove(abort_file)
exit("Abort using file: " + abort_file)
if opt.sanity_check:
sanity_check(opt)
batch_size = opt.batch_size
parallell_batch_size = opt.parallell_batch_size if opt.parallell_batch_size > 0 else opt.batch_size
opt.batch_size = parallell_batch_size
n_acc_batches = batch_size // parallell_batch_size
opt.n_acc_batches = n_acc_batches
assert batch_size % parallell_batch_size == 0, "Batch size should be divisible by parallell batch size"
data_loader = CreateDataLoader(copy.deepcopy(opt))
validation_size = 0
if opt.validation_freq > 0:
opt_val = copy.deepcopy(opt)
opt_val.phase = opt.validation_set
opt_val.max_dataset_site = opt.max_val_dataset_size
if opt.validation_set == "split":
torch.manual_seed(42)
validation_loader, data_loader = SplitDataLoader(
data_loader,
copy.deepcopy(opt),
opt_val,
length_first=opt.max_val_dataset_size)
else:
validation_loader = CreateDataLoader(opt_val)
import time
from options.train_options import TrainOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
if __name__ == '__main__':
opt = TrainOptions().parse()
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
dataset_size = len(data_loader)
print('#training images = %d' % dataset_size)
model = create_model(opt)
model.setup(opt)
visualizer = Visualizer(opt)
total_steps = 0
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
iter_data_time = time.time()
epoch_iter = 0
for i, data in enumerate(dataset):
iter_start_time = time.time()
if total_steps % opt.print_freq == 0:
t_data = iter_start_time - iter_data_time
visualizer.reset()
total_steps += opt.batchSize
epoch_iter += opt.batchSize
model.set_input(data)
import os
from options.test_options import TestOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import save_images
from util import html
if __name__ == '__main__':
opt = TestOptions().parse()
opt.nThreads = 1 # test code only supports nThreads = 1
opt.batchSize = 1 # test code only supports batchSize = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
opt.display_id = -1 # no visdom display
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
model = create_model(opt)
model.setup(opt)
# create website
web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.which_epoch))
webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.which_epoch))
# test
for i, data in enumerate(dataset):
if i >= opt.how_many:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
if i % 5 == 0:
def main():
# parse options
parser = TestOptions()
opts = parser.parse()
orig_dir = opts.orig_dir
blur_dir = opts.dataroot
saver = Saver(opts)
# data loader
print('\n--- load dataset ---')
dataset_domain = 'A' if opts.a2b else 'B'
# dataset = dataset_single(opts, 'A', opts.input_dim_a)
# else:
# dataset = dataset_single(opts, 'B', opts.input_dim_b)
# loader = torch.utils.data.DataLoader(dataset, batch_size=1, num_workers=opts.nThreads)
loader = CreateDataLoader(opts)
# model
print('\n--- load model ---')
model = UID(opts)
model.setgpu(opts.gpu) ## comment for cpu mode
model.resume(opts.resume, train=False)
model.eval()
# test
print('\n--- testing ---')
for idx1, data in enumerate(loader):
# img1, img_name_list = data[dataset_domain], data[dataset_domain+'_paths']
# img1 = img1.cuda(opts.gpu).detach()
images_b = data['B']
images_a = images_b # should in the same shape (This is only for the case `resize_or_crop="none"`)
img_name_list = data['B_paths'] # B is the fluorescence image
center_crop_shape = data[
'B_size_WH'][::-1] # B is the fluorescence image
if len(img_name_list) > 1:
print("Warning, there are more than 1 sample in the test batch.")
images_a = images_a.cuda(opts.gpu).detach() ## comment for cpu mode
images_b = images_b.cuda(opts.gpu).detach() ## comment for cpu mode
images_a = torch.cat(
[images_a] * 2,
dim=0) # because half of the batch is used as real_A_random
images_b = torch.cat(
[images_b] * 2,
dim=0) # because half of the batch is used as real_B_random
print('{}/{}'.format(idx1, len(loader)))
with torch.no_grad():
model.inference(images_a, images_b)
# img = model.test_forward(img1, a2b=opts.a2b)
img_name = img_name_list[0].split('/')[-1]
saver.write_img(idx1,
model,
img_name=img_name,
inference_mode=True,
mask_path='../input/testB_mask/' + img_name) # True
# saver.save_img(img=model.fake_I_encoded[[np.s_[:]]*2 + return_center_crop_slices(input_shapes=images_b.shape[-2:],
# output_shapes=center_crop_shape,
# input_scale=1.0,
# output_scale=opts.fineSize*1.0/opts.loadSize)],
# img_name=img_name,
# subfolder_name="fake_A") #'gen_%05d.png' % (idx1),
return
def main():
# parse options
parser = TrainOptions()
opts = parser.parse()
# visualizer
visualizer = Visualizer(opts)
# data loader
print('\n--- load dataset ---')
# dataset = dataset_unpair(opts)
# train_loader = torch.utils.data.DataLoader(dataset, batch_size=opts.batch_size, shuffle=True, num_workers=opts.nThreads)
data_loader = CreateDataLoader(opts)
# model
print('\n--- load model ---')
model = UID(opts)
model.setgpu(opts.gpu)
if opts.resume is None:
model.initialize()
ep0 = -1
total_it = 0
else:
ep0, total_it = model.resume(opts.resume)
model.set_scheduler(opts, last_ep=ep0)
ep0 += 1
print('start the training at epoch %d'%(ep0))
# saver for display and output
saver = Saver(opts)
# train
print('\n--- train ---')
max_it = 500000
for ep in range(ep0, opts.n_ep):
print("Epoch: {}".format(ep))
for it, data in enumerate(data_loader):
images_a, images_b = data['A'], data['B']
if images_a.size(0) != opts.batch_size or images_b.size(0) != opts.batch_size:
continue
images_a = images_a.cuda(opts.gpu).detach()
images_b = images_b.cuda(opts.gpu).detach()
# update model
# model.update_D_content(images_a, images_b) # uncomment for GAN_content, discriminator of z_content
model.update_D(images_a, images_b)
if (it + 1) % 2 != 0 and it != len(data_loader)-1:
continue
model.update_EG()
losses_dic = model.get_current_losses()
visualizer.plot_current_losses(ep, float(it)/len(data_loader), opts, losses_dic)
# save to display file
if (it+1) % 48 == 0:
print('total_it: %d (ep %d, it %d), lr %08f' % (total_it+1, ep, it+1, model.gen_opt.param_groups[0]['lr']))
print('Dis_I_loss: %04f, Dis_B_loss %04f, GAN_loss_I %04f, GAN_loss_B %04f' % (model.disA_loss, model.disB_loss, model.gan_loss_i,model.gan_loss_b))
print('B_percp_loss %04f, Recon_II_loss %04f' % (model.B_percp_loss, model.l1_recon_II_loss))
if (it+1) % 200 == 0:
saver.write_img(ep*len(data_loader) + (it+1), model)
total_it += 1
if total_it >= max_it:
saver.write_img(-1, model)
saver.write_model(-1, model)
break
# decay learning rate
if opts.n_ep_decay > -1:
model.update_lr()
saver.write_img(ep, model)
# Save network weights
saver.write_model(ep, total_it+1, model)
return
def train():
import time
from options.train_options import TrainOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
opt = TrainOptions().parse()
model = create_model(opt)
#Loading data
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
dataset_size = len(data_loader)
print('Training images = %d' % dataset_size)
visualizer = Visualizer(opt)
total_steps = 0
#Starts training
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
iter_data_time = time.time()
epoch_iter = 0
for i, data in enumerate(dataset):
iter_start_time = time.time()
if total_steps % opt.print_freq == 0:
t_data = iter_start_time - iter_data_time
visualizer.reset()
total_steps += opt.batchSize
epoch_iter += opt.batchSize
model.set_input(data)
model.optimize_parameters()
#Save current images (real_A, real_B, fake_A, fake_B, rec_A, rec_B)
if epoch_iter % opt.display_freq == 0:
save_result = total_steps % opt.update_html_freq == 0
visualizer.display_current_results(model.get_current_visuals(),
epoch, epoch_iter,
save_result)
#Save current errors
if total_steps % opt.print_freq == 0:
errors = model.get_current_errors()
t = (time.time() - iter_start_time) / opt.batchSize
visualizer.print_current_errors(epoch, epoch_iter, errors, t,
t_data)
if opt.display_id > 0:
visualizer.plot_current_errors(
epoch,
float(epoch_iter) / dataset_size, opt, errors)
#Save model based on the number of iterations
if total_steps % opt.save_latest_freq == 0:
print('saving the latest model (epoch %d, total_steps %d)' %
(epoch, total_steps))
model.save('latest')
iter_data_time = time.time()
#Save model based on the number of epochs
print(opt.dataset_mode)
if epoch % opt.save_epoch_freq == 0:
print('saving the model at the end of epoch %d, iters %d' %
(epoch, total_steps))
model.save('latest')
model.save(epoch)
print('End of epoch %d / %d \t Time Taken: %d sec' %
(epoch, opt.niter + opt.niter_decay,
time.time() - epoch_start_time))
model.update_learning_rate()
opt = TrainOptions().parse()
"""
opt.dataroot = './traindata'
opt.name = 'DANN_miter1step1'
opt.batchSize = 64
opt.lr = 0.00001
opt.model = 'DANN_m_iter'
opt.which_epochs_DA = 1
opt.which_usename_DA = 'DANN_mstep1without'
opt.which_epochs_Di = 10
opt.which_usename_Di = 'DANN_mv3step2'
opt.gpu_ids = [0]
opt.save_epoch_freq = 100
"""
mnist_data_loader, mnistm_data_loader, eval_data_loader = CreateDataLoader(
opt)
mnist_dataset, mnistm_dataset, eval_dataset = mnist_data_loader.load_data(
), mnistm_data_loader.load_data(), eval_data_loader.load_data()
mnist_dataset_size = len(mnist_data_loader)
mnistm_dataset_size = len(mnistm_data_loader)
eval_dataset_size = len(eval_data_loader)
print('#mnist training images = %d' % mnist_dataset_size)
print('#mnistm training images = %d' % mnistm_dataset_size)
print('#eval training images = %d' % eval_dataset_size)
print('#eval training images = %d' % len(eval_dataset))
model = create_model(opt)
best_acc = 0
total_steps = 0
i = 0
import time
import copy
from data import CreateDataLoader
from models import create_model
from options.train_options import TrainOptions
from util.visualizer import Visualizer, save_images
if __name__ == '__main__':
opt = TrainOptions().parse()
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
dataset_size = len(data_loader)
print('#training images = %d' % dataset_size)
if opt.validate_freq > 0:
validate_opt = copy.deepcopy(opt)
validate_opt.phase = 'val'
validate_opt.serial_batches = True # no shuffle
val_data_loader = CreateDataLoader(validate_opt)
val_dataset = val_data_loader.load_data()
val_dataset_size = len(val_data_loader)
print('#validation images = %d' % val_dataset_size)
model = create_model(opt)
model.setup(opt)
visualizer = Visualizer(opt)
total_steps = 0
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
def main():
args = get_arguments()
print('Called with args:')
print(args)
cfg_from_file(cfg, args.yml)
if cfg.EXP_NAME == '':
cfg.EXP_NAME = f'exp_1'
# 创建实验文件夹
if cfg.EXP_ROOT_SNAPSHOT == '':
cfg.EXP_ROOT_SNAPSHOT = osp.join(cfg.EXP_ROOT, 'snapshots')
if cfg.EXP_ROOT_LOGS == '':
cfg.EXP_ROOT_LOGS = osp.join(cfg.EXP_ROOT, 'logs')
if not osp.exists(cfg.EXP_ROOT_SNAPSHOT):
os.makedirs(cfg.EXP_ROOT_SNAPSHOT)
if not osp.exists(cfg.EXP_ROOT_LOGS):
os.makedirs(cfg.EXP_ROOT_LOGS)
print('Using config:')
pprint.pprint(cfg)
os.environ["CUDA_VISIBLE_DEVICES"] = cfg.visGPU
# INIT
_init_fn = None
if not cfg.RANDOM_TRAIN:
torch.manual_seed(cfg.TRAIN.RANDOM_SEED)
torch.cuda.manual_seed(cfg.TRAIN.RANDOM_SEED)
np.random.seed(cfg.TRAIN.RANDOM_SEED)
random.seed(cfg.TRAIN.RANDOM_SEED)
def _init_fn(worker_id):
np.random.seed(cfg.TRAIN.RANDOM_SEED + worker_id)
model_dict = {}
# LOAD NET
assert osp.exists(cfg.INIT_FROM), f'Missing init model {cfg.INIT_FROM}'
if cfg.TRAIN.MODEL == 'RESNET':
if cfg.METHOD == 'baseline':
model_dict['model'] = get_resnet()
else:
raise NotImplementedError
elif cfg.TRAIN.MODEL == 'VGG':
if cfg.METHOD == 'baseline':
model_dict['model'] = get_vgg()
else:
raise NotImplementedError
else:
raise NotImplementedError(f"Not yet supported {cfg.TRAIN.MODEL}")
print('Model loaded')
if cfg.RESTOR_FROM != '':
state_dict = torch.load(cfg.RESTOR_FROM, map_location=lambda storage, loc: storage)
if cfg.METHOD == 'baseline':
model_dict['model'].load_state_dict(state_dict['model_state_dict'])
print(f'model restore from {cfg.RESTOR_FROM}')
else:
raise NotImplementedError
# DATA LOADER
print('preparing dataloaders ...')
dataloader = CreateDataLoader(cfg)
dataloader_iter = enumerate(dataloader)
with open(osp.join(cfg.EXP_ROOT_LOGS, 'train_cfg.yml'), 'w') as yaml_file:
yaml.dump(cfg, yaml_file, default_flow_style=False)
# TRAINING
if cfg.METHOD == 'baseline':
train_baseline(model_dict, dataloader_iter, cfg)
import time
from options.train_options import TrainOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
if __name__ == '__main__':
opt = TrainOptions().parse() # opt用于处理命令行参数
data_loader = CreateDataLoader(opt) # data_loader用于加载数据
dataset = data_loader.load_data() # 加载数据集
dataset_size = len(data_loader) # 数据集的size
print('#training images = %d' % dataset_size) # training data:1096张(train, trainA, trainB均为1096张)
model = create_model(opt) # 创建模型，opt.model默认值是cycle_gan
model.setup(opt) # 模型读取opt中的参数，并进行相关初始化操作
visualizer = Visualizer(opt) # 用于可视化输出
total_steps = 0
# 训练200个epoch
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
iter_data_time = time.time()
epoch_iter = 0
for i, data in enumerate(dataset):
iter_start_time = time.time()
if total_steps % opt.print_freq == 0: # print_freq = 100
t_data = iter_start_time - iter_data_time
visualizer.reset()
total_steps += opt.batch_size # default batch_size = 1
epoch_iter += opt.batch_size
from util.util import post_process
if __name__ == '__main__':
opt = TrainOptions().parse()
if opt.no_normalize:
transform = tr.ToTensor()
else:
transform = tr.Compose([
tr.ToTensor(),
tr.Normalize(mean=opt.transform_mean, std=opt.transform_std)
])
#mix train---syn data
if opt.train_type == 'mix':
opt.batch_size = opt.batch_size // 2
train_loader = CreateDataLoader(opt,dataroot=opt.dataroot,image_dir=opt.train_img_dir_syn,\
label_dir=opt.train_label_dir_syn,record_txt=opt.train_img_list_syn,\
transform=transform,is_aug=False)
train_dataset = train_loader.load_data()
dataset_size = len(train_loader)
print('#Synthetic training images = %d, batchsize = %d' %
(dataset_size, opt.batch_size))
#train---real data
train_loader_real = CreateDataLoader(opt,dataroot=opt.dataroot,image_dir=opt.train_img_dir_real,\
label_dir=opt.train_label_dir_real,record_txt=opt.train_img_list_real,\
transform=transform,is_aug=False)
train_dataset_real = train_loader_real.load_data()
dataset_size_real = len(train_loader_real)
print('#Real training images = %d, batchsize = %d' %
(dataset_size_real, opt.batch_size))
import os
from arguments import Arguments
from data import CreateDataLoader
from models import create_model
from util import save_images
if __name__ == '__main__':
args = Arguments().parse()
data_loader = CreateDataLoader(args)
dataset = data_loader.load_data()
model = create_model(args)
for i, data in enumerate(dataset):
if i >= args.how_many:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
img_size = model.get_image_sizes()
print('%04d: processing image... %s' % (i, img_path))
save_images(args.results_dir, visuals, img_path, size=img_size)
def main(style):
opt = TestOptions().parse()
opt.dataroot = "datasets/own_data/testA"
# four styles
# opt.name = "style_ink_pretrained"
# opt.name = "style_monet_pretrained"
# opt.name = "style_cezanne_pretrained"
# opt.name = "style_ukiyoe_pretrained"
# opt.name = "style_vangogh_pretrained"
# set original img size
original_img = cv2.imread(opt.dataroot+"/temp.jpg")
original_img_shape = tuple([item for item in original_img.shape[:-1]][::-1])
opt.name = "style_%s_pretrained" % style
# 不可更改
opt.model = "test"
cv2.imread("temp.jpg")
opt.nThreads = 1 # test code only supports nThreads = 1
opt.batchSize = 1 # test code only supports batchSize = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
opt.display_id = -1 # no visdom display
# need to overwrite 8-27 这边可以不要
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
# create model
model = create_model(opt)
model.setup(opt)
# create website
# website没什么用，但是作者把保存图片写到了web_dir里面了，我就没有修改。
web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.which_epoch))
print("web_dir", web_dir)
webpage = html.HTML(web_dir, 'Experiment = %s, Phase = %s, Epoch = %s' % (opt.name, opt.phase, opt.which_epoch))
print("webpage", webpage)
# exit()
# test
for i, data in enumerate(dataset):
# i is index enumerate生成，很简单的
# type of data is dict
# one key is A， A is a tensor which size is ([1, 3, 256, 256]), another is A_path which type is str. from the read path (include the name)
# i. e. datasets/own_data/testA/2test.jpg
# default how_many is 50 : 一个数据集中只能处理 50 张照片
# need to overwrite "data"
# data 的形状和其一样，然后外面改写一个监听，应该就可以了
if i >= opt.how_many:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
if i % 5 == 0:
print('processing (%04d)-th image... %s' % (i, img_path))
save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize)
generate_img = cv2.imread("results/generate_images/" + "temp.png")
reshape_generate_img = cv2.resize(generate_img, original_img_shape, interpolation=cv2.INTER_CUBIC)
cv2.imwrite("results/generate_images/" + "temp.png", reshape_generate_img)
from options.train_options import TrainOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
# import random
# random.seed(666)
### landmark+bbox <-> face
### aligned, use UnalignedDataset class to achieve
if __name__ == '__main__':
print('start...')
### data
opt = TrainOptions().parse()
print('opt parse: success!')
data_loader = CreateDataLoader(opt)
print('initialize data_loader: success!')
dataset = data_loader.load_data() ### return self 233
dataset_size = len(data_loader)
print('#training images = %d' % dataset_size)
### model
model = create_model(opt)
model.setup(opt)
visualizer = Visualizer(opt)
total_steps = 0
### train
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
iter_data_time = time.time()
opt = TestOptions().parse()
# hard-code some parameters for test
opt.num_threads = 1 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # no shuffle
opt.no_flip = True # no flip
if opt.no_normalize:
transform = tr.ToTensor()
else:
transform=tr.Compose([tr.ToTensor(),
tr.Normalize(mean=opt.transform_mean,
std=opt.transform_std)
])
data_loader = CreateDataLoader(opt,dataroot=opt.dataroot,image_dir=opt.test_img_dir,\
label_dir=opt.test_label_dir,record_txt=opt.test_img_list,transform=transform,is_aug=False)
dataset = data_loader.load_data()
datasize = len(data_loader)
print('#test images = %d, batchsize = %d' %(datasize,opt.batch_size))
model = create_model(opt)
model.setup(opt)
img_dir = os.path.join(opt.results_dir, opt.name, '%s' % opt.epoch)
mkdir(img_dir)
eval_results={}
count=0
with open(img_dir+'_eval.txt','w') as log:
now = time.strftime('%c')
log.write('=============Evaluation (%s)=============\n' % now)
# -*- coding:utf-8 -*-
import time
from options.train_options import TrainOptions
from data import CreateDataLoader
from models import create_model
if __name__ == '__main__':
opt = TrainOptions().parse()
data_loader = CreateDataLoader(opt)
tmp = 0
import math from sklearn.metrics import balanced_accuracy_score, mean_squared_error from skimage.color import rgb2lab import numpy as np import torch import torch.nn as nn import os import shutil import logging opt = TrainOptions().parse() opt.phase = 'train/train_' opt.serial_batches = False train_data_loader = CreateDataLoader(opt) train_dataset = train_data_loader.load_data() train_dataset_size = len(train_data_loader) opt.phase = 'test/test_' opt.batch_size = 1 opt.serial_batches = True test_data_loader = CreateDataLoader(opt) test_dataset = test_data_loader.load_data() test_dataset_size = len(test_data_loader) model = create_model(opt) model.setup(opt) # Set logger msg = []
def convert():
if (chkGpuVar.get() == 0):
opt.gpu_ids.clear()
#opt.remove_images = chkDelVar.get()
opt.resize_or_crop = drpResizeOp.get()
try:
opt.epoch = txtEpoch.get()
except Exception as e:
print(e)
if (opt.resize_or_crop.__contains__('scale')):
for i in range(len(validSizes) - 2):
if (sclFineVar.get() < validSizes[i + 1]
and sclFineVar.get() >= validSizes[i]):
opt.fineSize = validSizes[i]
print(testOptions.return_options(opt))
try:
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
model = create_model(opt)
model.setup(opt)
# test with eval mode. This only affects layers like batchnorm and dropout.
# pix2pix: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# CycleGAN: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
progressbar.configure(maximum=len(dataset))
#progressbar.start(len(dataset))
for i, data in enumerate(dataset):
while running:
if i >= opt.num_test or running == False:
break
model.set_input(data)
model.test()
visuals = model.get_current_visuals()
img_path = model.get_image_paths()
mess = 'processing (%04d)-th of %04d image... %s' % (
i + 1, len(dataset), img_path[0])
print(mess)
# Open a file with access mode 'a'
file_object = open('conversion_progress.txt', 'a')
# Append 'hello' at the end of file
file_object.write(mess + '\n')
# Close the file
file_object.close()
save_images(opt.results_dir,
visuals,
img_path,
save_both=opt.save_both,
aspect_ratio=opt.aspect_ratio)
progress_var.set(i + 1)
if (opt.remove_images):
os.remove(img_path[0])
print('removed image', img_path[0])
except KeyboardInterrupt:
progress_var.set(0)
print("==============Cancelled==============")
raise
except Exception as e:
print(e)
raise
import time
from options.train_options import TrainOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
if __name__ == '__main__':
opt = TrainOptions().parse() # Trainning option
data_loader = CreateDataLoader(
opt) # Create a dataset given opt.dataset_mode and other options
dataset = data_loader.load_data() # Get dataset
dataset_size = len(data_loader)
print('#training images = %d' % dataset_size)
model = create_model(
opt) # create a model given opt.model and other options
model.setup(opt)
visualizer = Visualizer(opt)
total_steps = 0
for epoch in range(opt.epoch_count, opt.niter + opt.niter_decay + 1):
epoch_start_time = time.time()
iter_data_time = time.time()
epoch_iter = 0
for i, data in enumerate(dataset):
iter_start_time = time.time()
if total_steps % opt.print_freq == 0:
t_data = iter_start_time - iter_data_time
visualizer.reset()
total_steps += opt.batchSize
import time
import copy
import torch
from options.train_options import TrainOptions
from data import CreateDataLoader
from models import create_model
from util.visualizer import Visualizer
if __name__ == '__main__':
# training dataset
opt = TrainOptions().parse()
data_loader = CreateDataLoader(opt)
dataset = data_loader.load_data()
dataset_size = len(data_loader)
print('#training images = %d' % dataset_size)
print('#training objects = %d' % opt.nTrainObjects)
## validation dataset
if opt.compute_val:
opt_validation = copy.copy(opt) # create a clone
opt_validation.phase = 'val'
opt_validation.serial_batches = True
opt_validation.isTrain = False
data_loader_validation = CreateDataLoader(opt_validation)
dataset_validation = data_loader_validation.load_data()
dataset_size_validation = len(data_loader_validation)
print('#validation images = %d' % dataset_size_validation)
print('#validation objects = %d' % opt_validation.nValObjects)
# model
model = create_model(opt)
