""" Batch vectorization script. Reads images recursively from sample_inputs/simplified//.png and outputs to outputs/sampling/simplified/// Reuses the core inference logic from test_vectorization.py but loads the model ONCE and runs many images in the same TF session to amortize startup time. """ import os import sys import time import argparse import numpy as np # Limit TF/numpy thread counts BEFORE importing TF, so they take effect. # Each shard worker should only use a fraction of the CPU cores to avoid # contention when running many shards in parallel. _NUM_THREADS = os.environ.get('VS_NUM_THREADS', '') if _NUM_THREADS: for _v in ['OMP_NUM_THREADS', 'OPENBLAS_NUM_THREADS', 'MKL_NUM_THREADS', 'NUMEXPR_NUM_THREADS', 'TF_NUM_INTRAOP_THREADS', 'TF_NUM_INTEROP_THREADS']: os.environ.setdefault(_v, _NUM_THREADS) import tensorflow as tf from PIL import Image import hyper_parameters as hparams from model_common_test import DiffPastingV3, VirtualSketchingModel from utils import (reset_graph, load_checkpoint, update_hyperparams, save_seq_data, draw_strokes) from dataset_utils import GeneralRawDataLoader, copy_hparams # import sample() function from test_vectorization from test_vectorization import sample as sample_vectorization os.environ['CUDA_VISIBLE_DEVICES'] = os.environ.get('CUDA_VISIBLE_DEVICES', '0') def collect_inputs(input_root): """Walk input_root and collect all PNG/JPG files, returning list of (relative_subdir, filename, full_path).""" items = [] for dirpath, _, files in os.walk(input_root): rel_subdir = os.path.relpath(dirpath, input_root) for f in sorted(files): if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp')): items.append((rel_subdir, f, os.path.join(dirpath, f))) return items def build_eval_hparams(model_base_dir, model_name): """Create the eval/sample hparams matching what the loaded checkpoint expects.""" model_params_default = hparams.get_default_hparams_clean() # update_hyperparams reads the saved model_config.json under model_dir model_params = update_hyperparams( model_params_default, model_base_dir, model_name, infer_dataset='clean_line_drawings') eval_model_params = copy_hparams(model_params) eval_model_params.use_input_dropout = 0 eval_model_params.use_recurrent_dropout = 0 eval_model_params.use_output_dropout = 0 eval_model_params.batch_size = 1 eval_model_params.model_mode = 'sample' sample_model_params = copy_hparams(eval_model_params) sample_model_params.batch_size = 1 sample_model_params.max_seq_len = 1 return eval_model_params, sample_model_params def process_one_image(sess, sampling_model, paste_v3_func, image_path, eval_hps, sample_hps, out_dir, image_basename, longer_infer_lens, state_dependent, round_stop_state_num, stroke_acc_threshold, draw_seq=False, draw_color_order=True): """Run inference for one image and dump outputs into out_dir.""" os.makedirs(out_dir, exist_ok=True) test_set = GeneralRawDataLoader(image_path, eval_hps.raster_size, test_dataset='clean_line_drawings') input_photos, init_cursors, test_image_size = test_set.get_test_image() # input_photos: (1, image_size, image_size), [0-stroke, 1-BG] if init_cursors.ndim == 3: init_cursors = np.expand_dims(init_cursors, axis=0) input_photos = input_photos[0:1, :, :] ori_img = (input_photos.copy()[0] * 255.0).astype(np.uint8) ori_img = np.stack([ori_img for _ in range(3)], axis=2) Image.fromarray(ori_img, 'RGB').save( os.path.join(out_dir, image_basename + '_input.png'), 'PNG') (strokes_raw_out_list, states_raw_out_list, states_soft_out_list, pred_imgs_out, window_size_out_list, round_new_cursors, round_new_lengths) = sample_vectorization( sess, sampling_model, input_photos, init_cursors, test_image_size, eval_hps.max_seq_len, longer_infer_lens, state_dependent, paste_v3_func, round_stop_state_num, stroke_acc_threshold) best_result_idx = 0 strokes_raw_out = np.stack(strokes_raw_out_list[best_result_idx], axis=0) multi_cursors = [init_cursors[0, best_result_idx, 0]] for c_i in range(len(round_new_cursors)): multi_cursors.append(round_new_cursors[c_i][best_result_idx, 0]) save_seq_data(out_dir, image_basename + '_0', strokes_raw_out, multi_cursors, test_image_size, round_new_lengths, eval_hps.min_width) draw_strokes(strokes_raw_out, out_dir, image_basename + '_0_pred.png', ori_img, test_image_size, multi_cursors, round_new_lengths, eval_hps.min_width, eval_hps.cursor_type, sample_hps.raster_size, sample_hps.min_window_size, sess, pasting_func=paste_v3_func, save_seq=draw_seq, draw_order=draw_color_order) return strokes_raw_out.shape[0] # number of strokes def main(): parser = argparse.ArgumentParser() parser.add_argument('--input_root', type=str, default='sample_inputs/simplified', help="Root directory of input images.") parser.add_argument('--output_root', type=str, default='outputs/sampling/simplified', help="Root directory for outputs.") parser.add_argument('--model', type=str, default='pretrain_clean_line_drawings') parser.add_argument('--model_base_dir', type=str, default='outputs/snapshot') parser.add_argument('--progress_log', type=str, default='outputs/sampling/simplified/_progress.log') parser.add_argument('--skip_existing', action='store_true', default=True) parser.add_argument('--shard', type=str, default='0/1', help="Shard spec 'i/N': this worker processes items " "where index%%N == i (0-indexed).") args = parser.parse_args() # Parse shard try: shard_i, shard_n = (int(x) for x in args.shard.split('/')) except Exception: raise SystemExit("--shard must look like '0/8'") assert 0 <= shard_i < shard_n, "Bad shard" # Hyper-params equivalent to test_vectorization.main() state_dependent = False longer_infer_lens = [500 for _ in range(10)] round_stop_state_num = 12 stroke_acc_threshold = 0.95 np.set_printoptions(precision=8, edgeitems=6, linewidth=200, suppress=True) items = collect_inputs(args.input_root) print('Found {} images under {}'.format(len(items), args.input_root)) # Apply shard filter items = [it for idx, it in enumerate(items) if idx % shard_n == shard_i] print('Shard {}/{} -> {} images'.format(shard_i, shard_n, len(items))) # Build hparams + model ONCE eval_hps, sample_hps = build_eval_hparams(args.model_base_dir, args.model) reset_graph() sampling_model = VirtualSketchingModel(sample_hps) paste_v3_func = DiffPastingV3(sample_hps.raster_size) tfconfig = tf.ConfigProto() tfconfig.gpu_options.allow_growth = True if _NUM_THREADS: n = int(_NUM_THREADS) tfconfig.intra_op_parallelism_threads = n tfconfig.inter_op_parallelism_threads = n sess = tf.InteractiveSession(config=tfconfig) sess.run(tf.global_variables_initializer()) model_dir = os.path.join(args.model_base_dir, args.model) snapshot_step = load_checkpoint(sess, model_dir, gen_model_pretrain=True) print('Loaded snapshot_step:', snapshot_step) # Per-shard progress log progress_log = args.progress_log if shard_n > 1: base, ext = os.path.splitext(progress_log) progress_log = '{}.shard{}of{}{}'.format(base, shard_i, shard_n, ext) os.makedirs(os.path.dirname(progress_log), exist_ok=True) log_f = open(progress_log, 'a', buffering=1) log_f.write('=== run started at {} (shard {}/{}) ===\n'.format( time.strftime('%F %T'), shard_i, shard_n)) log_f.write('total_images={}\n'.format(len(items))) total_time = 0.0 done = 0 failed = [] for idx, (rel_subdir, fname, full_path) in enumerate(items, 1): basename = os.path.splitext(fname)[0] out_dir = os.path.join(args.output_root, rel_subdir, basename) # Skip if already done if args.skip_existing and os.path.exists( os.path.join(out_dir, basename + '_0_pred.png')): print('[{}/{}] SKIP (exists): {}'.format(idx, len(items), full_path)) continue t0 = time.time() try: num_strokes = process_one_image( sess, sampling_model, paste_v3_func, full_path, eval_hps, sample_hps, out_dir, basename, longer_infer_lens, state_dependent, round_stop_state_num, stroke_acc_threshold) elapsed = time.time() - t0 total_time += elapsed done += 1 avg = total_time / done line = ('[{}/{}] OK {:.1f}s strokes={} avg={:.1f}s {}\n' .format(idx, len(items), elapsed, num_strokes, avg, full_path)) print(line, end='') log_f.write(line) except Exception as e: elapsed = time.time() - t0 line = ('[{}/{}] FAIL {:.1f}s {} err={}\n' .format(idx, len(items), elapsed, full_path, repr(e))) print(line, end='') log_f.write(line) failed.append(full_path) summary = ('\n=== Done. processed={}, failed={}, total_time={:.1f}s, ' 'avg={:.2f}s/img ===\n').format( done, len(failed), total_time, total_time / max(done, 1)) print(summary) log_f.write(summary) if failed: log_f.write('Failed files:\n') for f in failed: log_f.write(' ' + f + '\n') log_f.close() if __name__ == '__main__': main()