import argparse import os import sys sys.path.append("./lumina_mgpt/") sys.path.append("./") # print(sys.path) import gc from lumina_mgpt.inference_solver import FlexARInferenceSolver from PIL import Image import torch import time import random import numpy as np import json, csv import re import lumina_mgpt.data.drafters.choices as choices def set_seed(seed: int): """ Args: Helper function for reproducible behavior to set the seed in `random`, `numpy`, `torch`. seed (`int`): The seed to set. """ random.seed(seed) np.random.seed(seed) torch.manual_seed(seed) torch.cuda.manual_seed_all(seed) def load_prompts(args): prompts = [] output_file_name_list = [] if args.prompt == "PartiPrompts": with open('data/prompts/PartiPrompts.tsv', 'r') as f: tsv_reader = csv.DictReader(f, delimiter='\t') ids = 0 for row in tsv_reader: prompts.append(row['Prompt']) output_file_name_list.append(ids) ids += 1 elif args.prompt == "MSCOCO2017Val": from pycocotools.coco import COCO coco = COCO("data/prompts/captions_val2017.json") top_k = 0 for i in range(args.num_images): img_id = coco.getImgIds()[i] img_name = coco.loadImgs(img_id)[0] ann_ids = coco.getAnnIds(imgIds=img_id) anns = coco.loadAnns(ann_ids) for j, ann in enumerate(anns): ann_id = ann['id'] caption = ann["caption"] prompts.append(caption) output_file_name_list.append(ann_id) if j == top_k: break elif args.prompt == "MSCOCO2014Val": with open('data/prompts/captions_val_2014.json', 'r') as f: captions = json.load(f) for caption in captions: prompts.append(caption) elif args.prompt == "MSCOCO2017Train": with open('data/prompts/captions_train2017_extracted.json', 'r') as f: captions = json.load(f) for caption in captions: prompts.append(caption['caption']) elif args.prompt == "SJDPrompts": with open('data/prompts/SJDPrompts.tsv', 'r') as f: tsv_reader = csv.DictReader(f, delimiter='\t') for row in tsv_reader: prompts.append(row['Prompt']) elif args.prompt == "T2ICompBenchVal": with open("data/prompts/T2I-CompBench_val.json", "r", encoding="utf-8") as f: data = json.load(f) for line in data: # 每行是一个独立的JSON对象，逐行解析 prompts.append(line['caption']) output_file_name_list.append(line['image_id']) else: # Single prompt input prompts = [args.prompt] * args.num_images if args.slice is not None: assert re.match(r'^\d+-\d+$', args.slice), f"Invalid format: '{args.slice}'. Expected format is 'start-end'." start, end = map(int, args.slice.split('-')) assert start < end, f"Invalid range: '{args.slice}'. Start value must be less than end value." assert start >= 0 and end >= 0, "Slice values must be non-negative." prompts = prompts[start:end] output_file_name_list = output_file_name_list[start:end] if args.num_images < len(prompts): print(f"Number of images to generate is less than the number of prompts. Sampling {args.num_images} prompts.") if args.benchmark_way == "random": prompts = random.sample(prompts, args.num_images) else: prompts = prompts[:args.num_images] output_file_name_list = output_file_name_list[:args.num_images] else: print(f"Number of images to generate is greater than the number of prompts. Generating only {len(prompts)} images and no sampling.") pass return prompts,output_file_name_list def main(args): static_tree = args.static_tree tree_choices = args.tree_choices lantern_delta = args.lantern_delta groupsum_delta = args.groupsum_delta threshold = args.sjd_pp_threshold try: tree_choices = getattr(choices, args.tree_choices) except AttributeError: print(f"Tree choices {args.tree_choices} is not a valid choice") return # ******************** Args Initation ******************** model_path = args.model_path target_size = args.target_size target_size_h, target_size_w = target_size, target_size device = "cuda:0" # TODO: 修改你的本地chameleon local_chameleon_tokenizer_path=args.tokenizer_path # TODO: 修改你的本地输出地址 output_path = args.output_path output_img_path = os.path.join(output_path,"img") if not os.path.exists(output_path): os.makedirs(output_path) if not os.path.exists(output_img_path): os.makedirs(output_img_path) # ******************** Input Initation ******************** inference_solver = FlexARInferenceSolver( model_path=model_path, precision="bf16", target_size=target_size, device = device, local_chameleon_tokenizer_path = local_chameleon_tokenizer_path ) seeds = [None, ] #[_ for _ in range(124, 200) ] max_num_new_tokens = args.num_init_new_token # 16 multi_token_init_scheme = args.isp # 'repeat_horizon' random image_top_k = 2000 text_top_k = 10 guidance_scale = 3.0 prefix_token_sampler_scheme = args.method # 'jacobi', 'speculative_jacobi' # ******************** Load Benchmark ******************** prompts,output_file_name_list = load_prompts(args) template_condition_sentences = [ f"Generate an image of {target_size_w}x{target_size_h} according to the following prompt:\n", ] * len(prompts) # ******************** Image Generation ******************** from scheduler.jacobi_iteration_lumina_mgpt import renew_pipeline_sampler inference_solver = renew_pipeline_sampler( inference_solver, jacobi_loop_interval_l = 3, jacobi_loop_interval_r = (target_size // 16)**2 + target_size // 16 - 10, max_num_new_tokens = max_num_new_tokens, guidance_scale = guidance_scale, seed = seeds[0], multi_token_init_scheme = multi_token_init_scheme, do_cfg= True, image_top_k=image_top_k, text_top_k=text_top_k, prefix_token_sampler_scheme = prefix_token_sampler_scheme, local_chameleon_tokenizer_path = local_chameleon_tokenizer_path, static_tree = static_tree, ) time_avg = 0 time_avg_forward = 0 avg_acceptance_length = 0 gen_count = 0 with open(f"{output_path}/generation_configs.json", "w") as f: json.dump(vars(args), f, indent=4) global_statistics = {} for seed in seeds: inference_solver.model.seed = seed for i, q_image_content_condition in enumerate(prompts): q1 = template_condition_sentences[i] + q_image_content_condition output_file_name = str(output_file_name_list[i]) + ".png" time_start = time.time() t1 = torch.cuda.Event(enable_timing=True) t2 = torch.cuda.Event(enable_timing=True) torch.cuda.synchronize() t1.record() result = inference_solver.generate( images=[], qas=[[q1, None]], max_gen_len=8192, temperature=1.0, logits_processor=inference_solver.create_logits_processor(cfg=guidance_scale, image_top_k=image_top_k, static_tree = static_tree), return_accl=True, # for static tree static_tree = static_tree, tree_choices = tree_choices, lantern_delta = lantern_delta, groupsum_delta = groupsum_delta, threshold = threshold ) generated = result.input_ids t2.record() torch.cuda.synchronize() t = t1.elapsed_time(t2) / 1000 time_end = time.time() a1, new_image = generated[0], generated[1][0] result_image = inference_solver.create_image_grid([new_image], 1, 1) result_image.save(os.path.join(output_img_path,output_file_name)) time_forward = result.time_forward token_gen_len = result.token_gen_len loop_num = result.loop_num acceptance_length = token_gen_len / loop_num avg_acceptance_length += acceptance_length statistics = { "prompt": q_image_content_condition, "time": time_forward, "acceptance_length": acceptance_length, "loop_num": loop_num, "Time elapsed cuda": t, "Time elapsed": time_end - time_start, "ann_id": output_file_name_list[i] } global_statistics[f"prompt_{i}"] = statistics time_avg += t / len(seeds) time_avg_forward += time_forward with open(f"{args.output_path}/result_{args.slice}.json", "w") as f: json.dump(global_statistics, f, indent=4) gen_count += 1 avg_acceptance_length = avg_acceptance_length/gen_count time_avg = time_avg/gen_count time_avg_forward = time_avg_forward/gen_count statistics = { "method":f"{prefix_token_sampler_scheme}_{multi_token_init_scheme}_{max_num_new_tokens}", "avg_acceptance_length":avg_acceptance_length, "time_forward_avg":time_avg_forward, "time_avg":time_avg, } global_statistics[f"summary"] = statistics with open(f"{args.output_path}/result_{args.slice}.json", "w") as f: json.dump(global_statistics, f, indent=4) print("Average time per generation: ", time_avg) del inference_solver gc.collect() def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("--model_path", default="Alpha-VLLM/Lumina-mGPT-7B-768",type=str, help="location of fake images for evaluation") parser.add_argument("--tokenizer_path", default='/data/lei/localmodel/lumina_mgpt/chameleon/tokenizer',type=str, help="location of the reference images for evaluation") parser.add_argument("--output_path", default='/home/leihaodong/AAAI25/exp/FSJD',type=str) parser.add_argument("--target_size", type=int, default=768) parser.add_argument("--isp", default='random', type=str,help="repeat_horizon, random") parser.add_argument("--method", default='speculative_jacobi', type=str,help="'jacobi', 'speculative_jacobi'") parser.add_argument("--num_init_new_token", type=int, default=16) parser.add_argument("--benchmark_way", default='order', type=str, help="order or sample",) parser.add_argument("--prompt", type=str, help="Prompt for image generation", default="Atlantis, the most Fantasy high-quality photos") parser.add_argument("--num_images", type=int, help="Number of images to generate", default=2) parser.add_argument("--slice", type=str, help="Slice of prompts to use; format: 'start-end'", default=None) #Tree parser.add_argument("--static_tree", action="store_true", help="Enable static tree structure for draft token generation") # Experimental arguments parser.add_argument("--tree_choices", type=str, help="Tree choice for LANTERN", default="mc_sim_7b_63") #lantern parser.add_argument("--lantern_delta", type=int, help="Delta for LANTERN", default=3) #groupsum parser.add_argument("--groupsum_delta", type=float, help="Delta for groupsum", default=0.01) #sjd++ parser.add_argument("--sjd_pp_threshold", type=float, help="Threshold for sjd++", default=0.5) return parser if __name__ == "__main__": parser = parse_args() args = parser.parse_args() main(args)