def _create_ingredient(cls, module, sub_ingredients, command_list): ingredient = sacred.Ingredient(module, ingredients=sub_ingredients.values()) # create module config consisting of (1) the module class name and (2) its config options (from config()) ingredient.add_config({"_name": cls.name}) ingredient.config(cls.config) # add ingredient's commands to the shared command_list for command_name, command_func in cls.commands.items(): command_list.append((command_name, command_func, module, ingredient)) # override sub_ingredients' configs for k, sub_ingredient in sub_ingredients.items(): overrides = cls.dependencies[k].config_overrides if overrides: assert "_name" not in overrides, "cannot override _name" sub_ingredient.add_config(cls.dependencies[k].config_overrides) return ingredient
import sacred ############### # Training # ############### training_ingredient = sacred.Ingredient('training') @training_ingredient.config def training_config(): # Dataset parameters batch_size = 64 validation_size = 0.1 eval_samples = 15 # Training Hyperparameters epochs = 2 learning_rate = 1e-3 nx_drop_rate = 0.1 # Capacity parameters lambda_image = 1.0 lambda_symbol = 50.0 beta_image = 1.0 beta_symbol = 1.0 gamma_image = 1.0 gamma_symbol = 50.0 beta_nexus = 1.0
"""Common configuration elements for reward network training.""" import logging from typing import Any, Mapping, Optional, Type import sacred from stable_baselines3.common import vec_env from imitation.rewards import reward_nets reward_ingredient = sacred.Ingredient("reward") logger = logging.getLogger(__name__) @reward_ingredient.config def config(): # Custom reward network net_cls = None net_kwargs = {} locals() # quieten flake8 @reward_ingredient.capture def make_reward_net( venv: vec_env.VecEnv, net_cls: Optional[Type[reward_nets.RewardNet]], net_kwargs: Optional[Mapping[str, Any]], ) -> Optional[reward_nets.RewardNet]: """Builds a reward network. Args:
"""Common configuration elements for scripts.""" import logging import os from typing import Any, Mapping, Sequence, Tuple, Union import sacred from stable_baselines3.common import vec_env from imitation.util import logger as imit_logger from imitation.util import sacred as sacred_util from imitation.util import util common_ingredient = sacred.Ingredient("common") logger = logging.getLogger(__name__) @common_ingredient.config def config(): # Logging log_root = None log_dir = None log_level = logging.INFO log_format_strs = ["tensorboard", "stdout"] # Environment config env_name = "seals/CartPole-v0" # environment to train on num_vec = 8 # number of environments in VecEnv parallel = True # Use SubprocVecEnv rather than DummyVecEnv max_episode_steps = None # Set to positive int to limit episode horizons env_make_kwargs = {} # The kwargs passed to `spec.make`.
import pymongo FILE_DIR = os.path.dirname(__file__) MONGODB_PORT = 27020 try: client = pymongo.MongoClient("localhost", serverSelectionTimeoutMS=1, port=MONGODB_PORT) client.server_info() except pymongo.errors.ServerSelectionTimeoutError: MONGODB_PORT = None # # Torch Ingredient # torch_ingredient = sacred.Ingredient('torch_cfg') # pylint: disable=invalid-name torch_ingredient.add_config(os.path.join(FILE_DIR, 'config/torch.yaml')) def cuda_is_available(): # hack to check if cuda is available. calling torch.cuda.is_available in # this process breaks the multiprocesscing of multiple environments # See: https://github.com/pytorch/pytorch/pull/2811 from torch.multiprocessing import Process, Queue def wrap_cuda_is_available(q): q.put(torch.cuda.is_available()) q = Queue() p = Process(target=wrap_cuda_is_available, args=(q, )) p.start()
import sacred ############### # Training # ############### training_ingredient = sacred.Ingredient('training') @training_ingredient.config def training_config(): experiment = 'sound_classifier' # Dataset parameters batch_size = 64 # Training Hyperparameters epochs = 100 learning_rate = 1e-3 # Seed seed = 4 ######## # CUDA # ######## gpu_ingredient = sacred.Ingredient('gpu')
import sacred import sounds_deep.contrib.data.data as data load_data_ingredient = sacred.Ingredient('dataset') @load_data_ingredient.config def cfg(): dataset_name = 'mnist' data_path = './data/' batch_size = 32 @load_data_ingredient.capture def load_data(dataset_name, data_path, batch_size): if dataset_name == 'mnist': train_data, _, test_data, _ = data.load_mnist(data_path) elif dataset_name == 'cifar10': train_data, _, test_data, _ = data.load_cifar10(data_path) else: assert False, "Must specify a valid dataset_name" data_shape = (batch_size, ) + train_data.shape[1:] batches_per_epoch = train_data.shape[0] // batch_size train_gen = data.data_generator(train_data, batch_size) test_gen = data.data_generator(test_data, batch_size) return train_gen, test_gen, batches_per_epoch, data_shape
import os import sacred import datetime import numpy as np import tensorflow as tf from utils.loader import data_loader from utils.rprop import RPropOptimizer from tensorflow.python.client import device_lib from src.visualization import visualize as plot sacredIngredients = sacred.Ingredient('default_params') sacredIngredients.add_config('./settings/config.yaml') sacredIngredients.add_config('./settings/params.yaml') def get_available_gpus(): local_device_protos = device_lib.list_local_devices() return [x.name for x in local_device_protos if x.device_type == 'GPU'] def variable_summaries(var): """Attach a lot of summaries to a Tensor (for TensorBoard visualization).""" with tf.name_scope('summaries'): mean = tf.reduce_mean(var) tf.summary.scalar('mean', mean) with tf.name_scope('stddev'): stddev = tf.sqrt(tf.reduce_mean(tf.square(var - mean))) tf.summary.scalar('stddev', stddev) tf.summary.scalar('max', tf.reduce_max(var)) tf.summary.scalar('min', tf.reduce_min(var))
import os import re import abc import random import itertools import sacred import pickle import collections import csv import warnings import copy from typing import List, Set, Tuple ingrediant = sacred.Ingredient("dataset") class DatasetBase(collections.abc.Sequence): """ #TODO """ def __init__(self, dataset: List[Tuple[str, str]]): self._dataset = sorted(dataset, key=lambda x: (x[1], x[0])) @property def dataset(self): return self._dataset def __getitem__(self, key): return self.dataset.__getitem__(key)
""" Try dependencies. Run in console with: python -m test02 print_dependencies with a=2 """ import sacred data_ingredient = sacred.Ingredient("data") experiment = sacred.Experiment(ingredients=[data_ingredient]) @data_ingredient.config def data_config(): file = "aaa" @experiment.config def my_config_01(): """This is `my_config_01`.""" a = 10 # some integer @experiment.automain def my_main(a, _config): print('Hello world!') print("_config =", _config)
import logging from typing import Any, Mapping, Type import sacred import stable_baselines3 from stable_baselines3.common import ( base_class, off_policy_algorithm, on_policy_algorithm, vec_env, ) from imitation.scripts.common.train import train_ingredient rl_ingredient = sacred.Ingredient("rl", ingredients=[train_ingredient]) logger = logging.getLogger(__name__) @rl_ingredient.config def config(): rl_cls = stable_baselines3.PPO batch_size = 2048 # batch size for RL algorithm rl_kwargs = dict( # For recommended PPO hyperparams in each environment, see: # https://github.com/DLR-RM/rl-baselines3-zoo/blob/master/hyperparams/ppo.yml learning_rate=3e-4, batch_size=64, n_epochs=10, ent_coef=0.0, )
import sacred import tensorflow as tf import sounds_deep.contrib.util as util train_ingredient = sacred.Ingredient('train') @train_ingredient.config def cfg(): epochs = 250 @train_ingredient.capture def run_training(write_update_fn, train_op, train_gen, input_ph, verbose_ops_dict, batches_per_epoch, epochs): out_dicts = [] config = tf.ConfigProto() config.gpu_options.allow_growth = True with tf.Session(config=config) as session: session.run(tf.global_variables_initializer()) for epoch in range(epochs): out_dict = util.run_epoch_ops( session, batches_per_epoch, verbose_ops_dict=verbose_ops_dict, silent_ops=[train_op], feed_dict_fn=lambda: {input_ph: next(train_gen)}, verbose=False) out_dicts.append(out_dict)
"""Common configuration elements for training imitation algorithms.""" import logging from typing import Mapping, Union import sacred from stable_baselines3.common import base_class, policies, vec_env from imitation.data import rollout from imitation.policies import base train_ingredient = sacred.Ingredient("train") logger = logging.getLogger(__name__) @train_ingredient.config def config(): # Training policy_cls = base.FeedForward32Policy policy_kwargs = {} # Evaluation n_episodes_eval = 50 # Num of episodes for final mean ground truth return locals() # quieten flake8 @train_ingredient.named_config def fast(): n_episodes_eval = 1 locals() # quieten flake8
import proximal as px from proximal.utils.utils import CUDA_AVAILABLE, Impl from proximal.utils.metrics import psnr_metric, ssim_metric from tf_solver import Deployer, FLAGS from utilities import pickle_load_all_to_list __all__ = ('elemental_ingredient', 'print_config', 'init_denoising_prior', 'grid_ingredient', 'init_cnn_func', 'init_metric', 'init_problem', 'solve_problem', 'start_grid_search', 'plt') # # This is the "elemental" ingredient to all our experiments. It provides a # default configuration and several helper functions. # elemental_ingredient = sacred.Ingredient('elemental') @elemental_ingredient.config def elemental_config(): """ Default experiment configuration. Remark: The notation of the alpha_* is different than in our paper but in consistence with the interface of the ProxImal framework. """ # pylint:disable=unused-variable sigma = 1.0 sigma_scale = 6.0 # default proximal value tau = None theta = None
import numpy as np import sacred import sonnet as snt import tensorflow as tf import sounds_deep.contrib.data.data as data import sounds_deep.contrib.models.vae as vae define_vae_ingredient = sacred.Ingredient('model') @define_vae_ingredient.config def cfg(): latent_dimension = 50 @define_vae_ingredient.capture def write_verbose_ops(epoch, result_dict, _run): result_dict['elbo'] = float(np.mean(result_dict['elbo'])) result_dict['iw_elbo'] = float(np.mean(result_dict['iw_elbo'])) _run.info[epoch] = result_dict @define_vae_ingredient.capture def define_model(data_shape, latent_dimension): # define model components encoder_module = snt.nets.MLP([200, 200]) decoder_module = snt.nets.MLP([200, 200, 784]) model = vae.VAE(latent_dimension, encoder_module, decoder_module) # assemble graph
import sacred ############### # Training # ############### training_ingredient = sacred.Ingredient('training') @training_ingredient.config def training_config(): # Dataset parameters batch_size = 16 # Training Hyperparameters epochs = 100 learning_rate = 1e-3 b_dim = 64 # Seed seed = 4 model_debug_ingredient = sacred.Ingredient('model_debug') @model_debug_ingredient.config def debug_config(): artifact_storage_interval = 10
"""Common configuration element for scripts learning from demonstrations.""" import logging import os from typing import Optional, Sequence import sacred from imitation.data import types demonstrations_ingredient = sacred.Ingredient("demonstrations") logger = logging.getLogger(__name__) @demonstrations_ingredient.config def config(): # Demonstrations data_dir = "data/" rollout_path = None # path to file containing rollouts n_expert_demos = None # Num demos used. None uses every demo possible locals() # quieten flake8 @demonstrations_ingredient.named_config def fast(): n_expert_demos = 1 # noqa: F841 def guess_expert_dir(data_dir: str, env_name: str) -> str: rollout_hint = env_name.rsplit("-", 1)[0].replace("/", "_").lower()