def main(): from config import load_args args = load_args() load_data(args) # if __name__ == '__main__': # main()
def main(): from config import load_args m = Model(load_args()) for name, param in m.named_parameters(): param.requires_grad = False for name, param in m.named_parameters(): print(name, param.requires_grad)
import tensorflow as tf import numpy as np from config import load_args from lip_model.losses import cer from lip_model.modules import embedding, sinusoid_encoding, multihead_attention, \ feedforward, label_smoothing from lip_model.visual_frontend import VisualFrontend from util.tf_util import shape_list config = load_args() class TransformerTrainGraph(): def __init__(self, x, y, is_training=True, reuse=None, embed_input=False, go_token_index=2, chars=None): self.is_training = is_training self.x = x if config.featurizer: vid_inp = x[0] if type(x) is tuple or type(x) is list else x istarget = tf.not_equal(vid_inp, 0) self.padding_mask = tf.to_float( tf.reduce_any(istarget, axis=[2, 3, 4]))
discriminator = Discriminator( from_rgb_activate=not args.no_from_rgb_activate) g_running = StyleGAN() if args.cuda: generator = generator.cuda() discriminator = discriminator.cuda() g_running = g_running.cuda() g_running.train(False) g_optimizer = optim.Adam(generator.generator.parameters(), lr=args.lr, betas=(0., 0.99)) g_optimizer.add_param_group({ 'params': generator.style.parameters(), 'lr': args.lr * 0.01, 'mult': 0.01 }) d_optimizer = optim.Adam(discriminator.parameters(), lr=args.lr, betas=(0., 0.99)) accumulate(g_running, generator, 0) train(args, train_loader, generator, g_running, discriminator, g_optimizer, d_optimizer) if __name__ == '__main__': args = load_args() main(args)
checkpoint = torch.load(f) state_dict = canonical_state_dict_keys(checkpoint['state_dict']) model.load_state_dict(state_dict) logger.info(f"Finished loading ckpt in {time.time() - tic:.3f}s") logger.info(f"CUDA device count: {torch.cuda.device_count()}") device_count = torch.cuda.device_count() models = [] for device_ind in range(device_count): device = f"cuda:{device_ind}" models.append(copy.deepcopy(model).to(device)) models[device_ind].eval() from config import load_args configdl = load_args() graph_dict = { 'train': TransformerTrainGraph, 'infer': TransformerInferenceGraph, } def init_models_and_data(istrain): print('Loading data generators') val_gen, val_epoch_size = setup_generators() os.environ["CUDA_VISIBLE_DEVICES"] = str(configdl.gpu_id) gpu_options = tf.GPUOptions(allow_growth=True) sess_config = tf.ConfigProto(gpu_options=gpu_options) sess = tf.Session(config=sess_config)
def main(): args = load_args() load_data(args)
im = PIL.Image.open(images[ii]) im.thumbnail((300, 300)) grid.paste(im, (0, 0)) index = 0 for i in range(300, 900, 300): for j in range(0, 900, 300): im = PIL.Image.open(closest[index]) im.thumbnail((300, 300)) grid.paste(im, (i, j)) index += 1 grid.save( f"{dataset_folder}/grids/{images[ii].split('/')[-1].split('.')[0]}.png" ) # generate_grids() args = config.load_args("config/sim.json") for ii, main_im in enumerate(tqdm(images)): for imfile in closest[ii]: args.style = f"{main_im},{imfile}" # print(args.style) style.img_img(args) for imfiles in itertools.combinations(closest[ii], 2): args.style = f"{main_im}{','.join(imfiles)}" style.img_img(args)
} else: ydl_opts = { 'outtmpl': download_location, 'quiet': 'true', 'format': 'bestaudio/best', } # Download the shit with youtube_dl.YoutubeDL(ydl_opts) as ydl: ydl.download([link]) print(download_location) if __name__ == '__main__': # Load arguments args = config.load_args() config = config.load_config() # If custom location is set, use it if args.output: output = args.output # If no custom location is set: use project directory else: output = prog_path # If ID is given, try to download the specific ID, error if something goes wrong if args.ID: download_set(args.ID) # If list with ID's is provided, loop through file and try download for each setID if args.list: try: f = open(args.list, "r") for line in f:
growth_factor = math.sqrt(math.sqrt(2)) if autoscale_args.precision == "high": growth_factor = math.sqrt(math.sqrt(math.sqrt(2))) min_size = autoscale_args.min_size print("\n\n\n\nmodels:", mods) print("optimizers:", opts) print("#GPUs:", num_gpus) print("starting from size:", min_size) print("scaling with factor:", growth_factor, "\n\n\n") im = lambda size: torch.rand(size=(1, 3, int(round(size)), int(round(size))) ) * 255 args = config.load_args("config/img_img.json") args.print_iter = -1 args.save_iter = -1 max_sizes = {} for mod, opt, gpus in [(mod, opt, gpus) for gpus in range(1, num_gpus + 1) for opt in opts for mod in mods]: conf = f"{mod}+{opt}+{gpus}" print(f"\nmodel: {mod.upper()} optimizer: {opt.upper()} #GPUs: {gpus}") max_sizes[conf] = {} if opt == "lbfgs" and gpus == 1: size = min_size / growth_factor else: # size >= that of previous more memory hungry config
def main(): print('~~~ Starting dimension estimation! ~~~') # load config file args = config.load_args() # make output folder if it doesn't exist already if not os.path.exists(args.save_dir): os.mkdir(args.save_dir) # save args to json file with open(args.save_dir + 'commandline_args.txt', 'w') as file2: json.dump(args.__dict__, file2, indent=2) # get model print(' > Loading model...') model = get_model(args) device = args.device model.cuda(device) model.eval() # get dataset print(' > Preparing dataset...') dataloader = get_dataloader(args) if args.model.split('_')[0] == 'vit': patch_size = int(args.model.split('_')[-2][-2:]) # create dict with n_factor lists and factor list factor_list = [] output_dict = {'example1': [], 'example2': []} print(' > Processing starting...') # for-loop inference and store values as numpy array for i, (factor, example1, example2, _, _) in enumerate(dataloader): # move data to GPU example1, example2 = example1.cuda(device), example2.cuda(device) # pass images through model and get distribution mean if args.model.split('_')[0] == 'vit': output1 = model(example1, patch=patch_size).mode()[0] output2 = model(example2, patch=patch_size).mode()[0] else: output1 = model(example1).mode()[0] output2 = model(example2).mode()[0] # add factor and output to list / array for processing dimensions later on factor_list.append(factor.detach().cpu().numpy()) output_dict['example1'].append(output1.detach().cpu().numpy()) output_dict['example2'].append(output2.detach().cpu().numpy()) if i % 10000 == 0: print('Processing example {}/{}'.format(i, len(dataloader))) print(' > Finished processing examples...') print(' > Starting Dimensionality Estimation!') # dimensionality estimation dims, dims_percent = dim_est(output_dict, factor_list, args) print(" >>> Estimated factor dimensionalities: {}".format(dims)) print(" >>> Ratio to total dimensions: {}".format(dims_percent)) print('Saving results to {}'.format(args.save_dir)) # save to output folder with open(args.save_dir + '/' + args.model + '_dim_est.csv', mode='w') as file1: writer = csv.writer(file1, delimiter=',') writer.writerow(dims) writer.writerow(dims_percent)