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",