with suppress_stdout(): tmp_ex.run("print_config") if tmp_ex.current_run is not None and "parent_config" in tmp_ex.current_run.config: return fetch_parents(tmp_ex.current_run.config["parent_config"], [current_path] + parents) else: return [current_path] + parents configs = fetch_parents(path) ex = Experiment('treeqn') for path in configs: ex.add_config(path) ex.logger = logger ex.observers.append(FileStorageObserver.create('./results')) @ex.config def my_config(save_folder, env_id, architecture, label, name): pytorch_version = torch.__version__ # Timestamp experiment directory save_folder = get_timestamped_dir(save_folder) # Environment switches # obs_dtype as str does the job and plays nice with sacred obs_dtype, input_mode = 'uint8', "atari" if "push" in env_id: obs_dtype, input_mode = 'float32', "push" if architecture == "dqn":
def main_console(): observer = FileStorageObserver(osp.join("output", "sacred", "expert_demos")) expert_demos_ex.observers.append(observer) expert_demos_ex.run_commandline()
if "no-mongo" in _v: # if "--no-mongo" == _v: del params[_i] no_mongodb = True break # If there is no url set for the mongodb, we cannot use it if not no_mongodb and "db_url" not in config_dict: no_mongodb = True logger.error("No 'db_url' to use for Sacred MongoDB") if not no_mongodb: db_url = config_dict["db_url"] db_name = config_dict["db_name"] mongo_client = setup_mongodb(db_url, db_name) # Save to disk by default for sacred, even if we are using the mongodb logger.info("Saving to FileStorageObserver in results/sacred.") file_obs_path = os.path.join(results_path, "sacred") while True: try: ex.observers.append(FileStorageObserver.create(file_obs_path)) break except FileExistsError: # sometimes we see race condition logger.info( "Creating FileStorageObserver failed. Trying again...") time.sleep(1) ex.run_commandline(params)
def main(): observer = FileStorageObserver.create(osp.join('data', 'sacred', 'score')) score_ex.observers.append(observer) score_ex.run_commandline() score_ex_logger.info("Sacred run completed, files stored at {}".format(observer.dir))
def hook(config, command_name, logger): if config['group_dir'] == None: raise Exception(f'group_dir is {config["group_dir"]}') else: util.require_dir(config['group_dir']) ex.observers.append(FileStorageObserver(config['group_dir']))
session_ids, _dir / 'audio', test_run=test_run, ) if mpi.IS_MASTER: print('Finished experiment dir:', _dir) if __name__ == '__main__': # Custom parsing of sacred --file_storage option. # This allows to give this option a default. argv = [*sys.argv] import argparse from pb_chime5 import git_root parser = argparse.ArgumentParser() parser.add_argument('-F', '--file_storage', default=git_root / 'sacred', help='add a file storage observer') parsed, args = parser.parse_known_args() argv = argv[:1] + args if mpi.IS_MASTER: path = Path(parsed.file_storage).expanduser().resolve() experiment.observers.append(FileStorageObserver.create(str(path))) experiment.run_commandline(argv)
def main(): observer = FileStorageObserver(osp.join("data", "sacred", "multi_score")) multi_score_ex.observers.append(observer) multi_score_ex.run_commandline()
def started_event(self, ex_info, command, host_info, start_time, config, meta_info, _id): timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") if config["result_folder"] is not None: result_folder = config["result_folder"].strip("/").split("/")[-1] custom_id = f"{timestamp}_ablation_waypoints_{result_folder}" else: custom_id = f"{timestamp}_ablation_waypoints" return custom_id # started_event returns the _run._id ex = Experiment("mujoco-ablation-waypoints") ex.observers = [ SetID(), FileStorageObserver.create("results/mujoco/ablation_waypoints"), ] class LatentSpaceTargetStateRewardWrapper(gym.Wrapper): def __init__(self, env, latent_space, target_states): self.env = env self.latent_space = latent_space self.target_states = [ts / np.linalg.norm(ts) for ts in target_states] self.state = None self.timestep = 0 super().__init__(env) def reset(self): obs = super().reset() self.state = self.latent_space.encoder(obs)
def cfg(data_config): model_config = { # Load pretrained model for testing "model_name": "DORN_median_matching", "model_params": { "in_channels": 3, "in_height": 257, "in_width": 353, "sid_bins": data_config["sid_bins"], "offset": data_config["offset"], "min_depth": data_config["min_depth"], "max_depth": data_config["max_depth"], "alpha": data_config["alpha"], "beta": data_config["beta"], "frozen": True, "pretrained": True, "state_dict_file": os.path.join("models", "torch_params_nyuv2_BGR.pth.tar"), }, "model_state_dict_fn": None } ckpt_file = None # Median matching eval dataset_type = "val" save_outputs = True seed = 95290421 small_run = 0 entry = None # print(data_config.keys()) output_dir = os.path.join( "results", data_config["data_name"], # e.g. nyu_depth_v2 "{}_{}".format(dataset_type, small_run), model_config["model_name"]) # e.g. DORN_nyu_nohints safe_makedir(output_dir) ex.observers.append( FileStorageObserver.create(os.path.join(output_dir, "runs"))) ## cuda_device = "0" # The gpu index to run on. Should be a string os.environ["CUDA_VISIBLE_DEVICES"] = cuda_device # print("after: {}".format(os.environ["CUDA_VISIBLE_DEVICES"])) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") print("using device: {} (CUDA_VISIBLE_DEVICES = {})".format( device, os.environ["CUDA_VISIBLE_DEVICES"])) if ckpt_file is not None: model_update, _, _ = load_checkpoint(ckpt_file) model_config.update(model_update) del model_update, _ # So sacred doesn't collect them.
#Sacred #Sources #https://github.com/gereleth/kaggle-telstra/blob/master/Automatic%20model%20tuning%20with%20Sacred%20and%20Hyperopt.ipynb #https://github.com/maartjeth/sacred-example-pytorch from sacred import Experiment from sacred.observers import FileStorageObserver from sacred.observers import MongoObserver from sacred.observers import SlackObserver from sacred.utils import apply_backspaces_and_linefeeds EXPERIMENT_NAME = 'experiment' DATABASE_NAME = 'experiments' URL_NAME = 'mongodb://localhost:27017/' ex = Experiment() ex.observers.append(FileStorageObserver.create('results')) ex.observers.append(FileStorageObserver.create('results-bert-aws')) ex.observers.append(FileStorageObserver.create('results-bert-google')) ex.observers.append(FileStorageObserver.create('results-features')) #ex.observers.append(MongoObserver.create(url=URL_NAME, db_name=DATABASE_NAME)) ex.captured_out_filter = apply_backspaces_and_linefeeds #Send a message to slack if the run is succesfull or if it failed slack_obs = SlackObserver.from_config('slack.json') ex.observers.append(slack_obs) #Device if torch.cuda.is_available(): device = torch.device("cuda") else: device = torch.device("cpu")
import numpy as np from sacred import Experiment from sacred.observers import FileStorageObserver from sacred.utils import apply_backspaces_and_linefeeds import datasets import models import evaluate_classification import evaluate_regression ex = Experiment('uncertainty-quality') ex.captured_out_filter = apply_backspaces_and_linefeeds ex.observers.append(FileStorageObserver.create('runs/', template='template_regression.html')) @ex.config def cfg(): seed = 1337 num_experiments = 10 dataset_settings = { 'name': 'protein_structure', } model_settings = { 'name': 'mlp', 'dropout': 0.05, 'layers': [50, 50], 'epochs': 300, 'batch_size': 100,
def main(): observer = FileStorageObserver.create( osp.join('data', 'sacred', 'tsne_activations')) generate_activations_ex.observers.append(observer) generate_activations_ex.run_commandline()
def compute_wc_multiple(config_grid): ex.observers.append(FileStorageObserver(config_grid.root_path)) ex.observers.append(SetID('myid')) for config in config_grid.configs_from_grid(): ex.observers[1] = SetID(config.uid) ex.run(config_updates={'config': config, 'seed': config.seed})
import time from datetime import datetime import numpy as np import tensorflow as tf from sacred import Experiment from sacred.observers import FileStorageObserver import configuration import siamese_model from utils.misc_utils import auto_select_gpu, mkdir_p, save_cfgs from utils.train_utils import load_caffenet ex = Experiment(configuration.RUN_NAME) ex.observers.append( FileStorageObserver.create(osp.join(configuration.LOG_DIR, 'sacred'))) @ex.config def configurations(): # Add configurations for current script, for more details please see the documentation of `sacred`. # REFER: http://sacred.readthedocs.io/en/latest/index.html model_config = configuration.MODEL_CONFIG train_config = configuration.TRAIN_CONFIG track_config = configuration.TRACK_CONFIG def _configure_learning_rate(train_config, global_step): lr_config = train_config['lr_config'] num_batches_per_epoch = \
from importlib import import_module from pip import get_installed_distributions import numpy as np from tqdm import tqdm from sacred import Experiment from sacred.observers import FileStorageObserver import torchvision.datasets from benchmark.data import Iterator ex = Experiment('benchmark') project_root = Path(__file__).resolve().parent.parent data_dir = project_root / 'results' ex.observers.append(FileStorageObserver.create(str(data_dir))) @ex.config def config(): """ """ project_root = str(project_root) ngpu = 1 # ngpu = 0 corresponds to cpu-mode data_type = 'image' # You can choise data-type from this list ['image', 'sequence', 'mnist', 'cifer-10']. 'image' and 'sequence' are dummy data. assert data_type in ['image', 'sequence', 'mnist', 'cifer-10'], \ "Your data_type[{}] is not supported.".format(data_type) batch_size = 128
from sacred.observers import FileStorageObserver, SlackObserver from graspy.models import SBMEstimator, DCSBMEstimator from src.data import load_left, load_right from graspy.utils import binarize, symmetrize from src.models import fit_a_priori from src.utils import save_obj ex = Experiment("Fit a priori") current_file = basename(__file__)[:-3] sacred_file_path = Path(f"./maggot_models/models/runs/{current_file}") slack_obs = SlackObserver.from_config("slack.json") file_obs = FileStorageObserver.create(sacred_file_path) ex.observers.append(slack_obs) ex.observers.append(file_obs) @ex.config def config(): # Variables defined in config get automatically passed to main directed = True # noqa: F841 def run_fit(seed, directed): # run left graph, labels = load_left()
import os.path as osp import random import time from datetime import datetime import numpy as np import tensorflow as tf from sacred import Experiment from sacred.observers import FileStorageObserver import configuration import siamese_model from utils.misc_utils import auto_select_gpu, mkdir_p, save_cfgs ex = Experiment(configuration.RUN_NAME) ex.observers.append(FileStorageObserver.create(osp.join(configuration.LOG_DIR, 'sacred'))) @ex.config def configurations(): # Add configurations for current script, for more details please see the documentation of `sacred`. # REFER: http://sacred.readthedocs.io/en/latest/index.html model_config = configuration.MODEL_CONFIG train_config = configuration.TRAIN_CONFIG track_config = configuration.TRACK_CONFIG def _configure_learning_rate(train_config, global_step): lr_config = train_config['lr_config'] num_batches_per_epoch = \
def main(): observer = FileStorageObserver.create(osp.join('data', 'sacred', 'train')) train_ex.observers.append(observer) train_ex.run_commandline()
monkey_patch_nifti_image() from sklearn.model_selection import train_test_split from modl.input_data.fmri.rest import get_raw_rest_data from modl.decomposition.fmri import fMRIDictFact, rfMRIDictionaryScorer from modl.plotting.fmri import display_maps from modl.utils.system import get_output_dir from sacred import Experiment import pandas as pd exp = Experiment('decomppose_fmri') base_artifact_dir = join(get_output_dir(), 'decompose_fmri') exp.observers.append(FileStorageObserver.create(basedir=base_artifact_dir)) @exp.config def config(): n_components = 70 batch_size = 100 learning_rate = 0.92 method = 'dictionary only' reduction = 1 alpha = 1e-4 n_epochs = 100 verbose = 30 n_jobs = 5 step_size = 1e-5 source = 'adhd_4'
import torch from torch import optim from torchvision.datasets import FashionMNIST from torch.utils.data import DataLoader from torch.utils.data import random_split from torchvision import transforms from torchvision.utils import save_image from sacred import Experiment from sacred.observers import FileStorageObserver, SlackObserver, MongoObserver from model import simple_cnn ##sacred stuff ex = Experiment("Fashion Modell MTL") ex.observers.append(FileStorageObserver.create('reports\\FashionMnistExperiments')) ex.observers.append(MongoObserver()) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") loss_fn = torch.nn.CrossEntropyLoss() #ex.observers.append() @ex.config def config(): batch_size = 128 epochs = 15 lr = 1e-3 train_split_ratio = 0.8 path = "" ##output path for saving images for example notes = "Experiment description" cfg_dict = {} ## if there are to many hyper_params, collect here and dependy inject the dict
from baselines.policy.mlp_policy import MlpPolicy from baselines.policy.cnn_policy import CnnPolicy from baselines.pois import pois from baselines.pois.parallel_sampler import ParallelSampler # Sacred from sacred import Experiment from sacred.observers import FileStorageObserver, SlackObserver # Create experiment ex = Experiment('POIS') # Set a File Observer if os.environ.get('SACRED_RUNS_DIRECTORY') is not None: print("Sacred logging at:", os.environ.get('SACRED_RUNS_DIRECTORY')) ex.observers.append( FileStorageObserver.create(os.environ.get('SACRED_RUNS_DIRECTORY'))) if os.environ.get('SACRED_SLACK_CONFIG') is not None: print("Sacred is using slack.") ex.observers.append( SlackObserver.from_config(os.environ.get('SACRED_SLACK_CONFIG'))) @ex.config def custom_config(): seed = 0 env = 'rllab.cartpole' num_episodes = 100 max_iters = 500 horizon = 500 iw_method = 'is' iw_norm = 'none'
from data_set_file import create_huge_data_set, create_encoding_deconding_dict, generate_random_dataset, create_dict_nb_ligne from model_creation import create_model from trainning import train_model, load_model_weights, create_scheduler from test_metrics import calcul_metric_concours import torch import torch.optim as optim import torch.nn as nn import numpy as np import random from torch.utils.data import DataLoader #Trucs sacred experiment_sacred = Experiment("Doodle_Boys") experiment_sacred.observers.append( FileStorageObserver.create('runs_sacred/model_data_random')) #Configs @experiment_sacred.config def configuration(): path_data = 'D:/User/William/Documents/Devoir/Projet Deep/data/mini_train/' path_save_model = "saves_model/model_poids_random.tar" #path_load_existing_model = "saves_model/model_poids_random.tar" path_load_existing_model = None path_model_weights_test = "saves_model/model_poids_random.tar" use_gpu = True
import os.path as osp import os import numpy as np import time import torch from torch_geometric.data import DataLoader import torch.utils.tensorboard as tb from lib.datasets.config import get_output_dir, get_tb_dir from lib.datasets.datasets import Datasets from lib.network.complete_net import completeNet from lib.network.utils import weighted_binary_cross_entropy, hungarian ex = Experiment('Training network') ex.observers.append(FileStorageObserver('../gdrive/MyDrive/KamMOT_trenowanie/logs')) ex.add_config('config/training.yaml') @ex.automain def main(_config, _log, _run, training): torch.manual_seed(training['seed']) torch.cuda.manual_seed(training['seed']) np.random.seed(training['seed']) torch.backends.cudnn.deterministic = True print(_config) output_dir = osp.join(get_output_dir(training['cnn_encoder']) + '_runID_' + _run._id) tb_dir = osp.join(get_tb_dir(training['cnn_encoder']) + '_runID_' + _run._id)
from ingredients.dataset import deladd, load_deladd as load_dataset from ingredients.model import model, init_model from ingredients.training import training, init_metrics, init_optimizer, \ create_rnn_trainer, create_rnn_evaluator, \ Tracer, ModelCheckpoint, LRScheduler # Add configs training.add_config('configs/dummy-training.yaml') deladd.add_config('configs/dummy-dataset.yaml') model.add_config('dummy-lstm.yaml') # Set up experiment ex = Experiment(name='deladd', ingredients=[deladd, model, training]) ex.add_config(no_cuda=False, save_folder='../../data/sims/deladd/temp/') ex.add_package_dependency('torch', torch.__version__) ex.observers.append(FileStorageObserver.create('../data/sims/test/')) # Functions @ex.capture def set_seed_and_device(seed, no_cuda): np.random.seed(seed) torch.manual_seed(seed) if torch.cuda.is_available() and not no_cuda: torch.cuda.manual_seed(seed) device = torch.device('cuda') else: device = torch.device('cpu') return device
import numpy as np import ddf_fdk as ddf import nn_fdk as nn import time import pylab t = time.time() from sacred.observers import FileStorageObserver from sacred import Experiment from os import environ name_exp = 'MSD' ex = Experiment(name_exp, ingredients=[]) FSpath = '/export/scratch2/lagerwer/NNFDK_results/' + name_exp ex.observers.append(FileStorageObserver.create(FSpath)) # %% @ex.config def cfg(): phantom = 'Fourshape_test' nVD = 1 nTD = 1 train = False # %% @ex.automain
def main(): observer = FileStorageObserver(osp.join("data", "sacred", "tsne")) tsne_ex.observers.append(observer) tsne_ex.run_commandline()
from sacred import Experiment from sacred.observers import FileStorageObserver from data_set_file import create_huge_data_set,create_encoding_deconding_dict from model_creation import create_model from trainning import LRPolicy,train_model import torch.optim as optim import torch.nn as nn from torch.optim.lr_scheduler import LambdaLR from torch.utils.data import DataLoader #Trucs sacred experiment_sacred=Experiment("Doodle_Boys") experiment_sacred.observers.append(FileStorageObserver.create('my_runs_v_alpha')) #Configs @experiment_sacred.config def configuration(): path_data = 'D:/User/William/Documents/Devoir/Projet Deep/data/mini_train/' path_save_model="saves_model/model_info.tar" nb_row_per_classe=400 use_gpu=True
from data_set_file import create_huge_data_set, create_encoding_deconding_dict from model_creation import create_model from trainning import train_model, load_model_weights, create_scheduler from test_metrics import calcul_metric_concours import torch import torch.optim as optim import torch.nn as nn import numpy as np import random from torch.utils.data import DataLoader #Trucs sacred experiment_sacred = Experiment("Doodle_Boys") experiment_sacred.observers.append( FileStorageObserver.create('my_runs_v_alpha')) #Configs @experiment_sacred.config def configuration(): path_data = 'D:/User/William/Documents/Devoir/Projet Deep/data/mini_train/' path_save_model = "saves_model/model_4_classes.tar" path_load_existing_model = None # path_load_existing_model = "saves_model/model_4_classes.tar" path_model_weights_test = "saves_model/model_4_classes.tar" use_gpu = True do_training = True
from sacred.observers import MongoObserver import fastai import news_utils.fastai from bpemb import BPEmb import news_utils.clean.german EX_PA = Path('/mnt/data/group07/johannes/ompc/pplmexp_short2') ex = Experiment('shortppompclm2') from sacred.observers import FileStorageObserver # ex.observers.append(MongoObserver.create(db_name='shortppompclm2')) ex.observers.append(FileStorageObserver.create('my_runs')) @ex.config def my_config(): bs = 128 epochs_start = 0 epochs = 10 #math.ceil(random.uniform(1, 5)) drop_mult = 0.5559 #random.uniform(0.5, 1) exp_id = datetime.datetime.now().strftime("%Y_%_m_%d_%H_%M_%S_%f") model_id = '2019_ 3_27_14_30_09_921754' # best model after 5 epochs @ex.main def my_main(epochs, drop_mult, exp_id, bs, epochs_start, model_id):
# writes the results # cf. https://github.com/IDSIA/sacred/issues/174 class SetID(RunObserver): priority = 50 # very high priority to set id def started_event(self, ex_info, command, host_info, start_time, config, meta_info, _id): timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S") custom_id = "{}_learn_dynamics_{}_{}".format(timestamp, config["env_name"], config["problem_spec"]) return custom_id # started_event returns the _run._id ex = Experiment("learn_dynamics_model") ex.observers = [SetID(), FileStorageObserver.create("results")] def _get_log_folders(checkpoint_base, tensorboard_base, label): checkpoint_folder = os.path.join(checkpoint_base, label) tensorboard_folder = os.path.join(tensorboard_base, label) os.makedirs(checkpoint_folder, exist_ok=True) os.makedirs(tensorboard_folder, exist_ok=True) return checkpoint_folder, tensorboard_folder def train_latent_space_model( env, hidden_layer_size, rnn_state_size, n_rollouts,
#!/usr/bin/env python3 import sacred from sacred.observers import FileStorageObserver experiment = sacred.Experiment('observe') @experiment.config def configuration(): recipient = 'observer' message = 'hello {0}!'.format(recipient) @experiment.main def main(message): print(message) experiment.observers.append( FileStorageObserver.create('run') ) experiment.run()
config.gpu_options.per_process_gpu_memory_fraction = 0.5 set_session(tf.Session(config=config)) import numpy as np from sacred import Experiment from sacred.observers import FileStorageObserver from sacred.utils import apply_backspaces_and_linefeeds import datasets import models import tqdm from scipy.stats import entropy from sklearn.linear_model import LogisticRegression ex = Experiment('uncertainty-quality') ex.captured_out_filter = apply_backspaces_and_linefeeds ex.observers.append(FileStorageObserver.create('runs/')) @ex.config def cfg(): seed = 1337 dataset_settings = { 'name': 'cifar10', } model_settings = { 'name': 'cnn', 'epochs': 100, }
"""A standard machine learning task without much sacred magic.""" from sacred import Experiment from sacred.observers import FileStorageObserver from sklearn import svm, datasets, model_selection ex = Experiment("svm") ex.observers.append( FileStorageObserver.create("my_runs") ) ex.add_config({ # Configuration is explicitly defined as dictionary. "C": 1.0, "gamma": 0.7, "kernel": "rbf", "seed": 42 }) def get_model(C, gamma, kernel): return svm.SVC(C=C, kernel=kernel, gamma=gamma) @ex.main # Using main, command-line arguments will not be interpreted in any special way. def run(_config): X, y = datasets.load_breast_cancer(return_X_y=True) X_train, X_test, y_train, y_test = model_selection.train_test_split(X, y, test_size=0.2) clf = get_model(_config["C"], _config["gamma"], _config["kernel"]) # Parameters are passed explicitly. clf.fit(X_train, y_train) return clf.score(X_test, y_test)
import tensorflow as tf import numpy as np from os import listdir, path from enhancersdata import EnhancersData from sacred import Experiment from sacred.observers import FileStorageObserver ex = Experiment() ex.observers.append(FileStorageObserver.create('log')) @ex.config def general_config(): general_cfg = { "seq_length": 1000, "num_outs": 2, "batch_size": 100, "num_epochs": 40 } @ex.config def cnn_config(): conv1_cfg = {"num_filters": 16, "filter_size": [4, 15]} conv2_cfg = {"num_filters": 16, "filter_size": [1, 5]} conv3_cfg = {"num_filters": 32, "filter_size": [1, 5]} pool1_cfg = {"kernel_size": 10, "stride": 10} pool2_cfg = {"kernel_size": 3, "stride": 3} pool3_cfg = {"kernel_size": 3, "stride": 3} dropout_keep_prob = 0.5
import torch.optim as optim from tqdm import tqdm from constants import * sys.path.append(BASE_DIR) from goggles.loss import CustomLoss2 from goggles.models.semantic_ae import SemanticAutoencoder from goggles.opts import DATASET_MAP, DATA_DIR_MAP from goggles.utils.vis import \ get_image_from_tensor, save_prototype_patch_visualization _make_cuda = lambda x: x.cuda() if torch.cuda.is_available() else x ex = Experiment('goggles-experiment') ex.observers.append(FileStorageObserver.create(os.path.join(ALL_RUNS_DIR))) def _provision_run_dir(run_dir): new_dirs = [LOGS_DIR_NAME, IMAGES_DIR_NAME, PROTOTYPES_DIR_NAME] new_dirs = list(map(lambda d: os.path.join(run_dir, d), new_dirs)) for new_dir in new_dirs: os.makedirs(new_dir) return new_dirs @ex.config def default_config(): seed = 42 # RNG seed for the experiment dataset = 'cub' # Dataset to be used (cub/awa2) filter_class_ids = None # Class IDs used for training, uses all classes if None
policy_path: A path to the serialized policy. log_dir: The directory to log intermediate output to. (As of 2019-07-19 this is just episode-by-episode reward from bench.Monitor.) Returns: Statistics returned by `imitation.util.rollout.rollout_stats`. """ tf.logging.set_verbosity(tf.logging.INFO) tf.logging.info('Logging to %s', log_dir) venv = util.make_vec_env(env_name, num_vec, seed=_seed, parallel=parallel, log_dir=log_dir) if render: venv = InteractiveRender(venv) # TODO(adam): add support for videos using VideoRecorder? policy = serialize.load_policy(policy_type, policy_path, venv) stats = rollout.rollout_stats(policy, venv, n_timesteps=timesteps) return stats if __name__ == "__main__": observer = FileStorageObserver.create( osp.join('output', 'sacred', 'policy_eval')) policy_eval_ex.observers.append(observer) policy_eval_ex.run_commandline()