def reference():
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
model = create_model(opt) # create a model given opt.model and other options
model.setup(opt) # regular setup: load and print networks; create schedulers
# create a website
web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.epoch)) # define the website directory
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.
# For [pix2pix]: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# For [CycleGAN]: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
if opt.eval:
model.eval()
for i, data in enumerate(dataset):
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
model.set_input(data) # unpack data from data loader
model.test() # run inference
visuals = model.get_current_visuals() # get image results
img_path = model.get_image_paths() # get image paths
if i % 5 == 0: # save images to an HTML file
print('processing (%04d)-th image... %s' % (i, img_path))
save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize)
webpage.save() # save the HTML
def load_cyclegan_with_path(path='cyclegan_baddies_c_1_a'):
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
opt.dataroot = "./test_image"
opt.load_size = 256
opt.crop_size = 256
opt.gpu_ids = '0'
# opt.gpu_ids = ''
opt.name = path
opt.eval = True
torch.cuda.set_device(0)
# create a dataset given opt.dataset_mode and other options
model = create_model(
opt) # create a model given opt.model and other options
model.setup(opt)
model.eval()
cyclegan_dict[path] = model
cyclegan_opts[path] = opt
def run_example(output=None, script=True):
args = "--dataroot datasets/horse2zebra/testA --name horse2zebra_pretrained --model test --no_dropout"
opt = TestOptions().parse(args.split(' '))
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
model = create_model(
opt) # create a model given opt.model and other options
data = torch.load('example_input.pt')
if script:
print("running scripted...")
m = torch.jit.script(model.netG.module)
ip = data['A'].cuda()
output_tensor = m(ip)
else:
print("running eager...")
model.set_input(data)
model.test()
visuals = model.get_current_visuals() # get image results
output_tensor = visuals['fake']
if output is not None:
torch.save(output_tensor, output)
def config_models_and_datasets(model_names, folder):
opt = None
models = dict()
for name in model_names:
sys.argv = sys.argv[:1]
sys.argv.append("--dataroot")
sys.argv.append(folder)
sys.argv.append("--name")
sys.argv.append(name)
sys.argv.append("--model")
sys.argv.append("test")
sys.argv.append("--no_dropout")
opt = TestOptions().parse()
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 0
opt.batch_size = 1 # test code only supports batch_sized = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
model = create_model(opt)
model.setup(opt)
models[name] = model
print(f"model {name} instantiated")
dataset = create_dataset(opt)
return dataset, models
def Predict():
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
model = create_model(opt) # create a model given opt.model and other options
model.setup(opt) # regular setup: load and print networks; create s
pickle_in = open("emb.pickle", "rb")
emb = pickle.load(pickle_in)
for data in emb:
if data['B_paths'][0].split('/')[-1] != e.get().split('/')[-1]: continue # compare with the user selected file to get the embedding
model.set_input(data) # unpack data from data loader
model.test() # run inference
visuals = model.get_current_visuals() # get image results
im = save_images(visuals)
img = Image.fromarray(im)
img = ImageTk.PhotoImage(img)
canvas.image = img # <--- keep reference of your image
canvas.create_image(2, 2, anchor='nw', image=img)
def run_test(epoch=-1, is_val=True):
print('Running Test')
opt = TestOptions().parse()
# No shuffling for test set
opt.serial_batches = True
opt.which_epoch = epoch
# Set batch_size to 1
opt.batch_size = 1
# If we are running on the test set change the folder path to where the test meshes are stored
if not is_val:
opt.phase = "test"
dataset = DataLoader(opt)
if opt.verbose:
print("DEBUG testpath: ", opt.dataroot)
print("DEBUG dataset length ", len(dataset))
model = create_model(opt)
writer = Writer(opt)
writer.reset_counter()
for i, data in enumerate(dataset):
model.set_input(data)
ncorrect, nexamples = model.test(epoch, is_val)
if opt.verbose:
print("DEBUG test ncorrect, nexamples ", ncorrect, nexamples)
writer.update_counter(ncorrect, nexamples)
writer.print_acc(epoch, writer.acc)
return writer.acc
def main():
cfg = TestOptions().parse() # get training options
cfg.NUM_GPUS = torch.cuda.device_count()
cfg.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
cfg.no_flip = True # no flip; comment this line if results on flipped images are needed.
cfg.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
cfg.phase = 'test'
cfg.batch_size = int(cfg.batch_size / max(1, cfg.NUM_GPUS))
launch_job(cfg=cfg, init_method=cfg.init_method, func=test)
def get_test_opt():
opt = TestOptions().parse()
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
result_root = os.path.join(opt.results_dir, opt.name)
if not os.path.exists(result_root):
os.makedirs(result_root)
return opt
def uploadFile():
f = request.files['file']
global fileName
fileName = f.filename[0:-4]
f.save(os.path.join(app.config['UPLOAD_FOLDER'], f.filename))
opt = TestOptions().parse()
opt.num_threads = 0
opt.batch_size = 1
opt.serial_batches = True
opt.no_flip = True
opt.display_id = -1
return opt
def inferViability(self, BrightfieldPath, GeneratedPath, results_dir, checkpoint_dir, experiment_name):
print(BrightfieldPath)
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.num_test = len(list(BrightfieldPath.glob('**/*')))
opt.dataroot = BrightfieldPath
opt.checkpoints_dir = checkpoint_dir
opt.name = experiment_name
opt.results_dir = results_dir
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
model = create_model(opt) # create a model given opt.model and other options
model.setup(opt) # regular setup: load and print networks; create schedulers
# if opt.eval:
# print('yes')
# model.eval()
storeCellCount = {}
for i, data in enumerate(dataset):
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
model.set_input(data) # unpack data from data loader
#model.test() # run inference
try:
model.testCell() #runs generator (forward) and discriminator(forwardD)
fakeCellCount = model.fake_pred_cellCount.item()
#visuals = model.get_current_visuals() # get image results
img_path = model.get_image_paths() # get image paths
fileName = Path(img_path[0]).stem
fake_img = model.fake_B
self.saveImages(fake_img,GeneratedPath,fileName)
if fileName in storeCellCount:
storeCellCount[fileName].append([fakeCellCount])
else:
storeCellCount[fileName]= [fakeCellCount]
except KeyError:
pass
if i % 5 == 0:
print('processing (%04d)-th image... %s' % (i, img_path))
self._toJson(opt.results_dir,storeCellCount,'viability')
def config_datasets():
sys.argv = sys.argv[:1]
sys.argv.append("--dataroot")
sys.argv.append(temp_folder)
sys.argv.append("--model")
sys.argv.append("test")
sys.argv.append("--no_dropout")
opt = TestOptions().parse()
opt.num_threads = 0 # test code only supports num_threads = 0
opt.batch_size = 1 # test code only supports batch_sized = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
return create_dataset(opt)
def __init__(self, options, verbose=False):
opt = TestOptions(options).parse(verbose=verbose) # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
model = create_model(
opt) # create a model given opt.model and other options
model.setup(
opt) # regular setup: load and print networks; create schedulers
model.eval()
self.opt, self.model = opt, model
self.totensor = ToTensor()
self.normalize = Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
def test_red_seal():
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 0
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
opt.name = "document_pix2pix"
opt.model = "pix2pix"
opt.netG = "unet_256"
opt.direction = "AtoB"
opt.norm = "batch"
model = create_model(
opt) # create a model given opt.model and other options
model.setup(
opt) # regular setup: load and print networks; create schedulers
if opt.eval:
model.eval()
# img_path = "test/input/343abe6f-9e28-4813-b87a-cdb098f8c17f_page1.jpg"
# img_path = "test/input/保利文化集团股份有限公司2019年第三季度财务报表-3.jpg"
# img_path = "test/input/常州天宁建设发展集团有限公司2019年三季度合并及母公司财务报表-0.jpg"
# img_path = "test/input/常州市晋陵投资集团有限公司2019年三季度合并及母公司财务报表-0.jpg"
# img_path = "test/input/重庆市万盛经济技术开发区开发投资集团有限公司2019年三季度财务报表-1.jpg"
img_path = "test/input/重庆市万盛经济技术开发区开发投资集团有限公司2019年三季度财务报表-2.jpg"
res_img_dir = "test/output"
signet_offsets = [(200, 100, 712, 612), (500, 100, 1012, 612),
(200, 100, 712, 612), (200, 100, 712, 612),
(1000, 200, 1512, 712), (1500, 100, 2012, 612)]
os.makedirs(res_img_dir, exist_ok=True)
img_path_list = [img_path]
import time
for img_path in img_path_list:
img = Image.open(img_path).convert("RGB")
a_img = img.crop(signet_offsets[5])
t0 = time.time()
transform = default_transform()
A = transform(a_img)
A = torch.unsqueeze(A, dim=0)
A = A.to(torch.device("cuda:0"))
fake_B = model.netG(A)
res_B = tensor2im(fake_B)
image_pil = Image.fromarray(res_B)
print("cost:{}".format(time.time() - t0))
out_img_path = os.path.join(res_img_dir, os.path.basename(img_path))
image_pil.save(out_img_path)
def cycle_gan_model(model):
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 0
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
opt.name = model
model = create_model(
opt) # create a model given opt.model and other options
model.setup(
opt) # regular setup: load and print networks; create schedulers
if opt.eval:
model.eval(
) # regular setup: load and print networks; create schedulers
return model
def load_model_with_options():
"""
Load the model details
"""
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 0
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
# dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
model = create_model(
opt) # create a model given opt.model and other options
model.setup(
opt) # regular setup: load and print networks; create schedulers
return opt, model
def get_model(script):
args = f"--dataroot {os.path.dirname(__file__)}/datasets/horse2zebra/testA --name horse2zebra_pretrained --model test --no_dropout"
opt = TestOptions().parse(args.split(' '))
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
model = create_model(
opt) # create a model given opt.model and other options
model = model.netG.module
data = torch.load('example_input.pt')
input = data['A'].cuda()
if script:
model = torch.jit.script(model)
return model, (input, )
def my_create_model():
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
opt.name = "shape02shape1_noflip_cyclegan" # model checkpoint saved
opt.model = "cycle_gan"
opt.phase = "test"
opt.no_dropout = True
opt.dataset_mode = "unaligned"
opt.dataroot = "./tmp"
model = create_model(opt)
model.setup(opt)
return opt, model
def setup(opts):
generator_checkpoint_path = opts['generator_checkpoint']
try:
os.makedirs('checkpoints/pretrained/')
except OSError:
pass
shutil.copy(generator_checkpoint_path, 'checkpoints/pretrained/latest_net_G.pth')
opt = TestOptions(args=['--dataroot', '',
'--name', 'pretrained',
'--model', 'test',
'--no_dropout']).parse()
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
opt.preprocess = 'none' # Don't resize to a square
model = create_model(opt)
model.setup(opt)
return {'model': model, 'opt': opt}
def get_cycled_data(video_id,label_id):
data_input_path = '../../../dataset/rendered_video/output_img/{}'.format(video_id)
data_output_path = '../../../dataset/cycled_video/cycled_img'
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.dataroot = data_input_path
opt.results_dir = data_output_path
opt.checkpoints_dir = '/scr1/system/alpha-robot/script/video_cycle/pytorch-CycleGAN-and-pix2pix/checkpoints/{}'.format(video_id)
# opt.checkpoints_dir = '/scr1/system/alpha-robot/script/video_cycle/pytorch-CycleGAN-and-pix2pix/checkpoints/{}'.format('merge')
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
model = create_model(opt) # create a model given opt.model and other options
model.setup(opt) # regular setup: load and print networks; create schedulers
# create a website
web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.epoch)) # define the website directory
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.
# For [pix2pix]: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# For [CycleGAN]: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
if opt.eval:
model.eval()
for i, data in enumerate(dataset):
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
model.set_input(data) # unpack data from data loader
model.test() # run inference
visuals = model.get_current_visuals() # get image results
img_path = model.get_image_paths() # get image paths
if i % 5 == 0: # save images to an HTML file
print('processing (%04d)-th image... %s' % (i, img_path))
save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize)
webpage.save() # save the HTML
video_id,data_num = select_only_B(data_output_path)
with open(os.path.join(data_output_path,'video_list.txt'),'w') as file:
file.write('{} {} {}'.format(video_id,data_num,label_id))
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 test_real_dataset():
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 0
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
opt.name = "document_pix2pix_best"
opt.model = "pix2pix"
opt.netG = "unet_256"
opt.direction = "AtoB"
opt.norm = "batch"
model = create_model(
opt) # create a model given opt.model and other options
model.setup(
opt) # regular setup: load and print networks; create schedulers
if opt.eval:
model.eval()
img_path = "/data/zhoubingcheng/signet_testdata/testimgs/39b5e538-18c0-11eb-b96f-02420a019fc9_page10.jpeg"
res_img_dir = "test/output2"
os.makedirs(res_img_dir, exist_ok=True)
img_path_list = [img_path]
import time
for img_path in img_path_list:
img = Image.open(img_path).convert("RGB")
w, h = img.size
a_img = img.crop((0, 0, 1024, 1024))
t0 = time.time()
transform = default_transform()
A = transform(a_img)
A = torch.unsqueeze(A, dim=0)
A = A.to(torch.device("cuda:0"))
fake_B = model.netG(A)
res_B = tensor2im(fake_B)
image_pil = Image.fromarray(res_B)
print("cost:{}".format(time.time() - t0))
out_img_path = os.path.join(res_img_dir, os.path.basename(img_path))
image_pil.save(out_img_path)
def test_discriminator():
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
opt.isTrain = True
opt.gan_mode = "lsgan"
model = create_model(opt) # create a model given opt.model and other options
model.setup(opt) # regular setup: load and print networks; create schedulers
# test with eval mode. This only affects layers like batchnorm and dropout.
# For [pix2pix]: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# For [CycleGAN]: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
if opt.eval:
model.eval()
for i, data in enumerate(dataset):
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
model.set_input(data) # unpack data from data loader
real_AB = torch.cat((model.real_A, model.real_B), 1) # we use conditional GANs; we need to feed both input and output to the discriminator
pred = model.netD(real_AB.detach())
print("Image {}: discriminator: {}".format(i, pred.mean()))
def main():
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
dataset = create_dataset(
opt) # create a dataset given opt.dataset_mode and other options
sample_rate = opt.sample_rate
model = create_model(
opt) # create a model given opt.model and other options
model.setup(
opt) # regular setup: load and print networks; create schedulers
mkdir(opt.results_dir)
# create a website
# web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.epoch)) # define the website directory
# 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.
# For [pix2pix]: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# For [CycleGAN]: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
if opt.eval:
model.eval()
for i, data in enumerate(dataset):
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
model.set_input(data) # unpack data from data loader
model.test() # run inference
clips = model.get_current_audio() # get image results
img_path = model.get_clip_paths() # get image paths
iter_dir = os.path.join(opt.results_dir, "{:03d}".format(i))
mkdir(iter_dir)
for name, y in clips.items():
librosa.output.write_wav(
os.path.join(iter_dir, '{}.wav'.format(name)), y, sample_rate)
from flask import Flask, request, Response, send_from_directory
from flask_cors import CORS
import time
import random
from options.test_options import TestOptions
from data import create_dataset
from models import create_model
from util.visualizer import save_images
from util import htmls
from util import util
opt = TestOptions().parse(infer=True)
# 直接指定一些选项进行测试
opt.num_threads = 0 # 测试时 DataLoader 仅支持 num_threads = 0
opt.batch_size = 1 # 测试时batch_size设为1
opt.serial_batches = True # 关闭数据 shuffling; 需要随机选择图片时再打开
opt.no_flip = True # no flip; 如果需要翻转图片，注释本行
opt.display_id = -1 # no visdom display; 测试时将结果保存入 HTML 文件
model = create_model(opt) # 根据 opt.model 和其他选项创建 model 实例
model.setup(opt) # 常规设置: 加载和打印网络; 创建 schedulers
model.eval()
static_folder = 'static'
app = Flask(__name__, static_folder=static_folder)
CORS(app)
@app.route('/', methods=['GET'])
def index():
# output = torch.argmax(output, dim=1)
fake_ED_M = fake_ED_M.data.to('cpu').numpy()
fake_ES_M = fake_ES_M.data.to('cpu').numpy()
fake_ED_2 = fake_ED_2.data.to('cpu').numpy()
fake_ES_2 = fake_ES_2.data.to('cpu').numpy()
flow_2 = flow_2.data.to('cpu').numpy()
warp_img = warp_img.data.to('cpu').numpy()
warped_mask = warped_mask.data.to('cpu').numpy()
return np.concatenate([fake_ED_M, fake_ES_M, fake_ED_2, fake_ES_2, flow_2, warp_img, warped_mask], axis=1)
if __name__ == '__main__':
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
# dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
# create a website
web_dir = os.path.join(opt.results_dir, opt.name, '%s_%s' % (opt.phase, opt.epoch)) # define the website directory
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.
# For [pix2pix]: we use batchnorm and dropout in the original pix2pix. You can experiment it with and without eval() mode.
# For [CycleGAN]: It should not affect CycleGAN as CycleGAN uses instancenorm without dropout.
output_dir = './output'
spacing_target = (10, 1.25, 1.25)
window_size = 256
stride = 128
(1, 2, 3)).tolist()
else:
g += code.view(code.size(0), -1).cpu().numpy().tolist()
tlbl += (lbl == cname).numpy().tolist()
tloss += np.mean(((out.cpu() - data).numpy())**2,
(1, 2, 3)).tolist()
#visuals = model.get_current_visuals()
#img_path = model.get_image_paths()
#save_images(webpage, visuals, img_path, aspect_ratio=opt.aspect_ratio, width=opt.display_winsize)
# save the website
#webpage.save()
output['test'] = g
output['lbl'] = tlbl
io.savemat('feat.mat', output)
fpr, tpr, _ = roc_curve(tlbl, tloss, 0)
roc_auc1 = auc(fpr, tpr)
return (roc_auc1)
if __name__ == '__main__':
opt = TestOptions().parse()
opt.dataroot = 'nol'
opt.batch_size = 256
opt.fineSize = 32
opt.input_nc = 3
opt.output_nc = 3
opt.ngf = 64
opt.name = 'cifar_AE8'
roc = run(opt)
for label, im_data in visuals.items():
im = util.tensor2im(im_data)
save_path = os.path.join(output_dir, file_name)
util.save_image(im, save_path, aspect_ratio=aspect_ratio)
if __name__ == '__main__':
opt = TestOptions().parse()
models_list = [
'style_monet_pretrained', 'style_vangogh_pretrained',
'style_ukiyoe_pretrained', 'style_cezanne_pretrained'
]
for style_id, premodel in enumerate(models_list):
opt.name = premodel
opt.num_threads = 0
opt.batch_size = 1
opt.serial_batches = True
opt.no_flip = True
opt.display_id = -1
file_name = str(style_id + 1) + '.png'
results_dir = opt.results_dir
if not os.path.exists(results_dir):
os.makedirs(results_dir)
dataset = create_dataset(opt)
model = create_model(opt)
model.setup(opt)
if opt.eval:
model.eval()
from util.visualizer import Visualizer
import os
import numpy as np
import torch
import torchvision
import torchvision.transforms as transforms
import scipy.io as sio
import models.channel as chan
import shutil
from pytorch_msssim import ssim, ms_ssim, SSIM, MS_SSIM
import math
# Extract the options
opt = TestOptions().parse()
opt.batch_size = 1 # batch size
if opt.dataset_mode == 'CIFAR10':
opt.dataroot = './data'
opt.size = 32
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])
testset = torchvision.datasets.CIFAR10(root='./data',
train=False,
download=True,
transform=transform)
dataset = torch.utils.data.DataLoader(testset,
batch_size=opt.batch_size,
def main():
opt = TestOptions().parse() # get test options
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 0
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
model = create_model(
opt) # create a model given opt.model and other options
model.setup(
opt) # regular setup: load and print networks; create schedulers
dataset = create_dataset(
opt) # create a dataset given opt.dataset_mode and other options
pix2pix_image = np.zeros((model_image_size, model_image_size, 3), np.uint8)
start_time = time.time()
x = 5 # displays the frame rate every 1 second
counter = 0
while True:
# ZMQ Subscribe convert incoming bytes to PIL and then to CVImage
frame = socketSubscribe.recv()
if len(frame) > 10:
pil_image = Image.frombytes('RGBA',
(model_image_size, model_image_size),
frame, 'raw').convert('RGB')
# learntest
#model.update_learning_rate()
for i, data in enumerate(dataset):
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
model.set_input(data,
pil_image) # unpack data from data loader
# learntest
#model.optimize_parameters()
model.test() # run inference
visuals = model.get_current_visuals() # get image results
for label, im_data in visuals.items():
im = util.tensor2im(im_data)
open_cv_image = numpy.array(im)
open_cv_image = open_cv_image[:, :, ::-1].copy()
pix2pix_image = open_cv_image
#dim = (256,256)
#blank_image = cv2.resize(blank_image, dim, interpolation = cv2.INTER_AREA)
socketPublish.send(pix2pix_image)
cv2.imshow("image", pix2pix_image)
cv2.waitKey(1)
counter += 1
if (time.time() - start_time) > x:
print("FPS: ", counter / (time.time() - start_time))
counter = 0
start_time = time.time()
def main():
opt = TestOptions().parse() # get test options
opt.netG = 'unet_128'
gen_jison = False
if gen_jison:
vis = False
opt.num_test=50000
else:
vis = True
opt.num_test = 300
# hard-code some parameters for test
opt.num_threads = 0 # test code only supports num_threads = 1
opt.batch_size = 1 # test code only supports batch_size = 1
opt.serial_batches = True # disable data shuffling; comment this line if results on randomly chosen images are needed.
opt.no_flip = True # no flip; comment this line if results on flipped images are needed.
opt.display_id = -1 # no visdom display; the test code saves the results to a HTML file.
dataset = create_dataset(opt) # create a dataset given opt.dataset_mode and other options
model = create_model(opt) # create a model given opt.model and other options
print(model.__dict__)
model.setup(opt) # regular setup: load and print networks; create schedulers
kwargs = {
"thred_dyn": 50,
"ksize_dyn": 100,
"ksize_close": 30,
"ksize_open": 3,
}
detector = DefectDetector(**kwargs)
if opt.eval:
model.eval()
for i, data in enumerate(dataset):
if i >= opt.num_test: # only apply our model to opt.num_test images.
break
# print(i)
paths = data["A_paths"]
print(paths)
# print(len(paths))
model.set_input(data) # unpack data from data loader
model.test() # run inference
visuals = model.get_current_visuals() # get image results
imgee_show=cv2.imread(paths[0])
# print(visuals["pre_score"])
cv2.imshow('image',imgee_show)
cv2.waitKey()
image_batch = visuals["real_A"]
reconst_batch = visuals["fake_B"]
# B_mask=data["B_mask"]
image_batch = image_batch.detach().cpu().numpy()
# label_batch = B_mask.detach().cpu().numpy()
reconst_batch = reconst_batch.detach().cpu().numpy()
# batchs=detector.apply(image_batch,label_batch,reconst_batch)
batchs = detector.ztb_rangd2_apply(image_batch, image_batch, reconst_batch)
image_high=128
image_width=128
image_name=paths[0].split('/')[-1].split('.')[0]
image=batchs[-1].squeeze()
# print(image.shape)
# cv2.imshow('image',image)
# cv2.waitKey(3)
submit(image_high,image_width,image_name,image)
if vis:
for idx, path in enumerate(paths):
visual_imgs = []
for batch in batchs:
visual_imgs.append(batch[idx].squeeze())
img_visual = detector.concatImage(visual_imgs, offset=None)
# print(img_visual.size)
visualization_dir = opt.checkpoints_dir + "/infer_epoch{}/".format(opt.load_iter)
if not os.path.exists(visualization_dir):
os.makedirs(visualization_dir)
img_visual.save(visualization_dir + "_".join(path.split("/")[-2:]))
print(i)