def __init__(self, env, prefix="$TMPDIR", *prefixes, file="monitor.metrics.pkl", allow_early_resets=False): """ Monitor Wrapper This wrapper uses ml-logger to cache environment metrics. :param env: gym environment :param prefixes: cache prefix, used to direct the stored metrics to a specific cache namescope. :param allow_early_resets: default False. raise exception if manual reset is detected. """ Wrapper.__init__(self, env=env) from ml_logger import ML_Logger # dump into the temp directory self.logger = ML_Logger(prefix, *prefixes) self.file = file self.allow_early_resets = allow_early_resets self.now = self.t0 = time.time() self.rewards = [] self.total_steps = 0 # Useful for metalearning where we're modifying the environment externally # But want our logs to know about these modifications self.additional_key_values = { } # extra info that gets injected into each log entry
def __init__(self, filename=None, overwrite=True, root=None, prefix=None, logger=None): """ Called by the module __init__.py to create a global document object. :param filename: the filename for the output markdown file. :param overwrite: Whether to append to the existing document, or to clear and start afresh :param logger: allow passing in an existing logger to log to a remote server instead. this is similar to a figure object as in matplotlib. """ super().__init__( window={ to_snake(k): v for k, v in globals().items() if is_subclass(v, components.Component) }) self.window['video'] = video self.window.logger = logger = logger or ML_Logger(root=root, prefix=prefix) # if logger.root_dir: # cprint(f"cmx root directory: {logger.root_dir}", color="green") self.config(filename=filename, overwrite=overwrite)
def collect_metrics(prefix="$TMPDIR", *prefixes, glob="**/monitor.metrics.pkl"): """ returns the metric: ["ep_rew", "ep_len", "env_steps", "dt"] :param prefix: :param prefixes: :param glob: :return: """ from ml_logger import ML_Logger logger = ML_Logger(prefix, *prefixes) df = logger.read_metrics("ep_rew", "ep_len", "env_steps", "dt", path=glob) if df is None: return None logger.remove(glob) return [v.mean() for k, v in df.iteritems()]
doc @ """ # Loading and Plotting A Single Learning Curve Here is a simple example, showing how to load a single learning curve with 95% confidence range using `logger.read_metrics` call. The plotting code is minimal to keep it simple. """ with doc @ """Import the CommonMark X module""": from cmx import doc from ml_logger import ML_Logger with doc @ """Initialize the loader""": import os loader = ML_Logger(root=os.getcwd(), prefix="data/walker-walk/curl") with doc @ """Check all the files""": files = loader.glob(query="**/metrics.pkl", wd=".", recursive=True) doc.print(files) with doc @ """Step 1: load the data""": avg, top, bottom, step = loader.read_metrics( "train/episode_reward/mean@mean", "train/episode_reward/mean@84%", "train/episode_reward/mean@16%", x_key="step@mean", path="**/metrics.pkl", bin_size=40) with doc @ "Step 2: Plot", doc.table().figure_row() as r:
from cmx import doc from ml_logger import ML_Logger, memoize from tqdm import tqdm if __name__ == "__main__": envs = [ 'dmc:Acrobot-swingup-v1', 'dmc:Quadruped-run-v1', 'dmc:Quadruped-walk-v1', 'dmc:Humanoid-run-v1', 'dmc:Finger-turn_hard-v1', 'dmc:Walker-run-v1', 'dmc:Cheetah-run-v1', 'dmc:Hopper-hop-v1' ] b_vals = [20, 10, 5, 5, 20, 5, 10, 15] colors = ['#23aaff', '#ff7575', '#66c56c', '#f4b247'] with doc @ """# MUJOCO Comparisons""": loader = ML_Logger( prefix="model-free/model-free/rff_post_iclr/dmc/drqv2/4_layer") print(loader) # loader.glob = memoize(loader.glob) # loader.load_pkl = memoize(loader.load_pkl) with doc: def plot_line(path, color, label): print(path) mean, low, high, step, = loader.read_metrics( "eval/avg_true_q/mean@mean", "eval/avg_true_q/mean@16%", "eval/avg_true_q/mean@84%", x_key="frames@min", path=path)
# Facet and Grouping Here we show the learning curve from multiple methods, on the same domain. We typically arrange the data with a folder structure `f"{domain}/{method}/{seed}"`. """ with doc @ """Initialize the loader""": import os from cmx import doc import matplotlib.pyplot as plt from matplotlib import ticker from ml_logger import ML_Logger loader = ML_Logger(root=os.getcwd(), prefix="data/walker-walk") with doc @ """Check all the files""": files = loader.glob(query="**/metrics.pkl", wd=".", recursive=True) doc.print(files) with doc @ """Plotting A Single Time Series""": def group(xKey="step", yKey="train/episode_reward/mean", color=None, bins=50, label=None, dropna=False): avg, top, bottom, step = loader.read_metrics(f"{yKey}@mean", f"{yKey}@84%",
class Monitor(Wrapper): def __init__(self, env, prefix="$TMPDIR", *prefixes, file="monitor.metrics.pkl", allow_early_resets=False): """ Monitor Wrapper This wrapper uses ml-logger to cache environment metrics. :param env: gym environment :param prefixes: cache prefix, used to direct the stored metrics to a specific cache namescope. :param allow_early_resets: default False. raise exception if manual reset is detected. """ Wrapper.__init__(self, env=env) from ml_logger import ML_Logger # dump into the temp directory self.logger = ML_Logger(prefix, *prefixes) self.file = file self.allow_early_resets = allow_early_resets self.now = self.t0 = time.time() self.rewards = [] self.total_steps = 0 # Useful for metalearning where we're modifying the environment externally # But want our logs to know about these modifications self.additional_key_values = { } # extra info that gets injected into each log entry def __getstate__(self): return self.__dict__.copy() def __setstate__(self, d): self.__dict__ = d def reset(self): if not self.allow_early_resets and self.rewards: raise RuntimeError( "Tried to reset an environment before done. If " "you want to allow early resets, wrap your env " "with Monitor(env, path, allow_early_resets=True)") return self.env.reset() def step(self, action): ob, rew, done, info = self.env.step(action) self.rewards.append(rew) if done: self.rewards = [] ep_rew = sum(self.rewards) ep_len = len(self.rewards) now = time.time() dt, self.now = now - self.now, now ep_info = { "r": ep_rew, "l": ep_len, "t": round(self.now - self.t0, 6) } ep_info.update(self.additional_key_values) ep_info["total_steps"] = self.total_steps self.logger.log(ep_rew=ep_rew, ep_len=ep_len, env_steps=self.total_steps, dt=round(dt, 6), flush=True, file=self.file, silent=True) info['episode'] = ep_info self.total_steps += 1 return ob, rew, done, info
from cmx import doc from ml_logger import ML_Logger doc @ """ # 0. Download Data from Server You can directly read from the server, which is the standard use-flow. We download the data here so that you can process the data locally. """ PREFIX = "geyang/dmc_gen/01_baselines/train" with doc @ """Initialize the loader""": loader = ML_Logger("http://<some-dash-server>:8080", prefix=PREFIX) with doc @ """Check all the files""": files = loader.glob(query="**/metrics.pkl", wd=".", recursive=True) for path in files: loader.download_file(path, to="data/", relative=True) doc.print(*files, sep="\n") doc.flush()
import matplotlib.pyplot as plt from cmx import doc from ml_logger import ML_Logger, BinOptions doc @ """ # Loading and Plotting Learning Curves """ PREFIX = "geyang/dmc_gen/01_baselines/train/walker-walk/curl" with doc @ """Initialize the loader""": loader = ML_Logger("http://improbable005.csail.mit.edu:8080", prefix=PREFIX) with doc @ """Check all the files""": files = loader.glob(query="**/metrics.pkl", wd=".", recursive=True) doc.print(files) with doc @ """Step 1: load the data""": step, avg, top, bottom = loader.read_metrics( "step", "train/episode_reward/mean", "train/episode_reward/mean@95%", "train/episode_reward/mean@5%", path="**/metrics.pkl") with doc @ "Step 2: Plot", doc.table().figure_row() as r: title = "CURL" plt.figure(figsize=(3, 2))
import os import matplotlib.pyplot as plt from cmx import doc from matplotlib import ticker from ml_logger import ML_Logger doc @ """ # Results Over All Domains """ with doc @ """Initialize the loader""": loader = ML_Logger(root=os.getcwd(), prefix="data") with doc @ """Check all the files""": files = loader.glob(query="**/metrics.pkl", wd=".", recursive=True) with doc @ """Plotting A Single Time Series""": def group(xKey="step", yKey="train/episode_reward/mean", color=None, bins=50, label=None, dropna=False): avg, top, bottom, step = loader.read_metrics(f"{yKey}@mean", f"{yKey}@84%", f"{yKey}@16%", x_key=f"{xKey}@mean", path="**/metrics.pkl",