def parse_args(): parser = argparse.ArgumentParser(description='3DMM Fitting') parser.add_argument('-j', '--workers', default=6, type=int) parser.add_argument('--epochs', default=40, type=int) parser.add_argument('--start-epoch', default=1, type=int) parser.add_argument('-b', '--batch-size', default=128, type=int) parser.add_argument('-vb', '--val-batch-size', default=32, type=int) parser.add_argument('--base-lr', '--learning-rate', default=0.001, type=float) parser.add_argument('--momentum', default=0.9, type=float, metavar='M', help='momentum') parser.add_argument('--weight-decay', '--wd', default=5e-4, type=float) parser.add_argument('--print-freq', '-p', default=20, type=int) parser.add_argument('--resume', default='', type=str, metavar='PATH') parser.add_argument('--devices-id', default='0,1', type=str) parser.add_argument('--filelists-train', default='', type=str) parser.add_argument('--filelists-val', default='', type=str) parser.add_argument('--root', default='') parser.add_argument('--snapshot', default='', type=str) parser.add_argument('--log-file', default='output.log', type=str) parser.add_argument('--log-mode', default='w', type=str) parser.add_argument('--size-average', default='true', type=str2bool) parser.add_argument('--num-classes', default=62, type=int) parser.add_argument('--arch', default='mobilenet_1', type=str, choices=arch_choices) parser.add_argument('--frozen', default='false', type=str2bool) parser.add_argument('--milestones', default='15,25,30', type=str) parser.add_argument('--task', default='all', type=str) parser.add_argument('--test_initial', default='false', type=str2bool) parser.add_argument('--warmup', default=-1, type=int) parser.add_argument('--param-fp-train', default='', type=str) parser.add_argument('--param-fp-val', default='') parser.add_argument('--opt-style', default='resample', type=str) # resample parser.add_argument('--resample-num', default=132, type=int) parser.add_argument('--loss', default='vdc', type=str) global args args = parser.parse_args() # some other operations args.devices_id = [int(d) for d in args.devices_id.split(',')] args.milestones = [int(m) for m in args.milestones.split(',')] snapshot_dir = osp.split(args.snapshot)[0] mkdir(snapshot_dir)
def plot_case(images, all_scores, raw_scores, locations, derender_objects, gt_objects, case_name, output_folder): fig, (ax1, ax3, ax2) = plt.subplots(nrows=3, ncols=1, figsize=(4.5, 10)) line, = ax2.plot([], [], "k") mkdir(os.path.join(output_folder, "imgs")) for i, (image, raw_score, xs, ys, derender_object, gt_object) in enumerate( zip(images, raw_scores, locations[0], locations[1], derender_objects, gt_objects), 1): ax1.imshow(image) ax1.axis('off') ax2.clear() line.set_xdata(range(i)) line.set_ydata(all_scores[:i]) ax2.plot(range(i), all_scores[:i]) ax2.axvline(x=i, color="r", linestyle='--') plt.draw() perturbed_score = [] for score in raw_score: perturbed_score.append(score + np.random.rand() * .001) bp = ax2.boxplot(perturbed_score, positions=[i], showfliers=False, showcaps=False, whis=[25, 75]) for element in ['boxes', 'whiskers', 'fliers', 'means', 'medians', 'caps']: plt.setp(bp[element], color="#1f77b4") ax2.set_xlim(0, len(images)) ax2.set_ylim(0, 12) ax2.get_xaxis().set_ticklabels([]) ax2.axes.get_yaxis().set_ticklabels([]) ax3.clear() ax3.scatter(ys, [-x for x in xs], 40, alpha=.2) derender_xs = [obj["location"][1] for obj in derender_object["objects"]] derender_ys = [-obj["location"][0] for obj in derender_object["objects"]] ax3.scatter(derender_xs, derender_ys, 10) if gt_object is not None: gt_xs = [obj["location"][1] for obj in gt_object["objects"]] gt_ys = [-obj["location"][0] for obj in gt_object["objects"]] ax3.scatter(gt_xs, gt_ys, 10) ax3.set_xlim(-4, 4) ax3.set_ylim(-1., 2.5) ax3.get_xaxis().set_ticklabels([]) ax3.get_yaxis().set_ticklabels([]) fig.savefig("{}/imgs/{}_{:03d}.png".format(output_folder, case_name, i)) print("{}/imgs/{}_{:03d}.png generated".format(output_folder, case_name, i)) fig.savefig("{}/{}_score.png".format(output_folder, case_name))
def main(): args = parse_args() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_dir = mkdir(cfg.OUTPUT_DIR) assert_proper_output_dir(args.config_file, output_dir) logger = setup_logger("train_logger", os.path.join(output_dir, "log.txt")) logger.info("Running with config:\n{}".format(cfg)) train(cfg, args)
def main(args): cfg = default_cfg.clone() cfg.merge_from_file(args.config_file) cfg.merge_from_list(args.opts) cfg.freeze() output_folder = mkdir(cfg.OUTPUT_FOLDER) assert_proper_output_dir(args.config_file, output_folder) start_time = time.time() processes = [] case_names = cfg.CASE_NAMES if len(case_names) == 0: case_names = sorted([dir_name for dir_name in os.listdir(cfg.ANNOTATION_FOLDER) if os.path.isdir(os.path.join(cfg.ANNOTATION_FOLDER, dir_name)) and "." not in dir_name]) if args.start_index is None: start_index = get_host_id() % args.stride else: start_index = args.start_index case_names = case_names[start_index::args.stride] manager = Manager() n_filter = manager.Semaphore(1) args.n_filter = n_filter for case_name in case_names: p = Process(target=run_updater, args=(cfg, args, case_name)) processes.append(p) p.start() break #ERASE for p in processes: p.join() if not args.only_plot: for case_name in case_names: results = read_serialized(os.path.join(output_folder, "results", "{}.json".format(case_name))) print(case_name, {key: result for key, result in results[case_name].items() if key in ["sum", "mean", "max"]}) print('| finish with time ', time.time() - start_time)
USER_HOME_CONFIG_PATH = f"{USER_HOME_PATH}/.config" BACKUP_DIR = "backup-pc" BACKUP_NAME = f"{BACKUP_DIR}.txz" BACKUP_PATH = f"{TMP_PATH}/{BACKUP_DIR}" BACKUP_HOME_PATH = f"{BACKUP_PATH}/_home" BACKUP_HOME_CONFIG_PATH = f"{BACKUP_HOME_PATH}/_config" BACKUP_ETC_PATH = f"{BACKUP_PATH}/_etc" BACKUP_VAR_PATH = f"{BACKUP_PATH}/_var" # Create a temp directory for backup io.cd(TMP_PATH) io.rm2([BACKUP_DIR, BACKUP_NAME]) ## Backup ~ ## # .config io.mkdir(BACKUP_HOME_CONFIG_PATH) io.cp_file(f"{USER_HOME_CONFIG_PATH}/katerc", BACKUP_HOME_CONFIG_PATH) io.cp_dir(f"{USER_HOME_CONFIG_PATH}/bunkus.org", f"{BACKUP_HOME_CONFIG_PATH}/bunkus.org") io.cp_file(f"{USER_HOME_CONFIG_PATH}/mkvtoolnix-guirc", BACKUP_HOME_CONFIG_PATH) io.cp_file(f"{USER_HOME_CONFIG_PATH}/makemkvrc", BACKUP_HOME_CONFIG_PATH) io.cp_dir(f"{USER_HOME_CONFIG_PATH}/Transmission Remote GUI", f"{BACKUP_HOME_CONFIG_PATH}/Transmission Remote GUI") # mpv io.mkdir(f"{BACKUP_HOME_CONFIG_PATH}/mpv") io.cp_dir(f"{USER_HOME_CONFIG_PATH}/mpv/hrtf", f"{BACKUP_HOME_CONFIG_PATH}/mpv") io.cp_file(f"{USER_HOME_CONFIG_PATH}/mpv/input.conf", f"{BACKUP_HOME_CONFIG_PATH}/mpv") io.cp_file(f"{USER_HOME_CONFIG_PATH}/mpv/mpv.conf",
from utils.io import read_serialized, mkdir from utils.constants import CONTENT_FOLDER """ _shape_net_names = ['airplane', 'ashcan', 'bag', 'basket', 'bathtub', 'bed', 'bench', 'bicycle', 'birdhouse', 'bookshelf', 'bottle', 'bowl', 'bus', 'cabinet', 'camera', 'can', 'cap', 'car', 'chair', 'computer_keyboard', 'dishwasher', 'display', 'earphone', 'faucet', 'file', 'guitar', 'helmet', 'jar', 'knife', 'lamp', 'laptop', 'loudspeaker', 'mailbox', 'microphone', 'microwave', 'motorbike', 'mug', 'piano', 'pillow', 'pistol', 'pot', 'printer', 'remote', 'rifle', 'rocket', 'skateboard', 'sofa', 'stove', 'table', 'telephone', 'tower', 'train', 'vessel', 'washer', 'wine_bottle'] """ _shape_net_names_sample = ['airplane', 'ashcan', 'bag', 'basket', 'bathtub', 'bed', 'bench', 'bicycle', 'birdhouse', 'bookshelf', 'bottle', 'bowl', 'bus', 'cabinet', 'camera', 'can', 'cap'] SIM_SHAPE_FOLDER = mkdir(os.path.join(CONTENT_FOLDER, "phys_sim", "data", "shapes")) RENDER_SHAPE_FOLDER = mkdir(os.path.join(CONTENT_FOLDER, "render", "data", "shapes")) SIM_SHAPE_NET_FOLDER = mkdir(os.path.join(CONTENT_FOLDER, "phys_sim", "data", "additional_shapes")) RENDER_SHAPE_NET_FOLDER = mkdir(os.path.join(CONTENT_FOLDER, "render", "data", "additional_shapes")) if len(os.listdir(SIM_SHAPE_NET_FOLDER)) > 0: SHAPE_NET_CATEGORY = {"{:04d}".format(i): name for i, name in enumerate(_shape_net_names_sample)} SHAPE_NET_NUMS = {"{:04d}".format(i): len(os.listdir(os.path.join(SIM_SHAPE_NET_FOLDER, "{:04d}".format(i)))) for i in range(len(_shape_net_names_sample))} SHAPE_NET_CATEGORY_INVERSE = {v: k for k, v in SHAPE_NET_CATEGORY.items()} if os.path.exists(os.path.join(SIM_SHAPE_NET_FOLDER, "all_dimensions.json")): _shape_net_dimensions = read_serialized(os.path.join(SIM_SHAPE_NET_FOLDER, "all_dimensions.json")) else: _shape_net_dimensions = dict()
def main(config): # main script rendering = config.rendering mkdir(rendering.output_dir) mkdir(os.path.join(rendering.output_dir, 'imgs')) mkdir(os.path.join(rendering.output_dir, 'masks')) mkdir(os.path.join(rendering.output_dir, 'depths')) mkdir(os.path.join(rendering.output_dir, 'flows')) clr_dir(os.path.join(rendering.output_dir, 'imgs')) clr_dir(os.path.join(rendering.output_dir, 'masks')) clr_dir(os.path.join(rendering.output_dir, 'depths')) clr_dir(os.path.join(rendering.output_dir, 'flows')) add_ground(rendering) # set up render parameters render_args = bpy.context.scene.render render_args.engine = 'CYCLES' render_args.resolution_x = rendering.width render_args.resolution_y = rendering.height render_args.resolution_percentage = 100 render_args.tile_x = rendering.render_tile_size render_args.tile_y = rendering.render_tile_size if rendering.use_gpu: if True: enable_gpus() render_args.tile_x = rendering.render_tile_size_gpu render_args.tile_y = rendering.render_tile_size_gpu else: # blender changed the API for enabling CUDA at some point pref = bpy.context.user_preferences.addons["cycles"].preferences pref.compute_device_type = "CUDA" for device in pref.devices: device.use = True # bpy.context.user_preferences.system.compute_device_type = 'CUDA' # bpy.context.user_preferences.system.compute_device = 'CUDA_0' render_args.tile_x = rendering.render_tile_size_gpu render_args.tile_y = rendering.render_tile_size_gpu # some CYCLES-specific stuff bpy.data.worlds['World'].cycles.sample_as_light = True bpy.context.scene.cycles.blur_glossy = 2.0 bpy.context.scene.cycles.samples = rendering.render_num_samples bpy.context.scene.cycles.transparent_min_bounces = rendering.render_min_bounces bpy.context.scene.cycles.transparent_max_bounces = rendering.render_max_bounces if rendering.use_gpu: bpy.context.scene.cycles.device = 'GPU' bpy.context.scene.use_nodes = True bpy.context.scene.view_layers['RenderLayer'].use_pass_object_index = True # set up camera set_camera(rendering.camera_rho, rendering.camera_theta, rendering.camera_phi, look_at=rendering.camera_look_at) # apply jitter to lamp positions if rendering.key_light_jitter > 0: for i in range(3): bpy.data.objects['Lamp_Key'].location[i] += rand_jitter( rendering.key_light_jitter) if rendering.back_light_jitter > 0: for i in range(3): bpy.data.objects['Lamp_Back'].location[i] += rand_jitter( rendering.back_light_jitter) if rendering.fill_light_jitter > 0: for i in range(3): bpy.data.objects['Lamp_Fill'].location[i] += rand_jitter( rendering.fill_light_jitter) # set up objects om = ObjectManager(config, rendering.shape_dir, rendering.material_dir, rendering.back_wall) mask_node = set_mask(os.path.join(rendering.output_dir, "masks")) depth_node = set_depth(os.path.join(rendering.output_dir, "depths")) flow_node = set_flow(os.path.join(rendering.output_dir, "flows")) # load motion with open(rendering.motion_file, 'r') as f: input_file = json.load(f) time_step = float(input_file['timestep']) motion = input_file['motion'] # render it render_every = int(1 / time_step / rendering.fps) if render_every == 0: render_every = 1 camera = dict(camera_rho=rendering.camera_rho, camera_theta=rendering.camera_theta, camera_phi=rendering.camera_phi, camera_look_at=rendering.camera_look_at) scene_anns = dict(case_name=config.case_name, camera=camera, scene=[]) if rendering.intro_time > 0: render_intro(om, rendering, motion[0]) for n, m in enumerate(motion): if n % render_every == 0: bpy.context.scene.frame_set(n) # objects are before occluders for i, obj_motion in enumerate(m["objects"] + m["occluders"]): loc = obj_motion['location'] euler = convert_euler(obj_motion['orientation']) om.set_position(om.obj_names[i], loc, euler, key_frame=True) i = len(m["objects"]) + len(m["occluders"]) for desk_motion in m["desks"]: for obj_motion in desk_motion: loc = obj_motion['location'] euler = convert_euler(obj_motion['orientation']) om.set_position(om.obj_names[i], loc, euler, key_frame=True) i += 1 for n, m in enumerate(motion): if "ABORT" in globals(): if globals()["ABORT"]: print("Aborted") raise KeyboardInterrupt if n % render_every == 0: bpy.context.scene.frame_set(n) image_path = os.path.join( rendering.output_dir, 'imgs', '%s_%06.2fs.png' % (rendering.image_prefix, n * time_step)) render_args.filepath = image_path mask_base_name = '####_%s_%06.2fs.png' % (rendering.image_prefix, n * time_step) mask_node.file_slots[0].path = mask_base_name depth_base_name = '####_%s_%06.2fs.png' % (rendering.image_prefix, n * time_step) depth_node.file_slots[0].path = depth_base_name for ch in "RGBA": flow_base_name = '%s_####_%s_%06.2fs.png' % ( ch, rendering.image_prefix, n * time_step) flow_node[ch].file_slots[0].path = flow_base_name bpy.ops.render.render(write_still=True) frame_anns = dict(image_path=image_path, objects=[]) mask_file_path = os.path.join( rendering.output_dir, "masks", "{:04d}".format(n) + mask_base_name[4:]) for i, obj_motion in enumerate(m["objects"] + m["occluders"]): mask = imread(mask_file_path)[:, :, 0] == i + 1 frame_anns["objects"].append(om.log(i, obj_motion, mask)) scene_anns["scene"].append(frame_anns) bpy.ops.wm.save_as_mainfile(filepath=os.path.join(rendering.output_dir, "scene.blend"), compress=True) write_serialized( scene_anns, os.path.join(rendering.output_dir, "{:s}_ann.yaml".format(rendering.image_prefix)))
import numpy as np from easydict import EasyDict from dataset.make_all import generate from utils.geometry import random_spherical_point, get_prospective_location from utils.io import mkdir, write_serialized, catch_abort from utils.constants import CONFIG_FOLDER, SIM_OUTPUT_FOLDER, RENDER_OUTPUT_FOLDER, VIDEO_OUTPUT_FOLDER, \ OCCLUDER_HALF_WIDTH from utils.misc import rand, random_distinct_colors, repeat_scale, get_host_id, BlenderArgumentParser from utils.shape_net import SHAPE_DIMENSIONS, random_shape_net default_shapes = [ 'boot', 'bowling_pin', 'cone', 'cube', 'cylinder', 'sphere', 'toy', 'truck' ] train_prefix = "train" TRAIN_CONFIG_FOLDER = mkdir(os.path.join(CONFIG_FOLDER, train_prefix)) TRAIN_SIM_OUTPUT_FOLDER = mkdir(os.path.join(SIM_OUTPUT_FOLDER, train_prefix)) TRAIN_RENDER_OUTPUT_FOLDER = mkdir( os.path.join(RENDER_OUTPUT_FOLDER, train_prefix)) TRAIN_VIDEO_OUTPUT_FOLDER = mkdir( os.path.join(VIDEO_OUTPUT_FOLDER, train_prefix)) def parse_args(): parser = BlenderArgumentParser(description='') parser.add_argument('--start', help='image index to start', type=int, default=0) parser.add_argument('--start_index', help='image index to start', type=int) parser.add_argument('--end',
df_fam = pd.DataFrame({'MID': mids}) df_fam = df_fam.join(df_rel_mat.loc[ids][cols]) df_fam = df_fam.join(pd.DataFrame({'Gender': genders, 'Name': names})) if do_save: df_fam.to_csv(dirs_out + "/" + fid + "/mid.csv", index=False) dfs_fams.append(df_fam) return dfs_fams logger = [] if __name__ == '__main__': logger = log.setup_custom_logger(__name__, f_log=CONFIGS.path.f_log,level=log.INFO) # logger.setLevel() from pyfiw.configs import CONFIGS out_bin = CONFIGS.path.dpairs io.mkdir(out_bin) dir_fids = dir_home() + "master-version/fiwdb/FIDs/" # dir_fid = dir_home() + "/Dropbox/Families_In_The_Wild/Database/Ann/FW_FIDs/" dir_families = io.sys_home() + 'master-version/fiwdb/FIDs/' do_sibs = True do_parents = True do_grandparents = True do_save = True parse_fids = False load_families = False if load_families: fams = fiw.load_families(dir_families) logger.info("Output Bin: {}\nFID folder: {}".format(out_bin, dir_fids)) logger.info("Parsing siblings: {}\nSaving Pairs: {}\n Parse FIDs: {}".format(do_sibs, do_save, parse_fids))
#!/usr/bin/env python3 # coding: utf-8 """ Backup Plex Media Server library """ import os from pathlib import Path from utils import io if __name__ == "__main__": HOME_PATH = Path("/home/nyxouf") BACKUP_PATH = Path("/data/tmp_pms") BACKUP_FILE = Path("pms.tar.lz4") io.rm(BACKUP_PATH) io.mkdir(BACKUP_PATH) io.cd(BACKUP_PATH) os.system("rsync --quiet --archive --exclude 'Logs' --exclude 'Crash Reports' --exclude 'plexmediaserver.pid' --exclude 'Updates' '/internal/plex' .") #io.cd(HOME_PATH) io.cd("/data") TARCF = f"tar cf - {str(BACKUP_PATH)} | lz4 -1 > {str(BACKUP_FILE)}" os.system(TARCF) io.chown(BACKUP_FILE, "nyxouf", "nyxouf") io.chmod(BACKUP_FILE, 777) io.rm(BACKUP_PATH) io.mv(BACKUP_FILE, f"/backup/data/{str(BACKUP_FILE)}")
def run_updater(cfg, args, case_name): output_folder = cfg.OUTPUT_FOLDER result_folder = mkdir(os.path.join(output_folder, "results")) gt = read_serialized(os.path.join(cfg.ANNOTATION_FOLDER, case_name, case_name + "_ann.yaml")) camera = gt["camera"] observation_path = os.path.join(cfg.OBSERVATION_FOLDER, case_name + ".json") scenes = read_serialized(observation_path)['scene'] for s in scenes: for o in s["objects"]: if "color" not in o: o["color"] = "green" if not args.only_plot: mkdir(os.path.join(output_folder, "logs")) logger = setup_logger("{}{}".format(cfg.LOG_PREFIX, case_name), os.path.join(cfg.OUTPUT_FOLDER, "logs", "{}.txt".format(case_name))) logger.info('{} start running '.format(case_name)) logger.info(args) logger.info("Running with config:\n{}".format(cfg)) # run updater init_belief = scenes[0]['objects'] filter_updater = FilterUpdater(cfg, init_belief, case_name, camera, args.n_filter) filter_updater.run(scenes[1:]) score = filter_updater.get_score() write_serialized({case_name: score}, os.path.join(result_folder, "{}.json".format(case_name))) with open(os.path.join(output_folder, "{}.txt".format(case_name)), 'w') as fout: fout.write( '| negative log likelihood: ' + json.dumps( {key: result for key, result in score.items() if key in ["sum", "mean", "max", "sum_lower", "mean_lower", "max_lower"]}) + '\n') logger.info('{} completed running '.format(case_name)) else: results = read_serialized(os.path.join(result_folder, "{}.json".format(case_name))) score = results[case_name] images_files = [ann["image_path"] for ann in gt["scene"]][6:] with ThreadPool(cpu_count() * 4) as p: images = p.map(Image.open, images_files) plot_case(images, score["all"], score["raw"], score["location"], scenes[1:], [None] * len(images), case_name, output_folder) # os.system( # '/data/vision/billf/object-properties/local/bin/ffmpeg -nostdin -r %d -pattern_type glob -i \'%s/%s.png\' ' # '-pix_fmt yuv420p -vcodec libx264 -crf 0 %s.mp4 -y' # % (15, "{}/imgs".format(output_folder), "{}_???".format(case_name), # "{}/{}_summary".format(output_folder, case_name))) # print('ffmpeg -nostdin -r %d -pattern_type glob -i \'%s/%s.png\' ' # '-pix_fmt yuv420p -vcodec libx264 -crf 0 %s.mp4 -y' # % (15, "{}/imgs".format(output_folder), "{}_???".format(case_name), # "{}/{}_summary".format(output_folder, case_name))) os.system( 'ffmpeg -nostdin -r %d -pattern_type glob -i \'%s/%s.png\' ' '-pix_fmt yuv420p -vcodec libx264 -crf 0 %s.mp4 -y' % (15, "{}/imgs".format(output_folder), "{}_???".format(case_name), "{}/{}_summary".format(output_folder, case_name)))
import argparse import os from easydict import EasyDict from multiprocessing import Pool, cpu_count, Process from dataset.human.build_occluders import get_occluders from dataset.human.build_objects import get_objects from dataset.make_all import generate from utils.io import write_serialized, catch_abort, mkdir from utils.constants import SIM_OUTPUT_FOLDER, RENDER_OUTPUT_FOLDER, VIDEO_OUTPUT_FOLDER, CONFIG_FOLDER from utils.misc import random_distinct_colors, get_host_id, BlenderArgumentParser from utils.shape_net import SHAPE_NET_CATEGORY, SHAPE_CATEGORY HUMAN_CONFIG_FOLDER = mkdir(os.path.join(CONFIG_FOLDER, "human")) HUMAN_SIM_OUTPUT_FOLDER = mkdir(os.path.join(SIM_OUTPUT_FOLDER, "human")) HUMAN_RENDER_OUTPUT_FOLDER = mkdir(os.path.join(RENDER_OUTPUT_FOLDER, "human")) HUMAN_VIDEO_OUTPUT_FOLDER = mkdir(os.path.join(VIDEO_OUTPUT_FOLDER, "human")) def parse_args(): parser = BlenderArgumentParser(description='') parser.add_argument('--start_index', help='image index to start', type=int) parser.add_argument("--stride", help="image index stride", type=int, default=1) parser.add_argument("--requires_valid", type=int, default=0) parser.add_argument("--preview", type=int, default=0) return parser.parse_args()
if __name__ == "__main__": TMP_PATH = "/tmp" HOME_PATH = "/home/pi" BACKUP_DIR = "backup-mpd" BACKUP_NAME = f"{BACKUP_DIR}.txz" BACKUP_PATH = f"{TMP_PATH}/{BACKUP_DIR}" BACKUP_HOME_PATH = f"{BACKUP_PATH}/_home" BACKUP_ETC_PATH = f"{BACKUP_PATH}/_etc" BACKUP_VAR_PATH = f"{BACKUP_PATH}/_var" BACKUP_SYSTEMD_PATH = f"{BACKUP_PATH}/_systemd" # Create a temp directory for backup io.cd(TMP_PATH) io.rm2([BACKUP_DIR, BACKUP_NAME]) io.mkdir(BACKUP_PATH) # Backup home folder io.mkdir(BACKUP_HOME_PATH) io.cp_dir(f"{HOME_PATH}/mpd", f"{BACKUP_HOME_PATH}/mpd") io.cp_file(f"{HOME_PATH}/.zpreztorc", BACKUP_HOME_PATH) io.cp_file(f"{HOME_PATH}/.zshrc", BACKUP_HOME_PATH) # Backup /etc io.mkdir(BACKUP_ETC_PATH) io.cp_dir("/etc/nginx", f"{BACKUP_ETC_PATH}/nginx") io.cp_file("/etc/fstab", BACKUP_ETC_PATH) io.cp_file("/etc/mpd.conf", BACKUP_ETC_PATH) # Backup services io.mkdir(BACKUP_SYSTEMD_PATH)
big_shapes = ["{:04d}".format(x) for x in range(55) if x % 5 == 0] return big_shapes _suffices = [".mp4", ".ogv"] def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("--overwrite", type=int, default=0) return parser.parse_args() if __name__ == '__main__': args = parse_args() new_human_folder = mkdir(os.path.join(VIDEO_OUTPUT_FOLDER, "human_new_2")) clr_dir(new_human_folder) file_map = dict(origin=[], destination=[]) experiment_id = 0 for shape_cat in SHAPE_CATS: big_shapes = get_shapes_from_cat(shape_cat) for violation, pairs in CASE_PAIRS.items(): shapes = random.sample(big_shapes, k=2) for shape in shapes: case, index = pairs[0] origin = "human_{}_{}_{}".format(case, shape, index) destination = "{:03d}_surprise_human_{}_{}_{}".format( experiment_id, case, shape, index) print(origin, destination) experiment_id += 1
def plot_result(data_folder, video_file, output_folder): video_result = read_serialized(video_file) images = get_images(data_folder, video_result) raw_scores = video_result["scores"]["raw"] locations = video_result["scores"]["location"] all_scores = video_result["scores"]["all"] case_name = video_result["original_video"].replace("/", "--") derender_objects = read_serialized( video_result["scene_file"])["scene_states"] fig, (ax1, ax3, ax2) = plt.subplots(nrows=3, ncols=1, figsize=(4.5, 10)) line, = ax2.plot([], [], "k") images_folder = "{}/.tmp_imgs/".format(output_folder) shutil.rmtree(images_folder, ignore_errors=True) mkdir(images_folder) for i, (image, raw_score, xs, ys, derender_object, gt_object) in enumerate( zip(images, raw_scores, locations[0], locations[1], derender_objects, repeat(None)), 1): ax1.imshow(image) ax1.axis('off') ax2.clear() line.set_xdata(range(i)) line.set_ydata(all_scores[:i]) ax2.plot(range(i), all_scores[:i]) ax2.axvline(x=i, color="r", linestyle='--') plt.draw() perturbed_score = [] for score in raw_score: perturbed_score.append(score + np.random.rand() * .001) bp = ax2.boxplot(perturbed_score, positions=[i], showfliers=False, showcaps=False, whis=[25, 75]) for element in [ 'boxes', 'whiskers', 'fliers', 'means', 'medians', 'caps' ]: plt.setp(bp[element], color="#1f77b4") ax2.set_xlim(0, len(images)) ax2.set_ylim(0, 12) ax2.get_xaxis().set_ticklabels([]) ax2.axes.get_yaxis().set_ticklabels([]) ax3.clear() ax3.scatter(ys, [-x for x in xs], 40, alpha=.2) derender_xs = [ obj["location"][1] for obj in derender_object["objects"] ] derender_ys = [ -obj["location"][0] for obj in derender_object["objects"] ] ax3.scatter(derender_xs, derender_ys, 10) if gt_object is not None: gt_xs = [obj["location"][1] for obj in gt_object["objects"]] gt_ys = [-obj["location"][0] for obj in gt_object["objects"]] ax3.scatter(gt_xs, gt_ys, 10) ax3.set_xlim(-4, 4) ax3.set_ylim(-1., 2.5) ax3.get_xaxis().set_ticklabels([]) ax3.get_yaxis().set_ticklabels([]) os.makedirs(output_folder, exist_ok=True) fig.savefig(os.path.join(images_folder, "{:05d}.png".format(i))) print("{}/.tmp_imgs/{:05d}.png generated".format(output_folder, i)) fig.savefig("{}/{}_score.png".format(output_folder, case_name)) render_video(images_folder, output_folder, case_name)