def plot_many(logs, metric='accuracy', measure="mean", info=None): logs_0 = load("collab_log_100_0_234.pkl") logs_2 = load("collab_log_100_2_108.pkl") logs_10 = load("collab_log_100_10_776.pkl") # get correct metrics _metric = metric metric, measure = verify_metrics(metric, measure) data_0 = np.mean([[v[metric] for v in lo] for lo in logs_0.values()], axis=0) data_2 = np.mean([[v[metric] for v in lo] for lo in logs_2.values()], axis=0) data_10 = np.mean([[v[metric] for v in lo] for lo in logs_10.values()], axis=0) # plot data xlabel = 'Number of rounds' ylabel = f'Test Accuracy' title = f'{_metric.capitalize()} vs. No. of rounds' if info: xlabel = info.get('xlabel', xlabel) ylabel = info.get('ylabel', ylabel) title = info.get('title', title) x = range(0, len(data_0) * EVAL_ROUND, EVAL_ROUND) # , color=colors[i], label=mean[i][1], linestyle=line_styles[i] plt.plot(x, data_0, label="Skip local step") # , '-x' plt.plot(x, data_2, label="2 local epochs") # , '-x' plt.plot(x, data_10, label="10 local epochs") # , '-x' plt.xlabel(xlabel) plt.ylabel(ylabel) # plt.title(title) plt.legend(loc="lower right", shadow=True) plt.show()
def word_day_occurrences(centrality_file_path=None, centrality_measure='degree', graph_path=PAJEK_FORMAT): if (centrality_file_path is None): print("Trying to load graph from file path: {}".format(graph_path)) try: graph = load(graph_path) except FileNotFoundError: print('File not found on specified path.') sys.exit(1) if centrality_measure == 'degree': words = degree_centrality(graph) elif centrality_measure == 'closeness': words = closeness_centrality(graph) elif centrality_measure == 'betweenness': words = betweenness_centrality(graph) else: print('Specified centrality measure not implemented.') sys.exit(1) word_dict = sorted(words.items(), key=operator.itemgetter(1), reverse=True)[:10] words = [item[0] for item in word_dict] else: centrality_data = pd.read_csv(centrality_file_path, sep='\t') words = list(centrality_data.iloc[:, 0]) word_day_dict = get_word_attributes(graph_path) for word in words: print("Word: {}, Days of occurrence: {}\n".format( word, word_day_dict[word]))
def plot_mean_var(k_type='triangular', sim=False, labels_names=None, label_ids=None): from collections import defaultdict, OrderedDict import itertools xlim = None #[200, 300] figures_fol = op.join(root_fol, 'figures', 'smss_per_label{}{}'.format( '_window' if not xlim is None else '', '_sim' if sim else '')) utils.make_dir(figures_fol) gen, data = {}, {} hs_plot = [5, 10, 15, 25] if labels_names is None: labels_names = utils.load(op.join(root_fol, 'labels_names.pkl')) label_ids = range(len(labels_names)) for fol, subject, sms, run in utils.sms_generator(root_fol): print(fol, subject, sms, run) if subject not in gen: gen[subject] = OrderedDict() if sms not in gen[subject]: gen[subject][sms] = [] gen[subject][sms].append((fol, run)) if not sim: d = np.load(op.join(fol, 'labels_data_{}_{}.npz'.format(atlas, measure))) data[fol] = d['data'] else: import scipy.io as sio d_sim = sio.loadmat(op.join(fol, 'fmri_timecourse_sim.mat')) data[fol] = d_sim['timecourse_use_sim'].T # labels_names = [0] now = time.time() for subject, (label_id, label_name) in itertools.product(gen.keys(), zip(label_ids, labels_names)): utils.time_to_go(now, label_id, len(labels_names), 5) fig, axes = plt.subplots(2, 2, sharex='col', sharey='row', figsize=(12, 8)) axs = list(itertools.chain(*axes)) # fig.suptitle('{} {} {}'.format(subject, label_name, 'sim' if sim else '')) for index, (ax, sms) in enumerate(zip(axs, gen[subject].keys())): fol, run = gen[subject][sms][0] tr = utils.load(op.join(fol, 'tr.pkl')) print(tr) ys = np.array([data[fol][label_id]]) plot_vector_mean_var(subject, sms, run, ys, [label_name], [label_id], fol, tr, hs_plot, k_type, sim, overwrite=False, ax=ax, plot_legend=index==1, xlim=None) utils.maximize_figure(plt) plt.tight_layout() plt.savefig(op.join(figures_fol, label_name)) plt.close()
def get_dataset_iemocap(data_folder: str, phase: str, img_interval: int, hand_crafted_features: Optional[bool] = False): main_folder = os.path.join(data_folder, 'IEMOCAP_RAW_PROCESSED') meta = load(os.path.join(main_folder, 'meta.pkl')) emoDict = getEmotionDict() uttr_ids = open( os.path.join(data_folder, 'IEMOCAP_SPLIT', f'{phase}_split.txt'), 'r').read().splitlines() texts = [meta[uttr_id]['text'] for uttr_id in uttr_ids] labels = [emoDict[meta[uttr_id]['label']] for uttr_id in uttr_ids] if hand_crafted_features: text_features = load( os.path.join(data_folder, 'IEMOCAP_HCF_FEATURES', f'{phase}_text_features.pt')) audio_features = load( os.path.join(data_folder, 'IEMOCAP_HCF_FEATURES', f'{phase}_audio_features.pt')) video_features = load( os.path.join(data_folder, 'IEMOCAP_HCF_FEATURES', f'{phase}_video_features.pt')) # Select only the FAUs for uttrId in video_features.keys(): for imgId in video_features[uttrId].keys(): video_features[uttrId][imgId] = video_features[uttrId][imgId][ -35:] this_dataset = IEMOCAP_baseline(utterance_ids=uttr_ids, texts=text_features, video_features=video_features, audio_features=audio_features, labels=labels, label_annotations=list(emoDict.keys()), img_interval=img_interval) else: this_dataset = IEMOCAP(main_folder=main_folder, utterance_ids=uttr_ids, texts=texts, labels=labels, label_annotations=list(emoDict.keys()), img_interval=img_interval) return this_dataset
def load_cfg() -> Tuple[Config, str]: from src.dict2obj import Config from src.base import Adversary from src.utils import gpu, load, set_seed cfg = Config() set_seed(opts.seed) # load the model model = load_model(opts.model)(num_classes=get_num_classes(opts.dataset)) device = gpu(model) load(model=model, path=opts.info_path, device=device) # load the testset testset = load_dataset(dataset_type=opts.dataset, transform=opts.transform, train=False) cfg['testloader'] = load_dataloader(dataset=testset, batch_size=opts.batch_size, train=False, show_progress=opts.progress) normalizer = load_normalizer(dataset_type=opts.dataset) # generate the log path _, log_path = generate_path(method=METHOD, dataset_type=opts.dataset, model=opts.model, description=opts.description) # set the attacker attack, bounds, preprocessing = load_attacks(attack_type=opts.attack, dataset_type=opts.dataset, stepsize=opts.stepsize, steps=opts.steps) epsilons = torch.linspace(opts.epsilon_min, opts.epsilon_max, opts.epsilon_times).tolist() cfg['attacker'] = Adversary(model=model, attacker=attack, device=device, bounds=bounds, preprocessing=preprocessing, epsilon=epsilons) return cfg, log_path
def plot_train_history(logs, metric='accuracy', measure="mean", info=None, plot_peer=None): if isinstance(logs, str): logs = load(logs) # get correct metrics _metric = metric metric, measure = verify_metrics(metric, measure) # prepare data std_data = None if measure == "mean": data = np.mean([[v[metric] for v in lo] for lo in logs.values()], axis=0) elif measure == "mean-std": if plot_peer is None: data = np.mean([[v[metric] for v in lo] for lo in logs.values()], axis=0) else: print(f">>>>> Plotting chart for Peer({plot_peer})...") data = [v[metric] for v in logs[plot_peer]] std_data = np.std([[v[metric] for v in lo] for lo in logs.values()], axis=0) elif measure == "max": data = np.max([[v[metric] for v in lo] for lo in logs.values()], axis=0) else: data = np.std([[v[metric] for v in lo] for lo in logs.values()], axis=0) # plot data xlabel = 'Rounds' ylabel = f' {measure.capitalize()} {_metric.capitalize()}' title = f'{_metric.capitalize()} vs. No. of rounds' if info: xlabel = info.get('xlabel', xlabel) ylabel = info.get('ylabel', ylabel) x = range(0, len(data) * EVAL_ROUND, EVAL_ROUND) # Configs plt.grid(linestyle='dashed') plt.xlabel(xlabel, fontsize=13) plt.xticks(fontsize=13, ) plt.ylabel(ylabel, fontsize=13) plt.yticks(fontsize=13, ) # Plot plt.plot(x, data) if std_data is not None: plt.fill_between(x, data - std_data, data + std_data, alpha=.1) plt.xlabel(xlabel) plt.ylabel(ylabel) # plt.title(title) plt.show()
def load_inception( resize: bool = True, normalizer: Optional[Callable] = None ) -> Tuple[nn.Module, torch.device]: file_ = os.path.join(INFO_PATH, INCEPTION_V3) if not os.path.exists(file_): print(">>> Inception model is not found. Download from url ...") inception_model = inception_v3(pretrained=True, transform_input=False) device = gpu(inception_model) torch.save(inception_model.state_dict(), file_) else: print(f">>> Inception model is found: {file_} ...") inception_model = Inception3(transform_input=False) device = gpu(inception_model) load(model=inception_model, path=INFO_PATH, filename=INCEPTION_V3, device=device) model = _Net(arch=inception_model, resize=resize, normalizer=normalizer) return model, device
def load_cfg() -> Tuple[Config, str]: from src.dict2obj import Config from src.utils import gpu, load, set_seed cfg = Config() set_seed(opts.seed) # load the model model = load_model(opts.model)(num_classes=get_num_classes(opts.dataset)) device = gpu(model) load(model=model, path=opts.info_path, device=device) model.eval() # load the testset testset = load_dataset(dataset_type=opts.dataset, transform='None', train=False) data = [] targets = [] for i in range(len(testset)): img, label = testset[i] data.append(img) targets.append(label) cfg['data'] = torch.stack(data) cfg['targets'] = torch.tensor(targets, dtype=torch.long) normalizer = load_normalizer(opts.dataset) # generate the log path _, log_path = generate_path(METHOD, opts.dataset, opts.model, opts.description) cfg['attacker'] = AutoAttack(Defense(model, normalizer), norm=opts.norm, eps=opts.epsilon, version=opts.version, device=device) return cfg, log_path
def get_dataset_mosei(data_folder: str, phase: str, img_interval: int, hand_crafted_features: Optional[bool] = False): main_folder = os.path.join(data_folder, 'MOSEI_RAW_PROCESSED') meta = load(os.path.join(main_folder, 'meta.pkl')) ids = open(os.path.join(data_folder, 'MOSEI_SPLIT', f'{phase}_split.txt'), 'r').read().splitlines() texts = [meta[id]['text'] for id in ids] labels = [meta[id]['label'] for id in ids] if hand_crafted_features: hcf = load( os.path.join(data_folder, 'MOSEI_HCF_FEATURES', f'mosei_senti_hcf_{phase}.pkl')) return MOSEI_baseline(ids=ids, hcf=hcf, labels=labels) return MOSEI(main_folder=main_folder, ids=ids, texts=texts, labels=labels, img_interval=img_interval)
def plot_mean_var(y, hs, t_axis, fol, k_type='triangular'): if not op.isfile(op.join(fol, 'ests_mean_{}.pkl'.format(k_type))): ests_mean, ests_var = {}, {} for h in hs: ests_mean[h] = est_mean(y, h, t_axis, k_type) ests_var[h] = est_var(y, ests_mean[h], h, t_axis, k_type) utils.save(ests_mean, op.join(fol, 'ests_mean_{}.pkl'.format(k_type))) utils.save(ests_var, op.join(fol, 'ests_var_{}.pkl'.format(k_type))) else: ests_mean = utils.load(op.join(fol, 'ests_mean_{}.pkl'.format(k_type))) ests_var = utils.load(op.join(fol, 'ests_var_{}.pkl'.format(k_type))) boynton_colors = ["red", "green", "yellow", "magenta", "pink", "orange", "brown", "gray"] t = range(len(y)) plt.figure() plt.plot(t, y, 'b', label='real') for h, color in zip(hs, boynton_colors): # plt.errorbar(t, ests_mean[h], c=color, yerr=np.power(ests_var[h], 0.5), label='w {}'.format(h)) plt.plot(t, ests_mean[h], color, label='w {}'.format(h)) error = np.power(ests_var[h], 0.5) plt.fill_between(t, ests_mean[h] - error, ests_mean[h] + error, alpha=0.2, edgecolor=color, facecolor=color) plt.legend() plt.savefig(op.join(fol, 'first_vertice_h_var_k_{}.jpg'.format(k_type)))
def run(config_name, config_folder, session_name, multi_session, pe, on_load): lowpriority() if session_name is None: session_name = config_name if multi_session <= 1 else f"{config_name}-x{multi_session}" session_name = session_name.replace(".ini", "") # Load config config = ConfigParser() read_ok = config.read(f"{config_folder}/{config_name}") assert len(read_ok) > 0, f"Failed to read config file: {Path(config_folder) / config_name}" # Define modules here. NOTE no longer need. Module and path can be specified directly in config file now if "Controller" in config and "module" in config["Controller"]: module = config["Controller"]["module"] if module == "CopyNTM": model_builder = lambda: CopyNTM(**dict([(key, int(value)) for key, value in config["NTM"].items()])) elif module == "TMazeNTMModule": model_builder = lambda: TMazeNTMModule(**dict([(k, int(v)) for k, v in config["ModelParameters"].items()])) else: raise AssertionError(f"Unknown module specification: {module}") else: model_builder = None # Set seed seed = config["HyperParameters"].get("seed") if "HyperParameters" in config else None if seed: seed = int(seed) torch.manual_seed(seed) numpy.random.seed(seed) random.seed(seed) # Create worker(s) and session workers = [] for i in range(max(1, multi_session)): workers.append(GA(f"{config_folder}/{config_name}", model_builder=model_builder)) if multi_session > 1: session = MultiSession(workers, session_name, parallel_execution=pe) else: session = Session(workers[0], session_name) # Copy config file to session folder if not os.path.isfile(Path(session.save_folder) / "config"): with open(Path(session.save_folder) / "config", "a") as fp: config.write(fp) if on_load: on_load = load(on_load) session.start(on_load=on_load)
def run(dataset, seed, ntrees, n_folds, n_repeats, dataset_results_path): start = int(time()) random_state = np.random.RandomState(seed) numerical_attributes, attr_names, attr_values, x, y = utils.load(dataset) random_forest = RandomForest(ntrees, random_state, numerical_attributes, attr_values) results = [] for i in range(n_repeats): start2 = int(time()) print("\t\t#{} {}-fold CV iteration".format(i, n_folds)) results += utils.cross_validate(random_forest, x, y, n_folds, random_state) print("\t\t" + readable_time(start2, int(time()))) stop = int(time()) print("\t\tSaving results...", end=" ") results_file_path = os.path.join(dataset_results_path, '{}.csv'.format(ntrees)) with open(results_file_path, 'w') as file: file.write('f1_score\n') for f1_score in results: file.write("{}\n".format(f1_score)) time_file_path = os.path.join(dataset_results_path, 'summary.csv') with open(time_file_path, 'a') as file: file.write('{},{},{},{},{},{},{}\n'.format(dataset, np.mean(results), np.std(results), ntrees, n_folds, n_repeats, stop - start)) # for i in range(2): # dot = graphviz.Digraph(name=str(i)) # random_forest.trees[i].get_graph(dot, attr_names=attr_names) # dot.render(cleanup=True) print("Done") print("\t\tTime elapsed: {}".format(readable_time(start, stop)))
def __init__(self, x=np.array([]), Fs=1.0, t0=0.0, path=None): if path is not None: # signal should be imported # from a WAV file x, Fs = load(path) else: # signal should be taken # from the 'x' argument x = x.astype(np.float64) self.x = x self.Fs = Fs self.L = np.size(self.x) self.t = np.arange(self.L) / self.Fs + t0 self.PLOTS = { "time": self._plot_time, "frequency": self._plot_freq, "spectrogram": self._plot_spec, "cepstrogram": self._plot_cepstrogram, "lpctrogram": self._plot_lpctrogram }
from src.dtree import DecisionTree from src.utils import load import graphviz numerical_attributes, attribute_names, attribute_values, x, y = load( 'benchmark') dtree = DecisionTree(None, numerical_attributes, attribute_values, benchmark=True) dtree.fit(x, y) dot = graphviz.Digraph(name='tests/results/benchmark_tree') dtree.get_graph(dot, attr_names=attribute_names) dot.render(cleanup=True)
top_hs = 120 # hs_plot = [5, 10, 15, 25] # hs = [8, 13, 18, 23] k_types = ['triangular'] # 'Epanechnikov', 'tricube' only_one_trace = False # legend_index = 1 # labels_names = ['posteriorcingulate-lh'] # figures_fol = op.join(root_fol, 'figures', 'smss_per_label_window') # utils.make_dir(figures_fol) overwrite = False sim = False n_jobs = -1 n_jobs = utils.get_n_jobs(n_jobs) specific_label = 'posteriorcingulate-lh' labels_names = utils.load(op.join(root_fol, 'labels_names.pkl')) labels_ids = range(len(labels_names)) specific_label = 'posteriorcingulate-lh' # for sim in [False, True]: subjects = set() for fol, subject, sms, run in utils.sms_generator(root_fol): if subject == 'nmr00956': continue subjects.add(subject) fmri_fname = op.join(fol, 'fmcpr.sm5.{}.{}.mgz'.format(fsaverage, hemi)) tr = utils.load(op.join(fol, 'tr.pkl')) print(subject, sms, run, tr) # main(subject, sms, run, fmri_fname, fol, root_fol, atlas, tr, hs, k_types, measure, sim, labels_names, # labels_ids, only_one_trace, overwrite, specific_label, n_jobs=n_jobs)
def get_data(args, phase): dataset = args['dataset'] seq_len = args['data_seq_len'] file_folder = args['data_folder'] aligned = args['aligned'] zsl = args['zsl'] fsl = args['fsl'] if phase == 'train' else -1 processed_path = f'./processed_datasets/{dataset}_{seq_len}_{phase}{"" if aligned else "_noalign"}.pt' if os.path.exists(processed_path) and zsl == -1 and fsl == -1: print(f'Load processed dataset! - {phase}') return load(processed_path) if dataset == 'mosi': if seq_len == 20: data_path = os.path.join(file_folder, f'X_{phase}.h5') label_path = os.path.join(file_folder, f'y_{phase}.h5') data = np.array(h5py.File(data_path, 'r')['data']) labels = np.array( h5py.File(label_path.replace('X', 'y'), 'r')['data']) text = data[:, :, :300] audio = data[:, :, 300:305] vision = data[:, :, 305:] this_dataset = MOSI(list(range(len(labels))), text, audio, vision, labels, is20=True) else: data_path = os.path.join( file_folder, f'mosi_data{"" if aligned else "_noalign"}.pkl') data = load(data_path) data = data[phase] this_dataset = MOSI(data['id'], data['text'], data['audio'], data['vision'], data['labels']) # elif dataset == 'mosei_senti': # if seq_len == 20: # text_data = np.array(h5py.File(os.path.join(file_folder, f'text_{phase}.h5'), 'r')['d1']) # audio_data = np.array(h5py.File(os.path.join(file_folder, f'audio_{phase}.h5'), 'r')['d1']) # vision_data = np.array(h5py.File(os.path.join(file_folder, f'vision_{phase}.h5'), 'r')['d1']) # labels = np.array(h5py.File(os.path.join(file_folder, f'y_{phase}.h5'), 'r')['d1']) # this_dataset = MOSEI(list(range(len(labels))), text_data, audio_data, vision_data, labels) # else: # data_path = os.path.join(file_folder, f'mosei_senti_data{"" if aligned else "_noalign"}.pkl') # data = load(data_path) # data = data[phase] # this_dataset = MOSEI(data['id'], data['text'], data['audio'], data['vision'], data['labels']) elif dataset == 'mosei_emo': text_data = np.array( h5py.File(os.path.join(file_folder, f'text_{phase}_emb.h5'), 'r')['d1']) audio_data = np.array( h5py.File(os.path.join(file_folder, f'audio_{phase}.h5'), 'r')['d1']) vision_data = np.array( h5py.File(os.path.join(file_folder, f'video_{phase}.h5'), 'r')['d1']) labels = np.array( h5py.File(os.path.join(file_folder, f'ey_{phase}.h5'), 'r')['d1']) # (N, 6) # Class order: Anger Disgust Fear Happy Sad Surprise labels = np.array(labels > 0, np.int32) this_dataset = MOSEI(list(range(len(labels))), text_data, audio_data, vision_data, labels, zsl=zsl, fsl=fsl) elif dataset == 'iemocap': data_path = os.path.join( file_folder, f'iemocap_data{"" if aligned else "_noalign"}.pkl') data = load(data_path) data = data[phase] # iemocap4 Distribution # neutral happy sad angry # [954 338 690 735] # [358 116 188 136] # [383 135 193 227] text_data = data['text'] audio_data = data['audio'] vision_data = data['vision'] labels = data['labels'] labels = np.argmax(labels, axis=-1) if zsl != -1: # iemocap9 Distribution # 0 1 2 3 4 5 6 7 8 # Anger Excited Fear Sad Surprised Frustrated Happy Neutral Disgust # [735 686 19 690 65 1235 338 954 1] (Train) # [136 206 9 188 17 319 116 358 0] (Valid) # [227 141 12 193 25 278 135 383 1] (Test) iemocap9_text_data = load2( os.path.join(file_folder, f'text_{phase}.p')) iemocap9_audio_data = load2( os.path.join(file_folder, f'covarep_{phase}.p')) iemocap9_vision_data = load2( os.path.join(file_folder, f'facet_{phase}.p')) iemocap9_labels = load2(os.path.join(file_folder, f'y_{phase}.p')) iemocap9_labels = iemocap9_labels[:, 1:-1] iemocap9_labels = np.expand_dims(iemocap9_labels[:, zsl], axis=1) nonzeros = [ i for i, l in enumerate(iemocap9_labels) if np.sum(l) != 0 ] zsl_text_data = iemocap9_text_data[nonzeros] zsl_audio_data = iemocap9_audio_data[nonzeros] zsl_vision_data = iemocap9_vision_data[nonzeros] zsl_labels = iemocap9_labels[nonzeros] # Align seq len to 20 zsl_text_data = zsl_text_data[:, :-1, :] zsl_audio_data = zsl_audio_data[:, :-1, :] zsl_vision_data = zsl_vision_data[:, :-1, :] text_data = np.concatenate((text_data, zsl_text_data), axis=0) audio_data = np.concatenate((audio_data, zsl_audio_data), axis=0) vision_data = np.concatenate((vision_data, zsl_vision_data), axis=0) labels = np.concatenate((labels, np.zeros((len(labels), 1))), axis=1) zsl_labels = np.concatenate((np.zeros( (len(zsl_labels), 4)), zsl_labels), axis=1) labels = np.concatenate((labels, zsl_labels), axis=0) this_dataset = IEMOCAP(list(range(len(labels))), text_data, audio_data, vision_data, labels) else: raise ValueError('Wrong dataset!') if zsl == -1 and fsl == -1: save(this_dataset, processed_path) return this_dataset
def load(self): utils.load( self.model, os.path.join(self.args.save, 'weights_{}.pt'.format(self.args.task_id)))
def get_glove_emotion_embs(path): dataDict = load(path) return dataDict
def __init__(self, config_file=None, env_keys=None, population=None, model_builder=None, max_generations=None, max_evals=None, max_reward=None, max_episode_eval=None, sigma=None, truncation=None, trials=None, elite_trials=None, n_elites=None, env_selection=None, sigma_strategy=None, termination_strategy=None, env_wrappers=None): self.config_file = config_file config = configparser.ConfigParser() default_config = Path(os.path.realpath( __file__)).parent.parent / 'config_files/config_default.cfg' read_ok = config.read( [default_config, config_file] if config_file else default_config) if len(read_ok) != 2: print("Warning: Failed to read all config files: " + str([self.config_file, default_config])) # hyperparams self.env_keys = env_keys if env_keys is not None else json.loads( config.get('EnvironmentSettings', 'env_keys')) if not env_keys and config.get('EnvironmentSettings', 'env_key'): self.env_keys.append(config.get('EnvironmentSettings', 'env_key')) self.population = population if population is not None else int( config['HyperParameters']['population']) self.model_builder = model_builder or self._load_model_builder(config) self.max_episode_eval = max_episode_eval if max_episode_eval is not None else int( config['HyperParameters']['max_episode_eval']) self.max_evals = max_evals if max_evals is not None else int( config['HyperParameters']['max_evals']) self.max_reward = max_reward if max_reward is not None else float( config['HyperParameters']['max_reward']) self.max_generations = max_generations if max_generations is not None else int( config['HyperParameters']['max_generations']) self.sigma = sigma if sigma is not None else float( config['HyperParameters']['sigma']) self.truncation = truncation if truncation is not None else int( config['HyperParameters']['truncation']) self.trials = trials if trials is not None else int( config['HyperParameters']['trials']) self.elite_trials = elite_trials if elite_trials is not None else int( config['HyperParameters']['elite_trials']) self.n_elites = n_elites if n_elites is not None else int( config['HyperParameters']['n_elites']) # strategies if sigma_strategy and not isinstance(sigma_strategy, str): sigma_strategies["Custom"] = sigma_strategy sigma_strategy = "Custom" if env_selection and not isinstance(env_selection, str): env_selections["Custom"] = env_selection env_selection = "Custom" if termination_strategy and not isinstance(termination_strategy, str): termination_strategies["Custom"] = termination_strategy termination_strategy = "Custom" self.sigma_strategy_name = sigma_strategy or config['Strategies'][ 'sigma_strategy'] self.env_selection_name = env_selection or config['Strategies'][ 'env_selection'] self.termination_strategy_name = termination_strategy or config[ 'Strategies']['termination'] self.sigma_strategy = sigma_strategies[self.sigma_strategy_name] self.env_selection = env_selections[self.env_selection_name] self.termination_strategy = termination_strategies[ self.termination_strategy_name] # Environment wrappers self.env_wrappers = env_wrappers or config["EnvironmentSettings"].get( "env_wrappers") or [] if isinstance(self.env_wrappers, str): self.env_wrappers = [ utils.load(s) for s in json.loads(self.env_wrappers) ] def wrap(env, i=0): if len(self.env_wrappers) > i: return wrap(self.env_wrappers[i](env), i + 1) return env # Safe-gaurd for max evaluations if not specified self.max_episode_eval = 1000000000 if self.max_episode_eval < 0 else self.max_episode_eval self.max_evals = 1000000000 if self.max_evals < 0 else self.max_evals # algorithm state self.g = 0 self.envs = [wrap(gym.make(key)) for key in self.env_keys] self.evaluations_used = 0 self.results = [] self.active_env = 0 self.scored_parents = None self.models = None
def train(self): extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(extra_update_ops): g_optim = tf.train.AdamOptimizer(self.flags.lr, beta1 = self.flags.beta1) \ .minimize(self.g_loss, var_list = self.g_vars) e_optim = tf.train.AdamOptimizer(self.flags.lr, beta1 = self.flags.beta1) \ .minimize(self.e_loss, var_list = self.e_vars) # g_optim = tf.train.AdagradOptimizer(self.flags.lr).minimize(self.g_loss, var_list = self.g_vars) # e_optim = tf.train.AdagradOptimizer(self.flags.lr).minimize(self.e_loss, var_list = self.e_vars) tf.global_variables_initializer().run() # merge summary sum_total = tf.summary.merge([self.im_sum, self.im_hat_sum, self.recon_im_sum, self.g_loss_sum, self.KL_fake_g_loss_sum, self.e_loss_sum,self.KL_fake_e_loss_sum, self.KL_real_e_loss_sum]) if hasattr(self, 'match_x_e_loss_sum'): sum_total = tf.summary.merge([sum_total, self.match_x_e_loss_sum]) if hasattr(self, 'match_z_e_loss_sum'): sum_total = tf.summary.merge([sum_total, self.match_z_e_loss_sum]) if hasattr(self, 'match_z_g_loss_sum'): sum_total = tf.summary.merge([sum_total, self.match_z_g_loss_sum]) if hasattr(self, 'match_x_g_loss_sum'): sum_total = tf.summary.merge([sum_total, self.match_x_g_loss_sum]) writer = tf.summary.FileWriter("%s/ge_GAN_log_%s"%(self.flags.checkpoint_dir, self.flags.dataset_name), self.sess.graph) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord = coord ) could_load, checkpoint_counter = load(self.saver, self.sess, self.flags) if could_load: counter = checkpoint_counter print(" [*] Load SUCCESS") else: counter = 0 print(" [!] Load failed...") for i in xrange(counter, self.flags.iter): i += 1 for iter_e in range(self.updates['e']['num_updates']): if iter_e < (self.updates['e']['num_updates'] -1 ): self.sess.run([e_optim]) else: # run with loss # self.sess.run([e_optim]) _, e_loss_, KL_real_e_loss_, KL_fake_e_loss_ = self.sess.run( [e_optim, self.e_loss, self.KL_real_e_loss, self.KL_fake_e_loss]) for iter_g in range(self.updates['g']['num_updates']): if iter_g < (self.updates['g']['num_updates'] -1): self.sess.run([g_optim]) else : # run with summary and loss # self.sess.run([g_optim]) _, sum_total_, g_loss_, KL_fake_g_loss_ = self.sess.run( [g_optim, sum_total, self.g_loss, self.KL_fake_g_loss]) if np.mod(i,20) == 0: writer.add_summary(sum_total_, i) print("iteration: [%2d], g_loss: %.8f, e_loss: %.8f" % (i, g_loss_, e_loss_)) print ('fake/real_ e: ', KL_fake_e_loss_, '\\', KL_real_e_loss_) print ('fake_g: ', KL_fake_g_loss_) print('**************************') if np.mod(i,self.flags.save_iter) == 0 or i == self.flags.iter: # try to sample and save model [gt_im, recon_im] = self.sess.run([self.im, self.recon_im_test]) save_images(self.flags, gt_im, i, 'GT') save_images(self.flags, recon_im, i, 'recon') save(self.saver, self.sess, self.flags, i) print ('saved once ...')
def train(self): extra_update_ops = tf.get_collection(tf.GraphKeys.UPDATE_OPS) with tf.control_dependencies(extra_update_ops): g_optim = tf.train.AdamOptimizer(self.flags.lr, beta1 = self.flags.beta1) \ .minimize(self.g_loss, var_list = self.g_vars) e_optim = tf.train.AdamOptimizer(self.flags.lr, beta1 = self.flags.beta1) \ .minimize(self.e_loss, var_list = self.e_vars) # d1_optim = tf.train.AdamOptimizer(self.flags.lr, beta1 = self.flags.beta1) \ # .minimize(self.d1_loss, var_list = self.d1_vars) # d2_optim = tf.train.AdamOptimizer(self.flags.lr, beta1 = self.flags.beta1) \ # .minimize(self.d2_loss, var_list = self.d2_vars) d1_optim = tf.train.RMSPropOptimizer(self.flags.lr).minimize( self.d1_loss, var_list=self.d1_vars) d2_optim = tf.train.RMSPropOptimizer(self.flags.lr).minimize( self.d2_loss, var_list=self.d2_vars) tf.global_variables_initializer().run() # merge summary # sum_total = tf.summary.merge([self.im_sum, self.im_hat_sum, self.recon_im_sum, # self.g_loss_sum, self.KL_fake_g_loss_sum, self.d1_g_loss_sum, self.d2_im_hat_g_loss_sum, # self.e_loss_sum,self.KL_fake_e_loss_sum, self.KL_real_e_loss_sum, self.d2_z_hat_e_loss_sum, # self.d1_loss_sum, self.d2_loss_sum # ]) sum_total = tf.summary.merge([ self.imh_sum, self.imh_hat_sum, self.g_loss_sum, self.d1_g_loss_sum, self.d2_imh_hat_g_loss_sum, self.e_loss_sum, self.d2_iml_hat_e_loss_sum, self.d1_loss_sum, self.d2_loss_sum ]) writer = tf.summary.FileWriter( "%s/sr_GAN_log_%s" % (self.flags.checkpoint_dir, self.flags.dataset_name), self.sess.graph) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) could_load, checkpoint_counter = load(self.saver, self.sess, self.flags) if could_load: counter = checkpoint_counter print(" [*] Load SUCCESS") else: counter = 0 print(" [!] Load failed...") for i in xrange(counter, self.flags.iter): i += 1 _, _, d1_loss_, d2_loss_ = self.sess.run( [d1_optim, d2_optim, self.d1_loss, self.d2_loss]) for iter_e in range(self.updates['e']['num_updates']): if iter_e < (self.updates['e']['num_updates'] - 1): self.sess.run([e_optim]) else: # run with loss _, e_loss_ = self.sess.run([e_optim, self.e_loss]) for iter_g in range(self.updates['g']['num_updates']): if iter_g < (self.updates['g']['num_updates'] - 1): self.sess.run([g_optim]) else: # run with summary and loss _, sum_total_, g_loss_, = self.sess.run( [g_optim, sum_total, self.g_loss]) if np.mod(i, 10) == 0: writer.add_summary(sum_total_, i) print("iteration: [%2d], g_loss: %.8f, e_loss: %.8f, d1_loss: %.8f, d2_loss: %.8f" \ % (i, g_loss_, e_loss_, d1_loss_, d2_loss_ )) print('**************************') if np.mod(i, self.flags.save_iter) == 0 or i == self.flags.iter: # try to sample and save model [low_im, high_im, fakehigh_im ] = self.sess.run([self.iml, self.imh, self.imh_hat]) save_images(self.flags, low_im, i, 'iml') save_images(self.flags, high_im, i, 'imh') save_images(self.flags, fakehigh_im, i, 'imh_hat') save(self.saver, self.sess, self.flags, i) print('saved once ...')
def main(arguments=None): """The main function Entry point. """ global loss_func global best_acc best_acc = 0 global args # Setting the hyper parameters parser = argparse.ArgumentParser(description='Example of Capsule Network') parser.add_argument('--epochs', type=int, default=10, help='number of training epochs. default=10') parser.add_argument('--lr', type=float, default=0.001, help='learning rate. default=0.01') parser.add_argument('--batch-size', type=int, default=128, help='training batch size. default=128') parser.add_argument('--test-batch-size', type=int, default=128, help='testing batch size. default=128') parser.add_argument( '--log-interval', type=int, default=10, help= 'how many batches to wait before logging training status. default=10') parser.add_argument('--no-cuda', action='store_true', default=False, help='disables CUDA training. default=false') parser.add_argument('--device', type=str, default='cuda:0', help='select the gpu. default=cuda:0') parser.add_argument( '--threads', type=int, default=4, help='number of threads for data loader to use. default=4') parser.add_argument('--seed', type=int, default=42, help='random seed for training. default=42') parser.add_argument( '--num_conv_in_channels', type=int, default=1, help='number of channels in input to first Conv Layer. default=1') parser.add_argument( '--num_conv_out_channels', type=int, default=256, help='number of channels in output from first Conv Layer. default=256' ) parser.add_argument('--conv-kernel', type=int, default=9, help='kernel size of Conv Layer. default=9') parser.add_argument('--conv-stride', type=int, default=1, help='stride of first Conv Layer. default=1') parser.add_argument( '--num-primary-channels', type=int, default=32, help='channels produced by PimaryCaps layer. default=32') parser.add_argument( '--primary-caps-dim', type=int, default=8, help='dimension of capsules in PrimaryCaps layer. default=8') parser.add_argument( '--primary-kernel', type=int, default=9, help='kernel dimension for PrimaryCaps layer. default=9') parser.add_argument('--primary-stride', type=int, default=2, help='stride for PrimaryCaps layer. default=2') parser.add_argument('--num-classes', type=int, default=10, help='number of output classes. default=10 for MNIST') parser.add_argument( '--digit-caps-dim', type=int, default=16, help='dimension of capsules in DigitCaps layer. default=16') parser.add_argument( '--dec1-dim', type=int, default=512, help='output dimension of first layer in decoder. default=512') parser.add_argument( '--dec2-dim', type=int, default=1024, help='output dimension of seconda layer in decoder. default=1024') parser.add_argument('--num-routing', type=int, default=3, help='number of routing iteration. default=3') parser.add_argument( '--use-reconstruction-loss', type=utils.str2bool, nargs='?', default=True, help='use an additional reconstruction loss. default=True') parser.add_argument( '--regularization-scale', type=float, default=0.0005, help= 'regularization coefficient for reconstruction loss. default=0.0005') parser.add_argument('--dataset', help='the name of dataset (mnist, cifar10)', default='mnist') parser.add_argument( '--input-width', type=int, default=28, help='input image width to the convolution. default=28 for MNIST') parser.add_argument( '--input-height', type=int, default=28, help='input image height to the convolution. default=28 for MNIST') parser.add_argument('--directory', type=str, default=PROJECT_DIR / 'results', help='directory to store results') parser.add_argument('--data-directory', type=str, default=PROJECT_DIR / 'data', help='directory to store data') parser.add_argument('--description', type=str, default='no description', help='description to store together with results') parser.add_argument('--exp-decay-lr', action='store_true', default=False, help='use exponential decay of learning rate') parser.add_argument( '--decay-steps', type=int, default=4000, help= 'decay steps for exponential learning rate adjustment. default = 2000' ) parser.add_argument( '--decay-rate', type=float, default=0.96, help= 'decay rate for exponential learning rate adjustment. default=1 (no adjustment)' ) parser.add_argument('--staircase', action='store_true', default=False, help='activate staircase for learning rate adjustment') # one cycle policy parser.add_argument('--one-cycle-policy', action='store_true', default=False, help='use one cycle policy for learning rate') # warm restarts parser.add_argument('--warm-restarts', action='store_true', default=False, help='use warm restarts of the learning rate') parser.add_argument( '--Ti', type=float, default=10.0, help='number of epochs of a cycle of the warm restarts') parser.add_argument('--Tmult', type=float, default=1.0, help='multiplier factor for the warm restarts') # adaptive batch size parser.add_argument('--adabatch', action='store_true', default=False, help='activate adabatch. default False') parser.add_argument('--adapow', type=int, default=2, help='power of two for adabatch size') # weight sharing parser.add_argument('--conv-shared-weights', type=int, default=0) parser.add_argument('--primary-shared-weights', type=int, default=0) parser.add_argument('--digit-shared-weights', type=int, default=0) parser.add_argument('--conv-shared-bias', type=int, default=0) # small decoder parser.add_argument( '--small-decoder', action='store_true', default=False, help='enables the small decoder instead of the standard one') # restart option parser.add_argument('--restart-training', action='store_true', default=False) # squash approx parser.add_argument('--squash-approx', action='store_true', default=False) # find best learning rate interval parser.add_argument('--find-lr', action='store_true', default=False, help='train to find the best learning rate') # normalize or not the inputs to the net (not normalized is better) parser.add_argument('--normalize-input', action='store_true', default=False, help='enables normalization and disables random ' 'cropping the ' 'inputs with padding 2') # use new / old version of the model parser.add_argument('--old-model', action='store_true', default=False, help='uses old model') args = parser.parse_args(args=arguments) args.directory = pathlib.Path(args.directory) print(args) if args.old_model: from src.model.model import Net import src.model.functions as func ModelToUse = Net def loss_func(output, target, regularization_scale, reconstruction, data, device, batch_size): return func.loss(output, reconstruction, target, data, regularization_scale, device) else: from src.model.layers import CapsNet from src.model.layers import loss_func as loss_func_internal ModelToUse = CapsNet def loss_func(output, target, regularization_scale, reconstruction, data, device, batch_size): return loss_func_internal(output, target, regularization_scale, reconstruction, data.view(batch_size, -1), device) # Check GPU or CUDA is available args.cuda = not args.no_cuda and torch.cuda.is_available() if not args.cuda: args.device = 'cpu' # Get reproducible results by manually seed the random number generator torch.manual_seed(args.seed) if args.cuda: torch.cuda.manual_seed(args.seed) # Load data train_loader, test_loader = utils.load_data(args) if args.adabatch: temp_bs = args.batch_size args.batch_size = 2**(args.adapow) train_loader1, _ = utils.load_data(args) args.batch_size = 2**(args.adapow) train_loader2, _ = utils.load_data(args) args.batch_size = 2**(args.adapow) train_loader3, _ = utils.load_data(args) args.batch_size = temp_bs # Build Capsule Network print('===> Building model') model = ModelToUse(input_wh=args.input_width, num_conv_in_channels=args.num_conv_in_channels, num_conv_out_channels=args.num_conv_out_channels, conv_kernel=args.conv_kernel, conv_stride=args.conv_stride, num_primary_channels=args.num_primary_channels, primary_caps_dim=args.primary_caps_dim, primary_kernel=args.primary_kernel, primary_stride=args.primary_stride, num_classes=args.num_classes, digit_caps_dim=args.digit_caps_dim, iter=args.num_routing, dec1_dim=args.dec1_dim, dec2_dim=args.dec2_dim, cuda_enabled=args.cuda, device=args.device, regularization_scale=args.regularization_scale, conv_shared_weights=args.conv_shared_weights, primary_shared_weights=args.primary_shared_weights, digit_shared_weights=args.digit_shared_weights, conv_shared_bias=args.conv_shared_bias, small_decoder=args.small_decoder, squash_approx=args.squash_approx) # Optimizer optimizer = optim.Adam(model.parameters(), lr=args.lr) # optimizer = optim.SGD(model.parameters(), lr=args.lr) lr_wr = utils.custom_warm_restarts(args.lr, args.lr * 10) starting_epoch = 1 if args.cuda: print('Utilize GPUs for computation') print('Number of GPU available', torch.cuda.device_count()) model.to(args.device) cudnn.benchmark = True model = torch.nn.DataParallel(model) args.file_flag = 'w' if args.restart_training: args.file_flag = args.file_flag p = pathlib.Path(args.directory) / + 'trained_model' if p.exists(): l = sorted(list(p.iterdir())) if l: f = l[-1] pckl = utils.load(str(f)) model.load_state_dict(pckl['model_state_dict']) optimizer.load_state_dict(pckl['optimizer_state_dict']) lr_wr.__dict__ = pckl['lr_wr'] starting_epoch = pckl['epoch'] # Print the model architecture and parameters print('Model architectures:\n{}\n'.format(model)) print('Parameters and size:') for name, param in model.named_parameters(): print('{}: {}'.format(name, list(param.size()))) # CapsNet has: # - 8.2M parameters and 6.8M parameters without the reconstruction subnet on MNIST. # - 11.8M parameters and 8.0M parameters without the reconstruction subnet on CIFAR10. num_params = sum([param.nelement() for param in model.parameters()]) # The coupling coefficients c_ij are not included in the parameter list, # we need to add them manually, which is 1152 * 10 = 11520 (on MNIST) or 2048 * 10 (on CIFAR10) print('\nTotal number of parameters: {}\n'.format(num_params + ( 11520 if args.dataset in ('mnist', 'fashionmnist') else 20480))) # Make model checkpoint directory if not (args.directory / 'trained_model').is_dir(): (args.directory / 'trained_model').mkdir(parents=True, exist_ok=True) # files to store accuracies and losses train_mloss = args.directory / 'train_margin_loss.txt' train_rloss = args.directory / 'train_reconstruction_loss.txt' train_acc = args.directory / 'train_accuracy.txt' test_mloss = args.directory / 'test_margin_loss.txt' test_rloss = args.directory / 'test_reconstruction_loss.txt' test_acc = args.directory / 'test_accuracy.txt' learning_rate = args.directory / 'learning_rate.txt' output_tensor = args.directory / 'output_tensor.txt' n_parameters = args.directory / 'n_parameters.txt' with open(n_parameters, args.file_flag) as f: f.write('{}\n'.format(num_params + (11520 if args.dataset == 'mnist' else 20480))) arguments_file = args.directory / 'arguments.txt' with open(arguments_file, args.file_flag) as f: pprint.pprint(args.__dict__, stream=f) description = args.directory / 'details.txt' description = open(description, args.file_flag) description.write(args.description) description.close() train_mloss = open(train_mloss, args.file_flag) train_rloss = open(train_rloss, args.file_flag) train_acc = open(train_acc, args.file_flag) test_mloss = open(test_mloss, args.file_flag) test_rloss = open(test_rloss, args.file_flag) test_acc = open(test_acc, args.file_flag) learning_rate = open(learning_rate, args.file_flag) output_tensor = open(output_tensor, args.file_flag) utils.dump(utils.make_dataset_obj(locals(), globals()), args.directory / 'trained_model' / 'dataset') # Train and test try: for epoch in range(starting_epoch, args.epochs + 1): if not args.adabatch: train(model, train_loader, optimizer, epoch, train_mloss, train_rloss, train_acc, learning_rate, lr_wr, output_tensor) test(model, test_loader, len(train_loader), epoch, test_mloss, test_rloss, test_acc, args.directory) else: if (1 <= epoch <= 3): train(model, train_loader, optimizer, epoch, train_mloss, train_rloss, train_acc, learning_rate, lr_wr, output_tensor) test(model, test_loader, len(train_loader), epoch, test_mloss, test_rloss, test_acc, args.directory) elif (4 <= epoch <= 33): args.batch_size = 2**(args.adapow) train(model, train_loader1, optimizer, epoch, train_mloss, train_rloss, train_acc, learning_rate, lr_wr, output_tensor) test(model, test_loader, len(train_loader), epoch, test_mloss, test_rloss, test_acc, args.directory) elif (34 <= epoch <= 63): args.batch_size = 2**(args.adapow + 1) train(model, train_loader2, optimizer, epoch, train_mloss, train_rloss, train_acc, learning_rate, lr_wr, output_tensor) test(model, test_loader, len(train_loader), epoch, test_mloss, test_rloss, test_acc, args.directory) else: args.batch_size = 2**(args.adapow + 2) train(model, train_loader3, optimizer, epoch, train_mloss, train_rloss, train_acc, learning_rate, lr_wr, output_tensor) test(model, test_loader, len(train_loader), epoch, test_mloss, test_rloss, test_acc, args.directory) train_mloss.flush() train_rloss.flush() train_acc.flush() test_mloss.flush() test_rloss.flush() test_acc.flush() learning_rate.flush() output_tensor.flush() # Save model checkpoint utils.checkpoint(utils.make_partial_checkpoint_obj( locals(), globals()), epoch, directory=args.directory) except KeyboardInterrupt: print("\n\n\nKeyboardInterrupt, Interrupting...") train_mloss.close() train_rloss.close() train_acc.close() test_mloss.close() test_rloss.close() test_acc.close() learning_rate.close() output_tensor.close() with open(args.directory / 'best_accuracy.txt', args.file_flag) as f: f.write("%.10f,%d\n" % (best_acc, best_acc_epoch)) print('\n\nBest Accuracy: ' + str(best_acc) + '%%\nReached at epoch: %d\n\n' % best_acc_epoch) global avg_training_time_per_epoch global avg_testing_time_per_epoch with open(args.directory / 'average_training_time_per_epoch.txt', args.file_flag) as f: f.write("%.10f\n" % avg_training_time_per_epoch) print('Average time per training epoch: %.10f\n\n' % avg_training_time_per_epoch) with open(args.directory / 'average_testing_time_per_epoch.txt', args.file_flag) as f: f.write("%.10f\n" % avg_testing_time_per_epoch) print('Average time per testing epoch: %.10f\n\n' % avg_testing_time_per_epoch)
def plot_manymore(exps, metric='accuracy', measure="mean", info=None, save=False): # Configs _metric = metric metric, measure = verify_metrics(metric, measure) xlabel = 'Rounds' ylabel = f' {measure.capitalize()} {_metric.capitalize()}' title = f'{_metric.capitalize()} vs. No. of rounds' if info is not None: xlabel = info.get('xlabel', xlabel) ylabel = info.get('ylabel', ylabel) title = info.get('title', title) plt.ylabel(ylabel, fontsize=13) plt.xlabel(xlabel, fontsize=13) colors = [ 'green', 'blue', 'orange', 'black', 'red', 'grey', 'tan', 'pink', 'navy', 'aqua' ] colors = [ 'black', 'green', 'orange', 'blue', 'red', 'grey', 'tan', 'pink', 'navy', 'aqua' ] line_styles = ['-', '--', '-.', '-', '--', '-.', ':', '-', '--', '-.', ':'] plt.grid(linestyle='dashed') plt.rc('legend', fontsize=12) plt.xticks(fontsize=13, ) plt.yticks(fontsize=13, ) std_data = None for i, exp in enumerate(exps): # Data logs = load(exp['file']) name = exp.get('name', "") if measure == "mean": data = np.mean([[v[metric] for v in lo] for lo in logs.values()], axis=0) elif measure == "mean-std": data = np.mean([[v[metric] for v in lo] for lo in logs.values()], axis=0) std_data = np.std([[v[metric] for v in lo] for lo in logs.values()], axis=0) elif measure == "max": data = np.max([[v[metric] for v in lo] for lo in logs.values()], axis=0) else: data = np.std([[v[metric] for v in lo] for lo in logs.values()], axis=0) x = range(0, len(data) * EVAL_ROUND, EVAL_ROUND) plt.plot(x, data, color=colors[i], label=name, linestyle=line_styles[i]) if std_data is not None: plt.fill_between(x, data - std_data, data + std_data, color=colors[i], alpha=.05) plt.legend(loc="lower right", shadow=True) plt.xlabel(xlabel) plt.ylabel(ylabel) # plt.yticks(np.arange(0, 1.1, 0.2)) plt.title(title) if save: unique = np.random.randint(100, 999) plt.savefig(f"../out/EXP_{unique}.pdf") plt.show()
import argparse import src.visualization.visualize as viz import src.graph_analysis as ga from src.utils import load from src.utils import load_graphml_format from src.predict_days import load_dataset from src.predict_days import predict_days from src.utils import GRAPHML_FORMAT from src.utils import PAJEK_FORMAT from src.utils import DATASET_PATH if __name__ == "__main__": reuters_graphml = load_graphml_format(GRAPHML_FORMAT) reuters_pajek = load(PAJEK_FORMAT) parser = argparse.ArgumentParser(description="Initializing graph analysis") parser.add_argument('-vg', '--visualize-graph', help="Visualize graph and save it to /figures folder") parser.add_argument('-ddd', '--draw-degree-distribution', help="Visualize degree distribution") parser.add_argument('-bc', '--betweenness-centrality', help="Visualize nodes with highest centrality value") parser.add_argument('-cc', '--closeness-centrality', help="Visualize nodes with highest centrality value") parser.add_argument('-vc', '--visualize-communities',
parser.add_argument('-n', '--name', default='model', type=str, help='Name of the model.') args = parser.parse_args() trained_model = os.path.join(BASE_PATH, 'models/{}.hdf5'.format(args.name)) model = MoleculeCVAE(gpu_mode=args.gpu) model.load(CHARSET, trained_model, latent_rep_size=LATENT_DIM) signatures, smiles = load(os.path.join(BASE_PATH, 'data/inchikeys_B4.npy'), os.path.join(BASE_PATH, 'data/signature_B4_matrix.npy'), os.path.join(BASE_PATH, 'data/key2inch_B4.csv'), calc_smiles=False) m = args.num_molecules n = args.num_reconstructions reconstructed_smiles = sim_reconstruction(model, np.array(smiles[-m:]), np.array(signatures[-m:]), latent_dim=LATENT_DIM, su=SignatureUtils(signatures), m=m, n=n, stds=[0, 0.05, 0.1], fix=args.fix)