def __getitem__(self, index): img_name = self.imgs[index] img = jpg_loader(os.path.join(self.root_img, img_name)) if not self.is_predict: label = self.labels[index] img_mask_name = get_image_mask_name(self.root_img_mask, img_name) img_mask = gif_loader(os.path.join(self.root_img_mask, img_mask_name)) if self.transform_img: for tran in self.transform_img: img, img_mask = tran(img, img_mask) img = img.resize((1024, 512), Image.BILINEAR) img_arr = np.asarray(img) / 255.0 img_mask = img_mask.resize((1024, 512), Image.BILINEAR) img_mask_arr = np.asarray(img_mask) if self.transform: for tran in self.transform: img_arr, img_mask_arr = tran(img_arr, img_mask_arr) img_mask_tensor = label_to_tensor(img_mask_arr) img_tensor = image_to_tensor(img_arr) return img_tensor, label, img_mask_tensor else: img = img.resize((1024, 512), Image.BILINEAR) img_arr = np.asarray(img) / 255.0 if self.transform: for tran in self.transform: img_arr = tran(img_arr) img_tensor = image_to_tensor(img_arr) return img_tensor,img_name
def style_transfer_image(args): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") image = Image.open(args.content_target) size = image.size content_target = image_to_tensor(image, size).to(device) style_targets = [ image_to_tensor(Image.open(image), size).to(device) for image in args.style_targets ] n = len(style_targets) style_weights = np.ones( n) / n if args.style_weights is None else args.style_weights input_image = content_target.clone().to(device) neural_style = NeuralStyle(content_layers=CONTENT_LAYERS, style_layers=STYLE_LAYERS) neural_style.content_target = content_target neural_style.set_style_targets(style_targets, style_weights) output_image, _ = neural_style.transfer( input_image=input_image, epochs=args.epochs, style_weight=args.style_weight, content_weight=args.content_weight, verbose=args.verbose, ) to_image(output_image, size=size).save(args.output)
def detect(self, filename, answer_text, verbose=False, layer_index=-1, mode="local"): if mode == "local": input_tensor = image_to_tensor(filename, self.img_height, self.img_width) else: # if True: try: input_tensor = image_to_tensor(filename, self.img_height, self.img_width) except: raise ValueError("This URL is not supported!! Use other one.") detection = self.model.predict(input_tensor)[0] a = np.array(detection) detect_label = self.labels[a.argmax(0)] if verbose is True: print("結果 .... " + str(answer_text[detect_label])) img1 = vis_utils.load_img(filename, target_size=(self.img_height, self.img_width)) # Swap softmax with linear layer_idx = vis_utils.find_layer_idx(self.model, 'predictions') self.model.layers[layer_idx].activation = activations.linear vis_model = vis_utils.apply_modifications(self.model) filter_index = a.argmax(0) grads = visualize_cam( vis_model, layer_idx, filter_index, #クラス番号 img1[:, :, :], backprop_modifier='guided') a = np.array(detection) fig = plt.figure(figsize=(10, 5)) ax1 = fig.add_subplot(1, 2, 1) ax1.tick_params(labelbottom="off", bottom="off") ax1.grid(False) ax1.tick_params(labelleft="off", left=False) plt.yticks(color="None") ax1.set_xticklabels([]) ax1.imshow(img1) ax1.imshow(grads, cmap='jet', alpha=0.6) ax1.set_title("Heat Map") sns.set(style="white", context="talk") f, ax1 = plt.subplots(1, 1, figsize=(8, 6), sharex=True) sns.barplot(self.labels, detection, palette="PiYG", ax=ax1) ax1.set_ylabel("Value") plt.tick_params(length=0) plt.grid(False) plt.show() else: print(detect_label) print(detection) print("detectメソッドが完了しました.")
def on_epoch_end(self, epoch, logs={}): clear_output(wait = True) index = 1 print('------------------------------------------------------------------------------------------------') print('------------------------------------------------------------------------------------------------') if self.verbose is True: for image in self.test_img_list: if self.color_mode == "rgb": input_tensor = image_to_tensor(image, self.img_height, self.img_width) elif self.color_mode == "grayscale": input_tensor = image_to_tensor(image, self.img_height, self.img_width, color_mode="grayscale") detection = self.model.predict(input_tensor)[0] layer_idx = utils.find_layer_idx(self.model, 'predictions') test_label = image.split("/")[-2] filter_index = self.labels.index(test_label) print(filter_index) img1 = utils.load_img(image, target_size=(self.img_height, self.img_width)) grads = visualize_cam( self.model, layer_idx, filter_indices=None, seed_input=img1, backprop_modifier='guided' ) print('\nIndex' + str(index)) print(detection) a = np.array(detection) print('Estimation:' + self.labels[a.argmax(0)]) fig = plt.figure(figsize=(10, 5)) ax1 = fig.add_subplot(1, 2, 1) ax1.tick_params(labelbottom="off",bottom="off") ax1.tick_params(labelleft="off",left="off") ax1.set_xticklabels([]) ax1.imshow(overlay(grads, img1)) ax2 = fig.add_subplot(1, 2, 2) ax2.tick_params(labelbottom="off",bottom="off") ax2.tick_params(labelleft="off",left="off") ax2.set_xticklabels([]) ax2.imshow(Image.open(image)) plt.show() sns.set(style="white", context="talk") f, ax1 = plt.subplots(1, 1, figsize=(8, 6), sharex=True) sns.barplot(self.labels, detection, palette="PiYG", ax=ax1) ax1.set_ylabel("Value") plt.show() index = index + 1 if self.now_epoch % 5 == 0 or self.now_epoch == 1: _index = str(self.now_epoch) if self.now_epoch < 10: _index = "0" + _index self.model.save("./models/"+ self.task_name+"/"+"epoch_"+ _index +".hdf5") self.now_epoch = self.now_epoch + 1
def on_epoch_end(self, epoch, logs={}): if self.color_mode == "rgb": input_tensor = image_to_tensor(self.test_img_path, self.img_height, self.img_width) elif self.color_mode == "grayscale": input_tensor = image_to_tensor(self.test_img_path, self.img_height, self.img_width, color_mode="grayscale") detection = self.model.predict(input_tensor)[0] a = np.array(detection) sns.set(style="white", context="talk") f, ax1 = plt.subplots(1, 1, figsize=(8, 6), sharex=True) gif_img = sns.barplot(self.labels, detection, palette="PiYG", ax=ax1) self.gif_images.append([gif_img])
async def face(ctx: discord.ext.commands.Context) -> None: """Create the reaction panel for attribute selection.""" try: # Fetch the sent image url = ctx.message.attachments[0].url image = Image.open(requests.get(url, stream=True).raw) except: # Image could not be found await ctx.send(error_message) return # If the image is a PNG file, it will have 4 channels # The model cannot handle 4 channels, so convert it to 3 image = image.convert('RGB') bot.image_data = image_to_tensor(image, bot.config) # Guess labels with discriminator _, labels = bot.discriminator(bot.image_data) # Round labels to 0 and 1 bot.labels = (labels > 0.5).float() bot.sent_panel = await ctx.send(embed=get_info_panel()) # Add reactions for emoji in bot.label_emojis: await bot.sent_panel.add_reaction(emoji) await bot.sent_panel.add_reaction(bot.go_emoji)
def disrupt_stimuli(save_folder, inputs_and_targets, encoder, roi_mask, target_roi, loss_method): roi_mask = torch.from_numpy(roi_mask.astype(np.uint8)) towards_target = True if loss_method == 'towards' else False if not target_roi: loss_func = roi_loss_func(None, towards_target) else: loss_func = roi_loss_func(roi_mask, towards_target) for input_and_target in tqdm(inputs_and_targets): orig_image = input_and_target['stimulus_path'] orig_image = utils.image_to_tensor(orig_image) target = input_and_target['target_voxels'] target = torch.from_numpy(target) if not target_roi: target = target[roi_mask] else: with torch.no_grad(): orig_voxels = encoder(orig_image.unsqueeze(0)).squeeze(0) target[1 - roi_mask] = orig_voxels[1 - roi_mask] disrupted_image = deepdream(orig_image, target, encoder, loss_func) metrics = loss_metrics(orig_image, disrupted_image, target, encoder, roi_mask if target_roi else None) disrupted_image = utils.tensor_to_image(disrupted_image) save_disrupted_image(save_folder, input_and_target, disrupted_image, metrics)
def detect(self, filename): input_tensor = image_to_tensor(filename, self.img_height, self.img_width) detection = self.model.predict(input_tensor)[0] a = np.array(detection) detect_label = self.labels[a.argmax(0)] print(detect_label) print(detection)
def style_transfer_video(args): device = torch.device("cuda" if torch.cuda.is_available() else "cpu") loader = transforms.ToPILImage() reader = imageio.get_reader(args.content_target) frames = [ image_to_tensor(loader(reader.get_data(i)), (512, 512)) for i in range(reader.count_frames()) ] style_targets = [ image_to_tensor(Image.open(image), (512, 512)) for image in args.style_targets ] style_weights = np.linspace(0, 1, num=len(frames)) neural_style = NeuralStyle(content_layers=CONTENT_LAYERS, style_layers=STYLE_LAYERS).to(device) input_image = frames[0].to(device) outputs = [] for i in trange(len(frames)): neural_style.content_target = frames[i].to(device) neural_style.set_style_targets( style_targets, [1 - style_weights[i], style_weights[i]]) output_image = neural_style.transfer( input_image=input_image, epochs=args.epochs, style_weight=args.style_weight, content_weight=args.content_weight, verbose=args.verbose, ) # del frames[i] input_image = output_image.clone().to(device) outputs.append(output_image.to("cpu")) del output_image writer = imageio.get_writer("output.mp4", fps=reader.get_meta_data()["fps"]) shape = reader.get_data(0).shape[:2] outputs = [to_image(output, (shape[1], shape[0])) for output in outputs] for output in outputs: writer.append_data(np.asarray(output)) writer.close()
def on_epoch_end(self, epoch, logs={}): index = 1 for image in self.test_img_list: if self.color_mode == "rgb": input_tensor = image_to_tensor(image, self.img_height, self.img_width) elif self.color_mode == "grayscale": input_tensor = image_to_tensor(image, self.img_height, self.img_width, color_mode="grayscale") detection = self.model.predict(input_tensor)[0] print '\nIndex %d' % index print detection a = np.array(detection) print '予測: %s' % self.labels[a.argmax(0)] display(Image(filename=image, width=300, height=300)) sns.set(style="white", context="talk") f, ax1 = plt.subplots(1, 1, figsize=(8, 6), sharex=True) sns.barplot(self.labels, detection, palette="PiYG", ax=ax1) ax1.set_ylabel("Value") plt.show() index = index + 1 self.now_epoch = self.now_epoch + 1
def condition_features(stimuli, model): print('Extracting features') condition_features = [] batch_size = 32 for i in tqdm(range(0, len(stimuli), batch_size)): batch_names = stimuli[i:i + batch_size] batch = [utils.image_to_tensor(s, resolution=256) for s in batch_names] batch = torch.stack(batch) if torch.cuda.is_available(): batch = batch.cuda() with torch.no_grad(): batch_feats = model(batch).cpu().numpy() condition_features.append(batch_feats) condition_features = np.concatenate(condition_features) return condition_features
def stimulus_predictions(stimuli_folder, model): print('Extracting features') stimuli = os.listdir(stimuli_folder) condition_features = {} batch_size = 32 for i in tqdm(range(0, len(stimuli), batch_size)): batch_names = stimuli[i:i + batch_size] batch = [utils.image_to_tensor(os.path.join(stimuli_folder, n), resolution=resolution) for n in batch_names] batch = torch.stack(batch) if torch.cuda.is_available(): batch = batch.cuda() with torch.no_grad(): batch_feats = model(batch).cpu().numpy() for name, feats in zip(batch_names, batch_feats): condition_features[name] = feats return condition_features
def main(): parser = ArgumentParser(description='Validate model on .png files') parser.add_argument('-m', type=str, required=False, default=None, help='Model to validate') parser.add_argument('input_dir', type=str, help='Input directory') parser.add_argument('target_dir', type=str, help='Output directory') args = parser.parse_args() device = get_device() model, _, _ = load_model(load_config().model if args.m is None else args.m, device=device) loss_f = BCELoss() count, loss_sum, acc_sum = 0, 0, 0 with torch.no_grad(): for fn in listdir(args.input_dir): input_path = join(args.input_dir, fn) target_path = join(args.target_dir, fn) if fn.endswith('.png') and isfile(input_path) and isfile( target_path): print('Validating %s with target %s' % (input_path, target_path)) data = image_to_tensor(imread(input_path), device=device) target = image_to_probs(imread(target_path), device=device) data = model(data).squeeze(0) loss = loss_f(data, target).item() acc = check_accuracy(data, target) print('Loss %f, acc %s' % (loss, acc_to_str(acc))) count += 1 acc_sum += acc loss_sum += loss print('\nSUMMARY\nLoss %f, acc %s' % (loss_sum / count, acc_to_str(acc_sum))) print(acc_to_details(acc_sum))
dir = '/home/eelmozn1/datasets/adversarial_tms' datasets = ['scenecats'] feature_names = ['conv_3'] rois = ['LOC', 'PPA', 'RANDOM'] resolution = 256 for feat_name in feature_names: for roi in rois: encoder = torch.load( 'saved_models/study=bold5000_featextractor=alexnet_featname={}_rois={}.pth' .format(feat_name, roi), map_location=lambda storage, loc: storage) for dataset in datasets: data_dir = os.path.join(dir, dataset) target_dir = os.path.join( dir, 'targets_bold5000', '{}_roi={}_feat={}'.format(dataset, roi, feat_name)) os.mkdir(target_dir) folder_names = os.listdir(data_dir) folder_names = [f for f in folder_names if f != '.DS_Store'] for name in folder_names: folder = os.path.join(data_dir, name) image_paths = utils.listdir(folder) images = torch.stack([ image_to_tensor(path, resolution=resolution) for path in image_paths ]) target = encoder(images).mean(dim=0) torch.save(target, os.path.join(target_dir, name + '.pth'))
def _resized_S(self, size): return utils.image_to_tensor(self.source_image, [transforms.Resize(size)])
def run(self): S = utils.image_to_tensor(self.source_image) R = utils.image_to_tensor(self.style_image) print(S) self._color_transfer(S, R)
image_path = '/home/eelmozn1/datasets/adversarial_tms/scenecats/3-3-japaneseroom/3-3-japaneseroom_9.jpg' save_folder = '/home/eelmozn1/Desktop/parameter_sweep' encoder_file = 'study=bold5000_featextractor=alexnet_featname=conv_3_rois=PPA.pth' generator = DeePSiM() encoder = torch.load(os.path.join('saved_models', encoder_file), map_location=lambda storage, loc: storage) if torch.cuda.is_available(): encoder.cuda() generator.cuda() shutil.rmtree(save_folder, ignore_errors=True) os.mkdir(save_folder) shutil.copyfile(image_path, os.path.join(save_folder, 'original.jpg')) image = image_to_tensor(image_path, resolution=256) with torch.no_grad(): if torch.cuda.is_available(): target = encoder(image.unsqueeze(0).cuda()).squeeze(0).cpu() else: target = encoder(image.unsqueeze(0)).squeeze(0) loss_func = roi_loss_func(roi_mask=None, towards_target=True) gen_images = [] fig, axs = plt.subplots(len(alphas), len(decays), squeeze=False, figsize=(len(decays) * 10, len(alphas) * 5)) for i, alpha in tqdm(enumerate(alphas)): for j, decay in enumerate(decays):
disrupted_stimuli = os.listdir(args.disrupted_folder) disrupted_stimuli = [d for d in disrupted_stimuli if '_disrupted.' in d] original_stimuli = [ d.replace('_disrupted.', '_original.') for d in disrupted_stimuli ] roi_mask = torch.from_numpy( utils.get_roi_mask(args.roi, args.encoder_file).astype(np.uint8)) encoder = torch.load(os.path.join('saved_models', args.encoder_file)) on_roi_distances, off_roi_distances = [], [] for original, disrupted in tqdm( list(zip(original_stimuli, disrupted_stimuli))): original = utils.image_to_tensor(os.path.join(args.disrupted_folder, original), resolution=resolution) disrupted = utils.image_to_tensor(os.path.join(args.disrupted_folder, disrupted), resolution=resolution) with torch.no_grad(): orig_voxels = encoder(original.unsqueeze(0)).squeeze(0) metrics = loss_metrics(original, disrupted, orig_voxels, encoder, roi_mask) on_roi_distances.append(metrics['Disrupted to Target (ON ROI)']) off_roi_distances.append(metrics['Disrupted to Target (OFF ROI)']) plot_compare_dists( on_roi_distances, off_roi_distances, args.roi + ' disruption',
parser.add_argument('--save_folder', required=True, type=str, help='folder to save generated images') parser.add_argument('--image_folder', required=True, type=str, help='images to generate for') parser.add_argument('--model', default='deepsim', type=str, choices=['deepsim', 'biggan'], help='which generator model to use for optimizing images') args = parser.parse_args() shutil.rmtree(args.save_folder, ignore_errors=True) os.mkdir(args.save_folder) encoder = alexnet(pretrained=True) encoder.classifier = encoder.classifier[:-1] encoder.eval() if args.model == 'deepsim': generator = DeePSiM() elif args.model == 'biggan': generator = BigGAN.from_pretrained('biggan-deep-256') if torch.cuda.is_available(): encoder.cuda() generator.cuda() for image_file in tqdm(os.listdir(args.image_folder)): image = image_to_tensor(os.path.join(args.image_folder, image_file), resolution=256) with torch.no_grad(): target = encoder(image.unsqueeze(0)).squeeze(0) target_mean_square = (target ** 2).mean().item() generated_image, _, lowest_loss, _ = optimize(generator, encoder, target, F.mse_loss) generated_image = to_pil_image(generated_image) generated_image.save(os.path.join(args.save_folder, image_file)) print('Lowest loss for {}:\t{}\nMean square of target for {}:\t{}\n' .format(image_file, lowest_loss, image_file, target_mean_square))
parser.add_argument('--input', default='images/LowResolution.png', type=str, help='path to input') parser.add_argument('--input-gt', default='images/SR_GT.png', type=str, help='path to input ground truth') parser.add_argument('--no-cuda', action='store_true', help='disable cuda') parser.add_argument('--output', type=str, help='directory to output') args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() truth = np.array(Image.open(args.input_gt)) target = image_to_tensor(args.input) input_depth = 32 input_size = torch.Size([1, input_depth] + (np.asarray(target.shape[2:]) * 4).tolist()) noise = torch.FloatTensor(input_size).uniform_(0, 0.1) # U(0, 0.1) sigma = 1. / 30 if use_cuda: target = target.cuda() noise = noise.cuda() net = SkipHourglass( input_depth, 3, #down_channels=[8, 16, 32, 64, 128], #up_channels=[8, 16, 32, 64, 128], #skip_channels=[0, 0, 0, 4, 4],
from models import SkipHourglass if __name__ == '__main__': parser = argparse.ArgumentParser(description='Image Denoising') parser.add_argument('--step', default=2400, type=int, help='number of steps') parser.add_argument('--lr', default=1e-2, type=float, help='learning rate') parser.add_argument('--input', default='images/bonus/2.png', type=str, help='path to input') parser.add_argument('--mask', default='images/bonus/2_mask.png', type=str, help='path to mask') parser.add_argument('--no-cuda', action='store_true', help='disable cuda') parser.add_argument('--output', type=str, help='directory to output') args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() #mask = np.array(Image.open(args.mask)) mask = image_to_tensor(args.mask) target_np = np.array(Image.open(args.input)) target = image_to_tensor(args.input) input_depth = 32 input_size = torch.Size([1, input_depth] + list(target.shape[2:])) noise = torch.FloatTensor(input_size).uniform_(0, 0.1) # U(0, 0.1) sigma = 1./30 if use_cuda: mask = mask.cuda() target = target.cuda() noise = noise.cuda() net = SkipHourglass(input_depth, 3, down_channels=[128, 128, 128, 128, 128], up_channels=[128, 128, 128, 128, 128], skip_channels=[4, 4, 4, 4, 4],
def map_to_grid(images): images = make_grid(images, int(math.sqrt(len(images))), sample_pad) return images files = os.listdir(dir) files = [f for f in files if '.jpg' in f] model = AlexNet(feature_name='pool') images = [ Image.open(os.path.join(dir, f)).convert('L').convert('RGB') for f in files ] image_tensors = torch.stack( [image_to_tensor(img, resolution=224) for img in images]) with torch.no_grad(): features = model(image_tensors).numpy() pcs = PCA(n_components=n_pcs).fit_transform(features) sorted_indices = np.argsort(pcs, axis=0) low_pcs = [[images[j] for j in sorted_indices[:n_exemplars, i]] for i in range(n_pcs)] high_pcs = [[images[j] for j in sorted_indices[-n_exemplars:, i]] for i in range(n_pcs)] for pc in range(n_pcs): os.mkdir(os.path.join(save_dir, 'pc_{}'.format(pc))) for i, img in enumerate(low_pcs[pc]): img.save( os.path.join(save_dir, 'pc_{}'.format(pc), 'neg_{}.jpg'.format(i)))
feature_extractor = VGG16() else: raise ValueError('Unimplemented feature extractor: {}'.format( args.model)) feature_extractor.conv1.register_forward_hook(get_activation('conv1')) feature_extractor.conv2.register_forward_hook(get_activation('conv2')) feature_extractor.conv3.register_forward_hook(get_activation('conv3')) feature_extractor.conv4.register_forward_hook(get_activation('conv4')) feature_extractor.conv5.register_forward_hook(get_activation('conv5')) feature_extractor.fc6.register_forward_hook(get_activation('fc6')) feature_extractor.fc7.register_forward_hook(get_activation('fc7')) conditions = listdir('data/image/' + args.dataset) for c in tqdm(conditions): stimuli = listdir(c) c_name = c.split('/')[-1] os.mkdir('processed/feature/' + args.dataset + '/' + args.model + '/' + c_name) stimuli_tensor = [ image_to_tensor(s, resolution=args.resolution) for s in stimuli ] for name, tensor in zip(stimuli, stimuli_tensor): activation = {} output = feature_extractor(tensor.unsqueeze(0)) file = name.split('/')[-1] + '.pth' torch.save( activation, os.path.join('processed/feature', args.dataset, args.model, c_name, file))
def main(show=True, images_dir='images', image_fmt='%.3d.png'): with open('config.json', 'r') as f: config = json.load(f) enc_cfg = config['video_enc'] parser = ArgumentParser(description='Process .svo files') parser.add_argument('input', type=str, help='Input directory or file') parser.add_argument('output', type=str, nargs='?', default=None, help='Output directory or file') parser.add_argument('-m', type=str, required=False, help='Model to process with') parser.add_argument('-f', type=int, required=False, default=1, help='Reduce factor') parser.add_argument('-v', action='store_true', required=False, default=False, help='Mix processed with input') parser.add_argument('-e', action='store_true', required=False, default=False, help='Estimate motion') parser.add_argument('-r', action='store_true', required=False, default=False, help='Read right image') parser.add_argument('-p', type=str, required=False, default=enc_cfg.get('default'), help='Select parameters preset for FFMPEG') args = parser.parse_args() enc_cfg = enc_cfg[args.p] model = None if args.m is None else load_model(args.m, device=device)[0] view = sl.VIEW.VIEW_RIGHT if args.r else sl.VIEW.VIEW_LEFT svo_path = config['svo_path'] if isdir(args.input): files = sorted([ join(args.input, fn) for fn in listdir(args.input) if isfile(join(args.input, fn)) and fn.endswith('.svo') ], key=file_idx) elif isfile(args.input): files = [args.input] else: try: files = decode_name(args.input) except ValueError: print('No such file or directory: %s' % args.input) return pause = False save_idx = get_save_idx(images_dir, image_fmt) writer = None out_path = args.output if out_path == 'auto': model_name = args.m if model_name is not None and args.v: model_name += '-v' out_path = config['mp4_path'].replace('{model}', model_name or '') if not isdir(out_path): mkdir(out_path) to_dir = False if out_path is None else isdir(out_path) out_height, out_width = None, None estimator = MotionEstimator('fly1', with_gui=out_path is None) with torch.no_grad(): for dn in files: if type(dn) == str: fn = dn out_name = basename(fn)[:-4] else: fn, out_name, view = dn fn = join(svo_path, fn) out_name = None if out_path is None else join( out_path, out_name + '.mp4') if not isfile(fn): print('File %s not found!' % fn) continue print('Processing %s' % fn) for frame_idx, source in enumerate(read_svo(fn, view)): # Processing: if model is not None: data = image_to_tensor(source, device=device) data = model(data).squeeze(0) # [:, :2] if args.e: mask = (data[4:6] < 0.5).all(0) estimator.add(source, mask.cpu().numpy(), out_name, frame_idx) result = probs_to_image(data, mask=True) output = visualize(source, result) if args.v else result else: result = None output = source if out_height is None: out_height, out_width = map(lambda s: s // args.f, output.shape[:2]) if args.f != 1: output = cv2.resize(output, (out_width, out_height)) # Open writer: if writer is None and out_path is not None: dst = out_name if to_dir else out_path print('Write to %s' % dst) writer = open_ffmpeg(dst, (out_width, out_height), params=enc_cfg) # Return output: if writer is not None: write_ffmpeg(writer, output) else: cv2.imshow('output', output) while True: key = cv2.waitKey(1) if key == ord('p'): pause = not pause elif key == ord('s'): cv2.imwrite( join('images', 'saved-in', image_fmt % save_idx), source) if result is not None: cv2.imwrite( join('images', 'saved-out', image_fmt % save_idx), result) save_idx += 1 elif key == ord('q'): return elif key == ord('m'): cv2.imshow('output', result) elif key == ord('i'): cv2.imshow('output', source) if not pause: break if to_dir and writer is not None: close_ffmpeg(writer) writer = None if writer is not None: close_ffmpeg(writer)
content_mask_tensor[i, :, :] ], dim=0), 'content_mask_' + str(i)) # Using GPU or CPU device = torch.device(config.device0) style_img = utils.load_image(style_image_path, None) content_img = utils.load_image(content_image_path, None) width_s, height_s = style_img.size width_c, height_c = content_img.size # print(height_s, width_s) # print(height_c, width_c) style_img = utils.image_to_tensor(style_img).unsqueeze(0) content_img = utils.image_to_tensor(content_img).unsqueeze(0) style_img = style_img.to(device, torch.float) content_img = content_img.to(device, torch.float) # print('content_img size: ', content_img.size()) # utils.show_pic(style_img, 'style image') # utils.show_pic(content_img, 'content image') # ------------------------- # Eval() means the parameters of cnn are frozen. cnn = models.vgg19(pretrained=True).features.to(config.device0).eval() cnn_normalization_mean = torch.tensor([0.485, 0.456, 0.406]).to(config.device0)
help='whether to use an encoder with random weights') args = parser.parse_args() shutil.rmtree(args.save_folder, ignore_errors=True) os.mkdir(args.save_folder) stimuli = os.listdir(args.stimuli_folder) stimuli = [s for s in stimuli if s != '.DS_Store'] roi_mask = utils.get_roi_mask(args.roi, args.encoder_file) encoder = torch.load(os.path.join('saved_models', args.encoder_file)) print('Generating disruption examples') for stimulus_name in tqdm(stimuli): stimulus = utils.image_to_tensor( os.path.join(args.stimuli_folder, stimulus_name), resolution) target = torch.load( os.path.join(args.targets_folder, stimulus_name + '.target.pth')) disrupted, metrics = disrupt_stimulus(stimulus, target, encoder, roi_mask, args.towards_target, args.random) shutil.copyfile( os.path.join(args.stimuli_folder, stimulus_name), os.path.join(args.save_folder, stimulus_name).replace('.', '_original.')) utils.tensor_to_image(disrupted).save( os.path.join(args.save_folder, stimulus_name.replace('.', '_disrupted.'))) with open( os.path.join(args.save_folder,