def recombination(): """ Detect recombination in VGS data. FASTQ files containing the data are read from an input folder and processed to return the sequences before and after a seed sequence. The output are CSV files, one per FASTQ file and per seed sequence.' """ setup_dirs(params) input_files = get_fastq_files(params) output_files = [] for input_file in input_files: for seed_sequence_name, seed_sequence in params.seed_sequences.items(): L.info('Processing file: {} with seed sequence: {}...'.format( input_file, seed_sequence_name)) processor = Processor(input_file, seed_sequence_name, seed_sequence.upper()) try: output_file = processor.process_and_write_to_file( params.output_folder) if output_file: output_files.append(output_file) except Exception as e: L.error(' >> Error: {}. Ignoring file...'.format(e)) L.info('\nDone! Your output is in the following {} files:'.format( str(len(output_files)))) for output_file in output_files: L.info(output_file)
def process_dir(root_dir, subdir, template): curr_dir = os.path.join(root_dir, subdir) # Look for template in current dir template_file = os.path.join(curr_dir, config.TEMPLATE_FILE) if os.path.exists(template_file): template = Template(template_file) # look for images in current dir to process paths = config.Paths(os.path.join(args['output_dir'], subdir)) exts = ('*.png', '*.jpg') omr_files = sorted( [f for ext in exts for f in glob(os.path.join(curr_dir, ext))]) # Exclude marker image if exists if (template and template.marker_path): omr_files = [f for f in omr_files if f != template.marker_path] print("\n\n\nMarker Found\n\n\n") subfolders = sorted([ file for file in os.listdir(curr_dir) if os.path.isdir(os.path.join(curr_dir, file)) ]) if omr_files: args_local = args.copy() if ("OverrideFlags" in template.options): args_local.update(template.options["OverrideFlags"]) print( '\n------------------------------------------------------------------' ) print(f'Processing directory {curr_dir} with settings- ') print("\tTotal images : %d" % (len(omr_files))) print("\tCropping Enabled : " + str(not args_local["noCropping"])) print("\tAuto Alignment : " + str(args_local["autoAlign"])) print("\tUsing Template : " + str(template.path) if (template) else "N/A") print("\tUsing Marker : " + str(template.marker_path) if ( template.marker is not None) else "N/A") print('') if not template: print(f'Error: No template file when processing {curr_dir}.') print( f' Place {config.TEMPLATE_FILE} in the directory or specify a template using -t.' ) return utils.setup_dirs(paths) output_set = setup_output(paths, template) return process_files(omr_files, template, args_local, output_set) elif (len(subfolders) == 0): # the directory should have images or be non-leaf print(f'Note: No valid images or subfolders found in {curr_dir}') # recursively process subfolders results_lists = [] for folder in subfolders: results_lists.append( process_dir(root_dir, os.path.join(subdir, folder), template)) return results_lists
def process_dir(root_dir, subdir, template, kesme_islemi, onizleme): curr_dir = os.path.join(root_dir, subdir) args['noCropping'] = bool(kesme_islemi) # Look for template in current dir template_file = os.path.join(curr_dir, config.TEMPLATE_FILE) if os.path.exists(template_file): template = Template(template_file) # look for images in current dir to process paths = config.Paths(os.path.join(args['output_dir'], subdir)) exts = ('*.png', '*.jpg') omr_files = sorted( [f for ext in exts for f in glob(os.path.join(curr_dir, ext))]) # Exclude marker image if exists if(template and template.marker_path): omr_files = [f for f in omr_files if f != template.marker_path] subfolders = sorted([file for file in os.listdir( curr_dir) if os.path.isdir(os.path.join(curr_dir, file))]) if omr_files: args_local = args.copy() if("OverrideFlags" in template.options): args_local.update(template.options["OverrideFlags"]) print('\n------------------------------------------------------------------') print(f'"{curr_dir}" dizini ayarları ile birlikte işleniyor- ') print("\tToplan resim : %d" % (len(omr_files))) print("\tKırpma Aktif : " + str(not args_local["noCropping"])) print("\tOtomatik Hizalama : " + str(args_local["autoAlign"])) print("\tKullanılan Şablon : " + str(template.path) if(template) else "N/A") print("\tKullanılan İşaretçi : " + str(template.marker_path) if(template.marker is not None) else "N/A") print('') if not template: print(f'Hata: işlenirken şablon bulunamadı {curr_dir}.') print(f' Çalışma dizininde {config.TEMPLATE_FILE} dosyasını konumlandırın veya -t parametresi ile birlikte belirtin.') return utils.setup_dirs(paths) output_set = setup_output(paths, template) process_files(omr_files, template, args_local, output_set, onizleme) elif(len(subfolders) == 0): # the directory should have images or be non-leaf print(f'Bilgi: {curr_dir} klasöründe geçerli bir resim veya alt klasör bulunamadı.') # recursively process subfolders for folder in subfolders: process_dir(root_dir, os.path.join(subdir, folder), template, kesme_islemi, onizleme)
def serotypes(): """ Reporty specific sequences in VGS data. This command reads FASTQ files from the input folder specified in Serotype_Report_Parameters, extracts the reads containing the sequence and counts the occurrences. The Research Team is using this tool to detect specific sequences in the capsid genes, thereby differentiating between various serotypes. """ start = datetime.now() setup_dirs(params) input_files = get_fastq_files(params) L.info('Found {} FASTQ files.'.format(len(input_files))) processor = Processor(input_files) processor.process() L.info('\nDone! the following two files were created:\n') L.info(processor.full_output_file) L.info(processor.summary_output_file) delta = datetime.now() - start L.info('\nCommand took {} seconds.'.format(delta.total_seconds()))
def main(config): setup_dirs(config) torch.manual_seed(config.random_seed) if torch.cuda.is_available(): torch.cuda.manual_seed(config.random_seed) data_loader = get_dataloader( data_dir=config.data_dir, batch_size=config.batch_size, random_seed=config.random_seed, is_train=config.train, valid_size=config.valid_size, shuffle=config.shuffle, pin_memory=torch.cuda.is_available(), cluttered_translated=config.cluttered_translated ) trainer = Trainer(config, data_loader) if config.train: trainer.train() else: trainer.test() return
def train(wandb_track, experiment_name, epochs, task, gpu_num=0, pretrained='', margin=0.4, losstype='deepcca'): """Train joint embedding networks.""" epochs = int(epochs) gpu_num = int(gpu_num) margin = float(margin) # Setup the results and device. results_dir = setup_dirs(experiment_name) if not os.path.exists(results_dir + 'train_results/'): os.makedirs(results_dir + 'train_results/') train_results_dir = results_dir + 'train_results/' device = setup_device(gpu_num) #### Hyperparameters ##### #Initialize wandb if wandb_track == 1: import wandb wandb.init(project=experiment_name) config = wandb.config config.epochs = epochs with open(results_dir + 'hyperparams_train.txt', 'w') as f: f.write('Command used to run: python ') f.write(' '.join(sys.argv)) f.write('\n') f.write('device in use: ' + str(device)) f.write('\n') f.write('--experiment_name ' + str(experiment_name)) f.write('\n') f.write('--epochs ' + str(epochs)) f.write('\n') # Setup data loaders and models. if task == 'cifar10': train_loader, test_loader = cifar10_loaders() model_A = CIFAREmbeddingNet() model_B = CIFAREmbeddingNet() elif task == 'mnist': train_loader, test_loader = mnist_loaders() model_A = MNISTEmbeddingNet() model_B = MNISTEmbeddingNet() elif task == 'uw': uw_data = 'bert' train_loader, test_loader = uw_loaders(uw_data) if uw_data == 'bert': model_A = RowNet(3072, embed_dim=1024) # Language. model_B = RowNet(4096, embed_dim=1024) # Vision. # Finish model setup. if pretrained == 'pretrained': # If we want to load pretrained models to continue training. print('Starting from pretrained networks.') model_A.load_state_dict( torch.load(train_results_dir + 'model_A_state.pt')) model_B.load_state_dict( torch.load(train_results_dir + 'model_B_state.pt')) print('Starting from scratch to train networks.') model_A.to(device) model_B.to(device) # Initialize the optimizers and loss function. optimizer_A = torch.optim.Adam(model_A.parameters(), lr=0.00001) optimizer_B = torch.optim.Adam(model_B.parameters(), lr=0.00001) # Add learning rate scheduling. def lr_lambda(e): if e < 50: return 0.001 elif e < 100: return 0.0001 else: return 0.00001 scheduler_A = torch.optim.lr_scheduler.LambdaLR(optimizer_A, lr_lambda) scheduler_B = torch.optim.lr_scheduler.LambdaLR(optimizer_B, lr_lambda) # Track batch losses. loss_hist = [] # Put models into training mode. model_A.train() model_B.train() # Train. # wandb if wandb_track == 1: wandb.watch(model_A, log="all") wandb.watch(model_B, log="all") epoch_list = [] # in order to save epoch in a pickle file loss_list = [] # in order to save loss in a pickle file for epoch in tqdm(range(epochs)): epoch_loss = 0.0 counter = 0 for data in train_loader: data_a = data[0].to(device) data_b = data[1].to(device) #label = data[2] # Zero the parameter gradients. optimizer_A.zero_grad() optimizer_B.zero_grad() # Forward. if losstype == 'deepcca': # Based on Galen Andrew's Deep CCA # data_a is from domain A, and data_b is the paired data from domain B. embedding_a = model_A(data_a) embedding_b = model_B(data_b) loss = deepcca(embedding_a, embedding_b, device, use_all_singular_values=True, outdim_size=128) # Backward. loss.backward() # Update. optimizer_A.step() optimizer_B.step() # Save batch loss. Since we are minimizing -corr the loss is negative. loss_hist.append(-1 * loss.item()) epoch_loss += embedding_a.shape[0] * loss.item() #reporting progress counter += 1 if counter % 64 == 0: print('epoch:', epoch, 'loss:', loss.item()) if wandb_track == 1: wandb.log({"epoch": epoch, "loss": loss}) # Save network state at each epoch. torch.save(model_A.state_dict(), train_results_dir + 'model_A_state.pt') torch.save(model_B.state_dict(), train_results_dir + 'model_B_state.pt') #since the batch size is 1 therefore: len(trainloader)==counter print('*********** epoch is finished ***********') epoch_loss = -1 * epoch_loss print('epoch: ', epoch, 'loss(correlation): ', (epoch_loss) / counter) epoch_list.append(epoch + 1) loss_list.append(epoch_loss / counter) pickle.dump(([epoch_list, loss_list]), open(train_results_dir + 'epoch_loss.pkl', "wb")) Visualize(train_results_dir + 'epoch_loss.pkl', 'Correlation History', True, 'epoch', 'Correlation (log scale)', None, 'log', None, (14, 7), train_results_dir + 'Figures/') # Update learning rate schedulers. scheduler_A.step() scheduler_B.step() # Plot and save batch loss history. pickle.dump(([loss_hist[::10]]), open(train_results_dir + 'epoch_corr.pkl', "wb")) Visualize(train_results_dir + 'epoch_corr.pkl', 'Correlation Batch', False, 'Batch', 'Correlation (log scale)', None, 'log', None, (14, 7), train_results_dir + 'Figures/') #### Learn the transformations for CCA #### if losstype == "CCA": a_base = [] b_base = [] no_model = True if no_model: # without using model: using raw data without featurization for data in train_loader: x = data[0].to(device) y = data[1].to(device) if task == 'uw': a_base.append(x) b_base.append(y) else: a_base.append(x.cpu().detach().numpy()) b_base.append(y.cpu().detach().numpy()) else: import torchvision.models as models #Either use these models, or use trained models with triplet loss res18_model = models.resnet18(pretrained=True) #changing the first layer of ResNet to accept images with 1 channgel instead of 3. res18_model.conv1 = torch.nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3, bias=False) # Select the desired layers model_A = torch.nn.Sequential(*list(res18_model.children())[:-2]) model_B = torch.nn.Sequential(*list(res18_model.children())[:-2]) model_A.eval() model_B.eval() for data in train_loader: x = data[0].to(device) # Domain A y = data[1].to(device) # Domain B a_base.append(model_A(x).cpu().detach().numpy()) b_base.append(model_B(y).cpu().detach().numpy()) # Concatenate predictions. a_base = np.concatenate(a_base, axis=0) b_base = np.concatenate(b_base, axis=0) a_base = np.squeeze(a_base) b_base = np.squeeze(b_base) if no_model: new_a_base = [] new_b_base = [] for i in range(len(a_base)): new_a_base.append(a_base[i, :, :].flatten()) new_b_base.append(b_base[i, :, :].flatten()) new_a_base = np.asarray(new_a_base) new_b_base = np.asarray(new_b_base) a_base = new_a_base b_base = new_b_base print('Finished reshaping data, the shape is:', new_a_base.shape) from sklearn.cross_decomposition import CCA from joblib import dump components = 128 cca = CCA(n_components=components) cca.max_iter = 5000 cca.fit(a_base, b_base) dump(cca, 'Learned_CCA.joblib') #### End of CCA fit to find the transformations #### print('Training Done!')
from args import init_parser, post_processing import numpy as np import torch from train import train_policy from evaluate import evaluate_policy from utils import setup_dirs import random from envs import make_env parser = argparse.ArgumentParser(description='SPC') init_parser(parser) # See `args.py` for default arguments args = parser.parse_args() args = post_processing(args) if __name__ == '__main__': setup_dirs(args) torch.manual_seed(args.seed) np.random.seed(args.seed) random.seed(args.seed) if 'carla8' in args.env: # run spc on carla0.9 simulator, currently only 0.9.4 is supported from envs.CARLA.carla.client import make_carla_client from envs.CARLA.carla8 import CarlaEnv with make_carla_client('localhost', args.port, 10000) as client: env = CarlaEnv(client) if args.eval: evaluate_policy(args, env) else: train_policy(args, env, max_steps=args.max_steps) else:
def test(experiment_name, task, gpu_num=0, pretrained='', margin=0.4, losstype='deepcca'): cosined = False embed_dim = 1024 gpu_num = int(gpu_num) margin = float(margin) # Setup the results and device. results_dir = setup_dirs(experiment_name) if not os.path.exists(results_dir + 'test_results/'): os.makedirs(results_dir + 'test_results/') test_results_dir = results_dir + 'test_results/' device = setup_device(gpu_num) #### Hyperparameters ##### #Initialize wandb #import wandb #wandb.init(project=experiment_name) #config = wandb.config with open(results_dir + 'hyperparams_test.txt', 'w') as f: f.write('Command used to run: python ') f.write(' '.join(sys.argv)) f.write('\n') f.write('device in use: ' + str(device)) f.write('\n') f.write('--experiment_name ' + str(experiment_name)) f.write('\n') # Setup data loaders and models based on task. if task == 'cifar10': train_loader, test_loader = cifar10_loaders() model_A = CIFAREmbeddingNet() model_B = CIFAREmbeddingNet() elif task == 'mnist': train_loader, test_loader = mnist_loaders() model_A = MNISTEmbeddingNet() model_B = MNISTEmbeddingNet() elif task == 'uw': uw_data = 'bert' train_loader, test_loader = uw_loaders(uw_data) if uw_data == 'bert': model_A = RowNet(3072, embed_dim=1024) # Language. model_B = RowNet(4096, embed_dim=1024) # Vision. # Finish model setup. model_A.load_state_dict( torch.load(results_dir + 'train_results/model_A_state.pt')) model_B.load_state_dict( torch.load(results_dir + 'train_results/model_B_state.pt')) model_A.to(device) model_B.to(device) # Put models into evaluation mode. model_A.eval() model_B.eval() """For UW data.""" ## we use train data to calculate the threshhold for distance. a_train = [] b_train = [] # loading saved embeddings to be faster a_train = load_embeddings(test_results_dir + 'lang_embeds_train.npy') b_train = load_embeddings(test_results_dir + 'img_embeds_train.npy') # Iterate through the train data. if a_train is None or b_train is None: a_train = [] b_train = [] print( "Computing embeddings for train data to calculate threshhold for distance" ) for data in train_loader: anchor_data = data[0].to(device) positive_data = data[1].to(device) label = data[2] a_train.append( model_A(anchor_data.to(device)).cpu().detach().numpy()) b_train.append( model_B(positive_data.to(device)).cpu().detach().numpy()) print("Finished Computing embeddings for train data") #saving embeddings if not already saved save_embeddings(test_results_dir + 'lang_embeds_train.npy', a_train) save_embeddings(test_results_dir + 'img_embeds_train.npy', b_train) a_train = np.concatenate(a_train, axis=0) b_train = np.concatenate(b_train, axis=0) # Test data # For accumulating predictions to check embedding visually using test set. # a is embeddings from domain A, b is embeddings from domain B, ys is their labels a = [] b = [] ys = [] instance_data = [] # loading saved embeddings to be faster a = load_embeddings(test_results_dir + 'lang_embeds.npy') b = load_embeddings(test_results_dir + 'img_embeds.npy') if a is None or b is None: compute_test_embeddings = True a = [] b = [] # Iterate through the test data. print("computing embeddings for test data") for data in test_loader: language_data, vision_data, object_name, instance_name = data language_data = language_data.to(device) vision_data = vision_data.to(device) instance_data.extend(instance_name) if compute_test_embeddings: a.append( model_A(language_data).cpu().detach().numpy()) # Language. b.append(model_B(vision_data).cpu().detach().numpy()) # Vision. ys.extend(object_name) print("finished computing embeddings for test data") # Convert string labels to ints. labelencoder = LabelEncoder() labelencoder.fit(ys) ys = labelencoder.transform(ys) #saving embeddings if not already saved save_embeddings(test_results_dir + 'lang_embeds.npy', a) save_embeddings(test_results_dir + 'img_embeds.npy', b) # Concatenate predictions. a = np.concatenate(a, axis=0) b = np.concatenate(b, axis=0) ab = np.concatenate((a, b), axis=0) ground_truth, predicted, distance = object_identification_task_classifier( a, b, ys, a_train, b_train, lamb_std=1, cosine=cosined) #### Retrieval task by giving an image and finding the closest word descriptions #### ground_truth_word, predicted_word, distance_word = object_identification_task_classifier( b, a, ys, b_train, a_train, lamb_std=1, cosine=cosined) with open('retrieval_non_pro.csv', mode='w') as retrieval_non_pro: csv_file_writer = csv.writer(retrieval_non_pro, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) csv_file_writer.writerow( ['image', 'language', 'predicted', 'ground truth']) for i in range(50): csv_file_writer.writerow([ instance_data[0], instance_data[i], predicted_word[0][i], ground_truth_word[0][i] ]) precisions = [] recalls = [] f1s = [] precisions_pos = [] recalls_pos = [] f1s_pos = [] #print(classification_report(oit_res[i], 1/np.arange(1,len(oit_res[i])+1) > 0.01)) for i in range(len(ground_truth)): p, r, f, s = precision_recall_fscore_support(ground_truth[i], predicted[i], warn_for=(), average='micro') precisions.append(p) recalls.append(r) f1s.append(f) p, r, f, s = precision_recall_fscore_support(ground_truth[i], predicted[i], warn_for=(), average='binary') precisions_pos.append(p) recalls_pos.append(r) f1s_pos.append(f) print('\n ') print(experiment_name + '_' + str(embed_dim)) print('MRR, KNN, Corr, Mean F1, Mean F1 (pos only)') print('%.3g & %.3g & %.3g & %.3g & %.3g' % (mean_reciprocal_rank( a, b, ys, cosine=cosined), knn(a, b, ys, k=5, cosine=cosined), corr_between(a, b, cosine=cosined), np.mean(f1s), np.mean(f1s_pos))) plt.figure(figsize=(14, 7)) for i in range(len(ground_truth)): fpr, tpr, thres = roc_curve(ground_truth[i], [1 - e for e in distance[i]], drop_intermediate=True) plt.plot(fpr, tpr, alpha=0.08, color='r') plt.xlabel('False Positive Rate') plt.ylabel('True Positive Rate') plt.savefig(test_results_dir + '_' + str(embed_dim) + '_ROC.svg') # Pick a pair, plot distance in A vs distance in B. Should be correlated. a_dists = [] b_dists = [] for _ in range(3000): i1 = random.randrange(len(a)) i2 = random.randrange(len(a)) a_dists.append(euclidean(a[i1], a[i2])) b_dists.append(euclidean(b[i1], b[i2])) # a_dists.append(cosine(a[i1], a[i2])) # b_dists.append(cosine(b[i1], b[i2])) # Plot. plt.figure(figsize=(14, 14)) #plt.title('Check Distance Correlation Between Domains') plt.xlim([0, 3]) plt.ylim([0, 3]) # plt.xlim([0,max(a_dists)]) # plt.ylim([0,max(b_dists)]) # plt.xlabel('Distance in Domain A') # plt.ylabel('Distance in Domain B') plt.xlabel('Distance in Language Domain') plt.ylabel('Distance in Vision Domain') #plt.plot(a_dists_norm[0],b_dists_norm[0],'.') #plt.plot(np.arange(0,2)/20,np.arange(0,2)/20,'k-',lw=3) plt.plot(a_dists, b_dists, 'o', alpha=0.5) plt.plot(np.arange(0, 600), np.arange(0, 600), 'k--', lw=3, alpha=0.5) #plt.text(-0.001, -0.01, 'Corr: %.3f'%(pearsonr(a_dists,b_dists)[0]), fontsize=20) plt.savefig(test_results_dir + '_' + str(embed_dim) + '_CORR.svg') # Inspect embedding distances. clas = 5 # Base class. i_clas = [i for i in range(len(ys)) if ys[i].item() == clas] i_clas_2 = np.random.choice(i_clas, len(i_clas), replace=False) clas_ref = 4 # Comparison class. i_clas_ref = [i for i in range(len(ys)) if ys[i].item() == clas_ref] ac = np.array([a[i] for i in i_clas]) bc = np.array([b[i] for i in i_clas]) ac2 = np.array([a[i] for i in i_clas_2]) bc2 = np.array([b[i] for i in i_clas_2]) ac_ref = np.array([a[i] for i in i_clas_ref]) aa_diff_ref = norm(ac[:min(len(ac), len(ac_ref))] - ac_ref[:min(len(ac), len(ac_ref))], ord=2, axis=1) ab_diff = norm(ac - bc2, ord=2, axis=1) aa_diff = norm(ac - ac2, ord=2, axis=1) bb_diff = norm(bc - bc2, ord=2, axis=1) # aa_diff_ref = [cosine(ac[:min(len(ac),len(ac_ref))][i],ac_ref[:min(len(ac),len(ac_ref))][i]) for i in range(len(ac[:min(len(ac),len(ac_ref))]))] # ab_diff = [cosine(ac[i],bc2[i]) for i in range(len(ac))] # aa_diff = [cosine(ac[i],ac2[i]) for i in range(len(ac))] # bb_diff = [cosine(bc[i],bc2[i]) for i in range(len(ac))] bins = np.linspace(0, 0.1, 100) plt.figure(figsize=(14, 7)) plt.hist(ab_diff, bins, alpha=0.5, label='between embeddings') plt.hist(aa_diff, bins, alpha=0.5, label='within embedding A') plt.hist(bb_diff, bins, alpha=0.5, label='within embedding B') plt.hist(aa_diff_ref, bins, alpha=0.5, label='embedding A, from class ' + str(clas_ref)) plt.title('Embedding Distances - Class: ' + str(clas)) plt.xlabel('L2 Distance') plt.ylabel('Count') plt.legend() #labelencoder.classes_ classes_to_keep = [36, 6, 9, 46, 15, 47, 50, 22, 26, 28] print(labelencoder.inverse_transform(classes_to_keep)) ab_norm = [ e for i, e in enumerate(ab) if ys[i % len(ys)] in classes_to_keep ] ys_norm = [e for e in ys if e in classes_to_keep] color_index = {list(set(ys_norm))[i]: i for i in range(len(set(ys_norm)))} #set(ys_norm) markers = ["o", "v", "^", "s", "*", "+", "x", "D", "h", "4"] marker_index = { list(set(ys_norm))[i]: markers[i] for i in range(len(set(ys_norm))) } embedding = umap.UMAP(n_components=2).fit_transform( ab_norm) # metric='cosine' # Plot UMAP embedding of embeddings for all classes. f, (ax1, ax2) = plt.subplots(1, 2, figsize=(20, 10)) mid = len(ys_norm) ax1.set_title('Language UMAP') for e in list(set(ys_norm)): x1 = [ embedding[:mid, 0][i] for i in range(len(ys_norm)) if ys_norm[i] == e ] x2 = [ embedding[:mid, 1][i] for i in range(len(ys_norm)) if ys_norm[i] == e ] ax1.scatter( x1, x2, marker=marker_index[int(e)], alpha=0.5, c=[sns.color_palette("colorblind", 10)[color_index[int(e)]]], label=labelencoder.inverse_transform([int(e)])[0]) ax1.set_xlim([min(embedding[:, 0]) - 4, max(embedding[:, 0]) + 4]) ax1.set_ylim([min(embedding[:, 1]) - 4, max(embedding[:, 1]) + 4]) ax1.grid(True) ax1.legend(loc='upper center', bbox_to_anchor=(1.1, -0.08), fancybox=True, shadow=True, ncol=5) ax2.set_title('Vision UMAP') for e in list(set(ys_norm)): x1 = [ embedding[mid::, 0][i] for i in range(len(ys_norm)) if ys_norm[i] == e ] x2 = [ embedding[mid::, 1][i] for i in range(len(ys_norm)) if ys_norm[i] == e ] ax2.scatter( x1, x2, marker=marker_index[int(e)], alpha=0.5, c=[sns.color_palette("colorblind", 10)[color_index[int(e)]]]) ax2.set_xlim([min(embedding[:, 0]) - 4, max(embedding[:, 0]) + 4]) ax2.set_ylim([min(embedding[:, 1]) - 4, max(embedding[:, 1]) + 4]) ax2.grid(True) plt.savefig(test_results_dir + '_' + str(embed_dim) + '_UMAP_wl.svg', bbox_inches='tight')
import argparse import torch from datasets import OmniglotDataset, MiniImageNet from core import NShotTaskSampler, create_nshot_task_label, EvaluateFewShot from models import VAE from maml import meta_gradient_step from train import fit from callbacks import * from utils import setup_dirs from config import PATH import torch.nn.functional as F from torchsummary import summary setup_dirs() assert torch.cuda.is_available() device = torch.device('cuda') torch.backends.cudnn.benchmark = True #################### #### Parameters #### #################### parser = argparse.ArgumentParser() parser.add_argument('--dataset', default='omniglot') parser.add_argument('--n', default=1, type=int) parser.add_argument('--k', default=5, type=int) parser.add_argument('--q', default=1, type=int) parser.add_argument('--inner-train-steps', default=1, type=int) parser.add_argument('--inner-val-steps', default=3, type=int) parser.add_argument('--inner-lr', default=0.4, type=float)
parser.add_argument("--b2", type=float, default=0.999, help="adam: decay of first order momentum of gradient") parser.add_argument("--n_cpu", type=int, default=8, help="number of cpu threads to use during batch generation") opt = parser.parse_args() if opt.dont_shuffle: opt.shuffle = False else: opt.shuffle = True model_name = "{0:%Y%m%d_%H%M%S}_WGAN_GP_{1}".format(datetime.datetime.now(), os.path.basename(opt.dset.rstrip('/'))) opt.model_name = model_name print(opt) # Setup logging model_dir, fig_dir = utils.setup_dirs(opt) # Configure dataloader dataloader = utils.configure_dataloader(opt.dset, opt.batch_size, opt.img_size, opt.shuffle) # Find img_shape # img_shape = (opt.channels, opt.img_size, opt.img_size) a, _ = next(iter(dataloader)) img_shape = (a.shape[1], a.shape[2], a.shape[3]) cuda = True if torch.cuda.is_available() else False # Loss weight for gradient penalty lambda_gp = 10 # Initialize generator and discriminator