def init(): log_id = str(int(time.time()*10)%(60*60*24*365*10))+str(os.getpid()) global logger logger = logging.getLogger(str(log_id)) logger.setLevel(logging.DEBUG) # write to file fh = logging.FileHandler('ex.log') fh.setLevel(logging.DEBUG) # write to console ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) # Handler format formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -\n\t%(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) logger.addHandler(fh) logger.addHandler(ch) global ex ex = Experiment('TrajMap') ex.logger = logger ex.observers.append(MongoObserver.create(url='10.60.43.110:27017', db_name='TurnHMM')) #ex.observers.append(MongoObserver.create(url='127.0.0.1:27017', db_name='nTrajMap')) return ex, logger
def objective(args_): # arguments to pass as config_updates dict global args # result to pass to hyperopt global result # command-line arguments global parse_args try: ex = Experiment('Hyperopt') logger.debug("Adding observer for {}, DB {}".format(parse_args.mongo_db_address,parse_args.mongo_db_name)) ex.observers.append(MongoObserver.create(url=parse_args.mongo_db_address, db_name=parse_args.mongo_db_name)) pythia_args = make_args_for_pythia(args_) args = mp.get_args(**pythia_args) ex.main(run_with_global_args) r = ex.run(config_updates=pythia_args) logger.debug("Experiment result: {}\n" "Report to hyperopt: {}".format(r.result, result)) return result except: raise #If we somehow cannot get to the MongoDB server, then continue with the experiment logger.warning("Running without Sacred") run_with_global_args()
def test_named_config_not_found_raises(): ex = Experiment('exp') ex.main(lambda: None) with pytest.raises(NamedConfigNotFoundError, match='Named config not found: "not_there". ' 'Available config values are:'): ex.run(named_configs=('not_there',))
def fetch_parents(current_path, parents=[]): tmp_ex = Experiment('treeqn') tmp_ex.add_config(current_path) 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
def test_config_added_raises(): ex = Experiment('exp') ex.main(lambda: None) with pytest.raises( ConfigAddedError, match=r'Added new config entry that is not used anywhere.*\n' r'\s*Conflicting configuration values:\n' r'\s*a=42'): ex.run(config_updates={'a': 42})
def test_circular_dependency_raises(): # create experiment with circular dependency ing = Ingredient('ing') ex = Experiment('exp', ingredients=[ing]) ex.main(lambda: None) ing.ingredients.append(ex) # run and see if it raises with pytest.raises(CircularDependencyError, match='exp->ing->exp'): ex.run()
def objective(args_): global args global result global parse_args args=args_ try: ex = Experiment('Hyperopt') ex.observers.append(MongoObserver.create(url=parse_args.mongo_db_address, db_name=parse_args.mongo_db_name)) ex.main(lambda: run_with_global_args()) r = ex.run(config_updates=args) print(r) return result except: raise #If we somehow cannot get to the MongoDB server, then continue with the experiment print("Running without Sacred") run_with_global_args()
class Job(metaclass=ABCMeta): def __init__( self, exp_config: dict = None, add_defaults: bool = True, mongo_hostnames: list = None, ): exp_config = exp_config or dict() if add_defaults: self.exp_config = self.add_config_defaults(exp_config) else: self.exp_config = exp_config if mongo_hostnames is None: mongo_hostnames = ["tater"] self.mongo_hostnames = mongo_hostnames self._experiment = None self._observers = [] @property def default_observers(self): observers = [] if socket.gethostname() in self.mongo_hostnames: observers.append( MongoObserver( url= f"mongodb://*****:*****@localhost:27017/?authMechanism=SCRAM-SHA-1", db_name="db", )) observers.append( FileStorageObserver( self.exp_config.get("storage_dir", "./sacred_storage"))) return observers @property def experiment(self): """ Experiment object required for Sacred. :return: sacred.Experiment object. """ if self._experiment is None: self._experiment = Experiment( name=self.exp_config.get("name"), ingredients=self.exp_config.get("ingredients"), ) observers = self._observers or self.default_observers self._experiment.observers.extend(observers) self._experiment.add_config(self.exp_config) if not self.exp_config["run_config"]["capture_output"]: self._experiment.captured_out_filter = ( lambda *args, **kwargs: "Output capturing turned off.") return self._experiment @staticmethod def set_config_defaults(d: dict, values: dict): for k, v in values.items(): d.setdefault(k, v) def add_config_defaults(self, ec: dict): for name, conf in self.config_defaults.items(): if name in ec: self.set_config_defaults(ec[name], conf) else: ec.setdefault(name, conf) return ec def update_observers(self, o: List[RunObserver]): """ ONLY USE BEFORE CALLING `self.experiment` AS OBSERVERS CANNOT BE SET AFTER THE EXPERIMENT IS CREATED. :param o: List of sacred RunObservers to update Job observers. """ self._observers.extend(o) def override_observers(self, o: List[RunObserver]): """ ONLY USE BEFORE CALLING `self.experiment`. Replace defaults with new list of RunObserver objects. :param o: List of new sacred RunObservers """ self._observers = o @abstractmethod def _main(self, run, seed, fitable, fitable_config, loader_config): """ Private method containing the actual work completed by the job. Implemented is a default workflow for a basic keras/kerastuner type job. :param run: sacred.Run object. See sacred documentation for more details on utility. :param fitable: Optional tensorflow.keras.Model or kerastuner.Tuner object. Model-like which contains a fit method. :param fitable_config: Optional dict. Contains data which can be used to create a new fitable instance. :param loader_config: Optional dict. Contains data which can be used to create a new DataLoader instance. """ pass def run( self, fitable: Model = None, fitable_config: dict = None, loader_config: dict = None, ): """ Exposed method of the particular job. Runs whatever work is entailed by the job based on the content provided in `self.exp_config`. """ @self.experiment.main def main(_run, _seed): self.exp_config["run_config"]["root_dir"] = Path( _run.observers[0].dir).absolute() self._main(_run, _seed, fitable, fitable_config, loader_config) self.experiment.run() @abstractmethod def _load_data(self, config): """ Obtains a loader using ingredients.get_loader and self.exp_config['loader_config'] :return: Loader object and the data returned by that Loader's get_data method. """ pass @abstractmethod def _load_fitable(self, loader, fitable_config): """ Defines and compiles a fitable (keras.model or keras_tuner.tuner) which implements a 'fit' method. This method calls either get_builder, or get_hyper_factory, depending on which type of fitable is beind loaded. :return: Model or Tuner object. """ pass @abstractmethod def _fit(self, run, fitable, data, callbacks): """ :param run: sacred.Run object. See sacred documentation for details on utility. :param fitable: tensorflow.keras.Model object. :param data: tuple. train and validation data in the form (train, val), where train is the tuple (x_train, y_train). :param callbacks: Optional list. List of tensorflow.keras.Callback objects to pass to fitable.fit method. :return: tensorflow.keras.Model object. """ pass @abstractmethod def _test_fitable(self, run, fitable, test_data): """ :param fitable: tensorflow.keras.Model object. :param test_data: tuple. contains (x_test, y_test). :return: float. Scalar test_loss value. """ pass @abstractmethod def _save_fitable(self, run, fitable): """ :param run: sacred.Run object. see sacred documentation for more details on utility. :param fitable: tensorflow.keras.Model object. """ pass @abstractmethod def _new_model_path(self, i): pass @property def config_defaults(self): """ Defines default values for the various config dictionaries required for the Job. :return: dict. Experiment dictionary containing necessary config(s) for the Job. """ return { "ingredients": [data_ingredient, builder_ingredient], "run_config": copy(cd.run_config), "loader_config": copy(cd.loader_config), "builder_config": copy(cd.builder_config), "tb_config": copy(cd.tb_config), "lr_config": copy(cd.lr_config), }
from __future__ import print_function import logging import os 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 siamesefc_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']
def prepare(): global ex ex = Experiment('SeqIDLoc') ex.observers.append(MongoObserver.create(url='localhost:27017', db_name='SeqIDLoc'))
from torch.utils.data.distributed import DistributedSampler from tqdm import tqdm, trange from torch.nn import CrossEntropyLoss, MSELoss from scipy.stats import pearsonr, spearmanr from sklearn.metrics import matthews_corrcoef from pytorch_pretrained_bert.file_utils import PYTORCH_PRETRAINED_BERT_CACHE, WEIGHTS_NAME, CONFIG_NAME from pytorch_pretrained_bert.modeling import BertForSequenceClassification, BertConfig from pytorch_pretrained_bert.tokenization import BertTokenizer from pytorch_pretrained_bert.optimization import BertAdam, WarmupLinearSchedule logger = logging.getLogger(__name__) from sacred import Experiment bert_ex = Experiment('bert_multimodal_transformer') from sacred.observers import MongoObserver from global_configs import * url_database = conf_url_database mongo_database_name = conf_mongo_database_name bert_ex.observers.append( MongoObserver.create(url=url_database, db_name=mongo_database_name)) class InputExample(object): """A single training/test example for simple sequence classification.""" def __init__(self, guid, text_a, text_b=None, label=None): """Constructs a InputExample. Args: guid: Unique id for the example.
import numpy as np import torch from torch import optim from torch.optim.lr_scheduler import ReduceLROnPlateau from sklearn.metrics import mean_squared_error from transformer.Optim import ScheduledOptim from sacred import Experiment from bots import TransformerBot from dataset import read_dataset from io_utils import export_validation, export_test logging.basicConfig(level=logging.WARNING) ex = Experiment('Transformer') ex.add_source_file("preprocess.py") ex.add_source_file("prepare_seq_data.py") @ex.named_config def no_tf_2l(): batch_size = 128 model_details = { "odrop": 0.25, "edrop": 0.25, "hdrop": 0.1, "d_model": 128, "d_inner_hid": 256, "n_layers": 2, "n_head": 4,
sys.path.append(os.path.join(os.path.dirname(__file__), "..")) sys.path.append(os.path.dirname(__file__)) from get_data import get_data from models.active_model import ActiveLearningExperiment from models.strategy import random_query from models.utils import ObstructedY from sklearn.linear_model import SGDClassifier from sklearn.metrics import accuracy_score import copy import traceback from sacred import Experiment from misc.config import * from kaggle_ninja import * from utils import ExperimentResults, binary_metrics from experiment_runner import fit_AL_on_folds ex = Experiment("fit_active_learning") from sklearn.metrics import auc from sklearn.linear_model import SGDClassifier from models.balanced_models import * @ex.config def my_config(): experiment_detailed_name = "active_uncertanity_sampling" batch_size = 10 seed = -1 timeout = -1 id_folds = -1 warm_start_percentage = 0 force_reload = False # Required args. could comment out
"""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)
loadFilters, PreprocessorList, \ SummaryDescriptionPreprocessor, SABDEncoderPreprocessor, SABDBoWPreprocessor from example_generator.offline_pair_geneneration import NonNegativeRandomGenerator, RandomGenerator, KRandomGenerator, \ MiscNonZeroRandomGen, PreSelectedGenerator, MiscOfflineGenerator, PositivePreSelectedGenerator, \ ProductComponentRandomGen from metrics.metric import AverageLoss, MeanScoreDistance, ConfusionMatrix, PredictionCache, cmAccuracy, cmPrecision, \ cmRecall, Accuracy, AccuracyWrapper, PrecisionWrapper, RecallWrapper, LossWrapper from metrics.ranking import PreselectListRanking, DeshmukhRanking, GeneralScorer, SunRanking, generateRecommendationList from model.compare_aggregate import SABD from model.loss import TripletLoss from util.jsontools import JsonLogFormatter from util.siamese_util import processCategoricalParam from util.torch_util import thresholded_output_transform from util.training_loop_util import logMetrics, logRankingResult, logConfusionMatrix ex = Experiment("filter_model") logger = logging.getLogger() logger.setLevel(logging.INFO) logHandler = logging.StreamHandler() formatter = JsonLogFormatter() logHandler.setFormatter(formatter) logger.addHandler(logHandler) ex.logger = logger @ex.config def cfg(): # Set here all possible parameters; You have to change some parameters values. bug_database = None
def main(): import argparse parser = argparse.ArgumentParser(description='Two layer linear regression') parser.add_argument("image_feature_file_train", type=str, help="Image Feature file for the training set") parser.add_argument("text_feature_file_train", type=str, help="Text Feature file for the training set") parser.add_argument("image_feature_file_test", type=str, help="Image Feature file for the test set") parser.add_argument("text_feature_file_test", type=str, help="Text Feature file for the test set") parser.add_argument("word_vector_file", type=str, help="Text file containing the word vectors") # Optional Args parser.add_argument("--learning_rate", type=float, default=.001, help="Learning Rate") parser.add_argument("--epochs", type=int, default=200, help="Number of epochs to run for") parser.add_argument("--batch_size", type=int, default=128, help="Batch size to use for training") parser.add_argument("--network", type=str, default="200,200", help="Define a neural network as comma separated layer sizes") parser.add_argument("--model_type", type=str, default="mse", choices=['mse', 'negsampling', 'fast0tag'], help="Loss function to use for training") parser.add_argument("--in_memory", action='store_true', default="store_false", help="Load training image features into memory for faster training") parser.add_argument("--model_input_path", type=str, default=None, help="Model input path (to continue training)") parser.add_argument("--model_output_path", type=str, default=None, help="Model output path (to save training)") parser.add_argument("--max_pos", type=int, default=5, help="Max number of positive examples") parser.add_argument("--max_neg", type=int, default=10, help="Max number of negative examples") global args args = parser.parse_args() try: # Sacred Imports from sacred import Experiment from sacred.observers import MongoObserver from sacred.initialize import Scaffold # Monkey patch to avoid having to declare all our variables def noop(item): pass Scaffold._warn_about_suspicious_changes = noop ex = Experiment('Regress2sum') ex.observers.append(MongoObserver.create(url=os.environ['MONGO_DB_URI'], db_name='attalos_experiment')) ex.main(lambda: convert_args_and_call_model()) ex.run(config_updates=args.__dict__) except ImportError: # We don't have sacred, just run the script convert_args_and_call_model()
def test_missing_config_raises(): ex = Experiment('exp') ex.main(lambda a: None) with pytest.raises(MissingConfigError): ex.run()
path = "./conf/default.yaml" def fetch_parents(current_path, parents=[]): tmp_ex = Experiment('treeqn') tmp_ex.add_config(current_path) 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
python -m padertorch.contrib.examples.wavenet.train """ import os from pathlib import Path from lazy_dataset.database import JsonDatabase from padertorch.contrib.examples.audio_synthesis.wavenet.data import \ prepare_dataset from padertorch.contrib.examples.audio_synthesis.wavenet.model import WaveNet from padertorch.io import get_new_storage_dir from padertorch.train.optimizer import Adam from padertorch.train.trainer import Trainer from sacred import Experiment, commands from sacred.observers import FileStorageObserver ex = Experiment('wavenet') @ex.config def config(): database_json = (str((Path(os.environ['NT_DATABASE_JSONS_DIR']) / 'librispeech.json').expanduser()) if 'NT_DATABASE_JSONS_DIR' in os.environ else None) assert database_json is not None, ( 'database_json cannot be None.\n' 'Either start the training with "python -m padertorch.contrib.examples.' 'audio_synthesis.wavenet.train with database_json=</path/to/json>" ' 'or make sure there is an environment variable "NT_DATABASE_JSONS_DIR"' 'pointing to a directory with a "librispeech.json" in it (see README ' 'for the JSON format).') training_sets = ['train_clean_100', 'train_clean_360', 'train_other_500']
def run_for_class(clas, it=1): print('work on ' + clas) torch.cuda.empty_cache() data_clas = setup_data(clas) encoder_name = 'encoder_' + best_lm_exp_id drop_mult = 1 #learn = text_classifier_learner(data_clas, drop_mult=drop_mult, embed_prevent_first=0) #earn.load_encoder(encoder_name) all_lrs = [] #for _ in range(3): # all_lrs.append(news_utils.fastai.get_optimal_lr(learn, runs=1)) #optim_lr = max(all_lrs) ex = Experiment(db_name + '_' + clas) ex.observers.append(MongoObserver.create(db_name=db_name + '_' + clas)) @ex.config def my_config(): exp_id = datetime.datetime.now().strftime("%Y_%_m_%d_%H_%M_%S_%f") factor = 2.6 wd = 0.01 moms = (0.8, 0.7) full_epochs = 200 bs = 64 embed_prevent = 0 mod = 'simle_fit' input_p = 0.3 lr = 0.001 embed_p = 0.1 @ex.main def run_exp(exp_id, drop_mult, input_p, embed_p, lr, moms, wd, factor, full_epochs): lrs = [lr / (factor**(4 - x)) for x in range(4)] + [lr] learn = text_classifier_learner(data_clas, drop_mult=drop_mult, embed_prevent_first=0) learn.load_encoder(encoder_name) learn.metrics += [ KappaScore(), news_utils.fastai.F1Macro(), news_utils.fastai.F1Weighted(), news_utils.fastai.PrecisionMacro(), news_utils.fastai.RecallMacro() ] learn.callbacks += [ SaveModelCallback(learn, name=exp_id, monitor='kappa_score'), EarlyStoppingCallback(learn, monitor='kappa_score', patience=20, mode='max'), news_utils.fastai.SacredLogger(learn, ex), ] for i in range(1, 5): epochs = 1 if i in [1, 2, 3]: learn.freeze_to(-i) else: learn.unfreeze() epochs = full_epochs learn.fit(epochs, np.array(lrs)) for _ in range(it): ex.run(config_updates={"drop_mult": drop_mult})
def main(): import argparse parser = argparse.ArgumentParser(description='Two layer linear regression') parser.add_argument("image_feature_file_train", type=str, help="Image Feature file for the training set") parser.add_argument("text_feature_file_train", type=str, help="Text Feature file for the training set") parser.add_argument("image_feature_file_test", type=str, help="Image Feature file for the test set") parser.add_argument("text_feature_file_test", type=str, help="Text Feature file for the test set") parser.add_argument("word_vector_file", type=str, help="Text file containing the word vectors") # Optional Args parser.add_argument("--learning_rate", type=float, default=0.001, help="Learning Rate") parser.add_argument("--num_epochs", type=int, default=200, help="Number of epochs to run for") parser.add_argument("--batch_size", type=int, default=128, help="Batch size to use for training") parser.add_argument("--model_type", type=str, default="multihot", choices=['multihot', 'naivesum', 'wdv', 'negsampling', 'fast0tag'], help="Loss function to use for training") parser.add_argument("--in_memory", action='store_true', default="store_false", help="Load training image features into memory for faster training") parser.add_argument("--model_input_path", type=str, default=None, help="Model input path (to continue training)") parser.add_argument("--model_output_path", type=str, default=None, help="Model output path (to save training)") # new args parser.add_argument("--hidden_units", type=str, default="200", help="Define a neural network as comma separated layer sizes. If log-reg, then set to '0'.") parser.add_argument("--cross_eval", action="store_true", default=False, help="Use if test dataset is different from training dataset") parser.add_argument("--word_vector_type", type=str, choices=[t.name for t in WordVectorTypes], help="Format of word_vector_file") parser.add_argument("--epoch_verbosity", type=int, default=10, help="Epoch verbosity rate") parser.add_argument("--verbose_eval", action="store_true", default=False, help="Use to run evaluation against test data every epoch_verbosity") parser.add_argument("--optim_words", action="store_true", default=False, help="If using negsampling model_type, use to jointly optimize words") parser.add_argument("--ignore_posbatch", action="store_true", default=False, help="Sample, ignoring from positive batch instead of examples. This should be taken out in future iters.") parser.add_argument("--joint_factor", type=float, default=1.0, help="Multiplier for learning rate in updating joint optimization") parser.add_argument("--use_batch_norm", action="store_true", default=False, help="Do we want to use batch normalization? Default is False") parser.add_argument("--opt_type", type=str, default="adam", help="What type of optimizer would you like? Choices are (adam,sgd)") parser.add_argument("--weight_decay", type=float, default=0.0, help="Weight decay to manually decay every 10 epochs. Default=0 for no decay.") parser.add_argument("--scale_words", type=float, default=1.0, help="Scale the word vectors. If set to zero, scale by L2-norm. Otherwise, wordvec=scale x wordvec") parser.add_argument("--scale_images", type=float, default=1.0, help="Scale the word vectors. If set to zero, scale by L2-norm. Otherwise, imvec=scale x imvec. ") parser.add_argument("--fast_sample", action="store_true", default=False, help="Fast sample based on distribution, only use in large dictionaries") args = parser.parse_args() try: # Sacred Imports from sacred import Experiment from sacred.observers import MongoObserver from sacred.initialize import Scaffold # Monkey patch to avoid having to declare all our variables def noop(item): pass Scaffold._warn_about_suspicious_changes = noop ex = Experiment('Attalos') ex.observers.append(MongoObserver.create(url=os.environ['MONGO_DB_URI'], db_name='attalos_experiment')) ex.main(lambda: convert_args_and_call_model(args)) ex.run(config_updates=args.__dict__) except ImportError: # We don't have sacred, just run the script logger.warn('Not using Sacred. Your results will not be saved') convert_args_and_call_model(args)
FlattenSingletonVecEnv, MergeAgentVecEnv, make_dummy_vec_multi_env, make_subproc_vec_multi_env, ) from aprl.envs.observation_masking import make_mask_agent_wrappers import aprl.envs.wrappers from aprl.policies.loader import load_backward_compatible_model, load_policy, mpi_unavailable_error from aprl.policies.wrappers import MultiPolicyWrapper from aprl.training.embedded_agents import CurryVecEnv, TransparentCurryVecEnv from aprl.training.logger import setup_logger from aprl.training.lookback import DebugVenv, LookbackRewardVecWrapper, OldMujocoResettableWrapper from aprl.training.scheduling import ConstantAnnealer, Scheduler from aprl.training.shaping_wrappers import apply_embedded_agent_wrapper, apply_reward_wrapper train_ex = Experiment("train") pylog = logging.getLogger("aprl.train") def _save(model, root_dir, save_callbacks): os.makedirs(root_dir, exist_ok=True) model_path = osp.join(root_dir, "model.pkl") model.save(model_path) for f in save_callbacks: f(root_dir) @train_ex.capture def old_ppo2( _seed, env,
This allows me to configure experiment by JSON file. Author: Yuhuang Hu Email : [email protected] """ from sacred import Experiment import os import cPickle as pickle import numpy as np import cv2 from spikefuel import tools, gui, helpers exp = Experiment("DVS Recording - Lipreading") exp.add_config({ "lipreading_dir": "", "lipreading_stats_path": "", "recording_save_path": "", "viewer_id": 1, "screen_height": 0, "screen_width": 0, "work_win_scale": 0.9, "bg_color": [255, 0, 0], "fps": 0 }) @exp.automain
from pathlib import Path from pprint import pprint from sacred import Experiment from sacred.observers import FileStorageObserver from sacred.utils import InvalidConfigError, MissingConfigError from tqdm import tqdm import padertorch as pt from padertorch.contrib.neumann.evaluation import compute_means from .train import prepare_dataset # Unfortunately need to disable this since conda scipy needs update warnings.simplefilter(action='ignore', category=FutureWarning) experiment_name = 'tasnet' ex = Experiment(experiment_name) JSON_BASE = os.environ.get('NT_DATABASE_JSONS_DIR', None) @ex.config def config(): debug = False dump_audio = False # Model config model_path = '' assert len(model_path) > 0, 'Set the model path on the command line.' checkpoint_name = 'ckpt_best_loss.pth' experiment_dir = None if experiment_dir is None:
from os.path import basename from pathlib import Path import numpy as np from sacred import Experiment 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 import pandas as pd from joblib import Parallel, delayed ex = Experiment("Run LDT") 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():
from keras.models import Sequential from keras.layers import Dense from keras.layers import Dropout from keras.layers.embeddings import Embedding from keras.layers.wrappers import TimeDistributed from keras.layers.pooling import GlobalAveragePooling1D from keras.callbacks import Callback, ModelCheckpoint from keras.optimizers import Adam from sacred import Experiment from sacred.observers import MongoObserver from sacred.utils import apply_backspaces_and_linefeeds from heise_online_dataset import heise_online_ingredient, load_data, get_word_count from train_lstm import c_score ex = Experiment('Dense_Average_Classification', ingredients=[heise_online_ingredient]) ex.observers.append(MongoObserver.create()) ex.captured_out_filter = apply_backspaces_and_linefeeds @ex.capture def log_performance(_run, logs): _run.add_artifact("weights.hdf5") _run.log_scalar("loss", float(logs.get('loss'))) _run.log_scalar("binary_accuracy", float(logs.get('binary_accuracy'))) _run.log_scalar("c_score", float(logs.get('c_score'))) _run.log_scalar("val_loss", float(logs.get('val_loss'))) _run.log_scalar("val_binary_accuracy", float(logs.get('val_binary_accuracy'))) _run.log_scalar("val_c_score", float(logs.get('val_c_score'))) _run.result = float(logs.get('val_c_score'))
import csv import sys import pandas as pd import numpy as np from sacred import Experiment from sacred.observers import MongoObserver from agents.agent import DDPG_Agent from agents.agent_simple import DDPG as DDPG_Agent_Simple from agents.policy_search import PolicySearch_Agent from agents.random_binary_agent import Random_Binary_Agent from collections import deque from tasks import TakeOff_Task import visuals as vs ex = Experiment() ex.observers.append(MongoObserver.create(db_name='sacred')) @ex.config def config(): # Noise process exploration_mu = 0. exploration_theta = 0.7 exploration_sigma = 0.2 # Replay memory buffer_size = 100000 batch_size = 256 # Algorithm parameters
import numpy as np import tensorflow as tf import random import time import model import sample import encoder from tqdm import tqdm from sacred import Experiment from sacred.observers import MongoObserver CHECKPOINT_DIR = 'checkpoint' SAMPLE_DIR = 'samples' ex = Experiment('gpt-2-finetune-tf') ex.observers.append( MongoObserver.create(url='localhost:27017', db_name='experiments')) def maketree(path): try: os.makedirs(path) except: pass def load_dataset(enc, path): paths = [] if os.path.isfile(path):
from sacred.observers import MongoObserver from scipy.special import expit from sacred import Experiment import tensorflow as tf import collections import tflearn import extend_recurrent import numpy as np import json import sys import lrp import os import heatmap import pickle ex = Experiment('IMDBMovieReview-LSTM') @ex.config def config(): db = "" if db == "mongo": print("Using mongodb for logging") ex.observers.append(MongoObserver.create()) elif db == "file": print("Using local file storage for logging") ex.observers.append(FileStorageObserver.create('SacredRunLog')) net_arch_layers = ['lstm', 'fc', 'output'] tensorboard_verbose = 3
return tf.Variable(initial) def bias_variable(shape): initial = tf.constant(0.1, shape=shape) return tf.Variable(initial) def conv2d(x, W): return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME') #Stride of 1 def max_pool_2x2(x): return tf.nn.max_pool(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME') #2x2 max pooling, stride = 2 from sacred import Experiment #from sacred.observers import MongoObserver ex = Experiment('DSB GATE EXPERIMENT') #ex.observers.append(MongoObserver.create()) @ex.config def config(): RUN_NAME = 'CRPS-MODEL-3.0' DATA_DIR = 'netdata' ITERS = 100000 START_ITER = 0 MODEL_LOAD_PATH = None PIC_WIDTH = 32 ### Architectural Hyperparameters DEPTH_1 = 20 # The output depth of the first convolutional layer DEPTH_2 = 40 # The output depth of the second convolutional layer DEPTH_3 = 80 # The output depth of the second convolutional layer DEPTH_4 = 150 # The output depth of the second convolutional layer
from os.path import basename from pathlib import Path import numpy as np import pandas as pd from joblib import Parallel, delayed, wrap_non_picklable_objects from sacred import Experiment from sacred.observers import FileStorageObserver, SlackObserver from src.utils import gen_B, gen_sbm, save_obj from src.models import select_sbm ex = Experiment("SBM model selection") current_file = basename(__file__)[:-3] pickle_path = Path("./maggot_models/simulations/outs/") sacred_file_path = Path(f"./maggot_models/simulations/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""" n_sims = 2 # noqa: F841
from mot_neural_solver.utils.misc import make_deterministic, get_run_str_and_save_dir, ModelCheckpoint from mot_neural_solver.path_cfg import OUTPUT_PATH import os.path as osp from mot_neural_solver.pl_module.pl_module import MOTNeuralSolver from pytorch_lightning import Trainer from pytorch_lightning.loggers import TensorBoardLogger #from pytorch_lightning.callbacks.model_checkpoint import ModelCheckpoint from sacred import SETTINGS SETTINGS.CONFIG.READ_ONLY_CONFIG = False ex = Experiment() ex.add_config('configs/tracking_cfg.yaml') ex.add_config({ 'run_id': 'train_w_default_config', 'add_date': True, 'cross_val_split': None }) @ex.config def cfg(cross_val_split, eval_params, dataset_params, graph_model_params, data_splits): # Training requires the use of precomputed embeddings assert dataset_params[ 'precomputed_embeddings'], "Training without precomp. embeddings is not supp"
import sys, os import torch from torchvision import datasets, transforms import torchsm from sacred import Experiment from sacred.observers import MongoObserver device = torch.device("cuda") if torch.cuda.is_available() else torch.device( "cpu") ex = Experiment('icpram2019') from utils import MovingAverage class Net(torchsm.BaseLayer): def __init__(self, input, output, **kwargs): torchsm.BaseLayer.__init__(self, input, output) self.hidden_layers = kwargs[ "hidden_layers"] if "hidden_layers" in kwargs else 1 self.hidden_dim = kwargs["hidden_dim"] if "hidden_dim" in kwargs else 10 self.stig_dim = kwargs["stig_dim"] self.n_inputs = input self.n_outputs = output self.stigmergic_memory = torchsm.RecurrentStigmergicMemoryLayer( self.n_inputs, self.stig_dim, hidden_dim=kwargs["stig_hidden_dim"],
"""Experiment Configuration""" import os import re import glob import itertools import sacred from sacred import Experiment from sacred.observers import FileStorageObserver from sacred.utils import apply_backspaces_and_linefeeds sacred.SETTINGS['CONFIG']['READ_ONLY_CONFIG'] = False sacred.SETTINGS.CAPTURE_MODE = 'no' ex = Experiment('PANet') ex.captured_out_filter = apply_backspaces_and_linefeeds source_folders = [ '.', './dataloaders', './models', './util', './dataloaders_medical' ] sources_to_save = list( itertools.chain.from_iterable( [glob.glob(f'{folder}/*.py') for folder in source_folders])) for source_file in sources_to_save: ex.add_source_file(source_file) # "Organs" : ["background", # "spleen", # "right kidney", # "left kidney", # "gallbladder",
import numpy as np import tensorflow as tf from sacred import Experiment from sacred.observers import FileStorageObserver from tensorflow.python.keras.backend import set_session from tensorflow.python.keras.callbacks import ReduceLROnPlateau, TensorBoard from tensorflow.python.keras.datasets import cifar10 from tensorflow.python.keras.preprocessing.image import ImageDataGenerator from resnet import make_resnet from utils import tf_disable_warnings, tf_disable_deprecation_warnings tf_disable_warnings() tf_disable_deprecation_warnings() ex = Experiment() observer = FileStorageObserver.create('runs') ex.observers.append(observer) ex.add_config({ 'net': 'resnet20' }) @ex.automain def main(net): config = tf.ConfigProto() config.gpu_options.allow_growth = True sess = tf.Session(config=config) set_session(sess)
self.register_buffer( 'mean', torch.FloatTensor(mean).view(1, len(mean), 1, 1) ) self.register_buffer( 'std', torch.FloatTensor(std).view(1, len(std), 1, 1) ) def forward(self, x): x = x.float() # implicitly convert to float x = x.sub(self.mean).div(self.std) return self.module(x) ROOT = pt.abspath(pt.dirname(__file__)) exp = Experiment('Experiment: Jigsaw encoder on Imagenet') # Add a FileObserver if one hasn't been attached already EXP_FOLDER = '../exp/' log_location = pt.join(EXP_FOLDER, pt.basename(sys.argv[0])[:-3]) if len(exp.observers) == 0: print('Adding a file observer in %s' % log_location) exp.observers.append(file_storage.FileStorageObserver.create(log_location)) def get_checkpoint(exp, exp_variant): # currently three experiments exist, vanilla_AE, AE_with_tiles, Jigsaw (two variants) # have namedtuple for experiment and checkpoints directory if exp is None: raise RuntimeError('Experiment can not be None!')
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3' import tensorflow as tf tf.enable_eager_execution() import numpy as np from sacred import Experiment from sacred.utils import apply_backspaces_and_linefeeds from sacred.observers import MongoObserver import common from convnet_data import load_train_val_datasets, load_test_dataset from models import get_model_wrapper EXPERIMENT = Experiment() EXPERIMENT.captured_out_filter = apply_backspaces_and_linefeeds EXPERIMENT.observers.append(MongoObserver.create()) @EXPERIMENT.config def config(): seed = 7198021 train_examples_per_class = 112640 val_examples_per_class = 768 batch_size = 1024 train_augmentation = True test_augmentation = 10 model = 'convnet' image_size = 128 base_filters = 64
from __future__ import absolute_import, division, print_function from multiprocessing import Process from copy import deepcopy import time import mat4py as m4p from utils import * from sacred import Experiment from rhn_stocks import Model ex = Experiment('rhn_prediction_stocks') logging = tf.logging import h5py import stocks_black_box as bb class Config(): # architecture weight_decay = 1e-07 max_grad_norm = 0.8 drop_i = 0.05 drop_e = 0.5 drop_h = 0.3 drop_o = 0.75 hidden_size = 200 mask = [0.6, 0.95, 0.05] # should be a list
from utils.typing_alias import * # Train helpers from utils.train_helper import ( get_optimisers, reduce_loss_dict, load_models, save_weights, ExpLoss_with_dict, AvgLoss_with_dict, pprint_args, ) from utils.tupperware import tupperware # Experiment, add any observers by command line ex = Experiment("Train") ex = initialise(ex) # local rank 0: for logging, saving ckpts if "LOCAL_RANK" in os.environ: is_local_rank_0 = int(os.environ["LOCAL_RANK"]) == 0 else: is_local_rank_0 = True if not is_local_rank_0: sys.stdout = open(os.devnull, "w") # To prevent "RuntimeError: received 0 items of ancdata" torch.multiprocessing.set_sharing_strategy("file_system") torch.autograd.set_detect_anomaly(True)
from zeiss_umbrella.config import FILE_OBSERVER_BASE_PATH, FILE_OBSERVER_RESOURCE_PATH, FILE_OBSERVER_SOURCE_PATH import sacred from sacred import Experiment from sacred.observers.file_storage import FileStorageObserver import torch.nn as nn from torch.optim import lr_scheduler import numpy as np import torchvision from zeiss_umbrella.fundus.setting_parser import get_baseline, get_optimizer, get_loss from zeiss_umbrella.fundus.train import * from zeiss_umbrella.fundus import data import pandas as pd import os ex = Experiment('incremental balancing') template = "" ex.observers.append( FileStorageObserver(FILE_OBSERVER_BASE_PATH, FILE_OBSERVER_RESOURCE_PATH, FILE_OBSERVER_SOURCE_PATH, template)) # uncomment if you use progress bars # from sacred.utils import apply_backspaces_and_linefeeds # ex.captured_out_filter = apply_backspaces_and_linefeeds # for more info see https://sacred.readthedocs.io/en/latest/collected_information.html#live-information @ex.config def my_config(): """ preprocessing: dictionary, 'type':'centerCrop','default' , 'cropSize':list, 'size':tuple adv_training_config: 'type':'baseline', 'fgsm', 'fgsm_k_image', 'pgd', 'boundary_attack'
from config import PHONETIC_EMB_SIZE from config import SEMEVAL_HUMOR_TRAIN_DIR from config import SEMEVAL_HUMOR_TRIAL_DIR from config import TWEET_SIZE from tf_tools import GPU_OPTIONS from tf_tools import HUMOR_DROPOUT from tf_tools import create_dense_layer from tf_tools import create_tensorboard_visualization from tf_tools import predict_on_hashtag from tf_tools import build_humor_model from tools import extract_tweet_pair_from_hashtag_datas from tools import get_hashtag_file_names from tools import load_hashtag_data from tools import load_hashtag_data_and_vocabulary ex = Experiment('humor_model') ex.observers.append(MongoObserver.create(db_name='humor_runs')) EMBEDDING_HUMOR_MODEL_LEARNING_RATE = .00001 N_TRAIN_EPOCHS = 2 @ex.config def my_config(): learning_rate = .000005 # np.random.uniform(.00005, .0000005) num_epochs = 5 # int(np.random.uniform(1.0, 4.0)) dropout = 1 # np.random.uniform(.5, 1.0) hidden_dim_size = 800 # int(np.random.uniform(200, 3200)) use_emb_model = True use_char_model = True model_save_dir = EMB_CHAR_HUMOR_MODEL_DIR
import tensorflow as tf import numpy as np import os import librosa import Datasets import Utils import Models.UnetSpectrogramSeparator import Models.UnetAudioSeparator import Test import Evaluate import functools from tensorflow.contrib.signal.python.ops import window_ops ex = Experiment('Waveunet Training', ingredients=[config_ingredient]) @ex.config # Executed for training, sets the seed value to the Sacred config so that Sacred fixes the Python and Numpy RNG to the same state everytime. def set_seed(): seed = 1337 @config_ingredient.capture def train(model_config, experiment_id, load_model=None): # Determine input and output shapes disc_input_shape = [ model_config["batch_size"], model_config["num_frames"], 0 ] # Shape of input if model_config["network"] == "unet":
#!/usr/bin/env python # coding=utf-8 """ An example showcasing the logging system of Sacred.""" from __future__ import division, print_function, unicode_literals import logging from sacred import Experiment ex = Experiment('log_example') # set up a custom logger logger = logging.getLogger('mylogger') logger.handlers = [] ch = logging.StreamHandler() formatter = logging.Formatter('[%(levelname).1s] %(name)s >> "%(message)s"') ch.setFormatter(formatter) logger.addHandler(ch) logger.setLevel('INFO') # attach it to the experiment ex.logger = logger @ex.config def cfg(): number = 2 got_gizmo = False @ex.capture def transmogrify(got_gizmo, number, _log): if got_gizmo:
import multidimensional import multidimensional.common import multidimensional.mds import multidimensional.point_filters import multidimensional.radius_updates import multidimensional.datagen.shapes as datagen import multidimensional.smacof import config EXPERIMENT_NAME = 'toroid_helix_noise_8e-2' KEEP_HISTORY = True ex = Experiment(EXPERIMENT_NAME) ex.observers.append(MongoObserver.create( url=config.SACRED_MONGO_URL, db_name=config.SACRED_DB # db_name='test' )) RESULT_IMAGE = EXPERIMENT_NAME + '.png' @ex.config def cfg(): data_type = 'toroid-helix' # { # 'sphere': Sphere, # 'cut-sphere': CutSphere,
This allows me to configure experiment by JSON file. Author: Yuhuang Hu Email : [email protected] """ from sacred import Experiment import os import cPickle as pickle import numpy as np import cv2 from spikefuel import tools, gui, helpers exp = Experiment("DVS Recording - Caltech-256") exp.add_config({ "caltech256_dir": "", "caltech256_stats_path": "", "recording_save_path": "", "viewer_id": 1, "screen_height": 0, "screen_width": 0, "saccade_size": 0, "work_win_scale": 0.9, "bg_color": [255, 0, 0], "fps": 0, "start_class": 0 })
import tensorflow as tf from tensorflow.python import debug as tf_debug from sacred import Experiment from sacred.observers import FileStorageObserver import os import datetime import audio_models import dataset from train import train from test import test ex = Experiment('UNet_Speech_Separation', interactive=True) ex.observers.append(FileStorageObserver.create('my_runs')) @ex.config def cfg(): model_config = { 'model_variant': 'unet', # The type of model to use, from ['unet', capsunet', basic_capsnet', 'basic_convnet'] 'data_type': 'mag_phase', # From [' mag', 'mag_phase', 'real_imag', 'mag_real_imag'] 'phase_weight': 0.005, # When using a model which learns to estimate phase, defines how much # weight phase loss should be given against magnitude loss 'initialisation_test': False, # Whether or not to calculate test metrics before training 'loading': False, # Whether to load an existing checkpoint 'checkpoint_to_load': "169/169-6", # Checkpoint format: run/run-step
from torch.utils.data import DataLoader 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)
from sacred import Experiment, SETTINGS from sacred.observers import FileStorageObserver from sacred.observers import MongoObserver from sacred.utils import apply_backspaces_and_linefeeds import sys import torch as th from utils.logging import get_logger import yaml import pymongo from run import run SETTINGS['CAPTURE_MODE'] = "fd" # set to "no" if you want to see stdout/stderr in console logger = get_logger() ex = Experiment("pymarl") ex.logger = logger ex.captured_out_filter = apply_backspaces_and_linefeeds # results_path = os.path.join(dirname(dirname(abspath(__file__))), "results") # Append results to data instead results_path = os.path.join("/data", str(os.environ.get('STORAGE_HOSTNAME')), "conlu", "results") mongo_client = None def setup_mongodb(): # The central mongodb for our deepmarl experiments # You need to set up local port forwarding to ensure this local port maps to the server # if conf_str == "": # db_host = "localhost"
Hello world! INFO - hello_config_dict - Completed after 0:00:00 The message can also easily be changed using the ``with`` command-line argument:: $ ./02_hello_config_dict.py with message='Ciao world!' INFO - hello_config_dict - Running command 'main' INFO - hello_config_dict - Started Ciao world! INFO - hello_config_dict - Completed after 0:00:00 """ from __future__ import division, print_function, unicode_literals from sacred import Experiment ex = Experiment('hello_config_dict') # We add message to the configuration of the experiment here ex.add_config({ "message": "Hello world!" }) # Equivalent: # ex.add_config( # message="Hello world!" # ) # notice how we can access the message here by taking it as an argument @ex.automain def main(message): print(message)
fh.setLevel(logging.DEBUG) # write to console ch = logging.StreamHandler() ch.setLevel(logging.DEBUG) # Handler format formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s -\n\t%(message)s') fh.setFormatter(formatter) ch.setFormatter(formatter) logger.addHandler(fh) logger.addHandler(ch) ex = Experiment('Biagioni') ex.logger = logger ex.observers.append(MongoObserver.create(url='10.60.43.110:27017', db_name='Biagioni')) @ex.config def cfg(): #data_file ="../../Data/Shanghai/minsh_1000_biagioni" data_file = "../Data/Chicago/all_trips" @ex.automain def main(data_file, side, k, percent, width, alpha, _log, _run): _log.info('data_file: %s' % (data_file)) _run.info['time'] = {}