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()
