def upload_file(): content = request.files['file'] style = request.form.get('style') content.save(os.path.join(app.config['UPLOAD_FOLDER'], 'content.jpg')) #load in content and style image content = load_image('./static/image/upload/content.jpg') #Resize style to match content, makes code easier style = load_image('./static/image/s' + style + '.jpg', shape=content.shape[-2:]) vgg = model() target = stylize(content, style, vgg) x = im_convert(target) plt.imsave(app.config['UPLOAD_FOLDER'] + 'target.png', x) return render_template('success.html')
def main(): parser = argparse.ArgumentParser() parser.add_argument('--image', help="Path to input image") parser.add_argument('--style', help="Which style to apply", choices=list(STYLE_IDS.keys())) parser.add_argument('--outdir', help="Path to output directory") parser.add_argument('--min-image-dim', help="Minimum image dimension", default=1000, type=int) parser.add_argument('--num-images', help="Number of images", default=50, type=int) parser.add_argument('--shimmer', help="Amount of movement", default=10, type=int) args = parser.parse_args() print("Loading image") img = load_image(args.image, args.min_image_dim) print("Downloading model") checkpoint_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), '%s.ckpt' % args.style) download_file_from_google_drive(STYLE_IDS[args.style], checkpoint_path) noise1 = args.shimmer * np.random.uniform(size=img.shape) + 177 noise2 = args.shimmer * np.random.uniform(size=img.shape) + 177 with imageio.get_writer(os.path.join(args.outdir, 'output.gif'), mode='I') as writer: for i in range(args.num_images): mult = np.sin(i * 2 * np.pi / args.num_images) / 2 + 0.5 noise = mult * noise1 + (1 - mult) * noise2 input_img = img + noise print("Transferring style (%d/%d)" % (i+1, args.num_images)) out = style_transfer(input_img, checkpoint_path) writer.append_data(out) print("Image saved")
def main( content_dir=os.getenv("CONTENT_PATH", "content"), model_dir=os.getenv("MODEL_PATH", "model"), style="mosaic", output_dir=os.getenv("OUTPUT_PATH", "output"), cuda=True, ): """ :param content_dir: :param model_dir: :param style: one of candy, mosaic, rain_princess, udnie :param output_dir: :return: """ filenames = os.listdir(content_dir) style_model = load_model(model_dir, style, cuda=cuda) for filename in filenames: print("Processing {}".format(filename)) full_path = os.path.join(content_dir, filename) content_image = load_image(full_path) styled_image = stylize(style_model, content_image) output_path = os.path.join(output_dir, filename) save_image(output_path, styled_image[0]) if cuda and not torch.cuda.is_available(): print("ERROR: cuda is not available, try running on CPU") sys.exit(1)
parser.add_argument("--semantic_thresh", type=float, help="Smantic threshold for label grouping", default=0.5) parser.add_argument( "--similarity_metric", type=str, help="Smantic similarity metric for label grouping., default: li", default="li") similarity_metric_options = ["li", "wpath", "jcn", "lin", "wup", "res"] args = parser.parse_args() # For more information on the similarity metrics: http://gsi-upm.github.io/sematch/similarity/#word-similarity assert (args.similarity_metric in similarity_metric_options) image = load_image(args.raw_segmentation) segmentation_image = cv2.imread(args.raw_segmentation) segmentation_masks, _ = merge_segments(segmentation_image, segmentation_image, args.semantic_thresh, args.similarity_metric) result_dir = 'semantic_merge' if not os.path.exists(result_dir): os.mkdir(result_dir) cv2.imwrite( change_filename(result_dir, args.raw_segmentation, '_{}'.format(args.semantic_thresh), '.png'), reduce_dict(segmentation_masks, image))
def main(style, content_key, request_id): device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') s3 = boto3.resource('s3') bucket_name = os.environ.get('IMAGE_BUCKET_NAME') bucket = s3.Bucket(bucket_name) content_object = bucket.Object(content_key) content_tmp = tempfile.NamedTemporaryFile() with open(content_tmp.name, 'wb') as f: content_object.download_fileobj(f) content = load_image(content_tmp.name).to(device) style_key = 'style/%s.jpg' % style style_object = bucket.Object(style_key) style_tmp = tempfile.NamedTemporaryFile() with open(style_tmp.name, 'wb') as f: style_object.download_fileobj(f) # Resize style to match content, makes code easier style = load_image(style_tmp.name, shape=content.shape[-2:]).to(device) # get the "features" portion of VGG19 (we will not need the "classifier" portion) vgg = models.vgg19(pretrained=True).features # freeze all VGG parameters since we're only optimizing the target image for param in vgg.parameters(): param.requires_grad_(False) vgg.to(device) # weights for each style layer # weighting earlier layers more will result in *larger* style artifacts # notice we are excluding `conv4_2` our content representation style_weights = { 'conv1_1': 1., 'conv2_1': 0.8, 'conv3_1': 0.5, 'conv4_1': 0.3, 'conv5_1': 0.1, } # you may choose to leave these as is content_weight = 1 # alpha style_weight = 1e6 # beta # iteration hyperparameters optimizer = optim.Adam steps = 2000 # decide how many iterations to update your image (5000) # for displaying the target image, intermittently show_every = 400 result = transfer( device, style, content, vgg, content_weight, style_weight, style_weights, optimizer, steps, ) result = Image.fromarray((255 * im_convert(result)).astype(np.uint8)) file_ext = '.%s' % content_key.split('.')[-1] result_tmp = tempfile.NamedTemporaryFile(suffix=file_ext) result.save(result_tmp.name) result_key = content_key.replace('/input/', '/output/') with open(result_tmp.name, 'rb') as result: bucket.put_object( Key=result_key, Body=result, ) sqs = boto3.client('sqs') result_message = { 'requestId': request_id, 'resultKey': result_key, } sqs.send_message( QueueUrl=os.environ.get('JOB_DONE_QUEUE_URL'), MessageBody=json.dumps(result_message), )
def postprocess(image): return (image + 1.0) * 127.5 if __name__ == '__main__': from datetime import datetime from style_transfer import load_image, save_image, adam_variables_initializer, compute_nima_loss import tensorflow as tf timestamp = datetime.now().strftime('%Y_%m_%d_%H_%M') result_dir = 'result_' + timestamp os.mkdir(result_dir) content_image = load_image("content.png") content_image = preprocess(content_image) with tf.Session() as sess: transfer_image = tf.Variable(content_image) sess.run(tf.global_variables_initializer()) nima_loss = compute_nima_loss(transfer_image) optimizer = tf.train.AdamOptimizer(learning_rate=0.001) train_op = optimizer.minimize(nima_loss, var_list=[transfer_image]) sess.run(adam_variables_initializer(optimizer, [transfer_image])) min_loss, best_image = float("inf"), None