def camera_transfer(checkpoint_dir, screen_shot_dir="output/camera_screen/"): cap = cv2.VideoCapture(0, cv2.CAP_DSHOW) fps = cap.get(30) i = 0 date = [] date2 = datetime.datetime.now() while (True): ret, frame = cap.read() i = i + 1 if i / fps == int(i / fps): cv2.imwrite("Assets/image/tmp.png", frame) evaluate.ffwd_to_img("Assets/image/tmp.png", "Assets/image/tmp2.png", checkpoint_dir) frame = cv2.imread("Assets/image/tmp2.png") cv2.imshow('frame', frame) date1 = datetime.datetime.now() date.append(date1 - date2) date2 = date1 if cv2.waitKey(1) & 0xFF == ord('s'): s = screen_shot_dir + "Screen_shot" + str( datetime.datetime.now()).split(" ")[0] + "-" + (str( datetime.datetime.now()).split(" ")[1].split( ".")[0]).replace(":", "-") + '.png' cv2.imshow("screen shot", frame) cv2.imwrite(s, frame) if cv2.waitKey(1) & 0xFF == ord('q'): print("你按了Q键") break cap.release() cv2.destroyAllWindows()
def upload_file(): @after_this_request def cleanup(response): for f in glob.glob("{}/*".format(INPUT_PATH)): os.remove(f) for f in glob.glob("{}/*".format(OUTPUT_PATH)): os.remove(f) return response if not request.form.get("style"): print('No selected style') return BadRequest('No selected style') print(request.form.get("style")) if 'file' not in request.files: print("No file part") return BadRequest('No file part') file = request.files['file'] if file.filename == '': print('No selected file') return BadRequest('No selected file') if file and allowed_file(file.filename): filename = secure_filename(file.filename) style = request.form.get("style") print("Everything is OK") print(file) input_filepath = os.path.join(INPUT_PATH, filename) output_filepath = os.path.join(OUTPUT_PATH, filename) file.save(input_filepath) checkpoint = '{}/{}.ckpt'.format(MODELS_PATH, style) print(checkpoint) ffwd_to_img(input_filepath, output_filepath, checkpoint, '/cpu:0') return send_file(output_filepath, mimetype='image/jpg')
def main(): print('ml5.js Style Transfer Training!') print('Note: This traning will take a couple of hours.') parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow":options.slow, "epochs":options.epochs, "print_iterations":options.checkpoint_iterations, "batch_size":options.batch_size, "save_path":os.path.join(options.checkpoint_dir,'fns.ckpt'), "learning_rate":options.learning_rate, } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] print('Training is starting!...') for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir,epoch,i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test,preds_path, options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text) print('Converting model to ml5js') dump_checkpoints(kwargs['save_path'], options.model_dir) print('Done! Checkpoint saved. Visit https://ml5js.org/docs/StyleTransfer for more information')
def main(): print("Enter main") parser = build_parser() options = parser.parse_args() check_opts(options) print("Get image target") style_target = get_img(options.style) if not options.slow: with log_time_usage("get images targets"): content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "debug": options.debug, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate, "tensorboard_dir": options.tensorboard_dir } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] print("Start training") with log_time_usage("Training completed in"): for preds, losses, i, epoch, time_info in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print( 'Epoch %d, Iteration: %d, Loss: %s, AVG batch time: %.2f, total_time: %.2f, ETA (in h): %.2f' % (epoch, i, loss, *time_info)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: # TODO: img is not defined # save_img(preds_path, img) pass ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): check_version() parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow":options.slow, "epochs":options.epochs, "print_iterations":options.checkpoint_iterations, "batch_size":options.batch_size, "save_path":os.path.join(options.checkpoint_dir,'fns.ckpt'), "learning_rate":options.learning_rate, "device":options.device, "total_iterations":options.total_iterations, "base_model_path":options.base_model_path, } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) sys.stdout.flush() if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir,epoch,i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test,preds_path, options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint-dir %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(style, test=False, test_dir='test', train_path=TRAIN_PATH, slow=False, epochs=NUM_EPOCHS, checkpoint_iterations=CHECKPOINT_ITERATIONS, batch_size=BATCH_SIZE, checkpoint_dir=CHECKPOINT_DIR, learning_rate=LEARNING_RATE, content_weight=CONTENT_WEIGHT, style_weight=STYLE_WEIGHT, tv_weight=TV_WEIGHT, vgg_path=VGG_PATH): #parser = build_parser() #options = parser.parse_args() #check_opts(options) style_target = get_img(style) if not slow: content_targets = _get_files(train_path) elif test: content_targets = [test] kwargs = { "slow": slow, "epochs": epochs, "print_iterations": checkpoint_iterations, "batch_size": batch_size, "save_path": checkpoint_dir, "learning_rate": learning_rate } if slow: if epochs < 10: kwargs['epochs'] = 1000 if learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, content_weight, style_weight, tv_weight, vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if test: assert test_dir != False preds_path = '%s/%s_%s.png' % (test_dir, epoch, i) if not slow: ckpt_dir = os.path.dirname(checkpoint_dir) evaluate.ffwd_to_img(test, preds_path, checkpoint_dir) else: save_img(preds_path, img)
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate, "device_and_number": options.device_and_number } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] import time from datetime import datetime start_time = time.time() for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses delta_time, start_time = time.time() - start_time, time.time() print( 'Current Time = {}; Time Elapsed = {}; Epoch = {}; Iteration = {}; Loss = {}' .format(datetime.now().strftime("%Y %B %d, %H:%M:%S"), delta_time, epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('Loss values: style = %s; content = %s; tv = %s' % to_print) sys.stdout.flush() if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: # if uses GPU, uses RAM that it doesn't have, so it's slow here ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): parser = build_parser() options = parser.parse_args() if not os.path.exists(options.test_dir): os.mkdir(options.test_dir) if not os.path.exists(options.checkpoint_dir): os.mkdir(options.checkpoint_dir) check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate, "gpu_fraction": options.gpu_fraction } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): parser = build_parser() options = parser.parse_args() # 获取命令行参数 check_opts(options) # 参数检查 style_target = get_img(options.style) # 三通道风格图,大小不固定 if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "epochs": options.epochs, # 训练多少轮,所有的训练数据集都训练过一次称为一个epoch,即一轮 "print_iterations": options.checkpoint_iterations, "batch_size": options. batch_size, # 批处理。一组多少张,itertions=epoch/batch即迭代一轮的迭代次数, epochs*(epoch/batch)即为总迭代次数 "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate } # !!! if options.slow: # !!! if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] # 待使用参数 for preds, losses, i, epoch in optimize(*args, **kwargs): # 迭代!!! style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img( preds_path, preds.reshape((512, 512, 3)) ) ####131 错误save_img(preds_path,img),I found a fix for this. Replace img with preds.reshape((512,512,3)) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def do_start(self): style_checkpoint_path = style_path.split(".")[0] + ".ckpt" out_path = storage_location_path + content_path.split('\\')[-1] if content_is_video: evaluate.ffwd_video(content_path, out_path, style_checkpoint_path) if show_result.show_video(out_path): return True else: evaluate.ffwd_to_img(content_path, out_path, style_checkpoint_path) if show_result.show_image(out_path): return True # time.sleep(10) '''
def get_image(file_path): url = "https://api.telegram.org/file/bot{}/{}".format(bot_token,file_path) #cmd = "curl -o {} {}".format(file_path, url) print "getting image:", url wget.download(url, file_path) #os.system(cmd) in_path = file_path out_path = 'static/' + in_path checkpoint_dir = 'checkpoints/udnie.ckpt' print in_path, out_path ffwd_to_img(in_path, out_path, random.choice(ckpt_files)) return out_path
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] # with tf.Graph().as_default(), tf.device('/cpu:0'), tf.Session() as sess: # init_op = tf.global_variables_initializer() # saver = tf.train.Saver() # saver.restore(sess, options.checkpoint_dir) print('options.test: ' + options.test) print('options.checkpoint_der: ' + options.checkpoint_dir) for index_image in range(0, 20): options.test = '../image_style_dataset/' + 'structure' + str( index_image + 1).zfill(4) + '.jpg' print(options.test) preds_path = '%s/' % (options.test_dir) + SAVE_NAME + '%s_%s.png' % ( 999, index_image) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img(preds_path, img)
def process_file(filename, chk): abs_in_filename = os.path.join( os.path.dirname(os.path.abspath(__file__)), app.config['UPLOAD_FOLDER'], filename) abs_out_filename = os.path.join( os.path.dirname(os.path.abspath(__file__)), app.config['PROCESSED_FOLDER'], filename) abs_chk_filename = os.path.join( os.path.dirname(os.path.abspath(__file__)), app.config['CHECKPOINT_FOLDER'], chk) if os.path.exists(abs_out_filename): os.remove(abs_out_filename) if allowed_file(filename, VIDEO_EXTENSIONS): process_video(abs_in_filename, abs_chk_filename, abs_out_filename) if allowed_file(filename, IMAGE_EXTENSIONS): ffwd_to_img(abs_in_filename, abs_out_filename, abs_chk_filename) return redirect('/static/'+filename)
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) # TODO:获取风格图像 style_target 以及内容图像数组 content_targets style_target = ___________________ if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { # "slow":options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate, "type": options.type, "save": options.save } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir print("Training complete.")
def stransfer_from_file(fpath): assert os.path.isfile(fpath) assert fpath.endswith(".jpg") or fpath.endswith(".png") fname = os.path.basename(fpath) out_path = os.path.join(OUT_PATH, fname) # picking random style style_id = random.randint(0, NUM_STYLES - 1) cpkt_file = os.path.join(CPKT_DIR, CPKT_LIST[style_id]) style_imgpath = STYLE_PATHS[style_id] # running style transfer evaluate.ffwd_to_img(fpath, out_path, cpkt_file, device='/cpu:0') # return the path to the output image and the path to the style image return out_path, style_imgpath
def processMessage(data): print data in_path = data['result']['file_path'].encode(encoding='UTF-8') print "in_path:", in_path, type(in_path) url = "https://api.telegram.org/file/bot{}/{}".format(bot_token, in_path) print "getting image:", url wget.download(url, in_path) out_path = 'static/' + in_path #checkpoint_dir = 'checkpoints/udnie.ckpt' checkpoint_dir = random.choice(ckpt_files) ffwd_to_img(in_path, out_path, checkpoint_dir) print "done image" sendPhoto(data['chat_id'], "https://dl2.rohbot.cc/" + out_path)
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) content_targets = _get_files(options.train_path) clear_content_targets = _get_files(options.train_path_) # random.shuffle(content_targets) # 乱序 kwargs = { "epochs":options.epochs, "print_iterations":options.checkpoint_iterations, "batch_size":options.batch_size, "save_path":os.path.join(options.checkpoint_dir,''), "learning_rate":options.learning_rate } args = [ content_targets, clear_content_targets, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir,epoch,i) ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test,preds_path, options.checkpoint_dir) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def upload_file(): if request.method == 'POST': # check if the post request has the file part if 'file' not in request.files: flash('No file part') return redirect(request.url) file = request.files['file'] # if user does not select file, browser also # submit a empty part without filename if file.filename == '': flash('No selected file') return redirect(request.url) if file and allowed_file(file.filename): filename = 'in.jpg' file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename)) filename_out = 'out.jpg' ffwd_to_img(filename, filename_out, request.form['checkpoint']) return redirect(url_for('uploaded_file', filename=filename_out)) return render_template('./index.html')
def style_transfer(path): """ Take the input image and style transfer it """ # check if the post request has the file part if 'file' not in request.files: return BadRequest("File not present in request") file = request.files['file'] if file.filename == '': return BadRequest("File name is not present in request") if not allowed_file(file.filename): return BadRequest("Invalid file type") if file and allowed_file(file.filename): filename = secure_filename(file.filename) input_filepath = os.path.join('./images/', filename) output_filepath = os.path.join('/output/', filename) file.save(input_filepath) # Get checkpoint filename from la_muse checkpoint = request.form.get("checkpoint") or "la_muse.ckpt" ffwd_to_img(input_filepath, output_filepath, '/input/' + checkpoint, '/gpu:0') return send_file(output_filepath, mimetype='image/jpg')
def style_transfer(path): """ Take the input image and style transfer it """ # check if the post request has the file part if 'file' not in request.files: return BadRequest("File not present in request") file = request.files['file'] if file.filename == '': return BadRequest("File name is not present in request") if not allowed_file(file.filename): return BadRequest("Invalid file type") if file and allowed_file(file.filename): filename = secure_filename(file.filename) input_filepath = os.path.join('./images/', filename) output_filepath = os.path.join('/output/', filename) file.save(input_filepath) # Get checkpoint filename from la_muse checkpoint = request.form.get("checkpoint") or "undine.ckpt" ffwd_to_img(input_filepath, output_filepath, '/input/' + checkpoint, '/gpu:0') return send_file(output_filepath, mimetype='image/jpg')
def main(): parser = build_parser() # ArgumentParser() options = parser.parse_args() # call the fucntion then return options check_opts(options) style_target = get_img(options.style) # a 3-D numpy array if not options.slow: # COCO train2014 dataset, roughly 20000 images content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] if options.IN: use_IN = True else: use_IN = False print(f"Are we using Instance Normalization? {use_IN}.") kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fast_style_transfer.ckpt'), "learning_rate": options.learning_rate } args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path, use_IN ] if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 for generated_image, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, total_loss = losses print(f"Epoch: {epoch}, Iteration: {i} ......") print( f"Total_loss: {total_loss}, Style_loss: {style_loss}, Content_loss: {content_loss}." ) if options.test: assert options.test_dir != False preds_path = f"{options.test_dir}/{epoch}_{i}.png" if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img(preds_path, img) cmd_text = f"python evaluate.py --checkpoint {options.checkpoint_dir} \ --in-path [in_picture] --out-path [out_picture]" print(f"Training complete. For evaluation, type: {cmd_text}")
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) # style_target = get_img(options.style) # style_targets = [] # for path in os.listdir(options.style_dir): # style_targets.append(get_img(os.path.join(options.style_dir, path))) style_targets = np.array([get_img(os.path.join(options.style_dir, fname), (256,256,3)) for fname in os.listdir(options.style_dir)]) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow":options.slow, "epochs":options.epochs, "print_iterations":options.checkpoint_iterations, "batch_size":options.batch_size, "save_path":os.path.join(options.checkpoint_dir,'fns.ckpt'), "learning_rate":options.learning_rate, "save_checkpoint":options.save_checkpoint, "restore_checkpoint_path":os.path.join(options.restore_checkpoint,'fns.ckpt') if options.restore_checkpoint else None } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, # style_target, style_targets, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: print('Save test image.') curr_lambda_style = np.random.randint(1, 100) * 1.0 # print('curr_lambda_style: {}'.format(curr_lambda_style)) assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir,epoch,i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir, control_lambda_style=curr_lambda_style, style_id=np.random.randint(len(style_targets))) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.fcrs_weight, options.fcon_weight, options.fdir_weight, options.vgg_path ] cnt = 0 for preds, losses, i, epoch, lr, gs in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, fcrs_loss, fcon_loss, fdir_loss, loss = losses print('cnt: %d' % cnt) cnt += 1 print('Epoch %d, Iteration: %d, Loss: %s, Lr: %s, Gs: %s' % (epoch, i, loss, lr, gs)) to_print = (style_loss, content_loss, tv_loss, fcrs_loss, fcon_loss, fdir_loss) print( 'style: %s, content:%s, tv: %s, fcrs_loss: %s, fcon_loss: %s, fdir_loss: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: #save_img(preds_path, img) save_img(preds_path, preds) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir save_img( '/home/marshallee/Documents/fast-style-transfer/examples/output/Step-wave-' + str(options.fcrs_weight) + '-' + str(options.fcon_weight) + '-' + str(options.fdir_weight) + '.jpg', np.squeeze(np.array(preds))) print("Training complete. For evaluation:\n `%s`" % cmd_text) print( str(options.fcrs_weight) + '-' + str(options.fcon_weight) + '-' + str(options.fdir_weight))
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] #define a path with weight weight_path = '%s/%s_%s_%s_%s' % (options.checkpoint_dir,options.test.split('/')[-1],options.style.split('/')[-1],options.content_weight,options.style_weight) #os.mkdir(weight_path) kwargs = { "slow":options.slow, "epochs":options.epochs, "print_iterations":options.checkpoint_iterations, "batch_size":options.batch_size, # "save_path":os.path.join(options.checkpoint_dir,'fns.ckpt'), "save_path":os.path.join(weight_path,'fns.ckpt'), "learning_rate":options.learning_rate } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False #calvin - make subfolder for output files - start output_path = '%s/%s_%s' % (options.test_dir,options.test.split('/')[-1],options.style.split('/')[-1]) if not os.path.isdir(output_path): os.mkdir(output_path) #calin - end preds_path = '%s/%s_%s_%s_%s_%s.png' % (output_path,options.content_weight,options.style_weight,epoch,i,style_loss) if not options.slow: ckpt_dir = os.path.dirname(weight_path) evaluate.ffwd_to_img(options.test,preds_path, weight_path) # ckpt_dir = os.path.dirname(options.checkpoint_dir) # change the checkpoint folder as dynamic # evaluate.ffwd_to_img(options.test,preds_path, # options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] style_files = [] if os.path.isfile(options.style): style_files.extend(options.style) else: style_files = _get_files(options.style) for style_file in style_files: print("-------------Started to train2014 model for style '%s'" % os.path.basename(style_file)) style_target = get_img(style_file) checkpoint_dir = "checkpoint_" + os.path.splitext( os.path.basename(style_file))[0] if not os.path.exists(checkpoint_dir): os.makedirs(checkpoint_dir) test_dir = "test_" + os.path.splitext(os.path.basename(style_file))[0] if options.test: if not os.path.exists(test_dir): os.makedirs(test_dir) kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": checkpoint_dir, "learning_rate": options.learning_rate } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: # assert options.test_dir != False preds_path = '%s/%s_%s.png' % (test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, checkpoint_dir) else: save_img(preds_path, preds) ckpt_dir = checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): #実際に実行される関数 parser = build_parser() #引数を解析してparserに格納する options = parser.parse_args() #引数として読み込まれたものをoptionsに格納する check_opts(options) #引数が不適切なものではないかどうかを確認する style_target = get_img(options.style) #スタイル画像をget_img関数を用いてプログラム内に読み込む if not options.slow: #slowを指定されていなければこちら側に分岐する content_targets = _get_files(options.train_path) #_get_files関数を使って訓練用の画像のパスを読み込み、content_targets変数に代入する elif options.test: #引数としてtestが指定されていた場合 content_targets = [options.test] #テスト用画像をcontent_targetsに代入する kwargs = { #辞書型のオブジェクトkwargsに値を入れていく "slow": options.slow, #slowが指定されていれば"slow"として格納する "epochs": options.epochs, #エポック数を"epochs"として格納する "print_iterations": options.checkpoint_iterations, #チェックポイントに到達するまでの数を"print_iterations"として格納する "batch_size": options.batch_size, #バッチサイズを"batch_size"として格納する "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), #チェックポイントとして使うファイルのパスをcheckpoint_dirと結合し、"save_path"として格納する "learning_rate": options.learning_rate #学習率を"learninng_rate"として格納する } if options.slow: #slowが指定されていた場合 if options.epochs < 10: #エポック数が10よりも小さければTrue kwargs['epochs'] = 1000 #エポック数を1000に上書きする if options.learning_rate < 1: #学習率が1よりも小さい場合 kwargs['learning_rate'] = 1e1 #学習率を1x10^1に上書きする args = [ # argsリストに値を代入していく content_targets, # コンテンツ画像 style_target, # スタイル画像 options.content_weight, # コンテンツの損失の重み options.style_weight, # スタイルの損失の重み options.tv_weight, # total variationの損失の重み options.vgg_path # vggのある場所へのパス ] # argsは初期値などを格納してある変数 # kwargsはハイパーパラメータなどが格納してある変数 for preds, losses, i, epoch in optimize(*args, **kwargs): # optimize関数から、マッピング後の入力ノードの値、損失の値、 # 現在の繰り返し数、現在のエポックを受け取り、 # その4つの値をそれぞれの変数に格納する style_loss, content_loss, tv_loss, loss = losses # スタイル損失、コンテンツ損失、tv損失、合計の損失をlosses変数から取得し、 # その4つの値をそれぞれの変数に格納する print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) # 現在のエポック数、繰り返し数、損失の値をコンソールに表示する to_print = (style_loss, content_loss, tv_loss) # スタイル損失、コンテンツ損失、tv損失のタプルをto_print変数に格納する print('style: %s, content:%s, tv: %s' % to_print) # それぞれの損失の値をコンソールに表示する if options.test: # testモードの場合true assert options.test_dir != False # テスト用ディレクトリのパスが指定されていなければAssertionError preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) # 新しく生成する画像の名前を、テスト用ディレクトリの名前、 # 現在のエポック数、繰り返し数から重複がないように生成する if not options.slow: # slowモードが指定されていない場合True ckpt_dir = os.path.dirname(options.checkpoint_dir) # チェックポイントのディレクトリを内包しているディレクトリの名前を取得する evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) # テストとして画風変換を行う # それぞれ引数testはテスト用画像のディレクトリ、 # preds_pathは変換後の画像の出力先、checkpoint_dirはチェックポイントのディレクトリ else: # slowモードが指定されている場合 save_img(preds_path, img) # 画像出力先のディレクトリpreds_pathにimgを保存する ckpt_dir = options.checkpoint_dir # checkpoint_dirが格納しているパスをckpt_dirに格納しておく cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir # コンソールに出力したい文字列を格納した変数cmd_textを定義する print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] # a simpler folder name format # [style image name]_[data format]_[num base channels]_[content weight]_[style weight]_[learning rate] style_image_str = os.path.basename(options.style) style_image_str = os.path.splitext(style_image_str)[0] content_weight_str = np.format_float_scientific( options.content_weight).replace('.', '').replace('+', '') style_weight_str = np.format_float_scientific( options.style_weight).replace('.', '').replace('+', '') folder_name = style_image_str + "-" + options.data_format + "_nbc" + str( options.num_base_channels) + "_bs" + str( options.batch_size ) + "_" + content_weight_str + "_" + style_weight_str + "_" + str( options.learning_rate) # create checkpoint and test image folders ckpt_dir_path = os.path.join(options.checkpoint_dir, folder_name) test_dir_path = os.path.join(options.test_dir, folder_name) print("ckpt_dir_path:{}".format(ckpt_dir_path)) print("test_dir_path:{}".format(test_dir_path)) if not os.path.isdir(ckpt_dir_path): os.mkdir(ckpt_dir_path) if not os.path.isdir(test_dir_path): os.mkdir(test_dir_path) options.checkpoint_dir = ckpt_dir_path options.test_dir = test_dir_path kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), #"save_path":os.path.join(options.checkpoint_dir,folder_name,'fns.ckpt'), "learning_rate": options.learning_rate, # more cli params "data_format": options.data_format, "num_base_channels": options.num_base_channels } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path, # more cli params #options.data_format, #options.num_base_channels ] #print ("kwargs:{}".format(kwargs)) #print ("args:{}".format(*args)) for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img( options.test, preds_path, options.checkpoint_dir, device= '/gpu:0', #mcky, force to use GPU, or would have 'Conv2DCustomBackpropInputOp only supports NHWC.' error. data_format=options.data_format, num_base_channels=options.num_base_channels) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def main(): start_time = time.time() parser = build_parser() options = parser.parse_args() check_opts(options) style_target = options.style_image if 1: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] print(len(content_targets)) kwargs = { "epochs":options.epochs, "print_iterations":options.checkpoint_iterations, "batch_size":options.batch_size, "save_path":os.path.join(options.checkpoint_dir,'fns.ckpt'), "learning_rate":options.learning_rate, "num_examples": options.num_examples, "no_gpu":options.no_gpu, "logs":options.logs, "affine":options.affine, "luma":options.luma, "contrast":options.contrast } args = [ content_targets, style_target, options.content_weight, options.style_weight, options.contrast_weight, options.tv_weight, options.affine_weight, options.luma_weight, options.vgg_path ] # save options as json file with open(os.path.join(options.test_dir, "options.json"), "w") as f: f.write(json.dumps(vars(options), sort_keys=True, indent=4)) for preds, losses, i, epoch in optimize(*args, **kwargs): if options.luma: style_loss, content_loss, tv_loss, contrast_loss, affine_loss, luma_loss, loss = losses to_print = (style_loss, content_loss, tv_loss, contrast_loss, affine_loss, luma_loss) elif options.affine: style_loss, content_loss, tv_loss, contrast_loss, affine_loss, loss = losses to_print = (style_loss, content_loss, tv_loss, contrast_loss, affine_loss) elif options.contrast: style_loss, content_loss, tv_loss, contrast_loss, loss = losses to_print = (style_loss, content_loss, tv_loss, contrast_loss) else: style_loss, content_loss, tv_loss, loss = losses to_print = (style_loss, content_loss, tv_loss) print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) # print('style: %s, content:%s, tv: %s, contrast: %s, gradient: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir,epoch,i) # copy ckpt src = os.path.join(options.checkpoint_dir, "fns.ckpt.data-00000-of-00001") dst = os.path.join(options.checkpoint_dir, "fns.ckpt") copyfile(src, dst) ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test,preds_path, options.checkpoint_dir) ckpt_dir = options.checkpoint_dir end_time = time.time() elapsed_time = end_time - start_time print("Training complete in %s seconds." % (elapsed_time)) # final cleanup os.remove(os.path.join(options.checkpoint_dir, "fns.ckpt.meta"))
def main(): check_version() parser = build_parser() options = parser.parse_args() check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] model_name = os.path.splitext(os.path.basename(options.style))[0] kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, '.'.join([model_name, 'ckpt'])), "learning_rate": options.learning_rate, "device": options.device, "total_iterations": options.total_iterations, "base_model_path": options.base_model_path, } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('style: %s, content:%s, tv: %s' % to_print) sys.stdout.flush() if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint-dir %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def _run_model(options): check_opts(options) style_target = get_img(options.style) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate, "device_and_number": options.device } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, style_target, options.content_weight, options.style_weight, options.tv_weight, options.vgg_path ] start_time = time.time() shutdown_time = start_time + options.max_runtime_in_minutes * 60 if options.log_file: log_file_ = open(options.log_file, 'w') sys.stdout = log_file_ sys.stderr = log_file_ for preds, losses, i, epoch, checkpoint_number in optimize( *args, **kwargs): style_loss, content_loss, tv_loss, loss = losses delta_time, start_time = time.time() - start_time, time.time() print( 'Current Time = {}; Time Elapsed = {}; Epoch = {}; Iteration = {}; Loss = {}' .format(datetime.now().strftime("%Y %B %d, %H:%M:%S"), delta_time, epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss) print('Loss values: style = %s; content = %s; tv = %s' % to_print) sys.stdout.flush() if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: # if uses GPU, uses RAM that it doesn't have, so it's slow here # ckpt_dir = os.path.dirname(options.checkpoint_dir) actual_dir = os.path.join( options.checkpoint_dir, 'checkpoint_{}'.format(checkpoint_number)) evaluate.ffwd_to_img(options.test, preds_path, actual_dir) else: save_img(preds_path, img) if time.time() > shutdown_time: # automatic shut down print( '\n\nRan for maximum runtime in minutes. Now shutting down time.' ) break ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text) if options.log_file: log_file_.close()
def main(): parser = build_parser() options = parser.parse_args() check_opts(options) # Load style and content images style_target = get_img(options.style) style_seg = get_img(options.style_seg) if not options.slow: content_targets = _get_files(options.train_path) elif options.test: content_targets = [options.test] kwargs = { "slow": options.slow, "epochs": options.epochs, "print_iterations": options.checkpoint_iterations, "batch_size": options.batch_size, "save_path": os.path.join(options.checkpoint_dir, 'fns.ckpt'), "learning_rate": options.learning_rate } if options.slow: if options.epochs < 10: kwargs['epochs'] = 1000 if options.learning_rate < 1: kwargs['learning_rate'] = 1e1 args = [ content_targets, # Batch image paths style_target, # Reference style *image* style_seg, # Reference style segmentation map *image* options.content_weight, options.style_weight, options.tv_weight, options.photo_weight, options.vgg_path, options.deeplab_path, options. resized_dir, # Batch image resized folder (intermediate from deeplab) options. seg_dir, # Batch image segmentation folder (intermediate from deeplab) options.matting_dir ] for preds, losses, i, epoch in optimize(*args, **kwargs): style_loss, content_loss, tv_loss, photo_loss, loss = losses print('Epoch %d, Iteration: %d, Loss: %s' % (epoch, i, loss)) to_print = (style_loss, content_loss, tv_loss, photo_loss) print('style: %s, content:%s, tv: %s, photo: %s' % to_print) if options.test: assert options.test_dir != False preds_path = '%s/%s_%s.png' % (options.test_dir, epoch, i) if not options.slow: ckpt_dir = os.path.dirname(options.checkpoint_dir) evaluate.ffwd_to_img(options.test, preds_path, options.checkpoint_dir) else: save_img(preds_path, img) ckpt_dir = options.checkpoint_dir cmd_text = 'python evaluate.py --checkpoint %s ...' % ckpt_dir print("Training complete. For evaluation:\n `%s`" % cmd_text)
def test_ckpt(): evaluate.ffwd_to_img('data/chicago.jpg', 'out/test_result.jpg', 'ckp_temp/') print('EVALUATE FINSHED.')