diff --git a/.coveragerc b/.coveragerc new file mode 100644 index 00000000..db49283d --- /dev/null +++ b/.coveragerc @@ -0,0 +1,32 @@ +[run] +branch = True +omit = + tests/* + docs/* + docker/* + test_* + *_test* + +[report] +# Regexes for lines to exclude from consideration +exclude_lines = + # Have to re-enable the standard pragma + pragma: no cover + + # Don't complain about missing debug-only code: + def __repr__ + if self\.debug + + # Don't complain if tests don't hit defensive assertion code: + raise AssertionError + raise NotImplementedError + raise FileNotFoundError + + # Don't complain if non-runnable code isn't run: + if 0: + if __name__ == .__main__.: + + # Don't complain about abstract methods, they aren't run: + @(abc\.)?abstractmethod + +ignore_errors = True diff --git a/.gitignore b/.gitignore index 82862824..e9903022 100644 --- a/.gitignore +++ b/.gitignore @@ -120,3 +120,13 @@ venv.bak/ # mypy .mypy_cache/ + +# VSCode +._* + +# Directories +results_dir +bsuite_results* +.vscode +results + diff --git a/.gitmodules b/.gitmodules index e69de29b..26cd98f9 100644 --- a/.gitmodules +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "exarl/envs/env_vault/Hadrec_dir"] + path = exarl/envs/env_vault/Hadrec_dir + url = git@github.com:exalearn/powerGridEnv.git diff --git a/.travis.yml b/.travis.yml index cbc81c8e..c416785f 100644 --- a/.travis.yml +++ b/.travis.yml @@ -20,6 +20,10 @@ before_install: script: - pip install -r setup/test-requirements.txt - flake8 . - - pytest + - pytest --cov-config=.coveragerc --cov=./ --cov-report=xml --cov-report=term - export PYTHONPATH=`pwd`:$PYTHONPATH - python exarl/driver + - curl -Os https://uploader.codecov.io/latest/linux/codecov + - chmod +x codecov + - CODECOV_TOKEN=58f6254a-1517-4f4b-9e87-1348390deaf7 + - ./codecov -t ${CODECOV_TOKEN} diff --git a/README.md b/README.md index 86b965e2..70b2c50a 100644 --- a/README.md +++ b/README.md @@ -7,6 +7,7 @@ A scalable software framework for reinforcement learning environments and agents [![License](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause) [![Build Status](https://travis-ci.com/exalearn/EXARL.svg?token=nVtzNrBfRo4qpVpEQP21&branch=develop)](https://travis-ci.com/exalearn/EXARL) [![Documentation Status](https://readthedocs.org/projects/exarl/badge/?version=latest)](https://exarl.readthedocs.io/en/latest/?badge=latest) +[![codecov](https://codecov.io/gh/exalearn/EXARL/branch/develop/graph/badge.svg?token=VMHFSSZ7MJ)](https://codecov.io/gh/exalearn/EXARL) [Complete documentation](https://exarl.readthedocs.io/en/latest/index.html) is available. diff --git a/bsuite/SingleRun.pm b/bsuite/SingleRun.pm new file mode 100644 index 00000000..9ec87387 --- /dev/null +++ b/bsuite/SingleRun.pm @@ -0,0 +1,197 @@ +#!/usr/bin/perl +package SingleRun; +use strict; +use Time::HiRes qw(usleep); + +my $user = "userName"; +my $partition = "partitionName"; +my $overSubFactor = 2; +my $defaultThreshold = 1; +my $threshold = $defaultThreshold; + +sub setPartition +{ + $partition = $_[0]; +} + +sub setUser +{ + $user = $_[0]; +} + +sub runCommand +{ + system($_[0]); +} + +sub getCurrentAvailableNodes +{ + my $command = "sinfo -p $partition -t idle -o %D -h"; + my $output = `$command`; + chomp $output; + return $output +} + +sub getCurrentTotalNodes +{ + my $command = "sinfo -p $partition -t idle,alloc -o %D -h"; + my $output = `$command`; + chomp $output; + return $output +} + +sub getCurrentLoad +{ + my $command = "squeue -h -p $partition -u $user | wc -l"; + my $output = `$command`; + chomp $output; + return $output +} + +sub getCurrentRunning +{ + my $command = "squeue -h -p $partition -u $user -t R | wc -l"; + my $output = `$command`; + chomp $output; + return $output +} + +sub throttleCommand +{ + my $command = $_[0]; + my $total = getCurrentTotalNodes(); + my $avail = getCurrentAvailableNodes(); + my $load = getCurrentLoad(); + if($threshold < $avail) + { + $threshold = int($avail*$overSubFactor); + } + else + { + my $max = $total * $overSubFactor; + if($max < $threshold) + { + $threshold = $max; + } + } + my $secs = 100; + while($load >= $threshold) + { + usleep($secs); + if($secs < 1000000) + { + $secs+=100; + } + $load = getCurrentLoad(); + } + my $load = getCurrentLoad(); + runCommand($command); + $total = getCurrentTotalNodes(); + $avail = getCurrentAvailableNodes(); + $load = getCurrentLoad(); + my $running = getCurrentRunning(); + my $percentage = 100 * $running / $total; + print("Nodes: $total Avail: $avail Load: $load Percent: $percentage Threshold: $threshold\n"); +} + +sub greedyThrottleCommand +{ + $threshold = shift(@_); + my $command = shift(@_); + my $total = getCurrentTotalNodes(); + my $avail = getCurrentAvailableNodes(); + my $load = getCurrentLoad(); + + + my $secs = 100; + while($load >= $threshold) + { + usleep($secs); + if($secs < 1000000) + { + $secs+=100; + } + $load = getCurrentLoad(); + } + my $load = getCurrentLoad(); + runCommand($command); + $total = getCurrentTotalNodes(); + $avail = getCurrentAvailableNodes(); + $load = getCurrentLoad(); + my $running = getCurrentRunning(); + my $percentage = 100 * $running / $total; + print("Nodes: $total Avail: $avail Load: $load Percent: $percentage Threshold: $threshold\n"); +} + +sub waitUntilFileExists +{ + my $fileName = shift(@_); + my $flag = 0; + while(!$flag) + { + if(-e $fileName) + { + $flag = 1; + } + else + { + # print("Waiting for $fileName\n"); + usleep(100); + } + } +} + +sub waitUntilFileExistsTimeout +{ + my $fileName = shift(@_); + my $waitTime = shift(@_) * 1000000; + my $flag = 0; + while(!$flag && $waitTime!=0) + { + if(-e $fileName) + { + $flag = 1; + } + else + { + usleep(100); + $waitTime -= 100; + } + } +} + +sub waitUntilDirExists +{ + my $dirName = shift(@_); + my $flag = 0; + while(!$flag) + { + if(-d $dirName) + { + $flag = 1; + } + else + { + # print("Waiting for $dirName\n"); + usleep(100); + } + } +} + +sub getDirsWithPrefix +{ + my $root = shift(@_); + my $prefix = shift(@_); + + opendir my $dh, $root + or die "$0: opendir: $!"; + my @dirs = grep {-d "$root/$_" && ! /^\.{1,2}$/} readdir($dh); + return grep(/$prefix/, @dirs); +} + +sub countDirsWithPrefix +{ + return scalar(getDirsWithPrefix(shift(@_))); +} + +1; \ No newline at end of file diff --git a/bsuite/bsuite_all.py b/bsuite/bsuite_all.py new file mode 100644 index 00000000..5ec03ea3 --- /dev/null +++ b/bsuite/bsuite_all.py @@ -0,0 +1,100 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +import sys +from bsuite import sweep + +subsets = {"all": ["bandit", "bandit_noise", "bandit_scale", + "cartpole", "cartpole_noise", "cartpole_scale", "cartpole_swingup", + "catch", "catch_noise", "catch_scale", + "deep_sea", "deep_sea_stochastic", + "discounting_chain", + "memory_len", "memory_size", + "mnist", "mnist_noise", "mnist_scale", + "mountain_car", "mountain_car_noise", "mountain_car_scale", + "umbrella_distract", "umbrella_length"], + "working": ["bandit", "bandit_noise", "bandit_scale", + "cartpole", "cartpole_noise", "cartpole_scale", + "catch", "catch_noise", "catch_scale", + "deep_sea", "deep_sea_stochastic", + "discounting_chain", + "memory_len", "memory_size", + "mnist", "mnist_noise", "mnist_scale", + "umbrella_distract", "umbrella_length"], + "developer": ["cartpole", "cartpole_noise", "bandit"], + "basic": ["bandit", "mnist", "catch", "mountain_car", "cartpole"], + "noise": ["bandit_noise", "mnist_noise", "catch_noise", "mountain_car_noise", "cartpole_noise"], + "scale": ["bandit_scale", "mnist_scale", "catch_scale", "mountain_car_scale", "cartpole_scale"], + "exploration": ["deep_sea", "deep_sea_stochastic", "cartpole_swingup"], + "credit_assignment": ["umbrella_length", "umbrella_distract", "discounting_chain"], + "memory": ["memory_len", "memory_size"], + "quick_basic": ["bandit", "catch", "discounting_chain"], + "dynamics_learning": ["cartpole_swingup", "deep_sea", "discounting_chain", "memory_len", "memory_size", "umbrella_length", "umbrella_distract"], + "cartpole": ["cartpole", "cartpole_noise", "cartpole_scale"], + "cartpole_only": ["cartpole"], + "cartpole_noise": ["cartpole_noise"], + "cartpole_scale": ["cartpole_scale"], + "cartpole_swingup": ["cartpole_swingup"], + "catch": ["catch", "catch_noise", "catch_scale"], + "catch_only": ["catch"], + "catch_noise": ["catch_noise"], + "catch_scale": ["catch_scale"], + "mountain_car_only": ["mountain_car"], + "mountain_car_noise": ["mountain_car_noise"], + "mountain_car_scale": ["mountain_car_scale"], + "deep": ["deep_sea", "deep_sea_stochastic"], + "umbrella": ["umbrella_length"], + "umb_dist": ["umbrella_distract"], + "discount": ["discounting_chain"], + "empty": []} + + +def parse_entry(entry): + temp = entry.split("/") + return temp[0], int(temp[1]) + 1 + +def get_all(filter): + ret = {} + for entry in sweep.SWEEP: + name, seed = parse_entry(entry) + reps = sweep.EPISODES[entry] + if filter is None or name in subsets[filter]: + if name in ret: + seed = max([ret[name][0], seed]) + reps = max([ret[name][1], reps]) + ret[name] = (seed, reps) + return ret + + +if __name__ == "__main__": + filter = "all" + if len(sys.argv) == 2: + filter = str(sys.argv[1]) + + if filter == "display": + for sub in subsets: + if sub != "empty": + print(sub) + else: + if filter not in subsets: + filter = "empty" + envs = get_all(filter) + for i in envs: + print(i, envs[i][0], envs[i][1]) diff --git a/bsuite/bsuite_batch.pl b/bsuite/bsuite_batch.pl new file mode 100755 index 00000000..33efe7bd --- /dev/null +++ b/bsuite/bsuite_batch.pl @@ -0,0 +1,269 @@ +#!/usr/bin/perl +use strict; +use Cwd qw(cwd); +use File::Basename; +use FindBin; +use lib "$FindBin::RealBin"; +require SingleRun; +use Getopt::Std; +my %options=(); +my $dir = cwd; +my $script_path = dirname($0); + +# ------------------ User options section ------------------ # +sub usage() { + print "usage: bsuite_batch.pl [options] partition\n"; + print " partition: Slurm parition to submit jobs to\n\n"; + print " options:\n"; + print " Slurm options:\n"; + print " -N: Number of nodes per srun job\n"; + print " -n: Number of ranks per srun job\n"; + print " -a: Additional slurm options to pass\n"; + print " (i.e. \"-x node15,node28\")\n"; + print " -S: Launch jobs using sbatch template\n"; + print " Exarl options:\n"; + print " -P: Path to exarl root\n"; + print " -s: Number of seeds per experiment\n"; + print " -e: Number of episodes per experiment\n"; + print " -p: Number of steps per episode per experiment\n"; + print " -o: Output dir\n"; + print " -A: Additional Exarl options\n"; + print " (i.e. \"--agent async\")\n"; + print " Bsuite options:\n"; + print " -b: Bsuite subset to run (defualt is all)\n"; + print " -B: Only print bsuite subset, seeds, and episodes\n"; + print " To see all use subset all (i.e. -B all)\n"; + print " -D: Display bsuite subsets.\n"; + print " Script options:\n"; + print " -t: Turn OFF throttling\n"; + print " -x: Don't run just print jobs\n"; + print " -c: Create directories but do not run\n"; + print " -h: Print this message\n\n"; + print "Example usage:\n"; + print " ./bsuite/bsuite_batch.pl -N 2 -n 2 -a \"-x node15,node28,node22,node42,node33\" -b developer -o out -s 2 -e 100 -p 100 slurm\n"; + print " ./bsuite/bsuite_batch.pl -N 2 -n 2 -A \"--agent async\" -o out slurm\n"; + print " ./bsuite/bsuite_batch.pl -N 1 -n 1 -S ./script/cori_V100_gpu.sh -b memory -s 1 -o out slurm\n"; + print " ./bsuite/bsuite_batch.pl -D slurm\n"; + print " ./bsuite/bsuite_batch.pl -B all slurm\n"; + exit() +} + +# User defined options +getopts("N:n:a:P:s:e:p:u:p:o:A:b:B:S:txhcD",\%options) or usage; +my $N = defined $options{N} ? $options{N} : 1; +my $n = defined $options{n} ? $options{n} : 1; +my $a = defined $options{a} ? $options{a} : ""; +my $path = defined $options{P} ? $options{P} : "."; +my $seeds = defined $options{s} ? $options{s} : 1000000000; +my $episodes = defined $options{e} ? $options{e} : 1000000000; +my $steps = defined $options{p} ? "--n_steps $options{p}" : ""; +my $A = defined $options{A} ? $options{A} : ""; +my $throttle = defined $options{t} ? 0 : 1; +my $run = defined $options{x} ? 0 : 1; +my $bsuite_set = defined $options{b} ? $options{b} : ""; +my $output_dir = defined $options{o} ? $options{o} : "."; +my $make_dir = defined $options{c} ? $options{c} : 0; +if(defined $options{h}) { + usage(); +} +if(defined $options{B}) { + $bsuite_set = $options{B}; + my $path_to_py_module = $script_path . "/bsuite_all.py " . $bsuite_set; + my $bsuite_txt = `python $path_to_py_module`; + print("Subset: $bsuite_set\n"); + print("Name Seeds Episodes\n"); + print($bsuite_txt); + exit(); +} +if(defined $options{D}) { + my $path_to_py_module = $script_path . "/bsuite_all.py display"; + my $bsuite_txt = `python $path_to_py_module`; + print("Subsets:\n"); + print($bsuite_txt); + exit(); +} +my @template; +if(defined $options{S}) { + my $file = $options{S}; + open(my $fh, "<", $file) or die "could not open $file: $!"; + chomp(@template = <$fh>); + close($fh); + + for(my $i=0; $i<=$#template; $i++) { + if($template[$i] =~ /#SBATCH/) { + if($template[$i] =~ /-n/) { + $template[$i] = "#SBATCH -n $n" + } + } + } +} + +# ------------------ Function section ------------------ # + +# Wrapper to make directories +sub makeDir { + if($run || $make_dir) { + my $path_to_make = shift(@_); + if(-d $path_to_make){ + print("Dir $path_to_make exists.\n"); + } + else { + print("Making $path_to_make\n"); + system("mkdir $path_to_make"); + } + } +} + +# This functions calls a python module to get the benchmark, seed, episodes +# that are found in the bsuite python module. script_path is the dir that +# this perl script is found in. Make sure bsuite_all and this script are +# colocated! +sub getBsuiteBenchSet { + my $path_to_py_module = $script_path . "/bsuite_all.py " . $bsuite_set; + my $ret = `python $path_to_py_module`; + my @lines = split("\n", $ret); + my %bsuite_benchmarks; + foreach my $line (@lines) { + my @parts = split(" ", $line); + $bsuite_benchmarks{$parts[0]} = [$parts[1], $parts[2]]; + } + return %bsuite_benchmarks +} + +# This function checks to see if there is a directory called +# bench_seed_episode under the provided path. If there is not +# then it creates the directory and returns the path. +sub checkForResults { + my $bench = shift(@_); + my $seed = shift(@_); + my $episode = shift(@_); + my $out_dir = shift(@_); + my $to_check = $out_dir . "/" . $bench . "_" . $seed . "_" . $episode; + if(-d $to_check) { + return 0; + } + if($run) { + system("mkdir $to_check"); + } + return $to_check; +} + +# This function generates a slurm command if results do not already exist. +sub getSbatchCommand { + my $bench = shift(@_); + my $seed = shift(@_); + my $episode = shift(@_); + my $partition = shift(@_); + my $driver_path = $path . "/exarl/driver"; + + my $bench_dir_name = $bench; + my $outfile = $bench_dir_name . "/" . $bench . "_" . $seed . "_" . $episode . ".txt"; + + if(defined $options{o}) { + $bench_dir_name = $output_dir . "/" . $bench_dir_name; + $outfile = $output_dir . "/" . $outfile; + } + + makeDir($bench_dir_name); + my $exp_dir = checkForResults($bench, $seed, $episode, $bench_dir_name); + if($exp_dir) { + makeDir($exp_dir); + my $output = "--output_dir $bench_dir_name"; + + # Set the srun command in script + for(my $i=0; $i<=$#template; $i++) { + if($template[$i] =~ /srun/) { + $template[$i] = "srun python $driver_path --env Bsuite-v0 --bsuite_id $bench --seed_number $seed --n_episodes $episode $steps $A $output&> $outfile"; + } + } + + # Write script + my $filename = $bench_dir_name . "/" . $bench . "_" . $seed . "_" . $episode . ".sh"; + my $to_write = join("\n", @template); + print("$filename \n"); + open(my $fh, '>', $filename) or die $!; + print $fh $to_write; + close($fh); + + return "sbatch -N $N $filename"; + } + return 0; +} + +# This function generates a slurm command if results do not already exist. +sub getSlurmCommand { + my $bench = shift(@_); + my $seed = shift(@_); + my $episode = shift(@_); + my $partition = shift(@_); + my $driver_path = $path . "/exarl/driver"; + + my $bench_dir_name = $bench; + my $outfile = $bench_dir_name . "/" . $bench . "_" . $seed . "_" . $episode . ".txt"; + + if(defined $options{o}) { + $bench_dir_name = $output_dir . "/" . $bench_dir_name; + $outfile = $output_dir . "/" . $outfile; + } + + makeDir($bench_dir_name); + my $exp_dir = checkForResults($bench, $seed, $episode, $bench_dir_name); + if($exp_dir) { + makeDir($exp_dir); + my $output = "--output_dir $bench_dir_name"; + + return "srun -p $partition -N $N -n $n $a python $driver_path --env Bsuite-v0 --bsuite_id $bench --seed_number $seed --n_episodes $episode $steps $A $output&> $outfile &"; + } + return 0; +} + +sub getCommand { + if(@template) { + return getSbatchCommand(@_); + } + return getSlurmCommand(@_); +} + +# ------------------ Scripting section ------------------ # + +# These are used to submit and throttle commands sent to slurm +my $username = $ENV{LOGNAME} || $ENV{USER} || getpwuid($<); +my $partition = shift(@ARGV); +print("Username: $username Slurm Partition: $partition\n"); +SingleRun::setPartition("$partition"); +SingleRun::setUser("$username"); + +# Create output directory +makeDir($output_dir); + +# This hashmap of desired benchmarks. +# Benchmark => (Number of seeds, Number of Episodes) +my %bsuite_bench = getBsuiteBenchSet(); + +# Iterate over all benchmarks +foreach my $benchmark (keys %bsuite_bench) { + # Get the min seed and episode + my $min_seed = $bsuite_bench{$benchmark}[0] <= $seeds ? $bsuite_bench{$benchmark}[0] : $seeds; + my $min_episode = $bsuite_bench{$benchmark}[1] <= $episodes ? $bsuite_bench{$benchmark}[1] : $episodes; + for(my $i=0; $i<$min_seed; $i++) { + my $command = getCommand($benchmark, $i, $min_episode, $partition); + if($command) { + if($run) { + # If we don't use throttling, all jobs will be dumped into the system + if($throttle) { + SingleRun::throttleCommand($command); + } + else { + print("$command\n"); + SingleRun::runCommand($command); + } + } + else { + print("$command\n"); + } + } + else { + print("Skipping $benchmark $i $min_episode\n"); + } + } +} diff --git a/docs/source/conf.py b/docs/source/conf.py index e74c1ee2..cf3b7641 100644 --- a/docs/source/conf.py +++ b/docs/source/conf.py @@ -71,7 +71,7 @@ # List of patterns, relative to source directory, that match files and # directories to ignore when looking for source files. # This pattern also affects html_static_path and html_extra_path. -exclude_patterns = [] # ['__init__.py', '__main__.py'] +exclude_patterns = ['Hadrec_dir'] # ['__init__.py', '__main__.py'] # autodoc_mock_imports = ['exarl/agents/agent_vault'] # -- Options for HTML output ------------------------------------------------- diff --git a/docs/source/index.rst b/docs/source/index.rst index 3102792e..4ffac7c5 100644 --- a/docs/source/index.rst +++ b/docs/source/index.rst @@ -20,6 +20,7 @@ Welcome to EXARL's documentation! usage/agent_doc usage/tutorial usage/utests + usage/bsuite Indices and tables diff --git a/docs/source/usage/agent_doc.rst b/docs/source/usage/agent_doc.rst index 13321817..79185e8b 100644 --- a/docs/source/usage/agent_doc.rst +++ b/docs/source/usage/agent_doc.rst @@ -23,8 +23,8 @@ Agents must include the following functions: train() # train the agent update() # update target model action() # Next action based on current state - load() # load weights from memory - save() # save weights to memory + load() # load weights from pickle file + save() # save weights to pickle file monitor() # monitor progress of learning Register the agent in ``ExaRL/exarl/agents/__init__.py`` diff --git a/docs/source/usage/bsuite.rst b/docs/source/usage/bsuite.rst new file mode 100755 index 00000000..0554afdd --- /dev/null +++ b/docs/source/usage/bsuite.rst @@ -0,0 +1,49 @@ +ExaBsuite Environment +====== + +Integration Test Environments +------- +- A wrapper for `bsuite `_ environments. ``ExaBsuite`` inherits from ``gym.Env``. + +Has the following environments: + +1. Simple Bandit (Noisy Rewards, Reward Scale) + +2. MNIST Contextual Bandit (Noisy Rewards, Reward Scale) + +3. Catch (Noisy Rewards, Reward Scale) + +4. Cartpole (Noisy Rewards, Reward Scale) + +5. Mountain Car (Noisy Rewards, Reward Scale) + +6. Deep Sea (Stochastic) + +7. Cartpole Swingup + +8. Umbrella Length + +9. Umbrella Features + +10. Discounting Chain + +11. Memory Length + +12. Memory Bits + +Example of how bsuite usually works: + +.. code-block:: python + + import bsuite + from bsuite.utils import gym_wrapper + SAVE_PATH_RAND = '/tmp/bsuite/rand' + raw_env = bsuite.load_and_record('bandit_noise/0', save_path=SAVE_PATH_RAND, overwrite=True) + env = gym_wrapper.GymFromDMEnv(raw_env) + + for episode in range(raw_env.bsuite_num_episodes): + state = env.reset() + done = False + while not done: + action = Agent(state) + state, reward, done, info = env.step(action) diff --git a/exarl/__init__.py b/exarl/__init__.py index 1e1918b6..829eef81 100644 --- a/exarl/__init__.py +++ b/exarl/__init__.py @@ -1,9 +1,9 @@ -# import faulthandler; faulthandler.enable() from exarl.utils import candleDriver try: candleDriver.initialize_parameters() -except: - print("Could not load candle parameters") +except FileNotFoundError as e: + print(e, flush=True) + print("Could not load candle parameters.", flush=True) from exarl.base import ExaComm from exarl.base import ExaAgent @@ -11,3 +11,25 @@ from exarl.base import ExaWorkflow from exarl.base import ExaLearner from exarl.base import ExaData + +from exarl.utils.globals import ExaGlobals +import importlib +import sys +try: + load_agent_module = ExaGlobals.lookup_params('load_agent_module') + print(sys.path) + importlib.import_module(load_agent_module) + print("Loaded:", load_agent_module) +except ExaGlobals.GlobalDoesNotExist: + pass +except ExaGlobals.GlobalsNotInitialized: + pass + +try: + load_env_module = ExaGlobals.lookup_params('load_env_module') + importlib.import_module(load_env_module) + print("Loaded:", load_env_module) +except ExaGlobals.GlobalDoesNotExist: + pass +except ExaGlobals.GlobalsNotInitialized: + pass \ No newline at end of file diff --git a/exarl/agents/__init__.py b/exarl/agents/__init__.py index 3035e33c..5091071b 100644 --- a/exarl/agents/__init__.py +++ b/exarl/agents/__init__.py @@ -1,12 +1,25 @@ from exarl.agents.registration import register, make -import exarl.utils.candleDriver as cd -agent = cd.lookup_params('agent') +from exarl.utils.globals import ExaGlobals +try: + agent = ExaGlobals.lookup_params('agent') +except: + agent = None if agent == 'DQN-v0': register( id=agent, entry_point='exarl.agents.agent_vault:DQN' ) +elif agent == 'DQN-v1': + register( + id=agent, + entry_point='exarl.agents.agent_vault:DQN_v1' + ) +elif agent == 'DQN-v2': + register( + id=agent, + entry_point='exarl.agents.agent_vault:DQN_v2' + ) elif agent == 'DDPG-v0': register( id=agent, @@ -17,5 +30,23 @@ id=agent, entry_point='exarl.agents.agent_vault:DDPG_Vtrace' ) -else: - print("No agent selected!") +elif agent == 'SAC-v0': + register( + id=agent, + entry_point='exarl.agents.agent_vault:SAC' + ) +elif agent == 'SAC-v1': + register( + id=agent, + entry_point='exarl.agents.agent_vault:SAC_squash' + ) +elif agent == 'TD3-v0': + register( + id=agent, + entry_point='exarl.agents.agent_vault:TD3' + ) +elif agent == 'TD3-v1': + register( + id=agent, + entry_point='exarl.agents.agent_vault:KerasTD3' + ) diff --git a/exarl/agents/agent_vault/__init__.py b/exarl/agents/agent_vault/__init__.py index 9c64bc7b..382c082c 100644 --- a/exarl/agents/agent_vault/__init__.py +++ b/exarl/agents/agent_vault/__init__.py @@ -1,11 +1,24 @@ -import exarl.utils.candleDriver as cd -agent = cd.lookup_params('agent') +from exarl.utils.globals import ExaGlobals +try: + agent = ExaGlobals.lookup_params('agent') +except: + agent = None if agent == 'DQN-v0': from exarl.agents.agent_vault.dqn import DQN +elif agent == 'DQN-v1': + from exarl.agents.agent_vault.dqn import DQN_v1 +elif agent == 'DQN-v2': + from exarl.agents.agent_vault.dqn import DQN_v2 elif agent == 'DDPG-v0': from exarl.agents.agent_vault.ddpg import DDPG elif agent == 'DDPG-VTRACE-v0': from exarl.agents.agent_vault.ddpg_vtrace import DDPG_Vtrace -else: - print("No agent selected!") +elif agent == 'SAC-v0': + from exarl.agents.agent_vault.keras_sac import SAC +elif agent == 'SAC-v1': + from exarl.agents.agent_vault.keras_sac import SAC_squash +elif agent == 'TD3-v0': + from exarl.agents.agent_vault.td3 import TD3 +elif agent == 'TD3-v1': + from exarl.agents.agent_vault.keras_td3 import KerasTD3 diff --git a/exarl/agents/agent_vault/_build_lstm.py b/exarl/agents/agent_vault/_build_lstm.py deleted file mode 100644 index dbfa34ea..00000000 --- a/exarl/agents/agent_vault/_build_lstm.py +++ /dev/null @@ -1,53 +0,0 @@ -# This material was prepared as an account of work sponsored by an agency of the -# United States Government. Neither the United States Government nor the United -# States Department of Energy, nor Battelle, nor any of their employees, nor any -# jurisdiction or organization that has cooperated in the development of these -# materials, makes any warranty, express or implied, or assumes any legal -# liability or responsibility for the accuracy, completeness, or usefulness or -# any information, apparatus, product, software, or process disclosed, or -# represents that its use would not infringe privately owned rights. Reference -# herein to any specific commercial product, process, or service by trade name, -# trademark, manufacturer, or otherwise does not necessarily constitute or imply -# its endorsement, recommendation, or favoring by the United States Government -# or any agency thereof, or Battelle Memorial Institute. The views and opinions -# of authors expressed herein do not necessarily state or reflect those of the -# United States Government or any agency thereof. -# PACIFIC NORTHWEST NATIONAL LABORATORY -# operated by -# BATTELLE -# for the -# UNITED STATES DEPARTMENT OF ENERGY -# under Contract DE-AC05-76RL01830 -from tensorflow.keras.models import Sequential -from tensorflow.keras.layers import Dense, Dropout, BatchNormalization, LSTM -from tensorflow.keras.regularizers import l1_l2 - - -def build_model(self): - - num_layers = len(self.lstm_layers) - - model = Sequential() - # special case for input layer - model.add(LSTM(self.lstm_layers[0], activation=self.activation, - return_sequences=True, input_shape=(1, self.env.observation_space.shape[0]))) - model.add(BatchNormalization()) - model.add(Dropout(self.gauss_noise[0])) - - # loop over inner layers only - for l in range(1, num_layers - 1): - model.add(LSTM(self.lstm_layers[l], activation=self.activation, - return_sequences=True)) - model.add(Dropout(self.gauss_noise[l])) - - # special case for output layer - l = num_layers = 1 - model.add(LSTM(self.lstm_layers[l], activation=self.activation, - kernel_regularizer=l1_l2(self.regularizer[0], self.regularizer[1]), - )) - model.add(Dropout(self.gauss_noise[l])) - model.add(Dense(self.env.action_space.n, activation=self.out_activation)) - - # model.summary() - print('', flush=True) - return model diff --git a/exarl/agents/agent_vault/_prioritized_replay.py b/exarl/agents/agent_vault/_prioritized_replay.py deleted file mode 100644 index a1fedb42..00000000 --- a/exarl/agents/agent_vault/_prioritized_replay.py +++ /dev/null @@ -1,97 +0,0 @@ -import random -import numpy as np -import tensorflow as tf -from collections import deque - - -class PrioritizedReplayBuffer(): - """ Class implements Prioritized Experience Replay (PER) - """ - - def __init__(self, maxlen): - """ PER constructor - - Args: - maxlen (int): buffer length - """ - self.maxlen = None if maxlen == "none" else maxlen - self.buffer = deque(maxlen=self.maxlen) - self.priorities = deque(maxlen=self.maxlen) - - def add(self, experience): - """ Add experiences to buffer - - Args: - experience (list): state, action, reward, next_state, done - - Returns: - full_buffer (done): True if buffer is full - """ - full_buffer = len(self.buffer) == self.maxlen - self.buffer.append(experience) - self.priorities.append(max(self.priorities, default=1)) - return full_buffer - - def get_probabilities(self, priority_scale): - """ Get probabilities for experiences - - Args: - priority_scale (float64): range [0, 1] - - Returns: - sample_probabilities (numpy array): probabilities assigned to experiences based on weighting factor (scale) - """ - scaled_priorities = np.array(self.priorities) ** priority_scale - sample_probabilities = scaled_priorities / sum(scaled_priorities) - return sample_probabilities - - def get_importance(self, probabilities): - """ Compute importance - - Args: - probabilities (numpy array): experience probabilities - - Returns: - importance_normalized (numpy array): normalized importance - """ - importance = 1 / len(self.buffer) * 1 / probabilities - importance_normalized = importance / max(importance) - return importance_normalized - - def sample(self, batch_size, priority_scale=1.0): - """ Sample experiences - - Args: - batch_size (int): size of batch - priority_scale (float, optional): range = [0, 1]. Defaults to 1.0. - - Returns: - samples (list): sampled based on probabilities - importance (numpy array): Importance of samples - sample_indices (array): Indices of samples - """ - sample_size = min(len(self.buffer), batch_size) - sample_probs = self.get_probabilities(priority_scale) - sample_indices = random.choices(range(len(self.buffer)), k=sample_size, weights=sample_probs) - samples = np.array(self.buffer, dtype=object)[sample_indices] - importance = self.get_importance(sample_probs[sample_indices]) - return samples, importance, sample_indices - - def set_priorities(self, indices, errors, offset=0.1): - """ Set priorities to experiences - - Args: - indices (array): sample indices - errors (array): corresponding losses - offset (float, optional): Small offset. Defaults to 0.1. - """ - for i, e in zip(indices, errors): - self.priorities[int(i)] = abs(e) + offset - - def get_buffer_length(self): - """ Get buffer length - - Returns: - (int): buffer length - """ - return len(self.buffer) diff --git a/exarl/agents/agent_vault/ddpg.py b/exarl/agents/agent_vault/ddpg.py index 781f41b8..39715f39 100644 --- a/exarl/agents/agent_vault/ddpg.py +++ b/exarl/agents/agent_vault/ddpg.py @@ -20,33 +20,24 @@ # under Contract DE-AC05-76RL01830 import numpy as np import tensorflow as tf -from tensorflow.keras import layers -import random -import os -import pickle -from datetime import datetime +from copy import deepcopy + +import exarl +from exarl.utils.globals import ExaGlobals +from exarl.agents.replay_buffers.buffer import Buffer from exarl.utils.OUActionNoise import OUActionNoise -from exarl.utils.OUActionNoise import OUActionNoise2 +from exarl.agents.models.tf_model import Tensorflow_Model from exarl.utils.introspect import introspectTrace -import exarl as erl - -from exarl.utils import log -import exarl.utils.candleDriver as cd -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) - +logger = ExaGlobals.setup_logger(__name__) -@tf.function -def update_target(target_weights, weights, tau): - for (a, b) in zip(target_weights, weights): - a.assign(b * tau + a * (1 - tau)) +# https://github.com/keras-team/keras-io/blob/master/examples/rl/ddpg_pendulum.py - -class DDPG(erl.ExaAgent): - """Deep deterministic policy gradient agent. +class DDPG(exarl.ExaAgent): + """ + Deep deterministic policy gradient agent. Inherits from ExaAgent base class. """ - is_learner: bool def __init__(self, env, is_learner): """DDPG constructor @@ -55,330 +46,140 @@ def __init__(self, env, is_learner): env (OpenAI Gym environment object): env object indicates the RL environment is_learner (bool): Used to indicate if the agent is a learner or an actor """ - # Distributed variables self.is_learner = is_learner - - # Environment space and action parameters - self.env = env - - self.num_states = env.observation_space.shape[0] - self.num_actions = env.action_space.shape[0] + self.upper_bound = env.action_space.high self.lower_bound = env.action_space.low - logger.info("Size of State Space: {}".format(self.num_states)) - logger.info("Size of Action Space: {}".format(self.num_actions)) - logger.info('Env upper bounds: {}'.format(self.upper_bound)) - logger.info('Env lower bounds: {}'.format(self.lower_bound)) - - self.gamma = cd.run_params['gamma'] - self.tau = cd.run_params['tau'] - - # model definitions - self.actor_dense = cd.run_params['actor_dense'] - self.actor_dense_act = cd.run_params['actor_dense_act'] - self.actor_out_act = cd.run_params['actor_out_act'] - self.actor_optimizer = cd.run_params['actor_optimizer'] - self.critic_state_dense = cd.run_params['critic_state_dense'] - self.critic_state_dense_act = cd.run_params['critic_state_dense_act'] - self.critic_action_dense = cd.run_params['critic_action_dense'] - self.critic_action_dense_act = cd.run_params['critic_action_dense_act'] - self.critic_concat_dense = cd.run_params['critic_concat_dense'] - self.critic_concat_dense_act = cd.run_params['critic_concat_dense_act'] - self.critic_out_act = cd.run_params['critic_out_act'] - self.critic_optimizer = cd.run_params['critic_optimizer'] - self.tau = cd.run_params['tau'] - - # TODO: Parameterize these - std_dev = 0.2 - # ave_bound = (self.upper_bound + self.lower_bound) / 2 - ave_bound = np.zeros(1) - print('ave_bound: {}'.format(ave_bound)) - # Ornstein-Uhlenbeck process - self.ou_noise = OUActionNoise(mean=ave_bound, std_deviation=float(std_dev) * np.ones(1)) + self.gamma = ExaGlobals.lookup_params('gamma') + self.tau = ExaGlobals.lookup_params('tau') + self.batch_size = ExaGlobals.lookup_params('batch_size') - # Not used by agent but required by the learner class - self.epsilon = cd.run_params['epsilon'] - self.epsilon_min = cd.run_params['epsilon_min'] - self.epsilon_decay = cd.run_params['epsilon_decay'] + # Ornstein-Uhlenbeck process + self.ou_noise = OUActionNoise(mean=np.zeros(env.action_space.shape), std_deviation=np.array([0.2])) # Experience data - self.buffer_counter = 0 - self.buffer_capacity = cd.run_params['buffer_capacity'] - self.batch_size = cd.run_params['batch_size'] - # self.buffer_counter = cd.run_params['buffer_counter'] - - self.state_buffer = np.zeros((self.buffer_capacity, self.num_states)) - self.action_buffer = np.zeros((self.buffer_capacity, self.num_actions)) - self.reward_buffer = np.zeros((self.buffer_capacity, 1)) - self.next_state_buffer = np.zeros((self.buffer_capacity, self.num_states)) - self.done_buffer = np.zeros((self.buffer_capacity, 1)) - self.memory = self.state_buffer # BAD - - # Setup TF configuration to allow memory growth - # tf.keras.backend.set_floatx('float64') - config = tf.compat.v1.ConfigProto() - config.gpu_options.allow_growth = True - sess = tf.compat.v1.Session(config=config) - tf.compat.v1.keras.backend.set_session(sess) - - # Training model only required by the learners - self.actor_model = None - self.critic_model = None - if self.is_learner: - self.actor_model = self.get_actor() - self.critic_model = self.get_critic() - - # Every agent needs this, however, actors only use the CPU (for now) - self.target_critic = None - self.target_actor = None - if self.is_learner: - self.target_actor = self.get_actor() - self.target_critic = self.get_critic() - self.target_actor.set_weights(self.actor_model.get_weights()) - self.target_critic.set_weights(self.critic_model.get_weights()) - else: - with tf.device('/CPU:0'): - self.target_actor = self.get_actor() - self.target_critic = self.get_critic() - - # Learning rate for actor-critic models - self.critic_lr = cd.run_params['critic_lr'] - self.actor_lr = cd.run_params['actor_lr'] - # TODO: Parameterize - self.critic_optimizer = tf.keras.optimizers.Adam(self.critic_lr) - self.actor_optimizer = tf.keras.optimizers.Adam(self.actor_lr) + self._replay = Buffer.create(observation_space=env.observation_space, action_space=env.action_space) + + self.actor = Tensorflow_Model.create("Actor", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.critic = Tensorflow_Model.create("Critic", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.target_actor = deepcopy(self.actor) + self.target_critic = deepcopy(self.critic) + + self.actor.init_model() + self.critic.init_model() + self.actor.print() + self.critic.print() + self.target_actor.init_model() + self.target_critic.init_model() + + self.target_actor.set_weights(self.actor.get_weights()) + self.target_critic.set_weights(self.critic.get_weights()) + + self._forward = tf.function(self.actor) - def remember(self, state, action, reward, next_state, done): - """Add experience to replay buffer + @introspectTrace() + def action(self, state): + """Returns sampled action with added noise Args: state (list or array): Current state of the system - action (list or array): Action to take - reward (list or array): Environment reward - next_state (list or array): Next state of the system - done (bool): Indicates episode completion - """ - # If the counter exceeds the capacity then - index = self.buffer_counter % self.buffer_capacity - self.state_buffer[index] = state - self.action_buffer[index] = action[0] - self.reward_buffer[index] = reward - self.next_state_buffer[index] = next_state - self.done_buffer[index] = int(done) - self.buffer_counter += 1 - - # @tf.function - def update_grad(self, state_batch, action_batch, reward_batch, next_state_batch): - """Update gradients - training step - - Args: - state_batch (list): list of states - action_batch (list): list of actions - reward_batch (list): list of rewards - next_state_batch (list): list of next states - """ - # tf.print(state_batch.shape) - # Training and updating Actor & Critic networks. - with tf.GradientTape() as tape: - target_actions = self.target_actor(next_state_batch, training=True) - y = reward_batch + self.gamma * self.target_critic( - [next_state_batch, target_actions], training=True - ) - critic_value = self.critic_model([state_batch, action_batch], training=True) - critic_loss = tf.math.reduce_mean(tf.math.square(y - critic_value)) - - logger.warning("Critic loss: {}".format(critic_loss)) - critic_grad = tape.gradient(critic_loss, self.critic_model.trainable_variables) - self.critic_optimizer.apply_gradients( - zip(critic_grad, self.critic_model.trainable_variables) - ) - - with tf.GradientTape() as tape: - actions = self.actor_model(state_batch, training=True) - critic_value = self.critic_model([state_batch, actions], training=True) - actor_loss = -tf.math.reduce_mean(critic_value) - # actor_loss = tf.math.reduce_mean(critic_value) - - logger.warning("Actor loss: {}".format(actor_loss)) - actor_grad = tape.gradient(actor_loss, self.actor_model.trainable_variables) - self.actor_optimizer.apply_gradients( - zip(actor_grad, self.actor_model.trainable_variables) - ) - - def get_actor(self): - """Define actor network Returns: - model: actor model + action (list or array): Action to take + policy (int): random (0) or inference (1) """ - # State as input - inputs = layers.Input(shape=(self.num_states,)) - # first layer takes inputs - out = layers.Dense(self.actor_dense[0], activation=self.actor_dense_act)(inputs) - # loop over remaining layers - for i in range(1, len(self.actor_dense)): - out = layers.Dense(self.actor_dense[i], activation=self.actor_dense_act)(out) - # output layer has dimension actions, separate activation setting - out = layers.Dense(self.num_actions, activation=self.actor_out_act, - kernel_initializer=tf.random_uniform_initializer())(out) - outputs = layers.Lambda(lambda i: i * self.upper_bound)(out) - model = tf.keras.Model(inputs, outputs) - # model.summary() - - return model - - def get_critic(self): - """Define critic network + tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0) + prediction = self._forward(tf_state) + sampled_actions = tf.squeeze(prediction) - Returns: - model: critic network - """ - # State as input - state_input = layers.Input(shape=self.num_states) - # first layer takes inputs - state_out = layers.Dense(self.critic_state_dense[0], - activation=self.critic_state_dense_act)(state_input) - # loop over remaining layers - for i in range(1, len(self.critic_state_dense)): - state_out = layers.Dense(self.critic_state_dense[i], - activation=self.critic_state_dense_act)(state_out) - - # Action as input - action_input = layers.Input(shape=self.num_actions) - - # first layer takes inputs - action_out = layers.Dense(self.critic_action_dense[0], - activation=self.critic_action_dense_act)(action_input) - # loop over remaining layers - for i in range(1, len(self.critic_action_dense)): - action_out = layers.Dense(self.critic_action_dense[i], - activation=self.critic_action_dense_act)(action_out) - - # Both are passed through seperate layer before concatenating - concat = layers.Concatenate()([state_out, action_out]) - - # assumes at least 2 post-concat layers - # first layer takes concat layer as input - concat_out = layers.Dense(self.critic_concat_dense[0], - activation=self.critic_concat_dense_act)(concat) - # loop over remaining inner layers - for i in range(1, len(self.critic_concat_dense) - 1): - concat_out = layers.Dense(self.critic_concat_dense[i], - activation=self.critic_concat_dense_act)(concat_out) - - # last layer has different activation - concat_out = layers.Dense(self.critic_concat_dense[-1], activation=self.critic_out_act, - kernel_initializer=tf.random_uniform_initializer())(concat_out) - outputs = layers.Dense(1)(concat_out) - - # Outputs single value for give state-action - model = tf.keras.Model([state_input, action_input], outputs) - # model.summary() - - return model + noise = self.ou_noise() + sampled_actions_wn = sampled_actions.numpy() + noise + legal_action = np.clip(sampled_actions_wn, self.lower_bound, self.upper_bound) + return legal_action, 0 + + def remember(self, state, action, reward, next_state, done): + self._replay.store(state, action, reward, next_state, done) def has_data(self): - """Indicates if the buffer has data + """ + Indicates if the buffer has data Returns: bool: True if buffer has data """ - return (self.buffer_counter > 0) + return self._replay.size > 0 + + def _prep_data(self, data): + data[2] = data[2].reshape((len(data[2]), 1)) + for i in range(4): + data[i] = tf.convert_to_tensor(data[i]) + data[2] = tf.cast(data[2], dtype=tf.float32) + return data @introspectTrace() def generate_data(self): - """Generate data for training - - Yields: - state_batch (list): list of states - action_batch (list): list of actions - reward_batch (list): list of rewards - next_state_batch (list): list of next states - """ + ret = None if self.has_data(): - record_range = min(self.buffer_counter, self.buffer_capacity) - logger.info('record_range:{}'.format(record_range)) - # Randomly sample indices - batch_indices = np.random.choice(record_range, self.batch_size) - else: - batch_indices = [0] * self.batch_size - - logger.info('batch_indices:{}'.format(batch_indices)) - state_batch = tf.convert_to_tensor(self.state_buffer[batch_indices]) - action_batch = tf.convert_to_tensor(self.action_buffer[batch_indices]) - reward_batch = tf.convert_to_tensor(self.reward_buffer[batch_indices]) - reward_batch = tf.cast(reward_batch, dtype=tf.float32) - next_state_batch = tf.convert_to_tensor(self.next_state_buffer[batch_indices]) - - yield state_batch, action_batch, reward_batch, next_state_batch + data = self._replay.sample(self.batch_size) + ret = self._prep_data(data) + yield ret @introspectTrace() def train(self, batch): - """Train the NN + """ + Train the NN Args: batch (list): sampled batch of experiences """ - if self.is_learner: - logger.warning('Training...') - self.update_grad(batch[0], batch[1], batch[2], batch[3]) - else: - logger.warning('Why is is_learner false...') + if batch is not None: + self.update_grad(batch[0], batch[1], batch[2], batch[3], batch[4]) - @introspectTrace() - def target_train(self): - """Update target model - """ - # Update the target model - model_weights = self.actor_model.get_weights() - target_weights = self.target_actor.get_weights() - for i in range(len(target_weights)): - target_weights[i] = self.tau * model_weights[i] + (1 - self.tau) * target_weights[i] - self.target_actor.set_weights(target_weights) - - model_weights = self.critic_model.get_weights() - target_weights = self.target_critic.get_weights() - for i in range(len(target_weights)): - target_weights[i] = self.tau * model_weights[i] + (1 - self.tau) * target_weights[i] - self.target_critic.set_weights(target_weights) + @tf.function + def update_grad(self, state_batch, action_batch, reward_batch, next_state_batch, done_batch): + with tf.GradientTape() as tape: + target_actions = self.target_actor(next_state_batch, training=True) + y = reward_batch + (1.0 - tf.cast(done_batch[:,None], tf.float32))*self.gamma * self.target_critic( + [next_state_batch, target_actions], training=True + ) + critic_value = self.critic([state_batch, action_batch], training=True) + critic_loss = tf.math.reduce_mean(tf.math.square(y - critic_value)) - @introspectTrace() - def action(self, state): - """Returns sampled action with added noise + critic_grad = tape.gradient(critic_loss, self.critic.trainable_variables) + self.critic.optimizer.apply_gradients( + zip(critic_grad, self.critic.trainable_variables) + ) - Args: - state (list or array): Current state of the system + with tf.GradientTape() as tape: + actions = self.actor(state_batch, training=True) + critic_value = self.critic([state_batch, actions], training=True) + actor_loss = -tf.math.reduce_mean(critic_value) - Returns: - action (list or array): Action to take - policy (int): random (0) or inference (1) - """ - policy_type = 1 - tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0) - sampled_actions = tf.squeeze(self.target_actor(tf_state)) - # sampled_actions = tf.squeeze(self.actor_model(tf_state)) - noise = self.ou_noise() - sampled_actions_wn = sampled_actions.numpy() + noise - legal_action = np.clip(sampled_actions_wn, self.lower_bound, self.upper_bound) - # legal_action = sampled_actions_wn - # isValid = self.env.action_space.contains(sampled_actions_wn) - # if isValid == False: - # legal_action = np.random.uniform(low=self.lower_bound, high=self.upper_bound, size=(self.num_actions,)) - # policy_type = 0 - # logger.warning('Bad action: {}; Replaced with: {}'.format(sampled_actions_wn, legal_action)) - # logger.warning('Policy action: {}; noise: {}'.format(sampled_actions, noise)) + actor_grad = tape.gradient(actor_loss, self.actor.trainable_variables) + self.actor.optimizer.apply_gradients( + zip(actor_grad, self.actor.trainable_variables) + ) + + for (a, b) in zip(self.target_actor.variables, self.actor.variables): + a.assign(b * self.tau + a * (1 - self.tau)) - return legal_action, policy_type + for (a, b) in zip(self.target_critic.variables, self.critic.variables): + a.assign(b * self.tau + a * (1 - self.tau)) - # For distributed actors # def get_weights(self): """Get weights from target model Returns: weights (list): target model weights """ - return self.target_actor.get_weights() + return self.actor.get_weights() def set_weights(self, weights): """Set model weights @@ -386,53 +187,7 @@ def set_weights(self, weights): Args: weights (list): model weights """ - self.target_actor.set_weights(weights) - - # Extra methods - def update(self): - print("Implement update method in ddpg.py") - - def load(self, filename): - """Load model weights from pickle file - - Args: - filename (string): full path of model file - """ - print("Loading from: ", filename) - layers = self.target_actor.layers - with open(filename, "rb") as f: - pickle_list = pickle.load(f) + self.actor.set_weights(weights) - for layerId in range(len(layers)): - assert layers[layerId].name == pickle_list[layerId][0] - layers[layerId].set_weights(pickle_list[layerId][1]) - - def save(self, filename): - """Save model weights to pickle file - - Args: - filename (string): full path of model file - """ - layers = self.target_actor.layers - pickle_list = [] - for layerId in range(len(layers)): - weigths = layers[layerId].get_weights() - pickle_list.append([layers[layerId].name, weigths]) - - with open(filename, "wb") as f: - pickle.dump(pickle_list, f, -1) - - def monitor(self): - print("Implement monitor method in ddpg.py") - - def set_agent(self): - print("Implement set_agent method in ddpg.py") - - # def print_timers(self): - # print("Implement print_timers method in ddpg.py") - - def epsilon_adj(self): - """Update epsilon value - """ - if self.epsilon > self.epsilon_min: - self.epsilon *= self.epsilon_decay + def train_return(self, args): + pass diff --git a/exarl/agents/agent_vault/ddpg_vtrace.py b/exarl/agents/agent_vault/ddpg_vtrace.py index 262900a2..a58bd14f 100644 --- a/exarl/agents/agent_vault/ddpg_vtrace.py +++ b/exarl/agents/agent_vault/ddpg_vtrace.py @@ -2,18 +2,12 @@ import tensorflow as tf from tensorflow.keras import layers import random -import os -from datetime import datetime import pickle +import exarl +from exarl.utils.globals import ExaGlobals from exarl.utils.OUActionNoise import OUActionNoise from exarl.utils.OUActionNoise import OUActionNoise2 - -import exarl as erl - -from exarl.utils import log -import exarl.utils.candleDriver as cd -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) - +logger = ExaGlobals.setup_logger(__name__) @tf.function def update_target(target_weights, weights, tau): @@ -21,7 +15,7 @@ def update_target(target_weights, weights, tau): a.assign(b * tau + a * (1 - tau)) -class DDPG_Vtrace(erl.ExaAgent): +class DDPG_Vtrace(exarl.ExaAgent): is_learner: bool def __init__(self, env, is_learner): @@ -42,10 +36,10 @@ def __init__(self, env, is_learner): # self.upper_bound = env.action_space.high # self.lower_bound = env.action_space.low - logger.info("Size of State Space: {}".format(self.num_states)) - logger.info("Size of Action Space: {}".format(self.num_actions)) - # logger.info('Env upper bounds: {}'.format(self.upper_bound)) - # logger.info('Env lower bounds: {}'.format(self.lower_bound)) + logger().info("Size of State Space: {}".format(self.num_states)) + logger().info("Size of Action Space: {}".format(self.num_actions)) + # logger().info('Env upper bounds: {}'.format(self.upper_bound)) + # logger().info('Env lower bounds: {}'.format(self.lower_bound)) self.gamma = 0.99 self.tau = 0.005 @@ -164,7 +158,7 @@ def update_grad( critic_loss = tf.math.reduce_mean( tf.math.square(y - curr_state_val)) - logger.warning("Critic loss: {}".format(critic_loss)) + logger().warning("Critic loss: {}".format(critic_loss)) critic_grad = tape.gradient( critic_loss, self.critic_model.trainable_variables) @@ -212,7 +206,7 @@ def update_grad( # critic_value = self.critic_model([state_batch], training=True) # actor_loss = -tf.math.reduce_mean(critic_value) - # logger.warning("Actor loss: {}".format(actor_loss)) + # logger().warning("Actor loss: {}".format(actor_loss)) actor_grad = tape.gradient( actor_loss, self.actor_model.trainable_variables) @@ -268,10 +262,10 @@ def get_critic(self): def generate_data(self): record_range = min(self.buffer_counter, self.buffer_capacity) - logger.info('record_range:{}'.format(record_range)) + logger().info('record_range:{}'.format(record_range)) # Randomly sample indices batch_indices = np.random.choice(record_range, self.batch_size) - logger.info('batch_indices:{}'.format(batch_indices)) + logger().info('batch_indices:{}'.format(batch_indices)) state_batch = tf.convert_to_tensor(self.state_buffer[batch_indices]) action_batch = tf.convert_to_tensor(self.action_buffer[batch_indices]) reward_batch = tf.convert_to_tensor(self.reward_buffer[batch_indices]) @@ -284,12 +278,12 @@ def generate_data(self): def train(self, batch): # self.epsilon_adj() # if len(batch[0]) >= self.batch_size: - # logger.info('Training...') + # logger().info('Training...') if self.is_learner: - logger.warning('Training...') + logger().warning('Training...') self.update_grad(batch[0], batch[1], batch[2], batch[3]) - def target_train(self): + def update_target(self): # Update the target model # if self.buffer_counter >= self.batch_size: @@ -342,13 +336,13 @@ def action(self, state): # legal_action = np.random.uniform(low=self.lower_bound, high=self.upper_bound, size=(self.num_actions,)) legal_action = random.randint(0, self.num_disc_actions - 1) policy_type = 0 - logger.warning( + logger().warning( 'Bad action: {}; Replaced with: {}'.format( sampled_actions_wn, legal_action)) - # logger.warning('Policy action: {}; noise: {}'.format(sampled_actions,noise)) + # logger().warning('Policy action: {}; noise: {}'.format(sampled_actions,noise)) return_action = [np.squeeze(legal_action)] - logger.warning('Legal action:{}'.format(return_action)) + logger().warning('Legal action:{}'.format(return_action)) # ************************** computations for vtrace ****************** # TODO: make a function for this procedure diff --git a/exarl/agents/agent_vault/dqn.py b/exarl/agents/agent_vault/dqn.py index ff04e9a0..aa527aa3 100644 --- a/exarl/agents/agent_vault/dqn.py +++ b/exarl/agents/agent_vault/dqn.py @@ -1,511 +1,273 @@ -# This material was prepared as an account of work sponsored by an agency of the -# United States Government. Neither the United States Government nor the United -# States Department of Energy, nor Battelle, nor any of their employees, nor any -# jurisdiction or organization that has cooperated in the development of these -# materials, makes any warranty, express or implied, or assumes any legal -# liability or responsibility for the accuracy, completeness, or usefulness or -# any information, apparatus, product, software, or process disclosed, or -# represents that its use would not infringe privately owned rights. Reference -# herein to any specific commercial product, process, or service by trade name, -# trademark, manufacturer, or otherwise does not necessarily constitute or imply -# its endorsement, recommendation, or favoring by the United States Government -# or any agency thereof, or Battelle Memorial Institute. The views and opinions -# of authors expressed herein do not necessarily state or reflect those of the -# United States Government or any agency thereof. -# PACIFIC NORTHWEST NATIONAL LABORATORY -# operated by -# BATTELLE -# for the -# UNITED STATES DEPARTMENT OF ENERGY -# under Contract DE-AC05-76RL01830 -import time -import os -import math -import json -import csv -import random -import tensorflow as tf -import sys -import gym -import pickle -import exarl as erl -from exarl.base.comm_base import ExaComm -from tensorflow import keras -from collections import deque -from datetime import datetime import numpy as np -from exarl.agents.agent_vault._prioritized_replay import PrioritizedReplayBuffer -import exarl.utils.candleDriver as cd -from exarl.utils import log +import tensorflow as tf +from gym import spaces +from gym.spaces.utils import flatdim +from copy import deepcopy + +import exarl +from exarl.utils.globals import ExaGlobals +from exarl.agents.replay_buffers.buffer import Buffer +from exarl.agents.models.tf_model import Tensorflow_Model from exarl.utils.introspect import introspectTrace -from tensorflow.compat.v1.keras.backend import set_session - -if ExaComm.num_learners > 1: - import horovod.tensorflow as hvd - multiLearner = True -else: - multiLearner = False - -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) -class LossHistory(keras.callbacks.Callback): - """Loss history for training - """ +logger = ExaGlobals.setup_logger(__name__) - def on_train_begin(self, logs={}): - self.loss = [] - - def on_batch_end(self, batch, logs={}): - self.loss.append(logs.get('loss')) - -# The Multi-Learner Discrete Double Deep Q-Network -class DQN(erl.ExaAgent): - """Multi-Learner Discrete Double Deep Q-Network with Prioritized Experience Replay - """ +class DQN(exarl.ExaAgent): def __init__(self, env, is_learner): - """DQN Constructor - - Args: - env (OpenAI Gym environment object): env object indicates the RL environment - is_learner (bool): Used to indicate if the agent is a learner or an actor - """ - - # Initial values + self.env = env self.is_learner = is_learner - self.model = None - self.target_model = None - self.target_weights = None - self.device = None - self.mirrored_strategy = None + self.observation_space = env.observation_space + self.action_space = env.action_space + assert isinstance(self.action_space, spaces.Discrete), "This agent only supports Discrete: " + type(self.action_space) + + self._num_actions = self.action_space.n + self._discount = ExaGlobals.lookup_params('discount') #0.99 + self._batch_size = ExaGlobals.lookup_params('batch_size') #32 + self._sgd_period = ExaGlobals.lookup_params('sgd_period') #1 + self._target_update_period = ExaGlobals.lookup_params('update_target_frequency') #4 + self._epsilon = ExaGlobals.lookup_params('epsilon') #0.05 + self._min_replay_size = ExaGlobals.lookup_params('min_replay_size') #100 + seed = ExaGlobals.lookup_params('seed') + self._replay = Buffer.create(observation_space=self.observation_space, action_space=self.action_space) + + # JS: We will get fake data for sonnet model and RMA + fake_data = self._replay.get_fake_data(self._batch_size) + fake_data = (self._prep_data(fake_data), -1) + + # JS: Seed tf RNG + tf.random.set_seed(seed) + self._rng = np.random.RandomState(seed) + + self._steps_since_generate_data = 0 + self._step_since_update = 0 + + self._init_model(fake_data) + + # JS: This allows for RMA windows to be set up + self.rma_model = self.get_weights() + # JS: This is setup for Priority Experience Replay + self.rma_train_ret = (np.zeros(shape=(self._batch_size,), dtype=np.float32), [0] * self._batch_size) + self.rma_exp_data = fake_data + + def _init_model(self, fake_data): + network = Tensorflow_Model.create(observation_space=self.observation_space, + action_space=self.action_space, + use_gpu=self.is_learner) + self._online_network = network + + strategy = self._online_network.model.optimizer._distribution_strategy + self._online_network.model.optimizer._distribution_strategy = None + self._target_network = deepcopy(network) + self._online_network.model.optimizer._distribution_strategy = strategy + self._target_network.model.optimizer._distribution_strategy = strategy + + self._forward = tf.function(network) + # JS: This will build the network + self._online_network.model + self._target_network.model + self._optimizer = self._online_network.model.optimizer + # JS: We do this to match sonnet... + self._optimizer.apply = lambda x, y: self._optimizer.apply_gradients(zip(x, y)) + self._forward = tf.function(network) - self.env = env - self.agent_comm = ExaComm.agent_comm - - # MPI - self.rank = self.agent_comm.rank - self.size = self.agent_comm.size - - # Timers - self.training_time = 0 - self.ntraining_time = 0 - self.dataprep_time = 0 - self.ndataprep_time = 0 - - self.enable_xla = True if cd.run_params['xla'] == "True" else False - if self.enable_xla: - # Optimization using XLA (1.1x speedup) - tf.config.optimizer.set_jit(True) - - # Optimization using mixed precision (1.5x speedup) - # Layers use float16 computations and float32 variables - from tensorflow.keras.mixed_precision import experimental as mixed_precision - policy = mixed_precision.Policy('mixed_float16') - mixed_precision.set_policy(policy) - - # dqn intrinsic variables - self.results_dir = cd.run_params['output_dir'] - self.gamma = cd.run_params['gamma'] - self.epsilon = cd.run_params['epsilon'] - self.epsilon_min = cd.run_params['epsilon_min'] - self.epsilon_decay = cd.run_params['epsilon_decay'] - self.learning_rate = cd.run_params['learning_rate'] - self.batch_size = cd.run_params['batch_size'] - self.tau = cd.run_params['tau'] - self.model_type = cd.run_params['model_type'] - - if self.model_type == 'MLP': - # for mlp - self.dense = cd.run_params['dense'] - - if self.model_type == 'LSTM': - # for lstm - self.lstm_layers = cd.run_params['lstm_layers'] - self.gauss_noise = cd.run_params['gauss_noise'] - self.regularizer = cd.run_params['regularizer'] - self.clipnorm = cd.run_params['clipnorm'] - self.clipvalue = cd.run_params['clipvalue'] - - # for both - self.activation = cd.run_params['activation'] - self.out_activation = cd.run_params['out_activation'] - self.optimizer = cd.run_params['optimizer'] - self.loss = cd.run_params['loss'] - self.n_actions = cd.run_params['nactions'] - self.priority_scale = cd.run_params['priority_scale'] - - # Check if the action space is discrete - self.is_discrete = (type(env.action_space) == gym.spaces.discrete.Discrete) - # If continuous, discretize the action space - # TODO: Incorpoorate Ai's class - if not self.is_discrete: - env.action_space.n = self.n_actions - self.actions = np.linspace(env.action_space.low, env.action_space.high, self.n_actions) - - # Data types of action and observation space - self.dtype_action = np.array(self.env.action_space.sample()).dtype - self.dtype_observation = self.env.observation_space.sample().dtype - - # Setup GPU cfg - if ExaComm.is_learner(): - logger.info("Setting GPU rank", self.rank) - config = tf.compat.v1.ConfigProto(device_count={'GPU': 1, 'CPU': 1}) - else: - logger.info("Setting no GPU rank", self.rank) - config = tf.compat.v1.ConfigProto(device_count={'GPU': 0, 'CPU': 1}) - # Get which device to run on - self.device = self._get_device() - - config.gpu_options.allow_growth = True - sess = tf.compat.v1.Session(config=config) - tf.compat.v1.keras.backend.set_session(sess) - - # Build network model - if self.is_learner: - with tf.device(self.device): - self.model = self._build_model() - self.model.compile(loss=self.loss, optimizer=self.optimizer) - self.model.summary() - # self.mirrored_strategy = tf.distribute.MirroredStrategy() - # logger.info("Using learner strategy: {}".format(self.mirrored_strategy)) - # with self.mirrored_strategy.scope(): - # self.model = self._build_model() - # self.model._name = "learner" - # self.model.compile(loss=self.loss, optimizer=self.optimizer) - # logger.info("Active model: \n".format(self.model.summary())) - else: - self.model = None - with tf.device('/CPU:0'): - self.target_model = self._build_model() - self.target_model._name = "target_model" - self.target_model.compile(loss=self.loss, optimizer=self.optimizer) - # self.target_model.summary() - self.target_weights = self.target_model.get_weights() - - if multiLearner and ExaComm.is_learner(): - hvd.init(comm=ExaComm.learner_comm.raw()) - self.first_batch = 1 - # TODO: Update candle driver to include different losses and optimizers - # Default reduction is tf.keras.losses.Reduction.AUTO which errors out with distributed training - # self.loss_fn = tf.keras.losses.MeanSquaredError(reduction=tf.keras.losses.Reduction.NONE) - self.loss_fn = cd.candle.build_loss(self.loss, cd.kerasDefaults, reduction='none') - # self.opt = tf.keras.optimizers.Adam(self.learning_rate * hvd.size()) - self.opt = cd.candle.build_optimizer(self.optimizer, self.learning_rate * hvd.size(), cd.kerasDefaults) - - self.maxlen = cd.run_params['mem_length'] - self.replay_buffer = PrioritizedReplayBuffer(maxlen=self.maxlen) - - def _get_device(self): - """Get device type (CPU/GPU) - - Returns: - string: device type + def get_weights(self): """ - cpus = tf.config.experimental.list_physical_devices('CPU') - gpus = tf.config.experimental.list_physical_devices('GPU') - ngpus = len(gpus) - logger.info('Number of available GPUs: {}'.format(ngpus)) - if ngpus > 0: - gpu_id = self.rank % ngpus - return '/GPU:{}'.format(gpu_id) - else: - return '/CPU:0' + Get weights from target model - def _build_model(self): - """Build NN model based on parameters provided in the config file - - Returns: - [type]: [description] + Returns + ------- + list : + Target model weights """ - if self.model_type == 'MLP': - from exarl.agents.agent_vault._build_mlp import build_model - return build_model(self) - elif self.model_type == 'LSTM': - from exarl.agents.agent_vault._build_lstm import build_model - return build_model(self) - else: - sys.exit("Oops! That was not a valid model type. Try again...") + return self._online_network.get_weights(), self._target_network.get_weights() - # TODO: Check if this is used in any workflow, if not delete - def set_learner(self): - logger.debug( - "Agent[{}] - Creating active model for the learner".format(self.rank) - ) - - def remember(self, state, action, reward, next_state, done): - """Add experience to replay buffer - - Args: - state (list or array): Current state of the system - action (list or array): Action to take - reward (list or array): Environment reward - next_state (list or array): Next state of the system - done (bool): Indicates episode completion + def set_weights(self, weights): """ - lost_data = self.replay_buffer.add((state, action, reward, next_state, done)) - if lost_data and self.priority_scale: - # logger.warning("Priority replay buffer size too small. Data loss negates replay effect!") - print("Priority replay buffer size too small. Data loss negates replay effect!", flush=True) - - def get_action(self, state): - """Use epsilon-greedy approach to generate actions + Set model weights - Args: - state (list or array): Current state of the system - - Returns: - (list or array): Action to take + Parameters + ---------- + weights : list + Model weights """ - random.seed(datetime.now()) - random_data = os.urandom(4) - np.random.seed(int.from_bytes(random_data, byteorder="big")) - rdm = np.random.rand() - if rdm <= self.epsilon: - self.epsilon_adj() - action = random.randrange(self.env.action_space.n) - return action, 0 - else: - np_state = np.array(state).reshape(1, 1, len(state)) - with tf.device(self.device): - act_values = self.target_model.predict(np_state) - action = np.argmax(act_values[0]) - return action, 1 + online_weights, target_weights = weights + self._online_network.set_weights(online_weights) + self._target_network.set_weights(target_weights) - @introspectTrace() def action(self, state): - """Discretizes 1D continuous actions to work with DQN - - Args: - state (list or array): Current state of the system - - Returns: - action (list or array): Action to take - policy (int): random (0) or inference (1) - """ - action, policy = self.get_action(state) - if not self.is_discrete: - action = [self.actions[action]] - return action, policy + # JS: Epsilon-greedy policy. + if self._rng.rand() < self._epsilon: + action = self.action_space.sample() + return action, 0 - @introspectTrace() - def calc_target_f(self, exp): - """Bellman equation calculations + observation = tf.convert_to_tensor(state[None, ...]) + q_values = self._forward(observation) - Args: - exp (list of experience): contains state, action, reward, next state, done + q_values = q_values.numpy() + action = self._rng.choice(np.flatnonzero(q_values == q_values.max())) + return int(action), 0 - Returns: - target Q value (array): [description] - """ - state, action, reward, next_state, done = exp - np_state = np.array(state, dtype=self.dtype_observation).reshape(1, 1, len(state)) - np_next_state = np.array(next_state, dtype=self.dtype_observation).reshape(1, 1, len(next_state)) - expectedQ = 0 - if not done: - with tf.device(self.device): - expectedQ = self.gamma * np.amax(self.target_model.predict(np_next_state)[0]) - target = reward + expectedQ - with tf.device(self.device): - target_f = self.target_model.predict(np_state) - # For handling continuous to discrete actions - action_idx = action if self.is_discrete else np.where(self.actions == action)[1] - target_f[0][action_idx] = target - return target_f[0] + def remember(self, state, action, reward, next_state, done): + # JS: discount = 0.0 if done else 1.0 + self._replay.store(state, action, reward, next_state, done) + self._steps_since_generate_data += 1 def has_data(self): - """Indicates if the buffer has data of size batch_size or more + return self._replay.size >= self._min_replay_size - Returns: - bool: True if replay_buffer length >= self.batch_size - """ - return (self.replay_buffer.get_buffer_length() >= self.batch_size) - - @introspectTrace() + def _prep_data(self, data): + # JS: This is for the train step which requires "discount" + data[4] = np.logical_not(data[4]).astype(float) + return data + def generate_data(self): - """Unpack and yield training data - - Yields: - batch_states (numpy array): training input - batch_target (numpy array): training labels - With PER: - indices (numpy array): data indices - importance (numpy array): importance weights - """ - # Has data checks if the buffer is greater than batch size for training - if not self.has_data(): - # Worker method to create samples for training - batch_states = np.zeros((self.batch_size, 1, self.env.observation_space.shape[0]), dtype=self.dtype_observation) - batch_target = np.zeros((self.batch_size, self.env.action_space.n), dtype=self.dtype_action) - indices = -1 * np.ones(self.batch_size) - importance = np.ones(self.batch_size) - else: - minibatch, importance, indices = self.replay_buffer.sample(self.batch_size, priority_scale=self.priority_scale) - batch_target = list(map(self.calc_target_f, minibatch)) - batch_states = [np.array(exp[0], dtype=self.dtype_observation).reshape(1, 1, len(exp[0]))[0] for exp in minibatch] - batch_states = np.reshape(batch_states, [len(minibatch), 1, len(minibatch[0][0])]) - batch_target = np.reshape(batch_target, [len(minibatch), self.env.action_space.n]) - - if self.priority_scale > 0: - yield batch_states, batch_target, indices, importance + if self.has_data(): + data = self._replay.sample(self._batch_size) + ret = (self._prep_data(data), self._steps_since_generate_data) + self._steps_since_generate_data = 0 else: - yield batch_states, batch_target + ret = (None, -1) + yield ret - @introspectTrace() def train(self, batch): - """Train the NN + data, steps = batch + # JS: we set the steps to -1 for fake data + if steps > 0: + update = False + self._step_since_update += steps + if self._step_since_update >= self._target_update_period: + update = True + self._step_since_update = 0 + td_error = self._training_step(data[:5], update) + # JS: We are using prioritized replay + if len(data) == 6: + return td_error.numpy(), data[5] - Args: - batch (list): sampled batch of experiences + @tf.function + def _training_step(self, data, update): + # JS: Consider where we prep data + observations, actions, rewards, next_observations, discounts = data + rewards = tf.cast(rewards, tf.float32) + discounts = tf.cast(discounts, tf.float32) + observations = tf.convert_to_tensor(observations) + next_observations = tf.convert_to_tensor(next_observations) - Returns: - if PER: - indices (numpy array): data indices - loss: training loss - else: - None - """ - ret = None - if self.is_learner: - start_time = time.time() - with tf.device(self.device): - if self.priority_scale > 0: - if multiLearner: - loss = self.training_step(batch) - else: - loss = LossHistory() - sample_weight = batch[3] ** (1 - self.epsilon) - self.model.fit(batch[0], batch[1], epochs=1, batch_size=1, verbose=0, callbacks=loss, sample_weight=sample_weight) - loss = loss.loss - ret = batch[2], loss - else: - if multiLearner: - loss = self.training_step(batch) - else: - self.model.fit(batch[0], batch[1], epochs=1, verbose=0) - end_time = time.time() - self.training_time += (end_time - start_time) - self.ntraining_time += 1 - logger.info('Agent[{}]- Training: {} '.format(self.rank, (end_time - start_time))) - start_time_episode = time.time() - logger.info('Agent[%s] - Target update time: %s ' % (str(self.rank), str(time.time() - start_time_episode))) - else: - logger.warning('Training will not be done because this instance is not set to learn.') - return ret + with tf.GradientTape() as tape: + q_tm1 = self._online_network(observations) + q_t = self._target_network(next_observations) - @tf.function - def training_step(self, batch): - """ Training step for multi-learner using Horovod + onehot_actions = tf.one_hot(actions, depth=self._num_actions) + qa_tm1 = tf.reduce_sum(q_tm1 * onehot_actions, axis=-1) + qa_t = tf.reduce_max(q_t, axis=-1) - Args: - batch (list): sampled batch of experiences + # One-step Q-learning loss. + target = rewards + discounts * self._discount * qa_t + td_error = qa_tm1 - target + loss = 0.5 * tf.reduce_mean(td_error ** 2) - Returns: - loss_value: loss value per training step for multi-learner - """ - with tf.GradientTape() as tape: - probs = self.model(batch[0], training=True) - if len(batch) > 2: - sample_weight = batch[3] * (1 - self.epsilon) - else: - sample_weight = np.ones(len(batch[0])) - loss_value = self.loss_fn(batch[1], probs, sample_weight=sample_weight) - - # Horovod distributed gradient tape - tape = hvd.DistributedGradientTape(tape) - grads = tape.gradient(loss_value, self.model.trainable_variables) - self.opt.apply_gradients(zip(grads, self.model.trainable_variables)) - - if self.first_batch: - hvd.broadcast_variables(self.model.variables, root_rank=0) - hvd.broadcast_variables(self.opt.variables(), root_rank=0) - self.first_batch = 0 - return loss_value - - def set_priorities(self, indices, loss): - """ Set priorities for training data - - Args: - indices (array): data indices - loss (array): Losses - """ - self.replay_buffer.set_priorities(indices, loss) + # Update the online network via SGD. + variables = self._online_network.trainable_variables + gradients = tape.gradient(loss, variables) + self._optimizer.apply(gradients, variables) - def get_weights(self): - """Get weights from target model + # Update target network + if update: + for target, param in zip(self._target_network.trainable_variables, self._online_network.trainable_variables): + target.assign(param) + return td_error - Returns: - weights (list): target model weights - """ - logger.debug("Agent[%s] - get target weight." % str(self.rank)) - return self.target_model.get_weights() + def train_return(self, args): + # JS: This will only be called with Prioratized Replay + self._replay.update_priorities(*args) - def set_weights(self, weights): - """Set model weights +class DQN_v1(DQN): - Args: - weights (list): model weights - """ - logger.info("Agent[%s] - set target weight." % str(self.rank)) - logger.debug("Agent[%s] - set target weight: %s" % (str(self.rank), weights)) - with tf.device(self.device): - self.target_model.set_weights(weights) - - @introspectTrace() - def target_train(self): - """Update target model - """ - if self.is_learner: - logger.info("Agent[%s] - update target weights." % str(self.rank)) - with tf.device(self.device): - model_weights = self.model.get_weights() - target_weights = self.target_model.get_weights() - for i in range(len(target_weights)): - target_weights[i] = ( - self.tau * model_weights[i] + (1 - self.tau) * target_weights[i] - ) - self.set_weights(target_weights) + def __init__(self, env, is_learner): + assert ExaGlobals.lookup_params('workflow') != 'sync' + super(DQN_v1, self).__init__(env, is_learner) + # JS: This gets the max size of the simple buffer + batch_episode_frequency = ExaGlobals.lookup_params('batch_episode_frequency') + batch_step_frequency = ExaGlobals.lookup_params('batch_step_frequency') + steps = ExaGlobals.lookup_params('n_steps') + if batch_episode_frequency > 1: + capacity = batch_episode_frequency * steps else: - logger.warning( - "Weights will not be updated because this instance is not set to learn." - ) - - def epsilon_adj(self): - """Update epsilon value - """ - if self.epsilon > self.epsilon_min: - self.epsilon *= self.epsilon_decay + if batch_step_frequency == -1: + batch_step_frequency = steps + capacity = batch_episode_frequency + + if not is_learner: + # JS: We create simple buffer for non-learners. + # They will just send all exps each time to the learner + self._replay = Buffer.create("SimpleBuffer", capacity=capacity, observation_space=self.observation_space, action_space=self.action_space) + + # JS: This fake data should convert bool to float + fake_data = self._replay.get_fake_data(capacity) + self.rma_exp_data = fake_data + + def has_data(self): + return self._replay.size > 0 - def load(self, filename): - """Load model weights from pickle file + def generate_data(self): + if self.has_data(): + data = self._replay.sample(self._batch_size) + ret = (data, self._steps_since_generate_data) + self._steps_since_generate_data = 0 + else: + ret = (None, -1) + yield ret - Args: - filename (string): full path of model file - """ - layers = self.target_model.layers - with open(filename, 'rb') as f: - pickle_list = pickle.load(f) + def train(self, batch): + data, steps = batch + # JS: we set the steps to -1 for fake data + if steps > 0: + # JS: Store data to the central buffer + self._replay.bulk_store(data) + if self._replay.size >= self._min_replay_size: + # JS: Now we sample and reformat discount + data = self._replay.sample(self._batch_size) + batch = (self._prep_data(data), steps) + # JS: Now we just call super! + super().train(batch) + +class DQN_v2(DQN): - for layerId in range(len(layers)): - # assert(layers[layerId].name == pickle_list[layerId][0]) - layers[layerId].set_weights(pickle_list[layerId][1]) + def __init__(self, env, is_learner): + self._batch_size = ExaGlobals.lookup_params('batch_size') + self._trajectory_length = ExaGlobals.lookup_params('trajectory_length') + assert ExaGlobals.lookup_params('model_type') == 'LSTM' + assert ExaGlobals.lookup_params('buffer') == 'TrajectoryBuffer' + assert ExaGlobals.lookup_params('buffer_trajectory_length') == self._trajectory_length + self._dims = (self._batch_size, self._trajectory_length, flatdim(env.observation_space)) + super(DQN_v2, self).__init__(env, is_learner) + self._local = Buffer.create(capacity=self._trajectory_length, observation_space=self.observation_space, action_space=self.action_space) + + def _prep_data(self, data): + data[0] = data[0].reshape(self._dims) + data[1] = data[1][self._dims[1]-1::self._dims[1]] + data[2] = data[2][self._dims[1]-1::self._dims[1]] + data[3] = data[3].reshape(self._dims) + data[4] = data[4][self._dims[1]-1::self._dims[1]] + data[4] = np.logical_not(data[4]).astype(float) + return data - def save(self, filename): - """Save model weights to pickle file + def remember(self, state, action, reward, next_state, done): + self._local.store(state, action, reward, next_state, done) + super().remember(state, action, reward, next_state, done) - Args: - filename (string): full path of model file - """ - layers = self.target_model.layers - pickle_list = [] - for layerId in range(len(layers)): - weigths = layers[layerId].get_weights() - pickle_list.append([layers[layerId].name, weigths]) + def action(self, state): + # JS: Epsilon-greedy policy. + if self._rng.rand() < self._epsilon: + action = self.action_space.sample() + return action, 0 - with open(filename, 'wb') as f: - pickle.dump(pickle_list, f, -1) + # JS: This is the part that is different! + observation = self._local.last()[0][None, ...] - def update(self): - logger.info("Implement update method in dqn.py") + observation = tf.convert_to_tensor(observation) + q_values = self._forward(observation) - def monitor(self): - logger.info("Implement monitor method in dqn.py") + q_values = q_values.numpy() + action = self._rng.choice(np.flatnonzero(q_values == q_values.max())) + return int(action), 0 diff --git a/exarl/agents/agent_vault/exa_a2c.py b/exarl/agents/agent_vault/exa_a2c.py new file mode 100644 index 00000000..e39ddf70 --- /dev/null +++ b/exarl/agents/agent_vault/exa_a2c.py @@ -0,0 +1,200 @@ +import time +import os +import math +import json +import csv +import random +import tensorflow as tf +import sys +import pickle +import exarl as erl +from datetime import datetime +import numpy as np +import exarl.utils.candleDriver as cd + + +class A2C(erl.ExaAgent): + + def __init__(self, env, is_learner): + + self.is_learner = False + + self.num_states = env.observation_space.shape[0] + self.num_actions = env.action_space.n + + # Constants used by agent + self.gamma = cd.run_params['gamma'] + self.e_const = cd.run_params['entropy_constant'] + self.v_const = cd.run_params['value_constant'] + + self.state_memory, self.reward_memory, self.action_memory = [], [], [] + # Constants not used by agent, but needed for Learner class + self.epsilon = cd.run_params['epsilon'] + self.epsilon_min = cd.run_params['epsilon_min'] + self.epsilon_decay = cd.run_params['epsilon_decay'] + + # Actor and Critic network parameters + self.actor_dense = cd.run_params['actor_dense'] + self.actor_dense_activation = cd.run_params['actor_dense_activation'] + self.actor_dense_kinit = cd.run_params['actor_dense_kernel_initializer'] + self.actor_lr = cd.run_params['actor_learning_rate'] + self.actor_optimizer = tf.keras.optimizers.RMSprop(self.actor_lr) + + self.critic_dense = cd.run_params['critic_dense'] + self.critic_dense_activation = cd.run_params['critic_dense_activation'] + self.critic_dense_kinit = cd.run_params['critic_dense_kernel_initializer'] + self.critic_lr = cd.run_params['critic_learning_rate'] + self.critic_optimizer = tf.keras.optimizers.RMSprop(self.critic_lr) + + # Setup TF configuration to allow memory growth + config = tf.compat.v1.ConfigProto() + config.gpu_options.allow_growth = True + sess = tf.compat.v1.Session(config=config) + tf.compat.v1.keras.backend.set_session(sess) + + # Training model only required by the learners + self.actor = None + self.critic = None + + if self.is_learner: + self.actor = Actor(self.num_actions, self.actor_dense, self.actor_dense_activation, self.actor_dense_kinit) + self.critic = Critic(self.critic_dense, self.critic_dense_activation, self.critic_dense_kinit) + else: + with tf.device('/CPU:0'): + self.actor = Actor(self.num_actions, self.actor_dense, self.actor_dense_activation, self.actor_dense_kinit) + + def action(self, state): + prob = self.actor(np.array([state])) + prob = prob.numpy() + dist = tf.compat.v1.distributions.Categorical(probs=prob, dtype=tf.float32) + action = dist.sample() + return int(action.numpy()[0]), 1 + + def remember(self, state, action, reward, next_state, done): + self.state_memory.append(state) + self.action_memory.append(action) + self.reward_memory.append(reward) + + def generate_data(self): + return [self.state_memory, self.action_memory, self.reward_memory] + + def train(self, batch): + if self.is_learner: + logger.warning('Training...') + self.update_grad(batch[0], batch[1], batch[2]) + + def update_grad(self, state, action, reward): + discount_rewards = [] + sum_rewards = 0.0 + reward.reverse() + + for r in reward: + sum_rewards = r + self.gamma * sum_rewards + discount_rewards.append(sum_rewards) + + discount_rewards.reverse() + discount_rewards = tf.reshape(discount_rewards, (len(discount_rewards),)) + states = np.array(state, dtype=np.float32) + actions = np.array(action, dtype=np.float32) + + with tf.GradientTape() as tape1, tf.GradientTape() as tape2: + p = self.actor(states, training=True) + v = self.critic(states, training=True) + v = tf.reshape(v, (len(v),)) + TDerror = tf.math.subtract(discount_rewards, v) + + a_loss = self.actor_loss(p, actions, TDerror) + c_loss = self.v_const * tf.keras.losses.mean_squared_error(discount_rewards, v) + + grads1 = tape1.gradient(a_loss, self.actor.trainable_variables) + grads2 = tape2.gradient(c_loss, self.critic.trainable_variables) + + self.actor_optimizer.apply_gradients(zip(grads1, self.actor.trainable_variables)) + self.critic_optimizer.apply_gradients(zip(grads2, self.critic.trainable_variables)) + + def actor_loss(self, probs, actions, TDerror): + probability = [] + log_probability = [] + + for pb, act in zip(probs, actions): + dist = tf.compat.v1.distributions.Categorical(probs=pb, dtype=tf.float32) + probability.append(dist.prob(act)) + log_probability.append(dist.log_prob(act)) + + p_loss = [] + e_loss = [] + TDerror = TDerror.numpy() + + for pb, t, lpb in zip(probability, TDerror, log_probability): + t = tf.constant(t) + policy_loss = tf.math.multiply(lpb, t) + entropy_loss = tf.math.negative(tf.math.multiply(pb, lpb)) + p_loss.append(policy_loss) + e_loss.append(entropy_loss) + + p_loss = tf.reduce_mean(tf.stack(p_loss)) + e_loss = tf.reduce_mean(tf.stack(e_loss)) + + return -p_loss - self.e_const * e_loss + + def target_train(self): + pass + + def reset_lists(self): + self.state_memory, self.reward_memory, self.action_memory = [], [], [] + + def set_learner(self): + self.is_learner = True + self.actor = Actor(self.num_actions, self.actor_dense, self.actor_dense_activation, self.actor_dense_kinit) + self.critic = Critic(self.critic_dense, self.critic_dense_activation, self.critic_dense_kinit) + + def get_weights(self): + return self.actor.get_weights() + + def set_weights(self, weights): + self.actor.set_weights(weights) + + def load(self, filename): + layers = self.actor.layers + with open(filename, "rb") as f: + pickle_list = pickle.load(f) + + for layerId in range(len(layers)): + assert layers[layerId].name == pickle_list[layerId][0] + layers[layerId].set_weights(pickle_list[layerId][1]) + + def save(self, filename): + layers = self.actor.layers + pickle_list = [] + for layerId in range(len(layers)): + weigths = layers[layerId].get_weights() + pickle_list.append([layers[layerId].name, weigths]) + + with open(filename, "wb") as f: + pickle.dump(pickle_list, f, -1) + + def epsilon_adj(self): + if self.epsilon > self.epsilon_min: + self.epsilon *= self.epsilon_decay + +class Actor(tf.keras.Model): + + def __init__(self, nactions, ndense, act, kinit): + super().__init__() + self.d1 = tf.keras.layers.Dense(ndense, activation=act, kernel_initializer=kinit) + self.a = tf.keras.layers.Dense(nactions, activation='softmax') + + def call(self, input_data): + x = self.d1(input_data) + return self.a(x) + +class Critic(tf.keras.Model): + + def __init__(self, ndense, act, kinit): + super().__init__() + self.d1 = tf.keras.layers.Dense(ndense, activation=act, kernel_initializer=kinit) + self.v = tf.keras.layers.Dense(1, activation=None) + + def call(self, input_data): + x = self.d1(input_data) + return self.v(x) \ No newline at end of file diff --git a/exarl/agents/agent_vault/keras_sac.py b/exarl/agents/agent_vault/keras_sac.py new file mode 100644 index 00000000..54c1672f --- /dev/null +++ b/exarl/agents/agent_vault/keras_sac.py @@ -0,0 +1,358 @@ +# Copyright (c) 2020, Jefferson Science Associates, LLC. All Rights Reserved. Redistribution +# and use in source and binary forms, with or without modification, are permitted as a +# licensed user provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, this +# list of conditions and the following disclaimer in the documentation and/or other +# materials provided with the distribution. +# 3. The name of the author may not be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# This material resulted from work developed under a United States Government Contract. +# The Government retains a paid-up, nonexclusive, irrevocable worldwide license in such +# copyrighted data to reproduce, distribute copies to the public, prepare derivative works, +# perform publicly and display publicly and to permit others to do so. +# +# THIS SOFTWARE IS PROVIDED BY JEFFERSON SCIENCE ASSOCIATES LLC "AS IS" AND ANY EXPRESS +# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL +# JEFFERSON SCIENCE ASSOCIATES, LLC OR THE U.S. GOVERNMENT BE LIABLE TO LICENSEE OR ANY +# THIRD PARTES FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +import numpy as np +import tensorflow as tf +import tensorflow_probability as tfp +from tensorflow.keras.initializers import RandomUniform +from tensorflow.keras.optimizers import Adam + +import exarl +from exarl.utils.globals import ExaGlobals +from exarl.agents.replay_buffers.replay_buffer import ReplayBuffer +logger = ExaGlobals.setup_logger(__name__) + +from exarl.agents.models.tf_model import Tensorflow_Model +from copy import deepcopy + +class SAC(exarl.ExaAgent): + + def __init__(self, env, is_learner, **kwargs): + """ Define all key variables required for all agent """ + + self.is_learner = is_learner + # Get env info + super().__init__(**kwargs) + self.env = env + + self.num_states = env.observation_space.shape[0] + self.num_actions = env.action_space.shape[0] + self.upper_bound = env.action_space.high + self.lower_bound = env.action_space.low + print('upper_bound: ', self.upper_bound) + print('lower_bound: ', self.lower_bound) + + # Buffer + self.buffer_counter = 0 + self.buffer_capacity = ExaGlobals.lookup_params('buffer_capacity') + self.batch_size = ExaGlobals.lookup_params('batch_size') + self.memory = ReplayBuffer(self.buffer_capacity, env.observation_space, env.action_space) + self.per_buffer = np.ones((self.buffer_capacity, 1)) + + # Used to update target networks + self.tau = ExaGlobals.lookup_params('tau') + self.gamma = ExaGlobals.lookup_params('gamma') + self.alpha = ExaGlobals.lookup_params('sac_alpha') + + + # Setup Optimizers + critic_lr = ExaGlobals.lookup_params('critic_lr') + actor_lr = ExaGlobals.lookup_params('actor_lr') + self.critic_optimizer1 = Adam(critic_lr, epsilon=1e-08) + self.critic_optimizer2 = Adam(critic_lr, epsilon=1e-08) + self.actor_optimizer = Adam(actor_lr, epsilon=1e-08) + + self.hidden_size = 56 + self.layer_std = 1.0 / np.sqrt(float(self.hidden_size)) + + # # Setup models + self.actor = Tensorflow_Model.create("SoftActor", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.critic1 = Tensorflow_Model.create("SoftCritic", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.critic2 = Tensorflow_Model.create("SoftCritic", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.target_actor = deepcopy(self.actor) + self.target_critic1 = deepcopy(self.critic1) + self.target_critic2 = deepcopy(self.critic2) + + self.actor.init_model() + self.critic1.init_model() + self.critic2.init_model() + self.actor.print() + self.critic1.print() + self.target_actor.init_model() + self.target_critic1.init_model() + self.target_critic2.init_model() + + self.target_actor.set_weights(self.actor.get_weights()) + self.target_critic1.set_weights(self.critic1.get_weights()) + self.target_critic2.set_weights(self.critic2.get_weights()) + + + # update counting + self.ntrain_calls = 0 + self.actor_update_freq = 2 + self.critic_update_freq = 1 + self.target_update_freq = 2 + + # Not used by agent but required by the learner class + # self.epsilon = ExaGlobals.lookup_params('epsilon') + # self.epsilon_min = ExaGlobals.lookup_params('epsilon_min') + # self.epsilon_decay = ExaGlobals.lookup_params('epsilon_decay') + + logger().info("TD3 buffer capacity {}".format(self.buffer_capacity)) + logger().info("TD3 batch size {}".format(self.batch_size)) + logger().info("TD3 tau {}".format(self.tau)) + logger().info("TD3 gamma {}".format(self.gamma)) + logger().info("TD3 critic_lr {}".format(critic_lr)) + logger().info("TD3 actor_lr {}".format(actor_lr)) + + @tf.function + def train_critic(self, states, actions, rewards, next_states, dones): + # next_actions, _ = self.action(next_states, use_target=True) + + sampled_means, sampled_sds = self.actor(next_states) + # dist = tfp.distributions.Normal(sampled_means, sampled_sds) + dist = tfp.distributions.TruncatedNormal(sampled_means, sampled_sds, self.lower_bound, self.upper_bound) + next_actions = dist.sample() + # next_actions = tf.clip_by_value(next_actions, self.lower_bound, self.upper_bound) + # tf.print("Means: ", sampled_means) + # tf.print("SDs: ", sampled_sds) + next_lp = tf.reduce_sum(dist.log_prob(next_actions), axis=1) + # tf.print("Next Actions: ", next_actions) + # tf.print("Log Prob: ", next_lp) + + # Add a little noise + new_q1 = self.target_critic1([next_states, next_actions], training=False) + new_q2 = self.target_critic2([next_states, next_actions], training=False) + new_q = tf.math.minimum(new_q1, new_q2) + # Bellman equation for the q value + # tf.print("SHAPES: ", states.shape, actions.shape, rewards.shape, new_q.shape, next_lp.shape) + # tf.print("Rewards: ", rewards) + q_targets = rewards + (1.0 - dones[:,None]) * self.gamma * (new_q - self.alpha * next_lp) + # Critic 1 + with tf.GradientTape() as tape: + q_values1 = self.critic1([states, actions], training=True) + td_errors1 = q_values1 - q_targets + critic_loss1 = tf.reduce_mean(tf.math.square(td_errors1)) + # tf.print("Critic 1 Loss: ", critic_loss1) + gradient1 = tape.gradient(critic_loss1, self.critic1.trainable_variables) + self.critic1.optimizer.apply_gradients(zip(gradient1, self.critic1.trainable_variables)) + + # Critic 2 + with tf.GradientTape() as tape: + q_values2 = self.critic2([states, actions], training=True) + td_errors2 = q_values2 - q_targets + critic_loss2 = tf.reduce_mean(tf.math.square(td_errors2)) + # tf.print("Critic 2 Loss: ", critic_loss2) + gradient2 = tape.gradient(critic_loss2, self.critic2.trainable_variables) + self.critic2.optimizer.apply_gradients(zip(gradient2, self.critic2.trainable_variables)) + + @tf.function + def train_actor(self, states): + # Use Critic 1 + with tf.GradientTape() as tape: + sampled_means, sampled_sds = self.actor(states) + dist = tfp.distributions.TruncatedNormal(sampled_means, sampled_sds, self.lower_bound, self.upper_bound) + # dist = tfp.distributions.Normal(sampled_means, sampled_sds) + actions = dist.sample() + # actions = tf.clip_by_value(actions, self.lower_bound, self.upper_bound) + action_lp = tf.reduce_sum(dist.log_prob(actions), axis=1) + q_value = self.critic1([states, actions], training=True) + loss = -tf.math.reduce_mean(q_value - self.alpha * action_lp) + # tf.print("Actor Loss: ", loss) + gradient = tape.gradient(loss, self.actor.trainable_variables) + self.actor.optimizer.apply_gradients(zip(gradient, self.actor.trainable_variables)) + + @tf.function + def soft_update(self, target_weights, weights): + for (target_weight, weight) in zip(target_weights, weights): + target_weight.assign(weight * self.tau + target_weight * (1.0 - self.tau)) + + def update(self, state_batch, action_batch, reward_batch, next_state_batch, done_batch): + if self.ntrain_calls % self.critic_update_freq == 0: + self.train_critic(state_batch, action_batch, reward_batch, next_state_batch, done_batch) + if self.ntrain_calls % self.actor_update_freq == 0: + self.train_actor(state_batch) + + def _convert_to_tensor(self, state_batch, action_batch, reward_batch, next_state_batch, terminal_batch): + state_batch = tf.convert_to_tensor(state_batch, dtype=tf.float32) + action_batch = tf.convert_to_tensor(action_batch, dtype=tf.float32) + reward_batch = tf.convert_to_tensor(reward_batch, dtype=tf.float32) + next_state_batch = tf.convert_to_tensor(next_state_batch, dtype=tf.float32) + terminal_batch = tf.convert_to_tensor(terminal_batch, dtype=tf.float32) + return state_batch, action_batch, reward_batch, next_state_batch, terminal_batch + + def generate_data(self): + state_batch, action_batch, reward_batch, next_state_batch, done_batch = \ + self._convert_to_tensor(*self.memory.sample(self.batch_size)) + yield state_batch, action_batch, reward_batch, next_state_batch, done_batch + + def train(self, batch): + """ Method used to train """ + self.ntrain_calls += 1 + self.update(batch[0], batch[1], batch[2], batch[3], batch[4]) + self.update_target() + + def update_target(self): + if self.ntrain_calls % self.target_update_freq == 0: + self.soft_update(self.target_actor.variables, self.actor.variables) + self.soft_update(self.target_critic1.variables, self.critic1.variables) + self.soft_update(self.target_critic2.variables, self.critic2.variables) + + def action(self, state, use_target=False): + """ Method used to provide the next action using the target model """ + tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0) + if use_target: + sampled_means, sampled_sds = tf.squeeze(self.target_actor(tf_state)) + else: + sampled_means, sampled_sds = tf.squeeze(self.actor(tf_state)) + dist = tfp.distributions.TruncatedNormal(sampled_means, sampled_sds, self.lower_bound, self.upper_bound) + # dist = tfp.distributions.Normal(sampled_means, sampled_sds) + sampled_actions = dist.sample() + + # sampled_actions = sampled_means + sampled_sds * np.random.normal(0, 1.0, sampled_means.shape) + policy_type = 1 + + # We make sure action is within bounds + legal_action = np.clip(sampled_actions, self.lower_bound, self.upper_bound) + # log_p = dist.log_prob(legal_action) + + return legal_action, policy_type + + def remember(self, state, action, reward, next_state, done): + self.memory.store(state, action, reward, next_state, done) + + def has_data(self): + """return true if agent has experiences from simulation + """ + return (self.memory._mem_length > 0) + + # For distributed actors # + def get_weights(self): + return self.target_actor.get_weights() + + def set_weights(self, weights): + self.target_actor.set_weights(weights) + + def train_return(self, args): + pass + + +class SAC_squash(SAC): + def __init__(self, env, is_learner, **kwargs): + """ Define all key variables required for all agent """ + + self.is_learner = is_learner + # Get env info + super().__init__(env, is_learner, **kwargs) + + self.target_actor = Tensorflow_Model.create("SoftActorUnbounded", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.actor = Tensorflow_Model.create("SoftActorUnbounded", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + + self.actor.init_model() + self.actor.print() + self.target_actor.init_model() + + self.target_actor.set_weights(self.actor.get_weights()) + + @tf.function + def train_critic(self, states, actions, rewards, next_states, dones): + + sampled_means, sampled_sds = self.actor(next_states) + dist = tfp.distributions.Normal(sampled_means, sampled_sds) + raw_actions = dist.sample() + next_actions = (tf.tanh(raw_actions) + 1.0) / 2.0 *(self.upper_bound - self.lower_bound) + self.lower_bound + next_lp = tf.reduce_sum(dist.log_prob(raw_actions),axis=1) - tf.reduce_sum(tf.math.log(1 - tf.math.square(tf.math.tanh(raw_actions))), axis=1) + + # Add a little noise + new_q1 = self.target_critic1([next_states, next_actions], training=False) + new_q2 = self.target_critic2([next_states, next_actions], training=False) + new_q = tf.math.minimum(new_q1, new_q2) + # Bellman equation for the q value + # tf.print("SHAPES: ", states.shape, actions.shape, rewards.shape, new_q.shape, next_lp.shape) + # tf.print("Rewards: ", rewards) + q_targets = rewards + (1.0 - dones[:,None]) * self.gamma * (new_q - self.alpha * next_lp) + # Critic 1 + with tf.GradientTape() as tape: + q_values1 = self.critic1([states, actions], training=True) + td_errors1 = q_values1 - q_targets + critic_loss1 = tf.reduce_mean(tf.math.square(td_errors1)) + # tf.print("Critic 1 Loss: ", critic_loss1) + gradient1 = tape.gradient(critic_loss1, self.critic1.trainable_variables) + self.critic1.optimizer.apply_gradients(zip(gradient1, self.critic1.trainable_variables)) + + # Critic 2 + with tf.GradientTape() as tape: + q_values2 = self.critic2([states, actions], training=True) + td_errors2 = q_values2 - q_targets + critic_loss2 = tf.reduce_mean(tf.math.square(td_errors2)) + # tf.print("Critic 2 Loss: ", critic_loss2) + gradient2 = tape.gradient(critic_loss2, self.critic2.trainable_variables) + self.critic2.optimizer.apply_gradients(zip(gradient2, self.critic2.trainable_variables)) + + @tf.function + def train_actor(self, states): + # Use Critic 1 + with tf.GradientTape() as tape: + sampled_means, sampled_sds = self.actor(states) + dist = tfp.distributions.Normal(sampled_means, sampled_sds) + raw_actions = dist.sample() + actions = (tf.tanh(raw_actions) + 1.0) / 2.0 *(self.upper_bound - self.lower_bound) + self.lower_bound + action_lp = tf.reduce_sum(dist.log_prob(raw_actions),axis=1) - tf.reduce_sum(tf.math.log(1 - tf.math.square(tf.math.tanh(raw_actions))), axis=1) + q_value = self.critic1([states, actions], training=True) + loss = -tf.math.reduce_mean(q_value - self.alpha * action_lp) + # tf.print("Actor Loss: ", loss) + gradient = tape.gradient(loss, self.actor.trainable_variables) + self.actor.optimizer.apply_gradients(zip(gradient, self.actor.trainable_variables)) + + def action(self, state, use_target=False): + """ Method used to provide the next action using the target model """ + tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0) + if use_target: + sampled_means, sampled_sds = tf.squeeze(self.target_actor(tf_state)) + else: + sampled_means, sampled_sds = tf.squeeze(self.actor(tf_state)) + # dist = tfp.distributions.TruncatedNormal(sampled_means, sampled_sds, self.lower_bound, self.upper_bound) + dist = tfp.distributions.Normal(sampled_means, sampled_sds) + sampled_actions = dist.sample() + sampled_actions = (tf.tanh(sampled_actions) + 1.0) / 2.0 *(self.upper_bound - self.lower_bound) + self.lower_bound + + policy_type = 1 + # tf.print("Means: ", sampled_means) + # tf.print("SDs: ", sampled_sds) + # tf.print("Actions: ", sampled_actions) + + # We make sure action is within bounds + legal_action = np.clip(sampled_actions, self.lower_bound, self.upper_bound) + # log_p = dist.log_prob(legal_action) + + return legal_action, policy_type + diff --git a/exarl/agents/agent_vault/keras_td3.py b/exarl/agents/agent_vault/keras_td3.py new file mode 100644 index 00000000..e472f07f --- /dev/null +++ b/exarl/agents/agent_vault/keras_td3.py @@ -0,0 +1,282 @@ +# Copyright (c) 2020, Jefferson Science Associates, LLC. All Rights Reserved. Redistribution +# and use in source and binary forms, with or without modification, are permitted as a +# licensed user provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this +# list of conditions and the following disclaimer. +# 2. Redistributions in binary form must reproduce the above copyright notice, this +# list of conditions and the following disclaimer in the documentation and/or other +# materials provided with the distribution. +# 3. The name of the author may not be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# This material resulted from work developed under a United States Government Contract. +# The Government retains a paid-up, nonexclusive, irrevocable worldwide license in such +# copyrighted data to reproduce, distribute copies to the public, prepare derivative works, +# perform publicly and display publicly and to permit others to do so. +# +# THIS SOFTWARE IS PROVIDED BY JEFFERSON SCIENCE ASSOCIATES LLC "AS IS" AND ANY EXPRESS +# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +# MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL +# JEFFERSON SCIENCE ASSOCIATES, LLC OR THE U.S. GOVERNMENT BE LIABLE TO LICENSEE OR ANY +# THIRD PARTES FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS +# OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +# LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +import numpy as np +import tensorflow as tf +from tensorflow.keras.initializers import RandomUniform +from tensorflow.keras.optimizers import Adam + +import exarl +from exarl.utils.globals import ExaGlobals +from exarl.agents.replay_buffers.buffer import Buffer +logger = ExaGlobals.setup_logger(__name__) + +from exarl.agents.models.tf_model import Tensorflow_Model +from copy import deepcopy + +class KerasTD3(exarl.ExaAgent): + + def __init__(self, env, is_learner, **kwargs): + """ Define all key variables required for all agent """ + + self.is_learner = is_learner + # Get env info + super().__init__(**kwargs) + self.env = env + + self.num_states = env.observation_space.shape[0] + self.num_actions = env.action_space.shape[0] + self.upper_bound = env.action_space.high + self.lower_bound = env.action_space.low + print('upper_bound: ', self.upper_bound) + print('lower_bound: ', self.lower_bound) + + # Used to update target networks + self.tau = ExaGlobals.lookup_params('tau') + self.gamma = ExaGlobals.lookup_params('gamma') + + # Buffer + self.buffer_capacity = ExaGlobals.lookup_params('buffer_capacity') + self.batch_size = ExaGlobals.lookup_params('batch_size') + self.per_buffer = np.ones((self.buffer_capacity, 1)) + self.memory = Buffer.create(observation_space=env.observation_space, action_space=env.action_space) + + # Setup Optimizers + critic_lr = ExaGlobals.lookup_params('critic_lr') + actor_lr = ExaGlobals.lookup_params('actor_lr') + self.critic_optimizer1 = Adam(critic_lr, epsilon=1e-08) + self.critic_optimizer2 = Adam(critic_lr, epsilon=1e-08) + self.actor_optimizer = Adam(actor_lr, epsilon=1e-08) + + self.hidden_size = 56 + self.layer_std = 1.0 / np.sqrt(float(self.hidden_size)) + + # # Setup models + self.actor = Tensorflow_Model.create("Actor", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.critic1 = Tensorflow_Model.create("Critic", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.critic2 = Tensorflow_Model.create("Critic", + observation_space=env.observation_space, + action_space=env.action_space, + use_gpu=self.is_learner) + self.target_actor = deepcopy(self.actor) + self.target_critic1 = deepcopy(self.critic1) + self.target_critic2 = deepcopy(self.critic2) + + self.actor.init_model() + self.critic1.init_model() + self.critic2.init_model() + self.actor.print() + self.critic1.print() + self.target_actor.init_model() + self.target_critic1.init_model() + self.target_critic2.init_model() + + self.target_actor.set_weights(self.actor.get_weights()) + self.target_critic1.set_weights(self.critic1.get_weights()) + self.target_critic2.set_weights(self.critic2.get_weights()) + + + # update counting + self.ntrain_calls = 0 + self.actor_update_freq = 2 + self.critic_update_freq = 1 + self.target_update_freq = 2 + + # Not used by agent but required by the learner class + # self.epsilon = ExaGlobals.lookup_params('epsilon') + # self.epsilon_min = ExaGlobals.lookup_params('epsilon_min') + # self.epsilon_decay = ExaGlobals.lookup_params('epsilon_decay') + + logger().info("TD3 buffer capacity {}".format(self.buffer_capacity)) + logger().info("TD3 batch size {}".format(self.batch_size)) + logger().info("TD3 tau {}".format(self.tau)) + logger().info("TD3 gamma {}".format(self.gamma)) + logger().info("TD3 critic_lr {}".format(critic_lr)) + logger().info("TD3 actor_lr {}".format(actor_lr)) + + @tf.function + def train_critic(self, states, actions, rewards, next_states, dones): + next_actions = self.target_actor(next_states, training=False) + # Add a little noise + noise = np.random.normal(0, 0.2, next_actions.shape) + noise = np.clip(noise, -0.5, 0.5) + next_actions = next_actions * (1 + noise) + new_q1 = self.target_critic1([next_states, next_actions], training=False) + new_q2 = self.target_critic2([next_states, next_actions], training=False) + new_q = tf.math.minimum(new_q1, new_q2) + # Bellman equation for the q value + q_targets = rewards + (1.0 - dones[:,None]) * self.gamma * new_q + # Critic 1 + with tf.GradientTape() as tape: + q_values1 = self.critic1([states, actions], training=True) + td_errors1 = q_values1 - q_targets + critic_loss1 = tf.reduce_mean(tf.math.square(td_errors1)) + gradient1 = tape.gradient(critic_loss1, self.critic1.trainable_variables) + self.critic1.optimizer.apply_gradients(zip(gradient1, self.critic1.trainable_variables)) + + # Critic 2 + with tf.GradientTape() as tape: + q_values2 = self.critic2([states, actions], training=True) + td_errors2 = q_values2 - q_targets + critic_loss2 = tf.reduce_mean(tf.math.square(td_errors2)) + gradient2 = tape.gradient(critic_loss2, self.critic2.trainable_variables) + self.critic2.optimizer.apply_gradients(zip(gradient2, self.critic2.trainable_variables)) + + @tf.function + def train_actor(self, states): + # Use Critic 1 + with tf.GradientTape() as tape: + actions = self.actor(states, training=True) + q_value = self.critic1([states, actions], training=True) + loss = -tf.math.reduce_mean(q_value) + gradient = tape.gradient(loss, self.actor.trainable_variables) + self.actor.optimizer.apply_gradients(zip(gradient, self.actor.trainable_variables)) + + def get_critic(self): + # State as input + state_input = tf.keras.layers.Input(shape=(self.num_states),batch_size = ExaGlobals.lookup_params('batch_size')) + state_out = tf.keras.layers.Dense(16 * self.num_states, activation="relu")(state_input) + state_out = tf.keras.layers.Dense(32 * self.num_states, activation="relu")(state_out) + + # Action as input + action_input = tf.keras.layers.Input(shape=(self.num_actions), batch_size = ExaGlobals.lookup_params('batch_size')) + action_out = tf.keras.layers.Dense(32 * self.num_actions, activation="relu")(action_input) + + # Both are passed through separate layer before concatenating + concat = tf.keras.layers.Concatenate()([state_out, action_out]) + + out = tf.keras.layers.Dense(256, activation="relu")(concat) + out = tf.keras.layers.Dense(256, activation="relu")(out) + outputs = tf.keras.layers.Dense(1)(out) + + # Outputs single value for give state-action + model = tf.keras.Model([state_input, action_input], outputs) + model.summary() + return model + + def get_actor(self): + + # MLP + inputs = tf.keras.layers.Input(shape=(self.num_states), batch_size = ExaGlobals.lookup_params('batch_size')) + # + out = tf.keras.layers.Dense(self.hidden_size, + kernel_initializer=RandomUniform(-self.layer_std, +self.layer_std), + bias_initializer=RandomUniform(-self.layer_std, +self.layer_std))(inputs) + out = tf.keras.layers.BatchNormalization()(out) + out = tf.keras.layers.Activation(tf.nn.leaky_relu)(out) + # + out = tf.keras.layers.Dense(self.hidden_size, + kernel_initializer=RandomUniform(-self.layer_std, +self.layer_std), + bias_initializer=RandomUniform(-self.layer_std, +self.layer_std))(out) + out = tf.keras.layers.BatchNormalization()(out) + out = tf.keras.layers.Activation(tf.nn.leaky_relu)(out) + # + outputs = tf.keras.layers.Dense(self.num_actions, activation="tanh", + kernel_initializer=RandomUniform(-self.layer_std, +self.layer_std), + bias_initializer=RandomUniform(-self.layer_std, +self.layer_std), + use_bias=True)(out) + + # Rescale for tanh [-1,1] + outputs = tf.keras.layers.Lambda( + lambda x: ((x + 1.0) * (self.upper_bound - self.lower_bound)) / 2.0 + self.lower_bound)(outputs) + + model = tf.keras.Model(inputs, outputs) + model.summary() + return model + + @tf.function + def soft_update(self, target_weights, weights): + for (target_weight, weight) in zip(target_weights, weights): + target_weight.assign(weight * self.tau + target_weight * (1.0 - self.tau)) + + def update(self, state_batch, action_batch, reward_batch, next_state_batch, done_batch): + if self.ntrain_calls % self.critic_update_freq == 0: + self.train_critic(state_batch, action_batch, reward_batch, next_state_batch, done_batch) + if self.ntrain_calls % self.actor_update_freq == 0: + self.train_actor(state_batch) + + def _convert_to_tensor(self, state_batch, action_batch, reward_batch, next_state_batch, terminal_batch): + state_batch = tf.convert_to_tensor(state_batch, dtype=tf.float32) + action_batch = tf.convert_to_tensor(action_batch, dtype=tf.float32) + reward_batch = tf.convert_to_tensor(reward_batch, dtype=tf.float32) + next_state_batch = tf.convert_to_tensor(next_state_batch, dtype=tf.float32) + terminal_batch = tf.convert_to_tensor(terminal_batch, dtype=tf.float32) + return state_batch, action_batch, reward_batch, next_state_batch, terminal_batch + + def generate_data(self): + state_batch, action_batch, reward_batch, next_state_batch, done_batch = \ + self._convert_to_tensor(*self.memory.sample(self.batch_size)) + yield state_batch, action_batch, reward_batch, next_state_batch, done_batch + + def train(self, batch): + """ Method used to train """ + self.ntrain_calls += 1 + self.update(batch[0], batch[1], batch[2], batch[3], batch[4]) + self.update_target() + + def update_target(self): + if self.ntrain_calls % self.target_update_freq == 0: + self.soft_update(self.target_actor.variables, self.actor.variables) + self.soft_update(self.target_critic1.variables, self.critic1.variables) + self.soft_update(self.target_critic2.variables, self.critic2.variables) + + def action(self, state): + """ Method used to provide the next action using the target model """ + tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0) + sampled_actions = tf.squeeze(self.actor(tf_state)) + noise = np.random.normal(0, 0.1, sampled_actions.shape) + sampled_actions = sampled_actions.numpy() * (1 + noise) + policy_type = 1 + + # We make sure action is within bounds + legal_action = np.clip(sampled_actions, self.lower_bound, self.upper_bound) + + return legal_action, policy_type + + def remember(self, state, action, reward, next_state, done): + self.memory.store(state, action, reward, next_state, done) + + def has_data(self): + """return true if agent has experiences from simulation + """ + return (self.memory.size > 0) + + # For distributed actors # + def get_weights(self): + return self.target_actor.get_weights() + + def set_weights(self, weights): + self.target_actor.set_weights(weights) + + def train_return(self, args): + pass diff --git a/exarl/agents/agent_vault/td3.py b/exarl/agents/agent_vault/td3.py new file mode 100644 index 00000000..1ef945a0 --- /dev/null +++ b/exarl/agents/agent_vault/td3.py @@ -0,0 +1,367 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +import numpy as np +import tensorflow as tf +import tensorflow.keras as keras +from tensorflow.keras import layers + +import exarl +from exarl.utils.globals import ExaGlobals +from exarl.utils.OUActionNoise import OUActionNoise +from exarl.utils.OUActionNoise import OUActionNoise2 +from exarl.utils.memory_type import MEMORY_TYPE +from exarl.agents.agent_vault._replay_buffer import ReplayBuffer, HindsightExperienceReplayMemory, PrioritedReplayBuffer +logger = ExaGlobals.setup_logger(__name__) + + +class TD3(exarl.ExaAgent): + + def __init__(self, env, is_learner=False, update_actor_iter=2): + # Distributed variables + self.is_learner = is_learner + + # Environment space and action parameters + self.env = env + self.num_states = env.observation_space.shape[0] + self.num_actions = env.action_space.shape[0] + self.upper_bound = env.action_space.high + self.lower_bound = env.action_space.low + + logger().info("Size of State Space: {}".format(self.num_states)) + logger().info("Size of Action Space: {}".format(self.num_actions)) + logger().info('Env upper bounds: {}'.format(self.upper_bound)) + logger().info('Env lower bounds: {}'.format(self.lower_bound)) + + self.gamma = ExaGlobals.lookup_params('gamma') + self.tau = ExaGlobals.lookup_params('tau') + + # model definitions + # model definitions + self.actor_dense = ExaGlobals.lookup_params('actor_dense') + self.actor_dense_act = ExaGlobals.lookup_params('actor_dense_act') + self.actor_out_act = ExaGlobals.lookup_params('actor_out_act') + self.actor_optimizer = ExaGlobals.lookup_params('actor_optimizer') + self.critic_state_dense = ExaGlobals.lookup_params('critic_state_dense') + self.critic_state_dense_act = ExaGlobals.lookup_params('critic_state_dense_act') + self.critic_action_dense = ExaGlobals.lookup_params('critic_action_dense') + self.critic_action_dense_act = ExaGlobals.lookup_params('critic_action_dense_act') + self.critic_concat_dense = ExaGlobals.lookup_params('critic_concat_dense') + self.critic_concat_dense_act = ExaGlobals.lookup_params('critic_concat_dense_act') + self.critic_out_act = ExaGlobals.lookup_params('critic_out_act') + self.critic_optimizer = ExaGlobals.lookup_params('critic_optimizer') + self.replay_buffer_type = ExaGlobals.lookup_params('replay_buffer_type') + + std_dev = 0.2 + # ave_bound = (self.upper_bound + self.lower_bound) / 2 + ave_bound = np.zeros(1) + print('ave_bound: {}'.format(ave_bound)) + self.ou_noise = OUActionNoise(mean=ave_bound, std_deviation=float(std_dev) * np.ones(1)) + + self.epsilon = ExaGlobals.lookup_params('epsilon') + self.epsilon_min = ExaGlobals.lookup_params('epsilon_min') + self.epsilon_decay = ExaGlobals.lookup_params('epsilon_decay') + + # Experience data + self.buffer_capacity = ExaGlobals.lookup_params('buffer_capacity') + self.batch_size = ExaGlobals.lookup_params('batch_size') + + if self.replay_buffer_type == MEMORY_TYPE.UNIFORM_REPLAY: + self.memory = ReplayBuffer(self.buffer_capacity, self.num_states, self.num_actions) + elif self.replay_buffer_type == MEMORY_TYPE.PRIORITY_REPLAY: + self.memory = PrioritedReplayBuffer(self.buffer_capacity, self.num_states, self.num_actions, self.batch_size) + elif self.replay_buffer_type == MEMORY_TYPE.HINDSIGHT_REPLAY: # TODO: Double check if the environment has goal state + self.memory = HindsightExperienceReplayMemory(self.buffer_capacity, self.num_states, self.num_actions) + else: + print("Unrecognized replay buffer please specify 'uniform, priority or hindsight', using default uniform sampling") + raise ValueError("Unrecognized Memory type {}".format(self.replay_buffer_type)) + + # Setup TF configuration to allow memory growth + # tf.keras.backend.set_floatx('float64') + config = tf.compat.v1.ConfigProto() + config.gpu_options.allow_growth = True + sess = tf.compat.v1.Session(config=config) + tf.compat.v1.keras.backend.set_session(sess) + + # Training model only required by the learners + + if self.is_learner: + self.actor_model = self.get_actor() + self.critic_model_1 = self.get_critic() + self.critic_model_2 = self.get_critic() + self.target_actor = self.get_actor() + self.target_critic_1 = self.get_critic() + self.target_critic_2 = self.get_critic() + self.target_actor.set_weights(self.actor_model.get_weights()) + self.target_critic_1.set_weights(self.critic_model_1.get_weights()) + self.target_critic_2.set_weights(self.critic_model_2.get_weights()) + + # Every agent needs this, however, actors only use the CPU (for now) + else: + with tf.device('/CPU:0'): + self.target_actor = self.get_actor() + self.target_critic_1 = self.get_critic() + self.target_critic_2 = self.get_critic() + + # Learning rate for actor-critic models + self.critic_lr = ExaGlobals.lookup_params('critic_lr') + self.actor_lr = ExaGlobals.lookup_params('actor_lr') + self.critic_optimizer = tf.keras.optimizers.Adam(self.critic_lr) + self.actor_optimizer = tf.keras.optimizers.Adam(self.actor_lr) + + self.update_actor_iter = update_actor_iter # Updates actor every other n (2) learning rate + self.learn_step_counter = 0 + np.random.seed(0) + tf.random.set_seed(0) + + def remember(self, state, action, reward, next_state, done): + # If the counter exceeds the capacity then + self.memory.store(state, action, reward, next_state, done) + + # @tf.function + # Just a hack for now: + def update_grad(self, state_batch, action_batch, reward_batch, next_state_batch, terminal_batch, b_idx=None, weights=None): + # Training and updating Actor & Critic networks. + with tf.GradientTape(persistent=True) as tape: + target_actions = self.target_actor(next_state_batch, training=True) + target_actions = target_actions + tf.clip_by_value(np.random.normal(scale=0.2), -0.5, 0.5) # TODO: Might remove this + target_actions = tf.clip_by_value(target_actions, self.lower_bound, self.upper_bound) # TODO: Same + q1_ = self.target_critic_1([next_state_batch, target_actions], training=True) + q2_ = self.target_critic_2([next_state_batch, target_actions], training=True) + # For priroritized experience + + q1 = self.critic_model_1([state_batch, action_batch], training=True) + q2 = self.critic_model_2([state_batch, action_batch], training=True) + + critic_value_ = tf.math.minimum(q1_, q2_) + # print(reward_batch.shape) + # exit() + # reward_batch = tf.squeeze(reward_batch,1) + + y = reward_batch + self.gamma * critic_value_ * (1 - terminal_batch) + + critic_loss_1 = keras.losses.MSE(y, q1) + critic_loss_2 = keras.losses.MSE(y, q2) + if self.replay_buffer_type == MEMORY_TYPE.PRIORITY_REPLAY: + error_1 = np.abs(tf.squeeze(y - q1).numpy()) + error_2 = np.abs(tf.squeeze(y - q2).numpy()) + error = np.abs(error_1 + error_2) / 2.0 + critic_loss_1 *= weights + critic_loss_2 *= weights + self.memory.batch_update(b_idx, error) + + logger().warning("Critic loss 1: {}, Critic loss 2: {} ".format(critic_loss_1, critic_loss_2)) + + critic_grad_1 = tape.gradient(critic_loss_1, self.critic_model_1.trainable_variables) + self.critic_optimizer.apply_gradients( + zip(critic_grad_1, self.critic_model_1.trainable_variables) + ) + + critic_grad_2 = tape.gradient(critic_loss_2, self.critic_model_2.trainable_variables) + self.critic_optimizer.apply_gradients( + zip(critic_grad_2, self.critic_model_2.trainable_variables) + ) + + self.learn_step_counter += 1 + if self.learn_step_counter % self.update_actor_iter == 0: + return + + with tf.GradientTape() as tape: + actions = self.actor_model(state_batch, training=True) + critic_value_1 = self.critic_model_1([state_batch, actions], training=True) + actor_loss = -tf.math.reduce_mean(critic_value_1) + + logger().warning("Actor loss: {}".format(actor_loss)) + actor_grad = tape.gradient(actor_loss, self.actor_model.trainable_variables) + self.actor_optimizer.apply_gradients( + zip(actor_grad, self.actor_model.trainable_variables) + ) + # self.target_train() + + # return model + + def get_actor(self): + # State as input + inputs = layers.Input(shape=(self.num_states,)) + # first layer takes inputs + out = layers.Dense(self.actor_dense[0], activation=self.actor_dense_act)(inputs) + # loop over remaining layers + for i in range(1, len(self.actor_dense)): + out = layers.Dense(self.actor_dense[i], activation=self.actor_dense_act)(out) + # output layer has dimension actions, separate activation setting + out = layers.Dense(self.num_actions, activation=self.actor_out_act, + kernel_initializer=tf.random_uniform_initializer())(out) + outputs = layers.Lambda(lambda i: i * self.upper_bound)(out) + model = tf.keras.Model(inputs, outputs) + # model.summary() + + return model + + def get_critic(self): + # State as input + state_input = layers.Input(shape=self.num_states) + # first layer takes inputs + state_out = layers.Dense(self.critic_state_dense[0], + activation=self.critic_state_dense_act)(state_input) + # loop over remaining layers + for i in range(1, len(self.critic_state_dense)): + state_out = layers.Dense(self.critic_state_dense[i], + activation=self.critic_state_dense_act)(state_out) + + # Action as input + action_input = layers.Input(shape=self.num_actions) + + # first layer takes inputs + action_out = layers.Dense(self.critic_action_dense[0], + activation=self.critic_action_dense_act)(action_input) + # loop over remaining layers + for i in range(1, len(self.critic_action_dense)): + action_out = layers.Dense(self.critic_action_dense[i], + activation=self.critic_action_dense_act)(action_out) + + # Both are passed through seperate layer before concatenating + concat = layers.Concatenate()([state_out, action_out]) + + # assumes at least 2 post-concat layers + # first layer takes concat layer as input + concat_out = layers.Dense(self.critic_concat_dense[0], + activation=self.critic_concat_dense_act)(concat) + # loop over remaining inner layers + for i in range(1, len(self.critic_concat_dense) - 1): + concat_out = layers.Dense(self.critic_concat_dense[i], + activation=self.critic_concat_dense_act)(concat_out) + + # last layer has different activation + concat_out = layers.Dense(self.critic_concat_dense[-1], activation=self.critic_out_act, + kernel_initializer=tf.random_uniform_initializer())(concat_out) + outputs = layers.Dense(1)(concat_out) + + # Outputs single value for give state-action + model = tf.keras.Model([state_input, action_input], outputs) + # model.summary() + + return model + + def _convert_to_tensor(self, state_batch, action_batch, reward_batch, next_state_batch, terminal_batch): + state_batch = tf.convert_to_tensor(state_batch, dtype=tf.float32) + action_batch = tf.convert_to_tensor(action_batch, dtype=tf.float32) + reward_batch = tf.convert_to_tensor(reward_batch, dtype=tf.float32) + next_state_batch = tf.convert_to_tensor(next_state_batch, dtype=tf.float32) + terminal_batch = tf.convert_to_tensor(terminal_batch, dtype=tf.float32) + return state_batch, action_batch, reward_batch, next_state_batch, terminal_batch + + def has_data(self): + """Indicates if the buffer has data of size batch_size or more + + Returns: + bool: True if replay_buffer length >= self.batch_size + """ + return (self.memory._mem_length > 0) + + def generate_data(self): + + if self.replay_buffer_type == MEMORY_TYPE.UNIFORM_REPLAY: + state_batch, action_batch, reward_batch, next_state_batch, terminal_batch = self.memory.sample_buffer( + self.batch_size) # done_batch might improve experience + state_batch, action_batch, reward_batch, next_state_batch, terminal_batch = self._convert_to_tensor( + state_batch, action_batch, reward_batch, next_state_batch, terminal_batch) + yield state_batch, action_batch, reward_batch, next_state_batch, terminal_batch + + elif self.replay_buffer_type == MEMORY_TYPE.PRIORITY_REPLAY: + state_batch, action_batch, reward_batch, next_state_batch, terminal_batch, btx_idx, weights = self.memory.sample_buffer(self.batch_size) + state_batch, action_batch, reward_batch, next_state_batch, terminal_batch = self._convert_to_tensor( + state_batch, action_batch, reward_batch, next_state_batch, terminal_batch) + weights = tf.convert_to_tensor(weights, dtype=tf.float32) + yield state_batch, action_batch, reward_batch, next_state_batch, terminal_batch, btx_idx, weights + else: + raise ValueError('Support for the replay buffer type not implemented yet!') + + def train(self, batch): + if self.is_learner: + if batch and len(batch[0]) >= (self.batch_size): + logger().warning('Training...') + if self.replay_buffer_type == MEMORY_TYPE.UNIFORM_REPLAY: + self.update_grad(batch[0], batch[1], batch[2], batch[3], batch[4]) + elif self.replay_buffer_type == MEMORY_TYPE.PRIORITY_REPLAY: + self.update_grad(batch[0], batch[1], batch[2], batch[3], batch[4], batch[5], batch[6]) + + def update_target(self): + # Update the target model + model_weights = self.actor_model.get_weights() + target_weights = self.target_actor.get_weights() + for i in range(len(target_weights)): + target_weights[i] = self.tau * model_weights[i] + (1 - self.tau) * target_weights[i] + self.target_actor.set_weights(target_weights) + + model_weights = self.critic_model_1.get_weights() + target_weights = self.target_critic_1.get_weights() + for i in range(len(target_weights)): + target_weights[i] = self.tau * model_weights[i] + (1 - self.tau) * target_weights[i] + self.target_critic_1.set_weights(target_weights) + + model_weights = self.critic_model_2.get_weights() + target_weights = self.target_critic_2.get_weights() + for i in range(len(target_weights)): + target_weights[i] = self.tau * model_weights[i] + (1 - self.tau) * target_weights[i] + self.target_critic_2.set_weights(target_weights) + + def action(self, state): + # TODO: Might be better to start after warm up + if np.random.random() < self.epsilon: + sampled_actions = np.random.uniform(low=self.lower_bound, high=self.upper_bound, size=(self.num_actions,)) + policy_type = 0 + self.epsilon_adj() + else: + policy_type = 1 + tf_state = tf.expand_dims(tf.convert_to_tensor(state), 0) + + sampled_actions = tf.squeeze(self.target_actor(tf_state)) + sampled_actions = sampled_actions.numpy() + noise = self.ou_noise() + sampled_actions_wn = sampled_actions + noise + legal_action = tf.clip_by_value(sampled_actions_wn, self.lower_bound, self.upper_bound) + + return_action = [np.squeeze(legal_action)] + logger().warning('Legal action:{}'.format(return_action)) + return return_action, policy_type + + # For distributed actors # + def get_weights(self): + return self.target_actor.get_weights() + + def set_weights(self, weights): + self.target_actor.set_weights(weights) + + # Extra methods + def update(self): + print("Implement update method in ddpg.py") + + def monitor(self): + print("Implement monitor method in td3.py") + + def set_agent(self): + print("Implement set_agent method in td3.py") + + def print_timers(self): + print("Implement print_timers method in td3.py") + + def epsilon_adj(self): + if self.epsilon > self.epsilon_min: + self.epsilon *= self.epsilon_decay diff --git a/exarl/agents/models/__init__.py b/exarl/agents/models/__init__.py new file mode 100644 index 00000000..264a66d6 --- /dev/null +++ b/exarl/agents/models/__init__.py @@ -0,0 +1,16 @@ +from exarl.agents.models.tf_model import Tensorflow_Model +from exarl.agents.models.tf_mlp import MLP +from exarl.agents.models.tf_lstm import LSTM +from exarl.agents.models.tf_sac import SoftActorUnbounded +from exarl.agents.models.tf_sac import SoftActor +from exarl.agents.models.tf_ac import Actor +from exarl.agents.models.tf_sac import SoftCritic +from exarl.agents.models.tf_ac import Critic + +Tensorflow_Model.register("MLP", MLP) +Tensorflow_Model.register("LSTM", LSTM) +Tensorflow_Model.register("SoftActor", SoftActor) +Tensorflow_Model.register("SoftCritic", SoftCritic) +Tensorflow_Model.register("SoftActorUnbounded", SoftActorUnbounded) +Tensorflow_Model.register("Critic", Critic) +Tensorflow_Model.register("Actor", Actor) diff --git a/exarl/agents/models/tf_ac.py b/exarl/agents/models/tf_ac.py new file mode 100644 index 00000000..485ced00 --- /dev/null +++ b/exarl/agents/models/tf_ac.py @@ -0,0 +1,96 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +import tensorflow as tf +from tensorflow.keras.models import Model +from tensorflow.keras.layers import Dense, Input, Concatenate, Lambda +from gym.spaces.utils import flatdim +from exarl.agents.models.tf_model import Tensorflow_Model +from exarl.utils.globals import ExaGlobals + +class Actor(Tensorflow_Model): + def __init__(self, observation_space, action_space, use_gpu=True): + super(Actor, self).__init__(observation_space, action_space, use_gpu) + self.batch_size = ExaGlobals.lookup_params('batch_size') + self.actor_dense = ExaGlobals.lookup_params('actor_dense') + self.actor_dense_act = ExaGlobals.lookup_params('actor_dense_act') + self.actor_out_act = ExaGlobals.lookup_params('actor_out_act') + + assert len(self.actor_dense) >= 1, "Must have at least one actor_dense layer: {}".format(len(self.actor_dense)) + + self.loss = None + self.actor_lr = ExaGlobals.lookup_params('actor_lr') + self.optimizer = tf.keras.optimizers.Adam(self.actor_lr) + + self.upper_bound = action_space.high + self.lower_bound = action_space.low + self.n_actions = action_space.shape[0] + + def _build(self): + last_init = tf.random_uniform_initializer() + last_init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003) + + layers = [] + layers.append(Input(shape=(flatdim(self.observation_space),), batch_size=self.batch_size)) + for i in range(len(self.actor_dense)): + layers.append(Dense(self.actor_dense[i], activation=self.actor_dense_act)(layers[-1])) + layers.append(Dense(self.n_actions, activation=self.actor_out_act, kernel_initializer=last_init)(layers[-1])) + layers.append(Lambda(lambda i: i * (self.upper_bound - self.lower_bound) + self.lower_bound)(layers[-1])) + self._model = Model(inputs=layers[0], outputs=layers[-1]) + +class Critic(Tensorflow_Model): + def __init__(self, observation_space, action_space, use_gpu=True): + super(Critic, self).__init__(observation_space, action_space, use_gpu) + self.batch_size = ExaGlobals.lookup_params('batch_size') + + self.critic_state_dense = ExaGlobals.lookup_params('critic_state_dense') + self.critic_state_dense_act = ExaGlobals.lookup_params('critic_state_dense_act') + self.critic_action_dense = ExaGlobals.lookup_params('critic_action_dense') + self.critic_action_dense_act = ExaGlobals.lookup_params('critic_action_dense_act') + + self.critic_concat_dense = ExaGlobals.lookup_params('critic_concat_dense') + self.critic_concat_dense_act = ExaGlobals.lookup_params('critic_concat_dense_act') + + assert len(self.critic_state_dense) >= 1, "Must have at least one critic_state_dense layer: {}".format(len(self.critic_state_dense)) + assert len(self.critic_action_dense) >= 1, "Must have at least one critic_action_dense layer: {}".format(len(self.critic_action_dense)) + assert len(self.critic_concat_dense) >= 1, "Must have at least one critic_concat_dense layer: {}".format(len(self.critic_concat_dense)) + + self.loss = None + self.critic_lr = ExaGlobals.lookup_params('critic_lr') + self.optimizer = tf.keras.optimizers.Adam(self.critic_lr) + + def _build(self): + state_layers = [] + state_layers.append(Input(shape=(flatdim(self.observation_space),), batch_size=self.batch_size)) + for i in range(len(self.critic_state_dense)): + state_layers.append(Dense(self.critic_state_dense[i], activation=self.critic_state_dense_act)(state_layers[-1])) + + action_layers = [] + action_layers.append(Input(shape=(flatdim(self.action_space),), batch_size=self.batch_size)) + for i in range(len(self.critic_action_dense)): + action_layers.append(Dense(self.critic_action_dense[i], activation=self.critic_action_dense_act)(action_layers[-1])) + + concat_layers = [] + concat_layers.append(Concatenate()([state_layers[-1], action_layers[-1]])) + for i in range(len(self.critic_concat_dense)): + concat_layers.append(Dense(self.critic_concat_dense[i], activation=self.critic_concat_dense_act)(concat_layers[-1])) + + concat_layers.append(Dense(1)(concat_layers[-1])) + self._model = Model([state_layers[0], action_layers[0]], concat_layers[-1]) diff --git a/exarl/agents/models/tf_lstm.py b/exarl/agents/models/tf_lstm.py new file mode 100755 index 00000000..42d17b1e --- /dev/null +++ b/exarl/agents/models/tf_lstm.py @@ -0,0 +1,71 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +import tensorflow as tf +from tensorflow.keras.models import Sequential +import tensorflow.keras.layers as tf_layer +from tensorflow.keras.regularizers import l1_l2 +from gym.spaces.utils import flatdim + +from exarl.agents.models.tf_model import Tensorflow_Model +from exarl.utils.globals import ExaGlobals + +class LSTM(Tensorflow_Model): + def __init__(self, observation_space, action_space, use_gpu=True): + super(LSTM, self).__init__(observation_space, action_space, use_gpu) + self.batch_size = ExaGlobals.lookup_params('batch_size') + self.trajectory_length = ExaGlobals.lookup_params('trajectory_length') + self.activation = ExaGlobals.lookup_params('activation') + self.out_activation = ExaGlobals.lookup_params('out_activation') + self.lstm_layers = ExaGlobals.lookup_params('lstm_layers') + self.gauss_noise = ExaGlobals.lookup_params('gauss_noise') + self.regularizer = ExaGlobals.lookup_params('regularizer') + self.clipnorm = ExaGlobals.lookup_params('clipnorm') + self.clipvalue = ExaGlobals.lookup_params('clipvalue') + + # self.optimizer = ExaGlobals.lookup_params('optimizer') + self.optimizer = tf.keras.optimizers.Adam() + self.loss = ExaGlobals.lookup_params('loss') + + def _build(self): + num_layers = len(self.lstm_layers) + + self._model = Sequential() + self._model.add(tf_layer.LSTM(self.lstm_layers[0], activation=self.activation, + return_sequences=True, + input_shape=(self.trajectory_length, flatdim(self.observation_space)))) + self._model.add(tf_layer.BatchNormalization()) + self._model.add(tf_layer.Dropout(self.gauss_noise[0])) + + # loop over inner layers only + for l in range(1, num_layers - 1): + self._model.add(tf_layer.LSTM(self.lstm_layers[l], + activation=self.activation, + return_sequences=True)) + self._model.add(tf_layer.Dropout(self.gauss_noise[l])) + + # special case for output layer + l = num_layers = 1 + self._model.add(tf_layer.LSTM(self.lstm_layers[l], + activation=self.activation, + kernel_regularizer=l1_l2(self.regularizer[0], + self.regularizer[1]),)) + self._model.add(tf_layer.Dropout(self.gauss_noise[l])) + self._model.add(tf_layer.Dense(flatdim(self.action_space), activation=self.out_activation)) diff --git a/exarl/agents/agent_vault/_build_mlp.py b/exarl/agents/models/tf_mlp.py old mode 100644 new mode 100755 similarity index 51% rename from exarl/agents/agent_vault/_build_mlp.py rename to exarl/agents/models/tf_mlp.py index d2ef6a85..133bb676 --- a/exarl/agents/agent_vault/_build_mlp.py +++ b/exarl/agents/models/tf_mlp.py @@ -18,26 +18,33 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 +import tensorflow as tf from tensorflow.keras.models import Model from tensorflow.keras.layers import Dense, Input, Flatten +from gym.spaces.utils import flatdim +from exarl.agents.models.tf_model import Tensorflow_Model +from exarl.utils.globals import ExaGlobals +class MLP(Tensorflow_Model): + def __init__(self, observation_space, action_space, use_gpu=True): + super(MLP, self).__init__(observation_space, action_space, use_gpu) + self.batch_size = ExaGlobals.lookup_params('batch_size') + self.dense = ExaGlobals.lookup_params('dense') + self.activation = ExaGlobals.lookup_params('activation') + self.out_activation = ExaGlobals.lookup_params('out_activation') + self.loss = ExaGlobals.lookup_params('loss') + # self.optimizer = ExaGlobals.lookup_params('optimizer') + self.optimizer = tf.keras.optimizers.Adam() -def build_model(self): - # Input: state - layers = [] - state_input = Input(shape=(1, self.env.observation_space.shape[0])) - layers.append(state_input) - length = len(self.dense) - # for i, layer_width in enumerate(self.dense): - for i in range(length): - layer_width = self.dense[i] - layers.append(Dense(layer_width, activation=self.activation)(layers[-1])) - # output layer - layers.append(Dense(self.env.action_space.n, activation=self.out_activation)(layers[-1])) - layers.append(Flatten()(layers[-1])) - - model = Model(inputs=layers[0], outputs=layers[-1]) - # model.summary() - print('', flush=True) - - return model + def _build(self): + layers = [] + # Input: state + state_input = Input(shape=(flatdim(self.observation_space),), batch_size=self.batch_size) + layers.append(state_input) + for i in range(len(self.dense)): + layer_width = self.dense[i] + layers.append(Dense(layer_width, activation=self.activation)(layers[-1])) + # Output layer + layers.append(Dense(flatdim(self.action_space), dtype='float32', activation=self.out_activation)(layers[-1])) + layers.append(Flatten()(layers[-1])) + self._model = Model(inputs=layers[0], outputs=layers[-1]) diff --git a/exarl/agents/models/tf_model.py b/exarl/agents/models/tf_model.py new file mode 100644 index 00000000..747c739d --- /dev/null +++ b/exarl/agents/models/tf_model.py @@ -0,0 +1,225 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +from abc import ABC, abstractmethod + +import tensorflow as tf +from exarl.utils.globals import ExaGlobals +from exarl.base.comm_base import ExaComm + +class Tensorflow_Model(ABC): + """ + This class is a base class for tensorflow models like mlp and lstm. The purpose is to + abstract the tensorflow specifics to reduce boiler plate for new models. The second + reason is to provide a factory method for building models. This reduces the total code + to change out the model for a given agent. + + Attributes + ---------- + _builders : dictionary + This dictionary has the name and constructor of inherited models. + + use_gpu : bool + Flag that indicates model should use gpu + + enable_xla : bool + Flag indicating is xla should be used when compiling model. This should + come from the configuration file for the TF model. + + mixed_precision : bool + Flag to turn on or off mixed preceision trading off speed and memory for accuracy. + This comes from configuration file for the TF model. + + rank : int + Rank used for getting gpu + + observation_space : gym space + From the environment, required input to the model + + action_space : gym space + From the environment, required input to the model + + _device : string + Id of the device the model will use + + _model : tensorflow model + This is the raw tf model + """ + + _builders = {} + + def __init__(self, observation_space, action_space, use_gpu=True): + self.use_gpu = use_gpu + self.rank = ExaComm.global_comm.rank + self.observation_space = observation_space + self.action_space = action_space + + # Set the device to use + self._set_device() + + # Optimization using XLA (1.1x speedup) + self.enable_xla = True if ExaGlobals.lookup_params('xla') in ["true", "True", 1] else False + + # Optimization using mixed precision (1.5x speedup) + self.mixed_precision = True if ExaGlobals.lookup_params('mixed_precision') in ["true", "True", 1] else False + # https://www.tensorflow.org/guide/mixed_precision + if self.mixed_precision: + tf.keras.mixed_precision.set_global_policy('mixed_float16') + + self._device = None + self._model = None + + def register(key, builder): + """ + This function registers a model to the tf model generator. + Models are registered in the exarl/agents/models/__init__ + when the python file is imported. The builder must pass + the observation and action spaces as the first two arguments + respectively. + + Parameters + ---------- + key : string + Name of the tf model + + builder : constructor + This is constructor of the tf model to build + """ + Tensorflow_Model._builders[key] = builder + + def create(key=None, **kwargs): + """ + This function is used to create registerd models. This should be + used in an agent. The observation and action spaces should be + passed in as keyword arguments. + + Parameters + ---------- + key : string + Name of the registered model to build + + kwargs : list + The parameters to pass to the registered builder + """ + # JS: Lookup which model if not passed + if key is None: + key = ExaGlobals.lookup_params('model_type') + # JS: Ensure buffer is listed + builder = Tensorflow_Model._builders.get(key) + if not builder: + raise ValueError(key) + # JS: Must pass observation and action spaces + observation_space = kwargs.pop("observation_space", None) + action_space = kwargs.pop("action_space", None) + return builder(observation_space, action_space, **kwargs) + + @abstractmethod + def _build(self): + """ + This function is a placeholder for the code to build the tf model. + """ + pass + + def _compile(self): + """ + This internal function compiles a tf model. + """ + with tf.device(self._device): + self._build() + self._model.compile(loss=self.loss, optimizer=self.optimizer, jit_compile=self.enable_xla) + + def _get_device(self): + """ + Get device type (CPU/GPU). + There is a weird bug in TF: + https://github.com/tensorflow/tensorflow/issues/39857 + If fixed we could use tf.config.list_physical_devices(). + + Returns: + string: device type + """ + ret = None + gpus = [] + if self.use_gpu: + # gpus = tf.config.list_logical_devices('GPU') + gpus = tf.config.list_physical_devices('GPU') + cpus = tf.config.list_logical_devices('CPU') + # cpus = tf.config.list_physical_devices('CPU') + assert len(gpus) + len(cpus) > 0, "There are no devices listed for TF -- gpus: {} cpus: {}".format(len(gpus), len(cpus)) + + # JS: "share" mode will round robin all agents across the gpus + if len(gpus) > 0: + temp = gpus[ExaComm.agent_comm.rank % len(gpus)] + else: + # JS: Fall back on cpu + temp = cpus[ExaComm.agent_comm.rank % len(cpus)] + # JS: There is some stupid TF error and this is my workaround + # return tf.config.PhysicalDevice('/CPU:0', 'CPU'), temp.device_type + return + + def _set_device(self): + # self._device, dev_type = self._get_device() + self._device = '/CPU:0' + # print("Setting agent rank:", ExaComm.agent_comm.rank, self._device, dev_type) + # JS: https://www.tensorflow.org/guide/gpu + # This limits the proc to one GPU + # There may be cases we want to override + # i.e. mirror strategy... + # tf.config.set_visible_devices(self._device, dev_type) + # tf.config.set_visible_devices(self._device, dev_type) + # JS: This minimizes the memory footprint + # tf.config.experimental.set_memory_growth(self._device, True) + + # tf.config.experimental.set_memory_growth(tf.config.list_physical_devices('CPU')[0], True) + + def init_model(self): + if self._model is None: + self._compile() + + @property + def model(self): + self.init_model() + return self._model + + @property + def trainable_variables(self): + return self._model.trainable_variables + + @property + def variables(self): + return self._model.variables + + def __call__(self, input, **kwargs): + model = self._model + with tf.device(self._device): + ret = model(input, kwargs) + return ret + + def get_weights(self): + return self._model.get_weights() + + def set_weights(self, weights): + with tf.device(self._device): + self._model.set_weights(weights) + + def print(self): + self._model.summary() + print('', flush=True) + \ No newline at end of file diff --git a/exarl/agents/models/tf_sac.py b/exarl/agents/models/tf_sac.py new file mode 100644 index 00000000..832ea98e --- /dev/null +++ b/exarl/agents/models/tf_sac.py @@ -0,0 +1,154 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +import tensorflow as tf +from tensorflow.keras.models import Model +from tensorflow.keras.layers import Dense, Input, Concatenate, Lambda +from gym.spaces.utils import flatdim +from exarl.agents.models.tf_model import Tensorflow_Model +from exarl.utils.globals import ExaGlobals + +class SoftActor(Tensorflow_Model): + def __init__(self, observation_space, action_space, use_gpu=True): + super(SoftActor, self).__init__(observation_space, action_space, use_gpu) + self.batch_size = ExaGlobals.lookup_params('batch_size') + self.actor_dense = ExaGlobals.lookup_params('actor_dense') + self.actor_dense_act = ExaGlobals.lookup_params('actor_dense_act') + self.actor_out_act = ExaGlobals.lookup_params('actor_out_act') + + assert len(self.actor_dense) >= 1, "Must have at least one actor_dense layer: {}".format(len(self.actor_dense)) + + self.loss = None + self.actor_lr = ExaGlobals.lookup_params('actor_lr') + self.optimizer = tf.keras.optimizers.Adam(self.actor_lr) + + self.upper_bound = action_space.high + self.lower_bound = action_space.low + self.n_actions = action_space.shape[0] + + def _build(self): + last_init = tf.random_uniform_initializer() + last_init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003) + + layers = [] + layers.append(Input(shape=(flatdim(self.observation_space),), batch_size=self.batch_size)) + for i in range(len(self.actor_dense)): + layers.append(Dense(self.actor_dense[i], activation=self.actor_dense_act)(layers[-1])) + layers.append(Dense(self.n_actions, activation=self.actor_out_act, kernel_initializer=last_init)(layers[-1])) + layers.append(Lambda(lambda i: i * (self.upper_bound - self.lower_bound) + self.lower_bound)(layers[-1])) + + layers.append(Dense(self.n_actions, activation=self.actor_out_act, kernel_initializer=last_init)(layers[-3])) + # layers.append(Lambda(lambda x: tf.exp(x) )(layers[-1])) + layers.append(Lambda(lambda x: tf.exp(x * (5.0 - (-5.0)) - 5.0))(layers[-1])) + self._model = Model(inputs=layers[0], outputs=[layers[-3], layers[-1]]) + + def _compile(self): + """ + This internal function compiles a tf model. + """ + with tf.device(self._device): + self._build() + self._model.compile(loss=self.loss, optimizer=self.optimizer, jit_compile=self.enable_xla) + +class SoftCritic(Tensorflow_Model): + def __init__(self, observation_space, action_space, use_gpu=True): + super(SoftCritic, self).__init__(observation_space, action_space, use_gpu) + self.batch_size = ExaGlobals.lookup_params('batch_size') + + self.critic_state_dense = ExaGlobals.lookup_params('critic_state_dense') + self.critic_state_dense_act = ExaGlobals.lookup_params('critic_state_dense_act') + self.critic_action_dense = ExaGlobals.lookup_params('critic_action_dense') + self.critic_action_dense_act = ExaGlobals.lookup_params('critic_action_dense_act') + + self.critic_concat_dense = ExaGlobals.lookup_params('critic_concat_dense') + self.critic_concat_dense_act = ExaGlobals.lookup_params('critic_concat_dense_act') + + assert len(self.critic_state_dense) >= 1, "Must have at least one critic_state_dense layer: {}".format(len(self.critic_state_dense)) + assert len(self.critic_action_dense) >= 1, "Must have at least one critic_action_dense layer: {}".format(len(self.critic_action_dense)) + assert len(self.critic_concat_dense) >= 1, "Must have at least one critic_concat_dense layer: {}".format(len(self.critic_concat_dense)) + + self.loss = None + self.critic_lr = ExaGlobals.lookup_params('critic_lr') + self.optimizer = tf.keras.optimizers.Adam(self.critic_lr) + + def _build(self): + state_layers = [] + state_layers.append(Input(shape=(flatdim(self.observation_space),), batch_size=self.batch_size)) + for i in range(len(self.critic_state_dense)): + state_layers.append(Dense(self.critic_state_dense[i], activation=self.critic_state_dense_act)(state_layers[-1])) + + action_layers = [] + action_layers.append(Input(shape=(flatdim(self.action_space),), batch_size=self.batch_size)) + for i in range(len(self.critic_action_dense)): + action_layers.append(Dense(self.critic_action_dense[i], activation=self.critic_action_dense_act)(action_layers[-1])) + + # action_sd_layers = [] + # action_sd_layers.append(Input(shape=(flatdim(self.action_space),), batch_size=self.batch_size)) + # for i in range(len(self.critic_action_dense)): + # action_sd_layers.append(Dense(self.critic_action_dense[i], activation=self.critic_action_dense_act)(action_sd_layers[-1])) + + concat_layers = [] + concat_layers.append(Concatenate()([state_layers[-1], action_layers[-1]])) + for i in range(len(self.critic_concat_dense)): + concat_layers.append(Dense(self.critic_concat_dense[i], activation=self.critic_concat_dense_act)(concat_layers[-1])) + + concat_layers.append(Dense(1)(concat_layers[-1])) + self._model = Model([state_layers[0], action_layers[0]], concat_layers[-1]) + +class SoftActorUnbounded(Tensorflow_Model): + def __init__(self, observation_space, action_space, use_gpu=True): + super(SoftActorUnbounded, self).__init__(observation_space, action_space, use_gpu) + self.batch_size = ExaGlobals.lookup_params('batch_size') + self.actor_dense = ExaGlobals.lookup_params('actor_dense') + self.actor_dense_act = ExaGlobals.lookup_params('actor_dense_act') + self.actor_out_act = ExaGlobals.lookup_params('actor_out_act') + + assert len(self.actor_dense) >= 1, "Must have at least one actor_dense layer: {}".format(len(self.actor_dense)) + + self.loss = None + self.actor_lr = ExaGlobals.lookup_params('actor_lr') + self.optimizer = tf.keras.optimizers.Adam(self.actor_lr) + + self.upper_bound = action_space.high + self.lower_bound = action_space.low + self.n_actions = action_space.shape[0] + + def _build(self): + last_init = tf.random_uniform_initializer() + last_init = tf.random_uniform_initializer(minval=-0.003, maxval=0.003) + + layers = [] + layers.append(Input(shape=(flatdim(self.observation_space),), batch_size=self.batch_size)) + for i in range(len(self.actor_dense)): + layers.append(Dense(self.actor_dense[i], activation=self.actor_dense_act)(layers[-1])) + layers.append(Dense(self.n_actions, kernel_initializer=last_init)(layers[-1])) + + layers.append(Dense(self.n_actions, kernel_initializer=last_init)(layers[-2])) + layers.append(Lambda(lambda x: tf.exp(x) )(layers[-1])) + self._model = Model(inputs=layers[0], outputs=[layers[-3], layers[-1]]) + + def _compile(self): + """ + This internal function compiles a tf model. + """ + with tf.device(self._device): + self._build() + self._model.compile(loss=self.loss, optimizer=self.optimizer, jit_compile=self.enable_xla) + diff --git a/exarl/agents/replay_buffers/__init__.py b/exarl/agents/replay_buffers/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/exarl/agents/replay_buffers/buffer.py b/exarl/agents/replay_buffers/buffer.py new file mode 100644 index 00000000..72e95084 --- /dev/null +++ b/exarl/agents/replay_buffers/buffer.py @@ -0,0 +1,38 @@ +from exarl.agents.replay_buffers.replay_buffer import ReplayBuffer, SimpleBuffer +from exarl.agents.replay_buffers.prioritized_replay import PrioritizedReplayBuffer +from exarl.agents.replay_buffers.trajectory_buffer import TrajectoryBuffer +from exarl.agents.replay_buffers.nStep_buffer import nStepBuffer +from exarl.utils.globals import ExaGlobals + +class Buffer: + _builders = {"ReplayBuffer": ReplayBuffer, + "PrioritizedReplayBuffer": PrioritizedReplayBuffer, + "TrajectoryBuffer": TrajectoryBuffer, + "nStepBuffer": nStepBuffer, + "SimpleBuffer" : SimpleBuffer} + + _config_args = {"ReplayBuffer": [], + "PrioritizedReplayBuffer": [], + "TrajectoryBuffer": ['buffer_trajectory_length'], + "nStepBuffer":["horizon", "gamma"], + "SimpleBuffer" : [] } + + def create(key=None, **kwargs): + # JS: Lookup which buffer if not passed + if key is None: + key = ExaGlobals.lookup_params('buffer') + + # JS: Ensure buffer is listed + builder = Buffer._builders.get(key) + if not builder: + raise ValueError(key) + # JS: Look to see if capacity was passed + capacity = kwargs.pop("capacity", None) + for config_arg in Buffer._config_args[key]: + # JS: make sure the required kwargs exist or are looked up + if config_arg not in kwargs: + kwargs[config_arg] = ExaGlobals.lookup_params(config_arg) + # JS: Lookup the capacity if it was not passed in + if capacity is None: + capacity = ExaGlobals.lookup_params('buffer_capacity') + return builder(capacity, **kwargs) diff --git a/exarl/agents/replay_buffers/nStep_buffer.py b/exarl/agents/replay_buffers/nStep_buffer.py new file mode 100644 index 00000000..b4ea5735 --- /dev/null +++ b/exarl/agents/replay_buffers/nStep_buffer.py @@ -0,0 +1,62 @@ +import numpy as np +from exarl.agents.replay_buffers.replay_buffer import ReplayBuffer +# np.random.seed(0) + +class nStepBuffer(ReplayBuffer): + """ + Class implements a simple replay buffer + """ + + def __init__(self, capacity, observation_space=None, action_space=None, name="nStep", **kwargs): + """ + Replay buffer constructor + + Parameters + ---------- + capacity : int + Maximum buffer length + observation_space : gym space (optional) + Sample of observation space used to init buffer + action_space : gym space (optional) + Sample of action space used to init buffer + """ + super(nStepBuffer, self).__init__(capacity, observation_space=observation_space, action_space=action_space, name=name) + self.horizon = kwargs['horizon'] + self.gamma = kwargs['gamma'] + + def get_data_from_indices(self, indices): + """ + Returns a list of the of data at given indices + """ + assert self._data is not None, str(self) + " -- not initialized!" + return_list = [] + # Append states + return_list.append(self._data[0][indices]) + + # Append actions + return_list.append(self._data[1][indices]) + + # Calculate nStep rewards, next states, and done indicators + reward_batch = [] + done_batch = [] + next_state_ind = [] + for b_start in indices: + b_end = np.min([self._count-1, b_start + self.horizon - 1]) + done_ind = np.where(self._data[4][np.arange(b_start, b_end+1) % self._capacity])[0] + b_end = b_end if len(done_ind) == 0 else np.arange(b_start, b_end+1)[done_ind[0]] + + reward_batch.append( np.sum(self._data[2][np.arange(b_start,b_end+1) % self._capacity,0] * self.gamma**np.arange(b_end - b_start + 1)) ) + next_state_ind.append( b_end % self._capacity) + done_batch.append( 0 if len(done_ind) == 0 else 1) + + # Append nStep rewards + return_list.append(np.array(reward_batch)[:,None]) + + # Append nStep next state + return_list.append(self._data[3][next_state_ind]) + + # Append nStep done indicators + return_list.append(np.array(done_batch)) + + return return_list + diff --git a/exarl/agents/replay_buffers/prioritized_replay.py b/exarl/agents/replay_buffers/prioritized_replay.py new file mode 100644 index 00000000..9a6c1914 --- /dev/null +++ b/exarl/agents/replay_buffers/prioritized_replay.py @@ -0,0 +1,196 @@ +import random +import numpy as np +from exarl.base.replay_base import Replay_Base + + +class PrioritizedReplayBuffer(Replay_Base): + """ + Class implements Prioritized Experience Replay (PER) + """ + + def __init__(self, capacity, observation_space=None, action_space=None, name="Priority"): + """ Replay buffer constructor + + Parameters + ---------- + capacity : int + Maximum buffer length + observation_space : gym space (optional) + Sample of observation space used to init buffer + action_space : gym space (optional) + Sample of action space used to init buffer + """ + super(PrioritizedReplayBuffer, self).__init__(capacity, name=name) + + self._alpha = 0.5 + self._alpha_decay_rate = 0.99 + self._beta = 0.5 + self._beta_growth_rate = 1.001 + + self.incremental_td_error = 0.0 + self.priorities_sum_alpha = 0 + self.priorities_max = 1 + self.weights_max = 1 + + self._samples = 1 + self.compute_weights = False + + # JS: we are going to try a two tiered approach + # self._data will hold all data + # self._meta will hold (priority, probability, weight, index) + # where index is the index into self._data + self._meta = None + if observation_space is not None and action_space is not None: + self._preallocate((observation_space.sample(), + action_space.sample(), + 0.0, + observation_space.sample(), + False)) + + def _preallocate(self, items): + super()._preallocate(items) + # JS: Tuple is (priority, probability, weight, index) + self._meta = [[0,0,0,i] for i in range(self._capacity)] + + def store(self, state, action, reward, next_state, done): + """ + Stores data in buffer. Allocates data if uninitialized. + + Parameters + ---------- + state : gym space sample + Current state to store + action : gym space sample + Current action to store + reward : float + Reward based on action + next_state : gym space sample + State after action + done : bool + If state is terminal + """ + data = (state, action, reward, next_state, done) + if self._data is None: + self._preallocate(data) + + index = self._count % self._capacity + meta = self._meta[index] + + # JS: This is the full case + if self._count > self._capacity: + + # JS: Subtract our running priority sum + self.priorities_sum_alpha -= meta[0] ** self._alpha + + # JS: Update the max priority if we are overwriting it + if meta[0] == self.priorities_max: + meta[0] = 0 + self.priorities_max = max(self._meta, key=lambda x: x[1])[0] + + # JS: Update the max weight if we are overwriting it + if self.compute_weights: + if meta[2] == self.weights_max: + meta[2] = 0 + self.weights_max = max(self._meta, key=lambda x: x[2])[2] + + priority = self.priorities_max + weight = self.weights_max + self.priorities_sum_alpha += priority ** self._alpha + probability = priority ** self._alpha / self.priorities_sum_alpha + + # JS: Update meta data + meta[0] = priority + meta[1] = probability + meta[2] = weight + + # JS: Actually add data to buffer + for slot, item in zip(self._data, data): + slot[meta[3]] = item + self._count += 1 + + def update_priorities(self, tds, indices): + N = self.size + tds = np.absolute(tds) + self.incremental_td_error + for updated_priority, index in zip(tds, indices): + if updated_priority > self.priorities_max: + self.priorities_max = updated_priority + + if self.compute_weights: + # JS: Annealing the bias + updated_weight = ((N * updated_priority) ** (-self._beta)) / self.weights_max + if updated_weight > self.weights_max: + self.weights_max = updated_weight + else: + updated_weight = 1 + + old_priority = self._meta[index][0] + # JS: Update our priority sum + self.priorities_sum_alpha += (updated_priority ** self._alpha) - (old_priority ** self._alpha) + # JS: Update our probability + updated_probability = (updated_priority ** self._alpha) / self.priorities_sum_alpha + + self._meta[index][0] = updated_priority + self._meta[index][1] = updated_probability + self._meta[index][2] = updated_weight + + def update_parameters(self): + # JS: Update the hypers + self._alpha *= self._alpha_decay_rate + self._beta *= self._beta_growth_rate + if self._beta > 1: + self._beta = 1 + + N = self.size + self.priorities_sum_alpha = sum(meta[0] ** self._alpha for meta in self._meta) + + for i, meta in zip(range(N), self._meta): + meta[1] = meta[0] ** self._alpha / self.priorities_sum_alpha + if self.compute_weights: + meta[2] = ((N * meta[1]) ** (-self._beta)) / self.weights_max + else: + meta[2] = 1 + + def sample_generator(self, batch_size): + start = 0 + random_values = [] + while True: + if start + batch_size <= len(random_values): + indices = random_values[start : start + batch_size] + start += batch_size + yield indices + else: + start = 0 + self.update_parameters() + N = self.size + random_values = random.choices(range(N), + [x[1] for _, x in zip(range(N), self._meta)], + k=batch_size * self._samples) + + def sample(self, batch_size): + assert self.size > 0, str(self) + " -- empty!" + indices = next(self.sample_generator(batch_size)) + assert len(indices) == batch_size + ret = self.get_data_from_indices([self._meta[i][3] for i in indices]) + ret.append(indices) + return ret + + def get_fake_data(self, batch_size): + """ + Returns a transposed batch size elements. Data is garbage, but + useful for sizing RMA window. + + Parameters + ---------- + batch_size : int + batch size to sample + + Returns + ------- + list : + List of np arrays for state, action, reward, next_state, done + """ + assert self._data is not None, "Must have preallocated data with observation and action space in constructor!" + batch_indices = np.random.choice(self._capacity, batch_size) + ret = self.get_data_from_indices(batch_indices) + ret.append(batch_indices) + return ret \ No newline at end of file diff --git a/exarl/agents/replay_buffers/replay_buffer.py b/exarl/agents/replay_buffers/replay_buffer.py new file mode 100644 index 00000000..b3258fbc --- /dev/null +++ b/exarl/agents/replay_buffers/replay_buffer.py @@ -0,0 +1,146 @@ +import numpy as np +from exarl.base.replay_base import Replay_Base +# np.random.seed(0) + +class ReplayBuffer(Replay_Base): + """ + Class implements a simple replay buffer + """ + + def __init__(self, capacity, observation_space=None, action_space=None, name="Replay"): + """ + Replay buffer constructor + + Parameters + ---------- + capacity : int + Maximum buffer length + observation_space : gym space (optional) + Sample of observation space used to init buffer + action_space : gym space (optional) + Sample of action space used to init buffer + """ + super(ReplayBuffer, self).__init__(capacity, name=name) + if observation_space is not None and action_space is not None: + self._preallocate((observation_space.sample(), + action_space.sample(), + [0.0], + observation_space.sample(), + False)) + + def store(self, state, action, reward, next_state, done): + """ + Stores data in buffer. Allocates data if uninitialized. + + Parameters + ---------- + state : gym space sample + Current state to store + action : gym space sample + Current action to store + reward : float + Reward based on action + next_state : gym space sample + State after action + done : bool + If state is terminal + """ + data = (state, action, reward, next_state, done) + if self._data is None: + self._preallocate(data) + + for slot, item in zip(self._data, data): + slot[self._count % self._capacity] = item + + self._count += 1 + + def sample(self, batch_size): + """ + Returns a transposed batch size elements + + Parameters + ---------- + batch_size : int + batch size to sample + + Returns + ------- + list : + List of np arrays for state, action, reward, next_state, done + """ + assert self.size > 0, str(self) + " -- empty!" + + batch_indices = np.random.choice(len(self), batch_size) + return self.get_data_from_indices(batch_indices) + + def get_fake_data(self, batch_size): + """ + Returns a transposed batch size elements. Data is garbage, but + useful for sizing RMA window. + + Parameters + ---------- + batch_size : int + batch size to sample + + Returns + ------- + list : + List of np arrays for state, action, reward, next_state, done + """ + assert self._data is not None, "Must have preallocated data with observation and action space in constructor!" + batch_indices = np.random.choice(self._capacity, batch_size) + return self.get_data_from_indices(batch_indices) + +class SimpleBuffer(ReplayBuffer): + def __init__(self, capacity, observation_space=None, action_space=None, name="Simple"): + """ + TODO: Write + + Parameters + ---------- + capacity : int + Maximum buffer length + observation_space : gym space (optional) + Sample of observation space used to init buffer + action_space : gym space (optional) + Sample of action space used to init buffer + """ + super(SimpleBuffer, self).__init__(capacity, observation_space=observation_space, action_space=action_space, name=name) + + def sample(self, batch_size): + """ + Returns a transposed batch size elements + + Parameters + ---------- + batch_size : int + batch size to sample + + Returns + ------- + list : + List of np arrays for state, action, reward, next_state, done + """ + assert self.size > 0, str(self) + " -- empty!" + ret = self.get_data_from_indices(range(self.size)) + self._count = 0 + return ret + + def get_fake_data(self, batch_size): + """ + Returns a transposed batch size elements. Data is garbage, but + useful for sizing RMA window. + + Parameters + ---------- + batch_size : int + batch size to sample + + Returns + ------- + list : + List of np arrays for state, action, reward, next_state, done + """ + assert self._data is not None, "Must have preallocated data with observation and action space in constructor!" + return self.get_data_from_indices(range(batch_size)) diff --git a/exarl/agents/replay_buffers/trajectory_buffer.py b/exarl/agents/replay_buffers/trajectory_buffer.py new file mode 100644 index 00000000..9babffdd --- /dev/null +++ b/exarl/agents/replay_buffers/trajectory_buffer.py @@ -0,0 +1,126 @@ +import numpy as np +from exarl.base.replay_base import Replay_Base +# np.random.seed(0) + +class TrajectoryBuffer(Replay_Base): + """ + TODO: WRITE DESCRIPTION HERE... + """ + + def __init__(self, capacity, buffer_trajectory_length=8, observation_space=None, action_space=None, name="Trajectory"): + """ Replay buffer constructor + + Parameters + ---------- + capacity : int + Maximum buffer length + trajectory_length : int + Length of max trajectory + observation_space : gym space (optional) + Sample of observation space used to init buffer + action_space : gym space (optional) + Sample of action space used to init buffer + """ + super(TrajectoryBuffer, self).__init__(capacity, name=name) + self._trajectory_length = buffer_trajectory_length + if observation_space is not None and action_space is not None: + self._preallocate((observation_space.sample(), + action_space.sample(), + 0.0, + observation_space.sample(), + False), + capacity = self._capacity + 1) + + def store(self, state, action, reward, next_state, done): + """ + Stores data in buffer. Allocates data if uninitialized. + + Parameters + ---------- + state : gym space sample + Current state to store + action : gym space sample + Current action to store + reward : float + Reward based on action + next_state : gym space sample + State after action + done : bool + If state is terminal + """ + data = (state, action, reward, next_state, done) + if self._data is None: + self._preallocate(data, capacity = self._capacity + 1) + + index = self._count % self._capacity + for slot, item in zip(self._data, data): + slot[index] = item + self._count += 1 + + def get_padded_indicies(self, end): + indicies = [] + if self._count == 0: + indicies = [self._capacity] * self._trajectory_length + else: + start = 0 if end < self._trajectory_length else end - self._trajectory_length + flag = False + for i in reversed(range(start,end)): + index = i % self._capacity + if self._data[-1][index] or flag: + indicies.append(self._capacity) + flag = True + else: + indicies.append(index) + indicies.extend([self._capacity] * (self._trajectory_length - len(indicies))) + indicies.reverse() + return indicies + + def sample(self, batch_size): + """ + Returns a transposed batch size elements + We prepad when based on following paper: + https://arxiv.org/pdf/1903.07288.pdf + + Parameters + ---------- + batch_size : int + batch size to sample + + Returns + ------- + list : + List of np arrays for state, action, reward, next_state, done + """ + assert self.size > 0, str(self) + " -- empty!" + maxIndex = len(self) + indices = np.random.choice(maxIndex, batch_size) + indices = self._count - indices + # assert (indices <= self._count).sum() == indices.size, str(indices) + " Size: " + str(self._count) + ret = [] + for i in indices: + ret.extend(self.get_padded_indicies(i)) + return self.get_data_from_indices(ret) + + def last(self): + indicies = self.get_padded_indicies(self._count) + return self.get_data_from_indices(indicies) + + def get_fake_data(self, batch_size): + """ + Returns a transposed batch size elements. Data is garbage, but + useful for sizing RMA window. + + Parameters + ---------- + batch_size : int + batch size to sample + + Returns + ------- + list : + List of np arrays for state, action, reward, next_state, done + """ + assert self._data is not None, "Must have preallocated data with observation and action space in constructor!" + batch_indices = [self._capacity] * (self._trajectory_length * batch_size) + # batch_indices = [self._capacity] * batch_size + return self.get_data_from_indices(batch_indices) \ No newline at end of file diff --git a/exarl/base/agent_base.py b/exarl/base/agent_base.py index 290b0973..0ae28cea 100644 --- a/exarl/base/agent_base.py +++ b/exarl/base/agent_base.py @@ -30,6 +30,7 @@ # under Contract DE-AC05-76RL01830 import os import sys +import pickle from abc import ABC, abstractmethod file_path = os.path.dirname(os.path.realpath(__file__)) @@ -52,37 +53,56 @@ def get_weights(self): pass @abstractmethod - def set_weights(self): + def set_weights(self, weights): """set target model weights """ pass @abstractmethod - def train(self): + def train(self, batch): """train the agent """ pass + # @abstractmethod + # def update_target(self): + # pass + @abstractmethod - def action(self): + def action(self, state): """next action based on current state """ pass @abstractmethod - def load(self): - """load weights + def has_data(self): + """return true if agent has experiences from simulation """ pass @abstractmethod - def save(self, results_dir): - """save weights - """ + def generate_data(self): pass @abstractmethod - def has_data(self): - """return true if agent has experiences from simulation - """ + def remember(self, state, action, reward, next_state, done): + pass + + @abstractmethod + def train_return(self, args): pass + + def load(self, filename): + weights = None + with open(filename, "rb") as f: + weights = pickle.load(f) + if weights is not None: + print("Loading from: ", filename) + self.set_weights(weights) + else: + print("Failed loading weights from:", filename) + + def save(self, filename): + weights = self.get_weights() + with open(filename, "wb") as f: + pickle.dump(weights, f) diff --git a/exarl/base/comm_base.py b/exarl/base/comm_base.py index a3ce50f1..b8cbf086 100644 --- a/exarl/base/comm_base.py +++ b/exarl/base/comm_base.py @@ -8,9 +8,6 @@ # nonexclusive, paid-up, irrevocable worldwide license in this material to reproduce, prepare # derivative works, distribute copies to the public, perform publicly and display publicly, and # to permit others to do so. - -import sys -import os from abc import ABC, abstractmethod class ExaComm(ABC): @@ -19,19 +16,25 @@ class ExaComm(ABC): env_comm = None learner_comm = None num_learners = 1 + procs_per_env = 1 def __init__(self, comm, procs_per_env, num_learners): if ExaComm.global_comm is None: ExaComm.num_learners = num_learners + ExaComm.procs_per_env = procs_per_env ExaComm.global_comm = comm ExaComm.agent_comm, ExaComm.env_comm, ExaComm.learner_comm = comm.split(procs_per_env, num_learners) + @abstractmethod + def raw(self): + pass + @abstractmethod def send(self, data, dest, pack=False): pass @abstractmethod - def recv(self, data_type, data_count, source): + def recv(self, data, source=None): pass @abstractmethod @@ -58,17 +61,26 @@ def time(self): def split(self, procs_per_env): pass + @staticmethod def is_learner(): - if ExaComm.agent_comm is not None: - if ExaComm.agent_comm.rank < ExaComm.num_learners: - return True - return False + return ExaComm.learner_comm is not None + @staticmethod def is_actor(): - if ExaComm.agent_comm is not None: - if ExaComm.agent_comm.rank >= ExaComm.num_learners: - return True - return False + return ExaComm.env_comm is not None + @staticmethod def is_agent(): return ExaComm.agent_comm is not None + + @staticmethod + def reset(): + ExaComm.global_comm = None + ExaComm.agent_comm = None + ExaComm.env_comm = None + ExaComm.learner_comm = None + ExaComm.num_learners = 1 + ExaComm.procs_per_env = 1 + + def get_MPI(): + return ExaComm.global_comm.MPI diff --git a/exarl/base/data_exchange.py b/exarl/base/data_exchange.py index 461aeedb..59a27b0f 100644 --- a/exarl/base/data_exchange.py +++ b/exarl/base/data_exchange.py @@ -8,7 +8,6 @@ # nonexclusive, paid-up, irrevocable worldwide license in this material to reproduce, prepare # derivative works, distribute copies to the public, perform publicly and display publicly, and # to permit others to do so. - import sys import os from abc import ABC, abstractmethod @@ -17,12 +16,21 @@ # from exarl.utils.introspect import introspectTrace class ExaData(ABC): - def __init__(self, dataType, size, comm_size=1, max_model_lag=None, name=None): - self.dataType = dataType + def __init__(self, comm, length, fail_push, data=None, size=None, name=None): + assert data is not None or size is not None, "ExaData: Must provided size or example data for MPI data structures" + # JS: This is fine since it is a singleton for MPI based communicators. + # Will throw an error if not using MPI base comm + self.MPI = ExaComm.get_MPI() + self.comm = comm + self.length = length + self.fail_push = fail_push + + if size is None: + dataBytes = self.MPI.pickle.dumps(data) + # JS: plus one for weird pickling errors... + size = len(dataBytes) + 1 + self.dataSize = size - if max_model_lag == "none": - max_model_lag = None - self.max_model_lag = max_model_lag self.name = name @abstractmethod @@ -32,30 +40,3 @@ def pop(self, rank, count=1): @abstractmethod def push(self, data, rank=None): pass - - # TODO: Think about low and high as parameters - def get_data(self, learner_counter, low, high): - actor_idx = np.random.randint(low=low, high=high, size=1)[0] - batch_data = self.pop(actor_idx) - if batch_data: - batch_data, actor_counter = batch_data - if self.max_model_lag is None or learner_counter - actor_counter <= self.max_model_lag: - return batch_data, actor_idx, actor_counter - return None, -1, -1 - - # def get_data(self, learner_counter, low, high, attempts=None): - # batch_data = None - # actor_counter = -1 - # actor_idx = 0 - # attempt = 0 - # while attempts is None or attempt < attempts: - # actor_idx = 0 - # if self.comm_size > 1: - # actor_idx = np.random.randint(low=low, high=high, size=1)[0] - # batch_data = self.pop(actor_idx) - # if batch_data: - # batch_data, actor_counter = batch_data - # if self.max_model_lag is None or learner_counter - actor_counter <= self.max_model_lag: - # break - # attempt += 1 - # return batch_data, actor_idx, actor_counter diff --git a/exarl/base/dataset_base.py b/exarl/base/dataset_base.py deleted file mode 100644 index 15702375..00000000 --- a/exarl/base/dataset_base.py +++ /dev/null @@ -1,60 +0,0 @@ -# This material was prepared as an account of work sponsored by an agency of the -# United States Government. Neither the United States Government nor the United -# States Department of Energy, nor Battelle, nor any of their employees, nor any -# jurisdiction or organization that has cooperated in the development of these -# materials, makes any warranty, express or implied, or assumes any legal -# liability or responsibility for the accuracy, completeness, or usefulness or -# any information, apparatus, product, software, or process disclosed, or -# represents that its use would not infringe privately owned rights. Reference -# herein to any specific commercial product, process, or service by trade name, -# trademark, manufacturer, or otherwise does not necessarily constitute or imply -# its endorsement, recommendation, or favoring by the United States Government -# or any agency thereof, or Battelle Memorial Institute. The views and opinions -# of authors expressed herein do not necessarily state or reflect those of the -# United States Government or any agency thereof. -# PACIFIC NORTHWEST NATIONAL LABORATORY -# operated by -# BATTELLE -# for the -# UNITED STATES DEPARTMENT OF ENERGY -# under Contract DE-AC05-76RL01830 -from numpy.core.arrayprint import _none_or_positive_arg -import tensorflow as tf -import numpy as np -import exarl.mpi_settings as mpi_settings -import time - -class BufferDataset(tf.data.Dataset): - def _generator(data_buffer, data_win): - # actor_idx = np.random.randint(low=1, high=mpi_settings.agent_comm.size, size=1) - # # Get data buffer from RMA window - # data_win.Lock(actor_idx) - # data_win.Get(data_buffer, target_rank=actor_idx) - # data_win.Unlock(actor_idx) - data_buffer += 1 - yield (data_buffer,) - - def __new__(cls, data_buffer, data_win): - return tf.data.Dataset.from_generator( - cls._generator, - output_types=tf.float32, - output_shapes=(None, None), - args=(data_buffer, data_win,) - ) - -def benchmark(dataset, num_epochs=2): - start_time = time.perf_counter() - for epoch_num in range(num_epochs): - for sample in dataset: - # Performing a training step - time.sleep(0.01) - print("Execution time:", time.perf_counter() - start_time) - -def bellman_equation(raw_data): - return raw_data + 1 - - -data_buffer = np.arange(10) -data_win = 0 -benchmark(BufferDataset(data_buffer, data_win).map(bellman_equation)) -benchmark(BufferDataset(data_buffer, data_win).prefetch(-1).cache().batch(256).map(bellman_equation)) diff --git a/exarl/base/env_base.py b/exarl/base/env_base.py index e12d8d9a..cb40c09a 100755 --- a/exarl/base/env_base.py +++ b/exarl/base/env_base.py @@ -8,26 +8,90 @@ # nonexclusive, paid-up, irrevocable worldwide license in this material to reproduce, prepare # derivative works, distribute copies to the public, perform publicly and display publicly, and # to permit others to do so. - - -import json import os -import sys -import gym -import time +import numpy as np +from gym import spaces from gym import Wrapper from exarl.base.comm_base import ExaComm +from exarl.utils.globals import ExaGlobals class ExaEnv(Wrapper): def __init__(self, env, **kwargs): - super(ExaEnv, self).__init__(env) + self.env = env + self.env.workflow_episode = 0 + self.env.workflow_step = 0 # Use relative path not absolute self.base_dir = os.path.dirname(__file__) - print(self.base_dir) self.env_comm = ExaComm.env_comm + self.action_type = ExaGlobals.lookup_params('convert_action_type') + self.original_env_type = type(self.env.action_space) + + if self.action_type == "Discrete": + if isinstance(self.env.action_space, spaces.Box): + self.old_action_space = self.env.action_space + self.num_discrete_steps = int(ExaGlobals.lookup_params('num_discrete_step')) + + self.min = self.env.action_space.low + self.increment = (self.env.action_space.high - self.env.action_space.low) / self.num_discrete_steps + + self.flat_dim = 1 + for x in self.env.action_space.shape: + self.flat_dim *= x + + if self.flat_dim == 1: + self.old_contains = self.env.action_space + self.env.action_space = spaces.Discrete(self.num_discrete_steps) + else: + self.old_contains = self.env.action_space.contains + self.env.action_space = spaces.MultiDiscrete(self.flat_dim * [self.num_discrete_steps]) + print("Converted Action Space to Discrete", self.flat_dim) + + else: + self.action_type = None + + elif self.action_type == "Continuous": + if isinstance(self.env.action_space, spaces.Discrete): + # JS: newer versions of gym have start + try: + self.min = self.env.action_space.start * np.ones((1,), dtype=int) + except AttributeError: + self.min = np.zeros((1,), dtype=int) + + self.old_action_space = self.env.action_space + self.env.action_space = spaces.Box(low=0, high=self.env.action_space.n - 1, shape=(1,)) + self.unpack_action = True + print("Converted Action Space to Continuous Box 1") + + elif isinstance(self.env.action_space, spaces.MultiDiscrete): + # JS: newer versions of gym have start + try: + self.min = self.env.action_space.start * np.ones(self.env.action_space.shape(), dtype=int) + except AttributeError: + self.min = np.zeros(self.env.action_space.shape(), dtype=int) + + self.old_action_space = self.env.action_space + self.env.action_space = spaces.Box(low=0, high=self.env.action_space.n - 1, shape=self.env.action_space.shape()) + self.unpack_action = False + print("Converted Action Space to Continuous Box N") + + else: + self.action_type = None + + def set_episode_count(self, episode_count): + ''' + Method to keep track of episode count in the env + ''' + self.env.workflow_episode = episode_count + + def set_step_count(self, step_count): + ''' + Method to keep track of step per episode in the env + ''' + self.env.workflow_step = step_count + def set_results_dir(self, results_dir): ''' Default method to save environment specific information @@ -36,3 +100,29 @@ def set_results_dir(self, results_dir): os.makedirs(results_dir) # Top level directory self.results_dir = results_dir + + def swap_action_spaces(self): + # print(self.env.workflow_episode, self.env.workflow_step, "Old:", type(self.old_action_space), "New:", type(self.env.action_space), flush=True) + temp = self.env.action_space + self.env.action_space = self.old_action_space + self.old_action_space = temp + + def step(self, action): + if self.action_type == "Discrete": + self.swap_action_spaces() + ret = self.env.step(action * self.increment + self.min) + self.swap_action_spaces() + + elif self.action_type == "Continuous": + new_action = action.astype(int) + self.min + if self.unpack_action: + new_action = new_action.item(0) + + self.swap_action_spaces() + ret = self.env.step(new_action) + self.swap_action_spaces() + + else: + ret = self.env.step(action) + return ret + diff --git a/exarl/base/learner_base.py b/exarl/base/learner_base.py index 416a9d85..4e3fcdcb 100755 --- a/exarl/base/learner_base.py +++ b/exarl/base/learner_base.py @@ -8,126 +8,115 @@ # nonexclusive, paid-up, irrevocable globalwide license in this material to reproduce, prepare # derivative works, distribute copies to the public, perform publicly and display publicly, and # to permit others to do so. - -import time +import os +import sys import gym import exarl.envs import exarl.agents import exarl.workflows - +from exarl.utils.globals import ExaGlobals +from exarl.base.env_base import ExaEnv +from exarl.base.comm_base import ExaComm from exarl.network.simple_comm import ExaSimple # from exarl.network.mpi_comm import ExaMPI -from exarl.base.comm_base import ExaComm -from exarl.base.env_base import ExaEnv - -import os -import csv -import sys -import json - -from exarl.utils import log -import exarl.utils.candleDriver as cd -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) - +logger = ExaGlobals.setup_logger(__name__) class ExaLearner: def __init__(self, comm=None): + # Setup agent and environments + agent_id = ExaGlobals.lookup_params('agent') + env_id = ExaGlobals.lookup_params('env') + workflow_id = ExaGlobals.lookup_params('workflow') - # Default training - self.nepisodes = 1 - self.nsteps = 10 - self.results_dir = './results' # Default dir, will be overridden by candle - self.do_render = False - - self.learner_procs = int(cd.lookup_params('learner_procs', '1')) - self.process_per_env = int(cd.lookup_params('process_per_env', '1')) - self.action_type = cd.lookup_params('action_type', 'variable') + learner_procs = int(ExaGlobals.lookup_params('learner_procs')) + process_per_env = int(ExaGlobals.lookup_params('process_per_env')) - # Setup agent and environments - self.agent_id = 'exarl.agents:' + cd.lookup_params('agent', "") - self.env_id = 'exarl.envs:' + cd.lookup_params('env', "") - self.workflow_id = 'exarl.workflows:' + cd.lookup_params('workflow', "") + self.nepisodes = int(ExaGlobals.lookup_params('n_episodes')) + self.nsteps = int(ExaGlobals.lookup_params('n_steps')) + self.action_type = ExaGlobals.lookup_params('action_type') + self.results_dir = ExaGlobals.lookup_params('output_dir') - # Setup MPI - # Global communicator - # ExaMPI(comm, self.process_per_env) - ExaSimple(comm, self.process_per_env, self.learner_procs) - self.global_comm = ExaComm.global_comm - self.global_size = ExaComm.global_comm.size + # Setup MPI Global communicator + ExaSimple(comm, process_per_env, learner_procs) # Sanity check before we actually allocate resources - if self.global_size < self.process_per_env: + workflow_id = self.sanity_check(workflow_id) + + self.create_output_dir() + self.agent, self.env, self.workflow = self.make(agent_id, env_id, workflow_id) + self.set_training() + if ExaComm.is_actor(): + self.env.reset() + + def sanity_check(self, workflow_id): + global_size = ExaComm.global_comm.size + learner_size = ExaComm.num_learners + actor_size = int((global_size - learner_size) / ExaComm.procs_per_env) + agent_size = actor_size + learner_size + env_size = actor_size * ExaComm.procs_per_env + + if self.nepisodes < actor_size: + sys.exit("EXARL::ERROR More resources allocated for the number of episodes.\n" + + "Number of ranks should be less than or equal to the number of episodes.") + if global_size < ExaComm.procs_per_env: sys.exit('EXARL::ERROR Not enough processes.') - if self.workflow_id == 'exarl.workflows:sync': - if self.learner_procs > 1: + if workflow_id == 'sync': + if learner_size > 1: sys.exit('EXARL::sync learner only works with single learner.') - if self.global_size != self.process_per_env: - sys.exit('EXARL::sync learner can only run one env group.') + if global_size != ExaComm.procs_per_env: + sys.exit('EXARL::sync learner procs_per_env must equal the comms global size.') else: - if (self.global_size - self.learner_procs) % self.process_per_env != 0: + if (global_size - learner_size) % ExaComm.procs_per_env != 0: sys.exit('EXARL::ERROR Uneven number of processes.') - if self.learner_procs > 1 and self.workflow_id != 'exarl.workflows:rma': + + if learner_size > 1 and workflow_id != 'rma': print('') print('_________________________________________________________________') print('Multilearner is only supported in RMA, running rma workflow ...') print('_________________________________________________________________', flush=True) - self.workflow_id = 'exarl.workflows:' + 'rma' - if self.global_size < 2 and self.workflow_id != 'exarl.workflows:sync': + workflow_id = 'rma' + + if (global_size < 2 or ExaComm.procs_per_env == global_size) and workflow_id != 'sync': print('') print('_________________________________________________________________') print('Not enough processes, running synchronous single learner ...') print('_________________________________________________________________', flush=True) - self.workflow_id = 'exarl.workflows:' + 'sync' - - self.agent, self.env, self.workflow = self.make() - self.env.unwrapped.spec.max_episode_steps = self.nsteps - self.env.unwrapped._max_episode_steps = self.nsteps + workflow_id = 'sync' + return workflow_id - self.env.spec.max_episode_steps = self.nsteps - self.env._max_episode_steps = self.nsteps - self.set_config() - # self.env.set_env() - self.env.reset() - - def make(self): + def make(self, agent_id, env_id, workflow_id): # Create environment object - env = gym.make(self.env_id).unwrapped + env = gym.make(env_id).unwrapped env = ExaEnv(env) - # Create agent object - agent = None + # Only agent_comm processes will create agents - if ExaComm.is_learner(): - agent = exarl.agents.make(self.agent_id, env=env, is_learner=True) - elif ExaComm.is_actor(): - agent = exarl.agents.make(self.agent_id, env=env, is_learner=False) - else: - logger.debug('Does not contain an agent') + agent = None + if ExaComm.is_agent(): + agent = exarl.agents.make(agent_id, env=env, is_learner=ExaComm.is_learner()) + # Create workflow object - workflow = exarl.workflows.make(self.workflow_id) + workflow = exarl.workflows.make(workflow_id, agent=agent, env=env) return agent, env, workflow - def set_training(self, nepisodes, nsteps): - self.nepisodes = nepisodes - self.nsteps = nsteps - if self.global_size > self.nepisodes: - sys.exit( - 'EXARL::ERROR There is more resources allocated for the number of episodes.\nnprocs should be less than nepisodes.') + def set_training(self): self.env.unwrapped._max_episode_steps = self.nsteps self.env.unwrapped.spec.max_episode_steps = self.nsteps self.env.spec.max_episode_steps = self.nsteps self.env._max_episode_steps = self.nsteps - # Use with CANDLE - def set_config(self): - params = cd.run_params - self.set_training(int(params['n_episodes']), int(params['n_steps'])) - self.results_dir = params['output_dir'] - if not os.path.exists(self.results_dir): - if self.global_comm.rank == 0: + def create_output_dir(self): + if ExaComm.global_comm == 0: + if not os.path.exists(self.results_dir): os.makedirs(self.results_dir) - def render_env(self): - self.do_render = True - def run(self): self.workflow.run(self) + + def final_number_of_episodes(self): + return self.workflow.get_total_episodes_run() + + def final_total_reward(self): + return self.workflow.get_total_reward() + + def final_rolling_reward(self): + return self.workflow.get_rolling_reward() diff --git a/exarl/base/replay_base.py b/exarl/base/replay_base.py new file mode 100644 index 00000000..053a92c0 --- /dev/null +++ b/exarl/base/replay_base.py @@ -0,0 +1,122 @@ +from abc import ABC, abstractmethod +import numpy as np + +class Replay_Base(ABC): + """ + Base class of a replay buffer + + Attributes + ---------- + _capacity : int + Max allotted number of elements for buffer + _count : int + Total number of elements added + _data : np.array + The buffer of actual data + + """ + def __init__(self, capacity, name=None): + """ + Parameters + ---------- + capacity : int + Max allotted number of elements for buffer + """ + self._name = name + self._capacity = capacity + self._count = 0 + self._data = None + + def _preallocate(self, items, capacity=None): + """ + Takes a list of representative data and allocates space for buffer + capacity : int + Max allotted number of elements for buffer. If None, _capacity will be used. + """ + if capacity is None: + capacity = self._capacity + temp = [] + for item in items: + temp.append(np.asarray(item)) + + self._data = [np.zeros(dtype=x.dtype, shape=(capacity,) + x.shape) + for x in temp] + + def reset(self): + """ + Resets the replay + """ + self._data = None + + def get_data_from_indices(self, indices): + """ + Returns a list of the of data at given indices + """ + assert self._data is not None, str(self) + " -- not initialized!" + return [slot[indices] for slot in self._data] + + @property + def is_full(self) -> bool: + """ + Returns True if buffer is full + """ + return self._capacity <= self._count + + @property + def capacity(self) -> int: + """ + Returns capacity of buffer + """ + return self._capacity + + @property + def size(self) -> int: + """ + Number of elements in buffer + """ + return min(self._capacity, self._count) + + def __len__(self): + """ + Returns number of elements in buffer + """ + return self.size + + def __repr__(self): + """ + String representation for buffer + """ + return 'Replay {}: allocated={}, capacity={}, size={}, added={}'.format( + self._name, + self._data is not None, + self._capacity, + min(self._capacity, self._count), + self._count) + + @abstractmethod + def sample(self, batch_size): + """ + Should return a sample of buffer + """ + raise NotImplementedError + + @abstractmethod + def store(self): + """ + Stores new elements and should adds to the count + """ + raise NotImplementedError + + def get_fake_data(self): + """ + This is used to get representative data for RMA learner. + Override to use RMA! + """ + return None + + def bulk_store(self, data): + assert len(data) == len(self._data) + for slot, array in zip(self._data, data): + for i, item in enumerate(array): + slot[(self._count + i) % self._capacity] = item + self._count += len(data[0]) \ No newline at end of file diff --git a/exarl/base/workflow_base.py b/exarl/base/workflow_base.py index aee36c55..4d8e9462 100644 --- a/exarl/base/workflow_base.py +++ b/exarl/base/workflow_base.py @@ -8,11 +8,9 @@ # nonexclusive, paid-up, irrevocable worldwide license in this material to reproduce, prepare # derivative works, distribute copies to the public, perform publicly and display publicly, and # to permit others to do so. - - +from exarl.base.comm_base import ExaComm from abc import ABC, abstractmethod - class ExaWorkflow(ABC): def __init__(self, **kwargs): diff --git a/exarl/candlelib/candle/__init__.py b/exarl/candlelib/candle/__init__.py index e412917c..1d5d9f1c 100644 --- a/exarl/candlelib/candle/__init__.py +++ b/exarl/candlelib/candle/__init__.py @@ -60,7 +60,7 @@ # import benchmark-dependent utils import sys -if search(sys.modules, 'keras'): +if search(sys.modules, 'keras') or search(sys.modules, 'tensorflow'): print('Importing candle utils for keras') # import from keras_utils diff --git a/exarl/candlelib/default_utils.py b/exarl/candlelib/default_utils.py index 2e7bba2c..d17bc323 100644 --- a/exarl/candlelib/default_utils.py +++ b/exarl/candlelib/default_utils.py @@ -10,7 +10,6 @@ import os import sys -import gzip import argparse try: import configparser @@ -356,7 +355,9 @@ def finalize_parameters(bmk): # print("Configuration file: ", conffile) fileParameters = bmk.read_config_file(conffile) # aux.config_file)#args.config_file) # Get command-line parameters - args = bmk.parser.parse_args() + # args = bmk.parser.parse_args() + args, extras = bmk.parser.parse_known_args() + print('The following arguments were not processed:', extras) # print ('Params:', fileParameters) # Consolidate parameter set. Command-line parameters overwrite file configuration gParameters = args_overwrite_config(args, fileParameters) @@ -472,7 +473,11 @@ def get_common_parser(parser): parser.add_argument("--experiment_id", default="EXP000", type=str, help="set the experiment unique identifier") - parser.add_argument("--run_id", default="RUN000", type=str, help="set the run unique identifier") + parser.add_argument("--run_id", default=argparse.SUPPRESS, type=str, help="set the run unique identifier") + + parser.add_argument("--horizon", default=1, type=int, help="nStep buffer hoizon for DDPG and TD3 Calculations") + + parser.add_argument("--sac_alpha", default=0.01, type=float, help="Alpha parameter for Soft Actor-Critic, which balances the entropy and reward terms in the Q-loss.") # Model definition # Model Architecture @@ -587,7 +592,6 @@ def get_common_parser(parser): return parser - def args_overwrite_config(args, config): """Overwrite configuration parameters with parameters specified via command-line. @@ -643,6 +647,57 @@ def get_choice(name): return mapped +def get_files(dir, filter=None, singleLevel=False): + """ + This grabs all the files in a directory. The filter is used + to select files that match a sub-string. If no filters is + supplied, all files in the directory will be return. + + Parameters + ---------- + dir : str + Directory to get files from + filter : str, optional + Sub-strings to look for in filename + + Returns + ------- + list + list of filenames + """ + ret = [] + for root, dirs, files in os.walk(dir): + for f in files: + if filter is None or filter in f: + file = os.path.join(root, f) + ret.append(file) + if singleLevel: + break + return ret + +def get_next_run(output_dir): + """ + This will look for the next available RUN directory without any logs. + There is a race condition if the exp is started but no logs are written. + The purpose of this function is to overwrite logs leading to + incorrect plotting of results. + + Parameters + ---------- + output_dir : string + The dir to run the lowest level exp in. + """ + num = 0 + next_run = "RUN000" + dirs = list(os.listdir(output_dir)) + while next_run in dirs: + files = get_files(os.path.join(output_dir, next_run), filter=".log", singleLevel=True) + if len(files): + next_run = "RUN" + "{0:03d}".format(num) + num += 1 + else: + break + return next_run def directory_from_parameters(params, commonroot='Output'): """ Construct output directory path with unique IDs from parameters @@ -655,21 +710,30 @@ def directory_from_parameters(params, commonroot='Output'): String to specify the common folder to store results. """ - if commonroot in set(['.', './']): # Same directory --> convert to absolute path outdir = os.path.abspath('.') else: # Create path specified outdir = os.path.abspath(os.path.join('.', commonroot)) if not os.path.exists(outdir): os.makedirs(outdir, exist_ok=True) + while(not os.path.exists(outdir)): + pass outdir = os.path.abspath(os.path.join(outdir, params['experiment_id'])) if not os.path.exists(outdir): os.makedirs(outdir, exist_ok=True) + while(not os.path.exists(outdir)): + pass + + # Save to the next available run + if 'run_id' not in params: + params['run_id'] = get_next_run(outdir) outdir = os.path.abspath(os.path.join(outdir, params['run_id'])) if not os.path.exists(outdir): os.makedirs(outdir, exist_ok=True) + while(not os.path.exists(outdir)): + pass return outdir @@ -728,7 +792,7 @@ def parse_from_common(self): # Parse has been split between arguments that are common with the default neon parser # and all the other options parser = self.parser - if self.framework is not 'neon': + if self.framework != 'neon': parser = get_default_neon_parser(parser) parser = get_common_parser(parser) diff --git a/exarl/candlelib/viz_utils.py b/exarl/candlelib/viz_utils.py index aef27b72..02f44cd4 100644 --- a/exarl/candlelib/viz_utils.py +++ b/exarl/candlelib/viz_utils.py @@ -184,7 +184,7 @@ def plot_histogram_error_per_sigma(sigma, yerror, method=None, figprefix=None): fig = plt.figure(figsize=(14, 16)) legend = [] for ii in range(6): # (H.shape[0]): - if ii is not 1: + if ii != 1: plt.plot(yedges[0:H.shape[1]], H[ii, :] / np.sum(H[ii, :]), marker='o', markersize=12, lw=6.) legend.append(str((xedges[ii] + xedges[ii + 1]) / 2)) diff --git a/exarl/config/agent_cfg/BSUITE-BASE-v0.json b/exarl/config/agent_cfg/BSUITE-BASE-v0.json new file mode 100644 index 00000000..098b04a3 --- /dev/null +++ b/exarl/config/agent_cfg/BSUITE-BASE-v0.json @@ -0,0 +1,16 @@ +{ + "which_agent" : "dqn", + "bsuite_default" : "True", + "batch_size" : 32, + "discount" : 0.99, + "replay_capacity" : 10000, + "min_replay_size" : 100, + "sgd_period" : 1, + "update_target_frequency" : 1, + "epsilon" : 0.05, + "seed" : 42, + "learning_rate" : 1e-3, + + "max_sequence_length" : 32, + "td_lambda" : 0.9 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/BSUITE-BASE-v1.json b/exarl/config/agent_cfg/BSUITE-BASE-v1.json new file mode 100644 index 00000000..0c8cd518 --- /dev/null +++ b/exarl/config/agent_cfg/BSUITE-BASE-v1.json @@ -0,0 +1,17 @@ +{ + "which_agent" : "dqn", + "train_frequency" : 1, + "bsuite_default" : "True", + "batch_size" : 32, + "discount" : 0.99, + "replay_capacity" : 10000, + "min_replay_size" : 100, + "sgd_period" : 1, + "update_target_frequency" : 1, + "epsilon" : 0.05, + "seed" : 42, + "learning_rate" : 1e-3, + + "max_sequence_length" : 32, + "td_lambda" : 0.9 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/BSUITE-DQN-v0.json b/exarl/config/agent_cfg/BSUITE-DQN-v0.json new file mode 100644 index 00000000..ea784f8c --- /dev/null +++ b/exarl/config/agent_cfg/BSUITE-DQN-v0.json @@ -0,0 +1,13 @@ +{ + "batch_size" : 32, + "discount" : 0.99, + "min_replay_size" : 100, + "sgd_period" : 1, + "update_target_frequency" : 1, + "epsilon" : 0.05, + "seed" : 42, + "learning_rate" : 1e-3, + "buffer" : "ReplayBuffer", + "buffer_capacity" : 10000, + "buffer_trajectory_length" : 4 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/DDPG-v0.json b/exarl/config/agent_cfg/DDPG-v0.json index 7cb9de65..d77f0ab4 100644 --- a/exarl/config/agent_cfg/DDPG-v0.json +++ b/exarl/config/agent_cfg/DDPG-v0.json @@ -1,9 +1,7 @@ { - "epsilon": 1.0, - "epsilon_min" : 0.01, - "epsilon_decay" : 0.999, "gamma": 0.99, - "tau" : 0.005, - "batch_size" : 64, + "tau": 0.005, + "batch_size": 64, + "buffer": "ReplayBuffer", "buffer_capacity": 50000 -} +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/DQN-v0.json b/exarl/config/agent_cfg/DQN-v0.json index 8a3dca2c..710178f3 100644 --- a/exarl/config/agent_cfg/DQN-v0.json +++ b/exarl/config/agent_cfg/DQN-v0.json @@ -1,13 +1,13 @@ { - "gamma": 0.75, - "epsilon": 0.9, - "epsilon_min": 0.01, - "epsilon_decay": 0.999, - "learning_rate": 0.001, - "batch_size": 5, - "tau": 0.5, - "nactions": 10, - "priority_scale": 0.0, - "mem_length": 1000, - "xla": "True" + "batch_size" : 32, + "discount" : 0.99, + "min_replay_size" : 100, + "sgd_period" : 1, + "update_target_frequency" : 1, + "epsilon" : 0.05, + "seed" : 42, + "learning_rate" : 1e-3, + "buffer" : "ReplayBuffer", + "buffer_capacity" : 10000, + "buffer_trajectory_length" : 8 } \ No newline at end of file diff --git a/exarl/config/agent_cfg/DQN-v1.json b/exarl/config/agent_cfg/DQN-v1.json new file mode 100644 index 00000000..ea784f8c --- /dev/null +++ b/exarl/config/agent_cfg/DQN-v1.json @@ -0,0 +1,13 @@ +{ + "batch_size" : 32, + "discount" : 0.99, + "min_replay_size" : 100, + "sgd_period" : 1, + "update_target_frequency" : 1, + "epsilon" : 0.05, + "seed" : 42, + "learning_rate" : 1e-3, + "buffer" : "ReplayBuffer", + "buffer_capacity" : 10000, + "buffer_trajectory_length" : 4 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/DQN-v2.json b/exarl/config/agent_cfg/DQN-v2.json new file mode 100644 index 00000000..e1f74611 --- /dev/null +++ b/exarl/config/agent_cfg/DQN-v2.json @@ -0,0 +1,13 @@ +{ + "batch_size" : 32, + "discount" : 0.99, + "min_replay_size" : 100, + "sgd_period" : 1, + "update_target_frequency" : 1, + "epsilon" : 0.05, + "seed" : 42, + "learning_rate" : 1e-3, + "buffer" : "TrajectoryBuffer", + "buffer_capacity" : 10000, + "buffer_trajectory_length" : 1 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/EXA-A2C-v0.json b/exarl/config/agent_cfg/EXA-A2C-v0.json new file mode 100644 index 00000000..464948ab --- /dev/null +++ b/exarl/config/agent_cfg/EXA-A2C-v0.json @@ -0,0 +1,8 @@ +{ + "gamma": 0.99, + "entropy_constant": 0.0001, + "value_constant": 0.5, + "epsilon": 1.0, + "epsilon_min" : 0.01, + "epsilon_decay" : 0.999 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/PPO-v0.json b/exarl/config/agent_cfg/PPO-v0.json new file mode 100644 index 00000000..9d9b67ce --- /dev/null +++ b/exarl/config/agent_cfg/PPO-v0.json @@ -0,0 +1,3 @@ +{ + "batch_size" : 32 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/SAC-v0.json b/exarl/config/agent_cfg/SAC-v0.json new file mode 100644 index 00000000..09069dbc --- /dev/null +++ b/exarl/config/agent_cfg/SAC-v0.json @@ -0,0 +1,7 @@ +{ + "buffer_capacity": 50000, + "batch_size": 64, + "sac_alpha": 0.01, + "tau": 0.01, + "gamma": 0.99 +} diff --git a/exarl/config/agent_cfg/SAC-v1.json b/exarl/config/agent_cfg/SAC-v1.json new file mode 100644 index 00000000..09069dbc --- /dev/null +++ b/exarl/config/agent_cfg/SAC-v1.json @@ -0,0 +1,7 @@ +{ + "buffer_capacity": 50000, + "batch_size": 64, + "sac_alpha": 0.01, + "tau": 0.01, + "gamma": 0.99 +} diff --git a/exarl/config/agent_cfg/TD3-v1.json b/exarl/config/agent_cfg/TD3-v1.json new file mode 100644 index 00000000..b7a5e7f0 --- /dev/null +++ b/exarl/config/agent_cfg/TD3-v1.json @@ -0,0 +1,8 @@ +{ + "buffer": "ReplayBuffer", + "buffer_capacity": 50000, + "batch_size": 64, + "tau": 0.005, + "gamma": 0.99, + "update_target_frequency": 1 +} diff --git a/exarl/config/agent_cfg/TORCH-AGENT-A3C-v0.json b/exarl/config/agent_cfg/TORCH-AGENT-A3C-v0.json new file mode 100644 index 00000000..1aaed0d0 --- /dev/null +++ b/exarl/config/agent_cfg/TORCH-AGENT-A3C-v0.json @@ -0,0 +1,22 @@ +{ + "seed" : 1, + "use_GPU" : "False", + "randomise_random_seed" : "True", + "learning_rate": 0.05, + "linear_hidden_units": [20, 20], + "final_layer_activation": "SOFTMAX", + "learning_iterations_per_round" : 5, + "episodes_per_learning_round" : 4, + "discount_rate": 0.99, + "batch_norm": "False", + "clip_epsilon": 0.1, + "normalise_rewards": "True", + "gradient_clipping_norm": 7.0, + "mu": 0.0, + "theta": 0.15, + "sigma": 0.25, + "epsilon_decay_rate_denominator": 1, + "clip_rewards": "False", + "update_target_frequency" : 1, + "average_score_required_to_win" : 100 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json b/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json new file mode 100644 index 00000000..896bc78a --- /dev/null +++ b/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json @@ -0,0 +1,24 @@ +{ + "which" : "DDQN", + "seed" : 1, + "use_GPU" : "False", + "standard_deviation_results" : 1.0, + "randomise_random_seed" : "True", + "learning_rate" : 0.01, + "batch_size" : 256, + "buffer_size" : 40000, + "epsilon" : 1.0, + "epsilon_decay_rate_denominator" : 1, + "discount_rate" : 0.99, + "tau" : 0.01, + "alpha_prioritised_replay" : 0.6, + "beta_prioritised_replay" : 0.1, + "incremental_td_error" : 1e-8, + "train_frequency" : 1, + "update_target_frequency" : 1, + "linear_hidden_units" : [30, 15], + "final_layer_activation" : "None", + "batch_norm" : "False", + "gradient_clipping_norm" : 0.7, + "learning_iterations" : 1 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json_bk b/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json_bk new file mode 100644 index 00000000..eed81c7f --- /dev/null +++ b/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json_bk @@ -0,0 +1,24 @@ +{ + "which" : "DDQN_With_Prioritised_Experience_Replay", + "seed" : 1, + "use_GPU" : "False", + "standard_deviation_results" : 1.0, + "randomise_random_seed" : "True", + "learning_rate" : 0.01, + "batch_size" : 256, + "buffer_size" : 40000, + "epsilon" : 1.0, + "epsilon_decay_rate_denominator" : 1, + "discount_rate" : 0.99, + "tau" : 0.01, + "alpha_prioritised_replay" : 0.6, + "beta_prioritised_replay" : 0.1, + "incremental_td_error" : 1e-8, + "train_frequency" : 1, + "update_target_frequency" : 1, + "linear_hidden_units" : [30, 15], + "final_layer_activation" : "None", + "batch_norm" : "False", + "gradient_clipping_norm" : 0.7, + "learning_iterations" : 1 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json_bk_hyper b/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json_bk_hyper new file mode 100644 index 00000000..6b602a97 --- /dev/null +++ b/exarl/config/agent_cfg/TORCH-AGENT-DQN-v0.json_bk_hyper @@ -0,0 +1,24 @@ +{ + "which" : "DDQN_With_Prioritised_Experience_Replay", + "seed" : 1, + "use_GPU" : "False", + "standard_deviation_results" : 1.0, + "randomise_random_seed" : "True", + "learning_rate" : 0.0011961792491823422, + "batch_size" : 237, + "buffer_size" : 40000, + "epsilon" : 0.527066637586905, + "epsilon_decay_rate_denominator" : 8, + "discount_rate" : 0.7691343938220233, + "tau" : 0.8271926187217387, + "alpha_prioritised_replay" : 0.6051159227587863, + "beta_prioritised_replay" : 0.10650091690795926, + "incremental_td_error" : 1e-8, + "train_frequency" : 1, + "update_target_frequency" : 1, + "linear_hidden_units" : [30, 15], + "final_layer_activation" : "None", + "batch_norm" : "False", + "gradient_clipping_norm" : 0.7, + "learning_iterations" : 1 +} \ No newline at end of file diff --git a/exarl/config/agent_cfg/TORCH-AGENT-PPO-v0.json b/exarl/config/agent_cfg/TORCH-AGENT-PPO-v0.json new file mode 100644 index 00000000..1aaed0d0 --- /dev/null +++ b/exarl/config/agent_cfg/TORCH-AGENT-PPO-v0.json @@ -0,0 +1,22 @@ +{ + "seed" : 1, + "use_GPU" : "False", + "randomise_random_seed" : "True", + "learning_rate": 0.05, + "linear_hidden_units": [20, 20], + "final_layer_activation": "SOFTMAX", + "learning_iterations_per_round" : 5, + "episodes_per_learning_round" : 4, + "discount_rate": 0.99, + "batch_norm": "False", + "clip_epsilon": 0.1, + "normalise_rewards": "True", + "gradient_clipping_norm": 7.0, + "mu": 0.0, + "theta": 0.15, + "sigma": 0.25, + "epsilon_decay_rate_denominator": 1, + "clip_rewards": "False", + "update_target_frequency" : 1, + "average_score_required_to_win" : 100 +} \ No newline at end of file diff --git a/exarl/config/env_cfg/Bsuite-v0.json b/exarl/config/env_cfg/Bsuite-v0.json new file mode 100755 index 00000000..73e06135 --- /dev/null +++ b/exarl/config/env_cfg/Bsuite-v0.json @@ -0,0 +1,7 @@ +{ + "bsuite_id": "bandit_noise", + "seed_number" : "0", + "driver_start_id" : 0, + "driver_max_seeds" : 20, + "driver_max_episodes" : -1 +} \ No newline at end of file diff --git a/exarl/config/env_cfg/ExaDMControl-v0.json b/exarl/config/env_cfg/ExaDMControl-v0.json new file mode 100644 index 00000000..0eb39636 --- /dev/null +++ b/exarl/config/env_cfg/ExaDMControl-v0.json @@ -0,0 +1,9 @@ +{ + "discrete": "False", + "discrete_step": 0.01, + "domain": "cartpole", + "task": "balance", + "render": "False", + "camera_id": 0, + "framrate": 30 +} \ No newline at end of file diff --git a/exarl/config/env_cfg/ExaParabola-v0.json b/exarl/config/env_cfg/ExaParabola-v0.json new file mode 100644 index 00000000..5b9fdf33 --- /dev/null +++ b/exarl/config/env_cfg/ExaParabola-v0.json @@ -0,0 +1,9 @@ +{ + "tolerance":0.0001, + "action_step":0.00001, + "coefficents": [ + 1, + 0, + 2 + ] +} \ No newline at end of file diff --git a/exarl/config/env_cfg/ExaRoots-v0.json b/exarl/config/env_cfg/ExaRoots-v0.json new file mode 100644 index 00000000..4f5d5b0e --- /dev/null +++ b/exarl/config/env_cfg/ExaRoots-v0.json @@ -0,0 +1,10 @@ +{ + "tolerance":0, + "action_space": "Discrete", + "action_step_size":0.00001, + "coefficents": [ + 10, + 7, + 21 + ] +} \ No newline at end of file diff --git a/exarl/config/env_cfg/GymSpaceTest-v0.json b/exarl/config/env_cfg/GymSpaceTest-v0.json deleted file mode 100644 index baa88932..00000000 --- a/exarl/config/env_cfg/GymSpaceTest-v0.json +++ /dev/null @@ -1,6 +0,0 @@ -{ - "action_space": "Box_One", - "observation_space" : "Box", - "action_Tuple" : "false", - "observation_Tuple" : "false" -} \ No newline at end of file diff --git a/exarl/config/hyper_params.json b/exarl/config/hyper_params.json new file mode 100644 index 00000000..78308dc6 --- /dev/null +++ b/exarl/config/hyper_params.json @@ -0,0 +1,14 @@ +{ +"agent": "DQN-v0", +"parameters": { + "gamma": [0.001, 0.1], + "batch_size": [5, 128], + "epsilon" : [0.01, 1.0], + "epsilon_decay" : [0.1, 1.0], + "learning_rate" : [0.001, 1.0], + "tau" : [0.01, 1.0] +}, +"objective": "all", +"sampler": "tpe", +"trials": 1 +} \ No newline at end of file diff --git a/exarl/config/hyper_params.json_bk b/exarl/config/hyper_params.json_bk new file mode 100644 index 00000000..e1b60eab --- /dev/null +++ b/exarl/config/hyper_params.json_bk @@ -0,0 +1,17 @@ +{ +"parameters": { + "learning_rate": [0.001, 0.1], + "batch_size": [32, 1024], + "epsilon" : [0.1, 1.0], + "epsilon_decay_rate_denominator" : [1, 500], + "discount_rate" : [0.01, 0.99], + "tau" : [0.01, 0.99], + "alpha_prioritised_replay" : [0.1, 0.9], + "beta_prioritised_replay" : [0.1, 0.9], + "batch_step_frequency" : [1, 100], + "train_frequency" : [1, 100] +}, +"objective": "last_rolling_reward", +"sampler": "tpe", +"trials": 100 +} \ No newline at end of file diff --git a/exarl/config/learner_cfg.json b/exarl/config/learner_cfg.json index 9e160606..117390a4 100644 --- a/exarl/config/learner_cfg.json +++ b/exarl/config/learner_cfg.json @@ -1,13 +1,24 @@ { "agent": "DQN-v0", - "env": "ExaCartPoleStatic-v0", - "workflow": "async", - "n_episodes": 50, - "n_steps": 10, - "output_dir": "./results_dir/", + "env": "CartPole-v1", + "workflow": "sync", + "n_episodes": 100, + "n_steps": 100, + "output_dir": "./results/", "process_per_env": 1, - "model_type": "LSTM", - "action_type": "variable", - "log_level": [3, 3], - "profile": "none" -} + "dev_affinity": "false", + "log_level": [ + 3, + 3 + ], + "model_type": "MLP", + "clip_rewards": "False", + "rolling_reward_length": 4, + "cutoff" : 0.00000, + "log_frequency": 1, + "profile": "intro", + "buffer": "PrioritizedReplayBuffer", + "buffer_capacity": 1000000, + "convert_action_type": "False", + "num_discrete_step": 1000 +} \ No newline at end of file diff --git a/exarl/config/learner_cfg_ddpg.json b/exarl/config/learner_cfg_ddpg.json deleted file mode 100644 index d689ce2f..00000000 --- a/exarl/config/learner_cfg_ddpg.json +++ /dev/null @@ -1,13 +0,0 @@ -{ - "agent": "DDPG-v0", - "env": "Pendulum-v0", - "workflow": "async", - "n_episodes": 10, - "n_steps": 10, - "output_dir": "./results_dir/", - "process_per_env": 1, - "model_type": "AC", - "action_type": "variable", - "log_level": [3, 3], - "profile": "none" -} diff --git a/exarl/config/model_cfg/AC.json b/exarl/config/model_cfg/AC.json index 2e6230dd..94aaf8f4 100644 --- a/exarl/config/model_cfg/AC.json +++ b/exarl/config/model_cfg/AC.json @@ -2,8 +2,9 @@ "actor_lr" : 0.001, "actor_dense_act" : "relu", "actor_dense": [256, 256], - "actor_out_act" : "tanh", + "actor_out_act" : "sigmoid", "actor_optimizer" : "adam", + "critic_lr" : 0.002, "critic_state_dense": [16, 32], "critic_state_dense_act" : "relu", @@ -11,8 +12,9 @@ "critic_action_dense_act" : "relu", "critic_concat_dense": [256, 256], "critic_concat_dense_act" : "relu", - "critic_out_act" : "linear", "critic_optimizer" : "adam", "loss" : "mse", - "std_dev": 0.2 + "std_dev": 0.2, + "xla" : "True", + "mixed_precision" : "False" } diff --git a/exarl/config/model_cfg/LSTM.json b/exarl/config/model_cfg/LSTM.json index 0bb91af1..446c6428 100644 --- a/exarl/config/model_cfg/LSTM.json +++ b/exarl/config/model_cfg/LSTM.json @@ -1,26 +1,14 @@ { - "dense": [ - 64, - 128 - ], + "trajectory_length" : 1, "optimizer": "adam", "loss": "mse", - "lstm_layers": [ - 56, - 56, - 56 - ], + "lstm_layers": [56, 56, 56], "activation": "tanh", - "gauss_noise": [ - 0.1, - 0.1, - 0.1 - ], + "gauss_noise": [0.1, 0.1, 0.1], "out_activation": "linear", - "regularizer": [ - 0.001, - 0.001 - ], + "regularizer": [0.001, 0.001], "clipnorm": 1.0, - "clipvalue": 0.5 + "clipvalue": 0.5, + "xla" : "True", + "mixed_precision" : "False" } \ No newline at end of file diff --git a/exarl/config/model_cfg/MLP.json b/exarl/config/model_cfg/MLP.json index 0f5c1b0f..c7c4db0a 100644 --- a/exarl/config/model_cfg/MLP.json +++ b/exarl/config/model_cfg/MLP.json @@ -3,5 +3,7 @@ "activation" : "relu", "optimizer" : "adam", "out_activation" : "linear", - "loss" : "mse" + "loss" : "mse", + "xla" : "True", + "mixed_precision" : "False" } diff --git a/exarl/config/workflow_cfg/async.json b/exarl/config/workflow_cfg/async.json index afdd319c..5038ae56 100644 --- a/exarl/config/workflow_cfg/async.json +++ b/exarl/config/workflow_cfg/async.json @@ -1,4 +1,10 @@ { "learner_procs": 1, - "process_per_env": 1 + "episode_block": "False", + "batch_episode_frequency": 1, + "batch_step_frequency": 1, + "save_weights_per_episode": "false", + "action_type": "variable", + "mpi4py_rc": "false", + "affinity": "false" } \ No newline at end of file diff --git a/exarl/config/workflow_cfg/random.json b/exarl/config/workflow_cfg/random.json index 404c63e4..bb7ead94 100644 --- a/exarl/config/workflow_cfg/random.json +++ b/exarl/config/workflow_cfg/random.json @@ -1,5 +1,8 @@ { "learner_procs": 1, "process_per_env": 1, - "weight_file": "None" + "weight_file": "None", + "action_type": "variable", + "mpi4py_rc": "true", + "affinity": "false" } \ No newline at end of file diff --git a/exarl/config/workflow_cfg/rma.json b/exarl/config/workflow_cfg/rma.json index 25031ebd..ef513455 100644 --- a/exarl/config/workflow_cfg/rma.json +++ b/exarl/config/workflow_cfg/rma.json @@ -1,9 +1,10 @@ { "learner_procs": 1, - "process_per_env": 1, - "data_structure": "buff_unchecked", - "data_structure_length": 32, - "max_model_lag": "none", - "loss_data_structure": "buff_unchecked", - "target_weight_structure": "buff_unchecked" + "episode_block": "False", + "batch_episode_frequency": 1, + "batch_step_frequency": 1, + "save_weights_per_episode": "false", + "action_type": "variable", + "mpi4py_rc": "true", + "affinity": "false" } \ No newline at end of file diff --git a/exarl/config/workflow_cfg/sync.json b/exarl/config/workflow_cfg/sync.json index afdd319c..ef513455 100644 --- a/exarl/config/workflow_cfg/sync.json +++ b/exarl/config/workflow_cfg/sync.json @@ -1,4 +1,10 @@ { "learner_procs": 1, - "process_per_env": 1 + "episode_block": "False", + "batch_episode_frequency": 1, + "batch_step_frequency": 1, + "save_weights_per_episode": "false", + "action_type": "variable", + "mpi4py_rc": "true", + "affinity": "false" } \ No newline at end of file diff --git a/exarl/driver/__main__.py b/exarl/driver/__main__.py index be37bfae..7d1c1d6a 100644 --- a/exarl/driver/__main__.py +++ b/exarl/driver/__main__.py @@ -18,36 +18,30 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 -from tensorflow import keras -import exarl as erl -import exarl.utils.analyze_reward as ar import time -from exarl.utils.candleDriver import lookup_params -from exarl.utils.introspect import * import numpy as np +import tensorflow +# import torch +import exarl +from exarl.utils.profile import ProfileConstants +import os +import exarl.utils.analyze_reward as ar - -# Create learner object and run -exa_learner = erl.ExaLearner() +exa_learner = exarl.ExaLearner() # MPI communicator -comm = erl.ExaComm.global_comm +comm = exarl.ExaComm.global_comm rank = comm.rank size = comm.size -writeDir = lookup_params("introspector_dir") -if writeDir is not None: - ibLoadReplacement(comm, writeDir) - # Run the learner, measure time -ib.start() start = time.time() exa_learner.run() elapse = time.time() - start -ib.stop() -if ibLoaded(): - print("Rank", comm.rank, "Time = ", elapse) +# Print duration +if ProfileConstants.introspected(): + print("Rank", rank, "Time = ", elapse) else: max_elapse = comm.reduce(np.float64(elapse), max, 0) elapse = comm.reduce(np.float64(elapse), sum, 0) @@ -55,8 +49,9 @@ print("Average elapsed time = ", elapse / size) print("Maximum elapsed time = ", max_elapse) +# Save rewards vs. episodes plot if rank == 0: - # Save rewards vs. episodes plot + print("Final number of episodes =", exa_learner.final_number_of_episodes()) + print("Total reward =", exa_learner.final_total_reward()) + print("Final rolling reward =", exa_learner.final_rolling_reward()[0]) ar.save_reward_plot() - -ibWrite(writeDir) diff --git a/exarl/driver/bsuite_driver_all.py b/exarl/driver/bsuite_driver_all.py new file mode 100755 index 00000000..c21a21fd --- /dev/null +++ b/exarl/driver/bsuite_driver_all.py @@ -0,0 +1,95 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +import time +import exarl +from exarl.utils.globals import ExaGlobals + +import numpy as np +from tqdm import tqdm +from bsuite import sweep + +""" +This is a driver that steps through all of Bsuite +with a single configuration. It runs each environment +one after another. There are three parameters that +can be adjusted from command line: + + - start_id - what environment index to start from + - max_seed_number - max seeds to run per environment + - max_episodes - max number of episodes to run per environment + +To adjust these from command line, be sure to set the +environment to Bsuite-v0 as that is where candlelib will pick +up the arguments from. If you don't then this driver will +try to run everything with full episodes. + +We added max_episodes to differentiate the episodes for this +driver as the user probably will have a learner_cfg.json file +configured for regular experiments. If they are sure they +want to limit the episodes they will have to add the --env +flag. By setting max_episodes to -1, we will run the +number of episodes given by Bsuite sweep. +""" + +# Experiment parameters. +# TODO: Fix these envs. +excluded_envs = ['cartpole_swingup', + 'mountain_car', + 'mountain_car_noise', + 'mountain_car_scale'] +start_id = ExaGlobals.lookup_params("driver_start_id") +max_seed_number = ExaGlobals.lookup_params("driver_max_seeds") +max_episodes = ExaGlobals.lookup_params("driver_max_episodes") +# End of experiment parameters + +for env_id in tqdm(sweep.SWEEP[start_id:]): + + # Only use seed number 0 until we can parallelize + bsuite_id, seed_number = env_id.split('/') + if int(seed_number) > max_seed_number or bsuite_id in excluded_envs: + continue + + episodes = sweep.EPISODES[env_id] if max_episodes == -1 else max_episodes + ExaGlobals.set_param("n_episodes", episodes) + ExaGlobals.set_param("bsuite_id", bsuite_id) + ExaGlobals.set_param('seed_number', seed_number) + + print("Current Env:", ExaGlobals.lookup_params("bsuite_id"), "Seed:", ExaGlobals.lookup_params('seed_number'), + "Episodes:", ExaGlobals.lookup_params("n_episodes"), "Steps:", ExaGlobals.lookup_params("n_steps")) + + # Create learner object and run + exa_learner = exarl.ExaLearner() + + # MPI communicator + comm = exarl.ExaComm.global_comm + rank = comm.rank + size = comm.size + + # Run the learner, measure time + start = time.time() + exa_learner.run() + elapse = time.time() - start + + max_elapse = comm.reduce(np.float64(elapse), max, 0) + elapse = comm.reduce(np.float64(elapse), sum, 0) + if rank == 0: + print("Average elapsed time = ", elapse / size) + print("Maximum elapsed time = ", max_elapse) diff --git a/exarl/driver/hyper-tune.py b/exarl/driver/hyper-tune.py new file mode 100755 index 00000000..bb74d307 --- /dev/null +++ b/exarl/driver/hyper-tune.py @@ -0,0 +1,317 @@ +#!/usr/bin/env python + +from collections import deque +import multiprocessing +import subprocess +import optuna +import json + +""" +To use: + sbatch -N [number of nodes] ./exarl/driver/hyper-tune.py + +Make sure the configuration files have the correct number of steps/episodes, workflow, agent, and environment +set correctly. The hyper_params.json file will contain the parameters to explore. Each parameter should +have the mins and max ranges set. The following is the format: + + { + "parameters": { + "param1": [0.001, 0.1], + "param2": [5, 128] + }, + "objective": "all", + "sampler": "tpe", + "trials": 1 + } + +The objective and sampler fields configure which objective function to maximize and which optuna function to +use respectively. Passing all for either will cycle through all objective/sampler. This file should be +launched from the directory just before exarl. Also we try to reserve a single node for optuna so if you want +to launch 10 trials in parallel, sbatch -N 11. + +The results dir set in the learner_cfg will contain ALL the results for each trial marked by optimizer +and trial number. +""" + +""" +This is the path to the hyper parameters to optimize! +""" +path_to_json = "./exarl/config/hyper_params.json" + +""" +These are the objective functions we will be optimizing: + Last Rolling Reward: This is the rolling reward on exit + Rolling Reward per Time: This is the rolling reward normalized to the total runtime + Rolling Reward per Episode: This is the rolling reward normalized to the total number of episodes + Total Reward per Time: This is the total reward normalized to the total runtime + Total Reward per Episode: This is the total reward normalized to the total number of episodes +""" +objectives = { + "rolling_reward": lambda x: x[0], + "total_reward": lambda x: x[1], + "rolling_reward_per_time": lambda x: x[0] / x[1], + "rolling_reward_per_episode": lambda x: x[0] / x[2], + "total_reward_per_time": lambda x: x[0] / x[1], + "total_reward_per_episode": lambda x: x[0] / x[2] +} + +""" +These are the samples that are readily available from optuna: + https://optuna.readthedocs.io/en/stable/reference/samplers/index.html +""" +samplers = { + "tpe": optuna.samplers.TPESampler, + "random": optuna.samplers.RandomSampler, + "cmaes": optuna.samplers.CmaEsSampler, + "qmc": optuna.samplers.QMCSampler, +} + +class Optimizer: + """ + This class is a utility built around optuna's study to support parallel study execution using Slurm. + Optuna parallelizes the study using built in python threading. We leaverage this "threading" by + launching a srun command per thread. These commands are then run in parallel on seperate nodes. + The results of the commands are captured and parsed and then passed into the study. + + See the following for information on parallelizing the study: + https://optuna.readthedocs.io/en/stable/reference/generated/optuna.study.Study.html#optuna.study.Study.optimize + Notice this is how they expect to parallize the study... + https://optuna.readthedocs.io/en/stable/tutorial/10_key_features/004_distributed.html#distributed + + Attributes + ---------- + params : dictionary + The parameters with their upper and lower bounds to explore + objective_func : function + This is the function that parses the returned values of a trial giving a score + sampler : optuna.sampler + The type of sampler to use in the study + n_trials : int + How many trials to run + exp : string + The name of the experiment folder + all_nodes : list + List of node names to send srun commands to. + """ + def __init__(self, params, objective_func, sampler, n_trials=100, exp="EXP000"): + self.params = params + self.objective_func = objective_func + self.sampler = sampler + self.n_trials = n_trials + self.exp = exp + self.manager = multiprocessing.Manager() + self.lock = self.manager.Lock() + self.all_nodes = self.get_nodes() + # JS: Leave the first node for optuna + if len(self.all_nodes) > 1: + self.all_nodes = self.all_nodes[1:] + + def optimize(self): + """ + This function performs the study. + + Returns + ------- + dictionary + This is the list of params and the best achieved value + """ + print("Study: ", self.sampler, self.n_trials) + # JS: Notice we are maximizing! + study = optuna.create_study(direction="maximize", sampler=self.sampler()) + study.optimize(self.objective, n_trials=self.n_trials, n_jobs=len(self.all_nodes)) + return study.best_params + + def get_nodes(self): + """ + This function uses scontrol to get a list of the nodes in sbatch job. + They are then return as a list. + + Returns + ------- + list + Names of all nodes in job + """ + cmd = command("scontrol show hostnames", wait=True) + return [x for x in cmd.out.split('\n') if len(x) > 0] + + def srun_prefix(self, cmd, nodeId, nodes=1, procs=1): + """ + Adds srun and srun options to the command to run. + + TODO: Propagate nodes > 1 and procs > 1 option through the rest + of the script. Maybe add to the hyperparameter json options. + + Returns + ------- + string + srun command with options + """ + return " ".join(["srun -N", str(nodes), "-n", str(procs), "-w", str(nodeId), cmd]) + + def run_cmd(self, params, nodeId, trial=0): + """ + Creates a srun command from the trial parameters and nodeId. + All trials will create a directory EXPXXX/RUNXXX. The exp dir + is configurable at the creation of this class. The run is given + by the trial id. + + Parameters + ---------- + + params : list + A list of tuples containing name, value for the parameters to run + + nodeId : string + The name of the node to run on + + trial : int + The trial id (given by the study) + + Returns + ------- + string + srun command with options + """ + text = f'python exarl/driver --run_id RUN{trial:04d} --experiment_id ' + self.exp + dash = [("--" + x[0], str(x[1])) for x in params] + flat_list = [item for sublist in dash for item in sublist] + text = ' '.join([text, *flat_list]) + return self.srun_prefix(text, nodeId) + + def parse(self, output): + """ + This parses the output of the srun command returning the reward, time, and total episodes. + + Parameters + ---------- + output : string + The output of the srun command + + Returns + ------- + tuple : + Rolling reward, total time, total episodes + """ + lines = output.split("\n") + for line in lines: + if "Total reward =" in line: + total_reward = float(line.split(" ")[-1]) + elif "Final rolling reward =" in line: + rolling_reward = float(line.split(" ")[-1]) + elif "Maximum elapsed time =" in line: + time = float(line.split(" ")[-1]) + elif "Final number of episodes =" in line: + num_eps = int(line.split(" ")[-1]) + return (rolling_reward, total_reward, time, num_eps) + + def objective(self, trial): + """ + This is the objection function. Here we get the suggested trial parameters and pass them along + to create a srun command. We run this command and parse its output. The node used to run the + command is based on the trial number. We assume that each python threads is running this + function (https://github.com/optuna/optuna/blob/1a520bd5daa9ff0af09fb060464bb157f8af891b/optuna/study/_optimize.py#L64). + We also assume each trial takes about the same time such that each nodes starts a stride making + the trial number good to use as a node offset. Also srun should treat job step allocations "exclusively." + + From https://slurm.schedmd.com/srun.html : + This option applies to job and job step allocations, and has two slightly different meanings for each one... + The exclusive allocation of CPUs applies to job steps by default, but --exact is NOT the default. In other words, + the default behavior is this: job steps will not share CPUs, but job steps will be allocated all CPUs available + to the job on all nodes allocated to the steps. + + The function will try to run the srun command and parse the output. If the parsing fails, + we catch the error and print the output and the error. We still continue on with the study. + + Parameters + ---------- + trial : int + Current trial + + Returns + ------- + float : + The score of the run trial, or -1 on failure + """ + my_node = trial.number % len(self.all_nodes) + suggestions = [] + for p in self.params: + if len(self.params[p]) == 2: + minimum, maximum = self.params[p] + assert type(minimum) == type(maximum), "Minimum and Maximum types should be the same" + if type(minimum) == float: + suggestions.append((p, trial.suggest_float(p, minimum, maximum))) + elif type(minimum) == int: + suggestions.append((p, trial.suggest_int(p, minimum, maximum))) + else: + raise Exception("Could not determine hyperparameter type") + else: + suggestions.append((p, trial.suggest_categorical(p, minimum, maximum))) + cmd = command(self.run_cmd(suggestions, self.all_nodes[my_node], trial=trial.number), wait=True) + try: + res = self.objective_func(self.parse(cmd.out)) + if res != res: + raise ValueError("Result is NaN!") + return res + except Exception as e: + print(e) + print("Failed:", cmd.cmd) + print("Output:\n", cmd.out) + print("Error:\n", cmd.err, flush=True) + # JS: We return -1 since we are maximizing!!! + return -1 + +class command: + """ + This class is a wrapper around subprocesses storing its results. + + Attributes + ---------- + cmd : string + Command to run + sp : subprocess + Subprocess handle to wait on + out : string + stdout of the command + err : string + stderr of the command + """ + def __init__(self, cmd, wait=False): + self.cmd = cmd + self.sp = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) + self.out = None + self.err = None + if wait: + self.wait() + + def wait(self): + """ + This will wait for the command to finish populating out and err. + """ + # self.ret = self.sp.wait() + self.out, self.err = self.sp.communicate() + + +if __name__ == "__main__": + with open(path_to_json) as file: + js = json.load(file) + parameters_from_json = js["parameters"] + my_sampler = js["sampler"] + my_objective = js["objective"] + n_trials = js["trials"] + + if my_sampler == "all": + my_samplers = samplers.keys() + else: + my_samplers = [my_sampler] + + if my_objective == "all": + my_objectives = objectives.keys() + else: + my_objectives = [my_objective] + + for sampler in my_samplers: + for objective in my_objectives: + op = Optimizer(parameters_from_json, objectives[objective], samplers[sampler], n_trials=n_trials, exp="_".join([sampler, objective])) + res = op.optimize() + for param in res: + print(sampler, objective, param, res[param]) diff --git a/exarl/envs/__init__.py b/exarl/envs/__init__.py index b5bf6de7..84920d21 100755 --- a/exarl/envs/__init__.py +++ b/exarl/envs/__init__.py @@ -1,7 +1,10 @@ from gym.envs import registration from gym.envs.registration import register -import exarl.utils.candleDriver as cd -env = cd.lookup_params('env') +from exarl.utils.globals import ExaGlobals +try: + env = ExaGlobals.lookup_params('env') +except: + env = None if env == 'ExaCH-v0': register( @@ -27,8 +30,26 @@ entry_point='exarl.envs.env_vault:ExaBooster' ) +elif env == 'ExaBoosterNew-v0': + register( + id=env, + entry_point='exarl.envs.env_vault:ExaBooster' + ) + elif env == 'ExaWaterClusterDiscrete-v0': register( id=env, entry_point='exarl.envs.env_vault:ExaWaterClusterDiscrete' ) + +elif env == 'Hadrec-v0': + register( + id=env, + entry_point='exarl.envs.env_vault:HadrecWrapper' + ) + +elif env == 'Bsuite-v0': + register( + id=env, + entry_point='exarl.envs.env_vault:BsuiteWrapper' + ) diff --git a/exarl/envs/env_vault/BsuiteWrapper.py b/exarl/envs/env_vault/BsuiteWrapper.py new file mode 100755 index 00000000..e0a7764f --- /dev/null +++ b/exarl/envs/env_vault/BsuiteWrapper.py @@ -0,0 +1,140 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +from os import path +import numpy as np +import gym +import gym.spaces as spaces +from typing import Any, Dict, Optional, Tuple, Union, Sequence +from exarl.base.comm_base import ExaComm +from exarl.utils.globals import ExaGlobals + +import bsuite +from bsuite.utils import gym_wrapper +from bsuite.logging.csv_logging import Logger as CSVLogger + +_GymTimestep = Tuple[np.ndarray, float, bool, Dict[str, Any]] + +# Inspired by https://github.com/deepmind/bsuite/blob/master/bsuite/utils/wrappers.py + +class BsuiteWrapper(gym.Env): + """Environment wrapper to track and log bsuite stats in ExaRL.""" + def __init__(self) -> None: + super().__init__() + self.env_comm = ExaComm.env_comm + rank = ExaComm.agent_comm.rank + bsuite_id = ExaGlobals.lookup_params("bsuite_id") + seed_number = ExaGlobals.lookup_params("seed_number") + env_name = bsuite_id + "/" + seed_number + print("Loading", env_name) + + # Let self.raw_env be of class dm_env.Environment. + # Then return gym-like outputs for step, reset methods. + self.raw_env = bsuite.load_from_id(bsuite_id=env_name) + post_path = 'bsuite_results/' + "_".join([bsuite_id, str(seed_number), str(rank)]) + bsuite_res_path = path.join(ExaGlobals.lookup_params("output_dir"), post_path) + self._logger = CSVLogger(bsuite_id=env_name, results_dir=bsuite_res_path, overwrite=True) + + self.env = gym_wrapper.GymFromDMEnv(self.raw_env) + self.action_space = self.env.action_space + self.observation_space = self.env.observation_space + + # Accumulating throughout experiment. + self._steps = 0 + self.workflow_episode = 0 + self._total_return = 0.0 + + # Most-recent-episode. + self._episode_len = 0 + self._episode_return = 0.0 + + self._log_by_step = False + self._log_every = False + + def step(self, action) -> _GymTimestep: + timestep = self.raw_env.step(action) + self._track(timestep) + next_state = timestep.observation + reward = timestep.reward + done = timestep.step_type.last() + return next_state, reward, done, {} + + def reset(self) -> np.ndarray: + timestep = self.raw_env.reset() + self._track(timestep) + return timestep.observation + + def _track(self, timestep): + # Count transitions only. + if not timestep.first(): + self._steps += 1 + self._episode_len += 1 + + if timestep.last(): + self.workflow_episode += 1 + + self._episode_return += timestep.reward or 0.0 + self._total_return += timestep.reward or 0.0 + + # Log statistics periodically, either by step or by episode. + if ExaComm.env_comm.rank == 0: + if self._log_by_step: + if _logarithmic_logging(self._steps) or self._log_every: + self._log_bsuite_data() + + elif timestep.last(): + if _logarithmic_logging(self.workflow_episode) or self._log_every: + self._log_bsuite_data() + + # Perform bookkeeping at the end of episodes. + if timestep.last(): + self._episode_len = 0 + self._episode_return = 0.0 + + if self.workflow_episode == self.raw_env.bsuite_num_episodes: + self.flush() + + def _log_bsuite_data(self): + """Log summary data for bsuite.""" + data = dict( + # Accumulated data. + steps=self._steps, + episode=self.workflow_episode, + total_return=self._total_return, + # Most-recent-episode data. + episode_len=self._episode_len, + episode_return=self._episode_return, + ) + # Environment-specific metadata used for scoring. + data.update(self.raw_env.bsuite_info()) + self._logger.write(data) + + def flush(self): + if hasattr(self._logger, 'flush'): + self._logger.flush() + +def _logarithmic_logging(episode: int, + ratios: Optional[Sequence[float]] = None) -> bool: + """Returns `True` only at specific ratios of 10**exponent.""" + if ratios is None: + ratios = [1., 1.2, 1.4, 1.7, 2., 2.5, 3., 4., 5., 6., 7., 8., 9., 10.] + exponent = np.floor(np.log10(np.maximum(1, episode))) + special_vals = [10**exponent * ratio for ratio in ratios] + return any(episode == val for val in special_vals) diff --git a/exarl/envs/env_vault/ExaBoosterDiscrete.py b/exarl/envs/env_vault/ExaBoosterDiscrete.py index 9fde0420..ede2a552 100644 --- a/exarl/envs/env_vault/ExaBoosterDiscrete.py +++ b/exarl/envs/env_vault/ExaBoosterDiscrete.py @@ -18,40 +18,34 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 -import gym + import sys import os import errno import math +import requests +import numpy as np +import pandas as pd + +import gym from gym import spaces from gym.utils import seeding -import pandas as pd + +import tensorflow as tf from tensorflow import keras from sklearn.preprocessing import MinMaxScaler import matplotlib.pyplot as plt -import numpy as np -import requests -import tensorflow as tf - -# import logging - -# logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s') -# logger = logging.getLogger('RL-Logger') -# logger.setLevel(logging.INFO) -from exarl.utils import log -import exarl.utils.candleDriver as cd -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) +from exarl.utils.globals import ExaGlobals +logger = ExaGlobals.setup_logger(__name__) np.seterr(divide='ignore', invalid='ignore') - def load_reformated_cvs(filename, nrows=100000): df = pd.read_csv(filename, nrows=nrows) df = df.replace([np.inf, -np.inf], np.nan) df = df.dropna(axis=0) return df - def create_dataset(dataset, look_back=10 * 15, look_forward=1): X, Y = [], [] offset = look_back + look_forward @@ -62,7 +56,6 @@ def create_dataset(dataset, look_back=10 * 15, look_forward=1): Y.append(yy) return np.array(X), np.array(Y) - def get_dataset(df, variable='B:VIMIN'): dataset = df[variable].values dataset = dataset.astype('float32') @@ -79,7 +72,6 @@ def get_dataset(df, variable='B:VIMIN'): return scaler, X_train, Y_train - class ExaBooster_v1(gym.Env): def __init__(self): @@ -87,21 +79,21 @@ def __init__(self): # https://zenodo.org/record/4088982#.X4836kJKhTY try: - booster_data_dir = cd.run_params['booster_data_dir'] + booster_data_dir = ExaGlobals.lookup_params('booster_data_dir') except: sys.exit("Must set booster_data_dir") - booster_dir = cd.run_params['model_dir'] + booster_dir = ExaGlobals.lookup_params('model_dir') if booster_dir == 'None': self.file_dir = os.path.dirname(__file__) booster_dir = os.path.join(self.file_dir, 'env_data/booster_data') - logger.info('booster related directory: '.format(booster_dir)) + logger().info('booster related directory: '.format(booster_dir)) try: os.mkdir(booster_dir) except OSError as exc: if exc.errno != errno.EEXIST: - logger.error("Creation of the directory %s failed" % booster_dir) + logger().error("Creation of the directory %s failed" % booster_dir) else: - logger.error("Successfully created the directory %s " % booster_dir) + logger().error("Successfully created the directory %s " % booster_dir) # Load surrogate models self.cpus = tf.config.list_physical_devices('CPU') @@ -111,7 +103,7 @@ def __init__(self): tf.compat.v1.keras.backend.set_session(sess) # booster_model_file = 'fullbooster_noshift_e250_bs99_nsteps250k_invar5_outvar3_axis1_mmscaler_t0_D10122020-T175237_kfold2__e16_vl0.00038.h5' - booster_model_file = cd.run_params['model_file'] + booster_model_file = ExaGlobals.lookup_params('model_file') booster_model_pfn = os.path.join(booster_dir, booster_model_file) print("booster model file=", booster_model_pfn, flush=True) with tf.device('/cpu:0'): @@ -119,20 +111,20 @@ def __init__(self): # Check if data is available # booster_data_file = 'BOOSTR.csv' - booster_data_file = cd.run_params['data_file'] + booster_data_file = ExaGlobals.lookup_params('data_file') booster_file_pfn = os.path.join(booster_data_dir, booster_data_file) - logger.info('Booster data file pfn:{}'.format(booster_file_pfn)) + logger().info('Booster data file pfn:{}'.format(booster_file_pfn)) if not os.path.exists(booster_file_pfn): - logger.info('No cached file. Downloading...') + logger().info('No cached file. Downloading...') try: # url = 'https://zenodo.org/record/4088982/files/data%20release.csv?download=1' - url = cd.run_params['url'] + url = ExaGlobals.lookup_params('url') r = requests.get(url, allow_redirects=True) open(booster_file_pfn, 'wb').write(r.content) except: - logger.error("Problem downloading file") + logger().error("Problem downloading file") else: - logger.info('Using exiting cached file') + logger().info('Using exiting cached file') # Load data to initialize the env data = load_reformated_cvs(booster_file_pfn, nrows=250000) @@ -141,10 +133,10 @@ def __init__(self): data = data.dropna() data = data.drop_duplicates() - self.save_dir = cd.run_params['output_dir'] + self.save_dir = ExaGlobals.lookup_params('output_dir') self.episodes = 0 self.steps = 0 - self.max_steps = cd.run_params['max_steps'] + self.max_steps = ExaGlobals.lookup_params('max_steps') self.total_reward = 0 self.data_total_reward = 0 self.total_iminer = 0 @@ -152,11 +144,11 @@ def __init__(self): self.diff = 0 # Define boundary - self.min_BIMIN = cd.run_params['min_BIMIN'] - self.max_BIMIN = cd.run_params['max_BIMIN'] + self.min_BIMIN = ExaGlobals.lookup_params('min_BIMIN') + self.max_BIMIN = ExaGlobals.lookup_params('max_BIMIN') self.variables = ['B:VIMIN', 'B:IMINER', 'B:LINFRQ', 'I:IB', 'I:MDAT40'] self.nvariables = len(self.variables) - logger.info('Number of variables:{}'.format(self.nvariables)) + logger().info('Number of variables:{}'.format(self.nvariables)) self.scalers = [] data_list = [] @@ -185,7 +177,7 @@ def __init__(self): # Dynamically allocate data['B:VIMIN_DIFF'] = data['B:VIMIN'] - data['B:VIMIN'].shift(-1) - self.nactions = cd.run_params['nactions'] + self.nactions = ExaGlobals.lookup_params('nactions') self.action_space = spaces.Discrete(self.nactions) self.actionMap_VIMIN = [] for i in range(1, self.nactions + 1): @@ -194,7 +186,7 @@ def __init__(self): self.VIMIN = 0 self.state = np.zeros(shape=(1, self.nvariables, self.nsamples)) self.predicted_state = np.zeros(shape=(1, self.nvariables, 1)) - logger.debug('Init pred shape:{}'.format(self.predicted_state.shape)) + logger().debug('Init pred shape:{}'.format(self.predicted_state.shape)) self.do_render = False # True def seed(self, seed=None): @@ -212,17 +204,17 @@ def step(self, action): # 4) Update B:IMINER # Step 1: Calculate the new B:VINMIN based on policy action - logger.info('Step() before action VIMIN:{}'.format(self.VIMIN)) + logger().info('Step() before action VIMIN:{}'.format(self.VIMIN)) delta_VIMIN = self.actionMap_VIMIN[action] DENORN_BVIMIN = self.scalers[0].inverse_transform(np.array([self.VIMIN]).reshape(1, -1)) DENORN_BVIMIN += delta_VIMIN - logger.debug('Step() descaled VIMIN:{}'.format(DENORN_BVIMIN)) + logger().debug('Step() descaled VIMIN:{}'.format(DENORN_BVIMIN)) if DENORN_BVIMIN < self.min_BIMIN or DENORN_BVIMIN > self.max_BIMIN: - logger.info('Step() descaled VIMIN:{} is out of bounds.'.format(DENORN_BVIMIN)) + logger().info('Step() descaled VIMIN:{} is out of bounds.'.format(DENORN_BVIMIN)) done = True self.VIMIN = self.scalers[0].transform(DENORN_BVIMIN) - logger.debug('Step() updated VIMIN:{}'.format(self.VIMIN)) + logger().debug('Step() updated VIMIN:{}'.format(self.VIMIN)) self.state[0][0][self.nsamples - 1] = self.VIMIN # Step 2: Predict using booster model @@ -246,9 +238,9 @@ def step(self, action): self.state[0, 2:self.nvariables, :] = self.data_state[0, 2:self.nvariables, :] iminer = self.predicted_state[0, 1] - logger.debug('norm iminer:{}'.format(iminer)) + logger().debug('norm iminer:{}'.format(iminer)) iminer = self.scalers[1].inverse_transform(np.array([iminer]).reshape(1, -1)) - logger.debug('iminer:{}'.format(iminer)) + logger().debug('iminer:{}'.format(iminer)) # Reward reward = -abs(iminer) @@ -256,14 +248,14 @@ def step(self, action): # reward = np.array(1. * math.exp(-5 * abs(np.asscalar(iminer)))) if abs(iminer) >= 2: - logger.info('iminer:{} is out of bounds'.format(iminer)) + logger().info('iminer:{} is out of bounds'.format(iminer)) done = True penalty = 5 * (self.max_steps - self.steps) reward -= penalty # if done: # penalty = 5 * (self.max_steps - self.steps) - # logger.info('penalty:{} is out of bounds'.format(penalty)) + # logger().info('penalty:{} is out of bounds'.format(penalty)) # reward -= penalty if self.steps >= int(self.max_steps): @@ -293,21 +285,21 @@ def reset(self): # Prepare the random sample ## self.batch_id = 10 # self.batch_id = np.random.randint(0, high=self.nbatches) - logger.info('Resetting env') + logger().info('Resetting env') # self.state = np.zeros(shape=(1,5,150)) - logger.debug('self.state:{}'.format(self.state)) + logger().debug('self.state:{}'.format(self.state)) self.state = None self.state = np.copy(self.X_train[self.batch_id].reshape(1, self.nvariables, self.nsamples)) - logger.debug('self.state:{}'.format(self.state)) - logger.debug('reset_data.shape:{}'.format(self.state.shape)) + logger().debug('self.state:{}'.format(self.state)) + logger().debug('reset_data.shape:{}'.format(self.state.shape)) self.min_BIMIN = self.scalers[0].inverse_transform(self.state[:, 0, :]).min() self.max_BIMIN = self.scalers[0].inverse_transform(self.state[:, 0, :]).max() - logger.info('Lower and upper B:VIMIN: [{},{}]'.format(self.min_BIMIN, self.max_BIMIN)) + logger().info('Lower and upper B:VIMIN: [{},{}]'.format(self.min_BIMIN, self.max_BIMIN)) # self.min_BIMIN = self.min_BIMIN * 0.9999 # self.max_BIMIN = self.max_BIMIN * 1.0001 self.VIMIN = self.state[0, 0, -1:] - logger.debug('Normed VIMIN:{}'.format(self.VIMIN)) - logger.debug('B:VIMIN:{}'.format(self.scalers[0].inverse_transform(np.array([self.VIMIN]).reshape(1, -1)))) + logger().debug('Normed VIMIN:{}'.format(self.VIMIN)) + logger().debug('B:VIMIN:{}'.format(self.scalers[0].inverse_transform(np.array([self.VIMIN]).reshape(1, -1)))) return self.state[0, :, -1:].flatten() def render(self): @@ -323,17 +315,17 @@ def render(self): plt.rcParams['font.family'] = [u'serif'] plt.rcParams['font.size'] = 16 - logger.debug('render()') - logger.debug('Save path:{}'.format(self.save_dir)) + logger().debug('render()') + logger().debug('Save path:{}'.format(self.save_dir)) render_dir = os.path.join(self.save_dir, 'render') - logger.debug('Render path:{}'.format(render_dir)) + logger().debug('Render path:{}'.format(render_dir)) if not os.path.exists(render_dir): os.mkdir(render_dir) import seaborn as sns sns.set_style("ticks") nvars = 2 # len(self.variables) fig, axs = plt.subplots(nvars, figsize=(12, 8)) - logger.debug('self.state:{}'.format(self.state)) + logger().debug('self.state:{}'.format(self.state)) for v in range(0, nvars): utrace = self.state[0, v, :] trace = self.scalers[v].inverse_transform(utrace.reshape(-1, 1)) diff --git a/exarl/envs/env_vault/ExaBoosterNew.py b/exarl/envs/env_vault/ExaBoosterNew.py new file mode 100644 index 00000000..bec71f05 --- /dev/null +++ b/exarl/envs/env_vault/ExaBoosterNew.py @@ -0,0 +1,455 @@ + +import os +import sys +import errno +import logging +import requests +import numpy as np +import pandas as pd +import matplotlib.pyplot as plt + +import gym +from gym import spaces +from gym.utils import seeding +import tensorflow as tf +from tensorflow import keras + +from exarl.utils.globals import ExaGlobals + +logging.basicConfig(format='%(asctime)s - %(levelname)s - %(message)s') +logger = logging.getLogger('RL-Logger') +logger.setLevel(logging.INFO) +np.seterr(divide='ignore', invalid='ignore') + +def load_reformated_cvs(filename, nrows=100000): + df = pd.read_csv(filename, nrows=nrows) + df = df.replace([np.inf, -np.inf], np.nan) + df = df.dropna(axis=0) + return df + +def create_dataset(dataset, look_back=10 * 15, look_forward=1): + X, Y = [], [] + offset = look_back + look_forward + for i in range(len(dataset) - (offset + 1)): + xx = dataset[i:(i + look_back), 0] + yy = dataset[(i + look_back):(i + offset), 0] + X.append(xx) + Y.append(yy) + return np.array(X), np.array(Y) + + +def get_dataset(df, variable='B:VIMIN'): + dataset = df[variable].values + dataset = dataset.astype('float32') + dataset = np.reshape(dataset, (-1, 1)) + + train_size = int(len(dataset) * 0.70) + train, test = dataset[0:train_size, :], dataset[train_size:len(dataset), :] + + X_train, Y_train = create_dataset(train, look_back=15) # 3/25 needed to change to replicate results of the paper #15) + X_train = np.reshape(X_train, (X_train.shape[0], 1, X_train.shape[1])) + Y_train = np.reshape(Y_train, (Y_train.shape[0], Y_train.shape[1])) + return X_train, Y_train # scaler, X_test, Y_test + + +def all_inplace_scale(df): + scale_dict = {} + + for var in ['B:VIMIN', 'B:IMINER', 'B_VIMIN', 'B:LINFRQ', 'I:IB', 'I:MDAT40']: # TODO: make dynamic + our_data2 = df + trace = our_data2[var].astype('float32') + data = np.array(trace) + # print(data) + median = np.median(data) + upper_quartile = np.percentile(data, 75) + lower_quartile = np.percentile(data, 25) + # print(median, upper_quartile, lower_quartile) + iqr = upper_quartile - lower_quartile + lower_whisker = data[data >= lower_quartile - 1.5 * iqr].min() + upper_whisker = data[data <= upper_quartile + 1.5 * iqr].max() + ranged = upper_whisker - lower_whisker + # (value − median) / (upper - lower) + our_data2[var] = 1 / ranged * (data - median) + + scale_dict[str(var)] = {"median": median, "range": ranged} + + return scale_dict + +def unscale(var_name, tseries, scale_dict): + # equivalent to inverse transform + from_model = np.asarray(tseries) + update = from_model * scale_dict[str(var_name)]["range"] + scale_dict[str(var_name)]["median"] + + return(update) + +def rescale(var_name, tseries, scale_dict): + # equivalent to transform + data = np.asarray(tseries) + update = 1 / scale_dict[str(var_name)]["range"] * (data - scale_dict[str(var_name)]["median"]) + return(update) + +def create_dropout_predict_model(model, dropout): + + # Load the config of the original model + conf = model.get_config() + + # Add the specified dropout to all layers + for layer in conf['layers']: + # Dropout layers + if layer["class_name"] == "Dropout": + layer["config"]["rate"] = dropout + + # Create a new model with specified dropout + model_dropout = keras.Model.from_config(conf) + model_dropout.set_weights(model.get_weights()) + return model_dropout + +def regulation(alpha, gamma, error, min_set, beta): + # calculate the prediction with current regulation rules + ER = error # error + _MIN = min_set # setting + for i in range(len(_MIN)): + if i > 0: + beta_t = beta[-1] + gamma * ER[i] + beta.append(beta_t) # hopefully this will update self.rachael_beta in place + MIN_pred = _MIN - alpha * ER - np.asarray(beta[-15:]).reshape(15, 1) # predict the next, shiftting happens in the plotting #check here + # used to be 15, now 150 + return MIN_pred + +class ExaBooster_v2(gym.Env): + def __init__(self): + + self.save_dir = os.getcwd() # './' + self.episodes = 0 + self.steps = 0 + self.max_steps = 100 + self.total_reward = 0 + self.data_total_reward = 0 + self.diff = 0 + + self.rachael_reward = 0 + self.rachael_beta = [0] # unclear if needed... depends on whether the regulation should be allowed to build continuously + + try: + booster_data_dir = ExaGlobals.lookup_params('booster_data_dir') + except: + sys.exit("Must set booster_data_dir") + booster_dir = ExaGlobals.lookup_params('model_dir') + if booster_dir == 'None': + self.file_dir = os.path.dirname(__file__) + booster_dir = os.path.join(self.file_dir, 'env_data/booster_data') + logger.info('booster related directory: '.format(booster_dir)) + try: + os.mkdir(booster_dir) + except OSError as exc: + if exc.errno != errno.EEXIST: + logger.error("Creation of the directory %s failed" % booster_dir) + else: + logger.error("Successfully created the directory %s " % booster_dir) + booster_model_file = ExaGlobals.lookup_params('model_file') + booster_model_pfn = os.path.join(booster_dir, booster_model_file) + print("booster model file=", booster_model_pfn, flush=True) + with tf.device('/cpu:0'): + self.booster_model = keras.models.load_model(booster_model_pfn) + + # Check if data is available + # booster_data_file = 'BOOSTR.csv' + booster_data_file = ExaGlobals.lookup_params('data_file') + booster_file_pfn = os.path.join(booster_data_dir, booster_data_file) + logger.info('Booster data file pfn:{}'.format(booster_file_pfn)) + if not os.path.exists(booster_file_pfn): + logger.info('No cached file. Downloading...') + try: + # url = 'https://zenodo.org/record/4088982/files/data%20release.csv?download=1' + url = ExaGlobals.lookup_params('url') + r = requests.get(url, allow_redirects=True) + open(booster_file_pfn, 'wb').write(r.content) + except: + logger.error("Problem downloading file") + else: + logger.info('Using exiting cached file') + + self.booster_model = create_dropout_predict_model(self.booster_model, 0) # calibrated on 3/02/2021: .2 + + # Load scalers + # Load data to initialize the env + # filename = 'data_release.csv' # 'decomposed_all.csv' #no longer want decomposed data + # data = dp.load_reformated_cvs('../data/' + filename, nrows=250000) + data = load_reformated_cvs(booster_file_pfn, nrows=250000) + scale_dict = all_inplace_scale(data) + data['B:VIMIN'] = data['B:VIMIN'].shift(-1) + data = data.set_index(pd.to_datetime(data.time)) + data = data.dropna() + data = data.drop_duplicates() + self.variables = ['B:VIMIN', 'B:IMINER', 'B_VIMIN', 'B:LINFRQ', 'I:IB', 'I:MDAT40'] + self.nvariables = len(self.variables) + logger.info('Number of variables:{}'.format(self.nvariables)) + self.scale_dict = scale_dict + # self.scalers = [] + data_list = [] + x_train = [] + + # get_dataset also normalizes the data + for v in range(len(self.variables)): + data_list.append(get_dataset(data, variable=self.variables[v])) + # self.scalers.append(data_list[v][2]) # comment out for new scaling + x_train.append(data_list[v][0]) + + # Axis + self.concate_axis = 1 + self.X_train = np.concatenate(x_train, axis=self.concate_axis) + + self.nbatches = self.X_train.shape[0] + self.nsamples = self.X_train.shape[2] + self.batch_id = self.episodes + 4200 + self.data_state = None + + print('Data shape:{}'.format(self.X_train.shape)) + self.observation_space = spaces.Box( + low=0, + high=1, + shape=(self.nvariables,), + dtype=np.float64 + ) + + # DYNAMIC ACTION SPACE SIZING + data['B:VIMIN_DIFF'] = data['B:VIMIN'] - data['B:VIMIN'].shift(-1, fill_value=0) + self.nactions = 15 # set here + # Discrete + # self.action_space = spaces.Discrete(self.nactions) + # Continuous + self.action_space = spaces.Box(low=np.percentile(data['B:VIMIN_DIFF'], 25), + high=np.percentile(data['B:VIMIN_DIFF'], 75), + shape=(1,), + dtype=np.float32) + self.actionMap_VIMIN = [] + for i in range(1, self.nactions + 1): + self.actionMap_VIMIN.append(data['B:VIMIN_DIFF'].quantile(i / (self.nactions + 1))) + + self.VIMIN = 0 + self.state = np.zeros(shape=(1, self.nvariables, self.nsamples)) + # self.B_VIMIN_state = np.zeros(shape= (1, 1, self.nsamples)) ### shouldn't normally need this + self.predicted_state = np.zeros(shape=(1, self.nvariables, 1)) + + self.rachael_state = np.zeros(shape=(1, self.nvariables, self.nsamples)) + self.rachael_predicted_state = np.zeros(shape=(1, self.nvariables, 1)) + + logger.debug('Init pred shape:{}'.format(self.predicted_state.shape)) + + def seed(self, seed=None): + self.np_random, seed = seeding.np_random(seed) + return [seed] + + def step(self, action): + self.steps += 1 + logger.debug('Episode/State: {}/{}'.format(self.episodes, self.steps)) + done = False + + # Steps: + # 1) Update VIMIN based on action + # 2) Predict booster variables + # 3) Predict next step for injector + # 4) Shift state with new values + + # Step 1: Calculate the new B:VIMIN based on policy action + logger.debug('Step() before action VIMIN:{}'.format(self.VIMIN)) + # Dicrete + # delta_VIMIN = self.actionMap_VIMIN[int(action)] + # Continuous + delta_VIMIN = action + DENORN_BVIMIN = unscale(self.variables[0], np.array([self.VIMIN]).reshape(1, -1), self.scale_dict) + DENORN_BVIMIN += delta_VIMIN + logger.debug('Step() descaled VIMIN:{}'.format(DENORN_BVIMIN)) + logger.debug('Action:{}'.format(delta_VIMIN)) + + # Rachael's Eq as an action + alpha = 10e-2 + gamma = 7.535e-5 + + B_VIMIN_trace = unscale(self.variables[2], self.state[0, 2, :].reshape(-1, 1), self.scale_dict) + BIMINER_trace = unscale(self.variables[1], self.state[0, 1, :].reshape(-1, 1), self.scale_dict) + + self.rachael_state[0][0][self.nsamples - 1] = rescale(self.variables[0], + regulation(alpha, + gamma, + error=BIMINER_trace, + min_set=B_VIMIN_trace, + beta=self.rachael_beta)[-1].reshape(-1, 1), + self.scale_dict) + self.VIMIN = rescale(self.variables[0], DENORN_BVIMIN, self.scale_dict) + + logger.debug('Step() updated VIMIN:{}'.format(self.VIMIN)) + self.state[0][0][self.nsamples - 1] = self.VIMIN + + # Step 2: Predict using booster model + self.predicted_state = self.booster_model.predict(self.state) + self.predicted_state = self.predicted_state.reshape(1, 2, 1) + # used to be 3 in the center #TODO: make dynamic, changing back. now should be 2 + + # Rachael's equation + self.rachael_predicted_state = self.booster_model.predict(self.rachael_state) + self.rachael_predicted_state = self.rachael_predicted_state.reshape(1, 2, 1) + + # Step 4: Shift state by one step + self.state[0, :, 0:-1] = self.state[0, :, 1:] # shift forward + self.rachael_state[0, :, 0:-1] = self.rachael_state[0, :, 1:] + + # Update IMINER + self.state[0][1][self.nsamples - 1] = self.predicted_state[0, 1:2] + self.rachael_state[0][1][self.nsamples - 1] = self.rachael_predicted_state[0, 1:2] + + # Update data state for rendering + self.data_state = np.copy(self.X_train[self.batch_id + self.steps].reshape(1, self.nvariables, self.nsamples)) + data_iminer = unscale(self.variables[1], self.data_state[0][1][self.nsamples - 1].reshape(1, -1), self.scale_dict) + + # where's data_vimin + data_reward = -abs(data_iminer) + + # Use data for everything but the B:IMINER prediction + self.state[0, 2:self.nvariables, :] = self.data_state[0, 2:self.nvariables, :] + self.rachael_state[0, 2:self.nvariables, :] = self.data_state[0, 2:self.nvariables, :] + + iminer = self.predicted_state[0, 1] + logger.debug('norm iminer:{}'.format(iminer)) + iminer = unscale(self.variables[1], np.array([iminer]), self.scale_dict).reshape(1, -1) + + logger.debug('iminer:{}'.format(iminer)) + + # Reward + reward = -abs(iminer) + + # update rachael state for rendering + rach_reward = -abs(unscale(self.variables[1], np.array([self.rachael_predicted_state[0, 1]]).reshape(1, -1), self.scale_dict)) + + if self.steps >= int(self.max_steps): + done = True + + self.diff += np.asscalar(abs(data_iminer - iminer)) + self.data_total_reward += np.asscalar(data_reward) + self.total_reward += np.asscalar(reward) + self.rachael_reward += np.asscalar(rach_reward) + + if self.episodes % 100 == 0: # so over this rendering... + self.render() + reward_list = [np.asscalar(reward), np.asscalar(rach_reward), np.asscalar(data_reward)] + return self.state[0, :, -1:].flatten(), reward_list[0], done, {} + + def reset(self): + self.episodes += 1 + self.steps = 0 + self.data_total_reward = 0 + self.total_reward = 0 + self.diff = 0 + self.rachael_reward = 0 + self.rachael_beta = [0] + + # Prepare the random sample ## + # self.batch_id = 10 + self.batch_id = self.episodes + 4200 + logger.info('Resetting env') + # self.state = np.zeros(shape=(1,5,150)) + logger.debug('self.state:{}'.format(self.state)) + self.state = None + self.state = np.copy(self.X_train[self.batch_id].reshape(1, self.nvariables, self.nsamples)) + + self.data_state = None + self.state = np.copy(self.X_train[self.batch_id].reshape(1, self.nvariables, self.nsamples)) + + self.rachael_state = None + self.rachael_state = np.copy(self.X_train[self.batch_id].reshape(1, self.nvariables, self.nsamples)) + + logger.debug('self.state:{}'.format(self.state)) + logger.debug('reset_data.shape:{}'.format(self.state.shape)) + self.VIMIN = self.state[0, 0, -1:] + logger.debug('Normed VIMIN:{}'.format(self.VIMIN)) + logger.debug('B:VIMIN:{}'.format(unscale(self.variables[0], np.array([self.VIMIN]), self.scale_dict).reshape(1, -1))) + + return self.state[0, :, -1:].flatten() + + def render(self): + plt.rcParams['axes.titlesize'] = 18 + plt.rcParams['axes.titleweight'] = 'bold' + plt.rcParams['axes.labelsize'] = 18 + plt.rcParams['axes.labelweight'] = 'regular' + plt.rcParams['xtick.labelsize'] = 14 + plt.rcParams['ytick.labelsize'] = 14 + plt.rcParams['font.family'] = [u'serif'] + plt.rcParams['font.size'] = 14 + plt.rcParams['font.family'] = [u'serif'] + plt.rcParams['font.size'] = 16 + + logger.debug('render()') + + import seaborn as sns + sns.set_style("ticks") + nvars = 2 # len(self.variables)> we just want B:VIMIN and B:IMINER + fig, axs = plt.subplots(nvars, figsize=(12, 8)) + logger.debug('self.state:{}'.format(self.state)) + + # Rachael's Eq + alpha = 10e-2 + gamma = 7.535e-5 + # try dstate + BVIMIN_trace = unscale(self.variables[0], self.state[0, 0, 1:-1].reshape(-1, 1), self.scale_dict) + BIMINER_trace = unscale(self.variables[1], self.state[0, 1, :].reshape(-1, 1), self.scale_dict) + + B_VIMIN_trace = unscale(self.variables[2], self.state[0, 2, :].reshape(-1, 1), self.scale_dict) + + # something is weird with this change... it definitely is predicting 180 value which isn't right + BVIMIN_pred = unscale(self.variables[0], self.rachael_state[0, 0, :].reshape(-1, 1), self.scale_dict) + rachael_IMINER = unscale(self.variables[1], self.rachael_state[0, 1, :].reshape(-1, 1), self.scale_dict) + + for v in range(0, nvars): + utrace = self.state[0, v, :] + trace = unscale(self.variables[v], utrace.reshape(-1, 1), self.scale_dict) + if v == 0: + # soemthing seems weird... might need to actually track it above + axs[v].set_title('Raw data reward: {:.2f} - RL agent reward: {:.2f} - PID Eq reward {:.2f}'.format(self.data_total_reward, + self.total_reward, self.rachael_reward)) + + axs[v].plot(trace, label='RL Policy', color='black') + + # if v==1: + data_utrace = self.data_state[0, v, :] + data_trace = unscale(self.variables[v], data_utrace.reshape(-1, 1), self.scale_dict) + + if v == 1: + x = np.linspace(0, 14, 15) # np.linspace(0, 14, 15) #np.linspace(0, 149, 150) #TODO: change this so that it is dynamic for lookback + axs[v].fill_between(x, -data_trace.flatten(), +data_trace.flatten(), alpha=0.2, color='red') + + axs[v].plot(data_trace, 'r--', label='Data') + # axs[v].plot() + axs[v].set_xlabel('time') + axs[v].set_ylabel('{}'.format(self.variables[v])) + # axs[v].legend(loc='upper left') + + # replaced np.linspace(0,14,15) + axs[0].plot(np.linspace(0, 14, 15), BVIMIN_pred, label="PID Eq", color='blue', linestyle='dotted') + axs[0].legend(loc='upper left') + axs[1].plot(np.linspace(0, 14, 15), rachael_IMINER, label="PID Eq", color='blue', linestyle='dotted') + axs[1].legend(loc='upper left') + + plt.savefig(ExaGlobals.lookup_params('output_dir') + 'episode{}_step{}_v1.png'.format(self.episodes, self.steps)) + plt.clf() + + fig, axs = plt.subplots(1, figsize=(12, 12)) + + Y_agent_bvimin = unscale(self.variables[0], self.state[0][0].reshape(-1, 1), self.scale_dict).reshape(-1, 1) + Y_agent_biminer = unscale(self.variables[1], self.state[0][1].reshape(-1, 1), self.scale_dict).reshape(-1, 1) + Y_data_bvimin = unscale(self.variables[0], self.data_state[0][0].reshape(-1, 1), self.scale_dict).reshape(-1, 1) + Y_data_biminer = unscale(self.variables[1], self.data_state[0][1].reshape(-1, 1), self.scale_dict).reshape(-1, 1) + Y_rachael_bvimin = unscale(self.variables[0], self.rachael_state[0][0].reshape(-1, 1), self.scale_dict).reshape(-1, 1) + Y_rachael_iminer = unscale(self.variables[1], self.rachael_state[0][1].reshape(-1, 1), self.scale_dict).reshape(-1, 1) + + np_predict = np.concatenate((Y_data_bvimin, Y_data_biminer, Y_agent_bvimin, Y_agent_biminer, + Y_rachael_bvimin, Y_rachael_iminer), axis=self.concate_axis) + df_cool = pd.DataFrame(np_predict, columns=['bvimin_data', 'biminer_data', 'bvimin_agent', 'biminer_agent', 'bvimin_rachael', 'biminer_rachael']) + + plt.scatter(Y_data_bvimin, Y_data_biminer, color='red', alpha=0.5, label='Data') + plt.scatter(Y_agent_bvimin, Y_agent_biminer, color='black', alpha=0.5, label='RL Policy') + plt.scatter(Y_rachael_bvimin, Y_rachael_iminer, color='blue', alpha=0.5, label='PID Eq') + plt.xlabel('B:VIMIN') + plt.ylabel('B:IMINER') + plt.legend() + plt.savefig(ExaGlobals.lookup_params('output_dir') + '/corr_episode{}_step{}.png'.format(self.episodes, self.steps)) + plt.close('all') diff --git a/exarl/envs/env_vault/ExaCH.py b/exarl/envs/env_vault/ExaCH.py index e4c1a41b..9e4ebc62 100644 --- a/exarl/envs/env_vault/ExaCH.py +++ b/exarl/envs/env_vault/ExaCH.py @@ -10,8 +10,7 @@ from gym import spaces from exarl.base.comm_base import ExaComm -import exarl as erl -import exarl.utils.candleDriver as cd +from exarl.utils.globals import ExaGlobals sys.path.append('envs/env_vault/CahnHilliard2D/cpp/python') sys.path.append('envs/env_vault/ImageStructure') @@ -60,19 +59,19 @@ def __init__(self): # Declare hyper-parameters, initialized for determining datatype super().__init__() - self.debug = cd.run_params['debug'] # 0 - self.change_T = cd.run_params['changeT'] # 0.1 - self.initT = cd.run_params['initT'] # 0.5 - self.targetT = cd.run_params['targetT'] # 0.5 - self.notTrain = cd.run_params['notTrain'] # False - self.output_dir = cd.run_params['output_dir'] - self.target_dir = cd.run_params['target_dir'] # './data/ch/' - self.target_file = cd.run_params['target_file'] # 'target.out' - self.notPlotRL = cd.run_params['notPlotRL'] # False - self.length = cd.run_params['length'] # 100 - self.genTarget = cd.run_params['genTarget'] # True - self.randInitial = cd.run_params['randInitial'] # False - self.steps = cd.run_params['n_steps'] + self.debug = ExaGlobals.lookup_params('debug') # 0 + self.change_T = ExaGlobals.lookup_params('changeT') # 0.1 + self.initT = ExaGlobals.lookup_params('initT') # 0.5 + self.targetT = ExaGlobals.lookup_params('targetT') # 0.5 + self.notTrain = ExaGlobals.lookup_params('notTrain') # False + self.output_dir = ExaGlobals.lookup_params('output_dir') + self.target_dir = ExaGlobals.lookup_params('target_dir') # './data/ch/' + self.target_file = ExaGlobals.lookup_params('target_file') # 'target.out' + self.notPlotRL = ExaGlobals.lookup_params('notPlotRL') # False + self.length = ExaGlobals.lookup_params('length') # 100 + self.genTarget = ExaGlobals.lookup_params('genTarget') # True + self.randInitial = ExaGlobals.lookup_params('randInitial') # False + self.steps = ExaGlobals.lookup_params('n_steps') # self.args = args self.comm = ExaComm.global_comm diff --git a/exarl/envs/env_vault/ExaCartpoleStatic.py b/exarl/envs/env_vault/ExaCartpoleStatic.py index 9cbed9af..3ff26a9a 100644 --- a/exarl/envs/env_vault/ExaCartpoleStatic.py +++ b/exarl/envs/env_vault/ExaCartpoleStatic.py @@ -26,6 +26,7 @@ import exarl as erl # from envs.env_vault.computePI import computePI as cp from exarl.base.comm_base import ExaComm +from exarl.utils.introspect import introspectTrace def computePI(N, new_comm): @@ -49,6 +50,7 @@ def __init__(self): self.action_space = self.env.action_space self.observation_space = self.env.observation_space + @introspectTrace() def step(self, action): next_state, reward, done, info = self.env.step(action) time.sleep(0) # Delay in seconds diff --git a/exarl/envs/env_vault/ExaWaterClusterDiscrete.py b/exarl/envs/env_vault/ExaWaterClusterDiscrete.py index 43d753e9..a4bfb282 100644 --- a/exarl/envs/env_vault/ExaWaterClusterDiscrete.py +++ b/exarl/envs/env_vault/ExaWaterClusterDiscrete.py @@ -18,15 +18,15 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 -from exarl.base.comm_base import ExaComm -import gym -import time import numpy as np +import gym from gym import error, spaces, utils from gym.utils import seeding -from exarl.utils import log -import exarl.utils.candleDriver as cd -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) + +from exarl.utils.globals import ExaGlobals +from exarl.base.comm_base import ExaComm + +logger = ExaGlobals.setup_logger(__name__) from ase.io import read, write from ase import Atom, Atoms @@ -172,7 +172,7 @@ def hook(model, input, output): def get_state_embedding(model, structure): data_loader = load_data(structure, idx=0) activation = {} - logger.debug('torch.no_grad()') + logger().debug('torch.no_grad()') with torch.no_grad(): for batch in data_loader: model.module.output_modules[0].standardize.register_forward_hook(get_activation('standardize', activation)) @@ -263,14 +263,14 @@ def __init__(self): # Setup water molecule application (should be configurable) self.file_dir = os.path.dirname(__file__) - self.env_input_name = cd.run_params['env_input_name'] + self.env_input_name = ExaGlobals.lookup_params('env_input_name') self.env_input_dir = os.path.join(self.file_dir, 'env_data/water_cluster_data') self.env_input = os.path.join(self.env_input_dir, self.env_input_name) - self.output_dir = cd.run_params['output_dir'] + self.output_dir = ExaGlobals.lookup_params('output_dir') self.calc = TTMCalculator() # Schnet encodering model - self.schnet_model_name = cd.run_params['env_schnet_model_name'] + self.schnet_model_name = ExaGlobals.lookup_params('env_schnet_model_name') self.schnet_model_pfn = os.path.join(self.env_input_dir, self.schnet_model_name) model = torch.load(self.schnet_model_pfn, map_location='cpu') self.schnet_model = torch.nn.DataParallel(model.module) @@ -303,20 +303,20 @@ def __init__(self): def _load_structure(self, env_input): # Read initial XYZ file - logger.debug('Env Input: {}'.format(env_input)) + logger().debug('Env Input: {}'.format(env_input)) structure = read(env_input, parallel=False) - logger.debug('Structure: {}'.format(structure)) + logger().debug('Structure: {}'.format(structure)) nclusters = (''.join(structure.get_chemical_symbols()).count("OHH")) - 1 - logger.debug('Number of atoms: %s' % len(structure)) - logger.debug('Number of water clusters: %s ' % (nclusters + 1)) + logger().debug('Number of atoms: %s' % len(structure)) + logger().debug('Number of water clusters: %s ' % (nclusters + 1)) return (structure, nclusters) def step(self, action): - logger.debug('Env::step()') + logger().debug('Env::step()') self.steps += 1 - logger.debug('Env::step(); steps[{0:3d}]'.format(self.steps)) - logger.debug('Current energy:{}'.format(self.current_energy)) - logger.debug('Action Choice:{}'.format(action)) + logger().debug('Env::step(); steps[{0:3d}]'.format(self.steps)) + logger().debug('Current energy:{}'.format(self.current_energy)) + logger().debug('Action Choice:{}'.format(action)) # Initialize outut done = False @@ -326,7 +326,7 @@ def step(self, action): natoms = 3 # Extract actions action = self.action_map[action] - logger.debug('Action:{}'.format(action)) + logger().debug('Action:{}'.format(action)) cluster_id = action[0] cluster_id = self.state_order[cluster_id] rotation_z = action[1] @@ -340,7 +340,7 @@ def step(self, action): dyn = SciPyFminLBFGSB(self.current_ase) dyn.run(fmax=1e-2) energy = self.calc.get_potential_energy(self.current_ase) - logger.debug('energy from ttm {}'.format(energy)) + logger().debug('energy from ttm {}'.format(energy)) except: done = True self.current_state = np.zeros(self.embedded_state_size) @@ -354,8 +354,8 @@ def step(self, action): # Reward is currently based on the potential energy lowest_energy_xyz = '' - logger.debug('lowest_energy:{}'.format(self.lowest_energy)) - logger.debug('energy:{}'.format(energy)) + logger().debug('lowest_energy:{}'.format(self.lowest_energy)) + logger().debug('energy:{}'.format(energy)) # Big reward and end episode if a lower energy is reached if round(self.lowest_energy, 3) > round(energy, 3): @@ -363,11 +363,11 @@ def step(self, action): # done = True # bias by episode # reward = (2*(self.current_energy - energy))*self.episode - logger.debug('Lowest energy found. status {}, reward {}'.format(done, reward)) + logger().debug('Lowest energy found. status {}, reward {}'.format(done, reward)) # self.current_state, self.state_order = get_state_embedding(self.schnet_model, self.current_ase) lowest_energy_xyz = os.path.join(self.output_dir, 'rotationz_rank{}_episode{}_steps{}_energy{}.xyz'.format( ExaComm.agent_comm.rank, self.episode, self.steps, round(self.lowest_energy, 4))) - logger.info("\t Found lower energy:{}".format(energy)) + logger().info("\t Found lower energy:{}".format(energy)) write_structure(lowest_energy_xyz, self.current_ase, self.current_energy) # return self.current_state, reward, done, {} @@ -382,9 +382,9 @@ def step(self, action): reward, done]) return self.current_state, reward, done, {} - logger.debug('Pre-step current energy:{}'.format(self.current_energy)) - logger.debug('Energy:{}'.format(energy)) - logger.debug('Reward:{}'.format(reward)) + logger().debug('Pre-step current energy:{}'.format(self.current_energy)) + logger().debug('Energy:{}'.format(energy)) + logger().debug('Reward:{}'.format(reward)) # Update state information self.current_state, self.state_order = get_state_embedding(self.schnet_model, self.current_ase) @@ -417,18 +417,18 @@ def step(self, action): translation, self.current_energy, self.current_state[0], reward, done]) - logger.debug('Reward:{}'.format(reward)) - logger.debug('Energy:{}'.format(energy)) + logger().debug('Reward:{}'.format(reward)) + logger().debug('Energy:{}'.format(energy)) return self.current_state, reward, done, {} def reset(self): - logger.info("Resetting the environemnts.") - logger.info("Current lowest energy: {}".format(self.lowest_energy)) + logger().info("Resetting the environemnts.") + logger().info("Current lowest energy: {}".format(self.lowest_energy)) self.episode += 1 self.steps = 0 self.streak = 0 - logger.debug('Env::reset(); episode[{0:4d}]'.format(self.episode, self.steps)) + logger().debug('Env::reset(); episode[{0:4d}]'.format(self.episode, self.steps)) (self.current_ase, self.nclusters) = self._load_structure(self.env_input) self.current_ase.calc = self.calc # self.current_structure = self.init_structure @@ -437,7 +437,7 @@ def reset(self): self.initial_energy = read_energy(self.env_input) self.current_energy = self.initial_energy self.current_state = state_embedding - logger.debug('self.current_state shape:{}'.format(self.current_state.shape)) + logger().debug('self.current_state shape:{}'.format(self.current_state.shape)) return self.current_state def render(self, mode='human'): diff --git a/exarl/envs/env_vault/GymSpaceTest.py b/exarl/envs/env_vault/GymSpaceTest.py deleted file mode 100644 index 6355d478..00000000 --- a/exarl/envs/env_vault/GymSpaceTest.py +++ /dev/null @@ -1,79 +0,0 @@ -import time -import sys -import gym -import json -import exarl as erl -import numpy as np -from gym import spaces -import exarl.utils.candleDriver as cd - -class GymSpaceTest(gym.Env): - - def __init__(self): - super().__init__() - - high = np.array([1, 1, 1], dtype=np.float64) - - spaceDict = { - "Discrete": spaces.Discrete(5), - "Box_One": spaces.Box(low=-1, high=1, shape=(1,), dtype=np.float64), - "Box_Two": spaces.Box(low=-1, high=1, shape=(1, 2), dtype=np.float64), - "Box": spaces.Box(low=-high, high=high, dtype=np.float64), - "MultiBinary": spaces.MultiBinary([2, 3]), - "MultiDiscrete": spaces.MultiDiscrete([3, 2]), - "Dict": spaces.Dict({ - "discrete": spaces.Discrete(100), - "box": spaces.Box(low=-1, high=1, shape=(3, 4), dtype=np.float64), - "multiBinary": spaces.MultiBinary([2, 3]), - "multiDiscrete": spaces.MultiDiscrete([3, 2]) - }) - } - - boolDict = { - "True": True, - "true": True, - "False": False, - "false": False - } - - actSpace = spaceDict[cd.lookup_params('action_space', default='Box')] - obvSpace = spaceDict[cd.lookup_params('observation_space', default='Box')] - actTuple = boolDict[cd.lookup_params('action_Tuple', default='False')] - obvTuple = boolDict[cd.lookup_params('observation_Tuple', default='False')] - - if actTuple: - self.action_space = spaces.Tuple((actSpace, actSpace)) - else: - self.action_space = actSpace - - if obvTuple: - self.observation_space = spaces.Tuple((obvSpace, obvSpace)) - else: - self.observation_space = obvSpace - - self.initial_state = self.observation_space.sample() - self.score = 0 - - print("ACTION SPACE", type(self.action_space), type(self.action_space.sample())) - - def step(self, action): - next_state = self.observation_space.sample() - # while True: - # try: - # gym.spaces.utils.flatten(self.observation_space, next_state) - # print("GOOD") - # break - # except: - # print("BAD", next_state) - # next_state = self.observation_space.sample() - - print("ACTION", type(action), action) - print("OBSERVATION", type(self.observation_space), next_state) - - self.score += 1 - reward = self.score - done = False - return next_state, reward, done, {} - - def reset(self): - return self.initial_state diff --git a/exarl/envs/env_vault/HadrecWrapper.py b/exarl/envs/env_vault/HadrecWrapper.py new file mode 100644 index 00000000..3843c431 --- /dev/null +++ b/exarl/envs/env_vault/HadrecWrapper.py @@ -0,0 +1,76 @@ +from asyncio.log import logger +import gym +import time +import numpy as np +import sys +import json +import exarl as erl +from exarl.base.comm_base import ExaComm + +import os +import gridpack +import gridpack.hadrec +import random +from gym.utils import seeding +from gym import spaces +import math +import xmltodict +import collections +import xml.etree.ElementTree as ET + +from exarl.envs.env_vault.Hadrec_dir.exarl_env.Hadrec import Hadrec +from exarl.utils.globals import ExaGlobals + +class HadrecWrapper(gym.Env): + + def __init__(self): + super().__init__() + + self.rl_config_file = ExaGlobals.lookup_params('rl_config_file') + self.simu_input_file = ExaGlobals.lookup_params('simu_input_file') + self.simu_input_Rawfile = ExaGlobals.lookup_params('simu_input_Rawfile') + self.simu_input_Dyrfile = ExaGlobals.lookup_params('simu_input_Dyrfile') + # This updates the input xml file with the required file location. + self.UpdateXMLFile() + + self.env = Hadrec(simu_input_file=self.simu_input_file, + rl_config_file=self.rl_config_file) + self.action_space = self.env.action_space + self.observation_space = self.env.observation_space + + def UpdateXMLFile(self): + tree = ET.parse(self.simu_input_file) + + logger.info("Updating the XML file with the candle passed input data path") + + logger.info(tree.find("Powerflow/networkFiles/networkFile/networkConfiguration_v33").text) + logger.info(tree.find("Dynamic_simulation/generatorParameters").text) + + (tree.find("Powerflow/networkFiles/networkFile/networkConfiguration_v33").text) = self.simu_input_Rawfile + (tree.find("Dynamic_simulation/generatorParameters").text) = self.simu_input_Dyrfile + + tree.write(self.simu_input_file) + + return + + def step(self, action): + return self.env.step(action) + + def reset(self): + return self.env.reset() + + def set_env(self): + return self.env.set_env() + + def seed(self, seed=None): + return self.env.seed(seed) + + # ---------------initialize the system with a specific state and fault + def validate(self, case_Idx, fault_bus_idx, fault_start_time, fault_duration_time): + return self.env.validate(case_Idx, fault_bus_idx, fault_start_time, fault_duration_time) + + def close_env(self): + return self.env.close_env() + + def get_base_cases(self): + return self.env.get_bases_cases() diff --git a/exarl/envs/env_vault/Hadrec_dir b/exarl/envs/env_vault/Hadrec_dir new file mode 160000 index 00000000..3ed11a19 --- /dev/null +++ b/exarl/envs/env_vault/Hadrec_dir @@ -0,0 +1 @@ +Subproject commit 3ed11a19c50a1c4cda6832a2cbf80601106ad803 diff --git a/exarl/envs/env_vault/UnitEvn.py b/exarl/envs/env_vault/UnitEvn.py new file mode 100644 index 00000000..294855b6 --- /dev/null +++ b/exarl/envs/env_vault/UnitEvn.py @@ -0,0 +1,144 @@ +import gym +from gym import spaces +import numpy as np +from exarl.base.comm_base import ExaComm + +class EnvGenerator: + """" + This class is used to generate environments to use for testing. + + Attributes + ---------- + high : np.array + Used to set the upper and lower bound of gym spaces + spaceDict : dictionary + Contains a map of string to gym spaces to test + """ + high = np.array([1, 1, 1], dtype=np.float64) + spaceDict = { + "Discrete": spaces.Discrete(5), + "Box_One": spaces.Box(low=-1, high=1, shape=(1,), dtype=np.float64), + "Box_Two": spaces.Box(low=-1, high=1, shape=(1, 2), dtype=np.float64), + "Box": spaces.Box(low=-high, high=high, dtype=np.float64), + "MultiBinary": spaces.MultiBinary([2, 3]), + "MultiDiscrete": spaces.MultiDiscrete([3, 2]), + "Dict": spaces.Dict({ + "discrete": spaces.Discrete(100), + "box": spaces.Box(low=-1, high=1, shape=(3, 4), dtype=np.float64), + "multiBinary": spaces.MultiBinary([2, 3]), + "multiDiscrete": spaces.MultiDiscrete([3, 2]) + }) + } + + @staticmethod + def createClass(action_space, observation_space, + action_tuple, observation_tuple, + reset_flag, max_steps, + num_seeds): + """ + This is the factory for new classes. + + Attributes + ---------- + action_space : string + String that maps to gym space for action + observation_space : string + String that maps to gym space for observation + action_tuple : string + Indicates if to use a tuple for action + observation_tuple : string + Indicates if to use a tuple for observation + reset_flag : bool + Indicates if reset should actually reset env + max_steps : int + The max steps before sending done after step + num_seeds : int + Number of unique seeds + + Returns + ------- + gym.Env + Environment to use for testing + """ + class envTester(gym.Env): + name = "_".join((action_space, observation_space, + str(action_tuple), str(observation_tuple), + str(reset_flag), str(max_steps), + str(num_seeds))) + "-v0" + + def __init__(self): + super().__init__() + actSpace = EnvGenerator.spaceDict[action_space] + obvSpace = EnvGenerator.spaceDict[observation_space] + self.action_space = spaces.Tuple((actSpace, actSpace)) if action_tuple else actSpace + self.observation_space = spaces.Tuple((obvSpace, obvSpace)) if observation_tuple else obvSpace + self.num_seeds = num_seeds + self.seed = 0 + self.initial_state = [] + for i in range(self.num_seeds): + self.initial_state.append(self.observation_space.sample()) + if ExaComm.is_actor(): + self.initial_state = ExaComm.env_comm.bcast(self.initial_state, root=0) + + self.state = self.initial_state[self.seed] + self.seed = (self.seed + 1) % self.num_seeds + self.step_index = 0 + self.max_steps = max_steps + + def step(self, action): + if self.step_index < self.max_steps: + self.state = self.observation_space.sample() + self.step_index += 1 + done = self.step_index == self.max_steps + return self.state, 1, done, {} + + def reset(self): + if reset_flag: + self.state = self.initial_state[self.seed] + self.seed = (self.seed + 1) % self.num_seeds + return self.state + + return envTester + + @staticmethod + def generator(reset_flag=True, max_steps=100, num_seeds=20): + """ + This is the generator to iterate through different options. + + Attributes + ---------- + reset_flag : True + Indicates if classes generaged actually reset + max_steps : int + Max step of the classes generated + num_seeds : int + Number of seed of the classes generated + + Returns + ------- + gym.env + A tester environment + """ + for act_tuple in [False, True]: + for obs_tuple in [False, True]: + for act_space in EnvGenerator.spaceDict: + for obs_space in EnvGenerator.spaceDict: + yield EnvGenerator.createClass(act_space, obs_space, act_tuple, obs_tuple, reset_flag, max_steps, num_seeds) + + @staticmethod + def getNames(reset_flag=True, max_steps=100, num_seeds=20): + """ + Returns the names of the classes generated + Returns + ------- + List + Names of the classes generated + """ + for action_tuple in [False, True]: + for observation_tuple in [False, True]: + for action_space in EnvGenerator.spaceDict: + for observation_space in EnvGenerator.spaceDict: + yield "_".join((action_space, observation_space, + str(action_tuple), str(observation_tuple), + str(reset_flag), str(max_steps), + str(num_seeds))) + "-v0" diff --git a/exarl/envs/env_vault/__init__.py b/exarl/envs/env_vault/__init__.py index 81ec549a..fc60bb41 100755 --- a/exarl/envs/env_vault/__init__.py +++ b/exarl/envs/env_vault/__init__.py @@ -1,5 +1,8 @@ -import exarl.utils.candleDriver as cd -env = cd.lookup_params('env') +from exarl.utils.globals import ExaGlobals +try: + env = ExaGlobals.lookup_params('env') +except: + env = None if env == 'ExaCartPoleStatic-v0': from exarl.envs.env_vault.ExaCartpoleStatic import ExaCartpoleStatic @@ -9,5 +12,11 @@ from exarl.envs.env_vault.ExaCOVID import ExaCOVID elif env == 'ExaBoosterDiscrete-v0': from exarl.envs.env_vault.ExaBoosterDiscrete import ExaBooster_v1 as ExaBooster +elif env == 'ExaBoosterNew-v0': + from exarl.envs.env_vault.ExaBoosterNew import ExaBooster_v2 as ExaBooster elif env == 'ExaWaterClusterDiscrete-v0': from exarl.envs.env_vault.ExaWaterClusterDiscrete import ExaWaterClusterDiscrete +elif env == 'Hadrec-v0': + from exarl.envs.env_vault.HadrecWrapper import HadrecWrapper +elif env == 'Bsuite-v0': + from exarl.envs.env_vault.BsuiteWrapper import BsuiteWrapper diff --git a/exarl/envs/env_vault/env_data/booster_data/TrainingData/ExaBooster_TrainValTest_LSTM_lookback_15step.h5 b/exarl/envs/env_vault/env_data/booster_data/TrainingData/ExaBooster_TrainValTest_LSTM_lookback_15step.h5 new file mode 100644 index 00000000..7d7c961d --- /dev/null +++ b/exarl/envs/env_vault/env_data/booster_data/TrainingData/ExaBooster_TrainValTest_LSTM_lookback_15step.h5 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:9adce6739b5ef2edea46d283cc1e262b866def78bbae934963b83bc0fc67f062 +size 58880064 diff --git a/exarl/envs/env_vault/env_data/booster_data/TrainingData/ExaBooster_TrainValTest_XYPair_lookback_1step.h5 b/exarl/envs/env_vault/env_data/booster_data/TrainingData/ExaBooster_TrainValTest_XYPair_lookback_1step.h5 new file mode 100644 index 00000000..881891db --- /dev/null +++ b/exarl/envs/env_vault/env_data/booster_data/TrainingData/ExaBooster_TrainValTest_XYPair_lookback_1step.h5 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3fdc7a36658934a9a9fd3b5b24e49fb317688aedae8afa602096de8814af98cb +size 5130432 diff --git a/exarl/envs/env_vault/env_data/booster_data/fullbooster_noshift_e25_bs32_k_invar6_outvar2_axis1_mmscaler_t0_D03012021-T173721_kfold4__final.h5 b/exarl/envs/env_vault/env_data/booster_data/fullbooster_noshift_e25_bs32_k_invar6_outvar2_axis1_mmscaler_t0_D03012021-T173721_kfold4__final.h5 new file mode 100644 index 00000000..51e9f8b6 --- /dev/null +++ b/exarl/envs/env_vault/env_data/booster_data/fullbooster_noshift_e25_bs32_k_invar6_outvar2_axis1_mmscaler_t0_D03012021-T173721_kfold4__final.h5 @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3ae757b88b780681359fa8b6a42e54e3b1ac82b0a41b759abdfe8d1b6628d554 +size 16008832 diff --git a/exarl/network/__init__.py b/exarl/network/__init__.py index a23d50e7..cb2e4b98 100644 --- a/exarl/network/__init__.py +++ b/exarl/network/__init__.py @@ -1,4 +1,4 @@ from exarl.network import simple_comm from exarl.network import mpi_comm from exarl.network import data_structures -from exarl.network import typing +# from exarl.network import typing diff --git a/exarl/network/data_structures.py b/exarl/network/data_structures.py index 6458224d..a224d8ff 100644 --- a/exarl/network/data_structures.py +++ b/exarl/network/data_structures.py @@ -12,16 +12,15 @@ import sys import os import numpy as np +from pickletools import optimize from exarl.base import ExaData from exarl.base.comm_base import ExaComm -from exarl.network.simple_comm import ExaSimple from exarl.network.typing import TypeUtils from exarl.utils.introspect import introspectTrace -MPI = ExaSimple.MPI class ExaMPIConstant: """ - This class is built to maintain a single value using mpi rdma. + This class is built to maintain a single value using MPI RDMA. Each rank will have a window the size of the type. Attributes @@ -51,10 +50,13 @@ class ExaMPIConstant: """ - def __init__(self, comm, rank_mask, the_type, name=None): + def __init__(self, comm, rank_mask, the_type, inc=1, name=None): """ Parameters ---------- + MPI : mpi4py.MPI + mpi4py's MPI access point + comm : mpi4py.MPI.Comm Communicator for all ranks involved @@ -65,8 +67,9 @@ def __init__(self, comm, rank_mask, the_type, name=None): python type (int, float) name : string, optional - name of constant for debbuging + name of constant for debugging """ + self.MPI = ExaComm.get_MPI() self.comm = comm.raw() self.npType = TypeUtils.np_type_converter(the_type, promote=True) self.mpiType = TypeUtils.mpi_type_converter(the_type, promote=True) @@ -75,13 +78,13 @@ def __init__(self, comm, rank_mask, the_type, name=None): if rank_mask: self.rank = self.comm.rank data = np.zeros(1, dtype=self.npType) - self.win = MPI.Win.Create(data, self.size, comm=self.comm) - self.sum = np.ones(1, dtype=self.npType) + self.win = self.MPI.Win.Create(data, self.size, comm=self.comm) + self.sum = np.ones(1, dtype=self.npType) * inc self.buff = np.zeros(1, dtype=self.npType) self.name = name @introspectTrace(name=True) - def put(self, value, rank): + def put(self, value, rank=None): """ Places a constant on a given rank @@ -94,13 +97,15 @@ def put(self, value, rank): Host rank of the actual number """ + if rank is None: + rank = self.rank data = np.array(value, dtype=self.npType) self.win.Lock(rank) - self.win.Accumulate(data, target_rank=rank, op=MPI.REPLACE) + self.win.Accumulate(data, target_rank=rank, op=self.MPI.REPLACE) self.win.Unlock(rank) @introspectTrace(name=True) - def get(self, rank): + def get(self, rank=None): """ Gets a constant from a given rank @@ -115,13 +120,15 @@ def get(self, rank): int Constant from host rank """ + if rank is None: + rank = self.rank self.win.Lock(rank) - self.win.Get_accumulate(self.sum, self.buff, target_rank=rank, op=MPI.NO_OP) + self.win.Get_accumulate(self.sum, self.buff, target_rank=rank, op=self.MPI.NO_OP) self.win.Unlock(rank) return self.buff[0] @introspectTrace(name=True) - def inc(self, rank): + def inc(self, rank=None): """ Increments a constant on host rank @@ -136,13 +143,15 @@ def inc(self, rank): int Constant from host rank before the increment """ + if rank is None: + rank = self.rank self.win.Lock(rank) - self.win.Get_accumulate(self.sum, self.buff, target_rank=rank, op=MPI.SUM) + self.win.Get_accumulate(self.sum, self.buff, target_rank=rank, op=self.MPI.SUM) self.win.Unlock(rank) return self.buff[0] @introspectTrace(name=True) - def min(self, value, rank): + def min(self, value, rank=None): """ Takes the min of new value and constant on host rank @@ -159,18 +168,20 @@ def min(self, value, rank): int Minimum of the new value and constant """ + if rank is None: + rank = self.rank data = np.array(value, dtype=self.npType) self.win.Lock(rank) - self.win.Get_accumulate(data, self.buff, target_rank=rank, op=MPI.MIN) + self.win.Get_accumulate(data, self.buff, target_rank=rank, op=self.MPI.MIN) self.win.Unlock(rank) return min(self.buff[0], value) class ExaMPIBuffUnchecked(ExaData): """ This class is creates an RMA buffer of a fixed size on each rank. - The buffer is used to send and recieve data across all participating ranks. + The buffer is used to send and receive data across all participating ranks. This buffer does not check to see if it is overwriting data or if there is - valid data from a get. This class always succeds a pop. + valid data from a get. This class always succeeds a pop. Attributes ---------- @@ -182,28 +193,8 @@ class ExaMPIBuffUnchecked(ExaData): buff : bytearray internal buffer used for RMA ops - - - **Intializer** - - Parameters - ---------- - comm : MPI Comm - Communicator for all ranks involved - data : list - Example data used to create buffer - rank_mask : int, optional - host of the window - length : int, optional - Not used - max_model_lag : int, optional - Not used - failPush : bool, optional - Not used - name : string, optional - name of constant for debbuging """ - def __init__(self, comm, data, rank_mask=None, length=1, max_model_lag=None, failPush=False, name=None): + def __init__(self, comm, data, size=None, length=1, fail_push=False, rank_mask=None, name=None): """ Parameters ---------- @@ -211,34 +202,28 @@ def __init__(self, comm, data, rank_mask=None, length=1, max_model_lag=None, fai Communicator for all ranks involved data : list Example data used to create buffer - rank_mask : int, optional - host of the window + size : int, optional + Size of data. The size of an element of the buffer will be overridden by this value + if provided (instead of the size from pickling data). length : int, optional Not used - max_model_lag : int, optional - Not used - failPush : bool, optional + fail_push : bool, optional Not used + rank_mask : int, optional + host of the window name : string, optional - name of constant for debbuging + name of constant for debugging """ - self.comm = comm - - dataBytes = MPI.pickle.dumps(data) - size = len(dataBytes) - - super().__init__(bytes, size, comm_size=comm.size, max_model_lag=None, name=name) + super().__init__(comm, 1, False, data=data, size=size, name=name) totalSize = 0 if rank_mask: - totalSize = size - self.win = MPI.Win.Allocate(totalSize, disp_unit=1, comm=self.comm.raw()) + totalSize = self.dataSize + self.win = self.MPI.Win.Allocate(totalSize, disp_unit=1, comm=self.comm.raw()) self.buff = bytearray(self.dataSize) - # If we are given data to start lets put it in our buffer - # Since everyone should call this everyone should get a start value! if rank_mask: - self.push(data) + self.push(None) def __del__(self): self.win.Free() @@ -268,10 +253,10 @@ def pop(self, rank, count=1): self.buff, rank, target=[0, self.dataSize], - op=MPI.NO_OP, + op=self.MPI.NO_OP, ) self.win.Unlock(rank) - return MPI.pickle.loads(self.buff) + return self.MPI.pickle.loads(self.buff) @introspectTrace(name=True) def push(self, data, rank=None): @@ -294,13 +279,16 @@ def push(self, data, rank=None): if rank is None: rank = self.comm.rank - toSend = MPI.pickle.dumps(data) - assert len(toSend) <= self.dataSize + toSend = self.MPI.pickle.dumps(data) + if len(toSend) > self.dataSize: + toSend = optimize(toSend) + toSend = bytearray(toSend) + assert len(toSend) <= self.dataSize, self.name + ":" + str(len(toSend)) + " vs " + str(self.dataSize) self.win.Lock(rank) # Accumulate is element-wise atomic vs put which is not self.win.Accumulate( - toSend, rank, target=[0, len(toSend)], op=MPI.REPLACE + toSend, rank, target=[0, len(toSend)], op=self.MPI.REPLACE ) self.win.Unlock(rank) return 1, 1 @@ -308,11 +296,14 @@ def push(self, data, rank=None): class ExaMPIBuffChecked(ExaData): """ This class is creates an RMA buffer of a fixed size on each rank. - The buffer is used to send and recieve data across all participating ranks. + The buffer is used to send and receive data across all participating ranks. On pop, checks to see if the data is first valid. Attributes ---------- + MPI : mpi4py.MPI + mpi4py's MPI access point + comm : mpi4py.MPI.Comm raw MPI communicator @@ -321,17 +312,8 @@ class ExaMPIBuffChecked(ExaData): buff : bytearray internal buffer used for RMA ops - - Methods - ------- - pop(value, rank, count) - Returns value stored in buffer at rank - - push(self, data, rank) - Pushes data to buffer at rank - """ - def __init__(self, comm, data, rank_mask=None, length=1, max_model_lag=None, failPush=False, name=None): + def __init__(self, comm, data, size=None, length=1, fail_push=False, rank_mask=None, name=None): """ Parameters ---------- @@ -339,38 +321,37 @@ def __init__(self, comm, data, rank_mask=None, length=1, max_model_lag=None, fai Communicator for all ranks involved data : list Example data used to create buffer - rank_mask : int, optional - host of the window + size : int, optional + Size of data. The size of an element of the buffer will be overridden by this value + if provided (instead of the size from pickling data). length : int Not used - max_model_lag : int - Not used - failPush : bool + fail_push : bool Not used + rank_mask : int, optional + host of the window name : string, optional name of constant for debbuging """ - - self.comm = comm - - self.dataBytes = bytearray(MPI.pickle.dumps((data, np.int64(0)))) - size = len(self.dataBytes) - - super().__init__(bytes, size, comm_size=comm.size, max_model_lag=None, name=name) + if size is None: + data = (data, np.int64(0)) + super().__init__(comm, 1, False, data=data, size=size, name=name) totalSize = 0 if rank_mask: - totalSize = size - self.win = MPI.Win.Allocate(totalSize, disp_unit=1, comm=self.comm.raw()) + totalSize = self.dataSize + self.win = self.MPI.Win.Allocate(totalSize, disp_unit=1, comm=self.comm.raw()) self.buff = bytearray(self.dataSize) + self.dataBytes = bytearray(self.MPI.pickle.dumps((None, np.int64(0)))) if rank_mask: self.win.Lock(self.comm.rank) self.win.Accumulate( - self.dataBytes, self.comm.rank, target=[0, self.dataSize], op=MPI.REPLACE + self.dataBytes, self.comm.rank, target=[0, totalSize], op=self.MPI.REPLACE ) self.win.Unlock(self.comm.rank) + def __del__(self): self.win.Free() @@ -399,11 +380,11 @@ def pop(self, rank, count=1): self.buff, rank, target=[0, self.dataSize], - op=MPI.REPLACE + op=self.MPI.REPLACE ) self.win.Unlock(rank) - data, valid = MPI.pickle.loads(self.buff) + data, valid = self.MPI.pickle.loads(self.buff) if valid: return data return None @@ -429,19 +410,23 @@ def push(self, data, rank=None): if rank is None: rank = self.comm.rank - toSend = bytearray(MPI.pickle.dumps((data, np.int64(1)))) - assert len(toSend) <= self.dataSize + toSend = self.MPI.pickle.dumps((data, np.int64(1))) + if len(toSend) > self.dataSize: + toSend = optimize(toSend) + toSend = bytearray(toSend) + assert len(toSend) <= self.dataSize, self.name + ": " + str(len(toSend)) + " vs " + str(self.dataSize) self.win.Lock(rank) self.win.Get_accumulate( toSend, self.buff, rank, - target=[0, self.dataSize], - op=MPI.REPLACE + target=[0, len(toSend)], + # target=[0, self.dataSize], + op=self.MPI.REPLACE ) self.win.Unlock(rank) - _, valid = MPI.pickle.loads(self.buff) + _, valid = self.MPI.pickle.loads(self.buff) return 1, valid == 1 class ExaMPIDistributedQueue(ExaData): @@ -451,13 +436,16 @@ class ExaMPIDistributedQueue(ExaData): Attributes ---------- + MPI : mpi4py.MPI + mpi4py's MPI access point + comm : mpi4py.MPI.Comm raw MPI communicator length : int capacity of the queue - failPush : bool + fail_push : bool flag setting if push can overwrite data buff : bytearray @@ -485,7 +473,7 @@ class ExaMPIDistributedQueue(ExaData): MPI window based on buffer for queue """ - def __init__(self, comm, data=None, rank_mask=None, length=32, max_model_lag=None, failPush=False, name=None): + def __init__(self, comm, data, size=None, length=32, fail_push=False, rank_mask=None, name=None): """ Parameters ---------- @@ -493,28 +481,19 @@ def __init__(self, comm, data=None, rank_mask=None, length=32, max_model_lag=Non Communicator for all ranks involved data : list, optional Example data used to create buffer - rank_mask : int, optional - host of the window + size : int, optional + Size of data. The size of an element of the buffer will be overridden by this value + if provided (instead of the size from pickling data). length : int, optional capacity of queue - max_model_lag : int, optional - Will not consider data past given model valide failPush : bool, optional Fail to overwrite data if queue is full + rank_mask : int, optional + host of the window name : string, optional - name of constant for debbuging + name of constant for debugging """ - - self.comm = comm - self.length = length - # This lets us fail a push when at full capacity - # Otherwise will overwrite the oldest data - self.failPush = failPush - - dataBytes = MPI.pickle.dumps(data) - size = len(dataBytes) - - super().__init__(bytes, size, comm_size=comm.size, max_model_lag=max_model_lag, name=name) + super().__init__(comm, length, fail_push, data=data, size=size, name=name) self.buff = bytearray(self.dataSize) self.plus = np.array([1], dtype=np.int64) self.minus = np.array([-1], dtype=np.int64) @@ -522,20 +501,20 @@ def __init__(self, comm, data=None, rank_mask=None, length=32, max_model_lag=Non totalSize = 0 self.headBuff = None self.tailBuff = None - disp = MPI.DOUBLE.Get_size() + disp = self.MPI.DOUBLE.Get_size() if rank_mask: - totalSize = size * self.length + totalSize = self.dataSize * self.length self.headBuff = np.zeros(1, dtype=np.int64) self.tailBuff = np.zeros(1, dtype=np.int64) # Setup head window - self.head = MPI.Win.Create(self.headBuff, disp, comm=self.comm.raw()) + self.head = self.MPI.Win.Create(self.headBuff, disp, comm=self.comm.raw()) # Setup tail window - self.tail = MPI.Win.Create(self.tailBuff, disp, comm=self.comm.raw()) + self.tail = self.MPI.Win.Create(self.tailBuff, disp, comm=self.comm.raw()) # Setup data window - self.win = MPI.Win.Allocate(totalSize, disp_unit=size, comm=self.comm.raw()) + self.win = self.MPI.Win.Allocate(totalSize, disp_unit=self.dataSize, comm=self.comm.raw()) def __del__(self): self.win.Free() @@ -567,8 +546,8 @@ def pop(self, rank, count=1): self.tail.Lock(rank) # Read the head and tail pointers. - reqHead = self.head.Rget_accumulate(self.minus, head, rank, op=MPI.NO_OP) - reqTail = self.tail.Rget_accumulate(self.plus, tail, rank, op=MPI.SUM) + reqHead = self.head.Rget_accumulate(self.minus, head, rank, op=self.MPI.NO_OP) + reqTail = self.tail.Rget_accumulate(self.plus, tail, rank, op=self.MPI.SUM) reqHead.wait() reqTail.wait() @@ -581,19 +560,19 @@ def pop(self, rank, count=1): self.buff, rank, target=[index, self.dataSize], - op=MPI.NO_OP, + op=self.MPI.NO_OP, ) self.win.Unlock(rank) else: # Dec the tail pointer - self.tail.Accumulate(self.minus, rank, op=MPI.SUM) + self.tail.Accumulate(self.minus, rank, op=self.MPI.SUM) ret = False self.tail.Unlock(rank) self.head.Unlock(rank) if ret: - return MPI.pickle.loads(self.buff) + return self.MPI.pickle.loads(self.buff) return None @introspectTrace(name=True) @@ -616,42 +595,44 @@ def push(self, data, rank=None): """ if rank is None: rank = self.comm.rank - toSend = MPI.pickle.dumps(data) - assert len(toSend) <= self.dataSize + toSend = self.MPI.pickle.dumps(data) + if len(toSend) > self.dataSize: + toSend = optimize(toSend) + toSend = bytearray(toSend) + assert len(toSend) <= self.dataSize, self.name + ": " + str(len(toSend)) + " vs " + str(self.dataSize) head = np.zeros(1, dtype=np.int64) tail = np.zeros(1, dtype=np.int64) - self.head.Lock(rank) self.tail.Lock(rank) - reqHead = self.head.Rget_accumulate(self.plus, head, rank, op=MPI.SUM) - reqTail = self.tail.Rget_accumulate(self.plus, tail, rank, op=MPI.NO_OP) + reqHead = self.head.Rget_accumulate(self.plus, head, rank, op=self.MPI.SUM) + reqTail = self.tail.Rget_accumulate(self.plus, tail, rank, op=self.MPI.NO_OP) reqHead.wait() reqTail.wait() - write = True headIndex = head[0] % self.length tailIndex = tail[0] % self.length + if head[0] > tail[0] and headIndex == tailIndex: - if self.failPush: + if self.fail_push: write = False self.head.Accumulate( - self.minus, rank, op=MPI.SUM + self.minus, rank, op=self.MPI.SUM ) else: self.tail.Accumulate( - self.plus, rank, op=MPI.SUM + self.plus, rank, op=self.MPI.SUM ) lost = 1 capacity = self.length else: lost = 0 - capacity = head[0] - tail[0] + capacity = head[0] - tail[0] + 1 if write: self.win.Lock(rank) self.win.Accumulate( - toSend, rank, target=[headIndex, len(toSend)], op=MPI.REPLACE + toSend, rank, target=[headIndex, len(toSend)], op=self.MPI.REPLACE ) self.win.Unlock(rank) @@ -667,6 +648,9 @@ class ExaMPIDistributedStack(ExaData): Attributes ---------- + MPI : mpi4py.MPI + mpi4py's MPI access point + comm : mpi4py.MPI.Comm raw MPI communicator @@ -701,7 +685,7 @@ class ExaMPIDistributedStack(ExaData): MPI window based on buffer for stack """ - def __init__(self, comm, data, rank_mask=None, length=32, max_model_lag=None, failPush=False, name=None): + def __init__(self, comm, data, size=None, length=32, fail_push=False, rank_mask=None, name=None): """ Parameters ---------- @@ -720,15 +704,7 @@ def __init__(self, comm, data, rank_mask=None, length=32, max_model_lag=None, fa name : string, optional name of constant for debbuging """ - self.comm = comm - self.length = length - # This lets us fail a push when at full capacity - # Otherwise will overwrite the oldest data - self.failPush = failPush - - dataBytes = MPI.pickle.dumps(data) - size = len(dataBytes) - super().__init__(bytes, size, comm_size=comm.size, max_model_lag=max_model_lag, name=name) + super().__init__(comm, length, fail_push, data=data, size=size, name=name) self.buff = bytearray(self.dataSize) self.plus = np.array([1], dtype=np.int64) @@ -737,20 +713,20 @@ def __init__(self, comm, data, rank_mask=None, length=32, max_model_lag=None, fa totalSize = 0 self.headBuff = None self.tailBuff = None - disp = MPI.DOUBLE.Get_size() + disp = self.MPI.DOUBLE.Get_size() if rank_mask: - totalSize = size * self.length + totalSize = self.dataSize * self.length self.headBuff = np.zeros(1, dtype=np.int64) self.tailBuff = np.zeros(1, dtype=np.int64) # Setup head window - self.head = MPI.Win.Create(self.headBuff, disp, comm=self.comm.raw()) + self.head = self.MPI.Win.Create(self.headBuff, disp, comm=self.comm.raw()) # Setup tail window - self.tail = MPI.Win.Create(self.tailBuff, disp, comm=self.comm.raw()) + self.tail = self.MPI.Win.Create(self.tailBuff, disp, comm=self.comm.raw()) # Setup data window - self.win = MPI.Win.Allocate(totalSize, disp_unit=size, comm=self.comm.raw()) + self.win = self.MPI.Win.Allocate(totalSize, disp_unit=self.dataSize, comm=self.comm.raw()) def __del__(self): self.win.Free() @@ -782,8 +758,8 @@ def pop(self, rank, count=1): self.tail.Lock(rank) # Read the head and tail pointers. - reqHead = self.head.Rget_accumulate(self.minus, head, rank, op=MPI.SUM) - reqTail = self.tail.Rget_accumulate(self.minus, tail, rank, op=MPI.NO_OP) + reqHead = self.head.Rget_accumulate(self.minus, head, rank, op=self.MPI.SUM) + reqTail = self.tail.Rget_accumulate(self.minus, tail, rank, op=self.MPI.NO_OP) reqHead.wait() reqTail.wait() # print("InPop", head[0], tail[0]) @@ -797,20 +773,20 @@ def pop(self, rank, count=1): self.buff, rank, target=[index, self.dataSize], - op=MPI.NO_OP, + op=self.MPI.NO_OP, ) self.win.Unlock(rank) else: self.head.Accumulate( - self.plus, rank, op=MPI.SUM + self.plus, rank, op=self.MPI.SUM ) self.tail.Unlock(rank) self.head.Unlock(rank) if ret: - return MPI.pickle.loads(self.buff) + return self.MPI.pickle.loads(self.buff) return None @introspectTrace(name=True) @@ -833,8 +809,11 @@ def push(self, data, rank=None): """ if rank is None: rank = self.comm.rank - toSend = MPI.pickle.dumps(data) - assert len(toSend) == self.dataSize + toSend = self.MPI.pickle.dumps(data) + if len(toSend) > self.dataSize: + toSend = optimize(toSend) + toSend = bytearray(toSend) + assert len(toSend) <= self.dataSize, self.name + ": " + str(len(toSend)) + " vs " + str(self.dataSize) head = np.zeros(1, dtype=np.int64) tail = np.zeros(1, dtype=np.int64) @@ -844,22 +823,22 @@ def push(self, data, rank=None): self.tail.Lock(rank) # Read the head and tail pointers. - reqHead = self.head.Rget_accumulate(self.plus, head, rank, op=MPI.SUM) - reqTail = self.tail.Rget_accumulate(self.plus, tail, rank, op=MPI.NO_OP) + reqHead = self.head.Rget_accumulate(self.plus, head, rank, op=self.MPI.SUM) + reqTail = self.tail.Rget_accumulate(self.plus, tail, rank, op=self.MPI.NO_OP) reqHead.wait() reqTail.wait() # This is if we are going to loose data because we exceded capacity write = True if tail[0] + self.length == head[0]: - if self.failPush: + if self.fail_push: write = False self.head.Accumulate( - self.minus, rank, op=MPI.SUM + self.minus, rank, op=self.MPI.SUM ) else: self.tail.Accumulate( - self.plus, rank, op=MPI.SUM + self.plus, rank, op=self.MPI.SUM ) lost = 1 capacity = self.length @@ -872,493 +851,10 @@ def push(self, data, rank=None): index = head[0] % self.length self.win.Lock(rank) self.win.Accumulate( - toSend, rank, target=[index, self.dataSize], op=MPI.REPLACE + toSend, rank, target=[index, self.dataSize], op=self.MPI.REPLACE ) self.win.Unlock(rank) self.tail.Unlock(rank) self.head.Unlock(rank) return capacity, lost - -class ExaMPICentralizedStack(ExaData): - """ - This class creates a stack in RMA windows across nodes in a communicator. - There is a stack per rank. Each rank acts as a host. - - Attributes - ---------- - comm : mpi4py.MPI.Comm - raw MPI communicator - - length : int - capacity of the stack - - failPush : bool - flag setting if push can overwrite data - - buff : bytearray - internal buffer for stack used for RMA ops - - plus : np.array - numpy constant for adding - - minus : np.array - numpy constant for subtracting - - headBuffer : np.array - buffer containing head counter - - tailBuffer : np.array - buffer containing tail counter - - head : MPI.win - window based on headBuffer - - tail : MPI.win - window based on tailBuffer - - win : MPI.win - MPI window based on buffer for stack - - """ - def __init__(self, comm, data, rank_mask=None, length=32, max_model_lag=None, failPush=False, name=None): - """ - Parameters - ---------- - comm : mpi4py.MPI.Comm - Communicator for all ranks involved - data : list - Example data used to create buffer - rank_mask : int, optional - host of the window - length : int, optional - capacity of stack - max_model_lag : int, optional - Will not consider data past given model valide - failPush : bool, optional - Fail to overwrite data if queue is full - name : string, optional - name of constant for debbuging - """ - self.comm = comm - if rank_mask: - self.rank = self.comm.rank - self.length = length - # This lets us fail a push when at full capacity - # Otherwise will overwrite the oldest data - self.failPush = failPush - - dataBytes = MPI.pickle.dumps(data) - size = len(dataBytes) - super().__init__(bytes, size, comm_size=comm.size, max_model_lag=max_model_lag, name=name) - - self.buff = bytearray(self.dataSize) - self.plus = np.array([1], dtype=np.int64) - self.minus = np.array([-1], dtype=np.int64) - - totalSize = 0 - headSize = 0 - tailSize = 0 - - # if comm.rank == rank: - if rank_mask: - totalSize = size * self.length - headSize = MPI.INT64_T.Get_size() - tailSize = MPI.INT64_T.Get_size() - - self.head = [] - self.tail = [] - self.win = [] - for i in range(comm.size): - # Setup head window - self.head.append(MPI.Win.Allocate(headSize, comm=self.comm.raw())) - self.head[i].Lock(self.rank) - self.head[i].Accumulate( - np.zeros(1, dtype=np.int64), self.rank, op=MPI.REPLACE - ) - self.head[i].Unlock(self.rank) - self.head[i].Fence(self.rank) - - # Setup tail window - self.tail.append(MPI.Win.Allocate(tailSize, comm=self.comm.raw())) - self.tail[i].Lock(self.rank) - self.tail[i].Accumulate( - np.zeros(1, dtype=np.int64), self.rank, op=MPI.REPLACE - ) - self.tail[i].Unlock(self.rank) - self.tail[i].Fence(self.rank) - - # Setup data window - self.win.append( - MPI.Win.Allocate(totalSize, disp_unit=size, comm=self.comm.raw()) - ) - self.win[i].Fence(self.rank) - - def __del__(self): - for i in range(self.comm.size): - self.win[i].Free() - self.head[i].Free() - - @introspectTrace(name=True) - def pop(self, rank, count=1): - """ - Returns data from head of stack if there is data. - - Parameters - ---------- - rank : integer - Host rank where to take data from - - count : integer - How many pops to perform - - Returns - ------- - list - Data from stack if there is any. - """ - ret = False - head = np.zeros(1, dtype=np.int64) - tail = np.zeros(1, dtype=np.int64) - rank = int(rank) - - self.head[rank].Lock(self.rank) - self.tail[rank].Lock(self.rank) - - # Read the head and tail pointers. - reqHead = self.head[rank].Rget_accumulate(self.minus, head, self.rank, op=MPI.SUM) - reqTail = self.tail[rank].Rget_accumulate(self.minus, tail, self.rank, op=MPI.NO_OP) - reqHead.wait() - reqTail.wait() - # print("InPop", head[0], tail[0]) - if head[0] > tail[0]: - ret = True - index = (head[0] - 1) % self.length - - self.win[rank].Lock(self.rank) - self.win[rank].Get_accumulate( - self.buff, - self.buff, - self.rank, - target=[index, self.dataSize], - op=MPI.NO_OP, - ) - self.win[rank].Unlock(self.rank) - - else: - self.head[rank].Accumulate( - self.plus, self.rank, op=MPI.SUM - ) - - self.tail[rank].Unlock(self.rank) - self.head[rank].Unlock(self.rank) - - if ret: - return MPI.pickle.loads(self.buff) - return None - - @introspectTrace(name=True) - def push(self, data, rank=None): - """ - Pushes data to a rank's stack. - - Parameters - ---------- - data : list - Data to be pushed to rank's stack - - rank : integer, optional - Rank to push data to - - Returns - ------- - list - Returns a capacity of stack and loss if data is overwritten - """ - if rank is None: - rank = self.comm.rank - toSend = MPI.pickle.dumps(data) - assert len(toSend) == self.dataSize - - head = np.zeros(1, dtype=np.int64) - tail = np.zeros(1, dtype=np.int64) - rank = int(rank) - - self.head[rank].Lock(self.rank) - self.tail[rank].Lock(self.rank) - - # Read the head and tail pointers. - reqHead = self.head[rank].Rget_accumulate(self.plus, head, self.rank, op=MPI.SUM) - reqTail = self.tail[rank].Rget_accumulate(self.plus, tail, self.rank, op=MPI.NO_OP) - reqHead.wait() - reqTail.wait() - - # This is if we are going to loose data because we exceded capacity - write = True - if tail[0] + self.length == head[0]: - if self.failPush: - write = False - self.head[rank].Accumulate( - self.minus, self.rank, op=MPI.SUM - ) - else: - self.tail[rank].Accumulate( - self.plus, self.rank, op=MPI.SUM - ) - lost = 1 - capacity = self.length - else: - lost = 0 - capacity = head[0] - tail[0] + 1 - - if write: - # Actual write data - index = head[0] % self.length - self.win[rank].Lock(self.rank) - self.win[rank].Accumulate( - toSend, self.rank, target=[index, self.dataSize], op=MPI.REPLACE - ) - self.win[rank].Unlock(self.rank) - - self.tail[rank].Unlock(self.rank) - self.head[rank].Unlock(self.rank) - return capacity, lost - -class ExaMPICentralizedQueue(ExaData): - """ - This class creates circular buffers in RMA windows across nodes in a communicator. - There is a queue per rank. Each rank acts as a host. - - Attributes - ---------- - comm : mpi4py.MPI.Comm - raw MPI communicator - - length : int - capacity of the queue - - failPush : bool - flag setting if push can overwrite data - - buff : bytearray - internal buffer for queue used for RMA ops - - plus : np.array - numpy constant for adding - - minus : np.array - numpy constant for subtracting - - headBuffer : np.array - buffer containing head counter - - tailBuffer : np.array - buffer containing tail counter - - head : MPI.win - window based on headBuffer - - tail : MPI.win - window based on tailBuffer - - win : MPI.win - MPI window based on buffer for queue - - """ - def __init__(self, comm, data, rank_mask=None, length=32, max_model_lag=None, failPush=False, name=None): - """ - Parameters - ---------- - comm : mpi4py.MPI.Comm - Communicator for all ranks involved - data : list - Example data used to create buffer - rank_mask : int, optional - host of the window - length : int, optional - capacity of queue - max_model_lag : int, optional - Will not consider data past given model valide - failPush : bool, optional - Fail to overwrite data if queue is full - name : string, optional - name of constant for debbuging - """ - self.comm = comm - if rank_mask: - self.rank = self.comm.rank - self.length = length - # This lets us fail a push when at full capacity - # Otherwise will overwrite the oldest data - self.failPush = failPush - - dataBytes = MPI.pickle.dumps(data) - size = len(dataBytes) - super().__init__(bytes, size, comm_size=comm.size, max_model_lag=max_model_lag, name=name) - - self.buff = bytearray(self.dataSize) - self.plus = np.array([1], dtype=np.int64) - self.minus = np.array([-1], dtype=np.int64) - - totalSize = 0 - headSize = 0 - tailSize = 0 - # if comm.rank == rank: - if rank_mask: - totalSize = size * self.length - headSize = MPI.INT64_T.Get_size() - tailSize = MPI.INT64_T.Get_size() - - self.head = [] - self.tail = [] - self.win = [] - for i in range(comm.size): - # Setup head window - self.head.append(MPI.Win.Allocate(headSize, comm=self.comm.raw())) - self.head[i].Lock(self.rank) - self.head[i].Accumulate( - np.zeros(1, dtype=np.int64), self.rank, op=MPI.REPLACE - ) - self.head[i].Unlock(self.rank) - self.head[i].Fence(self.rank) - - # Setup tail window - self.tail.append(MPI.Win.Allocate(tailSize, comm=self.comm.raw())) - self.tail[i].Lock(self.rank) - self.tail[i].Accumulate( - np.zeros(1, dtype=np.int64), self.rank, op=MPI.REPLACE - ) - self.tail[i].Unlock(self.rank) - self.tail[i].Fence(self.rank) - - # Setup data window - self.win.append( - MPI.Win.Allocate(totalSize, disp_unit=size, comm=self.comm.raw()) - ) - self.win[i].Fence(self.rank) - - def __del__(self): - for i in range(self.comm.size): - self.win[i].Free() - self.head[i].Free() - - @introspectTrace(name=True) - def pop(self, rank, count=1): - """ - Returns data from head of queue if there is data. - - Parameters - ---------- - rank : integer - Host rank where to take data from - - count : integer, optional - How many pops to perform - - Returns - ------- - list - Data from queue if there is any. - """ - ret = True - head = np.zeros(1, dtype=np.int64) - tail = np.zeros(1, dtype=np.int64) - rank = int(rank) - - self.head[rank].Lock(self.rank) - self.tail[rank].Lock(self.rank) - - # Read the head and tail pointers. - reqHead = self.head[rank].Rget_accumulate(self.minus, head, self.rank, op=MPI.NO_OP) - reqTail = self.tail[rank].Rget_accumulate(self.plus, tail, self.rank, op=MPI.SUM) - reqHead.wait() - reqTail.wait() - - # Is there space - if head[0] > tail[0]: - index = tail[0] % self.length - self.win[rank].Lock(self.rank) - self.win[rank].Get_accumulate( - self.buff, - self.buff, - self.rank, - target=[index, self.dataSize], - op=MPI.NO_OP, - ) - self.win[rank].Unlock(self.rank) - else: - # Dec the tail pointer - self.tail[rank].Accumulate(self.minus, self.rank, op=MPI.SUM) - ret = False - - self.tail[rank].Unlock(self.rank) - self.head[rank].Unlock(self.rank) - - if ret: - return MPI.pickle.loads(self.buff) - return None - - @introspectTrace(name=True) - def push(self, data, rank=None): - """ - Pushes data to a rank's queue. - - Parameters - ---------- - data : list - Data to be pushed to rank's queue - - rank : integer, optional - Rank to push data to - - Returns - ------- - list - Returns a capacity of queue and loss if data is overwritten - """ - if rank is None: - rank = self.comm.rank - toSend = MPI.pickle.dumps(data) - assert len(toSend) <= self.dataSize - - head = np.zeros(1, dtype=np.int64) - tail = np.zeros(1, dtype=np.int64) - - self.head[rank].Lock(self.rank) - self.tail[rank].Lock(self.rank) - - reqHead = self.head[rank].Rget_accumulate(self.plus, head, self.rank, op=MPI.SUM) - reqTail = self.tail[rank].Rget_accumulate(self.plus, tail, self.rank, op=MPI.NO_OP) - reqHead.wait() - reqTail.wait() - - write = True - headIndex = head[0] % self.length - tailIndex = tail[0] % self.length - if head[0] > tail[0] and headIndex == tailIndex: - if self.failPush: - write = False - self.head[rank].Accumulate( - self.minus, self.rank, op=MPI.SUM - ) - else: - self.tail[rank].Accumulate( - self.plus, self.rank, op=MPI.SUM - ) - lost = 1 - capacity = self.length - else: - lost = 0 - capacity = head[0] - tail[0] - - if write: - self.win[rank].Lock(self.rank) - self.win[rank].Accumulate( - toSend, self.rank, target=[headIndex, len(toSend)], op=MPI.REPLACE - ) - self.win[rank].Unlock(self.rank) - - self.tail[rank].Unlock(self.rank) - self.head[rank].Unlock(self.rank) - - return capacity, lost diff --git a/exarl/network/mpi_comm.py b/exarl/network/mpi_comm.py index b2bd224a..a5e73968 100644 --- a/exarl/network/mpi_comm.py +++ b/exarl/network/mpi_comm.py @@ -1,14 +1,11 @@ -from exarl.utils.introspect import introspectTrace -from exarl.base.comm_base import ExaComm +import sys +from importlib import reload import gc import numpy as np - -import mpi4py.rc - -mpi4py.rc.threads = False -mpi4py.rc.recv_mprobe = False -from mpi4py import MPI - +from exarl.utils.globals import ExaGlobals +from exarl.base.comm_base import ExaComm +from exarl.utils.introspect import introspectTrace +import mpi4py class ExaMPI(ExaComm): """ @@ -34,12 +31,13 @@ class ExaMPI(ExaComm): Flag indicating to use run length encoding buffers : map - These are preallocated buffers for sending and recieving to avoid memory thrashing + These are preallocated buffers for sending and receiving to avoid memory thrashing """ - mpi = MPI - def __init__(self, comm=MPI.COMM_WORLD, procs_per_env=1, run_length=False): + MPI = None + + def __init__(self, comm, procs_per_env, num_learners, run_length=False): """ Parameters ---------- @@ -52,14 +50,29 @@ def __init__(self, comm=MPI.COMM_WORLD, procs_per_env=1, run_length=False): Number of learners (multi-learner) """ + # Singleton + if ExaMPI.MPI is None: + mpi4py_rc = True if ExaGlobals.lookup_params('mpi4py_rc') in ["true", "True", 1] else False + if not mpi4py_rc: + print("Turning mpi4py.rc.threads and mpi4py.rc.recv_mprobe to false!", flush=True) + mpi4py.rc.threads = False + mpi4py.rc.recv_mprobe = False + # This statement actually starts MPI assuming this is the first call + from mpi4py import MPI + ExaMPI.MPI = MPI + if comm is None: - comm = MPI.COMM_WORLD - self.comm = comm - self.size = comm.Get_size() - self.rank = comm.Get_rank() + self.comm = ExaMPI.MPI.COMM_WORLD + self.size = ExaMPI.MPI.COMM_WORLD.Get_size() + self.rank = ExaMPI.MPI.COMM_WORLD.Get_rank() + else: + self.comm = comm + self.size = comm.size + self.rank = comm.rank + self.run_length = run_length self.buffers = {} - super().__init__(self, procs_per_env) + super().__init__(self, procs_per_env, num_learners) def np_type_converter(self, the_type): """ @@ -70,13 +83,13 @@ def np_type_converter(self, the_type): the_type : type Type to convert """ - if the_type == float or the_type == np.float64 or the_type == MPI.DOUBLE: + if the_type == float or the_type == np.float64 or the_type == ExaMPI.MPI.DOUBLE: return np.float64 - if the_type == np.float32 or the_type == MPI.FLOAT: + if the_type == np.float32 or the_type == ExaMPI.MPI.FLOAT: return np.float32 - if the_type == int or the_type == np.int64 or the_type == MPI.INT64_T: + if the_type == int or the_type == np.int64 or the_type == ExaMPI.MPI.INT64_T: return np.int64 - if the_type == np.int32 or the_type == MPI.INT: + if the_type == np.int32 or the_type == ExaMPI.MPI.INT: return np.int32 print("Failed to convert type", the_type) return the_type @@ -91,13 +104,13 @@ def mpi_type_converter(self, the_type): Type to convert """ if the_type == np.int32: - return MPI.INT + return ExaMPI.MPI.INT if the_type == np.int64: - return MPI.INT64_T + return ExaMPI.MPI.INT64_T if the_type == np.float32: - return MPI.FLOAT + return ExaMPI.MPI.FLOAT if the_type == np.float64: - return MPI.DOUBLE + return ExaMPI.MPI.DOUBLE return the_type def encode_type(self, the_type): @@ -222,7 +235,7 @@ def get_flat_size(self, data): return sum([self.get_flat_size(x) for x in data]) # We use this to encode the np.array shapes - # We are guarenteing this is an array + # We are guaranteeing this is an array @introspectTrace() def encode_int_list(self, data, buff=None, level=0): """ @@ -440,7 +453,7 @@ def decode_list_format( def run_length_encode(self, data): """ This implements runlength encoding of ints. - Runlegth encoding takes duplicate values and + Runlength encoding takes duplicate values and reduces it to two, the number and the number of repeating values. @@ -476,7 +489,7 @@ def run_length_encode(self, data): def run_length_decode(self, data): """ This implements runlength encoding of ints. - Runlegth encoding takes duplicate values and + Runlength encoding takes duplicate values and reduces it to two, the number and the number of repeating values. This only supports ints so the data must be cast if coming from float buffer @@ -585,7 +598,7 @@ def marshall(self, data, buff, data_type, data_count=None, index=0, first=True): def demarshall(self, data, buff, data_count=None, index=0, first=True): """ This demarshalls the data from a marshall call. - This should be called immediatly after a receive. + This should be called immediately after a receive. The type is maintained by the data object. Be careful to make sure that the types are the same across send/recv. If not the underlying buffer type could mismatch and mashalling will fail. @@ -641,7 +654,7 @@ def prep_data(self, data, copy=True, default_buffer_type=np.int64): data to prep copy : bool, optional - Inidicate if we should marshall data + Indicate if we should marshall data default_buffer_type : type, optional Buffer type @@ -666,14 +679,14 @@ def prep_data(self, data, copy=True, default_buffer_type=np.int64): # This will send messages if we do not know what "types" are in the message # First it will find the data format and send it along with the size/buffer type of the data - # Next we send the actuall data + # Next we send the actual data # Can use compression to decrease message size @introspectTrace() def send_with_type(self, data, dest, default_buffer_type=np.int64): """ This will send messages if we do not know what "types" are in the message. First it will find the data format and send it along with the size/buffer type of the data. - Next we send the actuall data. + Next we send the actual data. Can use compression to decrease message size. Parameters @@ -714,7 +727,7 @@ def send_with_type(self, data, dest, default_buffer_type=np.int64): ], dtype=np.int32, ) - self.comm.Send([first, 5, MPI.INT], dest=dest) + self.comm.Send([first, 5, ExaMPI.MPI.INT], dest=dest) # Send second message with real data return self.comm.Send(second, dest=dest) @@ -743,7 +756,7 @@ def send(self, data, dest, pack=False, default_buffer_type=np.int64): @introspectTrace() def recv_with_type(self, source, default_buffer_type=np.int64): """ - The receives messagse when we don't know the type ahead of time. + The receives messages when we don't know the type ahead of time. This follows the procedures outline in send_with_type. Parameters @@ -756,7 +769,7 @@ def recv_with_type(self, source, default_buffer_type=np.int64): """ # Recv the message sizes/buffer type buff = np.array([0, 0, 0, 0, 0], dtype=np.int32) - first = [buff, 5, MPI.INT] + first = [buff, 5, ExaMPI.MPI.INT] self.comm.Recv(first, source=source) # Unpack data properties @@ -782,11 +795,11 @@ def recv_with_type(self, source, default_buffer_type=np.int64): np_arrays = self.decode_int_list(buff_np_arrays) # Expand the data format with np.arrays data_shape = self.decode_list_format(buff_shape, np_arrays=np_arrays) - # Extract the actuall data + # Extract the actual data return self.demarshall(data_shape, buff_data, data_count=data_count) @introspectTrace() - def recv(self, data, source=MPI.ANY_SOURCE, default_buffer_type=np.int64): + def recv(self, data, source=None, default_buffer_type=np.int64): """ Point-to-point communication between ranks. Send must have matching send. @@ -798,10 +811,12 @@ def recv(self, data, source=MPI.ANY_SOURCE, default_buffer_type=np.int64): dest : int Rank within comm where data will be sent. Must have matching recv. source : int, optional - Rank to recieve data from. Default allows data from any source. + Rank to receive data from. Default allows data from any source. default_buffer_type: type, optional Buffer type """ + if source is None: + source = ExaMPI.MPI.ANY_SOURCE # This is if we do not know the type on both sides of the send/recv if data is None: return self.recv_with_type(source) @@ -861,12 +876,14 @@ def reduce(self, arg, op, root): recv_buff = np.array(arg, dtype=np_type) toSend = [send_buff, 1, mpi_type] toRecv = [recv_buff, 1, mpi_type] - converter = {sum: MPI.SUM, max: MPI.MAX, min: MPI.MIN} + converter = {sum: ExaMPI.MPI.SUM, + max: ExaMPI.MPI.MAX, + min: ExaMPI.MPI.MIN} self.comm.Reduce(toSend, toRecv, op=converter[op], root=root) return ret_type(toRecv[0]) # TODO: This is only supporting single values - def allreduce(self, arg, op=MPI.LAND): + def allreduce(self, arg, op=None): """ Data is joined from all processes in comm by doing op. Data is put on all processes in comm. @@ -878,6 +895,8 @@ def allreduce(self, arg, op=MPI.LAND): op : MPI op, optional Operation to perform """ + if op is None: + ExaMPI.MPI.LAND ret_type = type(arg) np_type = self.np_type_converter(ret_type) mpi_type = self.mpi_type_converter(np_type) @@ -885,17 +904,19 @@ def allreduce(self, arg, op=MPI.LAND): recv_buff = np.array(arg, dtype=np_type) toSend = [send_buff, 1, mpi_type] toRecv = [recv_buff, 1, mpi_type] - converter = {sum: MPI.SUM, max: MPI.MAX, min: MPI.MIN} - self.comm.Allreduce(toSend, toRecv, op=converter[op], root=root) + converter = {sum: ExaMPI.MPI.SUM, + max: ExaMPI.MPI.MAX, + min: ExaMPI.MPI.MIN} + self.comm.Allreduce(toSend, toRecv, op=converter[op]) return ret_type(toRecv[0]) def time(self): """ Returns MPI wall clock time """ - return MPI.Wtime() + return ExaMPI.MPI.Wtime() - def split(self, procs_per_env): + def split(self, procs_per_env, num_learners): """ This splits the comm into agent, environment, and learner comms. Returns three simple sub-comms @@ -907,32 +928,54 @@ def split(self, procs_per_env): num_learners : int Number of processes per learner comm """ - # Agent communicator - agent_color = MPI.UNDEFINED - if (self.rank < num_learners) or ((self.rank + procs_per_env - 1) % procs_per_env == 0): - agent_color = 0 - agent_comm = self.comm.Split(agent_color, self.rank) - if agent_color == 0: - agent_comm = ExaSimple(comm=agent_comm) - else: - agent_comm = None + if ExaMPI.MPI.COMM_WORLD.Get_size() == procs_per_env: + assert num_learners == 1, "num_learners should be 1 when global comm size == procs_per_env" + color = ExaMPI.MPI.UNDEFINED + if self.rank == 0: + color = 0 + learner_comm = self.comm.Split(color, self.rank) + agent_comm = self.comm.Split(color, self.rank) + if self.rank == 0: + learner_comm = ExaMPI(learner_comm, procs_per_env, num_learners) + agent_comm = ExaMPI(agent_comm, procs_per_env, num_learners) + else: + learner_comm = None + agent_comm = None - # Environment communicator - if self.rank < num_learners: env_color = 0 + env_comm = self.comm.Split(env_color, self.rank) + env_comm = ExaMPI(env_comm, procs_per_env, num_learners) else: - env_color = (int((self.rank - num_learners) / procs_per_env)) + 1 - env_comm = ExaSimple(comm=self.comm.Split(env_color, self.rank)) - - # Learner communicator - learner_color = MPI.UNDEFINED - if self.rank < num_learners: - learner_color = 0 - learner_comm = self.comm.Split(learner_color, self.rank) - if learner_color == 0: - learner_comm = ExaSimple(comm=learner_comm) - else: - learner_comm = None + # Agent communicator + agent_color = ExaMPI.MPI.UNDEFINED + if (self.rank < num_learners) or ((self.rank - num_learners) % procs_per_env == 0): + agent_color = 0 + agent_comm = self.comm.Split(agent_color, self.rank) + if agent_color == 0: + agent_comm = ExaMPI(agent_comm, procs_per_env, num_learners) + else: + agent_comm = None + + # Environment communicator + if self.rank < num_learners: + env_color = 0 + else: + env_color = (int((self.rank - num_learners) / procs_per_env)) + 1 + env_comm = self.comm.Split(env_color, self.rank) + if env_color > 0: + env_comm = ExaMPI(env_comm, procs_per_env, num_learners) + else: + env_comm = None + + # Learner communicator + learner_color = ExaMPI.MPI.UNDEFINED + if self.rank < num_learners: + learner_color = 0 + learner_comm = self.comm.Split(learner_color, self.rank) + if learner_color == 0: + learner_comm = ExaMPI(learner_comm, procs_per_env, num_learners) + else: + learner_comm = None return agent_comm, env_comm, learner_comm @@ -947,6 +990,6 @@ def printBufSize(self): Prints size of internal buffers. """ print("Printing buffers") - for i in buffers: - for j in buffers[i]: + for i in self.buffers: + for j in self.buffers[i]: print(self.rank, "BUFFER:", i, j) diff --git a/exarl/network/simple_comm.py b/exarl/network/simple_comm.py index c32513f4..47b395da 100644 --- a/exarl/network/simple_comm.py +++ b/exarl/network/simple_comm.py @@ -1,23 +1,14 @@ -from exarl.utils.introspect import ib -from exarl.utils.introspect import introspectTrace +import sys +from exarl.utils.globals import ExaGlobals from exarl.base.comm_base import ExaComm -import os -import numpy as np - -import exarl.utils.candleDriver as cd -workflow = cd.lookup_params('workflow') -if workflow == 'async': - print("Turning mpi4py.rc.threads and mpi4py.rc.recv_mprobe to false!") - import mpi4py.rc - mpi4py.rc.threads = False - mpi4py.rc.recv_mprobe = False -from mpi4py import MPI +from exarl.utils.introspect import introspectTrace +import mpi4py class ExaSimple(ExaComm): """ This class is built as a simple wrapper around mpi4py. Instances are a type of ExaComm which is used to send, - recieve, and synchronize data across the participating + receive, and synchronize data across the participating ranks. Attributes @@ -36,9 +27,9 @@ class ExaSimple(ExaComm): """ - MPI = MPI + MPI = None - def __init__(self, comm=MPI.COMM_WORLD, procs_per_env=1, num_learners=1): + def __init__(self, comm, procs_per_env, num_learners): """ Parameters ---------- @@ -51,18 +42,26 @@ def __init__(self, comm=MPI.COMM_WORLD, procs_per_env=1, num_learners=1): Number of learners (multi-learner) """ + # Singleton + if ExaSimple.MPI is None: + mpi4py_rc = True if ExaGlobals.lookup_params('mpi4py_rc') in ["true", "True", 1] else False + if not mpi4py_rc: + print("Turning mpi4py.rc.threads and mpi4py.rc.recv_mprobe to false!", flush=True) + mpi4py.rc.threads = False + mpi4py.rc.recv_mprobe = False + # This statement actually starts MPI assuming this is the first call + from mpi4py import MPI + ExaSimple.MPI = MPI + if comm is None: - self.comm = MPI.COMM_WORLD - self.size = MPI.COMM_WORLD.Get_size() - self.rank = MPI.COMM_WORLD.Get_rank() + self.comm = ExaSimple.MPI.COMM_WORLD + self.size = ExaSimple.MPI.COMM_WORLD.Get_size() + self.rank = ExaSimple.MPI.COMM_WORLD.Get_rank() else: self.comm = comm self.size = comm.size self.rank = comm.rank - # if self.rank > 0: - # os.environ["CUDA_VISIBLE_DEVICES"] = "-1" - self.buffers = {} super().__init__(self, procs_per_env, num_learners) @introspectTrace() @@ -83,7 +82,7 @@ def send(self, data, dest, pack=False): return self.comm.send(data, dest=dest) @introspectTrace() - def recv(self, data, source=MPI.ANY_SOURCE): + def recv(self, data, source=None): """ Point-to-point communication between ranks. Send must have matching send. @@ -91,12 +90,12 @@ def recv(self, data, source=MPI.ANY_SOURCE): Parameters ---------- data : any - Not used - dest : int - Rank within comm where data will be sent. Must have matching recv. + Not use source : int, optional - Rank to recieve data from. Default allows data from any source. + Rank to receive data from. Default allows data from any source. """ + if source is None: + source = ExaSimple.MPI.ANY_SOURCE return self.comm.recv(source=source) @introspectTrace() @@ -133,10 +132,12 @@ def reduce(self, arg, op, root): root : int Rank the result will end on """ - converter = {sum: MPI.SUM, max: MPI.MAX, min: MPI.MIN} + converter = {sum: ExaSimple.MPI.SUM, + max: ExaSimple.MPI.MAX, + min: ExaSimple.MPI.MIN} return self.comm.reduce(arg, op=converter[op], root=root) - def allreduce(self, arg, op=MPI.LAND): + def allreduce(self, arg, op=None): """ Data is joined from all processes in comm by doing op. Data is put on all processes in comm. @@ -148,13 +149,20 @@ def allreduce(self, arg, op=MPI.LAND): op : MPI op, optional Operation to perform """ + converter = {sum: ExaSimple.MPI.SUM, + max: ExaSimple.MPI.MAX, + min: ExaSimple.MPI.MIN} + if op is None: + op = ExaSimple.MPI.LAND + elif op in converter: + op = converter[sum] return self.comm.allreduce(arg, op) def time(self): """ Returns MPI wall clock time """ - return MPI.Wtime() + return ExaSimple.MPI.Wtime() def split(self, procs_per_env, num_learners): """ @@ -168,32 +176,55 @@ def split(self, procs_per_env, num_learners): num_learners : int Number of processes per learner comm """ - # Agent communicator - agent_color = MPI.UNDEFINED - if (self.rank < num_learners) or ((self.rank + procs_per_env - 1) % procs_per_env == 0): - agent_color = 0 - agent_comm = self.comm.Split(agent_color, self.rank) - if agent_color == 0: - agent_comm = ExaSimple(comm=agent_comm) - else: - agent_comm = None - # Environment communicator - if self.rank < num_learners: + if ExaSimple.MPI.COMM_WORLD.Get_size() == procs_per_env: + assert num_learners == 1, "num_learners should be 1 when global comm size == procs_per_env" + color = ExaSimple.MPI.UNDEFINED + if self.rank == 0: + color = 0 + learner_comm = self.comm.Split(color, self.rank) + agent_comm = self.comm.Split(color, self.rank) + if self.rank == 0: + learner_comm = ExaSimple(learner_comm, procs_per_env, num_learners) + agent_comm = ExaSimple(agent_comm, procs_per_env, num_learners) + else: + learner_comm = None + agent_comm = None + env_color = 0 + env_comm = self.comm.Split(env_color, self.rank) + env_comm = ExaSimple(env_comm, procs_per_env, num_learners) else: - env_color = (int((self.rank - num_learners) / procs_per_env)) + 1 - env_comm = ExaSimple(comm=self.comm.Split(env_color, self.rank)) - - # Learner communicator - learner_color = MPI.UNDEFINED - if self.rank < num_learners: - learner_color = 0 - learner_comm = self.comm.Split(learner_color, self.rank) - if learner_color == 0: - learner_comm = ExaSimple(comm=learner_comm) - else: - learner_comm = None + # Agent communicator + agent_color = ExaSimple.MPI.UNDEFINED + if (self.rank < num_learners) or ((self.rank - num_learners) % procs_per_env == 0): + agent_color = 0 + agent_comm = self.comm.Split(agent_color, self.rank) + if agent_color == 0: + agent_comm = ExaSimple(agent_comm, procs_per_env, num_learners) + else: + agent_comm = None + + # Environment communicator + if self.rank < num_learners: + env_color = 0 + else: + env_color = (int((self.rank - num_learners) / procs_per_env)) + 1 + env_comm = self.comm.Split(env_color, self.rank) + if env_color > 0: + env_comm = ExaSimple(env_comm, procs_per_env, num_learners) + else: + env_comm = None + + # Learner communicator + learner_color = ExaSimple.MPI.UNDEFINED + if self.rank < num_learners: + learner_color = 0 + learner_comm = self.comm.Split(learner_color, self.rank) + if learner_color == 0: + learner_comm = ExaSimple(learner_comm, procs_per_env, num_learners) + else: + learner_comm = None return agent_comm, env_comm, learner_comm diff --git a/exarl/network/typing.py b/exarl/network/typing.py index 9e5594be..25878feb 100644 --- a/exarl/network/typing.py +++ b/exarl/network/typing.py @@ -2,9 +2,7 @@ import os import functools import numpy as np -import tensorflow as tf -from exarl.network.simple_comm import ExaSimple -MPI = ExaSimple.MPI +from exarl.base.comm_base import ExaComm class TypeUtils: """ @@ -12,6 +10,9 @@ class TypeUtils: as well as providing type conversions between numpy, mpi, and python types. """ + def tf_to_np(the_type): + return the_type + def list_like(data): """ Updates tracing metrics for the given name. @@ -136,7 +137,7 @@ def get_dumps(data): """ list_flag, _ = TypeUtils.list_like(data) if not list_flag: - return len(MPI.pickle.dumps(data)) + return len(ExaComm.get_MPI().pickle.dumps(data)) return [TypeUtils.get_dumps(x) for x in data] def check_diff(data1, data2): @@ -211,8 +212,8 @@ def compare(data1, data2): print("Data 2:", data2_shape) return False - data1_dump_len = len(MPI.pickle.dumps(data1)) - data2_dump_len = len(MPI.pickle.dumps(data2)) + data1_dump_len = len(ExaComm.get_MPI().pickle.dumps(data1)) + data2_dump_len = len(ExaComm.get_MPI().pickle.dumps(data2)) if data1_dump_len != data2_dump_len: print("Dump Error", data1_dump_len, data2_dump_len) data1_dumps = TypeUtils.get_dumps(data1) @@ -223,6 +224,58 @@ def compare(data1, data2): return False return True + def promote_numpy_type(data, makeList=True): + """ + Turns non-list-like data to a numpy array. Promotes numpy lists from 32 to 64 bit. + + Parameters + ---------- + data : single value or np.array + Data to promote + + makeList : bool, optional + Indicates if data should be converted to np.array if not already np.array + + Returns + ------- + np.array + return promoted data + """ + list_flag, the_type = TypeUtils.list_like(data) + if not list_flag and makeList: + return np.array([data], dtype=TypeUtils.np_type_converter(the_type)) + + if isinstance(data, np.ndarray): + if data.dtype == np.float32: + return data.astype(np.float64) + elif data.dtype == np.int32: + return data.astype(np.int64) + return data + + def get_bool(val, default=False): + """ + This function turns versions of string true/false into bool + + Parameters + ---------- + value : strine + String to convert + default : bool, optional + value to return if conversion fails + + Returns + ------- + bool + return appropriate version of bool + """ + if isinstance(val, bool): + return val + + bool_map = {"true": True, "True": True, "false": False, "False": False} + if val in bool_map: + return bool_map[val] + return default + def np_type_converter(the_type, promote=True): """ Provides the equivalent numpy type givin python, MPI, tensorflow type. @@ -240,57 +293,25 @@ def np_type_converter(the_type, promote=True): type return corresponding np type """ - if the_type == float or the_type == np.float64 or the_type == tf.float64 or the_type == MPI.DOUBLE: + MPI = ExaComm.get_MPI() + the_type = TypeUtils.tf_to_np(the_type) + if the_type == float or the_type == np.float64 or the_type == MPI.DOUBLE: return np.float64 - if the_type == np.float32 or the_type == tf.float32 or the_type == MPI.FLOAT: + if the_type == np.float32 or the_type == MPI.FLOAT: if promote: return np.float64 return np.float32 - if the_type == int or the_type == np.int64 or the_type == tf.int64 or the_type == MPI.INT64_T: + if the_type == int or the_type == np.int64 or the_type == MPI.INT64_T: return np.int64 - if the_type == np.int32 or the_type == tf.int32 or the_type == MPI.INT: + if the_type == np.int32 or the_type == MPI.INT: if promote: return np.int64 return np.int32 - if the_type == bool or the_type == np.bool or the_type == tf.bool or the_type == MPI.BOOL: + if the_type == bool or the_type == np.bool or the_type == MPI.BOOL: return np.bool print("Failed to convert type", the_type, "to np type") return the_type - def tf_type_converter(the_type, promote=True): - """ - Provides the equivalent tensorflow type givin python, MPI, or numpy type. - - Parameters - ---------- - the_type : type - type to be converted - - promote : bool, optional - promots from 32 to 64 bit precision - - Returns - ------- - type - return corresponding tensorflow type - """ - if the_type == float or the_type == np.float64 or the_type == tf.float64 or the_type == MPI.DOUBLE: - return tf.float64 - if the_type == np.float32 or the_type == tf.float32 or the_type == MPI.FLOAT: - if promote: - return tf.float64 - return tf.float32 - if the_type == int or the_type == np.int64 or the_type == tf.int64 or the_type == MPI.INT64_T: - return tf.int64 - if the_type == np.int32 or the_type == tf.int32 or the_type == MPI.INT: - if promote: - return tf.int64 - return tf.int32 - if the_type == bool or the_type == np.bool or the_type == tf.bool or the_type == MPI.BOOL: - return tf.bool - print("Failed to convert type", the_type, "to tf type") - return the_type - def mpi_type_converter(the_type, promote=True): """ Provides the equivalent MPI type givin python, tensorflow, or numpy type. @@ -308,47 +329,74 @@ def mpi_type_converter(the_type, promote=True): type return corresponding mpi type """ - if the_type == float or the_type == np.float64 or the_type == tf.float64 or the_type == MPI.DOUBLE: + MPI = ExaComm.get_MPI() + the_type = TypeUtils.tf_to_np(the_type) + if the_type == float or the_type == np.float64 or the_type == MPI.DOUBLE: return MPI.DOUBLE - if the_type == np.float32 or the_type == tf.float32 or the_type == MPI.FLOAT: + if the_type == np.float32 or the_type == MPI.FLOAT: if promote: return MPI.DOUBLE return MPI.FLOAT - if the_type == int or the_type == np.int64 or the_type == tf.int64 or the_type == MPI.INT64_T: + if the_type == int or the_type == np.int64 or the_type == MPI.INT64_T: return MPI.INT64_T - if the_type == np.int32 or the_type == tf.int32 or the_type == MPI.INT: + if the_type == np.int32 or the_type == MPI.INT: if promote: return MPI.INT64_T return MPI.INT - if the_type == bool or the_type == np.bool or the_type == tf.bool or the_type == MPI.BOOL: + if the_type == bool or the_type == np.bool or the_type == MPI.BOOL: return MPI.BOOL print("Failed to convert type", the_type, "to mpi type") return the_type - def promote_numpy_type(data, makeList=True): - """ - Turns non-list-like data to a numpy array. Promotes numpy lists from 32 to 64 bit. - - Parameters - ---------- - data : single value or np.array - Data to promote - - makeList : bool, optional - Indicates if data should be converted to np.array if not already np.array + def tf_type_converter(the_type, promote=True): + return the_type - Returns - ------- - np.array - return promoted data - """ - list_flag, the_type = TypeUtils.list_like(data) - if not list_flag and makeList: - return np.array([data], dtype=TypeUtils.np_type_converter(the_type)) - if isinstance(data, np.ndarray): - if data.dtype == np.float32: - return data.astype(np.float64) - elif data.dtype == np.int32: - return data.astype(np.int64) - return data +for module in sys.modules: + if 'tensorflow' in module: + import tensorflow as tf + + def real_tf_to_np(the_type): + converter = {tf.float64: np.float64, tf.int32: np.float32, tf.bool: np.bool} + if the_type in converter: + return converter[the_type] + else: + return the_type + + def real_tf_type_converter(the_type, promote=True): + """ + Provides the equivalent tensorflow type givin python, MPI, or numpy type. + + Parameters + ---------- + the_type : type + type to be converted + + promote : bool, optional + promots from 32 to 64 bit precision + + Returns + ------- + type + return corresponding tensorflow type + """ + MPI = ExaComm.get_MPI() + if the_type == float or the_type == np.float64 or the_type == tf.float64 or the_type == MPI.DOUBLE: + return tf.float64 + if the_type == np.float32 or the_type == tf.float32 or the_type == MPI.FLOAT: + if promote: + return tf.float64 + return tf.float32 + if the_type == int or the_type == np.int64 or the_type == tf.int64 or the_type == MPI.INT64_T: + return tf.int64 + if the_type == np.int32 or the_type == tf.int32 or the_type == MPI.INT: + if promote: + return tf.int64 + return tf.int32 + if the_type == bool or the_type == np.bool or the_type == tf.bool or the_type == MPI.BOOL: + return tf.bool + print("Failed to convert type", the_type, "to tf type") + return the_type + + TypeUtils.tf_to_np = real_tf_to_np + TypeUtils.tf_type_converter = real_tf_type_converter diff --git a/exarl/utils/OUActionNoise.py b/exarl/utils/OUActionNoise.py index ffc3a2d6..288ee303 100644 --- a/exarl/utils/OUActionNoise.py +++ b/exarl/utils/OUActionNoise.py @@ -51,9 +51,6 @@ class OUActionNoise2: """ def __init__(self, mean=0, start_std=0.15, stop_std=0.05, damping=0.005): - """ - """ - self.mean = mean self.start_std = start_std self.stop_std = stop_std @@ -61,7 +58,8 @@ def __init__(self, mean=0, start_std=0.15, stop_std=0.05, damping=0.005): self.reset() def __call__(self): - """ Generate noise + """ + Generate noise Returns ------- @@ -77,18 +75,19 @@ def __call__(self): return np.random.normal(0, x, 1) + np.random.normal(0, self.stop_std, 1) def reset(self): - """Reset noise generator to start_std + """ + Reset noise generator to start_std """ self.x_prev = self.start_std class OUActionNoise: - """ Calculates Ornstein-Uhlenbeck process noise. + """ + Calculates Ornstein-Uhlenbeck process noise. """ def __init__(self, mean, std_deviation, theta=0.15, dt=1e-2, x_initial=None): - """[summary] - + """ Parameters ---------- mean : float @@ -109,26 +108,28 @@ def __init__(self, mean, std_deviation, theta=0.15, dt=1e-2, x_initial=None): self.reset() def __call__(self): - """ Generate noise + """ + Generate noise Returns ------- float noise """ - random.seed(datetime.now()) - random_data = os.urandom(4) - np.random.seed(int.from_bytes(random_data, byteorder="big")) + # random.seed(datetime.now()) + # random_data = os.urandom(4) + # np.random.seed(int.from_bytes(random_data, byteorder="big")) x = ( - self.x_prev - + self.theta * (self.mean - self.x_prev) * self.dt - + self.std_dev * np.sqrt(self.dt) * np.random.normal(size=self.mean.shape) + self.x_prev + + self.theta * (self.mean - self.x_prev) * self.dt + + self.std_dev * np.sqrt(self.dt) * np.random.normal(size=self.mean.shape) ) self.x_prev = x return x def reset(self): - """ Reset noise generator to x_initial or 0's + """ + Reset noise generator to x_initial or 0's """ if self.x_initial is not None: self.x_prev = self.x_initial diff --git a/exarl/utils/__init__.py b/exarl/utils/__init__.py index 216ca0ea..e69de29b 100644 --- a/exarl/utils/__init__.py +++ b/exarl/utils/__init__.py @@ -1,5 +0,0 @@ -from exarl.utils import candleDriver -from exarl.utils import analyze_reward -from exarl.utils import log -from exarl.utils import introspect -from exarl.utils import profile diff --git a/exarl/utils/analyze_reward.py b/exarl/utils/analyze_reward.py index f9cef0fd..6cc8af37 100644 --- a/exarl/utils/analyze_reward.py +++ b/exarl/utils/analyze_reward.py @@ -18,26 +18,19 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 -import pandas as pd -import numpy as np -import math import os -import sys +import numpy as np +import pandas as pd import matplotlib.pyplot as plt -from exarl.utils import log -import exarl.utils.candleDriver as cd -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) +from exarl.utils.globals import ExaGlobals - -def read_data(filename, rank): +def read_data(filename): """The function reads csv-based learning data from the given log file into a pandas frame for use in plotting and result analysis. Parameters ---------- filename : string csv file of log data from EXARL - rank : integer - MPI rank number Returns ------- @@ -46,14 +39,20 @@ def read_data(filename, rank): except for current_state and next_state fields, and with the addition of a rank field. """ frame = pd.read_csv(filename, sep=' ', header=None, - names=['time', 'current_state', 'action', 'reward', 'next_state', 'total_reward', 'done', - 'episode', 'step', 'policy_type', 'epsilon']) + names=['time', 'current_state', 'action', 'reward', + 'next_state', 'total_reward', 'done', 'episode', + 'step', 'policy_type']) + del frame['current_state'] del frame['next_state'] - frame['time'] = pd.to_datetime(frame['time'], unit='ns') + + parts = os.path.basename(filename).split("_") + rank = [int(part[4:]) for part in parts if "Rank" in part] + frame['rank'] = rank[0] + + frame['time'] = pd.to_datetime(frame['time'], unit='s') frame = frame[frame.done == True] frame = frame.reset_index() - frame['rank'] = int(rank) return frame def save_reward_plot(): @@ -61,40 +60,41 @@ def save_reward_plot(): It saves the plot in the results directory named by the output_dir run parameter in a subdirectory /Plots/reward_plot.png. It then tries to print the plot to the terminal. """ - df_ranks = [] - rank = 0 # Candle directory stucture - results_dir = cd.run_params['output_dir'] + '/' - for filename in os.listdir(results_dir): - if filename.endswith(".log"): - rank += 1 - logger.info('rank {}: filename:{}'.format(rank, filename)) - df = read_data(results_dir + filename, rank) - df_ranks.append(df) + results_dir = ExaGlobals.lookup_params('output_dir') + plot_path = os.path.join(results_dir, 'Plots') + os.makedirs(plot_path, exist_ok=True) + + files = [filename for filename in os.listdir(results_dir) if filename.endswith(".log")] + df_ranks = [read_data(os.path.join(results_dir, filename)) for filename in files] df_merged = pd.concat(df_ranks) - df_merged = df_merged.dropna() + # df_merged = df_merged.dropna() time_min = df_merged.time.min() - time_max = df_merged.time.max() - time_diff = time_max - time_min - logger.info('time_min:{}'.format(time_min)) - logger.info('time_diff:{}'.format(time_diff)) df_merged['rel_time'] = [idx - time_min for idx in df_merged.time] df_merged.sort_values(by=['rel_time'], inplace=True) - rolling_setting = 25 - fig, ax = plt.subplots(1, 1, figsize=(10, 8)) - episodes_per_nodes = [] - logger.info('Node path:{}'.format(results_dir)) + rolling_setting = ExaGlobals.lookup_params('rolling_reward_length') df_merged['total_reward_roll'] = df_merged['total_reward'].rolling(rolling_setting).mean() - logger.info((df_merged.shape)) + + fig, ax = plt.subplots(1, 1, figsize=(10, 8)) plt.plot(df_merged['rel_time'], df_merged['total_reward_roll']) - episodes_per_nodes.append(len(df_merged)) plt.xlabel('Relative Time') plt.ylabel('Rolling Total Reward ({})'.format(rolling_setting)) - if not os.path.exists(results_dir + '/Plots'): - os.makedirs(results_dir + '/Plots') - fig.savefig(results_dir + '/Plots/Reward_plot.png') + fig.savefig(os.path.join(plot_path, 'Reward_plot.png')) + plt.clf() + + ranks = df_merged['rank'].unique() + ranks.sort() + for rank in ranks: + to_plot = df_merged[df_merged['rank'] == rank] + to_plot = to_plot.sort_values(by=['rel_time']) + plt.plot(to_plot['rel_time'], to_plot['total_reward_roll'], label=rank) + plt.xlabel('Relative Time') + plt.ylabel('Rolling Total Reward ({})'.format(rolling_setting)) + plt.legend() + fig.savefig(os.path.join(plot_path, 'Rank_plot.png')) + plt.clf() # Terminal plot try: @@ -105,10 +105,13 @@ def save_reward_plot(): figure.y_label = 'Rolling reward' figure.x_label = 'Episodes' figure.color_mode = 'byte' - figure.set_x_limits(min_=0, max_=len(df_merged['total_reward_roll'])) - figure.set_y_limits(min_=min(df_merged['total_reward_roll'].replace(np.nan, 0)), max_=max(df_merged['total_reward_roll'].replace(np.nan, 0))) - figure.plot(range(len(df_merged['total_reward_roll'])), df_merged['total_reward_roll'].replace(np.nan, 0), lc=200, label='rolling reward') - # range(len(df_merged['time'])) + + to_plot = df_merged.dropna() + y = list(to_plot['total_reward_roll'].values) + x = list(range(len(y))) + figure.set_x_limits(min_=x[0], max_=x[-1]) + figure.set_y_limits(min_=min(y), max_=max(y)) + figure.plot(x, y, lc=200, label='rolling reward') print(figure.show(legend=True)) - except: - print("Terminal plot error: Check if you have plotille installed or for other errors.") + except ModuleNotFoundError: + print("Plottile not installed.") diff --git a/exarl/utils/candleDriver.py b/exarl/utils/candleDriver.py index 2c4ac2ed..946205b4 100644 --- a/exarl/utils/candleDriver.py +++ b/exarl/utils/candleDriver.py @@ -18,35 +18,44 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 -import argparse -import json -from exarl.utils import log -from pprint import pformat -from tensorflow import keras import os import sys import site -file_path = os.path.dirname(os.path.realpath(__file__)) +import json +import argparse +from exarl.utils.globals import ExaGlobals import exarl.candlelib.candle as candle -# from pprint import pprint - -# required = ['agent', 'env', 'n_episodes', 'n_steps'] -required = ['agent', 'model_type', 'env', 'workflow'] +file_path = os.path.dirname(os.path.realpath(__file__)) +required = ['agent', 'env', 'workflow', 'model_type'] -def resolve_path(*path_components) -> str: - """ Resolve path to configuration files. +def resolve_path(*path_components, config_path=None, alternate_path=None) -> str: + """ + Resolve path to configuration files. The alternate path is a second choice + based on the externally loaded modules. We look to see if any config files + exist in these dirs. For env and agent files they must still follow the + dir structure (i.e. agent_cfg/DQN-v0.json or env_cfg/ExaCartPoleStatic-v0). Priority is as follows: - - 1. /exarl/config - 2. ~/.exarl/config - 3. /exarl/config + 1. Path passed in at command line using --config_file + 2. Alternate path given by --load_agent/env_path + 3. /exarl/config + 4. ~/.exarl/config + 5. /exarl/config """ if len(path_components) == 1: path = path_components[0] else: path = os.path.join(*path_components) - + if config_path is not None: + config_path = os.path.abspath(config_path) + config_path = os.path.join(config_path, path) + if os.path.exists(config_path): + return config_path + if alternate_path is not None: + alternate_path = os.path.abspath(alternate_path) + alternate_path = os.path.join(alternate_path, path) + if os.path.exists(alternate_path): + return alternate_path cwd_path = os.path.join(os.getcwd(), 'exarl', 'config', path) if os.path.exists(cwd_path): return cwd_path @@ -59,48 +68,93 @@ def resolve_path(*path_components) -> str: return install_path raise FileNotFoundError("Could not find file {0}!".format(path)) -class BenchmarkDriver(candle.Benchmark): - - def set_locals(self): - """ Functionality to set variables specific for the benchmark - - required: set of required parameters for the benchmark. - - additional_definitions: list of dictionaries describing the additional parameters for the - benchmark. - """ - - print('Additional definitions built from json files') - additional_definitions = get_driver_params() - # pprint(additional_definitions, flush=True) - if required is not None: - self.required = set(required) - if additional_definitions is not None: - self.additional_definitions = additional_definitions - - -def initialize_parameters(): - # Build agent object - - driver = BenchmarkDriver(file_path, '', 'keras', - prog='CANDLE_example', desc='CANDLE example driver script') - - # Initialize parameters - gParameters = candle.finalize_parameters(driver) - # benchmark.logger.info('Params: {}'.format(gParameters)) - logger = log.setup_logger(__name__, gParameters['log_level']) - logger.info("Finalized parameters:\n" + pformat(gParameters)) - global run_params - global kerasDefaults - run_params = gParameters - kerasDefaults = candle.keras_default_config() - -def lookup_params(arg, default=None): - """ Attempts to lookup arg from the global run_params. - If it is not found it will return the defualt value passed as input. +def initialize_parameters(params=None): + if params is None: + # Build agent object + class BenchmarkDriver(candle.Benchmark): + def set_locals(self): + """ Functionality to set variables specific for the benchmark + - required: set of required parameters for the benchmark. + - additional_definitions: list of dictionaries describing the additional parameters for the + benchmark. + """ + + print('Additional definitions built from json files') + additional_definitions = get_driver_params() + if required is not None: + self.required = set(required) + if additional_definitions is not None: + self.additional_definitions = additional_definitions + + driver = BenchmarkDriver(file_path, '', 'keras', + prog='CANDLE_example', + desc='CANDLE example driver script') + params = candle.finalize_parameters(driver) + ExaGlobals(params, candle.keras_default_config()) + +def config_parser(): """ - try: - return run_params[arg] - except: - return default + This parsers runs first to get a config_path if present. + It removes the argument by resetting the sys.argv with the remaining args. + + Returns + ------- + String : + The path to search for config file + """ + parser = argparse.ArgumentParser(description="Config parser") + parser.add_argument("--config_path") + args, leftovers = parser.parse_known_args() + if args.config_path is not None and not os.path.exists(args.config_path): + raise FileNotFoundError("Path {0} does not exists!".format(args.config_path)) + sys.argv = sys.argv[:1] + leftovers + return args.config_path + +def external_env_and_agents_parser(): + """ + This checks command line for external agents and envs. If the load_*_path is + set for either, they will by added to the system path. The load_agent and + load_env will be added to the candle params. + + Returns + ------- + List : + List of load agent/env params + String : + agent load path + String : + env load path + """ + parser = argparse.ArgumentParser(description="External source parser") + parser.add_argument("--load_agent_module") + parser.add_argument("--load_agent_path") + parser.add_argument("--load_env_module") + parser.add_argument("--load_env_path") + args, leftovers = parser.parse_known_args() + + if args.load_agent_path is not None: + args.load_agent_path = os.path.abspath(args.load_agent_path) + if not os.path.exists(args.load_agent_path): + raise FileNotFoundError("Load Agent Path {0} does not exists!".format(args.load_agent_path)) + if args.load_agent_path not in sys.path: + sys.path.append(args.load_agent_path) + + if args.load_env_path is not None: + args.load_env_path = os.path.abspath(args.load_env_path) + if not os.path.exists(args.load_env_path): + raise FileNotFoundError("Load Env Path {0} does not exists!".format(args.load_env_path)) + if args.load_env_path not in sys.path: + sys.path.append(args.load_env_path) + + ret = [] + if args.load_agent_module is not None: + ret.append({'name': 'load_agent_module', 'type': str, 'default': args.load_agent_module}) + + if args.load_env_module is not None: + ret.append({'name': 'load_env_module', 'type': str, 'default': args.load_env_module}) + + sys.argv = sys.argv[:1] + leftovers + return ret, args.load_agent_module, args.load_env_module def base_parser(params): """ @@ -126,13 +180,10 @@ def base_parser(params): parser = argparse.ArgumentParser(description="Base parser") parser.add_argument("--agent") parser.add_argument("--env") - parser.add_argument("--model_type") parser.add_argument("--workflow") - parser.add_argument("--data_structure") - parser.add_argument("--batch_size") + parser.add_argument("--model_type") args, leftovers = parser.parse_known_args() - if args.agent is not None: params['agent'] = args.agent print("Agent overwitten from command line: ", args.agent) @@ -141,17 +192,15 @@ def base_parser(params): params['env'] = args.env print("Environment overwitten from command line: ", args.env) - if args.model_type is not None: - params['model_type'] = args.model_type - print("Model overwitten from command line: ", args.model_type) - if args.workflow is not None: params['workflow'] = args.workflow print("Workflow overwitten from command line: ", args.workflow) + if args.model_type is not None: + params['model_type'] = args.model_type + print("Model overwitten from command line: ", args.model_type) return params - def parser_from_json(json_file): """ Custom parser to read a json file and return the list of included keywords. @@ -169,7 +218,6 @@ def parser_from_json(json_file): ------- new_defs : dictionary Dictionary of parameters - """ file = open(json_file,) params = json.load(file) @@ -183,54 +231,51 @@ def parser_from_json(json_file): return new_defs +def check_keyword_and_config(params, keyword, config_path, alternate_path=None): + """ + This function performs a check for specific keywords to see if + they are set in the config file and also checks if there is a + corresponding configuration file. + """ + if keyword in params.keys(): + if keyword == 'model_type': + cfg = 'model_cfg' + else: + cfg = keyword + "_cfg" + try: + cfg_file = resolve_path(cfg, params[keyword] + '.json', config_path=config_path, alternate_path=alternate_path) + print('Agent parameters from ', cfg) + except FileNotFoundError: + cfg_file = resolve_path(cfg, 'default_' + cfg + '.json', config_path=config_path) + print(keyword + ' configuration does not exist, using default configuration') + return parser_from_json(cfg_file) + else: + sys.exit("CANDLELIB::ERROR The learner config file is malformed. There is no " + keyword + " selected.") def get_driver_params(): - """ Build the full set of run parameters by sequentially parsing the config files + """ + Build the full set of run parameters by sequentially parsing the config files for agent, model, env and workflow. Unless overwritten from the command line (via base_parser), the names for these config files are defined in the learner_cfg.json file. """ + config_path = config_parser() + external_defs, load_agent_path, load_env_path = external_env_and_agents_parser() - learner_cfg = resolve_path('learner_cfg.json') + learner_cfg = resolve_path('learner_cfg.json', config_path=config_path) learner_defs = parser_from_json(learner_cfg) print('Learner parameters from ', learner_cfg) params = json.load(open(learner_cfg)) params = base_parser(params) + + agent_defs = check_keyword_and_config(params, "agent", config_path, alternate_path=load_agent_path) + env_defs = check_keyword_and_config(params, "env", config_path, alternate_path=load_env_path) + workflow_defs = check_keyword_and_config(params, "workflow", config_path) + model_defs = check_keyword_and_config(params, "model_type", config_path) + print('_________________________________________________________________') - print("Running - {}, {}, {} and {}".format(params['agent'], params['model_type'], params['env'], params['workflow'])) + print("Running - {}, {}, {}, and {}".format(params['agent'], params['env'], params['workflow'], params['model_type'])) + # print("Running - {}, {}, {} and {}".format(params['agent'], params['model_type'], params['env'], params['workflow'])) print('_________________________________________________________________', flush=True) - try: - agent_cfg = resolve_path('agent_cfg', - params['agent'] + '.json') - print('Agent parameters from ', agent_cfg) - except FileNotFoundError: - agent_cfg = resolve_path('agent_cfg', 'default_agent_cfg.json') - print('Agent configuration does not exist, using default configuration') - agent_defs = parser_from_json(agent_cfg) - - try: - model_cfg = resolve_path('model_cfg', - params['model_type'] + '.json') - print('Model parameters from ', model_cfg) - except FileNotFoundError: - model_cfg = resolve_path('model_cfg', 'default_model_cfg.json') - print('Model configuration does not exist, using default configuration') - model_defs = parser_from_json(model_cfg) - - try: - env_cfg = resolve_path('env_cfg', params['env'] + '.json') - print('Environment parameters from ', env_cfg) - except FileNotFoundError: - env_cfg = resolve_path('env_cfg', 'default_env_cfg.json') - print('Environment configuration does not exist, using default configuration') - env_defs = parser_from_json(env_cfg) - - try: - workflow_cfg = resolve_path('workflow_cfg', params['workflow'] + '.json') - print('Workflow parameters from ', workflow_cfg) - except FileNotFoundError: - workflow_cfg = resolve_path('workflow_cfg', 'default_workflow_cfg.json') - print('Workflow configuration does not exist, using default configuration') - workflow_defs = parser_from_json(workflow_cfg) - - return learner_defs + agent_defs + model_defs + env_defs + workflow_defs + + return learner_defs + agent_defs + env_defs + workflow_defs + model_defs + external_defs diff --git a/exarl/utils/globals.py b/exarl/utils/globals.py new file mode 100644 index 00000000..99bface1 --- /dev/null +++ b/exarl/utils/globals.py @@ -0,0 +1,199 @@ +# This material was prepared as an account of work sponsored by an agency of the +# United States Government. Neither the United States Government nor the United +# States Department of Energy, nor Battelle, nor any of their employees, nor any +# jurisdiction or organization that has cooperated in the development of these +# materials, makes any warranty, express or implied, or assumes any legal +# liability or responsibility for the accuracy, completeness, or usefulness or +# any information, apparatus, product, software, or process disclosed, or +# represents that its use would not infringe privately owned rights. Reference +# herein to any specific commercial product, process, or service by trade name, +# trademark, manufacturer, or otherwise does not necessarily constitute or imply +# its endorsement, recommendation, or favoring by the United States Government +# or any agency thereof, or Battelle Memorial Institute. The views and opinions +# of authors expressed herein do not necessarily state or reflect those of the +# United States Government or any agency thereof. +# PACIFIC NORTHWEST NATIONAL LABORATORY +# operated by +# BATTELLE +# for the +# UNITED STATES DEPARTMENT OF ENERGY +# under Contract DE-AC05-76RL01830 +import os +import logging +from pprint import pformat + +class ExaGlobals: + """ + This class houses all of the globals required for Exarl. + This includes run_params, keras_defaults, and logger. + It has been built with helpful exceptions/messages for + when something has not been initialized yet. + To initialize parameter create the ExaGlobals object. The + class is a singleton so it can only be created once. + Keys can be modified however by using the set_param method. + + Attributes + ---------- + __keras_default : dictionary + Private member that houses defaults from candle for keras + __run_params : dictionary + Private member for all the parameters read in from the config + files via candleDriver + init_logger : bool + Indicates if the logs have been initialized + __logger : dictionary + Private member that holds all loggers + __global_log_level : int + Private member that give the log level from candleDriver + """ + + __keras_defaults = None + __run_params = None + __logger = {} + __global_log_level = None + + class GlobalsNotInitialized(Exception): + """ + Exception raised when trying to access globals that have not + been initialized. + """ + def __init__(self, key, value=None): + self.key = key + self.value = value + + def __str__(self): + message = "ExaRL globals have not been set. Trying " + str(self.key) + if self.value is not None: + return message + " : " + str(self.value) + else: + return message + + class GlobalDoesNotExist(Exception): + """ + Exception raised when trying to access global that has not + been set. + """ + def __init__(self, which, key, value=None): + self.key = key + self.value = value + self.which = which + + def __str__(self): + message = "ExaRL globals key does not exist. Trying " + str(self.key) + if self.value is not None: + message += " : " + str(self.value) + message += "\n" + pformat(self.which) + return message + + def __init__(self, run_params, keras_defaults): + if ExaGlobals.__run_params is None and ExaGlobals.__keras_defaults is None: + if isinstance(run_params, dict): + ExaGlobals.__run_params = run_params + if isinstance(keras_defaults, dict): + ExaGlobals.__keras_defaults = keras_defaults + + log_level = ExaGlobals.lookup_params('log_level') + ExaGlobals.__init_loggers(*log_level) + logger = ExaGlobals.setup_logger(__name__) + logger().info("Finalized parameters:\n" + pformat(ExaGlobals.__run_params)) + + def is_init(): + """ + Returns if globals have been initialized. + """ + return ExaGlobals.__run_params is not None and ExaGlobals.__keras_defaults is not None + + def lookup_params(key): + """ + Returns if key is in run_params otherwise throws an exception. + """ + if ExaGlobals.__run_params is None: + raise ExaGlobals.GlobalsNotInitialized(key) + if key not in ExaGlobals.__run_params: + raise ExaGlobals.GlobalDoesNotExist(ExaGlobals.__run_params, key) + return ExaGlobals.__run_params[key] + + def set_param(key, value): + """ + Sets a parameter in run_params if it has been initialized. + """ + if ExaGlobals.__run_params is None: + raise ExaGlobals.GlobalsNotInitialized(key, value=value) + ExaGlobals.__run_params[key] = value + + def set_params(dic): + """ + Updates parameters with a dictionary of new params. + """ + if ExaGlobals.__run_params is None: + raise ExaGlobals.GlobalsNotInitialized("") + assert isinstance(dic, dict), "Params must be a dictionary." + ExaGlobals.__run_params.update(dic) + + def keras_default(key): + """ + Returns if key is in keras_defaults otherwise throws an exception. + """ + if ExaGlobals.__keras_defaults is None: + raise ExaGlobals.GlobalsNotInitialized(key) + if key is None: + return ExaGlobals.__keras_defaults + if key not in ExaGlobals.__keras_defaults: + raise ExaGlobals.GlobalDoesNotExist(ExaGlobals.__keras_defaults, key) + return ExaGlobals.__keras_defaults[key] + + def log_helper(name): + """ + This function is returned when called by setup_logger + as a way to raise an error if not initialized. + """ + if ExaGlobals.is_init(): + return ExaGlobals.__logger[name] + raise ExaGlobals.GlobalsNotInitialized('log_level') + + def __init_log(name, level): + """ + Initialize a single logger. + """ + if level is None: + level = ExaGlobals.__global_log_level + formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s') + handler = logging.StreamHandler() + handler.setFormatter(formatter) + logger = logging.getLogger(name) + + if level == 0: + logger.setLevel(logging.DEBUG) + elif level == 1: + logger.setLevel(logging.INFO) + elif level == 2: + logger.setLevel(logging.WARNING) + elif level == 3: + logger.setLevel(logging.ERROR) + + logger.addHandler(handler) + return logger + + def __init_loggers(tensorflow_log_level, global_log_level): + """ + Initialize all loggers and set the tensorflow logger level. + """ + # Set TensorFlow log level + # 0: debug, 1: info, 2: warning, 3: error + os.environ['TF_CPP_MIN_LOG_LEVEL'] = str(tensorflow_log_level) + ExaGlobals.__global_log_level = global_log_level + for key in ExaGlobals.__logger: + log_level = ExaGlobals.__logger[key] + ExaGlobals.__logger[key] = ExaGlobals.__init_log(key, log_level) + + def setup_logger(name=None, level=None): + """ + This is function called by individual files to provide a + promise for logging. + """ + if name not in ExaGlobals.__logger: + if ExaGlobals.is_init(): + ExaGlobals.__logger[name] = ExaGlobals.__init_log(name, level) + else: + ExaGlobals.__logger[name] = level + return lambda: ExaGlobals.log_helper(name) diff --git a/exarl/utils/introspect.py b/exarl/utils/introspect.py index 94c59e97..60e27cf6 100644 --- a/exarl/utils/introspect.py +++ b/exarl/utils/introspect.py @@ -8,8 +8,8 @@ def ibLoaded(): return True - def ibLoadReplacement(comm, writeDir): - pass + def ibLoadReplacement(comm): + return ib def ibWrite(writeDir): pass @@ -77,6 +77,7 @@ def __init__(self, comm): self.skew.append(globalTimeStamp()) comm.barrier() + @staticmethod def start(): """Starts tracing this rank. @@ -91,6 +92,7 @@ def start(): return 1 return 0 + @staticmethod def stop(): """Stops tracing for this rank. """ @@ -98,6 +100,7 @@ def stop(): print("---------------STOPPING REPLACEMENT IB", ib.rank, "---------------", flush=True) ib.end_time = globalTimeStamp() + @staticmethod def update(name, toAdd): """Updates tracing metrics for the given name. @@ -125,6 +128,7 @@ def update(name, toAdd): return 1 return -1 + @staticmethod def startTrace(name, size): """Begin a trace of a metric for a function. @@ -153,6 +157,7 @@ def startTrace(name, size): return 1 return 0 + @staticmethod def simpleTrace(name, size, seqNum, endTimeStamp, trace): """Create a trace associated with a function @@ -182,6 +187,7 @@ def simpleTrace(name, size, seqNum, endTimeStamp, trace): return 1 return 0 + @staticmethod def stopTrace(): """Stops the trace if it was started. """ @@ -232,15 +238,13 @@ def ibLoaded(): """ return ib.replace - def ibLoadReplacement(comm, writeDir): + def ibLoadReplacement(comm): """Start tracing. Parameters ---------- comm : MPI communicator [description] - writeDir : str - Returns ------- diff --git a/exarl/utils/log.py b/exarl/utils/log.py deleted file mode 100644 index 39574d0d..00000000 --- a/exarl/utils/log.py +++ /dev/null @@ -1,63 +0,0 @@ -# This material was prepared as an account of work sponsored by an agency of the -# United States Government. Neither the United States Government nor the United -# States Department of Energy, nor Battelle, nor any of their employees, nor any -# jurisdiction or organization that has cooperated in the development of these -# materials, makes any warranty, express or implied, or assumes any legal -# liability or responsibility for the accuracy, completeness, or usefulness or -# any information, apparatus, product, software, or process disclosed, or -# represents that its use would not infringe privately owned rights. Reference -# herein to any specific commercial product, process, or service by trade name, -# trademark, manufacturer, or otherwise does not necessarily constitute or imply -# its endorsement, recommendation, or favoring by the United States Government -# or any agency thereof, or Battelle Memorial Institute. The views and opinions -# of authors expressed herein do not necessarily state or reflect those of the -# United States Government or any agency thereof. -# PACIFIC NORTHWEST NATIONAL LABORATORY -# operated by -# BATTELLE -# for the -# UNITED STATES DEPARTMENT OF ENERGY -# under Contract DE-AC05-76RL01830 -import os -import logging - - -def setup_logger(name, level): - """Sets up logging capability using the Python logger module. - - Parameters - ---------- - name : str - Potentially period-separated hierarchical value like foo.bar.baz or just plain foo. - level : list of two values - First value is the TensorFlow log level and second value is Python log level, both have values 0-3 (0: debug, 1: info, 2: warning, 3: error) - Returns - ------- - logging.Logger - Logger object - """ - formatter = logging.Formatter(fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s') - - handler = logging.StreamHandler() - handler.setFormatter(formatter) - - logger = logging.getLogger(name) - - # Set TensorFlow log level - # 0: debug, 1: info, 2: warning, 3: error - os.environ['TF_CPP_MIN_LOG_LEVEL'] = str(level[0]) - if level[1] == 0: - # Set Python logging level to debug - logger.setLevel(logging.DEBUG) - elif level[1] == 1: - # Set Python logging level to info - logger.setLevel(logging.INFO) - elif level[1] == 2: - # Set Python logging level to warning - logger.setLevel(logging.WARNING) - elif level[1] == 3: - # Set Python logging level to error - logger.setLevel(logging.ERROR) - - logger.addHandler(handler) - return logger diff --git a/exarl/utils/memory_type.py b/exarl/utils/memory_type.py new file mode 100644 index 00000000..7540b65a --- /dev/null +++ b/exarl/utils/memory_type.py @@ -0,0 +1,7 @@ +from enum import Enum +# TODO: An Interface class might be better, but quick hack to test +class MEMORY_TYPE(str, Enum): + UNIFORM_REPLAY = 'uniform' + PRIORITY_REPLAY = 'priority' + HINDSIGHT_REPLAY = 'hindsight' + # More to be added latter diff --git a/exarl/utils/profile.py b/exarl/utils/profile.py index 01ecbb5d..0261a289 100644 --- a/exarl/utils/profile.py +++ b/exarl/utils/profile.py @@ -19,19 +19,87 @@ # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 import atexit -import exarl.utils.candleDriver as cd import os import functools import time +from exarl.utils.globals import ExaGlobals -prof = cd.lookup_params('profile') -results_dir = cd.lookup_params('output_dir', ".") + '/' -if not os.path.exists(results_dir + '/Profile'): - os.makedirs(results_dir + '/Profile', exist_ok=True) +class ProfileConstants: + """ + Singleton class to deal with loading results directory from candle parameters. + The appropriate class is loaded the first time the initializer is called. + Attributes + ---------- + initialized : bool + Indicates if the singleton has been initialized + started : bool + Flag indicating if profiler has already been started + profile_type : string + This comes from the config/candle driver. Choices are + line, mem, and intro. + results_dir : string + Dir where to write results + file : string + File where to write results + profile : function + Function pointer of profiler + ib : ib + Introspector class + """ + initialized = False + started = False + profile_type = None + results_dir = None + file = None + profile = None + + ib = None + ib_loaded = lambda: False + + def __init__(self): + if not ProfileConstants.initialized: + ProfileConstants.profile_type = ExaGlobals.lookup_params('profile') + ProfileConstants.results_dir = os.path.join(ExaGlobals.lookup_params('output_dir'), 'Profile') + if not os.path.exists(ProfileConstants.results_dir): + os.makedirs(ProfileConstants.results_dir, exist_ok=True) + + if ProfileConstants.profile_type == 'mem': + import memory_profiler + ProfileConstants.profile = memory_profiler.profile + ProfileConstants.file = os.path.join(ProfileConstants.results_dir, 'mem_profile.txt') + + elif ProfileConstants.profile_type == 'line': + import line_profiler + ProfileConstants.profile = line_profiler.LineProfiler() + ProfileConstants.file = os.path.join(ProfileConstants.results_dir, 'line_profile.txt') + + def write_profile_to_file(): + with open(ProfileConstants.file, 'w') as file: + ProfileConstants.profile.print_stats(stream=file) + atexit.register(write_profile_to_file) + + elif ProfileConstants.profile_type == 'intro': + import exarl.utils.introspect + from exarl.base.comm_base import ExaComm + ProfileConstants.ib = exarl.utils.introspect.ibLoadReplacement(ExaComm.global_comm) + ProfileConstants.ib_loaded = exarl.utils.introspect.ibLoaded + atexit.register(lambda: exarl.utils.introspect.ibWrite(ProfileConstants.results_dir)) + ProfileConstants.initialized = True + + @staticmethod + def introspected(): + """ + Returns if introspector is loaded and ran. + """ + if ProfileConstants.started: + return ProfileConstants.ib_loaded() + return False def PROFILE(func): - """Invokes line_profiler and memory_profiler + """ + Invokes line_profiler, memory_profiler, and introspector. + Based on https://realpython.com/primer-on-python-decorators/ Parameters ---------- @@ -43,51 +111,39 @@ def PROFILE(func): function wrapper profile function """ - # Line profiler - if prof == 'line': - import line_profiler - profile = line_profiler.LineProfiler() - - @functools.wraps(func) - def wrapper_profile(*args, **kwargs): - new_func = profile(func) - return new_func(*args, **kwargs) - - # Write line profiler output to file - def write_profile_to_file(): - if prof == 'line': - with open(results_dir + '/Profile/line_profile.txt', 'w') as file: - profile.print_stats(stream=file) - atexit.register(write_profile_to_file) - - # Memory profiler - elif prof == 'mem': - from memory_profiler import profile - file = open(results_dir + '/Profile/mem_profile.txt', 'w') - - @functools.wraps(func) - def wrapper_profile(*args, **kwargs): - new_func = profile(func, stream=file) - return new_func(*args, **kwargs) - - # No profiler - else: - @functools.wraps(func) - def wrapper_profile(*args, **kwargs): - return func(*args, **kwargs) + @functools.wraps(func) + def wrapper_profile(*args, **kwargs): + ProfileConstants() + if ProfileConstants.profile_type is not None: + if not ProfileConstants.started: + ProfileConstants.started = True + if ProfileConstants.profile_type == 'line': + new_func = ProfileConstants.profile(func) + return new_func(*args, **kwargs) + + elif ProfileConstants.profile_type == 'mem': + stream = open(ProfileConstants.file, 'w') + new_func = ProfileConstants.profile(func, stream=stream) + return new_func(*args, **kwargs) + + elif ProfileConstants.profile_type == 'intro': + ProfileConstants.ib.start() + ret = func(*args, **kwargs) + ProfileConstants.ib.stop() + return ret + + return func(*args, **kwargs) return wrapper_profile -# Based on https://realpython.com/primer-on-python-decorators/ - - def DEBUG(func): - """Print the function signature and return value + """ + Print the function signature and return value Parameters ---------- func : function - function to be wrapped for debugggin + function to be wrapped for debuggin Returns ------- @@ -105,11 +161,9 @@ def wrapper_debug(*args, **kwargs): return value return wrapper_debug -# Based on https://realpython.com/primer-on-python-decorators/ - - def TIMER(func): - """Print the runtime of the decorated function + """ + Print the runtime of the decorated function Parameters ---------- @@ -132,7 +186,8 @@ def wrapper_timer(*args, **kwargs): return wrapper_timer def TIMERET(func): - """Print the runtime of the decorated function + """ + Print the runtime of the decorated function Parameters ---------- diff --git a/exarl/utils/sum_tree.py b/exarl/utils/sum_tree.py new file mode 100644 index 00000000..39fe82d6 --- /dev/null +++ b/exarl/utils/sum_tree.py @@ -0,0 +1,58 @@ +import numpy as np + +class SumTree(object): + + def __init__(self, capacity): + super(SumTree, self).__init__() + self.capacity = capacity + self.data_pointer = 0 + self.tree = np.zeros(2 * capacity - 1) + self.data = np.zeros(capacity, dtype=object) + + def add(self, priority, data): + tree_index = self.data_pointer + self.capacity - 1 + self.data[self.data_pointer] = data + self.update(tree_index, priority) + self.data_pointer = (self.data_pointer + 1) % self.capacity + + @property + def total_priority(self): + return self.tree[0] + + def update(self, tree_index, priority): + change = priority - self.tree[tree_index] + + self.tree[tree_index] = priority + + self._update_tree_difference(tree_index, change) + + def get_priority_values(self, value): + start_parent_index = 0 + index = self._get_value(start_parent_index, value) + + data_index = index - self.capacity + 1 + + return index, self.tree[index], self.data[data_index] + + def _update_tree_difference(self, tree_index, change): + + while(tree_index != 0): + tree_index = (tree_index - 1) // 2 + self.tree[tree_index] += change + + def _get_value(self, parent_index, value): + + while True: + left_index = 2 * parent_index + 1 + right_index = left_index + 1 + + if left_index >= len(self.tree): + leaf_index = parent_index + break + elif value <= self.tree[left_index]: + parent_index = left_index + else: + value -= self.tree[left_index] + parent_index = right_index + + return leaf_index diff --git a/exarl/workflows/workflow_vault/async_learner.py b/exarl/workflows/workflow_vault/async_learner.py index 4700435f..e88b2eef 100644 --- a/exarl/workflows/workflow_vault/async_learner.py +++ b/exarl/workflows/workflow_vault/async_learner.py @@ -18,291 +18,147 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 -import time -import csv -import numpy as np -import exarl as erl -from exarl.utils.introspect import ib -from exarl.utils.profile import * -from exarl.utils import log -import exarl.utils.candleDriver as cd from exarl.base.comm_base import ExaComm +from exarl.workflows.workflow_vault.sync_learner import SYNC +from exarl.utils.profile import PROFILE -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) - -class ASYNC(erl.ExaWorkflow): - """Asynchronous workflow class: inherits from ExaWorkflow base class. - In this approach, the EXARL architecture is separated into “learner” and “actors”. - Actor refers to the part of the agent with only the target network. A simple - round-robin scheduling scheme is used to distribute work from the learner to the actors. - The learner consists of a target model that is trained using experiences collected - by the actors. Each actor consists of a model replica that receives the updated - weights from the learner. This model is used to infer the next action given a state of - the environment. The environment can be rendered/simulated to update the state using this - action. In contrast to other architectures, each actor in EXARL independently stores - experiences and runs the Bellman equation to generate training data. The training - data is sent back to the learner (once enough data is collected). By locally running the - Bellman equations in each actor in parallel, the load is equally distributed among all actor - processes. The learner distributes work by parallelizing across episodes, and actors request - work in a round-robin fashion. Each actor runs all of the steps in an episode to completion - before requesting more work from the learner. This process is repeated until the learner - gathers experiences from all episodes. +class ASYNC(SYNC): + """ + This class builds ontop of the simple learner to support processing + environments in parallel. This is achieved by having separate learners + and actors. The communication is performed by MPI sends/recvs. + We are currently supporting single learner thus we set block_size = 2 + for off-policy learning. + This class assumes a single learner. """ - def __init__(self): - """Async class constructor. - """ - print('Creating ASYNC learner workflow...') - priority_scale = cd.lookup_params('priority_scale') - self.use_priority_replay = (priority_scale is not None and priority_scale > 0) - - @PROFILE - def run(self, workflow): - """This function implements the asynchronous workflow in EXARL using two-sided - point-to-point MPI communication. + def __init__(self, agent=None, env=None): + super(ASYNC, self).__init__() + self.debug('Creating ASYNC learner!') - Args: - workflow (ExaLearner type object): The ExaLearner object is used to access - different members of the base class. + if self.block_size == 1: + self.block_size = 2 - Returns: - None + def send_model(self, workflow, episode, train_ret, dst): """ - # MPI communicators - agent_comm = ExaComm.agent_comm - env_comm = ExaComm.env_comm - - target_weights = None - - # Variables for all - episode = 0 - episode_done = 0 - episode_interim = 0 - - # Round-Robin Scheduler - if ExaComm.is_learner(): - start = agent_comm.time() - worker_episodes = np.arange(1, agent_comm.size) - logger.debug("worker_episodes:{}".format(worker_episodes)) - - logger.info("Initializing ...\n") - for s in range(1, agent_comm.size): - # Send target weights - indices, loss = None, None - rank0_epsilon = workflow.agent.epsilon - target_weights = workflow.agent.get_weights() - episode = worker_episodes[s - 1] - agent_comm.send( - [episode, rank0_epsilon, target_weights, indices, loss], dest=s) - - init_nepisodes = episode - logger.debug("init_nepisodes:{}".format(init_nepisodes)) - - logger.debug("Continuing ...\n") - while episode_done < workflow.nepisodes: - # Receive the rank of the worker ready for more work - recv_data = agent_comm.recv(None) - ib.update("Async_Learner_Get_Data", 1) - - whofrom = recv_data[0] - step = recv_data[1] - batch = recv_data[2] - policy_type = recv_data[3] - done = recv_data[4] - logger.debug('step:{}'.format(step)) - logger.debug('done:{}'.format(done)) - # Train - train_return = workflow.agent.train(batch) - ib.update("Async_Learner_Train", 1) - # if train_return is not None: - if self.use_priority_replay and train_return is not None: - if train_return[0][0] != -1: - indices, loss = train_return - # TODO: Double check if this is already in the DQN code - workflow.agent.target_train() - ib.update("Async_Learner_Target_Train", 1) - - if policy_type == 0: - workflow.agent.epsilon_adj() - epsilon = workflow.agent.epsilon - - # Send target weights - logger.debug('rank0_epsilon:{}'.format(epsilon)) - # Increment episode when starting - if step == 0: - episode += 1 - logger.debug("if episode:{}".format(episode)) - - # Increment the number of completed episodes - if done: - episode_done += 1 - latest_episode = worker_episodes.max() - # Updated episode = latest_episode + 1 - worker_episodes[whofrom - 1] = latest_episode + 1 - logger.debug("episode_done:{}".format(episode_done)) - ib.update("Async_Learner_Episode", 1) - - # Send target weights - logger.debug('rank0_epsilon:{}'.format(epsilon)) - target_weights = workflow.agent.get_weights() - agent_comm.send([worker_episodes[whofrom - 1], epsilon, target_weights, indices, loss], whofrom) - - filename_prefix = 'ExaLearner_Episodes%s_Steps%s_Rank%s_memory_v1' \ - % (str(workflow.nepisodes), str(workflow.nsteps), str(agent_comm.rank)) - workflow.agent.save(workflow.results_dir + '/' + filename_prefix + '.h5') - logger.info("Finishing up ...\n") - episode = -1 - for s in range(1, agent_comm.size): - recv_data = agent_comm.recv(None) - whofrom = recv_data[0] - step = recv_data[1] - batch = recv_data[2] - epsilon = recv_data[3] - done = recv_data[4] - logger.debug('step:{}'.format(step)) - logger.debug('done:{}'.format(done)) + This function sends the model from the learner to + other agents using MPI_Send. - # Train - train_return = workflow.agent.train(batch) - if train_return is not None: - indices, loss = train_return - workflow.agent.target_train() - # Save weights - if ExaComm.learner_comm.rank == 0: - target_weights = workflow.agent.get_weights() - workflow.agent.save(workflow.results_dir + '/target_weights.pkl') - agent_comm.send([episode, 0, 0, indices, loss], s) + Parameters + ---------- + workflow : ExaWorkflow + This contains the agent and env - logger.info("Learner time: {}".format(agent_comm.time() - start)) + episode : int + The current episode corresponding to the model generation - else: - if ExaComm.env_comm.rank == 0: - # Setup logger - filename_prefix = 'ExaLearner_Episodes%s_Steps%s_Rank%s_memory_v1' \ - % (str(workflow.nepisodes), str(workflow.nsteps), str(agent_comm.rank)) - train_file = open(workflow.results_dir + '/' + - filename_prefix + ".log", 'w') - train_writer = csv.writer(train_file, delimiter=" ") - - start = env_comm.time() - while episode != -1: - # Reset variables each episode - # workflow.env.seed(0) - # TODO: optimize some of these variables out for env processes - current_state = workflow.env.reset() - total_reward = 0 - steps = 0 - action = 0 - episode_reward_list = [] - - # Steps in an episode - while steps < workflow.nsteps: - logger.debug('ASYNC::run() agent_comm.rank{}; step({} of {})' - .format(agent_comm.rank, steps, (workflow.nsteps - 1))) - if ExaComm.env_comm.rank == 0: - # Receive target weights - recv_data = agent_comm.recv(None, source=0) - # Update episode while beginning a new one i.e. step = 0 - if steps == 0: - episode = recv_data[0] - # This variable is used for kill check - episode_interim = recv_data[0] + train_return : list + This is what comes out of the learner calling train to be sent back + to the actor (i.e. indices and losses). - # Broadcast episode within env_comm - episode_interim = env_comm.bcast(episode_interim, 0) - - if episode_interim == -1: - episode = -1 - if ExaComm.env_comm.rank == 0: - logger.info( - "Rank[%s] - Episode/Step:%s/%s" - % (str(agent_comm.rank), str(episode), str(steps)) - ) - break + dst : int + This is the destination rank given by the agent communicator + """ + data = [episode, workflow.agent.get_weights(), []] + if train_ret is not None: + data[-1].append([train_ret]) + ExaComm.agent_comm.send(data, dst) - send_data = False - done = False - while send_data == False and done == False: - if ExaComm.env_comm.rank == 0: - workflow.agent.epsilon = recv_data[1] - workflow.agent.set_weights(recv_data[2]) + def recv_model(self): + """ + This function receives the model from the learner + using MPI_Recv. + + Returns + ---------- + list : + This list should contain the episode, epsilon, model weights, + and the train return (indices and losses if turned on) + """ + ret = ExaComm.agent_comm.recv(None, source=0) + return ret - action, policy_type = workflow.agent.action(current_state) - ib.update("Async_Env_Inference", 1) + def send_batch(self, batch_data, policy_type, done, episode_reward): + """ + This function is used to send batches of data from the actor to the + learner using MPI_Send. - if workflow.action_type == "fixed": - action, policy_type = 0, -11 + Parameters + ---------- + batch_data : list + This is a list of experiences generate by the actor to send to + the learner. - # Broadcast episode count to all procs in env_comm - action = env_comm.bcast(action, root=0) + policy_type : int + This is the policy given by the actor performing inference to get an action - ib.startTrace("step", 0) - next_state, reward, done, _ = workflow.env.step(action) - ib.stopTrace() - ib.update("Async_Env_Step", 1) + done : bool + Indicates if the episode is competed - if ExaComm.env_comm.rank == 0: - total_reward += reward - # memory = ( - # current_state, - # action, - # reward, - # next_state, - # done, - # total_reward, - # ) - # workflow.agent.remember(memory[0], memory[1], memory[2], memory[3], memory[4]) - workflow.agent.remember(current_state, action, reward, next_state, done) + epsilon : float + Current epsilon value to send to learner - batch_data = next(workflow.agent.generate_data()) - ib.update("Async_Env_Generate_Data", 1) + episode_reward : float + The total reward from the last episode. If the episode in not done, it + will be the current total reward. + """ + ExaComm.agent_comm.send([ExaComm.agent_comm.rank, batch_data, policy_type, done, episode_reward], 0) - logger.info( - 'Rank[{}] - Generated data: {}'.format(agent_comm.rank, len(batch_data[0]))) - try: - buffer_length = len(workflow.agent.memory) - except: - buffer_length = workflow.agent.replay_buffer.get_buffer_length() - logger.info( - 'Rank[{}] - # Memories: {}'.format(agent_comm.rank, buffer_length)) + def recv_batch(self): + """ + This function receives batches of experiences sent from an actor + using MPI_Recv. + + Returns + ------- + list : + This list should contain the rank, batched data, policy type, and done flag. + The done flag indicates if the episode the actor was working on finished. + """ + return ExaComm.agent_comm.recv(None) - if steps >= workflow.nsteps - 1: - done = True + def init_learner(self, workflow): + """ + This function is used to initialize the model on every agent. + We are assuming a single learner starting the range from 1. - if ExaComm.env_comm.rank == 0: - # Send batched memories - if workflow.agent.has_data(): - send_data = True - agent_comm.send([agent_comm.rank, steps, batch_data, policy_type, done], 0) - indices, loss = recv_data[3:5] - if indices is not None: - workflow.agent.set_priorities(indices, loss) - logger.info('Rank[%s] - Total Reward:%s' % - (str(agent_comm.rank), str(total_reward))) - logger.info( - 'Rank[%s] - Episode/Step/Status:%s/%s/%s' % (str(agent_comm.rank), str(episode), str(steps), str(done))) + Parameters + ---------- + workflow : ExaWorkflow + This contains the agent and env + """ + for dst in range(1, ExaComm.agent_comm.size): + self.send_model(workflow, self.next_episode, None, dst) + self.episode_per_rank[dst] = self.next_episode + self.next_episode += self.batch_episode_frequency + self.alive += 1 - # TODO: make this configurable so we don't always suffer IO - train_writer.writerow([time.time(), current_state, action, reward, next_state, total_reward, - done, episode, steps, policy_type, workflow.agent.epsilon]) - train_file.flush() + @PROFILE + def run(self, workflow): + """ + This function is responsible for calling the appropriate initialization + and looping over the actor/learner functions. - # Update state and step - current_state = next_state - steps += 1 + Parameters + ---------- + workflow : ExaWorkflow + This contains the agent and env + """ + convergence = -1 + nepisodes = self.episode_round(workflow) - # Broadcast done - done = env_comm.bcast(done, 0) - # Break loop if done - if done: - break - episode_reward_list.append(total_reward) - # Mean of last 40 episodes - average_reward = np.mean(episode_reward_list[-40:]) - print("Episode * {} * Avg Reward is ==> {}".format(episode, average_reward)) - ib.update("Async_Env_Episode", 1) - logger.info("Worker time = {}".format(env_comm.time() - start)) - if ExaComm.is_actor(): - train_file.close() + # These are the loops used to keep everyone running + if ExaComm.is_learner(): + self.init_learner(workflow) + while self.alive > 0 and self.done_episode < nepisodes: + do_convergence_check = self.learner(workflow, nepisodes, 1) + if do_convergence_check: + convergence = self.check_convergence() + # self.debug("Learner:", self.done_episode, nepisodes, do_convergence_check, convergence) + else: + keep_running = True + while keep_running: + keep_running = self.actor(workflow, nepisodes) + # self.debug("Actor:", keep_running) diff --git a/exarl/workflows/workflow_vault/random_learner.py b/exarl/workflows/workflow_vault/random_learner.py index f51bfb2b..66080433 100644 --- a/exarl/workflows/workflow_vault/random_learner.py +++ b/exarl/workflows/workflow_vault/random_learner.py @@ -18,91 +18,83 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 -import exarl as erl -import pandas as pd import csv +import time +import pandas as pd from os.path import join +import exarl from exarl.base.comm_base import ExaComm -import tensorflow as tf -from exarl.utils import log -import exarl.utils.candleDriver as cd -from exarl.utils.profile import * -from exarl.utils.introspect import * -from exarl.network.simple_comm import ExaSimple -MPI = ExaSimple.MPI - -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) - -class RANDOM(erl.ExaWorkflow): - """Random workflow class: inherits from Exaworkflow base class. - Used for testing inference against random actions. +from exarl.utils.globals import ExaGlobals +class RANDOM(exarl.ExaWorkflow): + """ + Random workflow class: inherits from Exaworkflow base class. + Used for testing inference against random actions. """ def __init__(self): - """Random workflow class constructor. The weight file gets loaded for + """ + Random workflow class constructor. The weight file gets loaded for inference. """ print('Class Random learner') - data_dir = cd.lookup_params("output_dir", ".") - data_file = cd.lookup_params("random_results_file", "random_learner_out.txt") - self.load_data = cd.lookup_params("weight_file") + data_dir = ExaGlobals.lookup_params("output_dir") + data_file = ExaGlobals.lookup_params("random_results_file") + self.load_data = ExaGlobals.lookup_params("weight_file") if self.load_data == "None": self.load_data = None self.out_file = join(data_dir, data_file) - def run(self, workflow): - """This function implements the random workflow in EXARL. + def run(self, exalearner): + """ + This function implements the random workflow in EXARL. Args: - workflow (ExaLearner type object): The ExaLearner object is used to access + exalearner (ExaLearner type object): The ExaLearner object is used to access different members of the base class. - - Returns: - None """ agent_comm = ExaComm.agent_comm env_comm = ExaComm.env_comm - episodesPerActor = int(workflow.nepisodes / (agent_comm.size - 1)) - if workflow.nepisodes % (agent_comm.size - 1): + episodesPerActor = int(exalearner.nepisodes / (agent_comm.size - 1)) + if exalearner.nepisodes % (agent_comm.size - 1): episodesPerActor += 1 df = pd.DataFrame(columns=['rank', 'episode', 'step', 'reward', 'totalReward', 'done']) if self.load_data is not None: if ExaComm.is_learner(): - workflow.agent.load(self.load_data) + exalearner.agent.load(self.load_data) - target_weights = workflow.agent.get_weights() + target_weights = exalearner.agent.get_weights() target_weights = agent_comm.bcast(target_weights, 0) if not ExaComm.is_learner(): - workflow.agent.set_weights(target_weights) + exalearner.agent.set_weights(target_weights) if not ExaComm.is_learner(): if ExaComm.env_comm.rank == 0: # Setup logger filename_prefix = 'ExaLearner_Episodes%s_Steps%s_Rank%s_memory_v1' \ - % (str(workflow.nepisodes), str(workflow.nsteps), str(agent_comm.rank)) - train_file = open(workflow.results_dir + '/' + + % (str(exalearner.nepisodes), str(exalearner.nsteps), str(agent_comm.rank)) + train_file = open(exalearner.results_dir + '/' + filename_prefix + ".log", 'w') train_writer = csv.writer(train_file, delimiter=" ") for episode in range(episodesPerActor): total_reward = 0 - current_state = workflow.env.reset() + current_state = exalearner.env.reset() - for step in range(workflow.nsteps): + for step in range(exalearner.nsteps): if ExaComm.env_comm.rank == 0: if self.load_data is None: - action = workflow.env.action_space.sample() + action = exalearner.env.action_space.sample() else: - action, _ = workflow.agent.action(current_state) + action, _ = exalearner.agent.action(current_state) action = env_comm.bcast(action, 0) - next_state, reward, done, _ = workflow.env.step(action) + next_state, reward, done, _ = exalearner.env.step(action) current_state = next_state - if step + 1 == workflow.nsteps: + if step + 1 == exalearner.nsteps: done = True done = env_comm.bcast(done, 0) @@ -110,7 +102,7 @@ def run(self, workflow): total_reward += reward train_writer.writerow([time.time(), current_state, action, reward, next_state, total_reward, - done, episode, step, 1, workflow.agent.epsilon]) + done, episode, step, 1, exalearner.agent.epsilon]) train_file.flush() df = df.append({'rank': agent_comm.rank, 'episode': episode, 'step': step, 'reward': reward, diff --git a/exarl/workflows/workflow_vault/rma_learner.py b/exarl/workflows/workflow_vault/rma_learner.py index 24b921e5..08913b10 100644 --- a/exarl/workflows/workflow_vault/rma_learner.py +++ b/exarl/workflows/workflow_vault/rma_learner.py @@ -18,271 +18,207 @@ # for the # UNITED STATES DEPARTMENT OF ENERGY # under Contract DE-AC05-76RL01830 - -import time -import csv -import numpy as np -from tensorflow.python.ops.gen_batch_ops import batch -import exarl as erl -from exarl.utils.introspect import * -from exarl.utils.profile import * -from exarl.utils import log -import exarl.utils.candleDriver as cd from exarl.base.comm_base import ExaComm +from exarl.workflows.workflow_vault.async_learner import ASYNC from exarl.network.data_structures import * -from exarl.network.simple_comm import ExaSimple -MPI = ExaSimple.MPI - -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) - -class RMA(erl.ExaWorkflow): - """RMA workflow class: inherits from ExaWorkflow base class. - The RMA worflow uses one-sided MPI communication for exchanging data - between learners and actors. The data is written into an RMA window or - ”memory pool” and the learners and actors can read/write from this pool, - independent of each other. +from exarl.utils.profile import PROFILE +from exarl.utils.globals import ExaGlobals +class RMA(ASYNC): + """ + TODO: Write description / notes """ - def __init__(self): - """RMA class constructor. Contrains a list of different data structures - that can be used for the "memory pool". - - """ - print("Creating RMA workflow") - data_exchange_constructors = { - "buff_unchecked": ExaMPIBuffUnchecked, - "buff_checked": ExaMPIBuffChecked, - "queue_distribute": ExaMPIDistributedQueue, - "stack_distribute": ExaMPIDistributedStack, - "queue_central": ExaMPICentralizedQueue, - "stack_central": ExaMPICentralizedStack - } - # target weights - This should be an unchecked buffer that will always succed a pop since weight need to be shared with everyone - self.target_weight_data_structure = data_exchange_constructors[cd.lookup_params('target_weight_structure', default='buff_unchecked')] - - # Batch data - self.batch_data_structure = data_exchange_constructors[cd.lookup_params('data_structure', default='buff_unchecked')] - self.de_length = cd.lookup_params('data_structure_length', default=32) - self.de_lag = None # cd.lookup_params('max_model_lag') - logger.info("Creating RMA data exchange workflow", cd.lookup_params('data_structure', - default='buff_unchecked'), "length", self.de_length, "lag", self.de_lag) - - # Loss and indicies - self.de = cd.lookup_params('loss_data_structure', default='buff_unchecked') - self.ind_loss_data_structure = data_exchange_constructors[cd.lookup_params('loss_data_structure', default='buff_unchecked')] - logger.info('Creating RMA loss exchange workflow with ', self.de) - - priority_scale = cd.lookup_params('priority_scale', 0) - self.use_priority_replay = (priority_scale is not None and priority_scale > 0) - - @PROFILE - def run(self, workflow): - """ This function implements the RMA workflow in EXARL using one-sided - MPI communication. - - Args: - workflow (ExaLearner type object): The ExaLearner object is used to access - different members of the base class. - - Returns: - None - """ - # Number of learner processes - num_learners = ExaComm.num_learners - - # MPI communicators - agent_comm = ExaComm.agent_comm - env_comm = ExaComm.env_comm + def __init__(self, agent=None, env=None): + super(RMA, self).__init__() + self.debug('Creating RMA learner!') + + # self.model_size = 1024 + # self.train_ret_size = 1024 + # self.exp_data_size = 1024 + # ExaGlobals.lookup_params('poop') + assert hasattr(agent, "rma_model"), "Agent must have rma_model to use rma" + assert hasattr(agent, "rma_train_ret"), "Agent must have rma_train_ret to use rma" + assert hasattr(agent, "rma_exp_data"), "Agent must have rma_exp_data to use rma" + + # JS: Model + self.model_buff = ExaMPIBuffUnchecked(ExaComm.agent_comm, agent.rma_model, rank_mask=True, name="model") + self.episode_const = ExaMPIConstant(ExaComm.agent_comm, True, int, name="episode") + self.train_ret_buff = ExaMPIDistributedQueue(ExaComm.agent_comm, (0, agent.rma_train_ret), length=1, rank_mask=True, name="episode") + + # JS: Exps + self.rma_exp_data = [ExaComm.agent_comm.rank, agent.rma_exp_data, 0, False, 0.0] + self.data_queue = ExaMPIDistributedQueue(ExaComm.agent_comm, self.rma_exp_data, rank_mask=True, name="experience") + + # JS: Next episode if ExaComm.is_learner(): - learner_comm = ExaComm.learner_comm - - # Allocate RMA windows - if ExaComm.is_agent(): - episode_const = ExaMPIConstant(agent_comm, ExaComm.is_learner() and learner_comm.rank == 0, np.int64, name="Episode_Const") - epsilon_const = ExaMPIConstant(agent_comm, ExaComm.is_learner() and learner_comm.rank == 0, np.float64, name="Epsilon_Const") - - if self.use_priority_replay: - # Create windows for priority replay (loss and indicies) - indices_for_size = -1 * np.ones(workflow.agent.batch_size, dtype=np.intc) - loss_for_size = np.zeros(workflow.agent.batch_size, dtype=np.float64) - indicies_and_loss_for_size = (indices_for_size, loss_for_size) - ind_loss_buffer = self.ind_loss_data_structure(agent_comm, indicies_and_loss_for_size, rank_mask=ExaComm.is_actor(), - length=num_learners, max_model_lag=None, name="Loss_Buffer") - - # Get serialized target weights size - learner_counter = np.int64(0) - target_weights = (workflow.agent.get_weights(), learner_counter) - model_buff = self.target_weight_data_structure(agent_comm, target_weights, rank_mask=ExaComm.is_learner() and - learner_comm.rank == 0, length=1, max_model_lag=None, failPush=False, name="Model_Buffer") - - # Get serialized batch data size - learner_counter = np.int64(0) - agent_batch = (next(workflow.agent.generate_data()), learner_counter) - batch_data_exchange = self.batch_data_structure(agent_comm, agent_batch, rank_mask=ExaComm.is_actor(), - length=self.de_length, max_model_lag=self.de_lag, name="Data_Exchange") - # This is a data/flag that lets us know we have data - agent_data = None + self.next_episode_const = ExaMPIConstant(ExaComm.learner_comm, True, int, inc=self.batch_episode_frequency, name="next episode") - # Synchronize - agent_comm.barrier() - - # Learner + # JS: This is to reduce times we update + self.last_model_sent = None + self.last_model_recv = None + self.last_episode_per_rank = None if ExaComm.is_learner(): - # Initialize counter - episode_count_learner = 0 - if learner_comm.rank == 0: - epsilon_const.put(workflow.agent.epsilon, 0) - - while True: - # Define flags to keep track of data - process_has_data = 0 - sum_process_has_data = 0 - - if learner_comm.rank == 0: - episode_count_learner = episode_const.get(0) - - if num_learners > 1: - episode_count_learner = learner_comm.bcast(episode_count_learner, root=0) - - if episode_count_learner >= workflow.nepisodes: - break - - if agent_data is None: - agent_data, actor_idx, actor_counter = batch_data_exchange.get_data( - learner_counter, learner_comm.size, agent_comm.size) - ib.update("RMA_Learner_Pop_Data", 1) - ib.simpleTrace("RMA_Learner_Get_Data", actor_idx, actor_counter, learner_counter - actor_counter, 0) + self.last_episode_per_rank = [None] * ExaComm.agent_comm.size - # Check the data_buffer again if it is empty - if agent_data is not None: - process_has_data = 1 - - # Do an allreduce to check if all learners have data - sum_process_has_data = learner_comm.allreduce(process_has_data, op=MPI.SUM) - if sum_process_has_data < learner_comm.size: - continue - - train_return = workflow.agent.train(agent_data) - ib.update("RMA_Learner_Train", 1) - - if self.use_priority_replay and train_return is not None: - if not np.array_equal(train_return[0], (-1 * np.ones(workflow.agent.batch_size))): - indices, loss = train_return - indices = np.array(indices, dtype=np.intc) - loss = np.array(loss, dtype=np.float64) - # Write indices to memory pool - ind_loss_buffer.push((indices, loss), rank=actor_idx) - ib.update("RMA_Learner_Loss_Push", 1) - learner_counter += 1 - agent_data = None - - if ExaComm.is_learner() and learner_comm.rank == 0: - workflow.agent.target_train() - ib.update("RMA_Learner_Target_Train", 1) - # Share new model weights - target_weights = (workflow.agent.get_weights(), learner_counter) - model_buff.push(target_weights, rank=0) - ib.update("RMA_Learner_Model_Push", 1) - - logger.info('Learner exit on rank_episode: {}_{}'.format(agent_comm.rank, episode_count_learner)) - - # Actors - else: - local_actor_episode_counter = 0 - if env_comm.rank == 0: - # Logging files - filename_prefix = 'ExaLearner_' + 'Episodes%s_Steps%s_Rank%s_memory_v1' \ - % (str(workflow.nepisodes), str(workflow.nsteps), str(agent_comm.rank)) - train_file = open(workflow.results_dir + '/' + filename_prefix + ".log", 'w') - train_writer = csv.writer(train_file, delimiter=" ") - - while True: - if env_comm.rank == 0: - episode_count_actor = episode_const.inc(0) + def send_model(self, workflow, episode, train_ret, dst): + """ + This function sends the model from the learner to + other agents using MPI_Send. - episode_count_actor = env_comm.bcast(episode_count_actor, root=0) + Parameters + ---------- + workflow : ExaWorkflow + This contains the agent and env - # Check if we are done based on the completed episodes - if episode_count_actor >= workflow.nepisodes: - break - logger.info('Rank[{}] - working on episode: {}'.format(agent_comm.rank, episode_count_actor)) + episode : int + The current episode corresponding to the model generation - # Episode initialization - # workflow.env.seed(0) - current_state = workflow.env.reset() - total_rewards = 0 - steps = 0 - action = 0 - done = False - local_actor_episode_counter += 1 + train_return : list + This is what comes out of the learner calling train to be sent back + to the actor (i.e. indices and losses). - while done != True: - if env_comm.rank == 0: - # Update model weight - target_weights, learner_counter = model_buff.pop(0) - ib.update("RMA_Env_Model_Pop", 1) - workflow.agent.set_weights(target_weights) - ib.simpleTrace("RMA_Actor_Get_Model", local_actor_episode_counter, learner_counter, 0, 0) + dst : int + This is the destination rank given by the agent communicator + """ + model = workflow.agent.get_weights() + # JS: The order here matters + # We are sending the a modified train ret last + # so we can spin on it when we really want a new model + + # JS: Send the new episode count to agent + if self.last_episode_per_rank[dst] != episode: + self.episode_const.put(episode, rank=dst) + self.last_episode_per_rank[dst] = episode + # JS: Push data to our local buffer let agents pull from us + if self.last_model_sent != self.model_count: + self.model_buff.push(model) + self.last_model_sent = self.model_count + # JS: We will use train_ret for blocking... + lost = 1 + while lost: + capacity, lost = self.train_ret_buff.push((self.model_count, train_ret), dst) + + def recv_model(self): + """ + This function receives the model from the learner + using MPI_Recv. + + Returns + ---------- + list : + This list should contain the episode, model weights, + and the train return (indices and losses if turned on) + """ + train_ret = None + while train_ret is None: + train_ret = self.train_ret_buff.pop(ExaComm.agent_comm.rank) + self.last_model_recv, train_ret = train_ret + + episode = self.episode_const.get() + model = self.model_buff.pop(0) + + ret = [episode, model, []] + if train_ret is not None: + ret[-1].append(train_ret) + return ret + + def send_batch(self, batch_data, policy_type, done, episode_reward): + """ + This function is used to send batches of data from the actor to the + learner using MPI_Send. - workflow.agent.epsilon = epsilon_const.min(workflow.agent.epsilon, 0) + Parameters + ---------- + batch_data : list + This is a list of experiences generate by the actor to send to + the learner. - if self.use_priority_replay: - # Get indices and losses - loss_data = ind_loss_buffer.pop(agent_comm.rank) - ib.update("RMA_Env_Loss_Pop", 1) - # print("loss data = ", loss_data, flush=True) - if loss_data is not None: - indices, loss = loss_data - if self.de == "buff_unchecked": - if not np.array_equal(indices, (-1 * np.ones(workflow.agent.batch_size, dtype=np.intc))): - workflow.agent.set_priorities(indices, loss) - else: - workflow.agent.set_priorities(indices, loss) + policy_type : int + This is the policy given by the actor performing inference to get an action - # Inference action - action, policy_type = workflow.agent.action(current_state) - ib.update("RMA_Env_Inference", 1) - if workflow.action_type == 'fixed': - action, policy_type = 0, -11 + done : bool + Indicates if the episode is competed - # Broadcast episode count to all procs in env_comm - action = env_comm.bcast(action, 0) + episode_reward : float + The total reward from the last episode. If the episode in not done, it + will be the current total reward. + """ + self.data_queue.push([ExaComm.agent_comm.rank, batch_data, policy_type, done, episode_reward], 0) - # Environment step - ib.startTrace("step", 0) - next_state, reward, done, _ = workflow.env.step(action) - ib.stopTrace() - ib.update("RMA_Env_Step", 1) - ib.simpleTrace("RMA_Reward", steps, 1 if done else 0, local_actor_episode_counter, reward) + def recv_batch(self): + """ + This function receives batches of experiences sent from an actor + using MPI_Recv. + + Returns + ------- + list : + This list should contain the rank, batched data, policy type, and done flag. + The done flag indicates if the episode the actor was working on finished. + """ + ret = None + while ret is None: + ret = self.data_queue.pop(0) + return ret - # Update current state and steps count - current_state = next_state - steps += 1 - if steps >= workflow.nsteps: - done = True - # Broadcast done - done = env_comm.bcast(done, 0) + def init_learner(self, workflow): + """ + This function is used to initialize the model on every agent. + We are assuming a single learner starting the range from 1. - if env_comm.rank == 0: - # Save memory - total_rewards += reward - workflow.agent.remember(current_state, action, reward, next_state, done) - if workflow.agent.has_data(): - batch_data = (next(workflow.agent.generate_data()), learner_counter) - ib.update("RMA_Env_Generate_Data", 1) - # Write to data window - capacity, lost = batch_data_exchange.push(batch_data) - ib.update("RMA_Env_Push_Data", 1) - ib.simpleTrace("RMA_Actor_Put_Data", capacity, lost, 0, 0) + Parameters + ---------- + workflow : ExaWorkflow + This contains the agent and env + """ + if ExaComm.is_learner() and ExaComm.learner_comm.rank == 0: + self.model_buff.push(workflow.agent.get_weights()) + for dst in range(1, ExaComm.agent_comm.size): + self.episode_const.put(self.next_episode, rank=dst) + self.train_ret_buff.push((self.model_count, None), dst) + self.episode_per_rank[dst] = self.next_episode + self.next_episode += self.batch_episode_frequency + self.alive += 1 + self.next_episode_const.put(self.next_episode, rank=0) + + # JS: Try to barrier to ensure weights are out + ExaComm.agent_comm.barrier() + + def inc_episode(self): + """ + We abstract this increment for future workflows (RMA) which + need to synchronize this value. + """ + self.next_episode = self.next_episode_const.inc(rank=0) + return self.next_episode - # Log state, action, reward, ... - train_writer.writerow([time.time(), current_state, action, reward, next_state, total_rewards, - done, local_actor_episode_counter, steps, policy_type, workflow.agent.epsilon]) - train_file.flush() - ib.update("RMA_Env_Episode", 1) + @PROFILE + def run(self, workflow): + """ + This function is responsible for calling the appropriate initialization + and looping over the actor/learner functions. - # mpi4py may miss MPI Finalize sometimes -- using a barrier - agent_comm.barrier() - if ExaComm.is_actor(): - train_file.close() + Parameters + ---------- + workflow : ExaWorkflow + This contains the agent and env + """ + convergence = -1 + nepisodes = self.episode_round(workflow) + self.init_learner(workflow) + last_print = 0 + # These are the loops used to keep everyone running + if ExaComm.is_learner(): + while self.alive > 0 and self.done_episode < nepisodes: + do_convergence_check = self.learner(workflow, nepisodes, 1) + if do_convergence_check: + convergence = self.check_convergence() + if self.done_episode % 10 == 0 and self.done_episode != last_print: + print("Learner:", self.done_episode, nepisodes, do_convergence_check, convergence, flush=True) + last_print = self.done_episode + else: + keep_running = True + while keep_running: + keep_running = self.actor(workflow, nepisodes) + # print("Actor:", keep_running, flush=True) \ No newline at end of file diff --git a/exarl/workflows/workflow_vault/sync_learner.py b/exarl/workflows/workflow_vault/sync_learner.py index f5198177..b2b2aafe 100644 --- a/exarl/workflows/workflow_vault/sync_learner.py +++ b/exarl/workflows/workflow_vault/sync_learner.py @@ -20,124 +20,792 @@ # under Contract DE-AC05-76RL01830 import time import csv -import exarl as erl +import numpy as np +import exarl +from exarl.utils.globals import ExaGlobals from exarl.base.comm_base import ExaComm -from exarl.utils import log -import exarl.utils.candleDriver as cd -from exarl.utils.profile import * -logger = log.setup_logger(__name__, cd.lookup_params('log_level', [3, 3])) - - -class SYNC(erl.ExaWorkflow): - """Synchronous workflow class: inherits from the ExaWorkflow base class. - It features a single learner and multiple actors. The MPI processes are statically - launched and are split into multiple groups. The environment processes can be set - during launchtime as a candle parameter and runs multiple multi-process environments. - The experiences generated by the environments are gathered and sent to learner for - training. +from exarl.network.typing import TypeUtils +from exarl.utils.profile import PROFILE +from exarl.utils.introspect import introspect + +class SYNC(exarl.ExaWorkflow): """ + This class implements a workflow by breaking the functionality into pieces. + We define 3 key terms used throughout the implementation/documentation: - def __init__(self): - print('Class SYNC learner') + Learner - the rank responsible for running the train/target train functions. + Agents - the ranks responsible for training/inference. Agents include learners. + Actors - everyone that is not a learner. - @PROFILE - def run(self, workflow): - """This function implements the synchronous workflow in EXARL and uses MPI - collective communication. + In addition to this there is the environment comm which includes an agent and + actors. + + The following is an example useful for understanding the above descriptions. + The example assumes 14 ranks (2 Learners, 5 Agents, 4 Environment) + We present both the comms and the ranks. + There is no actor comm so we add * to depict actors. + Rank 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 + Learn 0 1 - - - - - - - - - - - - + Agent 0 1 2 - - - 3 - - - 4 - - - + Actor - - * * * * * * * * * * * * + Envir - - 0 1 2 3 0 1 2 3 0 1 2 3 + + For a single rank execution, global rank 0 is the learner, agent, and environment. + + There are two possible cut-off conditions that this workflow respects: + + 1. The first cut-off condition for this is based on how many completed (done) + episodes the learner observes. + + 2. The second is based on learning convergence. This is configured via the config + files using the rolling reward length and cutoff settings. We determine if we + have converged by looking at the rolling average of the absolute value of the + differences across the last N number of episodes. If this value is <= the config + cutoff value, we terminate execution. To turn the cutoff off + set the cutoff configuration to -1. + + We have two sets of internal variables one set used by the learners and another + used by the actors. Batches and weights are passed via the leaner and actor calls + by setting self.batch and self.weights. + + We maintain a distinction between learner and agent variables even in the single + rank such that this can serve as a base class for future workflows. The actor + and learner functions should remain unchanged. The easiest changes should be + made to the send/recv, init_learner, and run functions. + + TODO: + - Add multi-learner - We can think if this should be in this class or in + a inherited class. + + Attributes + ---------- + block_size : int + This is used to indicate we want on-policy learning + and is used by the learner. When we want on-policy + learning we set this to the total number of agents. + We can allow off-policy learning by setting + the value to one. For sequential learning this + is set to one. + + batch_step_frequency : int + This value is used to determine how often we should + send a batch of data within an episode. The value + represents performing batch_step_frequency steps + per 1 batch send. + + batch_episode_frequency : int + This indicates how many episodes an actor should run before sending + its results to the learner. This features is required by sum learning + algorithms (i.e. rollout). + + log_frequency : int + This indicates how often we should write to the log. Logging + can be costly in time. + + clip_rewards : list + This variable indicates if rewards should be clipped to a space + of -1 to 1. + + next_episode : int + This value is used by the learner to keep track of + what the next episode to run is. + + done_episode : int + This is a counter of how many episodes have been + finished used by the learner. + + episode_per_rank : list + This is a list of ints that indicate what episode + each rank is working on. This is used by the learner. + + total_reward : int + This is the sum of rewards for the current episode. + This is used by an actor. + + steps : int + This is the current step within an episode. + This is used by the actor + + done : bool + This flag indicates if the episode is done. + This is used by the actor. + + current_state : + This is the current state of an environment for + a given actor. + + model_count : int + This is the current generation of the model. This counter + is set on the learner. It is up to the send/recv to + propagate this to the actors. + + save_weight_per_episode : bool + This will cause the workflow to save the weights for each + learner model generation. + + filename_prefix : string + Prefix of the log file. + + train_file : file + File we use to write logs to. + + train_writer : csv.writer + Logger that writes to train_file. + + episode_reward_list : list + This store total reward at the end of an episode. + + cutoff : float + This is the minimum value of absolute difference between the + last rolling_reward_length episodes required to consider + learning to have converged. Set to -1 to turn off the + convergence cutoff. + + rolling_reward_length : + The last number of episodes to consider to a + rolling average reward + + converged : bool + Indicates if learning convergence has been reached + + alive : + Counter of the number of actors that have not finished. + + verbose : bool + Debug print flag + + + """ + verbose = False + + def __init__(self, agent=None, env=None): + self.debug('Creating SYNC', ExaComm.global_comm.rank, ExaComm.is_learner(), ExaComm.is_agent(), ExaComm.is_actor()) + + self.block_size = 1 + block = TypeUtils.get_bool(ExaGlobals.lookup_params('episode_block')) + if block: + if ExaComm.global_comm.rank == 0: + self.block_size = ExaComm.agent_comm.size + self.block_size = ExaComm.global_comm.bcast(self.block_size, 0) + + # How often do we send batches + self.batch_episode_frequency = ExaGlobals.lookup_params('batch_episode_frequency') + if self.batch_episode_frequency <= 1: + self.batch_step_frequency = ExaGlobals.lookup_params('batch_step_frequency') + # Handles if < 1 was passed. Must be at least 1 + self.batch_episode_frequency = 1 + else: + # This is for multi-episode agents. We will set the batch_step_frequency + # to -1 since we only want to send full episodes. + self.batch_step_frequency = -1 + + # If it is set to -1 then we only send an update when the episode is over + if self.batch_step_frequency == -1: + self.batch_step_frequency = ExaGlobals.lookup_params('n_steps') + + # How often to write logs (in episodes) + self.log_frequency = ExaGlobals.lookup_params('log_frequency') + # If it is set to -1 then we only log at the end of the run + if self.log_frequency == -1: + self.log_frequency = ExaGlobals.lookup_params('n_episodes') + + self.clip_rewards = ExaGlobals.lookup_params('clip_rewards') + if not self.clip_rewards: + self.clip_rewards = None + elif self.clip_rewards == True: + self.clip_rewards = [-1, 1] + + # Learner episode counters + self.next_episode = 0 + self.done_episode = 0 + self.episode_per_rank = None + self.train_return = None + if ExaComm.is_learner(): + self.episode_per_rank = [0] * ExaComm.agent_comm.size + self.train_return = [None] * ExaComm.agent_comm.size + + # Actor counters + self.total_reward = 0 + self.steps = 0 + self.done = True + self.current_state = None - Args: - workflow (ExaLearner type object): The ExaLearner object is used to access - different members of the base class. + # Learner counters + self.model_count = 0 - Returns: - None + # Initialize logging + self.init_logging() + + # Save weights after each episode + self.save_weights_per_episode = TypeUtils.get_bool(ExaGlobals.lookup_params('save_weights_per_episode')) + + # Check this for convergence + self.episode_reward_list = [] + self.cutoff = ExaGlobals.lookup_params('cutoff') + self.rolling_reward_length = ExaGlobals.lookup_params('rolling_reward_length') + self.converged = False + self.alive = 0 + + def debug(self, *args): + """ + Function to turn on and off debug print statements + """ + if SYNC.verbose: + print("[", self.__class__.__name__, ExaComm.global_comm.rank, "]", *args, flush=True) + + def init_logging(self): + """ + Initialize the logging on rank 0. + """ + # Get parameters + self.results_dir = ExaGlobals.lookup_params('output_dir') + self.nepisodes = ExaGlobals.lookup_params('n_episodes') + self.nsteps = ExaGlobals.lookup_params('n_steps') + + # Do the initialization + if ExaComm.is_agent(): + self.filename_prefix = 'ExaLearner_Episodes%s_Steps%s_Rank%s_memory_v1' % (str(self.nepisodes), str(self.nsteps), str(ExaComm.agent_comm.rank)) + self.train_file = open(self.results_dir + '/' + self.filename_prefix + ".log", 'w') + self.train_writer = csv.writer(self.train_file, delimiter=" ") + self.data_matrix = [] + + def write_log(self, current_state, action, reward, next_state, total_reward, done, episode, steps, policy_type): + """ + Rank zero writes the input data to the log file. + + Parameters + ---------- + current_state : gym.space + The state from the observation space at the current step + + action : gym.space + The action from the action space given via inference + + reward : float + The value of the state transition given by the environment + performing a step + + next_state : gym.space + The resulting state after performing action on current observation space + + total_reward : float + This is the cumulative reward for within an episode + + done : bool + Flag indicated the episode ended + + episode : int + Current episode to log + + steps : int + This is the current step within an episode + + policy_type : int + This value is given by the action. + """ + if ExaComm.is_agent(): + self.data_matrix.append([time.time(), current_state, action, reward, next_state, total_reward, done, episode, steps, policy_type]) + if done or self.converged: + if (episode == (self.nepisodes - 1)) or ((episode + 1) % self.log_frequency == 0) or self.converged: + self.train_writer.writerows(self.data_matrix) + self.train_file.flush() + self.data_matrix = [] + + def save_weights(self, exalearner, episode, nepisodes): """ - env_comm = ExaComm.env_comm + This function is a wrapper around save weights. If save_weights_per_episode flag + is set in configuration, we will store all the weights for each model generation. + Otherwise, we just record the final weights. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + + episode : int + Current episode to index weights by + + nepisodes : int + Total number of episodes to be performed + """ + if self.save_weights_per_episode and episode != nepisodes: + exalearner.agent.save(exalearner.results_dir + '/' + self.filename_prefix + '_' + str(episode) + '.h5') + elif episode == nepisodes or self.converged: + exalearner.agent.save(exalearner.results_dir + '/' + self.filename_prefix + '.h5') + + # TODO: What to do about dst? + @introspect + def send_model(self, exalearner, episode, train_return, dst): + """ + This function is responsible for sending the model from the learner to + other agents. For the sync learner, we just store the weights in the workflow. + For more interesting workflows, this should include an MPI send or RMA operation. + We intend for this function is to be overloaded in subsequent workflows. + + The workflow expects a message containing the episode, and the model weights. + To use the learner and actor functions, this must be respected. Otherwise, it + one will need to rewrite those functions in a derived class. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + + episode : int + The current episode corresponding to the model generation + + train_return : list + This is what comes out of the learner calling train to be sent back + to the actor (i.e. indices and losses). + + dst : int + This is the destination rank given by the agent communicator + """ + weights = exalearner.agent.get_weights() + self.weights = [episode, weights, []] + if train_return: + self.weights[-1].append(train_return) + + @introspect + def recv_model(self): + """ + This function is the corresponding receive function to + the send_model function. Here the weights are being received by the + the other agents (sent from the learner). For the sync learner + we retrieve this data which is stored locally, however this function is + to be overloaded for more interesting workflows. + + Returns + ------- + list : + This list should contain the episode, model weights, + and the train return (indices and losses if turned on) + """ + return self.weights + + @introspect + def send_batch(self, batch_data, policy_type, done, episode_reward): + """ + This function is used to send batches of data from the actor to the + learner. For the sync learner, data is being stored locally. This + function is intended to be overwritten by future workflows. + + Parameters + ---------- + batch_data : list + This is a list of experiences generate by the actor to send to + the learner. + + policy_type : int + This is the policy given by the actor performing inference to get an action + + done : bool + Indicates if the episode is competed + episode_reward : float + The total reward from the last episode. If the episode in not done, it + will be the current total reward. + """ + self.batch = [ExaComm.agent_comm.rank, batch_data, policy_type, done, episode_reward] + + @introspect + def recv_batch(self): + """ + This function is the corresponding receive function to the send_batch + function. Here the batch data is received by the learner + (sent from an actor). Again for the sync learner we retrieve this + data which is stored locally, however this function is to be overloaded + for more interesting workflows. + + Returns + ------- + list : + This list should contain the rank, batched data, policy type, and done flag. + The done flag indicates if the episode the actor was working on finished. + """ + return self.batch + + @introspect + def reset_env(self, exalearner): + """ + This function resets an environment if the done flag has been set. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + """ + if self.done: + self.total_reward = 0 + self.steps = 0 + self.done = False + self.current_state = exalearner.env.reset() + + def init_learner(self, exalearner): + """ + This function is used to initialize the model on every agent. The learner + is responsible for sending out the model to each actor. The actors will + read in the values in the actor function. The learner uses the + episode_per_rank to keep track of which rank each episode is running and + used next_episode to record which episode is next to send to an actor. + + We use episode_per_rank to store the current episode for when we batch + the model updates ensuring on-policy learning. We will determine we + are finished by evaluating the done_episodes NOT episode_per_rank or + next episode. + + For this sync learning we are assuming that the learner and actor + are running on the same rank. In this case we only care about + episode_per_rank[0]. This function should be overwritten for the + multi-agent case which should iterate over the agent comm and update + the episode_per_rank[i] where i is the agent_comm.rank. + + The alive variable is used to know how many actors are still running. + This is important when a cutoff or number of done episodes is reached. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + """ + if ExaComm.is_learner(): + # We are assuming there is only one right here + self.episode_per_rank[0] = self.next_episode + self.send_model(exalearner, self.next_episode, None, 0) + self.next_episode += self.batch_episode_frequency + self.alive += 1 + + def check_convergence(self): + """ + This function checks if our learning performance has converged. + We consider this to converge if the past N episodes and an average + absolute difference less than some configurable cutoff. To use the + convergence check, set the rolling_reward_length > 1 (config variable) + and set the desired minimum via cutoff configuration variable. To + turn off set the cutoff to -1. + + Returns + ------- + float : + The average absolute difference if checking for convergence, -1 otherwise + """ + # Lets us know how we are doing + if self.cutoff > 0 and self.rolling_reward_length > 1 and not self.converged: + if len(self.episode_reward_list) >= self.rolling_reward_length: + ave = np.mean(np.abs(np.diff(np.array(self.episode_reward_list[-self.rolling_reward_length:])))) + if ave < self.cutoff: + self.converged = True + print("Converged:", len(self.episode_reward_list), "Alive:", self.alive, "Ave:", ave, "Last:", self.episode_reward_list[-1]) + return ave + return -1 + + def inc_episode(self): + """ + We abstract this increment for future workflows (RMA) which + need to synchronize this value. + + Returns + ------- + int : + The next episode index + """ + ret = self.next_episode + self.next_episode += self.batch_episode_frequency + return ret + + @introspect + def learner(self, exalearner, nepisodes, start_rank): + """ + This function is performed by the learner. The learner + performs the following key steps: + + 1. Receives batches of experiences + 2. Trains the models on the data received + 3. Checks if an episode has finished + 4. Sends data back to the appropriate actors + + Each call to train/target train represents a new model + generation. On-policy learning means that the experiences + contained by the batch are from the previous model (i.e. + there is only one generation of models between them). + Off-policy learning is done when experiences are used from + previous model generations to train. Training with a + single actor will result in on-policy learning. When we + scale to use multiple actors we will by definition be + training with older models. If we were to collect data + from each actor round robin with N actors, the model would + be off policy by N models. This assumes we collect the + experiences from each actor and train one at a time. + + The block_size variable is to approximate on-policy learning + with multiple actors. By setting block_size to the number of + actors, we will only send a new identical model to all actors + after we have received and processed data from each actor. + + The start_rank is used to indicate the first rank actor rank + in the agent comm. For sync learner this is rank 0 since + the learner and actor are on the same rank. For others this + should correlate to the number of learners. + + In summary: + + For single-actor: + start_rank = 0 + block_size = 1 + + For multi-actor + start_rank = number of learners + For blocking (on-policy) + block_size = size of agent_comm + For non-blocking (off-policy) + block_size = number of learners + 1 + + Ideally this function should not have to be overloaded. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + + nepisodes : int + The number of episodes to be performed + + start_rank : int + The rank of the first actor + """ + ret = False + to_send = [] + # JS: The zip makes sure we have ranks alive + for dst, _ in zip(range(start_rank, self.block_size), range(self.alive)): + src, batch, policy_type, done, total_reward = self.recv_batch() + self.train_return[src] = exalearner.agent.train(batch) + + self.model_count += 1 + to_send.append(src) + + if done: + self.episode_reward_list.append(total_reward) + self.done_episode += self.batch_episode_frequency + self.episode_per_rank[src] = self.inc_episode() + ret = True + + if self.converged: + self.episode_per_rank[src] = nepisodes + + for dst in to_send: + self.send_model(exalearner, self.episode_per_rank[dst], self.train_return[dst], dst) + if self.episode_per_rank[dst] >= nepisodes: + self.alive -= 1 + + self.save_weights(exalearner, self.done_episode, nepisodes) + return ret + + @introspect + def actor(self, exalearner, nepisodes): + """ + This function is performed by actors. It performs the follow: + + 1. Receives model weights from the learner + 2. Set agents with new model weights + 3. Resets the environment if necessary + 4. Performs inference based on current state to get action + 5. Broadcasts that action to the other ranks in the env_comm + 6. Performs the action and determines the reward and next state + 7. Records the experience (i.e. states, action, and reward) + 8. Check for max number of steps and broadcast + 9. Updates the current state to the new state + 10. Sends batches of experiences to the learner + + We use the batch_frequency to determine how often we send + results back the learner. To send data only on a complete + episode, batch_frequency should be set to the max number + of steps. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + + nepisodes : int + Total number of episodes to run + + Returns + ------- + bool + This function returns False if it receives an + episode index >= the number of episodes to run. + Otherwise it returns True. + """ + # These are for ranks > 0 + episode = 0 + action = 0 + policy_type = 0 + + # Get model and update the other env ranks (1) if ExaComm.env_comm.rank == 0: - filename_prefix = 'ExaLearner_' + 'Episodes%s_Steps%s_Rank%s_memory_v1' % ( - str(workflow.nepisodes), str(workflow.nsteps), str(env_comm.rank)) - train_file = open(workflow.results_dir + '/' + - filename_prefix + ".log", 'w') - train_writer = csv.writer(train_file, delimiter=" ") - - # Variables for all - rank0_epsilon = 0 - - # Loop over episodes - for e in range(workflow.nepisodes): - # Reset variables each episode - current_state = workflow.env.reset() - total_reward = 0 - steps = 0 - done = False - - start_time_episode = time.time() - - while done != True: - # All env ranks - action = None - if ExaComm.env_comm.rank == 0: - action, policy_type = workflow.agent.action(current_state) + episode, weights, train_ret = self.recv_model() + episode = ExaComm.env_comm.bcast(episode, 0) + if episode >= nepisodes: + return False + + # Set agent for rank 0 (2) + if ExaComm.env_comm.rank == 0: + exalearner.agent.set_weights(weights) + for x in train_ret: + exalearner.agent.train_return(x) + + # Repeat steps 3-9 for a number of episodes + for eps in range(self.batch_episode_frequency): + # Set the episode for envs that want to keep track + exalearner.env.set_episode_count(episode + eps) - # Broadcast episode count to all procs in env_comm - action = env_comm.bcast(action, root=0) - next_state, reward, done, _ = workflow.env.step(action) + # Reset environment if required (3) + self.reset_env(exalearner) + # Do the steps. If batch_episode_frequency > 1 batch_steps_frequency == nsteps + for i in range(self.batch_step_frequency): + # Do inference (4) if ExaComm.env_comm.rank == 0: - total_reward += reward - memory = (current_state, action, reward, - next_state, done, total_reward) - batch_data = [] - workflow.agent.remember( - memory[0], memory[1], memory[2], memory[3], memory[4]) - # TODO: we need a memory class to scale - batch_data = next(workflow.agent.generate_data()) - logger.info( - 'Rank[{}] - Generated data: {}'.format(env_comm.rank, len(batch_data[0]))) - try: - buffer_length = len(workflow.agent.memory) - except: - buffer_length = workflow.agent.replay_buffer.get_buffer_length() - logger.info( - 'Rank[{}] - # Memories: {}'.format(env_comm.rank, buffer_length)) - - # Learner - if ExaComm.is_learner(): - # Push memories to learner - train_return = workflow.agent.train(batch_data) - if train_return is not None: - # indices, loss = train_return - workflow.agent.set_priorities(*train_return) - workflow.agent.target_train() - rank0_epsilon = workflow.agent.epsilon + action, policy_type = exalearner.agent.action(self.current_state) + if exalearner.action_type == "fixed": + action, policy_type = 0, -11 + + # Set the step for envs that want to keep track + exalearner.env.set_step_count(self.steps) + # Broadcast action and do step (5 and 6) + action = ExaComm.env_comm.bcast(action, root=0) + next_state, reward, self.done, _ = exalearner.env.step(action) + self.steps += 1 + + # Clip rewards if specified in configuration + if self.clip_rewards is not None: + reward = max(min(reward, self.clip_rewards[1]), self.clip_rewards[0]) + + # Record experience (7) if ExaComm.env_comm.rank == 0: - # Update state - current_state = next_state - logger.info('Rank[%s] - Total Reward:%s' % - (str(env_comm.rank), str(total_reward))) - steps += 1 - if steps >= workflow.nsteps: - done = True - - # Save memory for offline analysis - train_writer.writerow([time.time(), current_state, action, reward, - next_state, total_reward, done, e, steps, policy_type, rank0_epsilon]) - train_file.flush() - - # Broadcast done - done = env_comm.bcast(done, 0) - - end_time_episode = time.time() - if ExaComm.env_comm.rank == 0: - logger.info('Rank[%s] run-time for episode %s: %s ' % - (str(env_comm.rank), str(e), str(end_time_episode - start_time_episode))) - logger.info('Rank[%s] run-time for episode per step %s: %s ' - % (str(env_comm.rank), str(e), str((end_time_episode - start_time_episode) / steps))) + exalearner.agent.remember(self.current_state, action, reward, next_state, self.done) + self.total_reward += reward + + # Check number of steps and broadcast (8) + if self.steps == exalearner.nsteps: + self.done = True + self.done = ExaComm.env_comm.bcast(self.done, 0) + self.write_log(self.current_state, action, reward, next_state, self.total_reward, self.done, episode, self.steps, policy_type) + # Update state (9) + self.current_state = next_state + + if self.done: + break + + # Send batches back to the learner (10) if ExaComm.env_comm.rank == 0: - # Save Learning target model - if ExaComm.is_learner(): - workflow.agent.save(workflow.results_dir + '/' + filename_prefix + '.h5') - train_file.close() + batch_data = next(exalearner.agent.generate_data()) + self.send_batch(batch_data, policy_type, self.done, self.total_reward) + return True + + def episode_round(self, exalearner): + """ + Rounds to an even number of episodes for blocking purposes. + We broadcast this result to everyone. This is also a good + sync point prior to running loops. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + """ + nepisodes = exalearner.nepisodes + if ExaComm.global_comm.rank == 0: + if self.block_size == ExaComm.agent_comm.size and ExaComm.agent_comm.size > 1: + nactors = ExaComm.agent_comm.size - ExaComm.num_learners + nactorBatch = nactors * self.batch_episode_frequency + if nepisodes % nactorBatch: + nepisodes = (int(nepisodes / nactorBatch) + 1) * nactorBatch + else: + # This else should make sure nepisodes is factor of self.batch_episode_frequency + # previous if makes sure of that. + if nepisodes % self.batch_episode_frequency: + nepisodes = (int(nepisodes / self.batch_episode_frequency) + 1) * self.batch_episode_frequency + + # Just make it so everyone does at least one batch + if nepisodes < (ExaComm.agent_comm.size - ExaComm.num_learners) * self.batch_episode_frequency: + nepisodes = (ExaComm.agent_comm.size - ExaComm.num_learners) * self.batch_episode_frequency + + # For multi-learner, we must have equal amount of batches + if ExaComm.num_learners > 1: + # We can't guarantee cutoff wont leave unequal number of batches + assert self.cutoff <= 0 or self.rolling_reward_length <= 1, "Cutoff not supported for multi-learner" + nepisodes = (int(nepisodes / ExaComm.num_learners) + 1) * ExaComm.num_learners + # This ensures everyone has the same nepisodes as well + # as ensuring everyone is starting at the same time + nepisodes = ExaComm.global_comm.bcast(nepisodes, 0) + return nepisodes + + @PROFILE + def run(self, exalearner): + """ + This function is responsible for calling the appropriate initialization + and looping over the actor/learner functions. This function should + be overloaded for more interesting workflows. + + We change the number of run episodes to make blocking easier. When the + block_size is set, we round up the number of episodes such that each + actor will run the same number of episodes. + + Parameters + ---------- + exalearner : ExaLearner + This contains the agent and env + """ + convergence = -1 + nepisodes = self.episode_round(exalearner) + self.init_learner(exalearner) + if ExaComm.is_agent(): + while self.alive and self.done_episode < nepisodes: + self.actor(exalearner, nepisodes) + do_convergence_check = self.learner(exalearner, nepisodes, 0) + if do_convergence_check: + convergence = self.check_convergence() + self.debug("Learner:", self.done_episode, nepisodes, do_convergence_check, convergence) + # Send the done signal to the rest + ExaComm.env_comm.bcast(self.done_episode, 0) + else: + keep_running = True + while keep_running: + keep_running = self.actor(exalearner, nepisodes) + self.debug("Actor:", keep_running) + + def get_total_episodes_run(self): + """ + The number of episodes finished. This is important especially when using convergence cutoff. + + Returns + ------- + int : + Total number of episodes completed + """ + return self.done_episode + + def get_total_reward(self): + """ + Gives the sum of the rewards across episodes + + Returns + ------- + int : + Total reward across learning from all episodes + """ + return sum(self.episode_reward_list) + + def get_rolling_reward(self): + """ + Gives the rolling reward based on the configuration variable rolling_reward_length + + Returns + ------- + int : + Average reward of the rolling_reward_length number of episodes. + """ + return np.mean(np.array(self.episode_reward_list[-self.rolling_reward_length:])), self.rolling_reward_length diff --git a/notebooks/bsuite_plots.ipynb b/notebooks/bsuite_plots.ipynb new file mode 100755 index 00000000..e59b08cf --- /dev/null +++ b/notebooks/bsuite_plots.ipynb @@ -0,0 +1,3975 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "eRrAUUu-t-O2" + }, + "source": [ + "# Behaviour suite for ExaRL\n", + "\n", + "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/deepmind/bsuite/blob/master/bsuite/analysis/results.ipynb)\n", + "\n", + "This is the official results page for `bsuite`. You can use this to:\n", + "- Get a snapshot of agent performance.\n", + "- Diagnose strengths/weaknesses of your agent.\n", + "- Leverage ready-made plots and analysis" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Please do NOT run commented out lines**\n", + "\n", + "These lines currently do not work with arbitrary changes to the parameters of the experiment. We are working to fix this issue and will uncomment these lines at a future date." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Experiment Parameters:\n", + "\n", + "- Number of episodes per seed number: 100\n", + "- Number of seed numbers per experiment: bsuite default\n", + "- Environments excluded: cartpole-swingup, mountain_car, mountain_car_noise, mountain_car_scale" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "qXOubWdlH9C0" + }, + "outputs": [], + "source": [ + "#@title Imports\n", + "import warnings\n", + "\n", + "import bsuite.experiments\n", + "from bsuite.experiments import summary_analysis\n", + "\n", + "from bsuite.logging import csv_load\n", + "from bsuite.logging import sqlite_load\n", + "\n", + "import numpy as np\n", + "import pandas as pd\n", + "import plotnine as gg\n", + "\n", + "pd.options.mode.chained_assignment = None\n", + "gg.theme_set(gg.theme_bw(base_size=16, base_family='serif'))\n", + "gg.theme_update(figure_size=(12, 8), panel_spacing_x=0.5, panel_spacing_y=0.5)\n", + "warnings.filterwarnings('ignore')" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "ss3Gk6DzZjqO" + }, + "outputs": [], + "source": [ + "#@title Import experiment-specific analysis\n", + "\n", + "from bsuite.experiments.bandit import analysis as bandit_analysis\n", + "from bsuite.experiments.bandit_noise import analysis as bandit_noise_analysis\n", + "from bsuite.experiments.bandit_scale import analysis as bandit_scale_analysis\n", + "from bsuite.experiments.cartpole import analysis as cartpole_analysis\n", + "from bsuite.experiments.cartpole_noise import analysis as cartpole_noise_analysis\n", + "from bsuite.experiments.cartpole_scale import analysis as cartpole_scale_analysis\n", + "from bsuite.experiments.cartpole_swingup import analysis as cartpole_swingup_analysis\n", + "from bsuite.experiments.catch import analysis as catch_analysis\n", + "from bsuite.experiments.catch_noise import analysis as catch_noise_analysis\n", + "from bsuite.experiments.catch_scale import analysis as catch_scale_analysis\n", + "from bsuite.experiments.deep_sea import analysis as deep_sea_analysis\n", + "from bsuite.experiments.deep_sea_stochastic import analysis as deep_sea_stochastic_analysis\n", + "from bsuite.experiments.discounting_chain import analysis as discounting_chain_analysis\n", + "from bsuite.experiments.memory_len import analysis as memory_len_analysis\n", + "from bsuite.experiments.memory_size import analysis as memory_size_analysis\n", + "from bsuite.experiments.mnist import analysis as mnist_analysis\n", + "from bsuite.experiments.mnist_noise import analysis as mnist_noise_analysis\n", + "from bsuite.experiments.mnist_scale import analysis as mnist_scale_analysis\n", + "from bsuite.experiments.mountain_car import analysis as mountain_car_analysis\n", + "from bsuite.experiments.mountain_car_noise import analysis as mountain_car_noise_analysis\n", + "from bsuite.experiments.mountain_car_scale import analysis as mountain_car_scale_analysis\n", + "from bsuite.experiments.umbrella_distract import analysis as umbrella_distract_analysis\n", + "from bsuite.experiments.umbrella_length import analysis as umbrella_length_analysis\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gcpZiexEmjdf" + }, + "source": [ + "## Overall `bsuite` scores\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dIJBQqCDp5aP" + }, + "source": [ + "Load your experiments below. We recommend a maximum of 5 result sets, for clarity of analysis.\n", + "\n", + "The input to the `load_bsuite` function is a dict that maps from an experiment name of your choosing to the result path.\n", + "\n", + "For an experiment that used CSV logging, this would map to the directory containing the results. For SQLite logging, this would map to the database file for that experiment." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Main Question:\n", + "## What's better: High or low values of $\\epsilon$?" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": { + "id": "TnqNuenpr61Y" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'mnist_scale/0', 'memory_size/0', 'cartpole/0', 'bandit_scale/0', 'umbrella_distract/0', 'bandit/0', 'umbrella_length/0', 'deep_sea/0', 'catch/0', 'memory_len/0', 'mnist_noise/0', 'cartpole_noise/0', 'catch_scale/0', 'discounting_chain/0', 'cartpole_scale/0', 'catch_noise/0', 'mnist/0', 'deep_sea_stochastic/0', 'bandit_noise/0'}\n" + ] + } + ], + "source": [ + "#@title loading results from local data:\n", + "\n", + "# experiments = {'simple_sync': '/people/suet688/exaLearn/ExaRL/bsuite_results_sync/simple_sync', 'simple_async': '/people/suet688/exaLearn/ExaRL/bsuite_results/simple_async'} # Add results here\n", + "experiments = {'simple_async': '/people/suet688/exaLearn/ExaRL/bsuite_results/simple_async'} # Add results here\n", + "# experiments = {'simple_sync': '/people/suet688/exaLearn/ExaRL/bsuite_results_sync/simple_sync'} # Add results here\n", + "\n", + "# Or\n", + "DF, SWEEP_VARS = csv_load.load_bsuite(experiments)\n", + "print(set(DF[\"bsuite_id\"]))" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": { + "id": "plQLUbWPpUhv" + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "cannot set a frame with no defined index and a scalar", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#@title overall score as radar plot (double-click to show/hide code)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mBSUITE_SCORE\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msummary_analysis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mbsuite_score\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mDF\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSWEEP_VARS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mBSUITE_SUMMARY\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msummary_analysis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mave_score_by_tag\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mBSUITE_SCORE\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSWEEP_VARS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# __radar_fig__ = summary_analysis.bsuite_radar_plot(BSUITE_SUMMARY, SWEEP_VARS)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/experiments/summary_analysis.py\u001b[0m in \u001b[0;36mbsuite_score\u001b[0;34m(df, sweep_vars)\u001b[0m\n\u001b[1;32m 137\u001b[0m \u001b[0mscore_fun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0m_bsuite_score_single\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBSUITE_INFO\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 138\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0msweep_vars\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 139\u001b[0;31m \u001b[0mscore_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msweep_vars\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscore_fun\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 140\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 141\u001b[0m \u001b[0mscore_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mscore_fun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(self, func, *args, **kwargs)\u001b[0m\n\u001b[1;32m 892\u001b[0m \u001b[0;32mwith\u001b[0m \u001b[0moption_context\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"mode.chained_assignment\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 893\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 894\u001b[0;31m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_python_apply_general\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_selected_obj\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 895\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 896\u001b[0m \u001b[0;31m# gh-20949\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/pandas/core/groupby/groupby.py\u001b[0m in \u001b[0;36m_python_apply_general\u001b[0;34m(self, f, data)\u001b[0m\n\u001b[1;32m 926\u001b[0m \u001b[0mdata\u001b[0m \u001b[0mafter\u001b[0m \u001b[0mapplying\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 927\u001b[0m \"\"\"\n\u001b[0;32m--> 928\u001b[0;31m \u001b[0mkeys\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalues\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmutated\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgrouper\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 929\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 930\u001b[0m return self._wrap_applied_output(\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/pandas/core/groupby/ops.py\u001b[0m in \u001b[0;36mapply\u001b[0;34m(self, f, data, axis)\u001b[0m\n\u001b[1;32m 236\u001b[0m \u001b[0;31m# group might be modified\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 237\u001b[0m \u001b[0mgroup_axes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgroup\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0maxes\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 238\u001b[0;31m \u001b[0mres\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mgroup\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 239\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0m_is_indexed_like\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mres\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgroup_axes\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 240\u001b[0m \u001b[0mmutated\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/experiments/summary_analysis.py\u001b[0m in \u001b[0;36m\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m 135\u001b[0m sweep_vars: Sequence[str] = None) -> pd.DataFrame:\n\u001b[1;32m 136\u001b[0m \u001b[0;34m\"\"\"Score bsuite for each experiment across hyperparameter settings.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 137\u001b[0;31m \u001b[0mscore_fun\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mlambda\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0m_bsuite_score_single\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mBSUITE_INFO\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 138\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0msweep_vars\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 139\u001b[0m \u001b[0mscore_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroupby\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msweep_vars\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mapply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mscore_fun\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreset_index\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/experiments/summary_analysis.py\u001b[0m in \u001b[0;36m_bsuite_score_single\u001b[0;34m(df, experiment_info, verbose)\u001b[0m\n\u001b[1;32m 124\u001b[0m data.append({\n\u001b[1;32m 125\u001b[0m \u001b[0;34m'bsuite_env'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0menv_name\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 126\u001b[0;31m \u001b[0;34m'score'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mb_summary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscore\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0menv_data\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 127\u001b[0m \u001b[0;34m'type'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mb_summary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtype\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 128\u001b[0m \u001b[0;34m'tags'\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mb_summary\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtags\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/experiments/deep_sea_stochastic/analysis.py\u001b[0m in \u001b[0;36mscore\u001b[0;34m(df, forgiveness)\u001b[0m\n\u001b[1;32m 54\u001b[0m forgiveness: float = 100.) -> float:\n\u001b[1;32m 55\u001b[0m \u001b[0;34m\"\"\"Outputs a single score for deep sea selection.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 56\u001b[0;31m \u001b[0mplt_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfind_solution\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 57\u001b[0m beat_dither = (plt_df.solved\n\u001b[1;32m 58\u001b[0m & (plt_df.episode < 2 ** plt_df['size'] + forgiveness))\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/experiments/deep_sea_stochastic/analysis.py\u001b[0m in \u001b[0;36mfind_solution\u001b[0;34m(df_in, sweep_vars, num_episodes)\u001b[0m\n\u001b[1;32m 48\u001b[0m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mepisode\u001b[0m \u001b[0;34m>=\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 49\u001b[0m return deep_sea_analysis.find_solution(\n\u001b[0;32m---> 50\u001b[0;31m df, sweep_vars, thresh=0.8, num_episodes=num_episodes)\n\u001b[0m\u001b[1;32m 51\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 52\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/experiments/deep_sea/analysis.py\u001b[0m in \u001b[0;36mfind_solution\u001b[0;34m(df_in, sweep_vars, merge, thresh, num_episodes)\u001b[0m\n\u001b[1;32m 64\u001b[0m \u001b[0mplt_df\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msolved\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0munsolved\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mto_frame\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 65\u001b[0m \u001b[0mplt_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrename\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'episode'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minplace\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 66\u001b[0;31m \u001b[0mplt_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0msolved\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'solved'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 67\u001b[0m \u001b[0mplt_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mloc\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0munsolved\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mindex\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'solved'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 68\u001b[0m \u001b[0mplt_df\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrename\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m{\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;34m'episode'\u001b[0m\u001b[0;34m}\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0minplace\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mTrue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m__setitem__\u001b[0;34m(self, key, value)\u001b[0m\n\u001b[1;32m 690\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 691\u001b[0m \u001b[0miloc\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m\"iloc\"\u001b[0m \u001b[0;32melse\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0miloc\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 692\u001b[0;31m \u001b[0miloc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_setitem_with_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mvalue\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mname\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 693\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 694\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0m_validate_key\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mkey\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mint\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/pandas/core/indexing.py\u001b[0m in \u001b[0;36m_setitem_with_indexer\u001b[0;34m(self, indexer, value, name)\u001b[0m\n\u001b[1;32m 1586\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0mis_list_like_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvalue\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1587\u001b[0m raise ValueError(\n\u001b[0;32m-> 1588\u001b[0;31m \u001b[0;34m\"cannot set a frame with no \"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1589\u001b[0m \u001b[0;34m\"defined index and a scalar\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1590\u001b[0m )\n", + "\u001b[0;31mValueError\u001b[0m: cannot set a frame with no defined index and a scalar" + ] + } + ], + "source": [ + "#@title overall score as radar plot (double-click to show/hide code)\n", + "BSUITE_SCORE = summary_analysis.bsuite_score(DF, SWEEP_VARS)\n", + "BSUITE_SUMMARY = summary_analysis.ave_score_by_tag(BSUITE_SCORE, SWEEP_VARS)\n", + "# __radar_fig__ = summary_analysis.bsuite_radar_plot(BSUITE_SUMMARY, SWEEP_VARS)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5ANabuXdFAFS" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Snapshot of agent behaviour across key metrics as measured by bsuite.\n", + "- Length of each \"spoke\" represents score between 0 and 1.\n", + "- For more detailed analysis, click into specific challenge domains." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ds789Mrq5LmR" + }, + "source": [ + "### Plotting scores per challenge in bar plot (click to show)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "id": "8VGZIvfGtZ4m" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plotting overall score as bar (double-click to show/hide code)\n", + "summary_analysis.bsuite_bar_plot(BSUITE_SCORE, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QsUzPzmrG208" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Height of each bar is the score on each challenge domain.\n", + "- Partially-finished runs are shown with transparent bars.\n", + "- Parameter/agent sweeps are automatically [faceted](http://www.sthda.com/english/wiki/ggplot2-facet-split-a-plot-into-a-matrix-of-panels) side by side.\n", + "- For more detailed analysis, click into specific challenge domains." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "id": "iR-J9iZWPDNW" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title compare agent performance on each challenge (double-click to show/hide code)\n", + "summary_analysis.bsuite_bar_plot_compare(BSUITE_SCORE, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nJcxdHc9Ps7k" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Height of each bar is the score on each challenge domain.\n", + "- Partially-finished runs are shown with transparent bars.\n", + "- Each \"facet\" focuses on a separate environment.\n", + "- This plot allows for easier comparison between agents.\n", + "- For more detailed analysis, click into specific challenge domains." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iaa0FgSoMu3T" + }, + "source": [ + "# Individual challenge domains\n", + "\n", + "This section of the report contains specific analysis for each individual `bsuite` experiment." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dwIcX62dDnNE" + }, + "source": [ + "## Basic\n", + "\n", + "\n", + "We begin with a collection of very simple decision problems with standard analysis:\n", + "- Does the agent learn a reasonable rewarding policy?\n", + "- How quickly do they learn simple tasks?\n", + "\n", + "We call these experiments \"basic\", since they are not particularly targeted at specific core issues.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vQmNzVbBDqZa" + }, + "source": [ + "### Bandit\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fjweihnXblOP" + }, + "source": [ + "\n", + "\"bandit\n", + "\n", + "\n", + "A simple independent-armed bandit problem.\n", + "\n", + "- The agent is faced with 11 actions with deterministic rewards [0.0, 0.1, .., 1.0] randomly assigned.\n", + "- Run over 20 seeds for 10k episodes.\n", + "- Score is 1 - 2 * average_regret at 10k episodes.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "cellView": "form", + "id": "h5um7tOPDpju" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('basic',)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "bandit_df = DF[DF.bsuite_env == 'bandit'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'bandit', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "cellView": "form", + "id": "j583NAoLD5nD" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot average regret through learning (lower is better)\n", + "bandit_analysis.plot_learning(bandit_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "asfed9wuEbO7" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of the agent averaged over 20 seeds.\n", + "- Random policy has reward of 0 = regret of 0.5 = dashed line\n", + "- Want to see a stable learning curve -> 0 and fast!\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "cellView": "form", + "id": "t600GCEj1qCu" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# bandit_analysis.plot_seeds(bandit_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_ypLP6DZHZc8" + }, + "source": [ + "### MNIST\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "woT2ar_fbjy3" + }, + "source": [ + "\n", + "\"mnist\n", + "\n", + "The \"hello world\" of deep learning, now as a contextual bandit.\n", + "\n", + "- Every timestep the agent must classify a random MNIST digit.\n", + "- Reward +1 for correct, -1 for incorrect.\n", + "- Run for 10k episodes, 20 seeds.\n", + "- Score is percentage of successful classifications.\n", + "- Must log `episode`, `total_regret` for standard analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "cellView": "form", + "id": "77KttSBsHZc-" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('basic', 'generalization')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "mnist_df = DF[DF.bsuite_env == 'mnist'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'mnist', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "cellView": "form", + "id": "dxjKHqPaHZdB" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot average regret through learning (lower is better)\n", + "mnist_analysis.plot_learning(mnist_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gMAtScV4HZdH" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of the agent averaged over 20 seeds.\n", + "- Random policy has reward of 0 = regret of 1.8 = dashed line\n", + "- Want to see a stable learning curve -> 0 and fast!\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "cellView": "form", + "id": "zmCi_x8F4jCt" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# mnist_analysis.plot_seeds(mnist_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QWtMyhFpNYC9" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GrTjfY11MD5E" + }, + "source": [ + "### Catch" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7MOVEQunM9QB" + }, + "source": [ + "\"catch\n", + "\n", + "\n", + "DeepMind's internal \"hello world\" for RL agents.\n", + "\n", + "- The environment is a 5x10 grid with a single falling block per episodes (similar to Tetris).\n", + "- The agent controls a single \"paddle\" pixel that it should use to \"catch\" the falling block.\n", + "- If the agent catches the block reward +1, if the agent misses the block reward -1.\n", + "- Run the agent for 10k episodes and 20 seeds.\n", + "- Score is percentage of successful \"catch\" over first 10k episodes.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "cellView": "form", + "id": "54UwF1sONICb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('basic', 'credit_assignment')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "catch_df = DF[DF.bsuite_env == 'catch'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'catch', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "cellView": "form", + "id": "54hwhFHSreCS" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot average regret through learning (lower is better)\n", + "catch_analysis.plot_learning(catch_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kjnlywacKyWk" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of the agent averaged over 20 seeds.\n", + "- Random policy has reward of 0 = regret of 1.6 = dashed line\n", + "- Want to see a stable learning curve -> 0 and fast!\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "cellView": "form", + "id": "m-F2cCPb4kNa" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# catch_analysis.plot_seeds(catch_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sVZ3SfqYNY5H" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YtCu7IUwFYOY" + }, + "source": [ + "### Mountain car" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "twcWpU2hb4XT" + }, + "source": [ + "\"mountaincar\n", + "\n", + "A classic benchmark problem in RL.\n", + "The agent controls an underpowered car and must drive it out of a valley.\n", + "\n", + "- Reward of -1 each step until the car reaches the goal.\n", + "- Maximum episode length of 1000 steps.\n", + "- Run 1000 episodes for 20 seeds.\n", + "- Score is based on regret against \"good\" policy that solves in 25 steps.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "cellView": "form", + "id": "10AxDzgmFYOa" + }, + "outputs": [], + "source": [ + "#@title parsing data\n", + "# mountain_car_df = DF[DF.bsuite_env == 'mountain_car'].copy()\n", + "# summary_analysis.plot_single_experiment(BSUITE_SCORE, 'mountain_car', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "cellView": "form", + "id": "PCiai_7_FYOe" + }, + "outputs": [], + "source": [ + "#@title plot average regret through learning (lower is better)\n", + "# mountain_car_analysis.plot_learning(mountain_car_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mLE9dhuPclv5" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of the agent averaged over 20 seeds.\n", + "- Dashed line is at 415 = average regret of a random agent.\n", + "- Want to see a stable learning curve -> 0 and fast!\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "cellView": "form", + "id": "UotK4LDa4m62" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# mountain_car_analysis.plot_seeds(mountain_car_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZpvpbLikNRRG" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iKRx2R7DEz5R" + }, + "source": [ + "### Cartpole\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XJkGob4ebrRj" + }, + "source": [ + "\n", + "\"cartpole\n", + "\n", + "A classic benchmark problem in RL.\n", + "The agent controls a cart on a frictionless plane.\n", + "\n", + "- The poles starts near-to upright.\n", + "- The observation is [x, x_dot, sin(theta), sin(theta)_dot, cos(theta), cos(theta)_dot, time_elapsed]\n", + "- Episodes end once 1000 steps have occured, or |x| is greater than 1.\n", + "- Reward of +1 when pole > 0.8 height.\n", + "- Run 1000 episodes for 20 seeds.\n", + "- Score is percentage of timesteps balancing the pole.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "cellView": "form", + "id": "1UFLKInrEz5X" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('basic', 'credit_assignment', 'generalization')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "cartpole_df = DF[DF.bsuite_env == 'cartpole'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'cartpole', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "cellView": "form", + "id": "CeR8Vgf-Ez5b" + }, + "outputs": [], + "source": [ + "#@title plot average regret through learning (lower is better)\n", + "# cartpole_analysis.plot_learning(cartpole_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UO1GwYM5ZiSI" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of the agent averaged over 20 seeds.\n", + "- Maximum regret of 1000 per episode = dashed line\n", + "- Want to see a stable learning curve -> 0 and fast!\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "cellView": "form", + "id": "0vWWVcYR4lNZ" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# cartpole_analysis.plot_seeds(cartpole_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jZuGijZZNBNU" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "UQ010l9tFsbG" + }, + "source": [ + "## Reward noise\n", + "\n", + "To investigate the robustness of RL agents to noisy rewards, we repeat the \"basic\" experiments under differing levels of Gaussian noise.\n", + "\n", + "This time we allocate the 20 different seeds across 5 levels of Gaussian noise $N(0, \\sigma^2)$ for $\\sigma$ = noise\\_scale = $[0.1, 0.3, 1, 3, 10]$ with 4 seeds each." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SWm2u8lpFsbK" + }, + "source": [ + "### Bandit noise" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "o27LKuR0d-Bh" + }, + "source": [ + "\"bandit\n", + "\n", + "\n", + "A simple independent-armed bandit problem.\n", + "\n", + "- The agent is faced with 11 actions with deterministic rewards [0.0, 0.1, .., 1.0] randomly assigned.\n", + "- Run noise_scale = [0.1, 0.3, 1., 3, 10] for 4 seeds for 10k episodes.\n", + "- Score is 1 - 2 * average_regret at 10k episodes.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": { + "cellView": "form", + "id": "NAU9QFGGFsbL" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('noise',)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "bandit_noise_df = DF[DF.bsuite_env == 'bandit_noise'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'bandit_noise', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "cellView": "form", + "id": "cKrEMGjlFsbP" + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "Your experiment has not yet run the necessary 10000 episodes", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m#@title average regret over learning (lower is better)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mbandit_noise_analysis\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot_average\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbandit_noise_df\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mSWEEP_VARS\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdraw\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m;\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/experiments/bandit_noise/analysis.py\u001b[0m in \u001b[0;36mplot_average\u001b[0;34m(df, sweep_vars, group_col)\u001b[0m\n\u001b[1;32m 57\u001b[0m \u001b[0mgroup_col\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mgroup_col\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 58\u001b[0m \u001b[0mepisode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msweep\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mNUM_EPISODES\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 59\u001b[0;31m \u001b[0msweep_vars\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0msweep_vars\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 60\u001b[0m )\n\u001b[1;32m 61\u001b[0m \u001b[0mp\u001b[0m \u001b[0;34m+=\u001b[0m \u001b[0mgg\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mscale_y_continuous\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mbreaks\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1.1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtolist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/utils/plotting.py\u001b[0m in \u001b[0;36mplot_regret_average\u001b[0;34m(df_in, group_col, episode, sweep_vars, regret_col)\u001b[0m\n\u001b[1;32m 202\u001b[0m regret_col: str = 'total_regret') -> gg.ggplot:\n\u001b[1;32m 203\u001b[0m \u001b[0;34m\"\"\"Bar plot the average regret at end of learning.\"\"\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 204\u001b[0;31m \u001b[0mdf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0m_preprocess_ave_regret\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf_in\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mgroup_col\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mepisode\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msweep_vars\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mregret_col\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 205\u001b[0m \u001b[0mgroup_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgroup_col\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreplace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'_'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m' '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 206\u001b[0m p = (gg.ggplot(df)\n", + "\u001b[0;32m~/.conda/envs/quExarlEnvTest/lib/python3.7/site-packages/bsuite/utils/plotting.py\u001b[0m in \u001b[0;36m_preprocess_ave_regret\u001b[0;34m(df_in, group_col, episode, sweep_vars, regret_col)\u001b[0m\n\u001b[1;32m 189\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mplt_df\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0;31m# pylint:disable=g-explicit-length-test\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 190\u001b[0m raise ValueError('Your experiment has not yet run the necessary {} episodes'\n\u001b[0;32m--> 191\u001b[0;31m .format(episode))\n\u001b[0m\u001b[1;32m 192\u001b[0m \u001b[0mgroup_name\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mgroup_col\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreplace\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'_'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m' '\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 193\u001b[0m \u001b[0mplt_df\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mgroup_name\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt_df\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mgroup_col\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'category'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mValueError\u001b[0m: Your experiment has not yet run the necessary 10000 episodes" + ] + } + ], + "source": [ + "#@title average regret over learning (lower is better)\n", + "bandit_noise_analysis.plot_average(bandit_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "szaUeRc4ed6Q" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for largest noise_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "6fS80_PNF96e" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "bandit_noise_analysis.plot_learning(bandit_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DWHHIRkhejPZ" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for largest noise_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "9a89RWjd4n4I" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# bandit_noise_analysis.plot_seeds(bandit_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "bvbUja5cNbA_" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XeeO3UdkHvro" + }, + "source": [ + "### MNIST noise" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KQU-bBpCeMXS" + }, + "source": [ + "\n", + "\"mnist\n", + "\n", + "The \"hello world\" of deep learning, now as a contextual bandit.\n", + "\n", + "- Every timestep the agent must classify a random MNIST digit.\n", + "- Reward +1 for correct, -1 for incorrect.\n", + "- Run noise_scale = [0.1, 0.3, 1., 3, 10] for 4 seeds for 10k episodes.\n", + "- Score is percentage of successful classifications.\n", + "- Must log `episode`, `total_regret` for standard analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "3gHxu0e4Hvrp" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('noise', 'generalization')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "mnist_noise_df = DF[DF.bsuite_env == 'mnist_noise'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'mnist_noise', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "HsNrBsl3Hvrx" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret over learning (lower is better)\n", + "mnist_noise_analysis.plot_average(mnist_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m_q0mBBvfgq6" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for largest noise_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "6vKxHHfGHvr4" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "mnist_noise_analysis.plot_learning(mnist_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gFquOp8YfenD" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for largest noise_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "H_wJ_oLq4o5K" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# mnist_noise_analysis.plot_seeds(mnist_noise_df, SWEEP_VARS).draw;" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ft77N63zNcKf" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BhNvrDHtFsbW" + }, + "source": [ + "### Catch noise" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cuwO8ePyfnMF" + }, + "source": [ + "\"catch\n", + "\n", + "\n", + "DeepMind's internal \"hello world\" for RL agents.\n", + "\n", + "- The environment is a 5x10 grid with a single falling block per episodes (similar to Tetris).\n", + "- The agent controls a single \"paddle\" pixel that it should use to \"catch\" the falling block.\n", + "- If the agent catches the block reward +1, if the agent misses the block reward -1.\n", + "- Run noise_scale = [0.1, 0.3, 1., 3, 10] for 4 seeds for 10k episodes.\n", + "- Score is percentage of successful \"catch\" over first 10k episodes.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "PfrF58GRFsbX" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('noise', 'credit_assignment')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "catch_noise_df = DF[DF.bsuite_env == 'catch_noise'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'catch_noise', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "QIHLMrZBFsba" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret over learning (lower is better)\n", + "catch_noise_analysis.plot_average(catch_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KQne2I0TgIQN" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for largest noise_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "ChxlGZ3MGf9n" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABQoAAAJVCAYAAACWIsj0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAADscElEQVR4nOzdeXhU1f3H8c+sCSEkQMjCvoYlCQQFtSIKQl2rWFHqUhWxoq20RautVlsFXGrdgGK18HOvKO6Cu2VxxRUhkIR9kTUJawIJSWYy9/dHnCE3CyR3JssM79fz8Dy555659yRnJjl87znfYzMMwxAAAAAAAACA45q9uRsAAAAAAAAAoPkRKAQAAAAAAABAoBAAAAAAAAAAgUIAAAAAAAAAIlAIAAAAAAAAQAQKAQAAAAAAAIhAIQAAAAAAAAARKAQAAAAAAAAgydncDYhUBw4cUElJSXM3AwCA40ZMTIzatm3b3M0IGmMIAACaVqSMIYBQIFDYCA4cOKDHH39cXq+3uZsCAMBxw+l06ve//31YD/QZQwAA0PQiYQwBhAqBwkZQUlIir9erE044QbGxsc3dHAAAIt6hQ4e0fPlylZSUhPUgnzEEAABNK1LGEECoEChsRLGxsfyiAQAADcYYAgAAAM2BzUwAAAAAAAAAECgEAAAAAAAAQKAQAAAAAAAAgMhRCBw3Dh06pAULFqhXr1762c9+1tzNQSNZuXKl/vGPf2js2LEaN26cJGnRokWaOXNmoM7//d//KTk5ubmaGJQdO3bov//9r1atWqXy8nJ1795dF110kU4//fSjvu7LL7/Uf/7zH0VFRempp55qotYCQGRgDHF8iOQxRFlZmebPn68vvvhCO3fulMPhUI8ePXThhRdq+PDhtb5m9+7dev311/XDDz9o7969atWqldLS0nT55Zerd+/eTfwdAEDTYUYhcJwoLi7WvHnz9PXXXzd3U9CICgsLVVxcrN27dwfKRo8erQULFmjUqFHN2LLgbd68WX/6059UVFSkhx9+WM8//7yGDh2qhx9+WK+++mqtrykqKtJDDz2kxx9/XIWFhU3cYgCIDIwhjg+ROoYoKSnR7bffrldffVXnnXeennnmGT3++OPq37+/HnroIc2bN6/GazZv3qzJkyfru+++0+9+9zu9+OKL+sc//qGysjL9+c9/VlZWVjN8JwDQNAgUAkAEOf300/Xcc8/pt7/9bXM3JaR8Pp+mT58uwzD0l7/8RZ06dVJMTIwuv/xynXTSSXrppZf0448/1njdpEmT5HK5dP/99zdDqwEACB+ROoZ4+eWXtWnTJl100UU677zzFBcXp8TERE2YMEGDBw/WvHnztHnzZtNrZs6cqUOHDukPf/iDTjzxRMXExKhbt26644471KpVK82cOVNlZWXN9B0BQOMiUAgAEaZ9+/ay2yPr1/vKlSu1ZcsWnXTSSWrbtq3p3M9//nP5fD698847NV73hz/8Qbfccotat27dRC0FACB8ReIY4ssvv5QknXLKKTXODRs2TD6fT++9916gLC8vT5s2bVJUVJROOOEEU/2YmBidcMIJ2rNnDzNsAUQschQCx1BWVqbFixfrq6++0rZt21RYWKi2bdtq6NChuvLKK2sELSSpvLxc8+bN0yeffKIDBw4oISFBI0eO1IABAzRlypRAvfvvv18DBw6UJFVUVOi9997TokWLtGPHDrlcLvXp00eXXHKJBg8eHHjN66+/rhdeeCFwPG/ePD333HNaunSpSktL1adPH02cONGUO+XOO+9Udna2JGnx4sVavHhx4NyCBQvq/bOwcm9J2r59uxYtWqTly5crPz9fHo9HXbp00TnnnKNzzz1XNpstUPeJJ57Qhx9+KElKSkrSww8/rNmzZ2v58uVyu906/fTTNWHCBDmdTs2bN08fffSRDh06pAEDBuimm25Sx44da7R79+7dmjdvnpYtW6aioqJA/11xxRVq165dvb//o6nvPcaMGRP4+vLLL1dKSormz5+vHTt2KCoqSkOGDNG1116r9u3bm66/du1avfbaa9qwYYOKi4uVlJSktLQ0jRw5Uunp6ZLM/ZyRkaEHHnigwe3/4YcfVFhYqPj4eA0ZMkSXXXaZEhMTA/XuueceLV++PHCPSZMm6amnnlJubq5sNptOPPFE/fa3v1VcXFzDf4hH8f3330uS+vXrV+Nc//79TXWqOvnkk0PaDgBoCMYQRzCGqFtD7rF9+3bNmzdPubm5KioqUmJiolJTU3X66afrpJNOklRzPDB+/Hi9+OKLWr9+vSoqKtS3b1+NHz9effv2DVw3kscQ+/fvl6RaP28JCQmSpBUrVgTK9u3bJ0mKj4+v9Xr+MdqKFSs0YsSIELYUAFoGm2EYRnM3ItLs3LlTc+bM0emnn17rHySEl/Xr1+vWW2/VmDFjdPHFFys2NlYbN27U7NmzdfjwYc2YMUMxMTGB+oZhaMqUKVq+fLmuvfZanXvuufJ4PHr77bf1zTffaPv27br88st15ZVXBl7j8/n0wAMP6Pvvv9f111+v0aNHq6SkRHPnztWiRYs0efLkGrlh/AO6YcOGacSIEcrMzNTWrVv14IMPyufzac6cOYqOjg7Uz8/P18SJEzVq1CjdfPPNQf1MGnrv//znP/r00081efJkZWZmqry8XF999ZXmzJmjCy+8UBMmTKhxj+uvv15er1e9e/fWuHHj1K1bN3322Wd64okndP7556t9+/ZKTk7WSSedpI0bN+qBBx5Qhw4dNGvWLNN1tm3bpjvvvFOtWrXSrbfeql69emnjxo2aPn26PB6PHn744cAg0aqG3mPVqlW666671LlzZ3Xs2FE33HCD2rdvrx9++EHTp09XXFycHn300cBAecOGDfrLX/6iU089VePHj1fbtm21adMmzZo1S2VlZTU25xgzZkytg/wZM2Zo8eLFNRKR//jjj7rrrrvUtm1bTZ48WT169NCWLVs0Y8YMFRUV6YEHHlDXrl1r3KN79+5q27atrrnmGnXu3FnffvutZs6cqRNOOEF33313UD/T6v7+978rKytLd955Z62J9C+99FKVl5frxRdfrPU/GP73f1JSEpuZRKgDBw7o888/1w033KBOnTo1d3MsYwwRWRhD1MQYwqwh99izZ49+//vfq0+fPvrtb3+r5ORkbd++XbNnz1Zubm6NwO2YMWPUoUMHtWnTRr/73e/Uu3dvbd26VdOnT1deXp7uvfdeDRgwoMZrIm0Mce2112rfvn165JFHTMFRSVq4cKH+9a9/yWaz6bXXXpPb7daOHTv0u9/9TlFRUXrttddqXG/69OlasmSJ+vXrp4cffjikbUXziJQxBBAqkTWvHGgE/lle119/vRISEhQVFaW0tDTdfPPNysvL00cffWSqv3jxYi1fvlwjRozQ2LFjFRMTo/j4eI0fP16xsbG13uP999/Xt99+qxEjRuiCCy5Qq1atlJCQoEmTJikxMVGzZ8/WwYMHa31t//79deqppyomJkb9+/fXhRdeqAMHDpiejDaW+t67Q4cOuuaaa/Szn/1MrVq1Unx8vM4991ydf/75WrBgQeBJb3X79u3Tueeeq/79+ysmJkbnnnuuunfvrkWLFqmsrEwjRoxQTEyMBg4cqBEjRujHH3+skWNm+vTpKiws1KRJk9SvXz+5XC71799fN910k/bs2aPnnnvOVH/Lli0aP368pkyZovo+R2noPap+f7feeqtSUlLkdrv1s5/9TFdffbXy8/M1d+7cQL1PP/1UXq9Xv/rVr5SUlCS3263+/fvrhhtuqFf76tP+gwcP6o477lBqaqpcLpdSU1N1xx13qKioSNOnT6/1dT/++KOuvfZapaamKiYmRiNHjtTgwYO1bNmyOt+vVvnfI3V9hvz/0T5w4EBI7wsAwWAMUTfGEA2/x1dffaWSkhJddNFF6tKli1wul3r27KnJkyfXef09e/boN7/5jfr37y+Xy6XevXvrtttuU3l5uR5//PF6tfFY7W/pY4ghQ4ZIkr755psa57799ltJlUH64uJiSQo8yC0rKwvMgPQrLy8PbGRy6NChkLYTAFoKAoXAMXTr1k333HNPjfLu3btLklavXm0qX7JkiSTpjDPOqPGaupYnfPDBB5Kks846y1TucDh02mmn6fDhw1q6dGmtr62eb8X/1Hbnzp211g+l+t770ksv1XnnnVfj9d27d1dFRYXWrVtX6/XtdrtOPPFEU1mnTp1UVlamzMxMU3nnzp0lSTt27AiUrVu3Ths2bFBycnKN+pmZmYqPj9eXX36pw4cPB8qXL1+u/fv364cffqjXQNXKPfxOPPHEGrnzTj/9dEmVwUGfz2c698UXX5j+49HQpUG1Wbt2rTZt2qRevXqpS5cupnNdu3ZVz549tWHDhlr7qEOHDjWWiHXp0kWGYSgvLy+odlVXXl4uSXI6a8+Y4S8nsTiAloQxRN0YQzT8Hv5l1kuXLpXX6w3U7dixo/7zn//Ueo/4+HgNGjTIVNajRw917dpV27Zt0/r164/ZzrqEyxjiyiuvVEJCgubPn68PPvhARUVF2rt3r1566SWtXbs2kJOx6hjrt7/9rZxOp2bNmqUffvhBJSUl2r59ux566KGQtg0AWiJyFAL1kJubqzfffFObN2/W3r17TQEc/9NHv02bNkk6MuisqmqeFr+SkhJt27ZNktSzZ886X7Nhwwadc845Nc5Xz2XnX67TFAGT+t7b4/Hoo48+0uLFi5Wfn19j8FzXE9m4uDg5HA5TWatWrWq9t39GWdV7+wemtf1cpcpBamFhoX788cdAnrvhw4fru+++U69eveqVI8fKPfxqez/Ex8crNjZWhw4dUl5enjp16qSzzjpLH3/8sV555RV98cUXGjlypIYNG6auXbsqKSnpmG08Gv9/EKoP8P26dOmiTZs2af369TWW61TvA+lI/4T6/ed2uyXJ9B+jqvzlUVFRIb0vAASLMUTtGEM0/B7Dhw/X66+/rkWLFikrK0sjRozQsGHDlJqaWudyydreN1Lle2zbtm3avHmzUlNTj9nW2oTLGCIhIUGPPfaYXn75Zb322muaM2eO2rRpoyFDhujhhx/W9ddfL0mmh7cnnHCC/vnPf+q1117To48+qsOHD6tDhw4aMWKEzjnnHN17772mtAEAEEkIFALH8Mknn2j69OlKTU3VX//6V3Xv3l0ul0tSZY6V6ktLSkpKJNUesPAPgKqq+iT6iiuuqLMddS2prH4f/9Pmpkg/Wp97G4ah++67T8uXL9cll1yiCy64QO3bt5fNZtOiRYs0c+bMOq/vDw7Vxt8HR+Pvi6+//tq0iUh1VX+2iYmJDZqlZ+UeflVzMFUvP3ToUODa3bp108yZM/X666/r888/19y5czV37lz1799f119/fY3Bd0Mc7f1atY3V/zMrHb1/Qv3+a9eunbZu3Vrnfwj93wc53QC0JIwh6sYYouH3aNu2rWbMmKE33nhDixcv1htvvKE33nhD3bt31/jx4zV06NAarz3aWEOq/e97Q9vf0scQUuU44qabbqpRXlRUJKkycFn9+0hNTdWdd95Z4zX+XZRr2/wGACIBgULgGObNmyfDMDRp0qQ6n/hW1bp1ax08eLDWp6G1LT/1P7202Wx6/fXX6zV4DSdr1qzR8uXL1atXL40fP75J7+3/2Y4YMUK33npri7tHaWnpUcurPqlOSUnR73//e91www36/vvv9dFHH2n58uW688479a9//cty4mV/++t6eu9vS125sZpK9+7dlZWVpfz8/Brn9u/fr/LycrVv3z7kOyUCQDAYQwSHMURNbdu21W9+8xtde+21ysrK0sKFC/Xll1/q3nvv1f3336+MjAxT/WONNaqnQLHS/pY+hjia7du3S1KDHrr6l6j369evUdoEAM2NHIXAMRQUFEhSjUBMXYOiXr16SToy8Khq9+7dNcqio6PVrVs3GYZR63lJWrlyZdD5gvxP6ptaXT8/qfGXNvkHff42VFdUVKRly5YF1Y5g7lFbfx84cECHDh1S69atlZKSIknauHFjIEDmdrs1bNgwTZ06VWeddZbKy8v13XffBd1+/9K16vzlVpclhYo/EXlteY7WrFljqgMALQVjiOAwhjDfY/v27dq6daukyhyUJ554ov7yl7/oyiuvlGEY+uqrr2pco673hT/Y5X/PBdP+lj6GOHjwYK0bmUgKbJ5TPQfo9u3bA+OL2l7jcDg0fPjwkLYTAFoKAoXAMXTo0EFS5U52VeXm5tZaf9SoUZKkzz//vMa5Tz/9tNbXnH/++ZIqdzusbv369frb3/6mffv21bvNtfE/zfV4PIGyO+64I5A4vbH4c+P8+OOPNZaSVE/iHmqpqanq27ev1q5da0pQ7vfyyy9r9uzZphkYu3fv1l133aVnn3220e7h98MPP9RYjvPFF19IkkaOHBlIrv3OO+8EktVX1a1bN0nB5eVLTU1Vnz59tHnz5hr/Md22bZu2bNmiPn36NNkgf8WKFbr11ltrfFYyMzPVvXt3fffddzWW0C1cuFB2u10XXHBBk7QRAOqLMURwGEOY7/HZZ59p3rx5Ner5xwO1LectLCwM7NLrt2XLFm3btk3du3dXnz596tXWutofDmOIHTt26P77768RkD148KA+/PBDpaam6tRTTzWd+/rrr/XYY4/V2Fhu9erVys7O1oUXXqh27do1zjcCAM2MQCFwDBdddJEk6fHHH9e6detUVlam7OxsPfnkk7XWHzlypIYOHapPP/1Ub731lkpKSlRUVKTnn3++znws5557rk499VS9+eabeuutt7Rnzx6VlJTou+++0z/+8Q+NHj26xlKShoqJiVGnTp20YcMGHTx4UCtWrFBubm7gPzGNpX///urbt6+2bdumOXPmaN++fTp48KDeeuutWv8jFGo333yz4uLidO+992rFihUqKSkJ7HT38ccf63e/+10gICdVBupWrVqlt956K5C3JtT38OvVq5emT5+uvLw8eTweff3113rxxReVkpKiK6+80lT3vffe05IlSwJL0rKzs7VgwQK1b99ep512WlA/o1tuuUVxcXF68MEHtX79enk8Hq1fv17//Oc/FRcXp1tuuSWo6zfEggULtH79er322mumcrvdrptvvlk2m00PPfSQdu3apZKSEs2bN0/fffedLr/88not6wOApsQYIjiMIWreY+nSpVqwYEEg7cb69es1b948tWrVqsbO11Ll7sMvv/yy1qxZI4/Ho40bN+qRRx6R2+3WpEmTgv4ZhcMYwu+xxx7Ttm3bVF5erjVr1uiee+6R2+3WHXfcUes4LS8vT3PmzNH+/ft1+PBhffnll3rggQc0ZMgQXX311Y397QBAs7EZTZGt+Dizc+dOzZkzR6effjqJ9SPEZ599prfffjvwtLdPnz669NJLdc899wTqTJ48WaNHj5YklZeX69VXX9XixYt14MABJScn67zzzlPXrl11zz336KqrrtKvfvUr0z0qKir00Ucf6X//+5+2bdsml8ulTp066eyzz9ZZZ50VGMDUlrx71KhRuvnmm3X99dfXeFr6f//3f0pOTpZU+RR0zpw52rZtm9q0aaNzzjlHl19+eb1/DlbvXVxcrJdfflnffvut9uzZo7i4OA0dOlQpKSl64YUXAvUXLFigl156qcbT8ssvv1yjR4/WxIkTTeUZGRl64IEHak0AvmDBgsDXe/fu1SuvvKLvv/9eBw4cUNu2bdW3b19dcsklNZ5yb968Wffcc4969eqle+65p97LrRpyj1WrVumuu+7S5Zdfrn79+unll1/Wli1b5Ha7NXToUF177bWm3QB37dqlxYsXa9myZSooKFBpaak6dOigIUOGaOzYsUpISJAk3XnnncrOzq7xs0tOTq7Rb0lJSXrqqacCx7t379Yrr7yiZcuWqbCwUHFxcRoyZIguv/xy046JM2bMqDFrZfLkycrIyKjRP9XvUR+LFi3SnDlzNG7cOF166aU1zm/fvl0vvviiVq1apbKyMnXr1k0XXXRRjSVDR2tv1Xb7P7MIfwcOHNDnn3+uG264wXLOzpaAMUTkYQyhoO7NGOLIPfbt26clS5bom2++UX5+vg4dOqT27dsrIyNDl156aY3dsseMGaOMjAz9/ve/1zPPPKOcnBx5PB7169dP48ePN+Xli+QxxP79+/XKK68oJydHe/bskcfjUXJysk499VSNHTu21t2L161bp3feeUdr167Vvn375HQ61a1bN40aNUpnn312rYFFhK9IGUMAoUKgsBEwyEdd/IPkm2++ObC8CMefqoHC6jMHAVgTKYN8xhCoC2MINJQ/UNiQnZiB41GkjCGAUOFRCNAIJk2apMLCwhrl33//vZxOpwYPHtz0jQIAAC0eYwgAANCcCBQCjWDbtm167LHHtHXrVnk8HuXn52vu3LlaunSpfv3rX5uWlQIAAPgxhgAAAM3J2dwNACLRpEmT9PXXX2vq1Kk6cOCAnE6nevXqpdtvv13Dhg1r7uahGVXNhTRv3jzNmzdP999/vwYOHNiMrQIAtBSMIRCsqvkGs7OzNWbMGNKdAADqjUAh0AjOOeccnXPOOc3djHrx58s7FnLchEbVBOnHg6NtJlIVG4sAQCXGEAhWpPysGUMAQPMgUAgc5wYOHHjcBa/QdG6++WbdfPPNzd0MAEAjYAyBxsQYAgCaBzkKAQAAAAAAABAoBAAAAAAAAECgEAAAAAAAAIAIFAIAAAAAAAAQgUIAAAAAAAAAYtfjRnXo0KHmbgIAAMeFSPubG2nfDwAALRV/cwEzAoWNwOv1SpKWL1/ezC0BAOD44v8bHK4YQwAA0DzCfQwBhAqBwkbgdFb+WM8880y1a9eumVvT8jkcDrVp00YHDx5URUVFczcH9UCfhR/6LPzQZw2zf/9+LVmyJPA3OFwxhmgYPifhhz4LP/RZeKG/Gi5SxhBAqPBJaESpqanq1KlTyK7n8/mUl5enlJQU2e2Rk17SMAx5vV517dpVNputuZsTUvRZ+KHPwkuk9pdEnzXUzp07tWTJkpBdr7kxhqgfPifhhz4LP/RZeInU/pIYQwBNJXJ+IwIAAAAAAACwjEAhAAAAAAAAAAKFAAAAAAAAAAgUAgAAAAAAABCBQgAAAAAAAAAiUAgAAAAAAABABAoBAAAAAAAAiEAhAAAAAAAAABEoBAAAAAAAACAChQAAAAAAAABEoBAAAAAAAACACBQCAAAAAAAAEIFCAAAAAAAAACJQCAAAAAAAAEAECgEAAAAAAABIcjZ3AyJVaWmpCgsLFRMT0+DX2mw2xcfH13quoqJCBw4ckN1uLcbrdDoVGxtb67ny8nKVlJRYuq4kud3uOr/f0tJSlZaW1nrOMAx5vV45nU7ZbLZa67Rq1UpRUVG1nisuLpbH47HWaEmxsbFyOmv/KBw8eFAVFRVBXbsuBw4csHzdY71HDh48aPna9XmP1KfPamP1PVIfoXqP+Hw+FRYWKjo6OvA5a8z3SFxcXJ2f53B+j1jV0PdIbf1Vl3D7PeL/nLVv314Oh6PWOuH6Hqlvn9XmaO+RSMEYwux4HEP4fD75fL46z4frZz+SxxB1/T1iDGHWkn6PROoYoupnLD4+PuLeI4whgMZHoLCR5OTk6J133lHbtm0b/Fq3261rr7221nMHDx7Ue++9Z3mQn5ycrIsuuqjWc9u3b9fChQstXVeS+vfvrzPOOKPWc9nZ2frhhx9qPWcYhnw+n+x2e50DxlNPPVUDBw6s9dxXX32lTZs2WWu0pPPPP19dunSp9dwHH3wQ1B/RK6+8ss5zr776quXrHu09UlhYqNdff93ytY/2Htm2bZsWLVpUrz6rjdX3SH0MGzZMGRkZtZ5bunSpNm/eXK/r+Hw+FRUVmQbfv/jFL9S5c+da6wf7HrnqqqtqHbAYhhHUeyQqKkrjx4+v9Vyw75GUlBSNGTOm1nP+94hVAwYM0Omnn17rudreI7X1V11C9R6pTWO8R/yfs2uuuUatW7eu9Xw4vke2bt2qd955p159VpujvUciBWMIs+NxDOHz+XTWWWfVeZ4xhFlLGEPU9feIMYQZY4iaQv0eqfoZu/rqqyPqPcIYAmgaLD0GAAAAAAAAQKAQAAAAAAAAAIFCAAAAAAAAAJJshmEYzd2ISLNz507961//0vjx49WxY8cGv76u5LA+n087duxQ69atSUReRUtLIFz92gUFBUpJSanRZ+GaQDiSE5FLlZ+z/Px8JScnR9RmJlX7zOfzRVQi8ur9VZdw+z0SqZuZlJaWavPmzfXqs9rU9R7ZuXOn5syZoxtuuEGdOnVq8HVbCsYQNR2PYwifz6eSkhJ16tSp1v4Kx89+pI8h6vp7xBjCrCX9HonUMUQkb2bCGAJoGmxm0kiio6MVHx9vKRH50TgcDrVt29byIP9o3G633G53yK8rVf48oqOjaz1ndcDoV1uS/1Bp06ZNUK8/2o6FoX5v+PnfI43B/x4Jts9qc7T3SLAa8h7x+XwqLS2t9+cs2PfI0YTze6Qx1PYeaWh/1aUl/h7xf86O9n2F63vE//exMf6WRQLGEGbH4xjC/7utLuH62Y/kMYSVv0eMIcwYQ9Rk5T1S389YuL5HGEMAjY9PFwAAAAAAAAAChQAAAAAAAAAIFAIAAAAAAAAQgUIAAAAAAAAAIlAIAAAAAAAAQAQKAQAAAAAAAIhAIQAAAAAAAAARKAQAAAAAAAAgAoUAAAAAAAAARKAQAAAAAAAAgAgUAgAAAAAAABCBQgAAAAAAAAAiUAgAAAAAAABABAoBAAAAAAAASHI2dwOCVVRUpCeffFJffvmlJk+erNGjRzfo9S+99JLmzZtX5/kHH3xQaWlpwTYTAAAAAAAAaNHCOlC4dOlSPfnkk/J6vUFdp02bNoqLi6v1XFRUVFDXBgAAAAAAAMJB2AYK33//fb366qv64x//qC+//FKLFy+2fK1f/OIXuvLKK0PYOgAAAAAAACC8hG2Owh49eujxxx/XSSed1NxNAQAAAAAAAMJe2M4oJG8gAAAAAAAAEDphGygMpc2bN2vatGnasGGDDh06pISEBA0ZMkTjxo1TQkJCczcPAAAAAAAAaHRhu/Q4lHJzc3XaaafpiSee0EsvvaQJEyYEdlHeunVrczcPAAAAAAAAaHTHfaBwxIgRevTRRzV69GjFxsYqOjpaw4YN06RJk1RUVKTHHnusuZsIAAAAAAAANLrjPlDYuXNnpaSk1Cg/5ZRT1LZtW23atElbtmxp+oYBAAAAAAAATYgchXWw2WxKTk7WgQMHtH37dvXo0aPWert27dKuXbtMZbt371ZxcbEkyefzhaxN/muF8potgWEY8vl88vl8stlszd2ckKLPwg99Fl4itb8k+ux45nK5JDGGqA8+J+GHPgs/9Fl4idT+kiK3z4CWhkDhURiGccw6s2fP1tSpU2uUX3755ZKkvLy8kLeroKAg5NdE46LPwg99Fl7or/BDn9VtwoQJkhhDgP4KR/RZ+KHPwg99BjSu4zpQuHv3bt1666164oknFBsbazpnGIby8/MlVS5PrsuNN96oMWPG1LjuwoULJanWZc1W+Xw+FRQUKCkpSXZ75KwaNwxDXq9XTqczIp960WfhhT4LL5HaXxJ91lCNEVRrLs8++6wmTJjAGKIe+JyEH/os/NBn4SVS+0tiDAE0leMiUFhSUqJHHnlEbdq00R//+Ec5HA5Jlb9oDhw4oBUrVmj48OGm1yxdulSFhYXq0aNHncuOJaljx47q2LGjqWznzp366quvJKlR/ujY7faI+2Pm/54i7Y+ZH30Wfuiz8BJp/SXRZ8czj8cjiTFEffA5CT/0Wfihz8JLpPeXFHl9BrQ0x0WgcPny5fr+++8lSRdccIFSU1MlKfCLc/bs2aqoqNAJJ5wgt9utH374QU8++aRiY2N1yy23ROwvWAAAAAAAAMAvbAOF+fn5mjhxoqls5syZmjlzppKSkvTUU08Fyvv376+UlBS1adNG3bp1C5QnJSXp0Ucf1SeffKJXX31Vs2bNks/nU4cOHTR8+HBdcsklSkxMbLLvCQAAAAAAAGguYRsoTE5O1oIFC+pVNyEhQXPmzKn1XGpqamCGIQAAAAAAAHC8YmE/AAAAAAAAAAKFAAAAAAAAAAgUAgAAAAAAABCBQgAAAAAAAAAiUAgAAAAAAABAIQgUHjx4UI8++qhGjBihxMRERUVFKTExUSNHjtT06dN18ODBULQTAAAAAAAAQCNyBvPib775Rpdeeql27twpSTIMQ5K0d+9eff755/r88881ffp0vfbaazrllFOCby0AAAAAAACARmE5UPjjjz/qnHPOUVFRkRwOhzIzM9WjRw/FxMSopKREW7ZsUVZWlrZv365zzz1XK1asUPfu3UPZdgAAAAAAAAAhYjlQOHXqVBUVFemPf/yj/v73vyshIaFGnb1792ratGmaNWuWpk2bpqeffjqoxgIAAAAAAABoHJYDhR999JEmTpyoGTNm1FknISFBM2fOVElJid5//32rtwIAAAAAAADQyCxvZrJ3715dddVV9ap79dVXa+/evVZvBQAAAAAAAKCRWQ4Utm/fXq1atapX3ZiYGCUmJlq9FQAAAAAAAIBGZjlQOHz4cH322Wf1qvvZZ5/pzDPPNJXt3r1b06ZNs3p7AAAAAAAAACFkOVB4xx136MEHH9Q333xz1Hpff/21Zs2apalTp5rKCwoKapQBAAAAAAAAaB6WNzPJzs7WqFGjNHz4cJ111lkaPny4UlJS5HQ65fV6lZ+fr88//1yLFi3SLbfcos8//1yff/554PXbt28PyTcAAAAAAAAAIHiWA4XXXnutbDabDMPQRx99pI8++qjWeoZh6OGHH7bcQAAAAAAAAACNz3KgUJI6duwol8tl6bUej0e7du0K5vYAAAAAAAAAQsRyoNBms+njjz9WWlqapddnZ2crMzPT6u0BAAAAAAAAhJDlzUwMwwjqxv5lywAAAAAAAACan+UZhT6fL6gbp6enB30NAAAAAAAAAKFheUYhAAAAAAAAgMgRdKBwy5YtuvnmmzVw4EC1bdtWq1evliS9//77uvvuu1VQUBB0IwEAANB4fD7SwQAAACDIQOHbb7+tgQMHatasWcrJydHBgwcDeQfz8vJ03333acCAAfr4449D0lgAAACEXoXPR7AQAAAA1gOFmzZt0lVXXaXi4mKlpqbqwgsvlM1mC5wfP3685s+fr5SUFI0dO1abNm0KSYMBAAAQYobk8VQ0dysAAADQzCwHCmfMmCGv16s33nhDa9as0fz5802BQofDoQsvvFDffPONunbtqkcffTQkDQYAAEDoeTxsMgcAAHC8sxwoXLhwoW677TZdfPHFR60XGxurv/zlL/rf//5n9VYAAABoZB4vMwoBAACOd5YDhdu2bdOZZ55Zr7oZGRnatm2b1VsBAACgkXm9zCgEAAA43lkOFPp8Prnd7nrVPXjwoJxOp9VbAQAAoLEZzCoEAAA43lkOFHbr1k2fffZZveq+8sor6tmzp9VbAQAAoAl4yVMIAABwXLMcKDzvvPP0wAMPaNGiRXXWMQxDjz32mJ5++mldcMEFVm8FAACAJsDOxwAAAMc3y+uB//znP+vpp5/W2WefrdGjR2vEiBEyDENvvvmmFi5cqDVr1uiDDz7Q1q1b1a5dO91yyy2hbDcAAABCjJ2PAQAAjm+WA4UdO3bUm2++qYsvvlgLFy4MzCy85557AnUMw1BcXJzefPNNJSYmBt9aAAAANBqfz1BFhU8Oh+VFJwAAAAhjQY0CR48ereXLl+uyyy5TdHS0DMMI/IuOjtYVV1yhZcuW6YwzzghVewEAANCImFUIAABw/Ap6K+LevXvr5Zdflsfj0bp161RYWKj4+HilpqbWe1dkAAAAtAweb4Wigx8iAgAAIAyFbBTocrmUnp5uKtu/f78OHjyobt26heo2AAAAaETsfAwAAHD8srz0+LrrrtOuXbuOWufjjz9Wjx49dNJJJ2nr1q1WbwUAAIAm4vX6ZBhGczcDAAAAzcByoPD555/X/v37j1rn5JNP1rRp05SXl6c77rjD6q0AAADQhMhTCAAAcHyyvPS4Pk+ae/bsqb/97W864YQTdOONN1q9FQAAAJqQx1Mht9vR3M0AAABAEwtq1+P6iouL0+7du5viVgAAAAiS18uMQgAAgONRvWcUvvDCCzXK5s+fr++//77O1xiGoX379un5559Xp06drLUQAAAATcpDoBAAAOC4VO9A4bXXXiubzWYq+9vf/lav1xqGQY5CAACAMGH4DHm9PjmdTbL4BAAAAC1EvQOF3bp1MwUKt27dqo4dO8rlctV9cadTKSkpGjNmjG655ZbgWgoAAIAm4/FWECgEAAA4ztQ7ULhlyxbTsd1u18cff6y0tLRQtwkAAADNzOvxSdHN3QoAAAA0JcuPibt37y632x3KtgAAAKAZGYYR+NrjqWjGlgAAAKA51HtGYXWbN28OZTsAAADQxDyeCuWuLtD3y3bq+2U7tG79Hj3/9CWKinKqosKQz2fIbrcd+0IAAACICJYDhcfi8/m0b98+dejQobFuAQAAgCBs3rxfEya+ZSpbu26PBg1MkVQZSIyKarThIgAAAFoYy0uPS0tLde+992ratGmaN2+e6dxdd92l1q1bKzk5WX369NHixYuDbigAAABCq3fv9optbU4lk51bEPja4/E1dZMAAADQjCwHChcsWKB77rlHU6ZM0dtvvx0o/9e//qV//OMfKisrk2EY2rRpky688EJt3LgxFO0FAABAiDgcdg0alGIqy6kaKPSSpxAAAOB4YjlQ+N5776l9+/b67LPPAjMKfT6f/vnPf8pms+nSSy/VihUr9PLLLysqKkrTp08PWaMBAAAQGicM7mg6zl1doIqKypmEXi8zCgEAAI4nlpPOfPPNN/rrX/+q4cOHB8o+/fRT7dq1S4mJiXrhhRcUHR2tQYMGacuWLXruuedC0V4AAACE0OBMc6CwpMSjLT8eUO9e7SWjclahy+loptYBAACgKVmeUbh161adeuqpprL33ntPkvTrX/9a0dHRgfJhw4Zp69atVm8FAACARpKRliSXyzwkzM7JD3ztJU8hAADAccNyoNDlcsnhMD9dfuedd2Sz2XTJJZeYylu1aiWv12v1VgAAAGgkUVFODeifaCozb2hCnkIAAIDjheVAYbdu3bRy5crA8ddff63169crJSVFp512mqnuli1b1K5dO+utBAAAQKPJHFhtQ5OcfBmGIYmdjwEAAI4nlgOFZ5xxhu69914tXrxY33zzjW688UbZbDZdddVVpnqGYWjOnDnq379/0I0FAABA6FXPU7h332Hl5R+SJPl8RmBzEwAAAEQ2y4HCW2+9Vbt379ZZZ52lYcOGadWqVWrTpo3+8Ic/BOrMnj1bZ555phYtWqQzzzwzJA0GAABAaA0cmFyjLDun6vJjAoUAAADHA8uBwl69eum9995TZmam3G63Bg4cqLfffltdunQJ1JkyZYo+++wzGYahK6+8MiQNBgAAQGjFx0Wre7e2prKc3CMbmni85CkEAAA4HjiDefGoUaP0ww8/1Hl+165dwVweAAAATSQjPUk/bj0QOK46o5CdjwEAAI4PlmcUAgAAIHJkpJmXH2/bXqgDhaWSJK/XF9jcBAAAAJErJIFCn8+nZcuW6a233lJRUZEkqaSkJBSXBgAAQBPISE+qUZabS55CAACA40nQgcKHHnpIycnJOvnkk3XppZdq+/btkqSXX35Z3bt315w5c4JuJAAAABpXUlKsEhNbm8qyq+Yp9JCnEAAAINIFFSi85ppr9Ne//lV79+6tsRylV69eKi0t1e9+9ztNnDgxqEYCAACg8aWnmWcV5lSZUej1MqMQAAAg0lnezGTBggV68cUX1alTJ02aNEn9+vXTZZddFjh/5plnaufOnZo6daruv/9+XXDBBbroootC0uhwEBsbK6fTGdJ8PoZhBK4ZSXmC/N9LJH1PfvRZ+KHPwkuk9pdEnzWU0xnU/mwtSkpKSpOPIfzlGWlJ+uTTzYHy9Rv26vDhckVHu1TuqWhx70c+J+GHPgs/9Fl4idT+khhDAE3F8ifimWeeUZ8+ffTDDz8oNja21joOh0PTpk3T+vXrNWfOnOMqUHjCCSeoXbt28nq9Ib1uu3bt5PP55PNF3lP9iorIXNJEn4Uf+iy8RHJ/SfRZQ64ZKX7zm99IUpOOIbzeCnkrvOrfL8FUXlFhKHdNgQYNTJYqpNLScjmdLW8vPD4n4Yc+Cz/0WXiJxP6SGEMATcFyoPC7777T/fffX2eQsKqrrrpK1113ndVbhaXly5dr4MCBSkxMDNk1fT6f9u7dq4SEBNntLW+QbpVhGKqoqJDD4ZDNZmvu5oQUfRZ+6LPwEqn9JdFnDbV79+6QXau5Pf300xo7dmyTjiEMwyanw6lePRMU29qtQ8XlgXOrV+/RiYM7V9aTrUXNvOBzEn7os/BDn4WXSO0viTEE0FQsj/T27t2rtLS0etXt2LGj9u/fb/VWYenQoUPyer0h/eVss9kC14y0X/qSIvL7os/CD30WXiK9vyT6rL5CPfuuOeXl5TX5GMJf7nDYlJaWpG+/2x44l7O6IPCaCq/RIt+PfE7CT6R9b/RZ+In0PovE74sxBNA0LIfhW7durby8vHrVXbduneLj463eCgAAAE0ko9qGJqvX7FZFReUSL3Y+BgAAiGyWA4WDBg3Ss88+e8x6ZWVleuSRR3TCCSdYvRUAAACaSEZ6sun48GGvNm2uXBlSUWHI54u8BPkAAACoZDlQ+Otf/1rz58/XNddco507dwbK/VOADcPQ4sWLNWLECC1fvlzXXHNN8K0FAABA6FVZwZWamiCXyzxEzM7JD3zNrEIAAIDIZTlQOGHCBJ122ml68cUX1bVrV6Wmpsrn8+maa67RiSeeqPj4eJ111ln69ttvNXLkSP36178OZbsBAAAQIk6HPRAsdLsc6pvawXQ+J7cg8LXHE3m7gwIAAKCS5UChw+HQO++8o3POOUeGYWjjxo0yDEM//PCDVqxYoUOHDskwDJ1//vl68803Iy6RKgAAQKSw2WxyOo8MC6svP87OyZdhVC459niZUQgAABCpLO96LElt27bVBx98oI8//livvvqqsrKyVFhYqPj4eGVmZuqyyy7TWWedFaq2AgAAoJG4nA55f5otmJGWpFeqnNt/oFQ7dx1U505x8nqZUQgAABCpggoU+p199tk6++yzQ3EpAAAANAO326HDhz2SpLQBSbLZJKPKviXZOfnq3ClOMipnFbqcjmZqKQAAABqL5aXHDVFSUqLPPvusKW4FAAAAC6puYBIb61aP7u1M56vmKfSSpxAAACAiNUmgcPPmzTrzzDOb4lYAAACwoGaewiTTefOGJuQpBAAAiEQhWXq8detW7dq1S2VlZbWe37RpUyhuAwAAgEbkcjkCOQgz0pL1zntrA+e27yjS/v2H1a5dK3Y+BgAAiFBBBQqfeeYZ3Xvvvdq6dWuo2gMAAIBm4nLZdfhw5dfp1WYUSlLO6gINH9ZdPp+higqfHI4mWZwCAACAJmJ5dPfcc89p4sSJ+vHHH2UYxjH/AQAAoGVzuY5sUJLYobWSk2NN53Nyqi4/ZlYhAABApLEcKJw+fbpiY2P19NNPa9u2bfJ4PPL5fLX+W7lyZSjbDAAAgEZgt1fLU5hmnlWYnZsf+NrjJU8hAABApLEcKFy3bp0eeughTZgwQZ07d5bD4aizrs1mY1YhAABAGHBW2f04vVqgcMPGfTp82COJnY8BAAAikeVAYfv27TV06NB61U1PT5fPx2CyKfB0HwAABMNdZflxRnqy6ZzPZ2j12t2SJK/Xx4NgAACACGM5UPiLX/xCGzdurFfdkpISffbZZ1ZvhQbwlBOQBQAA1lXNU9i1S7zatIkynSdPIQAAQOSyHCi899579fTTT9drx+PNmzfrzDPPtHorNIDHw4xCAABgnd1uk8NhC3ydPiDRdD47t2qgkHEHAABAJHFafWFycrJefPFF/fGPf5TNZtOQIUOUkJAgu71m7HH79u1BNRL15/lpGZDNZmvupgAAgDDlcjtUcdgrqXL58dffHhnLrV6zW16vT06nXV4vMwoBAAAiieVAoST9+9//1vz581VWVqZXXnklVG1CEAzDkNfrMy0bAgAAaAiX06FSVQYKq29oUlbm1cZN+9Svbwd5CBQCAABEFMuBwjlz5mjatGmSpOjoaCUkJMjprP1yHo9Hu3btsnorNFB5eQWBQgAAYJnbfWQckdonQW63Q+XlR5YZZ+fkq1/fDjJ8RmB2IQAAAMKf5UDhE088oc6dO+ull17S8OHDj7rUNTs7W5mZmVZvhQbi6T4AAAiGP09hRYUhl8uh/n07aGV2fuB8Tm6BLrk4XZLk8VYQKAQAAIgQlkd1GzZs0MMPP6zTTz/9mPnwoqKi1K1bN6u3QgN5PBUyDKO5mwEAAMJY1dUJ6enm5cfZuQWBsYaXnY8BAAAihuVAYXx8vPr27Vuvuqmpqdq8ebPVW6GhDMnDoB0AAAShaqAwIy3ZdK6wsFTbdxRJYudjAACASGI5UHjhhRdqxYoV9aq7e/fuQD5DNA0G7QAAIBgu15Fh4oABibLbzStIcnILJEkVFYZ8PlYyAAAARALLgcL77rtPs2fP1nfffXfMugUFBZo6darVW8GCcgKFAAAgCA6HPRAcbB3jVq+e7Uzns3OP5CzkASUAAEBkCGozk5NPPlnDhw/XkCFDNGTIECUkJMhurxl7LCgoCKqRaDiv1yfDMI6ZPxIAAKAubrdDpaVeSVJ6WpI2bNwXOJedc2R85/H4FBXV5M0DAABAiFkOFE6ZMkU2m02GYejrr7/WN998U2ddAlbN4Kc8hW6349h1AQAAauF02aXSyq/T05I1/501gXO7dh3U3n0lSmgfI4+XGYUAAACRwHKgUJKGDBmi1q1bH7NecXGxli1bFsytYIHHU0GgEAAAWOY2bWiSVON8Tm6BzhjeQ14vm6gBAABEgqAChc8995zS0tKOWS87O1uZmZnB3AoWlHsqdOwwLgAAQO38eQp9PkMJCTHqmBKrXXmHAudzcioDhTIkj7dCLicPKAEAAMKZ5c1MunfvLrfbXa+6sbGxOuOMM6zeChb58xQCAABYVXX34/S0ZNO5qhuaeD3MKgQAAAh3lgOFmzdvVp8+fepVt0ePHlqyZInVW8Gqn/IUAgAAWOWqksYkI928/HjT5v0qLimXxM7HAAAAkcByoLAhdu7cqeuuu64pboVqyssZtAMAAOuqLieuPqPQ5zO0Zs1uSTycBAAAiARNEijcv3+/nn/++aa4FaphF0IAABAMp9Mum90mSeraJU7xcVGm89m5BZIqg4YVFQQLAQAAwlm9NjPZs2ePPv/8c51zzjmKiYmRJE2bNq3eNykoKLDWOgTN66nMU2iz2Zq7KQAAIEy5XXaVlVXIZrMpPS1JS7/eFjiXnXNknOfx+ORwNMlzaAAAADSCegUKzzjjDK1du1YXX3yxXn/9dUnSlClT6h18IlDVvDwen9xudiEEAADWuFwOlZVVrlJIT0s2BQrXrtstj6dCLpdDHm+Fous3vAQAAEALVK+RnGEYgX9VDRkyRK1btz7m64uLi7Vs2TJrLUTQyssrCBQCAADLXK66NzQpK6vQho37NKB/IjsfAwAAhLl6BQo/++yzwNLjqp577jmlpaUd8/XZ2dnKzMy01kIEjV0IAQBAMPx5Cg2foT69ExQV5VRZmTdwPjs3vzJQ6CXlCQAAQDirVxKZxMREjR071jR7sHv37nK73fW6SVRUlLp162athQiaf9AOAABglctZOWx0Ou0a0K+D6VxOrjlPIQAAAMKT5WzTmzdvVp8+fepVNzU1VZs3b7Z6K4RAeTmzCgEAgHVV05ikpyebzuXkFsjnq3woyUoGAACA8GU5UPjCCy+oqKjoqHVef/119erVS7fddptKS0ut3gr1lJ9/SAsXb9SjM77Uli37Ted4ug8AAILhdB0ZNqanmfMUFhWVafuOQkmVKxkAAAAQnixvSzdhwgQNHTr0qDkKu3btql69emnmzJlyOp168MEHrd4OR+HzGbr8qle0YeO+QFn3bm3Vo0e7wDFP9wEAQDBcTkcgT+GAfomy222BWYSSlJ1ToG5d28pDoBAAACBsWZ5RWJ+cd6eccooWLlyof//733r99det3grHYLfb1DY+2lSWtSrPdOz1+kyDeQAAgIby5ymMiXGpd6/2pnPZOfmSJMNnMKsQAAAgTFkOFDbECSecoO3btzfFrY5bQ4d0Nh1nZ+erosI8SGdWIQAACIbLVSVPYbXlx6YNTbyMOQAAAMJRvZceb926NfC1fzbhrl27FBsbW+drDMPQvn37NH36dMXFxQXRTBzL0CGdpf/7LnBcctij9Rv2qn+/xECZx+NTVFRztA4AAEQCl9suFVd+nZGerLcXrA6cy8s/pD17itWhQ2t5PT4puo6LAAAAoMWqd6CwZ8+eNcrOPvvset/osssuq3ddNNzAjGRFRzlVWuYNlGWtzKsWKOTpPgAAsM7ldEg2SYaUUW1GoSRl5xZo5Bk9GXMAAACEqXovPTYMw/SvtrLa/tntdp177rmaMWNGY30PUOVSoMGZKaayrJXkKQQAAKHlX37crl0rde5kXjHiX35cUWEw5gAAAAhD9Z5RuHnz5sDXhmGod+/e+uijj5Samlr3xZ1OdejQQVGsd20SQ4d01tffHskFmZ1bII+nwpRPyOOpUFSU5c2uAQDAcc7tcshTXjljMD0tSTt2FgXO+Tc0kRhzAAAAhKN6j966d+9uOjYMQ506dapRjuZTfUOTsjKv1q3fa0o2Xs6gHQAABMHlOrIgJSMtSR8v3BA43rxlv4qLy9W6tZvcyAAAAGHI8q7HmzdvVt++fUPZFgRpwIBEtWplDgJmrdxlOvZ6zDshAwAANITTaa/MU6jKDU2qMgwpd3Xl8mN2PgYAAAg/lgOF3bt3l9PJzLSWxOV01BiwryBPIQAACCGbzRZIa9KpUxu1bWve3jj7pzyFXi8PJwEAAMKN5UAhWqbMQeYNTXJXF6i83PxEn50IAQBAMFzOyiGkzWZTRpr5IaV/QxMZzCoEAAAINwQKI8zgQR1Nxx6PT6vX7DaVlRMoBAAAQXC7j2yUlp6eZDq3Zu3uwFiDlCcAAADhhUBhhOnVq51iW7tNZVmrzMuPPeUECgEAgHWmPIVp5kChx+PT+g17f/qaMQcAAEA4IVAYYRwOuzIyzEuAqm9oUlFhkKcQAABYZrPZKoOFknr3aq/oaHPe6pycnzY0YUYhAABAWCFQGIGq5ylcs3aPSku9prLqeQsBAAAawv3ThiYOh10D+ieazmXn5EuSfD5DFRUECwEAAMIFgcIINLhaoNDr9SlndYGpjOTiAAAgGP6dj6Way49zVhcEVi8wqxAAACB8WA4Ubt26NfDP54uMAWBRUZH++c9/asyYMVq0aFFzN8eyHt3bKS4uylSWtZI8hQAAIHRcrip5CtPNaU8OHSrX1q0HJPFwEgAAIJxYDhT26NFDPXv2VM+ePbV9+/ZQtqlZLF26VJMmTdKKFSuauylBs9ttGpRhnlW4slqgsKKCpUAAAMC6qnkK+/frIIfDZjqfnVu5moGdjwEAAMJHUEuP+/TpoxdffFEpKSnHrtyCvf/++5ozZ47++Mc/6pRTTmnu5oRE9TyFa9fvUUmJx1TGUiAAABAMl7Ny+XF0tEt9eieYzuX4A4VenwyDTdQAAADCgeVAocvl0owZM3TFFVfI7XaHsk1NrkePHnr88cd10kknNXdTQqZ6oNDnM5STm28q83hYCgQAAKxzu4/kKUyvlqfQv6GJxMNJAACAcGE5UNixY0clJSUdu2IYSEtLU2xsbHM3I6S6dY1Xu7bRprIV1fMUEigEAABBcLmODCWrb2hSsLtYBQWHJDHmAAAACBeWA4XnnHOOPv/883rVzcnJkcPhOHZFhIzNZqsxq7D6hibkKQQAAMGomqcwvdqGJlLl7sdS5fJjAAAAtHyWA4V33323/v3vf+v777+vV31y0zS9zEEdTccbN+3ToUPlpjKWAgEAgGC4XJUPg9vGR6tLlzjTueycykChh0AhAABAWHBafeGiRYt02WWX6fTTT9fZZ5+t0047TYmJibXOHNy+fbtsNlstV0FjyhxYM0/hqpw8nXpKt0CZx1Oh6GjLbwMAAHCcc7nsOny48uuMtGRt314UOOff0MTwGfJ6fYHZhwAAAGiZLEeIrr32WtlsNhmGoXfffVfvvvtuKNsVNnbt2qVdu3aZynbv3q3i4mJJks8Xuifo/msd7ZqGzyf/5M2UlNZKSIjR3r0lgfMrsnbplJO6BI5Lyzxq3doVsjZaYRiGfD6ffD5fxAWU69Nn4Yg+Cz+R2meR2l8SfXY8c7kq/y439RjCKofDFrhu2oBEffjx+sC5LT/uV2HRYbWJjVJ5uUd2e2jHHHxOwg99Fn7os/ASqf0lRW6fAS1NUFPJOnbsGBjMHo3H46kRTIsUs2fP1tSpU2uUX3755ZKkvLy8GueCVVBQUOe5fftKZejIMu9+qfFaWiVQ+MPyHSrY3d30mtLD0XI4IuuPSEtztD5Dy0SfhRf6K/zQZ3WbMGGCpKYfQwSjsLBM3gqfUlLMK0sMQ/rq6w0anJmowiKHYlu7G+X+kYrPSfihz8IPfRZ+6DOgcVkOFNpsNn388cdKS0s7Zt3s7GxlZmZavVWLduONN2rMmDGmst27d2vhwoWSpJSUlNpeZonP51NBQYGSkpJkt9e+dCc6+rAp7+DJJ/XQ0q+PBGm3bjuoqKg4xccd2RG5TRu3oqObb1ahYRjyer1yOp0R+dTrWH0Wjuiz8BOpfRap/SXRZw3VGEG15vLss89qwoQJTT6GCEZsbJkOH/YqsYOh9u2/1759hwPnduwo09k/T5LDYVf79q1Cel8+J+GHPgs/9Fl4idT+khhDAE3FcqCwIZuTREVFqVu3bseuGIY6duyojh3Nm4bs3LlTX331lSQ1yh8du91e53XdbpcqKjyB4xMGd6pRJztnt04/7ciswoqKxmlnfRmGEfieIu2Pmd/R+iwc0WfhJ9L7LNL6S6LPjmceT+Xf8aYeQwQjKsqlsrLKB5XpaUn6/IsfA+dyVu+W3W7/KTWKTXZ76N7PfE7CD30Wfuiz8BLp/SVFXp8BLY3lT5fP56vXbEJJSk1N1ebNm63eCg3gdpuX/KQkxyo5OdZUlrXSvAy8vLyi0dsFAAAil3/nY6lyQ5Oq1q3bExhreDyMOQAAAFoywvARxuWyS9UeHFXf/ThrlXlqtc9nqKKChLAAAMAau90WyHeckZ5kOufx+rR23Z7Krz2MNwAAAFqyoAOFBw8e1IwZM3ThhRcqMzNTGzZskCR9/vnneuaZZ1ReXh50Ixtbfn6+xowZozFjxmjx4sWSpJkzZ2rMmDG6/vrrm7l1DWOz2eR0mrs1c5A5ULh1a6H27z9sKivnCT8AAAiC66dVDT17tFNMK3Pu45zcysTzHi/jDQAAgJYsqF2Pv/rqK40dO1YFBQUyDEM2my0QGFy3bp0mTpyo+++/X2+88YYGDx4civY2iuTkZC1YsKC5mxEybpdD3ipP7KsHCqXKWYUjz+gZOPaUV6hVM25oAgAAwpvL6VCpvHI47BowIFHLftgZOJeTmy9poLxeZhQCAAC0ZJZnFPpn4eXn5ysmJkYDBw40nb/00ks1c+ZMHT58WOeccw5bmDeh6nkKEzu0VudOcaayrJXm5ccsBQIAAMFwuY4MKzPSzMuPc1YXVKY5MZhVCAAA0JJZDhTOnDlT+/bt06OPPqp9+/YpKyvLtPNQfHy8/vCHP+j777+Xy+XSo48+GpIG49iczlryFFabVVg9UOjzGTzlBwAAljkc9kCewvRqG5oUF3v049YDkmRa9QAAAICWxXKg8IMPPtBNN92kW265RS5X3UtWO3XqpDvuuEPvvfee1VuhgWw2m2n3QanmhiY7dhZpz55iUxlP+AEAQDD8449+fTvUyJkcyFNIXmQAAIAWy3KgcNOmTfrFL35Rr7pDhw7V5s2brd4KFrirBQoH1ZGnsCpPOQN3AABgnT9QGB3tVGrvBNO57Jx8SaQ7AQAAaMksBwrLy8sVHx9fr7per9fqbWBR1TxBktS+XSt162ruL/IUAgCAUDLlKUw35ynMzqnc/M7nMyrzFQIAAKDFsRwo7NSpk7777rt61X3nnXfUtWtXq7eCBS6X45h5CleQpxAAAISQw2GX3f5TnsJqgcI9e0uUX1CZ9oSHkwAAAC2T5UDh6NGjNXXqVK1Zs+ao9d58803961//0tlnn231VrCo+vLjzEEdTcf5+YeUl3/IVEbeIAAAEAy3u3L8kT4gqca5nNyflh+TFxkAAKBFshwo/POf/6zi4mINHjxYN9xwg+bOnSvDMPTtt99qwYIFeuihh3TGGWdo3Lhxstvt+tOf/hTKdqMeqm9oMigjuUadrJW7TMcECgEAQDCcPy0/jouLVrdu5rQn2TmVG5qw8zEAAEDL5LT6wtTUVD399NOaMGGCnn76aT399NOSpN/85jeBOoZhyOl06rnnnlOPHj2CbiwaxuW2S1U2No6Pj1bPHu20ecv+QFnWyjydc1Zq4LicgTsAAAiCy3nkQWVGWrK2bi0MHGf/NKPQ6/XJMAzZbLYarwcAAEDzsTyjUJJ+/etfa8mSJTr55JNlGEaNf6eeeqo+/fRTjRs3LlTtRQO4nA7Z7OYBePU8hVmr8mQYRuDYIE8hAAAIgtNZJU9hmnn58dathSoqKpVEnkIAAICWyPKMQr/TTjtNX331lbZv366srCwVFhYqPj5emZmZ6tKlSyjaiCC4nHaVlx9ZTpw5KEVvL1gdON6zp0Q7dx1U505xgTKPp0JOZ1AxZAAAcBxzuewqK6tQRnrNtCe5q3frZ6d0lcdTEchnCAAAgJYh6EChX5cuXQgMtkBut8MUKByYkSybTaoyiVBZK/NqBApbtXI1ZTMBAEAEcbkcKiurUHJSa3VIiNGevSWBc9k5+frZKV1ZwQAAANAChXTaWHFxsXbt2qXi4uJjV0aTqL6hSZvYKPXpnWAqq76hCXkKAQBAMPzjD5vNpox08/Lj7NzKDU08BAoBAABanKADhVu3btUf/vAHde/eXXFxcerSpYvi4uLUo0cPTZ48WVu3bg1FO2FR1TxBfjXyFK4kTyEAAAgdp9MeyJOcnmZefrx+w16VlXkZbwAAALRAQQUKFyxYoIEDB+qJJ57Qtm3bTBuZbN26VY8//rgGDhyoBQsWhKq9sMDlMndz5kBzoHD/gVJt215oKvN4KgQAAGCV+6fxR/UNTbxen9au2yNJ8ngZbwAAALQklnMUrly5UuPGjZPH41GHDh10xhlnqEePHoqJiVFJSYm2bNmiTz/9VHv37tWvfvUrfffddxo4cGAo2456crkr8wT5ZaQny263yec7Moswa2WeunVtGzguLydPIQAAsM6fp7BH97Zq3dql4mJP4Fx2boEGDUyR1+OTopuxkQAAADCxHCi877775PP5NH36dE2aNElOZ81Leb1ezZo1S7fffrvuu+8+vfLKK0E1Fta4q+UpjIlxqW9qgtas3RMoW5GVpwt/0T9wTN4gAAAQDOdPMwodDrvS+ifpu2U7Aueyc/IlsYIBAACgpbG89PjTTz/VrbfeqsmTJ9caJJQkp9OpW265Rbfccos++eQTq7dCkByO2vIUdjQdr8zOM80wNHwGy4EAAIBlLqcjkKcwI92cp3D16t2qqPCposIwjT8AAEDTWb16tbp27arTTjtNpaWlzd2csNejRw/ZbLbAvylTpjR3kyyxHCgsLCzUL3/5y3rVvfjii1VUVGT1VggBt9s8q7D6hiZFRWXa8uN+U5mX3Y8BAEAQXM7a8xSWHPZo85bKcQezCgEAaB7vv/++tm/frqVLlyonJ6e5mxP2Pv74Y61atUpDhw5t7qYExfLS4+Tk5GNXqqJjx47HroRG43I5VFrqDRynD0iS02k37TaYtTJPvXq2DxyTpxAAAATD5XKovLxC/fp2kMtpN6U2ycktUJ/eCfJ4fIqKasZGAgBwnLriiiv04YcfqmvXrho8eHBzNyfs9e3bV5LUunXrZm5JcCzPKBw1apQ++OCDetX94IMPdO6555rKdu7cqeuuu87q7dFA1Xc+jo52ql/fDqayrFV5pmPyFAIAgGC43JXjD7fbob7Vxh3ZuQWS2PkYAIDm0qlTJ/3vf//TM888I4fDcewX4LhgOVD4t7/9TU8++aRef/31o9Z79dVXNW/ePE2bNs1Uvn//fj3//PNWb48Gcjjscjiq5yk0Lz9etSpfFRVHgoPkKQQAAMGomqew+vLj7Jx8GYZhWt0AAACA5mU5UDh37lydeuqpuuyyy5SWlqYbbrhBd999t6ZNm6a7775bN954o9LS0vTrX/9ao0eP1hNPPKFp06YF/j355JOh/D5QD65j5Ck8VFyuTZvNeQo95QzeAQCAdXXlKdy377Dy8g9JBrMKAQDHny1btpg2vrDZbPrkk0+UlZWlsWPHKjExUdHR0UpLS9Ojjz4qwzj65l9LlizRuHHj1LlzZ0VFRalDhw4aPXq0nnvuOVVU1Pw7W/3ezz33XI06Xq9Xc+fO1ZlnnqmuXbvK7XYrMTFRI0eO1JQpU5Sbm1trW7xer5566imNHDlS7du3V1RUlDp16qSLLrpI8+fPt/TzkqSNGzdq0qRJysjIUFxcnFq1aqV+/frpmmuu0SuvvKLDhw8f9XV9+/ZVTEyMWrVqpd69e2vcuHF69tlndejQIVP9w4cP6+WXX9ZVV12lfv36KSYmRtHR0erZs6euueYaLV++3PL34Ldu3TrdcMMN6tWrl6KjoxUXF6fBgwfrr3/9q/Ly8o59gUZkOUfhlClTZLPZZBiG1qxZo7Vr19ao438jz549u9ZzNputRjkaj8vpUKmO5ClM658kl8suT5VNS1as3KXUPgmB48oE4+QpBAAA1vjzFFYPFEpSdk6BOqa0kdfjk8vJkicAwPGjc+fOWrVqlSRp4MCBkqQvvvhCb7/9tm6//Xb99a9/1apVq3T77bfrtttu0549e/SPf/yjxnUMw9DkyZM1a9Ys9evXT//85z81YMAA5eXladasWZowYYKef/55vfXWW2rbtm3gdf57n3POOdq5c2eN6/p8Pl1wwQX66KOP9Otf/1q33367EhMTtX37ds2ePVtTp07V1KlTawQw9+/frzFjxuiLL77QhRdeqGeeeUYpKSnKzc3VAw88oF/+8pf69a9/rRdeeEF2e/3nri1evFjnn3++OnTooL/97W/KzMxURUWFvvrqKz344IP673//qylTpuiee+4xve6ll17Sddddp6ioKN15550aOXKkDh8+rG+++UYPPfSQXn/9dT3xxBP67rvvAq955ZVXNGHCBCUlJemvf/2rTj75ZJWXl+ubb77Rww8/rJdfflnPP/+8rrzyynq3v6q5c+fquuuuU0xMjO6++26dfPLJKiws1Hvvvad//vOf+r//+z8tWLBAw4YNs3T9YFkOFErSkCFDLCdpLC4u1rJly4K5PRqo+s7HbrdDaQOSlLXySLR65co8jRubETgmTyEAAAiGP09ym9go9ejeVlt+PBA4l52Tr7NG95bHwwZqAIDji8vlUkZGhqns3//+t1atWqUOHSrz+p500knq2LGjzj//fM2cOVN33nmn2rRpY3rNgw8+qFmzZqlLly5aunSp2rc/skHpeeedp1/84hf68MMPddVVV+ndd98NnPPf2+Wq/e/vu+++q48++kjDhg3Tiy++GCgfMmSIxowZo7PPPlsLFy6s8borr7xSX3zxha688krNnTs3UP6zn/1M48aNU//+/TV37lxlZGTojjvuqO+PS7fddpvKysr07LPP6qyzzgqUDx8+XD/72c90xhln1AhafvHFFxo/frx8Pp+WLFmiU089NXBu5MiRGjVqlE477TR5PJ5a7/n+++9ryJAhptecd955OvnkkzVx4kSNHj26wRv9fvnll7r22mtls9n0xRdfKD09PXDu/PPPV69evXTbbbfp4osv1rp16xQfH9+g64dCUIHC5557TmlpaZZem52drczMzGBujway221yOGyqqDjy4ckcmGIKFGbnFKiiwieHo3JQ789TyFN+AABghcvlkGySDCkjPdkUKMzxb2ji4cEkAABXXXVVIEjoN2rUKNntdh0+fFjLli3TyJEjA+f27t2r+++/X5L0pz/9yRQklCS73a57771XH374od577z19/PHHOvvss+vVFv+y4tjY2BrnbDabJk2apKioKFP5Rx99pA8//FBSZQCzujZt2mjSpEm666679PDDD+u2226T01m/sNTR2nP66adr3LhxgV2H/W677TZ5vV6NGTPGFCT0O+mkkzRy5EgVFBSYygcPHqwZM2aYgoR+gwYN0qmnnqpPPvlEb7zxhm666aZ6tb96m6677jpTkNDvD3/4g+655x4VFBTo6aef1p/+9KcGXT8ULOco7N69u9xut+UbR0VFqVu3bpZfD2uOlaew5LBH6zfsNZWRpxAAAATD5aocf1Rffrxte6EOFJbK5zNMG6oBAHA8Oumkk2qU+fMNSqqRu+69995TcXGxJOnnP/95rdccOnSo2rVrJ6lys9n68gfdPv74Y02bNk1FRUWm87/85S9NMxSrXr9Xr17q2rVrrdft37+/JGnfvn0NyvXnb8+NN96or776qsb5V1991bQUeOvWrfrmm28k1f2zkaTHH39cTzzxhKls8ODBmjx5cp2v6d69uyRp9erV9W6/JG3btk1ff/21JJkCvlW53W716tVLkrRo0aIGXT9ULAcKN2/erD59+li+cWpqqjZv3mz59bDG7TIHCvv17aCoKHMEf0WW+ZdPZZ5CAAAAa/wbmmTUkqcwl1mFAABIkhISEmotb9WqlSSptLTUVL5y5crA1/7gUm169uwpScrKyqp3W375y19qzJgxkqR77rlHycnJGjNmjP7zn/9ox44dtb7Gf/1NmzbJ6XTW+m/cuHGB+lu3bq13e2bOnKk2bdpo1apVGjZsmPr27atbb71VixcvrnWzlvr+bPr27VtrLsCsrKzAJr1xcXFyuVyB7+GFF16QpBqboBxL1Z//tddeW+fPyJ8/siE/n1AKaukxwo+rWqDQ5XIoIy1Jy5YfSV6atWqXLv/VwMBxOYFCAAAQBLfboZISj5KSYpWU2FoFu4sD57Jz8zXs1G7yeCsUzdAUAHAcczgalvKrsLAw8LU/mFibmJiYGvWPxW636+2339Zrr72mOXPmaMmSJXrnnXf0zjvv6KabbtL555+vxx57zLTc13/9E088Uc8///wx79GlS5d6t+fMM89Udna2Zs2apRdffFHr16/XY489pscee0wdO3bU7bffrj/+8Y+BTXPr+7OpzTPPPKOJEyfKZrPp+uuv10UXXaROnToF+udvf/ub5s+ff8ydqKur2qY5c+bolFNOOWr9YFbxBoPR2HHGbrfJ6bTLW2WTksxBKaZAYU7ubnk8FUeCiobMxwAAAA3gdNoDeQrT05JU8OmRVSXZOZUzCr3MKAQAoEGqbnRRUlJSa/4+/7nq9evDZrPpV7/6lX71q1+poKBAb7/9tubNm6clS5bovffe01dffaXs7Gx17NjRdP2KiooaG7WEQrdu3fTwww/rn//8p7788ku98cYbmjt3rnbt2qWbb75ZeXl5gZ2hq36vhw8frvc9CgoKdNNNN8nn8+mvf/2rHnjggRp1qu4e3RBV25SQkNAoP6NQsLz0GOGresCvep7CsjKv1q7bYypjORAAALDKZrMFxh8Z6ebdATds3KvSUo+8Xl+Dn8wDAHA8GzRoUODrTZs21VnPn/YtmA1lk5KSdMMNN2jx4sX65JNP1KpVK+3bt09PPfVUoI7/+hs2bKh1ObDf4sWL9dRTTzV46a6f3W7X6aefrhkzZujHH3/UpZdeKkl67LHH5PV6TW2Rjv6zKS8v16FDh+TzVcY8vvjiC5WVlUmSLr74Ykvtq0vVNq1Zs6bOegcOHNBTTz2lzz77LKT3ry8Chcchd7UNTVL7JCimlXlL9Ko7IUssPwYAAMGpK09hRYWhNT89oOTBJAAA9XfBBReodevWkqT//e9/tdb57rvvtH//fknSZZddVu9rP/LII3XuSzFixAidc845kqRdu3YFyv3XLy4u1pIlS2p9rdfr1RVXXKGpU6cG2l4fKSkpevLJJ2uUx8TE6G9/+5ukyqDfvn37JEldu3YN7HRc189GqtxVOjk5ORC09AcMJdX5AHPLli31bndVVdtUfSOYqv773/9q4sSJWrdunaX7BItA4XHI5TJ3u8NhV0a6edCetarmhiY85QcAAFb5ZxR269ZWsbHmnDv+5cdsoAYAQP21b98+ECR77LHHtHfvXtN5n8+nu+++W5L0i1/8QmeddVa9r33o0CFt3LhRCxcurHGuoqJC69evlySdfPLJgfKzzz5b559/viTpzjvvrLH5iiRNmzZNBQUFuvPOOwP5BOsjPz9fL7/8simQ5+efndejRw8lJiYGyh955BE5nc7AMunqPvroI3355Ze6+uqrFRcXJ0k69dRT5XRWZul78cUXa7xm+fLlWrp0ab3bXZ2/Tf6l09Xt3LlTDzzwgLp3766rrrrK8n2CQY7C45DNZpPTZTflAho0KEXffn9k56Lc1QUqL684MvvQkLxeH3kKAQCAJS5XZZ5Cu92m9AFJ+ua77YFzObn5kmTKoQwAQKTLzs42HW/evFkdOnRQz5491bp1a61bt07l5eXyeDySpB07dig7O1tdunQJ5Mm7/fbbtWPHDj3++OMaNmyY/v73vystLU15eXmaNWuWPvzwQ40YMaJG0Mt/7+rXTkpKUlJSUiCI96tf/Up/+tOfNGzYMMXHx2vbtm36z3/+o5ycHJ1zzjm6+uqrTdedO3euLr74Yn3yySc67bTTdNttt6lv377atWuX5s6dq3nz5mnChAn67W9/2+Cf1+eff65zzjlHN9xwg3r06KHDhw/rq6++0oMPPqjo6GjNmTPHFHwcNmyY/vvf/+raa6/Veeedp7vuuksjRoxQSUmJlixZokcffVSnnHKKHnvsscBrOnfurHvuuUd///vf9fjjj+vQoUO67LLLFBcXp2+++Ub33nuvWrVqJY/HowMHDig7O1vt2rVT586dA/1VXFy5aVtBQYHpvL9NL774oq699lpdeeWVmjx5si688EI5nU4tW7ZM//jHP+TxePTuu+8qOjq6wT+jULAZTBMLuZ07d2rOnDm64YYb1KlTp5Bd1+fzKS8vTykpKbLbg5sMWlxcrpIST+B4/Ya9+v3N5qmv/3zgbA0e1DFw3Lq1WzEx5iXKoWAYhrxer5xOZ4OeKISDUPZZS0KfhZ9I7bNI7S+JPmuoxvrb29TCYQwRjP0HDsvr8emV11fpmed+CJS3auXUG/OukNPlUIeEmHpfj89J+KHPwg99Fl4itb+kyBxD1NVHS5Ys0ciRI9WjRw/9+OOPNc4/++yzuvbaa01lixcv1hNPPKEvv/xSe/fuVWxsrAYPHqyrr75a11xzTY0dleu69z333KMpU6aorKxMb7/9thYsWKDvv/9e27dvV1lZmdq2batBgwbpqquu0vjx42vdqbmiokJz587VCy+8oOXLl6uwsFDt2rXT0KFDNXHiRI0dO7aeP6Ej1q5dq5deeklLlizRmjVrtH//fjmdTnXr1k2jRo3Sn/70J6Wmptb62o0bN+qxxx7Txx9/rO3bt8tms6lv37761a9+pZtvvjmwK3RVb7/9tmbNmqVly5apuLhY7dq108knn6ybbrpJr776qmlX5/Hjx+u5556rs7/856vatGlToE3btm2TJPXs2VPnn3++brvtNqWkpNS4TlNp1BmF5eXlcjqdEfWLN1JUzgw8Eijs1bOdYlu7dai4PFCWtTLPFCgs91QoRqEPFAIAgOODy+mQ1+NTRpp5Q5PDh73atHm/UvskyOv1Ve6SDABAhDvWvK2G5MIbNWqURo0aFbJ7R0VF6bLLLmtQXkM/h8Oha665Rtdcc02DX1uXfv36aerUqZo6dWqDX9u7d2/9+9//btBrfvnLX+qXv/xlrefOP//8GoE/qWH91atXLz3++OMNalNTsTwKmzZtmvbs2XPUOm+99ZZatWqlSy+9NJBQEi2Df/mPn8Nh18CB5kF79Q1NyFMIAACC4U9pkpqaUCNncnZO5fJjj5c8hQAAAM3FcqBw6tSpKigoOGqd9PR0XX311frf//6nO++80+qt0AhsNluNfIOZA81TW9eu26PS0iOzDv15CgEAAKzwBwfdLof69e1gOuff0MTLzscAAADNxnKgsD4zyzIyMvTUU09pzpw5+vDDD63eCo3EVW1ZT+Ygc6DQ6/UpJ9ccDC4v5yk/AACwxr+hmiRlpJtXMuTk5sswDHY+BgAAaEZNkgCme/fuysvLO3ZFNKnAjsY/6dG9neLiokxlNZYfM6MQAAAEweWsHH9kpCWZyvcfKNXOnQdVUWHI5yPVCQAAQHOo92Ymn332WY2y77///qh5Cg3D0L59+/Tvf/9bCQkJ1lqIRuN0/pSn8KexuN1uU+bAFH3+5ZFderJW1Z6nMNJ20AIAAE3D5bLr8GFpQP8k2WxS1UUq2bn56tw5Th5PhaKiGnXPPQAAANSi3iOwkSNH1ggOTZgwod43uuGGG+rfKjQJf55CT5XlxJmDzIHCdev3qqTEo5iYn3Y7/ilPYfX8hgAAAPXhH0PExrrVs0c7bdq8P3AuJ7dA55yVKo/Hp6iouq4AAACAxtKgpceGYQT+VT+u7Z/dblenTp3029/+Vg8//HCjfAMIjrv6hibV8hT6fEZgF0I/8hQCAACr7HZb5aoGSenVlh/7NzRh52MAAIDmUe9Aoc/nM/2z2WzKzs6uUV71n8fj0bZt2/Tvf/9bsbGxjfl9wCKX2/wW6NolXu3btTKVVV9+XE6ScQAAEIS6NjTZsbNI+/cflpecyAAAAM3CcvKX+ux6jJbP5XTIZrfJ+ClpuM1m06CByfrksy2BOiuydple4/X6yFMIAAAsc7scKj3srTGjUJJyVhdo+LDu8ngrAhufAAAQaZYtW9bcTTAZMmRIczcBLYTlXY99Pp/S0tJC2RY0E5fT/DbIHNTRdLxx0z4dPFR2pMCQPB6e9AMAAGv8eQoTO7RWcrJ51Yk/5YmXsQYAAECTYzs5yO12mPIOVs9TaBjSqux8DftZt0CZx1Mht5un/AAAoOHsdpscDpsqKgxlpCUpP/9Q4FxO7k95Cj0VatXK1VxNBACgSfTt27e5m6B169Y1dxPQglieUei3ZcsW3XzzzRo4cKDatm2r1atXS5Lef/993X333SooKAi6kWhc/jxBfp06tlGHDjGmsqyV5CkEAACh4/rpgWP1PIUbNu7T4cMeVi8AAAA0g6AChW+//bYGDhyoWbNmKScnRwcPHgzkLszLy9N9992nAQMG6OOPPw5JY9E4/HkK/Ww2mzIHmmcVVg8U+vMUAgAAWOHPP1g9T6HPZ2j12t3y+QxVVBAsBAAAaEqWA4WbNm3SVVddpeLiYqWmpurCCy80bW4xfvx4zZ8/XykpKRo7dqw2bdoUkgajcbhd1fMUmgOFm7fsV2Fh6ZEC8hQCAIAg+FOYdOsar7i4KNO5nBz/8mPGGgAAAE3JcqBwxowZ8nq9euONN7RmzRrNnz/fFCh0OBy68MIL9c0336hr16569NFHQ9JgNA5/UnG/6huaSNLKVdWWH5ez/BgAAFjjz1Nos9mUNsA8q9C/oYnHy1gDAACgKVkOFC5cuFC33XabLr744qPWi42N1V/+8hf973//s3orNIHqgcKU5FilVNuFMKtaoJDBOwAACIZ//JGRbg4Url67R16vj52PAQAAmpjlQOG2bdt05pln1qtuRkaGtm3bZvVWaAJOp132KnkKpZrLj2vkKfSQpxAAAFgXCBSmmTc0KSvzauOmfeREBgCgBSgqKtItt9yibt26KTo6Wn379tV9990nj8fT4GsVFxfr97//vex2u6ZMmRL6xiJoTqsv9Pl8crvd9ap78OBBOZ2Wb4Um4nLZVVZ2ZJZg5qAUffS/DYHjrdsKtW//YbVv1ypQ5vH4AjmGAAAAGsL1U47kPr3bKyrKYRqHZOfkq1/fDow1AAAR6cCBcknSnj0lzdySI22pTVFRkU477TTt379f8+bN05AhQ/Thhx/qmmuu0dKlS/XOO+/I4ajf3+lPP/1UEyZM0P79+3kQ2IJZnlHYrVs3ffbZZ/Wq+8orr6hnz55Wb4Um4qo2CK++87EkrVxJnkIAABAaDoddDodNLpdD/fomms7l5Po3NGGsAQBAc7nrrruUnZ2tOXPmaPjw4WrVqpUuvvhiTZkyRR988IFmz55dr+u89957uvjii/X3v/9dkydPbuRWIxiWA4XnnXeeHnjgAS1atKjOOoZh6LHHHtPTTz+tCy64wOqt0ETc1fIUdujQWp07xZnKVqzcZTomTyEAAAjGkeXH1TY0yS2QYRjyeslTCABAczh48KCeeuopdezYUeedd57p3LXXXiubzabp06fX61qdOnXSypUrNWHChMZoKkLI8nrgP//5z3r66ad19tlna/To0RoxYoQMw9Cbb76phQsXas2aNfrggw+0detWtWvXTrfcckso241G4HBU5in0+Y5MAc4clKIdO4sCx3XlKay64zUAAEB9OV12qbTmhiaFhaXavqNI3bq1bZ6GAQBwnFu8eLFKS0t1yimn1Pg/f0JCgvr27au1a9dq3bp16tu371GvdcIJJzRmUxFClgOFHTt21JtvvqmLL75YCxcuDMwsvOeeewJ1DMNQXFyc3nzzTSUmJtZ1KbQgbrdDpaXewHHmoBS9/+G6wPHOXQe1e0+xEju0DpSVl1coKooclAAAoOH8Kxr690+s8cAyJ7dAXbvEy+v1yem0vBAGAABYsGrVKklSjx49aj3fo0cPrV27VqtWrTpmoBDhI6gR1+jRo7V8+XJddtllio6OlmEYgX/R0dG64oortGzZMp1xxhmhai8amct17DyF1WcVejwsCQIAANb4VzS0jnGrV892pnPZOfmSSHUCAEBzyMur/L9/u3btaj3ftm1bSVJ+fn5TNQlNIOhpYL1799bLL78sj8ejdevWqbCwUPHx8UpNTa33rshoOfy7D/q1a9dK3brFa+vWwkBZ1so8/XxU78AxScYBAEAwXC67ysoqlJGWrA0b9wXKs3/a0MTr8UnRzdU6AABC7893Lv/pq+VHrddUfvjm1Bplhw8fliS5XK5aX+OP+ZSUNP/OzQgdy4HCadOmBb6++eabFRcXp/T09JA0Cs3Hv/tgRUWVPIUDU8yBwlXV8hR6ffL5DNnt5CkEAAAN53I7VFZWofT0JL39zupA+a5dB7V3X4mSElsf5dUAAKAxtGrVSpLk8XhqPV9eXi5JiomJabI2ofFZDhROmTJFNptNMTExuv766xUXF3fsFx1HYmNj5XQ6ZRjGsSvXk2EYgWuG8rrVOV12eb1V8hQOTNE7760NHOfnH9KuXUVKSWkTKCsv91rOU+j/Xhrze2ouTdVnTY0+Cz+R2meR2l8SfdZQTmfk5MpNSUkJ2zGEVU6HXYZhKG1AzZzW2Tn5OmN4D1VU+Go8lORzEn7os/BDn4WXSO0viTFEc0hJqUxFtn///lrPHzhwQJKUnJzcVE1CEwjqEzFhwgT95z//4YNVixNOOEHt2rUzBdxCoV27dvL5fPL5Gi8voM1myFtxpN1paR1q1Pkha6fOTjyy/PhwqU0OR41qDVJREZlLmJuiz5oLfRZ+IrHPIrm/JPqsIdeMFL/5zW8kKSzHEMHwGRWKj3erY0qsduUdCpSvysnTsFO76PDhsjofSvI5CT/0Wfihz8JLJPaXxBiiqQ0cOFCStHnz5lrPb9myxVQPkcFyhK9Nmza64YYbCBLWYfny5Ro4cGBId3v2+Xzau3evEhISZLc33s5/MXaHDpcc+cPSvp1TvXq206bNR54iZGfv1vnn9AscGz6b5feCYRiqqKiQw+GoseV6uGuqPmtq9Fn4idQ+i9T+kuizhtq9e3fIrtXcnn76aY0dOzYsxxDBaBUdpbIyr9LTkk2BwtzcPXI6nDJkrzHW4HMSfuiz8EOfhZdI7S+JMURzGDVqlKKiovTtt9/KMAzTe2rv3r1at26devfuzY7HEcZylC81NVXFxcX1qltYWKj58+frmmuusXq7sHPo0CF5vd6Q/nK22WyBazbmL32HwyaXyyGv98hTmsxBKaZA4cqf8hT621FRYcgwFFSewsb+vppDU/VZc4nE74s+Cy+R3l8SfVZfoZ5915zy8vLCdgwRDLfbofLyCg3MSNbCxRsD5Zu37FfJYY9c7rr/09uSvy8rwqG/ghVp3xt9Fn4ivc8i8ftiDNH02rRpo9/85jd64okn9MEHH+j8888PnHvuuedkGIZuvvnmQFlRUZGuvPJKJSQk6JlnnpEj2GWHaBaWA4VXXXWVXnjhBZ155pnHrLt9+3ZNmDDhuAoUhrvKPIXmQOFb848kF9+zt0Q7dx5U585HclN6PBWW8xQCAIDjm8tV+Z+J9LQkU7nPZ2jNmt0aMqRzczQLAIBG8fADJ0iSevXq1cwtkTZt2lTnuQceeECffPKJbrjhBs2bN09DhgzRhx9+qClTpujss8/Wb3/720Ddjz/+WO+9954k6Q9/+IOGDh3a6G1H6Fmer/vHP/5RBw4c0OTJk5mqG4HcLnPkf2B6So3ZgitW7jIdl3siMw8GAABofE6nXTa7TV06xyk+Ptp0LjunQDIkj5exBgAATSk+Pl5Lly7VpZdeqiuuuEJt27bVX/7yF/3lL3/RO++8Y0oLMmzYMPXq1UsnnXSS0tPTa1zLPxt06tSpkqSpU6dG5OzXcGd5+tfPf/5zGYah9957T0888YRSU1OVmJhY69TS+i5RRsvhqhYojI11q3ev9lq/YW+gLGtlnn5x3pE8hV5P5CUBBgAATcfltKvcZygjLUlffrU1UJ6dWyCpcqzhcrKMCQCAphQfH68ZM2ZoxowZR63XqVMnbdy4sc7zkbgbdySyHCj85JNPZLPZAh29Zs0arVmzps76RIjDi91uk9NpXn48eFCKKVC4clWeKaGp1+uTz2cElacQAAAcv/x5CtOrBQrXrN0tj6dCHk+FWrVyNWMLAQAAIltQCeV++9vfKikp6Zj18vPzNXv27GBuhWZQ24Ymr72ZEzjef6BUW7cVqnu3toEy8hQCAACrnK7KrDgZ6cmm8vLyCm3YuK9G/kIAAACEVlARnUmTJiktLe2Y9bKzs/Wf//wnmFuhGbjdDh0+7Akcp6cly263yec7Ml04a2WeKVBYTqAQAABY5HI6ZLPb1LtXe0VFOVVWdmQnyuzcfA3on6iKCp8cDstptgEAAHAUliM648ePV7t27epVNzk5Wffcc4/VW6GZuFx2ySbpp7hgTIxL/VI7aPXaI5vXZK3M05gL+geOPeUkGQcAANa5nHYZPkMD+nXQipV5gfLsnAKNGyt5PAQKAQDhr21btySpQ4eYZm6JtG+fu7mbgBbE8ijr2WefVceOHetVNzExkUBhGLLZKvMUVjVoUIrpOGtVnmmGYUWFYToGAABoCP+GatWXH+euLpDPZ7DzMQAAQCOyHCgcNWqUfvzxx1C2BS2Qu9rux4MzzYHCgwfLtHnLflNZObMKAQCARS535fA0Pd2cj7CoqEzbdxTK6/HV9jIAAACEgOVA4SeffKKSkpJQtgUtkKtaoDCtf1KNWYZZq/JMxzzpBwAAVrmcDskmDeiXKLvdZjqXnVMgr9cnw2D1AgAAQGMIateJu+66S23btq1XXbfbraSkJA0fPlxnn312MLdFE6qepzA62qn+/TooO6cgUCdrZZ7GXnRkUxvyFAIAgGC4XA6pldSnd3utW783UJ6dk6/zz+0rj8cnt9txlCsAAADAiqAChfPnzzcdV326a7PZTOVVjwcOHKg33nhDvXv3Dub2aAI2m00ul8MU/Msc1NEUKFyVnWfagdCfp7D6LAAAAID6cP809khPSzIHCnMrxx8eTwWBQgAAgEZgOVB4zTXXaNu2bVqyZIni4uI0dOhQpaSkyOVyyePxKC8vT99//70OHTqkcePGKSoqSgcOHNAPP/yglStX6uc//7lWrFih+Pj4UH4/aAQup90cKByYorkvZwWOi4s92rhpn/qmdgiUlZdXKDo6qDg0AAA4TrlclQ8fM9KT9db81YHy/PxD2r2nWJ07xTVX0wAAACKa5UjOP//5Tw0ZMkT33Xefbr31VkVFRdWoU1ZWpkceeURvvfWWPvvsM8XEVG77/fzzz2vixIl6/PHHddddd1lvPZqE2+1QSYkncDygf6JcLrs8VZKJZ63MMwUKPR4ChQAAwBqnszL1SfqApBrncnILlJQU2wytAgAAiHyWIzn333+/LrnkEt1555111omKitJdd92lgoIC3XfffXrggQckSePHj1dWVpbefvttAoVhwD9Y9+cpdLsdSh+QpBUrj2xikrUyT+MuyQgcezzkKQQAANb4U5+0a9dKnTvFacfOosC57Jx8jTyjp7xenxwO0pwAAMLbunXrmrsJgInlQOH777+v5557rl51x40bp+uvvz4QKJSkCy+8UM8884zV26MJ1Z6nMMUUKMzOzZfX6wvsiFxRYZjyFgIAADSEP/VJRnqSKVCY489T6K2Qw8HqBQBAeBoyZEhzNwGoleUozo4dOxQdHV2vulFRUdq2bZuprF27diorK7N6ezQxt8ucMDxzUEfT8eHDXq3fsNdUVnVpMgAAQEP4NytJTzMvP968Zb8OHSqXl3EGAABAyFkOFMbExGjRokX1qrto0aIaQcW8vDx16NChjlegpXG5zW+VvqkJiooyP8XPqjLDUGL5MQAAsM6f+iQjPdlUbhjS6jUFjDMAAAAageVA4SmnnKL77rtP77///lHrvfvuu3rggQf0s5/9zFT+yiuvqGPHjnW8Ci2Ny+mQzX4kD5DL5VBGtSf8K1buMh0zgAcAAFbZbDY5nXZ16thG7dqaHzhn5xaoosKQz2c0U+sAAAAik+XELrfffrs++ugjXXjhhTrxxBM1atQo9ejRQ61atVJJSYm2bNmixYsXa/ny5YH6krRp0yY9/PDDeuGFF3TLLbeE5rtAk3A57SqvmqcwM0XLlu8MHOeuLlC5pyKwTJk8hQAAIBhul0Nej0/pacn6YumPgfLsnHxJlQ8lHY66Xg0AAICGshwoHDFihGbOnKmbb75Zy5Yt0w8//FCjjmEYstvtmjFjhs444wxJ0rPPPqvZs2dLki666CKrt0czcLsd5kDhwBTT+bKyCq1du0cDM44sESr3VKgVgUIAAGCBy+WQ5FFGepIpULh23R6Veyrk8fJAEgAAIJSCGln9/ve/1xdffKFzzz1XTqdThmEE/jmdTp1//vn68ssv9fvf/z7wmnvvvVc+n08+n0+nn3560N8Amo7TZX67pPZJUEwrl6ksa5U5TyGJxgEAgFUuV+15Cj0en9Zv2EuaEwAAgBCzPKPQ72c/+5nef/99lZaWav369SoqKlJcXJxSU1PrvSsywoM/T6HxUz4gh8OujIxkffvd9kCdrJV5uuqKzMBx1RmIAAAADeHPU9irZzu1auXU4cPewLnsnHylDUhsxtYBAABEnpCt1YiOjtbAgQN12mmnaeDAgQQJI5S72qzC6suPV68pUFnZkUG8z1eZpxAAAMAKl9Mhh8OuAf3NQcGcnALJkLxexhkAAAChErJA4d69e7V8+XKVlpaG6pJogVwuc8bwzEHmQKHH49PqNbtNZeUsCwIAABa53ZVjj/Q08/LjnNUF8vkMlh8DAACEUNCBwldffVWDBw9WUlKShg4dqk2bNkmq3LTkjDPO0Mcffxx0I9FyVA8U9urZTrGxblNZ1kryFAIAgNBw/bSaISM9yVR+6FC5tm47IA/jDAAAgJAJKlB411136YorrtDKlStlGIbpXEJCgr799ludd955uvfee4NqJFoOp9Muu90WOHY47BqUYX7CX31DE/IUAgAAq/x5Cvv37SCHw2Y6l5NbII+XcQYAAECoWA4Ufv755/rHP/6hVq1aaeLEiXrkkUdktx+53JgxY7Rz505dddVVmjJlij777LOQNBjNz1U9T+Ggjqbjtev2qLTUEzj2+QzyBwEAAMtcLoeio13q0zvBVJ6dU0A+ZAAAgBCyHCh84oknlJKSojVr1mj27Nn605/+VKNO+/bt9fzzz+vnP/+5Zs2aFVRD0XK43EfPU+j1+pSTW2Aq42k/AACwqq7lx/7xBsuPAQAAQsNyoHDp0qX6+9//ri5duhyz7o033qilS5davRVaGHe1PIXdu7VVfFyUqWxFtTyFHpYfAwAAi/w5kjOqbWhSsLtYBbuLeSAJAAAQIpYDhQUFBRo8eHC96vbo0UN79uyxeiu0MA6HOU+h3W7ToIHmWYXVNzThST8AALDKbq/MU5iWllTjXG7ubjZOAwAACBHLgcKoqCgVFhbWq+62bdvUunVrq7dCC+Suvvw40xwoXL9hr4pLygPH5CkEAADBcLrsahsfra5d4k3luat3y+v11dhYDwAAAA1nOVDYv39/vf7668esZxiGZs2apYyMDKu3Qgvkqrb8OHOgeUMTn89Qdg55CgEAQGj4U5+kp5GnEAAAoLFYDhSOGzdOzz77rO6++26Vlx+ZOWazHVmSumnTJo0dO1ZLlizRZZddFlxL0aJU3/m4a5c4tW/XylSWtXKX6Zg8hQAAwKpAnsJ0c57CH7cW6uChMnk8jDMAAACCZTlQOGnSJPXv31/333+/EhMTddZZZ8kwDN1xxx0aO3as0tLSlJqaqgULFmjgwIG64YYbQtluNDOHwy6H40hQ2GazadCgo+cpLOdJPwAAsMhut8nhsNXY+Vg6svwYAAAAwbEcKIyOjtaHH36ogQMH6uDBg1q0aJEMw9C7776r+fPna82aNTIMQ5mZmXr33XflcrlC2W60AK7qeQqrbWiycdM+FR0sCxwb5CkEAABBcLkdSkmOVfv25lUMOTn58jDGAAAACJrlQKEkde3aVd9++62efPJJjRo1Su3bt5fD4VD79u01atQozZ49W9988426dOkSqvaiBXE5zYHCwdU2NDEMKTs731TGsiAAAGCVy+mQzWarsfw4O7eAB5IAAAAh4Az2Am63WzfeeKNuvPHGULQHYaT6zscdU9ooMbG1du8uDpRlrczTsFO7BY49ngq1asXsUgAA0HD+sUdGWpI++3xLoHz9+r0qL6+Qx1shpzOo5+AAAADHNcsjqVGjRgX+FRQUHPsFiDh2u800GLfZbDWWH2etIk8hAAAIjSN5Cs0zCj1en9au2yMv4wwAAICgWA4UfvLJJ/r000/lcrnkdAY9MRFhyllt9+PMahuabN6yXwcKSwPHLAsCAADBcLkc6tG9rWKqrVDIyS0gxQkAAECQglqb8dhjj+mjjz5S+/btQ9UehBm3q9qGJtUChZK0stqsQgbxAADAKpfLIYfDrgEDEk3l2Tn5qqgw5PMZzdQyAACA8Gc5UJiQkKDTTz89lG1BGHJVCxQmJ8UqJTnWVJa1stry43IChQAAwBrXT6sZqi8/zl1ToIoKHw8kAQAAgmA5UHjCCSdo27Zt9aq7c+dOXXfddVZvhRasep5CSRqc2dF0XD1Q6GHpMQAAsMjhsMtutykjLclUXlzs0Y9bD8hDnkIAAADLLAcK//jHP+rhhx+Wx+M5Zt39+/fr+eeft3ortHDVZxVW39Bk2/ZC7d1XEjg2fIY8Xp72AwAAa9xuh/r17VDjYWV2TgFjDAAAgCBYDhRecMEFGjt2rM444wy99dZbKigokGGQE+Z45HY3PE8huxICAACrnC67oqKcSu2TYCrPyc1n0zQAAIAgWN6u2OE4Ehy69NJLQ9IYhCeXyy7ZJP0UJ05IiFGXznHavqMoUCdrZZ7OHNErcFxeXqFW1XYrBAAAqA//ZmrpaUlavWZ3oDw7pyCwcsHldNT1cgAAANTB8oxCwzAa9A+Ry2armadwULXlxyvIUwgAAEIkkKcw3ZyncM/eEuUXFLNyAQAAwCLLMwol6dlnn1WPHj2OWW/Tpk26/vrrg7kVWji3y2EalGcOStH7H64LHO/adVAFu4uVlNhaknjaDwAAguJy2ZXWP7FGeU5uvrp3i2flAgAAgAVBBQpPOukkpaWlHbNehw4dmFUY4So3NDmysU31DU2kyuXHZ43uHTj2lPsIFAIAAEtcbofi4qLVrWu8tm4rDJRn5xTorNF9mrFlAAAA4cvy0uNnn31WXbp0qVfdnj17asmSJVZvhTAQyFP4k3btWql7t7amOlmrdpmOPR52JQQAANb4HzampZlnFWbn5svnM1RRwfJjAACAhrIcKBw/frzi4uLqVTcmJkYjRoyweiuEAZvN9tOswiOq736clZVnmllKnkIAAGCV02mXzW5T+gBzoHDr1kIVFZXKQ55CAACABrMcKASqc1Xb0KR6oLBgd7Hy8g8Fjv15CgEAAKxwuxxKT0uqUZ6zuoAxBgAAgAUEChEybrd5RuGgjGTZbOY6WdV3Py7naT8AALDG5bIrMTFGHTrEmMpzcgrY+RgAAMACAoUIGZfLYcpTGBcXrV4925vq1AgUkqcQAABY5HI5ZLPZaswqzM4pkNfrYzM9AACABiJQiJCqkaew2u7HWSt3mQbt5QQKAQCARU6nXXabTRnVAoXrN+5VaamXPIUAAAANRKAQIeU+xoYme/cd1o6dRUcKDGYVAgAA65wuu9LTkk1lXq9P69bvYYwBAADQQM7mboBVJSUleumll7R06VIVFhYqMTFRZ555pi655BI5nfX7tl566SXNmzevzvMPPvig0tLSQtXk44LLbZeKjxwPzEiW3W6Tz3dkFmHWyjx16RwfOPZ4fHK7qyUzBAAAqAe3y6Ee3duqdWuXios9gfLsnHwNHdK5GVsGAAAQfsIyUFhSUqLbb79dhw4d0p///Gf17t1bP/zwg2bMmKE1a9bob3/7mxwOx7EvJKlNmzaKi4ur9VxUVFQom31ccDkdstltMn4KDLZu7Vaf3u21bv3eQJ0VK/P0i/P6BY7LPRVyu8PyrQgAAJqZy+WQ3e5T+oAkffv9jkB5dm6BPF6WHgMAADREWEZn/vvf/+rHH3/U3XffHZjxd+qppyovL0/PPvusPvroI51//vn1utYvfvELXXnllY3Z3OOOy2lXefmRpT6ZA1NMgcKVq/JkGIZsP22JXLksKCzfigAAoJk5nXbZ7DalpyWbAoWrV++W11Mhr9cnp5NsOwAAAPURklHT7t279cYbb2j69Onau7cyIJSfn69Dhw6F4vImJSUl+t///qf27dtryJAhpnOjR4+WzWbT/PnzQ35f1J/bXS1PYWZH0/GBA6X6ceuBIwXkKQQAAEFwOe3KSDdvaFJy2KPNW/bL42WMAQAAUF9BBQpLS0t10003qWvXrvrVr36l2267Tfn5+ZKkd999VykpKbrzzjvl8XiOcaX6W7lypcrLy9W3b9/AjDS/uLg4derUSbt27dKOHTvquAIam9NlfltlpCXJ4TD3VdbKPNMxuxICAACrXC6H+qZ2kKvazMGc3AJ5GWMAAADUm+VAoc/n05gxYzR79myVl5fLMAzT+UGDBqlfv3568MEH9ctf/jLYdgb8+OOPkqSkpKRaz/vL/fWOZfPmzZo2bZquueYajR07VhMnTtR//vOfwMxINJw/T6Ffq1Yu9U3tYKqTtap6oJCn/QAAwBqXyy6326G+fc3jjVU5+YwxAAAAGsByoHDu3LlauHChMjMzNXfuXH3//femDUROOukkLVu2TE899ZQ+/vhjPf/88yFp8P79+yVJsbGxtZ73lx84cKBe18vNzdVpp52mJ554Qi+99JImTJigL7/8UpMnT9bWrVtD0ubjkbvarMLMQSmm45Wr8k07IXs8vhrBZgAAgPpwuRySrXIVQ1U5uQXyen2mMQcAAADqFlSgcOjQofruu+90xRVX6MQTT6w10HPddddp4sSJIQsUlpeXS1Kduxo7nZWbYpSVlR3zWiNGjNCjjz6q0aNHKzY2VtHR0Ro2bJgmTZqkoqIiPfbYYyFp8/HI5aqWp7BaoPDgwTJt3rI/cGzIkJedCQEAgEUul0Pp6cmmsn37Disv/5AOHizjgSQAAEA9WN5qdvny5Zo5c2adAbuqfvnLX+qKK66weisTt9stSaqoqH0ZidfrlSRFRUUd81qdO3eutfyUU05R27ZttWnTJm3ZskU9evSo8xq7du3Srl27TGW7d+9WcXGxpMol2qHiv1Yor9lYHA6bqZ39+3WQ02k3BQNXZO1Uzx5tZRiGfD6fSks9EbcrYTj1WUP4+8zn89XIFRru6LPwEqn9JdFnxzOXyyXp+B1DNETVz4nTYVP/fgmy2aSqMcGVq/KUnNRaPp9PcXFRYfF5itT+kvjdFo7os/ASqf0lRW6fAS2N5UDhgQMH1Lt373rV7dChQ8h2QG7Xrp0k1Xk9f3nbtm0t38Nmsyk5OVkHDhzQ9u3bjxoonD17tqZOnVqj/PLLL5ck5eXl1TgXrIKCgpBfszHsP1BqWurTu1e81q47Movw2++36rRhR3IJHTpYpLg4d5O2samES5/hCPosvNBf4Yc+q9uECRMkHd9jCCs8Hp8OHy5T586x2r79yDhx2Q8/KnNQG0mSK9+hNm1cYfOf50jur0hFn4Uf+iz80GdA47IcKIyPj9fWrVt10kknHbNuVlaW2rdvb/VWJt27d5ekwO7K1fl/afjrWVXf5Sk33nijxowZYyrbvXu3Fi5cKElKSUmp7WWW+Hw+FRQUKCkpSXZ7y595FxNTprIyb+B46IldTYHC9RsOKKF9B9ntNnkrvHI5nerQoXXYDN7rI9z6rL4Mw5DX65XT6Yyo/pLos3ATqf0l0WcN1RhBteby7LPPasKECcf1GKK+qn5OJGnv3hJlDuyk7dvXBeps3HRQSYlHche63A7Ft/CZhZHaXxK/28IRfRZeIrW/JMYQQFOxHCgcOnSoZsyYobFjxx71F9C+ffv0wAMP6OSTT7Z6K5NBgwbJ5XJp/fr1MgzDdO+ioiLt3LlTKSkpdS4r9tu9e7duvfVWPfHEEzU2RjEMIxCIPNZ1OnbsqI4dO5rKdu7cqa+++kqSGuWPjt1uD4s/ZlHRTnk8R6aFD87sqLnzVgaOi4s92rzlgFL7JMhu2GWz2eXzVe5cGGnCpc/qyzCMwPcUaQMQP/osvERaf0n02fHM4/FIOr7HEPVV/XPijnJpYEay3vvgSKBw+44iFR0sV9v4aElShdcIHLf0z1ak9ZfE77ZwRJ+Fl0jvLyny+gxoaSx/uvy7A48aNUpLly4N5Ab0/zIqKCjQM888o5NOOkmbNm3SxIkTQ9LgmJgYnXXWWdq3b5+WLVtmOrdo0SIZhmGa4VdSUqJp06Zp+vTppryGPp9PBw4c0IoVK2rcY+nSpSosLFSPHj2OuuwYR+eutqFJ//6JcrvNZSuyzE9vystrzz0JAABwLC6nXelpyTXKc3PNy9S8Hp8OFJaywQkAAEA1lgOF48aN09ixY/Xpp5/q9NNPV3x8vHw+n0aPHq327durY8eOmjhxojZv3qzLLrtMF1xwQcgaffXVV6tr167697//rdzcXJWVlemrr77SvHnzdMIJJ+i8884L1F2+fLm+//57LVmyRJs2bQqU+wOas2fP1qeffqqioiKVlpZq6dKlevLJJxUbG6tbbrklYp/CNAWHwy67/cjPz+1yKK1/oqlO1qpqgUIPgUIAAGCNy+VQUmJrJSe1NpWvyqmZssYfLKyaTxkAAOB4Z3npsSS99NJLmjx5subMmaPDhw9LMq/vt9vt+t3vfqfp06cH18pqWrdurYceekgvvfSSHnnkER04cECJiYm6+OKLdckll5h2Yu7fv79SUlLUpk0bdevWLVCelJSkRx99VJ988oleffVVzZo1Sz6fTx06dNDw4cN1ySWXKDExsbbbowHcbodKS4/kKczM7KgVK4+8R7Jz8it3Qv4pnuj1+mosKQcAAKgPl8su2aT0tGTlFxx5QJyTW3vie6/Hp8LCUsXHR5sebgIAAByvggoUut1uPfnkk7r55pv12muvKSsrS4WFhYqPj1dmZqbGjRunfv36haqtJq1bt9bEiROPuaQ5ISFBc+bMqfVcamqqUlNTG6N5+InLVS1QOMicmL201Kt1G/aqb2rlbtYyKnctrL5EGQCA/2/vvuOjKBM3gD+zM9uSTSU9QGgi0uupCEqz4Y/Dcp54nu3U0zsL9o4eKnqCBT27Zz/L2e6woB7VQhGkVwkh1CSE9GzfnZnfH1uym92EzWZTNnm+n08+7E59s8OwL8+8heh4BEGAJGkwZHAWlq9sCAr3FlXCbnfBYNCG7ON2MywkIiIi8mlVUOhz4okn4sEHH4zFoaiLaTwxyYknZMBgkILCw61byxqCQgAul8ygkIiIiKKi04oYOiQraJksq9j9awVGjsgNu4/braCmxobUVCPDQiIiIurWoh6j8IcffvB3NyZqiihqIIoNFW7fU/5AHKeQiIiIYkWrFdG7VypMJl3Q8u1NdD/2kWUVNTU2jllIRERE3VrUQeHkyZNRXFwcy7JQF6Vt1DqwcffjHTvL4QoIB33jFBIRERG1lFbrmUxtyEnBDya3h5nQpDFfWCjLSlsVj4iIiKhTi7rrsaqqKC0thclkimh7nU6HHj16QKsNHRuGujatJMKOgHEKhwUHhU6njF/3VGLk8DzPAo5TSERERFESBAGSVoOhQ7Lx8/rD/uW7dh+DLCsQxeafk8uy6h+z8HjbEhEREXU1rRqj8KyzzmrR9qIoYty4cbjjjjtw4YUXtubUFEcaB34nDOiBhAQtrFaXf9nWbUcbgkJ4wkMGhURERBQNrSRiSKNxCu12N/755gZc+6cxEYWFNTV2pKYyLCQiIqLupVU1H1VVW/TjdruxZs0aXHzxxbj//vtj9TtQJ6fReGYg9BFFDYYNyQ7aZuu24O5ALjfHKSQiIqLoaLUanDCgR8hDx88X7cSjT6yE3e5qYs8GiuIJC91udkMmIiKi7iPqoLC4uBh/+MMfkJOTg3nz5uGHH37Anj17UFxcjD179uCHH37AY489hvz8fDz22GMoKirChg0b8Oqrr2LQoEF48sknsXLlyhj+KtSZSY1mP248TuHuXyvgcDR0T+Y4hURERBQtnU6ETiti4mkFIevWrD2EO+75FhUVluMeR1E83ZAZFhIREVF3EXXX43Xr1mHDhg3Yvn070tPTQ9YPGDAAEyZMwJ///GecfvrpGD9+PCZNmoRRo0bhsssuw/jx4/HSSy9h0qRJrSk/xQmdVoTdFjBOYaOg0O1WsHP3MYweyXEKiYiIqHUEwdOb4Y5bT0Nysh7/WbQraP3eoirMvmMx5j40BQP692j2WIqioqbWjtQUQ1APCSIiIqKuKOraziuvvII5c+aEDQkDZWRk4IEHHsCTTz7pX5aQkIDbbrsNa9asifb0FGcaB379+qbDZNIFLduytSzovdPJ7sdEREQUHa1WhChqcMN1v8FNfz0ZGo0QtL6i0oo77vkWa38+dNxjqd6wkEOjEBERUVcXdVC4ZcsWnHTSSRFtO3jwYPzyyy9By4YNG4Zjx45Fe3qKM74n+z4ajRAy+/HWbcFBISvjREREFC1twLAnM6YPwqMPT0WCURu0jd3uxt8eW47PF+087pAnqqKittbB+gkRERF1aVEHhRaLBaWlpRFtW1JSArPZHLTM4XAgISEh2tNTHNJqg1sVNu5+/OueCthsDYOLu10cp5CIiIii07jeMXZMPp5dcC6ysxKDlqsq8Orr6/HCyz9Dlpsfi5BhIREREXV1UQeFBQUFePrppyHLzVeUZFnG008/jd69ewct37x5M7Kzs5vYi7qixt2PG7colGUVO3aWBy1j92MiIiKKhkYjhIwp2KdPGp57+jwMOjEjZPuvFv+KOX9bBovF2exx/WGhi3UUIiIi6nqiDgovvvhirFixAqeffjoWL14Mq9UatN5iseCrr77CxIkT8f333+OSSy7xrzt48CDmz5+PgQMHRl9yijtarQYIGB6ooCAVKSmGoG22NO5+7OIsg0RERBQdSRta1U1LM2L+42dj4oTQGZE3bCrBbXd9g7Kj5pB1gfxjFjIsJCIioi4m6qDw3nvvxeDBg7FmzRrMmDEDSUlJyM7ORp8+fZCVlYXk5GTMnDkTa9euxeDBg3HPPfcAAF5//XUMHDgQBw8exP/93//F7Behzq/xOIWCIGD4sOBWpZu3BHdnZwWciIiIoqWVxLDL9XoJ9999Bi69ZFjIugMHazD7jq+xa/dxxtJWwbCQiIiIupyog8LExESsWLEC5557LlRVhaqqOHbsGA4ePIiKigr/sunTp2P58uVITPSMBzNgwADcd999eOihh3DBBRfE7Beh+KA7zjiFe4uqgrr8uN0KFIXjFBIREVHLNR72JJBGI+Cqy0fjzttOC+miXFNjx133fYuVPxQ3fwJvWMihUoiIiKirkFqzc2ZmJr7++musX78eX3zxBXbu3Im6ujokJydj8ODBmDlzJsaOHRu0z+TJkzF58uRWFZril2dg8YYJS0YOzw1arygqtu04ilN+08u/zOWSode36q8qERERdUMajQBRFCDLTT90PHPqAGRnmTB33gqYzQ0PK10uBU/M/wElpfW49PfDIAhC+AOoQG2dHSnJhmaDSSIiIqJ4EJP0Zdy4cRg3blwsDkVdnH+cQm99vWd+MtLTjaiqsvm32bK1rFFQqECvb+eCEhERUZeg1YmQbe5mtxk+LAfPPT0dD81djiMldUHr3nlvE0pK6nDLTaeG9Izw84aFyUl6PtwkIiKiuBZ11+OWsFqt+OGHH9rjVNTJCYLgbVXY8L7x7MdbQyY0YXceIiIiik5T4xQ21jM/BQufOhfDhmaHrFuyrAj3z1mCujp70wdQgbp6BxyO5kNJIiIios6sXYLC4uJidjcmP22jcYCGNwoKi/ZVoa7e4X/PcQqJiIgoWtowMx83JTnZgCcePRNnTu0fsm7b9qOYfcdiHD5S2/QBvGGh3c6wkIiIiOJTTPpGmM1mFBYWwmw2Q1VDA519+/bF4jTUReh0IqzWhnEKG09ooqrAtm1lOG18gX8ZxykkIiKiaIiiBpJWA7dLiWh7rVbEHbeehvz8ZLz97qagdSWl9bj1zm/w0P2TQh50+qlAvfeBp8HAugsRERHFl1bVXsrLy3HjjTdi0aJFkGV2D6XIaLVi0DiFuTkmZGYm4Ngxq3+bLY2CQieDQiIiIopSaooBZrMz4pZ+giDg0t8PR15uMp569qegWY3r6x24b84SzL7pVJw1bUCTx2BYSERERPEo6q7H9fX1mDBhAj777DO43W6oqtrsD1GgxuMUDm80HtCWrcHjFEbaCoCIiIioMUEQkJSkR3KyHoKmidmLwzhjYh8seOJspKYagpa73QqeXrgKb727sdnhUerrHbDZXU2uJyIiIupsog4KFy5ciKKiItx3333Yv38/FEWBKIrYvn07FEWBoigoLi7GHXfcgdTUVOzfvz+GxaZ413jWwOHDgoPC/QdqUFPbMGA4xykkIiKi1tLrJaSlGiC1YNzCQSdm4rmnz0NB79SQdR99vA2Pz/++2QlMzPVO2GwMC4mIiCg+RB0ULlq0CJdddhnmzZuH3r17h92moKAACxYswPnnn4+nnnoq6kJS16PVBf/VGzYsdIZBzn5MREREsSaKGqSlGpGQoI14n5xsE55dcC7GjMoLWffjTwdw9/3fobra1uT+ZjPDQiIiIooPUQeFhYWFuOSSSyLadtasWfjuu++iPRV1QVpJDOr6k5WZiNwcU9A2m7eUBr2vNzvhcjMsJCIiotZLTNQhNdUATYRdkRMTdXj0b1Pxf9NPDFm3+9cKzL7ja+zfX93k/mazM2gyNyIiIqLOKOqg0GazITc3N2iZVqtFVVVVyLbJyck4ePBgtKeiLkorBf/1azx74JZGLQpVRUVNjb3Z7j1EREREkdJqRaSlGaHXi8ffGJ7WiDf95WRcf904CI3yxaPlFtx21zf4ZcORJve3WBgWEhERUecWdVCYkZEREv716NEDmzdvDtl27dq10Z6GujCdLrhSPnJ4cFB4+HAdKiutQcugAnV1DlayiYiIKCY0GgHJyQaYknRABI0LBUHAhTMH428PTgmZ0dhqc2HO3GX4cvHuJve3WJywWJytLTYRERFRm4g6KBw6dCief/55yHJDV9ARI0bgySefxO7dDZWjDRs24PHHH0e/fv1aV1LqcrSNJzRpFBQCoa0KfSwWJ+rrHZxRm4iIiGLCaNAiLdUISYqsenzKyb3wzPxzkdEjIWi5oqh44aWf8fJr6yDLSth9rVYXw0IiIiLqlKIOCqdOnYqVK1di/Pjx+PHHHwF4xiI8cuQIRowYgWHDhmHo0KE45ZRTUFlZid/97ncxKzR1DZKkCRqnsEd6Anr2TA7aZsvW8EEhANjtbtTWOTgbMhEREcWEJGmQmmqAwSgdf2MA/ful4/lnzsOA/ukh6/77xS7MfWxFk5OYWK0umM0MC4mIiKhziToonDVrFk4//XQkJCSguLgYAHDZZZdh2rRpcLlc2LFjB3bu3AlZljFixAjcfffdMSs0dR06bfBfwRGNxyncGjyhSWMup4yaGhvc7vBP7ImIiIhaQhAEJJn0SE7WBz3QbEqPHgl4+slzcOopvULW/bz+MO6451scq7CE3ddmY1hIREREnUvUQWFBQQFWrlyJFStW4IorrgDgqVgtXrwYzz77LGbMmIHzzjsPf//73/HTTz8hISHhOEek7qhx9+MRw4MnyCktM6O83NzsMWRZRU2tHS4XZ0QmIiKi2NDrJaSlGqDVHX+iE4NBizn3TcLvLhwSsq5oXxVuuf1rFO6tDLuvzeZCvdnR6vISERERxULUQWFTJEnC7NmzsWjRInz55Ze4++67GRJSk0KCwmHZIds0NU5hIFXxhIV2O2dEJiIiotgQRQ1SUwxITDz+RCeiqMF1fxqL2TedCk2jlohVVTbccc+3WL3mYNh97TY3w0IiIiLqFKIOCkVR9P80nv2YKFKSpAmqTKemGtGnIDVom+bGKQyiAvX1Dg4OTkRERDGVkKBFaqoBonj8rsjTzxmIx+ZOQ2KiNmi5w+HGI4+vwKef7wg7GZvd5kZ9PcNCIiIi6lhRB4WqqiIzMxOPPfYYMjIyYlkm6mZCux83HqewrEWzG1utLtTV2TkjMhEREcWMVhKRlmaEXn/8rshjRuXh2QXTkZNtClquqsDrb/6C515YE3Z8ZbudYSERERF1rFa1KHzxxRdx3333sWsxtYpW1/yEJuXHLCg72vw4hY05HDJqau2cEZmIiIhiRhAEJCcbkJSkP25X5ILeqXju6ek4aVBmyLpvvivEg39bGnYiE7vdjbo6hoVERETUMaIOCrOystC3b99YloW6KV2jFoXDhuVAaFT53ryl+dmPw3G7FFRXc0ZkIiIiii2DQUJaqhGStvmqdGqqEfMfPxuTTu8Tsm7T5lLcdtdilJbVh6xzONyorXPA4eDYy0RERNS+og4KJ0+ejE2bNkW0bWFhIfr16xftqaiLE8XgcQqTk/To1zc9aJuIxylsRPFOcuJ0ckZkIiIiih1J8kx0YjRqm91OpxNx712n47JLR4SsO3ioFrNv/xo7dpWHrHO7FdTVOVBRaYXZ7OSDTyIiImoXUQeF999/P+bPn49Dhw4dd1un04kDBw5EeyrqBhq3KgwZp3Bby8YpDKQqKmpr7bDZXFGXj4iIiKgxQRBgMumQkmIImem48XZXXDYSd98xAVopuPpdW+fAPfd/hxXf7wu7r6qosNlcqK62oabWDrvdzXGYiYiIqM1I0e5YUVGBK6+8EiNHjsQf//hHnHbaacjMzIQohg7wvG9f+IoPkY9WJ8Ltbmj1N2J4Dj7/707/+6oqGw4fqUOvnilRn8NsdkKWVZhMulaVlYiIiCiQTueZ6KS+3tFsL4apk/sjK9OERx5fETQOocul4O8LfsSRknpcNmt4k/u7nDJcThlmiwC9XoTRoIUkRf3cn4iIiChE1EHhpEmTIHgHknvhhRfwwgsvxKxQ1P3otCJsaKhYDxuSDY1GCJqMZMvWslYFhQBgs7kgywqSk/X+v79EREREraXRCEhJMcBmc8FscQJNNPobNjQbC5+ajofmLsPhI3VB6957fzNKSupwy02nNHsuVVFht7lht7khaTUwGCQY9BLrNkRERNRqrXoEqapqxD9EzdFoBIhiQ+U2MVGHAf0bjVO4LbpxChtzOmXU1Nghyxzrh4iIiGLLaNQiNdUQVK9pLD8vGQufnh4y1AoALFuxD/fPWYr6+tAZkcNxuxSY652orLKh3uyAy81xmYmIiCh6UQeFgiBg+/btUBTluD9bt26NZZmpi9LqGo9TmBv0fsvW6McpbMztVlBTY2dlmoiIiGJOK3m6IhsMTXfeSTLpMW/uNJx95oCQdTt2lmPuvLU4dLg24nP6WhnWVNtRXW2Dzebiw3oiIiJqsaiDwpZUPARBYEWFjut4E5rU1tpx4EBNzM6nKCpqauxwONwxOyYRERER4Kn/JiXpPcOdNDHRiVYr4rZbxuNPV40OWXfsmA1/uflLzH1sOdb+fKhFPSHcbgVmsxMVlVbU1zvgcvHBKBEREUUm6jEKi4uLkZ+fH9G2Q4YMgaKwmyc1T9soKBw6OAuiKECWA8Yp3FaGPn3SYndSFaircyAxUUVCgjZ2xyUiIiICoNdLkCQN6uodcLtC68OCIOCS3w1DXm4yFjzzIxyOhlBPllWsXnsIq9ceQlqqAVOn9MdZ0wagoHdqZCdXAbvdDbvdDUnyjGWo10vNztBMRERE3VvULQoLCgogSVHnjEQhNBohaOY+o1GLEwdmBG2zZWtsxilszGJxot7sOP6GRERERC0kihqkpRqbfSg58bQCLHjiHKSnGcOur66x49PPd+DPf12E2Xd8ja+/+RUWS2TjGAINrQwrq6yoq7OzlSERERGF1arJTABPF+T//ve/uPnmmzFz5kwcPHgQALB582YsX7681QWk7qVxq8LG3Y+3bCsLmgk5luw2N2pq7W12fCIiIureEhN1SE01NNmi78SBGXju6ekYfFJms8fZ/WsFnn9xLWZd/jGefOpHbNpcGnn9RQUcDs/EblVVVlitLtZ9iIiIyK9VQWFhYSGGDx+Oiy66CC+99BK++uormM1mAMCGDRswbdo0nHbaaf7wkOh4tNrgv5IjhgVPaGI2O7GvuKrNzu9yyqipsXFGZCIiImoTWq1nohO9Xgy7PivLhKefPAfz5o7HhecPRmqqocljOZ0ylq/ch3sf/B+uuvYzvPf+ZpQdNUdcFllWYbE0tDJ0OtnKkIiIqLuLOiisq6vD2WefjR07dkBVVSQlJQWtP/vss3Hbbbdh69atmDp1qj9AJGqOrtHMx4NPyoRWCv5r+sSCH7D712NtVgZZVlFdwy45RERE1DY0GgHJyQaYknRAE8MF9uyZhOv+NAbvv30xHn5wMk49pVezYwseLbfgXx9uwZXXfIa77/8Oy1YUwW6PcMI2byvD2lo7KiutsFicfGhKRETUTUUdFL744ovYv38/brrpJhw5cgQ1NTXQaBoO17NnTzz99NNYvXo1KisrsXDhwliUl7o4QRAgBbQq1OslDBoU3P3m8OE63HbXN3jznY1wtlGYpyoqamrtkVewiYiIiFrIaNAiLdUYNEZzY5KkwfhTeuNvD07BB+9cjOv+NBa9e6c0e9wtW8sw/+mfcOkVH2PhP1Zj1+5jUNXIuhcrigqr1YWqKhtqa+1wOFgXIiIi6k6iDgoXLVqESy+9FM8//zxyc3Ob3G7YsGG466678Pnnn0d7KupmtFJwq8KJpxWEbKMoKv79yTbcctvX2FtU2TYFUYH6ekeLBgonIiIiaglJ0iA11QCD8fiTBKalGfG7C4fgtRdn4rmnp+O8cwciMbHpCVKsVhe++a4Qt965GNf9ZRE+/nQ7KqusEZfN6ZRRV+dgK0MiIqJuJOqgcM+ePZg1a1ZE206cOBGFhYXRnoq6mcbdj2fOOAlzH5oSdhbA4v3VuOX2r/H+h1vgdrdN5dVqdaG+3hHxk3giIiKilhAEAUkmPZKT9RCa6V4cuP2gEzNxy42n4sN3f4977pyIUSNzITSz66HDtXjj7Q3441Wf4qG5y/DT6gMRD7MS2MqwxtvKkPUiIiKirun4jy6bYLVakZ2dHdlJJAluN7stUGS0Wo1nvJ6A+ucpv+mFwS9m4sVX12Hl98VB28uyinff34w1Px/CXbdPQEHv1JiXyW53wy0rSElueqZCIiIiotbQ6yVIkga1dfYW7TNlUj9MmdQPR8vNWLKsCEuW7m1yUhNFUfHz+sP4ef1hpCTrMWVyP5w1bQD69U2P6HwupwyXU4agEWDQSzAYpGa7ThMREVF8ifpbPSsrC9u2bYto2+XLlzfbPZkokCAIYSucyckG3HfX6Xjg3jOQnKwPWV+4txI3zv4Sn3y2vU26xrhdCmpqbG3WcpGIiIhIFDVITTEgMUHb4gAuO8uEP146Am+9fiHmP342pk3p3+TsygBQW+fAfxbtwl9u/hI3zv4SX3y1G3X1jojOpSoqbDYXqqs9rQxtNhe7JhMREXUBUQeFEydOxNy5c1FRUdHsduvWrcP8+fMxefLkaE9F3ZBO23Sl9vQJffDaizMx/pReIetcLgX/fGsD7rz3WxwpqYt5uWTZM8mJ08kZkYmIiKjtGAwS0tKMSEszwmjUtqhHg0YjYMTwHNx1+wR8+N7vcevNp+KkRpPDNba3qAovvvIz/nD5x5j35PdYv+FIxMGfyynDbHaiqsqGqior6s0OOJ0yuycTERHFoai7Ht9+++346KOPMGjQINx+++0444wzAACHDx+G2+3G7t278dVXX+Hf//43FEXBrbfeGqsyUzeg04mwWl1Nrk9LM+KhByZj2Yp9eOnVn2GxBG+7c9cx/OXmL3HNVaMx47xBMe0urCoqauvsMJl0MBqaHkCciIiIqLUkSQOTSQeTSQenU4bd7oLDKQcN0dKcxAQdzj17IM49eyAOHqrFkmV7sXR5EaqqbGG3d7kV/PDjfvzw435kZCRg2pT+OGvaAOTnJUd0PllWIdvcsNvcgABotSL0OhFarcguykRERHEg6qBwzJgxeOKJJ3Dvvfdizpw5/uXnnntu0HaqquKZZ57BsGHDoi8ldTuSFDpOYWOCIGDalP4YMTwHzz6/Ghs2lgStdzjceOnVdVi95iBuv/U0ZGeZYldAFTDXOyG7VZhMutgdl4iIiKgJOp0InU6EqqqwO9xwODzjBUaqd68UXHPVGFx1+Sj8srEE/1uyF2vXHWpyWJWKCis++ngbPvp4G4YOycJZ0wbg9Al9YDRG+KBUbRjTEPC0dNTqNNAIKkRRhNDc7CtERETUIVr1WO/uu+/Ghx9+iPz8fKiqGvLTq1cv/Pvf/2ZrQmoxQRCgbab7caDMjETMmzsNs286FUZjaPa9eWsZbrjxC3z7v8KYd4Gx2Vyoq7Ozaw0RERG1G0EQYDRokZpiQHq6EYmJOohi5KGbKGpw8riemHP/JHzwzsW44bpx6Nc3rdl9tu8oxzPPrcasyz/G0wtXYdv2oy2u/yiKCrvNjbp6ByoqraiptcNqdcHl5pAuREREnUXULQp9LrnkEvzud7/DmjVrsGXLFtTW1iIlJQUjRozAqaeeClGMLOwhakynFSN+Si4IAqafMxCjR+bi6YWrsHX70aD1VpsLzz6/GqtWH8CtN49Hjx4JMSunwyFDVuycEZmIiIjanShqkJCgQUKCFi63DLvd09JQVSIL8VJSDLhg5mBcMHMw9hZV4rsle7F85T6Yzc6w29vtbvxv6V78b+le5OUm4awzB2DalP7IzEhsWcEDWxtaPK0Ndd4uyjqdyDoVERFRB4k6KDx48CDy8/MhiiJEUcSECRMwYcKEWJaNujmttuUNXnNykvDk42fji6924423N4RMOrLulyP4842LcOMNJ2PyGX1j1uXF7VJQXW1DSoqB4+8QERFRh9BKIrQmEUkmzxAsDoe7ReMZDujfAwP698B114zF2p8P4bsle7FxUwmUJkLHktJ6vP3uJrz7r80YOSIHo0flYeTwXPTrmwZRbFl9SFFU2O1u2O1uAICk1UCnFaHTi9BKbHhARETUXqIOCvv27Yvt27fjpJNOimV5iPy0WvG44xSGo9EIOP+3J2HM6Dw8/ewq7Pr1WNB6s9mJJ5/6EatWH8TNN56C1BRDTMqrKCqqa2xISTZAp2OFloiIiDqOXi9Br5egKCocTk8A53ZFNouxTivi9Al9cPqEPqiosGDp8n34bkkhSkrrw26vKCo2birFxk2lAIDERC2GDcnGiOE5GD4sB/36pre4haDbpcDtUmC1uiBoBOi0Guh0ElsbEhERtbGog0JVVfHSSy/h9ttvR9++fWNZJiI/nVYMaRUYqV49U/D0/HPw6ec78N77m+FqNFD3T6sPYNuOo7jlxlMwYXxBLIoLqEBtrXdG5EgH+iYiIiJqIxqNZzxDo0ELWVa8XZPdkOXInsRmZCRi1u+H4ZKLh2LHznL8b+lefP/jfn/Lv3AsFhfWrjuMtesOAwBMJh2GDc3GiGE5GD4sGz17JgEteKaqKiocDhkOh6dO6G9t6O2qTERERLHTqjEK3377bbz88suYOnUqbrjhBvz2t7/lmIReJpMJkiTFdJILVVX9x+xKk2f4fpdwv5MkaeBwNF0RPR6NRsDvfzcU48bm46lnV6FoX1XQ+tpaOx59fCUmT+qLv17/GySZ9FGfK1B9vQMut4zEBG23u2bxrjveZ/Gsq14vgNespSSp1cMudxo5OTmsQ0SI90nLaDQCEhK0nvEMXbJ/5uRIxzMcMjgLQwZn4YbrxuHHVQewZGkRtu04etz9zGYn1qw9hDVrDwEAkpJ0GDYkG8OH5WDE8BwU9E5tUStB39iGFgu8rQ1FaHUa6HVSh7U27Kr3GMD7LN501esFsA5B1F4ENco7TKPRYOPGjdi9ezdee+01rFy5Ejk5Objmmmtw3XXXoXfv3rEua9woKSnBrl27cPrpp3d0UeKe262gusYWs2P9+5Pt+PcnO8KOtZOebsQtN56MsWPyYnI+wNMi0mDwdJOJ1XiIREQU3rx58/DnP/8ZeXmx+3e8vZWUlCAzM7Oji0HdiKqqcDo9oaHLqUBt4ZgvJaX1+P6H/di2vRy7dh+DK8LuzYGSk/UYOiQLw4ZmYfiwbPTulRJ1vUkSNdDqROjZ2pCIWqAr1CGIYiXqoHDy5Ml4++23UVDg6bK5Z88evPbaa3j33XdRXV2Ns846CzfccAPOO+88aDTda3KHkpISfPDBB7jiiitiWtlXFAWVlZXo0aNHl/pMVVWFLMsQxfBhWkWlNeIn3ZEo3FuJBc/8hIOHasOuP+esAbjumrFITNC1+lyKoqC6uhrp6WnQ67XQ6cUOfdodK8e7ZvGsu95n8aqrXi+A16yljh07hpdeeinuK/klJSX44osvcOGFF7IOEQHeJ7E+rwqHww27I/LxDAM5nTJ2/3oMW7aVYeu2o9i9+1jI0C+RSEkxYPjQbAwf5hnnsFfPKINDAf4JUXRascUTrLREV73HAN5n8aarXi+AdQii9hJ1G9sVK1YEvR84cCCeeuopPP744/jss8/w6quvYubMmcjPz8e1116La665Bj179mx1geOF2WyG2+2O6T/OgiD4j9nV/tEH0OTv1ZpxCsMZeEIGXnxuBt59fzM+/Xw7Gkfl3/5vLzZtLsXtt56GkcNzW3UuQRDglt0ABLhcClwuBRa4IGk93WN0OjGuZ0nuin8Xu+t9Fq+6+vUCeM0i5XZHP0xFZ1NWVsY6RAt1td+ro66XKApISNAhIUEHt1vxhIZ2d5OzHjem10sYMTwXI7z1J4fDjV2/HsOWrWXYuq0Mu3+tgDuC4LC21o4fVx3Aj6sOAADSUg0YPizH31W5Z35yxJ9LYP1LFAX/hCiSpInpg9uufo8BvM/iTVf8vViHIGofMe+Mr9PpcOmll+LSSy/Fiy++iNtuuw2PPPII5s2bB6fTGevTUTeg08U2KPQd89qrx+DUU3rhqWd+CpnF72i5Bffc/z/MnDEIf7pyDAyG2N4qnpn8nLBYPJVyTxcZibMlExERUacgSRpIkg6JiTrPeIZ2NxzOyMczBDzB4cjhuf4Hr3a7Gzt3l2PzlhJs216OX/dURDSpSnWNHd//uB/f/7gfgGe4mOHDcjDC+5OXlxRRaCDLKmw2F2w2FwBPHUySNNBqRe/vq+lywQoREVFLxTworKiowFtvvYXXX38dRUVF/kFGMzIyYn0q6ibacnyZISdl4eV/zMCb72zEoi93h6xf9OVu/LKhBHfcdhqGnJTVJmWQZRWyzQ27ze0dkFsDnU6CXt/1ugsQERFR/NFqPeP9mVTf7MPuqB7iGgwSRo3IxbChmZBECQ6HGzt2NbQ43FMYWXBYVWXDyu+LsfL7YgBARo8Eb4tDT1fl3JzIg0NZbphNGQL8gaFWaggPiYiIupOog0JRFLFt2zYMHjwYALBy5Uq8+uqr+M9//gOXywVVVSEIgn9G5PPPPz9WZaZuRpI0EDRCTMcpDGQwaPHX60/G+FN645nnVuFouSVo/ZGSOtx5z7e46IIhuOKykW3a6k9VfBVwGfVmT8VcrxOh07XtuDpERERExyMIAgwGCQaD1DCeod0dUXficAwGLcaMysOYUZ4xwWw2F3bsLPeOcViGPYWVEXV7rqi0YvnKfVi+ch8AICMjwd/acMTwHGRnmyJ7+Kr6en0osMPTFVHQeFsd+gJErRj3Y00TERE1J+qgUFVVVFRU4JlnnsFrr72GwsJC//IePXrgqquuwvXXX48BAwbErLDUfem0moanvW1k5IhcvPzCb/HaP3/Bt/8rDFqnKCo++Ww71q0/jLtun4ATBvRo07IAAFTA5ZTh8j6xlyQNdDrPgNxaiV2UiYiIqONoNAKMRi2MRi3cbgVOpwyXS4bbrUQ8pmFjRqMWY8fkY+yYfACAxerEzp3l2LK1DFu2lWFvUVVkwWGFFctW7MOyFZ7gMCszESOGN4xxmJ1lirhMqqIG1ccAz+/uCw21WrY6JCKirqVVXY+nTJkCVVX93YsnTJiAG264Ab/73e+g07V+xlgiH61ObPOgEAASE3S47ZbxmDC+N555fjWqqmxB6w8crMEtt3+NP1wyHJdeMrxdK4ZutwK3W4HV6oJGI/hnUNZqOZ4OERERdZyGLrpaAIAseyYQcbllf/0FUWSHiQk6jBvbE+PGeiZEtFic2L6zHFu2lmLrtqMo2hdZcFh+zIIly4qwZFkRACA724STTsxAv37p6N83HQP6pyM11RhxuRRFhdMpB3W/FgTAbHHCZnNBp5f4UJeIiOJWq4JCRVGQkpKCyy+/HDfccIO/GzJRrLV3ZWvc2J549cWZePnVdf5uLD6KouJfH27B2nWHcNdtE9CnT1q7ls1XBrt3XEMI8HZP9kyGwu4wRERE1JFEUQNR1MDg/a+Gqqpwu73hoUuGYo/u4W9iog4nj+uJk8d5gkOz2YntO456xjjcXoaifVVQIwgkjx414+hRM1b+sN+/LD3diP5909G/fzr6ewPE3NykiOtVsqzA4ZBhNjuhsbr94x36xjrUajUcRoaIiOJCq4LC+fPn48Ybb4TRGPkTOKJoSJIGGo0QdVeWaCQn6XHPnRNx2vjeeP7FtaittQet31tUhZtu/QqX/3EkfnfBkI6r/Knwj2sIAJJW459BmV1hiIiIqKMJguCfEEVVJSQkiBAEDdxub4DobXnY0laHJpMOp5zcC6ec3AsAUFfvaAgOt5VhX3F1xMeqqrKhquoI1m844l9mNEro1zcd/fqmYUD/HujfLx0FvVMjG686YLxDH0EjBI116KvfEhERdSatCgqnT5/OkJDajU4velrQtbMJ4wswdHAWnn9pLVatPhi0zuVW8ObbG7FmzSHceftp6Jmf0u7la8xTKXXCYgFEUfDPoNyWs0cTERERtYQoaiBJDSFZYKtDt1uGy9XysQ6Tk/QYf0pvjD+lNwCgrs6ObduPeidHOYri/ZEHhwBgs7mxY2c5duwsDyi3gN69UtGvb5qn5WH/dPTrmw5Tova4x1ODuiy7/McLDA4liUPKEBFRx4o6KFSUyGc3s1qt+OWXX3D66adHezoiJJn00OskWKzOoKez7SE11Yg5903Ciu+L8eLLP8NscQat3/XrMfz1li9x9RWjMXPGSZ3m6bAsq7DZXLDZXBA0gn8GZZ1OZCWUiIiIOo3AVoeNxzqMttVhcrIBp40vwGnjCwAANbWe4HDX7nIU7atG0b4q1Nc7WlROWVZRvL8axfur/ZOlAJ4JU3rmJ+KkQTme1of905GVmXjc+pYsq5Dlhp4hEABJ1EDyTpLi67pMRETUXlrVojBSxcXFmDx5MmS57SejoK7NE3IZ4XTK7R4YCoKAKZP6YcSwHCz8x2qs++VI0HqHQ8Yrr6/H6rWHcMfs8cjJSWq3skVCVVTY7W7Y7Z5xc3Ra0T8hSmcJNomIiIh8fGMd+vhaHXpaHra81WFqigETTyvAxNMK/Mc7VmHFvn1VKAr4KTtqbnFZy49ZUH7Mgo2bG1ofmhJ16NcvHQP6pXsmTumXht69UpsP/tSGCez8vOGhKArelpga/59ERESxFpOg0Gw2o7CwEGaz2T8DcqB9+/aF2Ysoeh0ZGPbokYBHHp6K75bsxauvr4fV5gpav3VbGW64+Qv8+ZpxOPvM/u1WrhZR4e/6YobTP66hVqfhLH1ERETUKQW2OjQaG1od+idKaWGrQ0EQkJWZiKzMRP84h4BnkpR9xd7gsLgKRUVVOHCwBrLcsq7QZosTW7d5xkv00UoaFBSkerote3/69k1DYoKu6QP5w0MACGh4IQCiRvAHh6KogSgJkER2XyYioui1KigsLy/HjTfeiEWLFrG1IHUIX2DocLhhtbqCn762IUEQcM5ZJ2DUyFw8s3AVNm8tC1pvs7nx3Atr8NOqA/jjZScgK7NdihU137iGsHgG2pYkDXRaEVotx8ohIiKizssXkOn1nveqqsIteyYRiabVIeCZJGX4sBwMH5bjX+Z0yTh0qNYTHhZ5A8R9VbBaXc0cKZTLrWBvURX2FlUFLc/LTUJ/b8vDAd4AMT3d2HwdTG3ouhwUIAL+1of+FogMEImIKEJRB4X19fWYMGEC9u7dG9H2/FKitqTXS9DrpXYPDLOzTHjisbPw5de78cbbGxrGl/HasKkEW7eXYdjQbIwdnY8xo/JQUJDaqe8HVVHhcspwOQPGyvGOkaPVegbb7sTFJyIiom5MEARPnUVqaHWoKKo/NIx2hmWdVvS3AMQ0zzJVVVF21IyifVXYW1SJXbvLcPiIBRUV1haXu6S0HiWl9fhx1QH/spQUAwZ4Wxzm5yUjLzcJeXnJyOiRcNxhY5oKEDWBLRC94SEfChMRUaCog8KFCxeiqKgI9913H66//nr07t0bWq0WW7ZsweDBgwEABw4cwAsvvIA33ngDW7ZsiVmhiZrSEYGhRiNg5oyTMHZ0Pp5a+BN27joWtN7lUrBxUyk2bioFAPRIN2L06DyMGZWH0SPzkJJiaPMytorqa3GowGbzLNJoPD8Gg6dVZ+D4QURERESdiUYjeOuIDcvcbgWyrECWVbjdsudPuWUBoiAIyM1JQm5OEsaf0gvlx8qRlZmF+non9hVXY+++SuzzTppy6HBti1s21tbasWFTCTZsKglartOJyM1JQl5ekj9A9P2ZkZHYbIioeGdeDhcgipLGMxaiN0AURQ3HsSYi6oaiDgoXLVqEyy67DPPmzWtym4KCAixYsACVlZV46qmn8Nxzz0V7OqIW6YjAMD8/GU/9/Rx8vmgn3nl3E1xNnLOyyoYlS4uwZGkRBAEY0L8HxniDw5MGZXpn++vcZFmFw+mGy6VCEARoNIK/taGk5TiHRERE1LlJUuBkIFr/8lgEiCkpBowamYtRI3P9yxwON/YfqAmaNGVfcTUcDneLy+50yjhwsAYHDtaErNNqNcjNbRwgJiM/r/kQUVFUKE4ZrjABokYUAFWBXq9CqxUZIBIRdXFRB4WFhYWYO3duRNvOmjULt9xyS7SnIoqaLzC0292wWp0tHoS6pURRg4svHIpxY/Lx1LOrULi3stntVRUo3FuJwr2V+OjjbTAaJYwYloPRo/IwdnQ+8vKS4qIriKKocDhkf9drjnNIRERE8aipANE3aYqnS6/ndUsCRL1ewokDM3DiwIygY5aU1ntCw31VKCquRlFRJapr7FGX3+VScPBgLQ4erA1Z5wsRfcGh589k5OUlIbOJEFFRvL+v3PCAGPDU9UTRU9/ztT70jYtIRETxLeqg0GazITc3N2iZVqtFVVVVyLbJyck4ePBgtKciajWDQYLB0H6BYZ+CNDz/zHko3FuBH34qxK976rBzV/lxz2uzubF23WGsXXcYAJCdbcKYUXkYMzoPI4fnwmRqZka8TiSScQ75JJqIiIjihW9ikMYaZl2Woa8TIUkaKCoiChBFUYNePVPQq2cKJp3e17+8qtoWNGnKkSN1OFJSB7u95a0PAx03RMzxjIHob4no7drcI90Ysr2qqHArKtyu4B40gkaAqPH0NvGFh75WiZxMhYgoPkQdFGZkZODgwYMYPXq0f1mPHj2wefNmTJgwIWjbtWvXRl9Cohhqz8BQoxFwwoAeSEmRcc1VWbDbZWzdXoYNG0uwcVMJDh+pO+4xjh41Y/G3e7D42z3QaAQMOjHDGxzmY+AJPeLnqW2YcQ5FUYBWJ/rDw7j5XYiIiIi8fAGiVquBKVGHtDQjNBpNaAtE7/tIAsT0NCPSx+Rj3Jh8/zJVVVFdY8eRI3UoKa3DkZJ6lJTWoaSkPnYh4qFaHDwUJkSUNMjJMSEvLzkoQMzLTUZmRkJQHc4XIHrIIcdqKkj0vWaQSETU8aIOCocOHYrnn38eM2bMgCh6xiMbMWIEnnzySUybNg2DBg0CAGzYsAGPP/44+vXrF5sSE8WALzC02V2wWV1t3sIQABIStDjlN71wym96AQDKjpqxcVMJftl4BJu3lMJicTW7v6Ko2LnrGHbuOob3PtgCU6IOo0bmYrS3xWF2lqnNf4dYkmUVss0NOzwVW45zSERERF1Fcy0QPeMfKi0KEAVB8ASIaUYMG5odtK65ELGktA42WytDRLeCQ4frcOhw6ENuT4iYFNQKMTMzET3SE9CjRwJSUwxBvUgiDRI9AWJDd2aNdxmDRCKithd1UDh16lTcd999GD9+PJ566ilMnDgRs2bNwuLFizFixAgMHDgQqqri119/haIo+Otf/xrLchPFhNGghdGghc3ugtXiavFsdK2Rk23C9HMGYvo5AyHLCn7dU4ENGz0z2/26p+K4ZTFbnPhx1QH8uOoAAKBnz2R/a8PhQ7NhNGqb3b+zCTfOoVbyBIcc55CIiIi6Ak+A6Jm5OFC0ASIQWYhYUuLpvlxS6mmBWOr9MzYhYi0OHQ5tiQh4epCkpRk9wWG6ET16eAJEX5DoW2ZK1EEQhIYuzW6gySBR9LVKZJBIRNQWog4KZ82ahW+++QaCIKC4uBgTJ07EZZddhnfffRdLly7Fjh07/NuOHDkSd999d0wKTNQWOjIwBDyVxsEnZWHwSVm4/LKRqDc7sHlLGTZuKsGGjUdwtNxy3GMcPlyHw4frsOjL3ZAkDYYMzsKYUXkYPSoP/fulx92YgKqiwumU4eQ4h0RERNTFHS9AlBUFiqx6JhdRVCiyAllRW9QSceiQ0BCxpsYeFCCWlNajpMTTGtFqa763SyRkWUVFhRUVFdZmt9PrRaT7wsT0gCCxR+B7IwwGrSdI9Bw95Di+8RD9QaIkQNQwSCQiaomog8KCggKsXLkyaJkgCFi8eDFefPFFLF++HIqiYOLEibjpppuQkJDQ2rIStTmjQQuDXoLd4e6QwNAnyaTHxNMKMPG0AqiqiiMldZ7WhhtLsGVb2XHHoXG7FWzZWoYtW8vw5jsbkZJiwOiRuRgzOh+jR+WiR3oc3o9hxjnUaASIkudpMmfcIyIioq7GFyAC4YdkkWXFOzOxL0T0BIpyBEGiIHha+6U1EyKWlNbj8JFaHCmpRWmp2RskxiZEDORwyCgtrUdpaX2z2yUmatEjPQHp6QnICGiRGPg+Lc0IrVbE8YJEQQDsdjccDjckSYQgeCde4YNoIurmog4KmzygJGH27NmYPXt2rA9N1C4EQWgIDO1uWK0dFxj6ytMzPwU981Mwc8ZJcLpk7Np1DBu8rQ33FoXONN5Yba0dK74vxorviwEAffukYcxoT2vDYUOyQ55exwtFUaE4ZYRUVQV4g0NPaChJGg6STURERF2OL0jUNjHiTGB46AsU/eGiokJtoo4bGCIOPikTbtkNSZQ83YNVFbW1dv9YiEdKGiZVKSszw2xxttnva7G4YLGEn3QlUEqKwR8c+kPEHglI97ZYzOiRgKQkHSxWF+rqHNBoAh4yC4DGGxoKGgEaAd4/PSGjfx2DRSLqomIeFBJ1FYIgwGjUBsyS3LGBoY9OK2LE8ByMGJ6DP105GjW1dmzc5JlJecOmElRV2Y57jOL91SjeX41PP98BnU7EsKHZGDs6D6NG5qFXzxRIUpy3yFM9rSrDjW/jCw9F0dMdxdcSkZU8IiIi6mo8QZbY5P/6VDW4NaLsVqEoird7sxq27isIAlJTjUhNNWLI4KyQ9Xa7G1XVVlRW2lBZaUVlle/H+967zDcudVuorbWjttaOon1NbyOKApKSdEhNMSI52YDkJD2Sk/VIMumQlKz3v09OMiApYF1Iz5UwwaLG291Z0DSs8/3woTURdXYMComOo7MGhj6pKQZMmdQPUyb1g6qq2H+gxjspyhFs234ULpfS7P5Op+zv1gx4Kk25OZ6Z6/Lzk9EzP9n/OqNHQtxXbjxP0mU0DhB9g2NrBMBm83RD0ekkdmMmIiKiLksQBEiSr24XvoeJ2y3D6XQBggaqguOOk2gwSMjLTUZebnKT51VVFRaLqyFEbBQqVlXaUFFlRVWVFbLcNvVuWVZRU+NATY2jRfuZEgOCRF+AmOT58S0LDhr1MBikhjp0o2BRDGid6A8WG7VcJCJqTwwKiSIUGBjabG5Yba4mu2t0FEEQ0LdPGvr2ScPvLhwCh8ONbduPYoO3xeH+AzXHPYYsqzh8pA6Hj9QB64PX6fUS8vOS0DM/Gbm5JvTqmYpePVOQl5eM5CR92/xS7cQ3y56iKLDafN1QXCHdmANbIrLiRkRERF2dKHomkZMkKWzdx9OlWfG3TFQUFarqfa16ujcrKoLqzYIgwGTSwWTSoaB3apPnVhQVdXV2VFbZUOFtjVhVZfW8rrKhqsqzrKbWDrWdquVmixNmi/O44ykG0kqaoHAx6HUT4WJSkt7zwFpoCA8FoVFX6MCQUfB8rqyeElFrMSgkaiFBEJCQoIXR2HkDQx+9XsLYMfkYOyYfAFBRYcHGzaXYsPEINm4uRV1dy56gOhxu7Cuuxr7i6pB1Kcl65Od7WyHmpfhbI+blJkGvj+N/aprpxszJVIiIiKi783VvbmqcRB9VVaGq8IeJzQWKvmUaTUM35/790ps8ttutoKq6ITgMChK9wWJVpa1Nx09sjsutoKrKFtEQQYESE7UNYWKyASaTztM12qT3B62Br00mPZJMWogSoNPpPK0VNZEFjBxvkYh84vh/70QdK54CQ5+MjEScNW0Azpo2AIqiYm9Rpae14cYS7NhV3qquHbV1DtTWHcPOXcdC1mVlJgZ1Y+7pDRSzs0xxHapFMpmKJImeLs2iAFHDsRCJiIioe/K1dmtJXSg4SGw6ZBRFAdnZJmRlJjZ7PLvd7enaXGXFsWMWHC6pgKrqUF/vQH29A3X1DtTVOVBvdqK+zhHz2Z1byjN5iwulZeYW7SdJmoYgMTEgVEzS+8NGkyn4te9Pg1FiwEjUzTEoJGqleAwMAU8lbeAJGRh4QgYu/f1w2GwuHDxUiyNH6nC4pA5HjtTi8BHPTHY2m7tV5yo/ZkH5MQs2bS4NWi5JGs94iGFCxPQ0Y/x27Q1ohRgyUHdA9xFRI/gHu9Z4x0gUBIGzMxMREREB/npR+NETwwvfWtGz3GCQkJysR0HvVLhlGUfLTMjMzAye9TiAyyWj3uxEXZ3dEyTWecPEegfqva/9AWPAsrYaVzFSbreCmho7amrsLd5X6w8ZG4JEX8AYHC7qYErUIynJ06oxKVkPo3csRkEjIDlJzwCRKE4xKCSKkcDA0Gp1wWZ3A83PI9KpGI1anDgwAycOzAharqoqqqptOHzYExoe9gWIR+pQWlbfqoqQ263g0OFaHDpcG6Y8UkBwmIKe3glV8vOSYTLpoj5nh1MBxVtx9cSv4Wf888+aJ2r8g1yLYvCsefHcGpOIiIioLUTawk1RFLicBmRmJgIQPMGiN1QMfJ2SYoCSlwRV8Xad9naT9r1uPJmLqqqw2lz+0LAuMFBsFC4GLrNaO7b1oo/LraC6xo7qaEJGrcbfFfrJx8/CiQMz26CERNTWGBQSxZggCEhM1MFo1MJicUCK8zBHEAT0SE9Aj/QEjBieA8BTAXLLbgjQ4Gi5JaAVYp2/FeKxY5ZWnddmc2NvURX2FlWFrEtNNSA/LxlZmYlISzUiNdWA1FQD0lKNSEvzvk8xQKttyfPnzkVVVMgAZDlM1+YAvtnyNJqAGfK83ZwFDdjdmYiIiOg4PHWllrVc9Akce9H3OjnZgOwsU6PlDWMw+l8HBI1utxLc/bm+UYvFOgfMZifMZk/XaN+fnSVgBACXyztWZLWND7SJ4hiDQqI2otF4AsOUFD0yMhIgy4DTKcPlluF2KyFPH+ORKGqQn+dp5febRuvsdjdKSuvChogtnUSlMV9Xih3H2c6UqENqmsEfJqalGpGWavAOih383mCIz38OfbM1N0sABACqqkCn0waNl8juzkRERETRi2bsxUC+LtKqCmRkJPhfBy73v0bDZC++17KswGJxesNDJ+rq7aits8FmlT0zNHuX15sdqK/3BIy+ZW05BmNSkr7Njk1EbSs+/2dMFGcEQYBOp4FO53lOqaoqXC4FLpcMl9vzZ1cIDgMZDBL69U1Hv76hM9TV1dlxpKTeGxw2dGU+UlIXOqZfK5gtTpgtThw+XHfcbY1GCakpntDQaBSQk52CtLSEhmAxxYA0b+iYkKCNr1DN2zXGLctQ1aYDwcDuzhoB/vETfS0TBQ2CBrImIiIiotbxPbCNVuBYjFABWVbgcrkhiqI3ZGw6aHS75OAg0dwQJAa+NpudnglfzE5v+Og47hjmyQwKieIWg0KiDuAJDsWg4NDtVuByKXC65C4ZHAZKTjYgOdmAkwYFj1uiKCoqq6wNrQ8DWiOWltVDacNJYmw2N2w2c8CscuVNbqvVagK6PDe0SkzztlJMTfN0fU5LNSIpjgZyDuzu7NF0aOsLFX1dn/2z4YkNs+L5fhgqEhEREbWNxhO+SJIGoghIkhRRHaxx0Nj4dVNBo8vbVdoc0FLR16rRanX5/59DRPGHQSFRJyAIArRaEVqtiARoAXhmWQtsdRgPMym3lkYjIDMjEZkZiRg5IjdondutoOxofVDrw+pqG6pr7Kip8fxpt7duduZIuVyKfybn4xFFASkpnuDQZNLDlKhFokmHpEQ9Ek06mBJ9s8bpkJjomUXOt9xgiKyC1xF8oSJk36QszQiY6TlciBj4Pl5CVSIiIqKuIJqZpX1ysk1NBo2s0xHFLwaFRJ2ULziELzh0y3C7FO84h90jOAwkSRr0zE9Bz/yUJrex212o8c7SVl1j87yutnle19q962yoqbbDbHG2S7llWUVVlQ1VVbYW7yuKgj9ANJk8P4mJvnBR71ln0oYPHU066DrLZC4BMz0flxDQvdnXFbqJLtAcJJuIiIioY7UmaCSizolBIVGc0EoitJIIo9ETHLq9Yxv6Wh62ZbfceGEwaJGTo0VOTtJxt3W6ZNTU2FFbGxAm1thRVW1F2dEa2O3wh451dXaoHfDxyrKK2joHaqOc/EWnE4NaKyYmapFk0oeGjr7g0eTZxmTSIzFB2zFBXNhQseku0CpU1NQ4YDDYoBFFf3dojeBpregLFRu/5lNuIiIiIiKiUAwKieKUJGkgSZrg4NAtw+VkcBgJnVZEVmYisjITg5YrioLyY+XIysyCRuMJymRZQW2dA9XVvpaJNlRXN3R5rq6x+QPHmlo7ZLlzfPZOpxx1a0YA0OslJCZokeD7MWqRmKhreJ+gRYKx4X1iog4JRu9r/zY6SFLbBY6qokJWPON7alo4D46gESAAQa0XhYAgUfC+b/yaISMREREREXVVDAqJugh/cGjwBIeeGc8aWh12lvAqHomiBulpRqSnGY+7raKoMJsdQd2ffS0XzRYnLBbPIM9m758W78zM7TW+Yks4HG44HG5UVUcXNProdKI3OGwcMjaEiYmJ3oDR2GibBC0SvftpY9yVWvUOyh1VqC74Wic2tGDUaISgrtNB3ai923JyFyIiIiIi6swYFBJ1UaKogShqYDB4bnN/cOhtdcjgsG1oNIJ/VueC3qkR7+dyybBYXbCYnag3O7wBogsWi/d9QLgYLnB0u5W2+6VayemU4XTKqK6xt+o4Wq3GHzYmBgSNgkZGWqoJBoMWRqMWBr0Eo1GCwSDBYNB6/gxYZvQtM0jRd6/2dpEGAERzLwUGjYInVBSEhhaO8GaJsuyGVlKDwkbfnw3HCDgOERERERFRKzAoJOom/MGh97ZXFBUulwynyzNJSmcOmroDrVZEaoqI1BRDi/dVVRVOp9wQHPpaK/qDRAfM3gDSanUFhY31ZiesVldcdFV3uRTU1npaZ8aKVqvxh4sGoy9QDAwbG0LFwICx8TKjd1+D0fNeK2maD+4Cg0aE/+xVVYVbdkMS1chDQF8X6TABpK/1o4DgwDFcACkguMs1ERERERF1DwwKibopjUaAXi9Br28IDmXZM7ahoqqeIENRoaqewELxdtNUFRWKokBRGB50FoLQcC179EgIu01D6CSFBD+KosJm9waI3h+bzQWL1RMiWq0uWKwuWH3vbS5YLMHvrVYXnM4WDhLYCXi65ztQh+gmjGmKKApNhIta6PUi9DoJOp0IvV6ETidBrxOh8/7o9ZL/tSQBRoMuYJnk3b/hdVCrSO/9KvvetFJSkt7fKpmIiIiIiLo+1v6JCAC8kzRENgacqqpwu92QpIaQMShQ9L5W/WGj50fxLVcaXscgy6BW0mgEJCbokJigQ3ZW9MdxuWTYbMHBosUbNPp/bJ5wMVzQ6NvP4eh84zW2lCyrsFg8v2dbE0UBep0Erc4bIAYGkToROn2jIFInebdpCBt1/vVS0DFOOKEHciOYRZyIiIiIiLoGBoVE1CqCIEAUo29dGBooel9DhaoEvvauUxteq979PQeKze9D0dNqRWi1IpKTW959OpAsK6GtFv1BY0BLR4vndXV1PVRVgt3hht3u+bHZXf7X8dCtujVkWYXV5gJssQ8l775jAmb9fnjMj0tERERERJ0Tg0Ii6lCBs8HGgi849LVq9L0GABUNLRj9ywK3hwpVUWCxaGEy6SAIGv82QcfwvAhz/IBjhj1+8DKGm+GJogZJJj2STPrjbqsoCsqPlSMrMwsaTejEJKqqwuVSYLO5YHe4PX/a3UE/vlDR5l/W6L1/X7f/GA67G65uMK6nXsdqAhERERFRd8L/ARBRl+Ibf8/zR8vDR0VRvJNTaMMGT7EWEjY2DiXDBJstWu95AUVRIboBURR9H05QYNlVA01BEPzdalNifGy3WwlpvWi3u4ICxXChpMMhw+F0w+WU4XDKcHrfO/3v3XC6ZDgccoe3hvSNYUpERERERN0D/wdARNSBgoNNIJpwMxKecSVFSFLoZCYtOUa4lphAZK01vRuGbBMu2AxdF3xMX7gpCBrP+JqiAEEQ2jXclCQNTCYdTCZdmxxfVVXYHU7IMuByKp4Q0emGw+GZrTwoYHR41znlgADS7d1HhsMREEQGHscZegw14LPT6yMbt5SIiIiIiLoGBoVERBQRXzdx77uOLIqfoihwOg3okZ4Q0gK0Ja01jxd8NhV6hut+HsuWmpKkgUEvQUhsn8/bEygr/lAxJ9vULuclIiIiIqLOgUEhERF1Se3VWrM1mhtTU1EVuF2+2cWFqMNM33kiCTMBARpRA61ORCLY9ZiIiIiIqLvh/wCIiIg6SHNjaqqqAAEqJEmMurs4ERERERFRS7T9SP1ERERERERERETU6TEoJCIiIiIiIiIiIgaFRERERERERERExKCQiIiIiIiIiIiIwKCQiIiIiIiIiIiIwFmP/axWKz744AOsXr0atbW1yMzMxOTJk3HRRRdBkvgxERERERERERFR18YEDJ6Q8J577oHZbMZdd92F/v37Y+PGjVi4cCF2796NBx98EKIodnQxiYiIiIiIiIiI2gy7HgN47733cODAAdx4440YPHgw9Ho9Tj31VMyaNQsbNmzAd99919FFJCIiIiIiIiIialPdPii0Wq1YsmQJ0tPTMWbMmKB1U6dOhSAIWLRoUQeVjoiIiIiIiIiIqH10+6Bw69atcDqdGDhwIARBCFqXnJyMvLw8lJaW4siRIx1UQiIiIiIiIiIiorbX7YPCAwcOAACysrLCrvct921HRERERERERETUFXX7oLC6uhoAYDKZwq73La+pqWmvIhEREREREREREbW7bh8UOp1OAGhyVmNJ8kwM7XA42q1MRERERERERERE7a3bB4U6nQ4AIMty2PVutxsAoNfr261MRERERERERERE7U3q6AJ0tLS0NACA2WwOu963PDU1Nez60tJSlJaWBi07duwYLBYLAEBRlBiVtOFYsTxmZ6CqKhRFgaIoIRPKxDtes/jDaxZfuur1AnjNujOtVguAdYhI8D6JP7xm8YfXLL501esFdN1rRtTZdPugsKCgAABw9OjRsOvLy8uDtmvs1Vdfxdy5c0OWz5o1CwBQVlYWi2KGLRPFD16z+MNrFl94veIPr1nTrr76agCsQxCvVzziNYs/vGbxh9eMqG11+6Bw+PDh0Gq1KCwshKqqQU9d6urqUFJSgpycHOTn54fd//rrr8dvf/vboGXHjh3D0qVLAQA5OTkxK6uiKCgvL0dWVhY0mq7Ta1xVVbjdbkiS1CWfevGaxRdes/jSVa8XwGvWUm0RqnWUt956C1dffTXrEBHgfRJ/eM3iD69ZfOmq1wtgHYKovXT7oDAhIQFnnnkmFi9ejA0bNmDs2LH+dcuWLYOqqiFBYKDc3Fzk5uYGLSspKcGaNWsAoE2+dDQaTZf7MvP9Tl3ty8yH1yz+8JrFl652vQBes+7M5XIBYB0iErxP4g+vWfzhNYsvXf16AV3vmhF1Nry7AFx++eXo1asXXnzxRezcuRMOhwNr1qzBRx99hFGjRuHcc8/t6CISERERERERERG1qW7fohAAEhMTMX/+fHzwwQd46qmnUFNTg8zMTFxwwQW46KKLIIpiRxeRiIiIiIiIiIioTTEo9EpMTMR1112H6667rqOLQkRERERERERE1O7Y9ZiIiIiIiIiIiIgYFBIRERERERERERGDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgKDQiIiIiIiIiIiIgIgdXQBurKKioo2OW5ZWVmbHLejSJKEtLQ0HDt2DG63u6OL0yZ4zeIPr1l86WrXC+A1a6m2+s7tKKxDRIb3SfzhNYs/vGbxpatfL4B1CKK2xqCwDSQkJECr1eLzzz+P6XHr6+uxYcMGjBkzBklJSTE9NrUNXrP4w2sWX3i94k9bXjOtVouEhISYHrO9sQ5BAK9XPOI1iz+8ZvGHdQii9iGoqqp2dCG6opqaGlit1pgec9u2bTjnnHPw7bffYtiwYTE9NrUNXrP4w2sWX3i94k9bXrOEhASkpqbG9JgdgXUI4vWKP7xm8YfXLP6wDkHUPtiisI2kpqbG/B8aXxPrzMxM5OXlxfTY1DZ4zeIPr1l84fWKP7xmx8c6BPF6xR9es/jDaxZ/eM2I2gcnMyEiIiIiIiIiIiIGhURERERERERERMSgkIiIiIiIiIiIiMCgMK7k5ubi4YcfRm5ubkcXhSLEaxZ/eM3iC69X/OE16xj83OMLr1f84TWLP7xm8YfXjKh9cNZjIiIiIiIiIiIiYotCIiIiIiIiIiIiYlBIREREREREREREYFBIREREREREREREAKSOLgAdn9VqxQcffIDVq1ejtrYWmZmZmDx5Mi666CJIEi9ha6mqivXr1+P777/Hrl27UFNTA71ej4KCApx99tmYPHlyyD7XXnstysvLwx4vJycHr732Wth1GzZswKeffop9+/ZBo9HgpJNOwh/+8AcMGDAg7PaKouDrr7/Gd999h7KyMphMJowdOxZ//OMfkZqaGvXv3BUsXLgQy5cvb3L9m2++iYyMjKBlR44cwXvvvYdt27bB6XSioKAAM2fOxMSJE5s8Dq9Z6y1btgzPPffccbebN28ehg0bBoD3WEeoq6vDyy+/jFWrVmH27NmYOnVqk9t21nuJ35eh+Jm0HdYf4hPrD/GFdYjOj/UHoq6HLQo7OavVinvuuQerVq3CnXfeiQ8++ABXXnklPv/8c8ybNw+yLHd0EePexx9/jMceewx1dXV44IEH8OGHH2L+/PkwmUx49tlnm6yc5OTkID8/P+SnqVm4lixZgrlz56Jv37745z//iX/84x+QJAl33303tm3bFnaf5557Dm+99RbOP/98vP/++5gzZw527tyJO+64A9XV1TH7DOJVWlpa2GuQn58PURSDti0uLsbtt9+Ouro6LFiwAO+88w7Gjh2LBQsW4OOPPw57fF6z2NHpdE1eq6SkJGg0mpB7h/dY+1m9ejVuvPFGbN68+bjbdtZ7id+XofiZtC3WH+IX6w/xhXWIzov1B6IuSqVO7ZVXXlFnzJihrl+/Pmj5559/rs6YMUP9+uuvO6hkXcd7772nXn755arVag1a7nQ61euuu06dMWOGunnz5qB111xzjVpWVhbxOY4dO6ZedNFF6h133KEqiuJfbrPZ1Msvv1y9+uqrVafTGbTPqlWr1BkzZqhvvvlm0PLCwkJ1xowZ6t///veIz98VPfvss+rSpUsj2laWZfXmm29WL774YrW6ujpo3SOPPKLOnDlT3b9/f9ByXrPYWbp0qXrfffc1uf7+++9X582bF7SM91j7+frrr9Urr7xSXbdunfrss8+qM2bMaPLe6sz3Er8vQ/EzaVusP8Qn1h/iC+sQnRfrD0RdF1sUdmJWqxVLlixBeno6xowZE7Ru6tSpEAQBixYt6qDSdR3p6emYMmUKjEZj0HKtVouRI0cCALZs2dKqc3z77bdwOp3+6+ZjMBgwceJEVFRUYNWqVUH7+K7tmWeeGbR8wIAB6NOnD1avXo2KiopWlau72Lp1K/bv349x48aFdDmYNm0aFEXBl19+GbSc1yx2srOzMXz48LDrDh06hG3btuHcc89t1Tl4vaLXp08fvPDCCxg3btxxt+2s9xK/L0PxM2l7rD90fZ3137zuhHWIzov1B6Kui0FhJ7Z161Y4nU4MHDgw6B9HAEhOTkZeXh5KS0tx5MiRDiph1zB9+nRcddVVYdf5Kv+qqrbqHOvXrwcADBo0KGTdiSeeCAD45Zdf/MvMZjN2796NxMRE9OzZM2SfQYMGQVXVoH2oab7PyfdZB/Jdk8afJa9Z7AwdOhSzZs0Ku27x4sXIy8vz/6c6Wrxe0Rs8eDBMJlNE23bWe4nfl6H4mbQ91h+6vs76b153wjpE58X6A1HXxZE5O7EDBw4AALKyssKuz8rKwpEjR3DgwAHk5+e3Z9G6Dd+XwtChQ0PWffvtt9i4cSNKS0shCAJ69eqFKVOm4JxzzoFG05DBy7KMQ4cOAQh/LX3LfNcbAA4ePAhVVZu99o336Y62bt2K5cuXY//+/XA4HMjKysLJJ5+Miy66KKji0ty9lJaWBp1Oh6qqKtTV1SE5OZnXrJ3YbDasWLECs2bNCqmcAbzHOqPOei/x+zIUP5OOxfpD58b6Q/xjHSK+dNZ7id+VROExKOzEfIOtNvWkxre8pqamvYrUrdTX12PTpk3o168fRo8eHbL+119/xY033oi+ffuirq4OX3zxBV555RVs3LgR9913n38wbIvFArfbDUEQkJiYGHKccNfxeNfed5zufu137NiBa6+9FiNHjoTb7caaNWvw2muvYdWqVfj73/+O9PR0AMf/PBMSEuB0OlFTU4Pk5GRes3aycuVKuN1uTJs2Lex63mOdT2e9l/h9GYqfScdh/aHzY/0h/rEOEV86673E70qi8BgUdmJOpxMAQmZf8/FN1e5wONqtTN3J22+/DUEQcNttt4U8qbz55psxePBgaLVaAECPHj1w9dVXo6SkBD///DO+/vpr/Pa3vwXQcH1ach191963LpJ9upuZM2fiiiuu8FfmAc94JFarFW+88QZeeeUV3H///QBa/nnymrWPxYsXY+LEiWErZ7zHOqfOei/x+zIUP5OOw/pD58b6Q9fAOkR86az3Er8ricLjGIWdmE6nA4Amp2R3u90AAL1e325l6i5WrlyJZcuW4fbbb0dBQUHI+hEjRvgrH4HOPvtsAMCKFSv8y3zXpyXX0Xftfesi2ae76du3b1Al3+fss8+GIAhYt24dzGYzgJZ/nrxmbW/Hjh04cOAApk+fHnY977HOqbPeS/y+DMXPpGOw/tD5sf4Q/1iHiD+d9V7idyVReAwKO7G0tDQA8FdWGvMtbzxzFLXOpk2b8MILL+DGG2/E+PHjW7RvTk4OAODw4cP+ZYmJiZAkCaqqwmKxhOwT7joe79r7jsNrH8pgMCA1NRWKoqC0tBTA8T9Pq9UKoOHz5DVre4sXL8YJJ5yAE044oUX78R7rWJ31XuL3ZSh+Ju2P9Yf4xvpD/GAdIv501nuJ35VE4TEo7MR8T6KPHj0adn15eXnQdtR6mzdvxhNPPIHrr78eZ555ZkyOKYoievXqBSD8tQx3HXv37g1BEPzrItmHGjSeZbK5e6m6uhpOpxPp6elITk4GwGvW1qqrq7FmzZomWwK0FK9X++ms9xK/L0PxM2lfrD90Daw/dH6sQ8Snznov8buSKDwGhZ3Y8OHDodVqUVhYGFJxqaurQ0lJCXJycjgDU4xs2bIFjz/+OK699tqgSv7Bgwfx448/+t//5z//wbPPPhv2GL4n0I2vydixYwF4BlZuzLdszJgx/mUmkwknnngiLBZL0FNPn927d0MQhKB9upNdu3bh+uuvD7vOZrOhtrYWGo0Gubm5ABo+2z179oRsv3v37qBtfHjN2s7//vc/GI1GTJw4Mex63mOdV2e9l/h9GYqfSfth/SF+sP4Q/1iHiE+d9V7idyVReAwKO7GEhASceeaZqKqqwoYNG4LWLVu2DKqq+gfipdbZsmUL5s2bh2uvvRZnnXVW0LrCwkJ88803/vc2mw2bNm3yN5EP5Ntu0qRJQcvPOecc6HQ6/3Xzsdvt+Omnn5CRkYHTTjstaB/ftV2yZEnQ8r1792L//v049dRTkZmZ2fJftgtwu90oLS1FYWFhyLpvv/0Wqqpi7Nix/gGuR4wYgYKCAqxfvz5k1rKlS5dCo9Hg//7v/4KW85q1DVmW8d1332Hq1Kn+cWEa4z3WeXXWe4nfl6H4mbQP1h/iC+sP8Y11iPjVWe8lflcShcegsJO7/PLL0atXL7z44ovYuXMnHA4H1qxZg48++gijRo3Cueee29FFjHtbt27Fo48+CqPRiC1btmDBggVBP4GVfAAQBAE1NTV44oknUFhYCIfDgcrKSrzxxhv45ZdfMGrUqJAvuszMTFx33XXYs2cPXn/9ddTX16OyshLPPPMM6uvrMXv27JAKz4QJE3DGGWfgyy+/xNKlS+FwOFBUVIRnnnkGGRkZuO6669r8s+msfLNILliwAOvXr4fFYoHFYsH//vc/vP/++8jMzMQNN9zg316j0eDWW2+FIAiYP38+SktLYbVa8dFHH2H9+vWYNWsW+vbtG3QOXrO2sW7dOlRWVjb7bxfvsc6rM99L/L4Mxc+kbbH+EH9Yf4hvrEPEr858L/G7kiiUoDZuY0udjsViwQcffIA1a9agpqYGmZmZmDx5Mi666KKwM3pRyyxcuBDLly9vdpuhQ4fi8ccfBwA4HA6sW7cOP/74I/bs2YPa2lrodDr07t0bkyZNwjnnnANRFMMeZ8OGDfjkk0+wb98+iKKIQYMG4Q9/+EOTgzErioKvvvoK3333HcrKymAymTB27Fj88Y9/9A++2x2pqort27fj+++/x7Zt21BRUQFBEJCdnY3f/OY3uPDCC5GUlBSy3+HDh/Gvf/0L27Ztg8PhQO/evTFz5kycccYZTZ6L1yy25syZA41Gg7lz5za5De+x9nX06NEm/0OTlZWFf/7znyHLO+u9xO/LUPxM2g7rD/GH9Yf4xjpE58L6A1HXxaCQiIiIiIiIiIiI2PWYiIiIiIiIiIiIGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERERERERERERGBQSERFRnHjqqaeQlJSEp556qqOL0qxJkyZBEAT/z1VXXdXRRSIiIiIiigiDQiIiIooL77zzDsxmM955552OLkqz3nrrLWzbtg0zZ87s6KIQEREREbUIg0IiIiKKCw899BDGjh2LOXPmdHRRmtW3b18MHToUqampHV0UIiIiIqIWkTq6AERERESRuPjii3HxxRd3dDGIiIiIiLostigkIiIiIiIiIiIiBoVERETUcqqq4pNPPsG5556LzMxM6HQ6ZGVl4eyzz8a7774LWZb92/7tb38LmtyjT58+cDgcePLJJzFq1CgkJSXBZDLh5JNPxhtvvAFVVYPO9fbbbwftLwhC2DKVlpbivvvuw4gRI5Ceng6DwYB+/frh97//Pd58803U1tY2ud/dd9+NoUOHIjExEYmJiRg6dCjuvvtulJWVNfs5fP/995g+fTrS09ORkJCAQYMG4YEHHoDFYonocywpKcHtt9+OQYMGISEhASaTCSeddBJuvvlmFBUVRXQMIiIiIqJYEdTGtXEiIiKiZjgcDlx22WX47LPPMH78eMyePRsFBQUoKirCM888gw0bNmDq1Kn44osvkJCQgPLycpSXl2PRokV48MEHkZeXh4EDB8JgMOCmm25CTk4Otm/fjocffhgHDhzAJZdcgg8++AAajed5Zk1NDQ4fPoz169fjT3/6EwCEhInbt2/H6aefDkVRMGfOHJx88smQJAmbNm3CE088gUOHDuGqq67CW2+9FbTfsmXLcNFFF8Fut+Puu+/GueeeCwBYvHgxFixYAKPRiP/85z+YNGlSyOfwwgsv4JZbboHRaMQDDzyAadOmwW6345NPPsHq1avRv39/fPLJJ7jyyivx9ttvh+y/bNkyXHjhhXA6nbjvvvtwxhlnwOl0YsWKFXj66achSRL+9a9/4YILLojBVSMiIiIiioBKRERE1AI33HCDCkCdOHGi6na7g9a5XC515MiRKgD1+uuvD1r31ltvqQBUAOr06dNVWZaD1h84cEBNSkpSAagLFiwIOe+KFSv8+zd2wQUXqADU1157LWRdYWGhqtPp1CuvvDJo+a+//uo/38cffxyy3wcffKACUJOTk9W9e/cGrVuzZo2q0WhUAOoXX3wRsu+jjz7qX9/4vL4y+c793Xffhaz/9NNPVQBqQkKCWlRUFLKeiIiIiKgtsOsxERERRWz37t149dVXAQDz5s2DKIpB6yVJwl133QUAePPNN3H06NGwx5kzZ46/xaBP7969/S0G//73v8Nut0dcrp07dwIATCZTyLoBAwbgz3/+M0aOHBm0/KGHHkJ9fT2GDx8edpKUSy+9FEOGDEFdXV3ITMuPPPIIFEXB6NGjMWPGjJB977zzzrBl8ZkzZw7q6+sxZcoUnHXWWSHrL7roIgwcOBBWqxULFy5s8jhERERERLHEoJCIiIgi9sknn0BVVRgMBpxyyilhtxk0aBAAwOVy4YcffghZr9frMW7cuLD7Tp06FQBQWVmJVatWRVyugQMHAgDuuecefPfddyFdk//xj3/g1ltv9b93OBxYtGgRAGDatGlNHtcX4v33v/+F0+kEANhsNixduhQAMGXKlLD7GQwGjB07Nuw6p9PpP3e4Ls0+J554IgBPF2UiIiIiovbAoJCIiIgitmXLFgCA3W6H0WiEJEkhP7/5zW/82x88eDDkGBkZGSEtEX369Onjf+1rJRiJJ554AtnZ2Th06BDOOecc9O7dG3/961/x1VdfweFwhGxfWFjob7HYr1+/Jo/bt29fAJ5wsLCw0L+vy+UKKW9jOTk5YZfv2bMHNpsNgGeil3CfoSRJ+OqrrwCE/wyJiIiIiNqC1NEFICIiovjhmzk4Ozvb36quOdnZ2SHLJKnp6kdCQoL/dV1dXcTlGjJkCLZv344XX3wR77zzDoqLi/Hyyy/j5ZdfRmpqKm6++WY8+OCD0Ol0Qb8HABiNxojK49snsFzN7avVasMuDzz3ww8/jAsvvLDZ362pWZ6JiIiIiGKNQSERERFFLCUlBYCnReHQoUOjOobb7W5yndVq9b9OTk5u0XEzMjLw8MMP4+GHH8bGjRvx2Wef4b333sOhQ4fw6KOPorCwEB9++CGAht+j8TmbK49vn8ByNbevr9VhY4HnTk5OjvpzJCIiIiKKNXY9JiIiooiNGDECgKdVXFlZWZPbrVu3Dv/85z9RWloasq6iogKyLIfdb//+/f7XQ4YMibqco0ePxrx587Bv3z7ccsstAICPPvoIhw4dAgCccMIJ/taA+/bta/I4vnUJCQk44YQT/Pv6WgsGlrexpj6fwHPv3r27yf3dbjfeeOMNfP31101uQ0REREQUSwwKiYiIKGIXX3yxf7Zi3xh64fzlL3/BLbfcgsTExJB1DocD69evD7ufrztzjx49MH78+IjLNW7cONx///0hyyVJwiOPPOJ/7wsu9Xo9Zs6cCQBYsmRJk8f1rTv//PP93ZaNRiPOPPNMAMDy5cvD7me32/HLL7+EXafX63H++ecDAL755psmQ9NvvvkG1157LdasWdNk+YiIiIiIYolBIREREUVs0KBBuOGGGwAA8+bNQ2VlZcg2b775JjZu3Iibb745bPdhjUaDRx99NGRm4oMHD+Ktt94CANx7770wGAwRl+vYsWP49NNP/ZOEBPK12ktMTMTgwYP9yx955BEkJSVh+/bt/i7JgT788EPs2LEDycnJQWEjAMyZMwcajQabNm3Cl19+GbLv008/3ewYi4888giSk5Nx8OBBLFy4MGS92WzGvffei5SUFNx0001NHoeIiIiIKJY4RiERERG1yLPPPovKykr8+9//xsknn4z7778fI0aMQEVFBRYtWoTXXnsNZ599dki45tOrVy/k5eXhvPPOw0033YScnBxs374dDz30EOrr6/H73/8et99+u3/7mpoaHD58GMXFxf5l27dvBwCceOKJ0Gq1EAQBhYWFOP300zF79myccMIJkGUZmzZtwhNPPAGNRoOXXnoJJpPJf4wTTjgB//nPf3DRRRfh6quvxs6dOzF9+nQAntZ88+fPR2pqKj7//HP0798/6Hc45ZRTsHDhQtxyyy249NJL8cADD2Dq1KlwOBz45JNP8Pnnn2PKlClYvnw5ampqsH37diQkJPhnWB4wYAAWLVqECy+8EHfddRd+/fVXXHLJJUhKSsKOHTvw5JNP4uDBg/jss8+anD2ZiIiIiCjWBLXx43wiIiKiCHzxxRd4/fXXsW7dOlRVVcFkMmHEiBG44oorcNVVV/m7KPu8/fbbuPrqq1FQUIDi4mK88sorePPNN7F7924oioLBgwfj+uuvxzXXXBM0069vv3CKi4vRp08fHD58GO+//z6WLFmCnTt3oqKiAoIgID8/HxMmTMDs2bMxZsyYsMcoLS3FM888g6+//to/5mCfPn1w3nnn4Y477mg2qFu5ciWefPJJrF27FjabDbm5uTjnnHPw8MMP495778U777zj3/bkk0/G2rVrg/Y/evQonn32WXz11VcoLi6G2+1Gr169MG3aNNx5550YMGBAs9eAiIiIiCiWGBQSERFRuwgMCpubBISIiIiIiDoGxygkIiIiIiIiIiIiBoVERERERERERETEyUyIiIiojZWXl6O8vBxHjhwBALhcLv9kJEOHDu3IohERERERUQCOUUhERERt6m9/+xvmzp0bdh2rIUREREREnQeDQiIiIiIiIiIiIuIYhURERERERERERMSgkIiIiIiIiIiIiMCgkIiIiIiIiIiIiMCgkIiIiIiIiIiIiMCgkIiIiIiIiIiIiMCgkIiIiIiIiIiIiMCgkIiIiIiIiIiIiMCgkIiIiIiIiIiIiMCgkIiIiIiIiIiIiAD8P4c6DSTNwXeaAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "catch_noise_analysis.plot_learning(catch_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZTYufA6_gLA6" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for largest noise_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "_zT9y1NA4poe" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# catch_noise_analysis.plot_seeds(catch_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wQ15ZnVgNc6n" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PvkWAhKAFsbo" + }, + "source": [ + "### Mountain car noise" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "U3I25hMAf-5i" + }, + "source": [ + "\"mountaincar\n", + "\n", + "A classic benchmark problem in RL.\n", + "The agent controls an underpowered car and must drive it out of a valley.\n", + "\n", + "- Reward of -1 each step until the car reaches the goal.\n", + "- Maximum episode length of 1000 steps.\n", + "- Run noise_scale = [0.1, 0.3, 1., 3, 10] for 4 seeds for 1k episodes.\n", + "- Score is based on regret against \"good\" policy that solves in 25 steps.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "_5AaZZRhFsbo" + }, + "outputs": [], + "source": [ + "#@title parsing data\n", + "# mountain_car_noise_df = DF[DF.bsuite_env == 'mountain_car_noise'].copy()\n", + "# summary_analysis.plot_single_experiment(BSUITE_SCORE, 'mountain_car_noise', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "LCBxH1IJFsbu" + }, + "outputs": [], + "source": [ + "#@title average regret over learning (lower is better)\n", + "# mountain_car_noise_analysis.plot_average(mountain_car_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "l2f9gSdNgOay" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for largest noise_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "DDXxo_9vH1u9" + }, + "outputs": [], + "source": [ + "#@title average regret through learning (lower is better)\n", + "# mountain_car_noise_analysis.plot_learning(mountain_car_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cm_g7R2cgM7D" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for largest noise_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "uWCJrwHK4tKb" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# mountain_car_noise_analysis.plot_seeds(mountain_car_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "atMZdJBQNfNy" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_OXjiYVTFsbe" + }, + "source": [ + "### Cartpole noise" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zGPI8tqyf7E-" + }, + "source": [ + "\n", + "\"cartpole\n", + "\n", + "A classic benchmark problem in RL.\n", + "The agent controls a cart on a frictionless plane.\n", + "\n", + "- The poles starts near-to upright.\n", + "- The observation is [x, x_dot, sin(theta), sin(theta)_dot, cos(theta), cos(theta)_dot, time_elapsed]\n", + "- Episodes end once 1000 steps have occured, or |x| is greater than 1.\n", + "- Reward of +1 when pole > 0.8 height.\n", + "- Run noise_scale = [0.1, 0.3, 1., 3, 10] for 4 seeds for 1k episodes.\n", + "- Score is percentage of timesteps balancing the pole.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "wJpb89yUFsbf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('noise', 'generalization')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "cartpole_noise_df = DF[DF.bsuite_env == 'cartpole_noise'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'cartpole_noise', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "asG7gr5_Fsbi" + }, + "outputs": [], + "source": [ + "#@title average regret over learning (lower is better)\n", + "# cartpole_noise_analysis.plot_average(cartpole_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "wPOUkkq1gJBS" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for largest noise_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "kZrjk8WSHqUm" + }, + "outputs": [], + "source": [ + "#@title average regret through learning (lower is better)\n", + "# cartpole_noise_analysis.plot_learning(cartpole_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vRa8iMYJgMCx" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by noise_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for largest noise_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "vBEKq2zq4qh5" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# cartpole_noise_analysis.plot_seeds(cartpole_noise_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZXAVj3SrNd6P" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zCNVq9M0IEpT" + }, + "source": [ + "## Reward scale\n", + "\n", + "To investigate the robustness of RL agents to reward rewards, we repeat the \"basic\" experiments under differing levels of problem rescaling.\n", + "\n", + "This time we allocate the 20 different seeds across 5 levels of reward\\_scale = $[0.1, 0.3, 1, 3, 10]$ with 4 seeds each.\n", + "\n", + "In order to keep comparable statistics/regret we report rescaled regret/reward\\_scale." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "U5B77UDjIEpY" + }, + "source": [ + "### Bandit scale" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JscWOhKOiA60" + }, + "source": [ + "\"bandit\n", + "\n", + "\n", + "A simple independent-armed bandit problem.\n", + "\n", + "- The agent is faced with 11 actions with deterministic rewards [0.0, 0.1, .., 1.0] randomly assigned.\n", + "- Run reward_scale = [0.01, 0.1, 1., 10, 100] for 4 seeds for 10k episodes.\n", + "- Score is 1 - 2 * average_regret at 10k episodes.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "XgOuCckcIEpb" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('scale',)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "bandit_scale_df = DF[DF.bsuite_env == 'bandit_scale'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'bandit_scale', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "3vR6CvD8IEpd" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret over learning (lower is better)\n", + "bandit_scale_analysis.plot_average(bandit_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "dNHc7dECukLF" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for reward_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "_qkiiY16IEpi" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "bandit_scale_analysis.plot_learning(bandit_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4gd87xYWuvLa" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for reward_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "hUTzD5tj4vZq" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "bandit_scale_analysis.plot_seeds(bandit_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "22rddkYVNf8f" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hPlIUnPgIBb5" + }, + "source": [ + "### MNIST scale" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Xo6uxj7iiGSL" + }, + "source": [ + "\n", + "\"mnist\n", + "\n", + "The \"hello world\" of deep learning, now as a contextual bandit.\n", + "\n", + "- Every timestep the agent must classify a random MNIST digit.\n", + "- Reward +1 for correct, -1 for incorrect.\n", + "- Run reward_scale = [0.01, 0.1, 1., 10, 100] for 4 seeds for 10k episodes.\n", + "- Score is percentage of successful classifications.\n", + "- Must log `episode`, `total_regret` for standard analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "KUp30dhSIBb6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('scale', 'generalization')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "mnist_scale_df = DF[DF.bsuite_env == 'mnist_scale'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'mnist_scale', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "opeE-AlYIBb8" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret over learning (lower is better)\n", + "mnist_scale_analysis.plot_average(mnist_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vpeAlsxluomy" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for reward_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "QoJe7269IBcA" + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABSMAAAJVCAYAAAAlauDuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAA9hAAAPYQGoP6dpAACrhklEQVR4nOzdd3xUVd7H8e+0JCQhCSUhFAGBIFJkWUAFQQQURAVXhZW1AXYXV0DXsuoqoLJ2wIKCguWxoGIBRUVpgqAiHUSkBakhtPQ+c58/JjPJkAkkN0PCDJ/36xXI3HvuOWfmzGTO/OYUi2EYhgAAAAAAAADgJLPWdAUAAAAAAAAAnB4IRgIAAAAAAACoFgQjAQAAAAAAAFQLgpEAAAAAAAAAqgXBSAAAAAAAAADVgmAkAAAAAAAAgGpBMBIAAAAAAABAtSAYCQAAAAAAAKBa2Gu6AqEqLS1NOTk5NV0NAABOG5GRkYqLi6vpalQZfQgAAKpXqPQhgGBBMPIkSEtL0yuvvKKioqKargoAAKcNu92uu+++O6g/TNCHAACg+oVCHwIIJgQjT4KcnBwVFRWpU6dOio6OrunqAAAQ8rKysrRmzRrl5OQE9QcJ+hAAAFSvUOlDAMGEYORJFB0dzR8zAABQafQhAAAAEKrYwAYAAAAAAABAtSAYCQAAAAAAAKBaEIwEAAAAAAAAUC1YMxI4TWRlZWnOnDlq0aKFzj///JquDk6S9evX63//+5+uvvpqDRkyRJK0YMECTZ482ZvmjTfeUIMGDWqqilWyd+9e/d///Z82bNiggoICNWvWTFdeeaV69ux53OuWLVum119/XeHh4XrzzTerqbYAEBroQ5weQrkPkZ+fr9mzZ+vHH3/Uvn37ZLPZ1Lx5cw0cOFA9evTwe83Bgwc1a9YsrV69WocPH1atWrXUtm1bDR06VC1btqzmewAAoYWRkcBpIjs7WzNnztTPP/9c01XBSZSenq7s7GwdPHjQe6xv376aM2eO+vTpU4M1q7rk5GTde++9ysjI0HPPPad33nlHXbp00XPPPaePP/7Y7zUZGRl69tln9corryg9Pb2aawwAoYE+xOkhVPsQOTk5evDBB/Xxxx9rwIABmjFjhl555RW1adNGzz77rGbOnFnmmuTkZI0aNUq//vqr7rrrLr333nv63//+p/z8fN1///1at25dDdwTAAgdBCMBIIT07NlTb7/9tu68886arkpAuVwuTZw4UYZh6IEHHlCjRo0UGRmpoUOHqmvXrvrggw/0559/lrlu5MiRcjgceuqpp2qg1gAABI9Q7UN8+OGH2rFjh6688koNGDBAMTExio+P14gRI/SXv/xFM2fOVHJyss81kydPVlZWlv71r3/pr3/9qyIjI9W0aVM99NBDqlWrliZPnqz8/PwaukcAEPwIRgJAiKlbt66s1tD6875+/Xrt3LlTXbt2VVxcnM+5iy++WC6XS19++WWZ6/71r39pzJgxioqKqqaaAgAQvEKxD7Fs2TJJ0nnnnVfmXPfu3eVyuTR37lzvsZSUFO3YsUPh4eHq1KmTT/rIyEh16tRJhw4dYqQwAFQBa0YCJ5Cfn6+FCxfqp59+0u7du5Wenq64uDh16dJF1113XZnAiCQVFBRo5syZWrx4sdLS0lSvXj1ddNFFOvvsszV27FhvuqeeekodOnSQJDmdTs2dO1cLFizQ3r175XA41KpVK11zzTX6y1/+4r1m1qxZevfdd723Z86cqbffflvLly9XXl6eWrVqpdtuu81nLZuHH35YGzdulCQtXLhQCxcu9J6bM2dOhR8LM2VL0p49e7RgwQKtWbNGBw4cUGFhoZo0aaL+/fvr0ksvlcVi8aadMmWKvv32W0lSQkKCnnvuOU2dOlVr1qxRWFiYevbsqREjRshut2vmzJmaN2+esrKydPbZZ+uf//ynGjZsWKbeBw8e1MyZM7Vq1SplZGR42+8f//iH6tSpU+H7fzwVLWPQoEHe34cOHarExETNnj1be/fuVXh4uDp37qzhw4erbt26Pvn/8ccf+uSTT7Rt2zZlZ2crISFBbdu21UUXXaR27dpJ8m3n9u3ba8KECZWu/+rVq5Wenq7Y2Fh17txZ1157reLj473pHn/8ca1Zs8ZbxsiRI/Xmm29q06ZNslgs+utf/6o777xTMTExlX8Qj2PlypWSpLPOOqvMuTZt2vikKe3cc88NaD0AoDLoQ5SgD1G+ypSxZ88ezZw5U5s2bVJGRobi4+OVlJSknj17qmvXrpLK9geGDRum9957T1u3bpXT6VTr1q01bNgwtW7d2ptvKPchjh49Kkl+X2/16tWTJK1du9Z77MiRI5Kk2NhYv/l5+mhr165Vr169AlhTADh9WAzDMGq6EqFm3759mjZtmnr27On3TQ/BZevWrbrvvvs0aNAgXXXVVYqOjtb27ds1depU5ebmatKkSYqMjPSmNwxDY8eO1Zo1azR8+HBdeumlKiws1BdffKFffvlFe/bs0dChQ3Xdddd5r3G5XJowYYJWrlypW2+9VX379lVOTo7ef/99LViwQKNGjSqzVo+n09i9e3f16tVLHTt21K5du/T000/L5XJp2rRpioiI8KY/cOCAbrvtNvXp00ejR4+u0mNS2bJff/11/fDDDxo1apQ6duyogoIC/fTTT5o2bZoGDhyoESNGlCnj1ltvVVFRkVq2bKkhQ4aoadOmWrJkiaZMmaLLLrtMdevWVYMGDdS1a1dt375dEyZMUP369fXyyy/75LN79249/PDDqlWrlu677z61aNFC27dv18SJE1VYWKjnnnvO2xE1q7JlbNiwQY888ogaN26shg0b6vbbb1fdunW1evVqTZw4UTExMXrhhRe8nfFt27bpgQceULdu3TRs2DDFxcVpx44devnll5Wfn19mQ5ZBgwb5/SAxadIkLVy4sMzi83/++aceeeQRxcXFadSoUWrevLl27typSZMmKSMjQxMmTNAZZ5xRpoxmzZopLi5ON910kxo3bqwVK1Zo8uTJ6tSpkx577LEqPabH+u9//6t169bp4Ycf9rt5wuDBg1VQUKD33nvP74cYz/M/ISGBDWxCVFpampYuXarbb79djRo1qunqmEYfIrTQhyiLPoSvypRx6NAh3X333WrVqpXuvPNONWjQQHv27NHUqVO1adOmMsHhQYMGqX79+qpdu7buuusutWzZUrt27dLEiROVkpKiJ554QmeffXaZa0KtDzF8+HAdOXJEzz//vE8AVpLmz5+vl156SRaLRZ988onCwsK0d+9e3XXXXQoPD9cnn3xSJr+JEydq0aJFOuuss/Tcc88FtK6oGaHShwCCSWiNwQdOAs9otVtvvVX16tVTeHi42rZtq9GjRyslJUXz5s3zSb9w4UKtWbNGvXr10tVXX63IyEjFxsZq2LBhio6O9lvG119/rRUrVqhXr1664oorVKtWLdWrV08jR45UfHy8pk6dqszMTL/XtmnTRt26dVNkZKTatGmjgQMHKi0tzecb3pOlomXXr19fN910k84//3zVqlVLsbGxuvTSS3XZZZdpzpw53m+sj3XkyBFdeumlatOmjSIjI3XppZeqWbNmWrBggfLz89WrVy9FRkaqQ4cO6tWrl/78888ya/5MnDhR6enpGjlypM466yw5HA61adNG//znP3Xo0CG9/fbbPul37typYcOGaezYsarodzWVLaP0/bvvvvuUmJiosLAwnX/++brxxht14MABvf/++950P/zwg4qKivT3v/9dCQkJCgsLU5s2bXT77bdXqH4VqX9mZqYeeughJSUlyeFwKCkpSQ899JAyMjI0ceJEv9f9+eefGj58uJKSkhQZGamLLrpIf/nLX7Rq1apyn69meZ4j5b2GPB/m09LSAlouAFQFfYjy0YeofBk//fSTcnJydOWVV6pJkyZyOBw688wzNWrUqHLzP3TokG655Ra1adNGDodDLVu21L///W8VFBTolVdeqVAdT1T/U70P0blzZ0nSL7/8UubcihUrJLm/CMjOzpYk75fF+fn53pGcHgUFBd7Na7KysgJaTwA4nRCMBE6gadOmevzxx8scb9asmSTp999/9zm+aNEiSdKFF15Y5prypnJ88803kqRLLrnE57jNZtMFF1yg3NxcLV++3O+1x65/4/n2ed++fX7TB1JFyx48eLAGDBhQ5vpmzZrJ6XRqy5YtfvO3Wq3661//6nOsUaNGys/PV8eOHX2ON27cWJK0d+9e77EtW7Zo27ZtatCgQZn0HTt2VGxsrJYtW6bc3Fzv8TVr1ujo0aNavXp1hTrDZsrw+Otf/1pmLcOePXtKcgcgXS6Xz7kff/zR58NNZadR+fPHH39ox44datGihZo0aeJz7owzztCZZ56pbdu2+W2j+vXrl5lO16RJExmGoZSUlCrV61gFBQWSJLvd/+oinuMsJg/gVEIfonz0ISpfhmdK+vLly1VUVORN27BhQ73++ut+y4iNjdU555zjc6x58+Y644wztHv3bm3duvWE9SxPsPQhrrvuOtWrV0+zZ8/WN998o4yMDB0+fFgffPCB/vjjD+8amaX7WHfeeafsdrtefvllrV69Wjk5OdqzZ4+effbZgNYNAE5XrBkJVMCmTZv02WefKTk5WYcPH/YJEnm+RfXYsWOHpJKObWml183xyMnJ0e7duyVJZ555ZrnXbNu2Tf379y9z/ti1BT1Tm6ojKFPRsgsLCzVv3jwtXLhQBw4cKNNBL++b5ZiYGNlsNp9jtWrV8lu2Z2Rc6bI9nV9/j6vk7ginp6frzz//9K472KNHD/36669q0aJFhdYsMlOGh7/nQ2xsrKKjo5WVlaWUlBQ1atRIl1xyib777jt99NFH+vHHH3XRRRepe/fuOuOMM5SQkHDCOh6P50PIsR8iPJo0aaIdO3Zo69atZaY2HdsGUkn7BPr5FxYWJkk+H75K8xwPDw8PaLkAUFX0IfyjD1H5Mnr06KFZs2ZpwYIFWrdunXr16qXu3bsrKSmp3Kml/p43kvs5tnv3biUnJyspKemEdfUnWPoQ9erV04svvqgPP/xQn3zyiaZNm6batWurc+fOeu6553TrrbdKks8XxJ06ddIzzzyjTz75RC+88IJyc3NVv3599erVS/3799cTTzzhs8QCAKByCEYCJ7B48WJNnDhRSUlJ+s9//qNmzZrJ4XBIcq95c+w0nJycHEn+gyKeTlZppb9R/8c//lFuPcqbfnpsOZ5vzatjOdiKlG0Yhp588kmtWbNG11xzja644grVrVtXFotFCxYs0OTJk8vN3xOA8sfTBsfjaYuff/7ZZ+OYY5V+bOPj4ys12tBMGR6l18Q69nhWVpY376ZNm2ry5MmaNWuWli5dqvfff1/vv/++2rRpo1tvvbVMB78yjvd8LV3HYz8wS8dvn0A//+rUqaNdu3aV+6HTcz9YYw/AqYQ+RPnoQ1S+jLi4OE2aNEmffvqpFi5cqE8//VSffvqpmjVrpmHDhqlLly5lrj1eX0Py//5e2fqf6n0Iyd2P+Oc//1nmeEZGhiR3cPTY+5GUlKSHH364zDWe3bn9bXgEAKgYgpHACcycOVOGYWjkyJHlfnNdWlRUlDIzM/1+q+tvqq7nW1iLxaJZs2ZVqIMcTDZv3qw1a9aoRYsWGjZsWLWW7Xlse/Xqpfvuu++UKyMvL++4x0t/456YmKi7775bt99+u1auXKl58+ZpzZo1evjhh/XSSy+ZXmzbU//yRiF46lLeWmXVpVmzZlq3bp0OHDhQ5tzRo0dVUFCgunXrBnwHTgCoCvoQVUMfoqy4uDjdcsstGj58uNatW6f58+dr2bJleuKJJ/TUU0+pffv2PulP1Nc4drkYM/U/1fsQx7Nnzx5JqtQXu57p/GedddZJqRMAnA5YMxI4gdTUVEkqE+wpr+PVokULSSWdm9IOHjxY5lhERISaNm0qwzD8npek9evXV3n9Js+Ig+pW3uMnnfxpYJ6OpacOx8rIyNCqVauqVI+qlOGvvdPS0pSVlaWoqCglJiZKkrZv3+4NwoWFhal79+4aN26cLrnkEhUUFOjXX3+tcv090/yO5TludgpXoHgWn/e37tTmzZt90gDAqYI+RNXQh/AtY8+ePdq1a5ck95qgf/3rX/XAAw/ouuuuk2EY+umnn8rkUd7zwhNQ8zznqlL/U70PkZmZ6XfzGkneDZOOXZN1z5493v6Fv2tsNpt69OgR0HoCwOmEYCRwAvXr15fk3iGxtE2bNvlN36dPH0nS0qVLy5z74Ycf/F5z2WWXSXLvonmsrVu36tFHH9WRI0cqXGd/PN9KFxYWeo899NBD3sXyTxbPWkV//vlnmWk3xy7cH2hJSUlq3bq1/vjjD59F6T0+/PBDTZ061WckycGDB/XII4/orbfeOmlleKxevbrM1KUff/xRknTRRRd5F1T/8ssvvRsUlNa0aVNJVVsnMSkpSa1atVJycnKZD7+7d+/Wzp071apVq2r7ILF27Vrdd999ZV4rHTt2VLNmzfTrr7+WmW44f/58Wa1WXXHFFdVSRwCoKPoQVUMfwreMJUuWaObMmWXSefoD/qY+p6ene3d/9ti5c6d2796tZs2aqVWrVhWqa3n1D4Y+xN69e/XUU0+VCfpmZmbq22+/VVJSkrp16+Zz7ueff9aLL75YZjPB33//XRs3btTAgQNVp06dk3NHAOA0QDASOIErr7xSkvTKK69oy5Ytys/P18aNG/Xaa6/5TX/RRRepS5cu+uGHH/T5558rJydHGRkZeuedd8pdH+fSSy9Vt27d9Nlnn+nzzz/XoUOHlJOTo19//VX/+9//1Ldv3zLTbiorMjJSjRo10rZt25SZmam1a9dq06ZN3g9KJ0ubNm3UunVr7d69W9OmTdORI0eUmZmpzz//3O+HrUAbPXq0YmJi9MQTT2jt2rXKycnx7qD43Xff6a677vIG/SR3MHDDhg36/PPPvesIBboMjxYtWmjixIlKSUlRYWGhfv75Z7333ntKTEzUdddd55N27ty5WrRokXf63saNGzVnzhzVrVtXF1xwQZUeozFjxigmJkZPP/20tm7dqsLCQm3dulXPPPOMYmJiNGbMmCrlXxlz5szR1q1b9cknn/gct1qtGj16tCwWi5599lnt379fOTk5mjlzpn799VcNHTq0QlMgAaA60YeoGvoQZctYvny55syZ412iZOvWrZo5c6Zq1apVZkd1yb2r9YcffqjNmzersLBQ27dv1/PPP6+wsDCNHDmyyo9RMPQhPF588UXt3r1bBQUF2rx5sx5//HGFhYXpoYce8ttPS0lJ0bRp03T06FHl5uZq2bJlmjBhgjp37qwbb7zxZN8dAAhpFqM6Vqg+zezbt0/Tpk1Tz5492UwhRCxZskRffPGF91vrVq1aafDgwXr88ce9aUaNGqW+fftKkgoKCvTxxx9r4cKFSktLU4MGDTRgwACdccYZevzxx3XDDTfo73//u08ZTqdT8+bN0/fff6/du3fL4XCoUaNG6tevny655BJvJ8nfgu19+vTR6NGjdeutt5b51veNN95QgwYNJLm/zZ02bZp2796t2rVrq3///ho6dGiFHwezZWdnZ+vDDz/UihUrdOjQIcXExKhLly5KTEzUu+++600/Z84cffDBB2W+9R86dKj69u2r2267zed4+/btNWHCBL+Lvs+ZM8f7++HDh/XRRx9p5cqVSktLU1xcnFq3bq1rrrmmzLf1ycnJevzxx9WiRQs9/vjjFZ6aVpkyNmzYoEceeURDhw7VWWedpQ8//FA7d+5UWFiYunTpouHDh/vsMrl//34tXLhQq1atUmpqqvLy8lS/fn117txZV199terVqydJevjhh7Vx48Yyj12DBg3KtFtCQoLefPNN7+2DBw/qo48+0qpVq5Senq6YmBh17txZQ4cO9dmJc9KkSWVG34waNUrt27cv0z7HllERCxYs0LRp0zRkyBANHjy4zPk9e/bovffe04YNG5Sfn6+mTZvqyiuvLDO96nj1LV1vz2sWwS8tLU1Lly7V7bffbnoN1VMBfYjQQx9CVSqbPkRJGUeOHNGiRYv0yy+/6MCBA8rKylLdunXVvn17DR48uMwu7IMGDVL79u119913a8aMGfrtt99UWFios846S8OGDfNZJzGU+xBHjx7VRx99pN9++02HDh1SYWGhGjRooG7duunqq6/2uyv2li1b9OWXX+qPP/7QkSNHZLfb1bRpU/Xp00f9+vXzG7xE8AqVPgQQTAhGngR8kEB5PB3x0aNHe6di4fRTOhh57AhIAOaEygcJ+hAoD30IVJYnGFmZHb6B01Go9CGAYMJXOsBJMHLkSKWnp5c5vnLlStntdv3lL3+p/koBAIBTHn0IAAAQ6ghGAifB7t279eKLL2rXrl0qLCzUgQMH9P7772v58uW6/vrrfabgAgAAeNCHAAAAoc5e0xUAQtHIkSP1888/a9y4cUpLS5PdbleLFi304IMPqnv37jVdPdSg0mtTzZw5UzNnztRTTz2lDh061GCtAACnCvoQqKrS6z9u3LhRgwYNYmkYAMAphWAkcBL0799f/fv3r+lqVIhn/cITYc2hwCi9KP7p4HgbyJTGZjIA4EYfAlUVKo81fQgACF0EI4HTXIcOHU67ABmqz+jRozV69OiargYA4CSgD4GTiT4EAIQu1owEAAAAAAAAUC0IRgIAAAAAAACoFgQjAQAAAAAAAFQLgpEAAAAAAAAAqgXBSAAAAAAAAADVgt20T6KsrKyargIAAKeFUHvPDbX7AwDAqYr3XKD6EYw8CYqKiiRJa9asqeGaAABwevG8Bwcr+hAAANSMYO9DAMGEYORJYLe7H9bevXurTp06NVybU5/NZlPt2rWVmZkpp9NZ09VBBdBmwYc2Cz60WeUcPXpUixYt8r4HByv6EJXD6yT40GbBhzYLLrRX5YVKHwIIJrzaTqKkpCQ1atQoYPm5XC6lpKQoMTFRVmvoLPdpGIaKiop0xhlnyGKx1HR1Aoo2Cz60WXAJ1faSaLPK2rdvnxYtWhSw/GoafYiK4XUSfGiz4EObBZdQbS+JPgQQSkLnry4AAAAAAACAUxrBSAAAAAAAAADVgmAkAAAAAAAAgGpBMBIAAAAAAABAtSAYCQAAAAAAAKBaEIwEAAAAAAAAUC0IRgIAAAAAAACoFgQjAQAAAAAAAFQLgpEAAAAAAAAAqgXBSAAAAAAAAADVgmAkAAAAAAAAgGpBMBIAAAAAAABAtSAYCQAAAAAAAKBaEIwEAAAAAAAAUC0IRgIAAAAAAACoFgQjAQAAAAAAAFQLgpEAAAAAAAAAqgXBSAAAAAAAAADVgmAkAADAac7pdCk3t1BOp6umqwIAAIAQZ6/pCgAAAKBmuVyGsrIKJEk2m0VhYXaFhdnkcFhlsVhquHYAAAAIJQQjAQAA4OV0GsrNLVRubqFkkcIcNoWF2xTmsMlmY1INAAAAqoZgJAAAAJS886gaJkYrIsJRctCQCgqcKihwSpLsdqscDpvCw21yOGw1VFMAAAAEM4KRAAAApznDMPTQo98pIyNfrVrWVfu2DdSuXYLanZ2gOnVqedMVFblUVOReX9JitSjMYZUjzKbwMLusVqZzAwAA4MQIRgIAAJzmdu/JUFpaniRpy9bD2rL1sD6bvUmS1LhRjNq3S1C7tglq37aBGjWqLYvFIsNlKD/fqfx8p7JUILvdqrAw95Ruh51RkwAAAPCPYCQAAMBpbt36/eWe27svQ3v3ZWje99skSXFxEcWByQS1b9dALVvUlc1m9Y6azMlxj5oMD3NP5Q4LszFqEgAAAF4EI0PMwUPZslosslqLf2wW2axWWa0W2Wwlx9kZEwAAePz++8EKp01Ly9Oy5bu0bPkuSVJEhF1tzopX+7YJatcuQWefFa9atRzKyytSXl6RJMnusCo8zC5HmJVRkwAAAKc5gpEhyOUy5HIZx01jsVpk8xOw9PzYbAQsAQA4Xfz73h7qd0kr/bYpVb9tStXGTak6cCCrQtfm5RVp7br9WrvOPbrSarWoZYu67tGT7RqoXdsE1a1TS0WFBVK2+3xYmM37Q38DAADg9EIw8jRluAwVVTJgabWUHWnJBwgAAIKf1WpR82Z11LxZHV0+4CxJ7tkWv/2Wqo2bDui3TalK3nlUxvG7DpLcX4pu3XZYW7cd1hdzfpckNWpYW+3audecbNc2QU0ax7hHTVrknspdPJ3bbreezLsJAACAUwDBSJSrogFLq0Wy2qx+R1oSsAQAIDjF14/SRb3O1EW9zpQkZWcXaNPmg/pt0wFt/C1Vf2w5pIICZ4Xy2rc/U/v2Z+r7+dslSbGxEWp3drx35GSrlvVkt1tls1m8u3M7HFb6EAAAACGIYCSqxHAZckpyOp0qLC+RRe5A5TEBS89ISysfNAAAqFF2u1W1a4fL6XR5N6I5dsmXqKgwde3cWF07N5YkFRQ6tW3bYe+07t82pSozM79C5aWn52n5z7u1/OfdkqTwcJvanBXv3Rjn7DYJioxyeEdMhoXZZLMxahIAACAUEIzEyWdITqdRbsDSMNznwsLsstltshVvsGMYhg4dylZKapYOHMjW0aO53qnjNps7uGm3WWSzeUZhWmW3Wd0jM4tHZ9psFtns1uJritPZ3ddZPedtpf4vTldyTXE6u8WddzVuAORyGXK6XHI5DbkMw/2/y5DTZcjldBX/X3z7mHTO4nVDnU5XqWuK07kkl8v/9ZL7A6m/H4fd5v3dZrNIFkMR4Q6Fhdl90jGKBQCCj8ViUUSEb7fQMAxvYLKoVJBSxTHKMIdNbc9OUNuzEzTkGvf71p696dr4W6o2/uae2p1SwXUn8/OdWrc+RevWp0hyTxtvcWYd97Tudglq1zZBCfFRCguzKyzMxqhJAACAIEYw8iTJy8tTenq6IiMjK32txWJRbGys33NOp1NpaWmyWv2PDkhPz/Z+SPDHZrMrOjra77mCggLl5uZUur4eDkdYufc3Ly9P+fl5PscKC506dDhHqQezdSAlU4eO5OjgwRwdPJit1EPZOnIk1zsqw2p1yGp1+M3b6cyXYVRsmpg/Nlu4LBb/O3s6nXkyDFfZa6wlQUxPINRaHKy029wfomxWq8LCI+V0umSxWL0bC3mCgPn52XK5DPfoUsMTKCwJEB6PRRbZ7LX8njMMl5zOPL/nKsJiscpmi/B7zuUqkstVcNzrbTZ34NZut7kDv3ar7HaL7FarHGFhqlWrlp9gp00WFUkqkt1RfMzqvt7hsLhvFweJvdfYbAoPd+/OGh5hV0xMlGrXjlJEuF0REXZFhLuPR4TbVVSUL5vNqNBaZC6XS+np6YqIiPC+zqKjo2W3+/9zmZmZKafT/PMvJiam3NdzWlqa6XxP9HckMzPTdN52+/H/juTkmP87EhZ2/L8jeXm+z21/7VWeWrVqKTw83O+57OxsFRaWO777hE7Gc8QdCCpS3bp1ZbP5/xsVrM+RiraZP8d7joSKmupDnIjDbleduGif0ZNFRS45nS7l5uYrNzdHsTHSBd0SdEG3BEnS4cM52rzlkH7ffFCb/zionX+m+d1kz2qxy2oL8952uQxt235E27Yf0Wez18vlKlRigyi1OStBbc6KV9u28TqzWZwcYTZZLYbCw8PKDU4G22tfUnGfoGz/wyNYX/s5OTnev212u71SAeXKvj9URiCeI+W9H9GH8EUfoqxAP0dKv8ZiY2ND7jlCHwIIDQQjT5LffvtNX375peLi4ip9bVhYmIYPH+73XGZmpubOnVvuH9/MrPzjBiPj4xM0YMAVfs/t27dXS5Ysqmx1vZKSWqtbtx7e2wWFTh1MdY9s/PmnFdqwca0yM/KVkZmvjIx8ZecUVGghfEmKij5TtSIb+z2XnZWsgvxDpusdE9dOYWF1/J7LSPtNTmeu6bzr1jvX58NVaYdSl5vO12KxqV58N7/nnM5cpR1ZYzpvu6O24up09HuusOCoMjP+MJ13REQDRcck+T2Xk/WncnJ2m847KrqFakU28nsuI/13FeQfltVqkcPhO9LT4bDJbre4bzvcgVHDcCoqMlyOMJscdqu6dLlIiY0auQOdxcHO8HCbIiIcWrTwK+XmZclRnJcnv4p2kG644Qa/nSLDMPTxxx+bfjzCw8M1bNgwv+fS09M1a9Ys03knJiZq0KBBfs/t3r1bCxYsMJ332WefrZ49e/o9t3HjRq1evdrnmMvlUkZGxnE/kHl0795d7du393tu+fLlSk5ONldpSZdffrkaN/b/N+qbb74x1eE3ir+kuOmmmxQVFeX3fDA+R3bt2qUvv/yyQm3mz/GeI6GipvoQJ9KgQQNdeeWVxV/GWVX6c/n27fv1/fff+4zeN1zu56kkxdeV4rtJ53a2KmV/VvEakhlKOZCloiLXcd8f8nL2KSdnt9KOSJt/LzkeEWFXo4a11bBhtM5oHKuGDWMUEWEvM527W7du6tChg9+8f/rpJ+3YscPU4yFJl112mZo0aeL3nNnXvuT+23bJJZeUe74qr/3jPUeq+tr3PEf88bw/eP62Wa2VG93apk0bXXjhhX7P+Xt/qIzu3burXbt2kuTtm3qeu0uX/uj3/eHYdIZhFL8f1ZYsVm9//NJLB6hRo8al0hVfJ0OffT5H6cXPkWP7xJ6bnus8j1XpR2zo0OvcfQiL+4tqdzr3Ne+992FJQovKXOvN75gmsFg87w/D/Z6nD1HWqdaHKP0au/HGG0Oqn0kfAggdBCNhWlGRSxmZ+d4A45Zt0uKlTh1IzdaB1CwdOVISxHMHmvbWYG0B90ib/Hyn8vOdUvmrnJaxduMqhYVt93vu6OFVfgPWNptFdk/A026V3WEtXvfMrvAwd9AyPNym9KyfVScuRlFRYYqKcigqKkyRtRyqFelQ6sEsb3rWSwNwKrNYPDMGJDlKRvK6XC45nYYMQ3I6XbJaHWrWLE7NmsVJch87eChbTlc9FRQ20m+bUpWeUbF1J/PyirQj+ah2JB+VtFt2u1WJCdFq2ChGTZvE6Iwz4hQZ6X9WxcnmcrmnuOfnF8lZvGyK01kcqC2eAeE55nPOc7zIJVn/VEJCnqxWiySLLBb342yxSOs3uKezuwNFFm/AqOR/T+DK4o5Aef6zSA57mH5YkiwV52VRSb4ZmenavuOINy9LqUyLiyops/icpTh/qyzKLwjXpt9TvcvaWK3utcEtVov27cvQkaO5ktyBEpvN5l43vDhPq6Xkfsp7u+Q+5eUVKifH/d5tGIZPUC87u0B5eYWljsmbrvSX9KUDfoZKEh85kqNDh/yPyMvMLPCWezyG4e5j5OU5ZbGUjGrNySlUdrb/WSWFBU4VFpY/AvaYEsocycsrktVaVE5dyh6vqMJCqw4fLnk8DMNQkdM90i4tLVtZWSX3xydY6XmO+pyzFD+H3bcLC50qLHR629hiKTkPADh9EIxEuQoLne5gY2bJaMbSwcdjO2YREdmKjvE/lbCqHA6bmjSOkdVqUZFnHUSnIWeRS66iMGXLXvwtoPvHMEq+SUbFsPZWYLk/YBYp/wSfqZP/XO939KxhGDp8cKXPMZvN6l0rzbOhQ+lgpecnPMymyMhaiqv7uzvIGRmmqCj3aM7atSNUkJ8np9NFcBPASWe1WlUyeMXdR/C8X3tGUTZuHKsWLc5Ut/MvkGEY2r0nQ79tOuDdGGf71oqVVVTk0p59GdqzL0O/rnS/r9WvF6kNv9nVs6e7T1BY5FJRodP9f5FLv23cpNQDe+QsvZayJzhY3NfwBFSdLt+goctpaOanuXLYY4vzdamwyFk8dd0o98uqilr2S+xxZldsNp2vxWLTd4vKjraWpKKibKUdWW86b7ujtt76v2y/5/LzDlZxdsU2Rcf8Ubx2t3zW8c7O+lM52btLgqtWT6DVHQj1BGIt3uBpSaDUapUWLM5Xvfq7SjZctFm8v+/ds1ZZWanFgbOS57QnyFryv1RYVKCI8PSSulktKnRtUf166e41zUutV261WrTp94PKzc0sCdpaSq4rfT9tNmvJl5vFMzFqJIBnuH9K97HLdreP3//OySlUWpqfKfUW6ejRXHfgtlRQs3TA3eIJXqtUWx7zOwAgOBCMPI3l5hbqwIEsHTiYrQMHsvT771u0ZvUWZWTmKSOzQLm55tc+qSy73aqY2uGKiXH/1K4doTpx4apTp5bq1o3UJRf30jnnnOP32vnz5/udYnVscNLlcsllSC6nUXLOMHRRr4sVn9CwJMBZaqTCt99alZ6efkxehlxOyWUUbwZjuNd9LH3eWbwW5LnndVVhYaFiY2O8m/NYizfGmT8/1duBtUglnU6LVRZvJ9e9hqPVWtLRslosCgsP01VXXeNds9K7bqXVooyMNH3zTZisFpV0kovz8unoWkrKtFhKNuWJj0/Q5ZcPLF4LzOldE6ywyKXt27dr6ZLFcjrdH7hkWOQyPB/OjFKb4ngCxq5SH+YMJTRoppYt/1Kcn9NnzbE//7Rq7+6CklEhpfMq9aHQc9vpcqmoyFBRUWVGFQQ397psLuVW4LOtxWLXitX+l11wf9hcI7vdqjCHTY4wW/H/Vp+Rmw6H+7zdYVOYw/3hJyzMqoQUl+Lq7lRUpEMREXbViij+v5ZDeXmFcrkMRjkAKJd7FKXFZxRlXGyE6tatJafTUHR0uJJa1dXAy9uoyOnSD4sTNX/BMvfU7n0ZOngop0JfOBqGoYOHsrVw8Q79tML/N0MZ6duqtNRLkZGlsLCaGX15uvKsOep0ljwH8vOKqjQSMCsnTSmpqX7PZaSnqiD/sOm81/9WW2FhcX7PHT28yXTA2mq1aNZsi6IioxQeblN4uL3kJ8yqbVu2lKzDXXojQocnqGkrtXSN+7bnXGSkVXl5RQoLq8agpyFvX9p7oJLS0nJ16HCOt19dMvpSys4pKB5J6jud3dPv97dGfEmA0+Lt47uP08cBgKqyGAwfC7h9+/bppZde0rBhw9SwYcNKX1/egsAul0t79+5VVFRUuWtkHDpcsoFNTk6hUg9muTeFOZStA6nZOnQ4V2lpLh1IzVLGMdOgKrI5yfEcu/h8aeHhhurVDVNCfJQS4qNVPz5SDeKjFB8fpfj6UaoVaZPDbi8OdrhHcJUetRVMi0Yfm3dqaqoSExPLtFmwLhp9qi4+HxERIcmu/Pwi5RV/KMnLK1JefpGOpmUoKytPBQXuY+7/ncovKFJebpH7/zxn8TWFysjIkSGbCvLdaYqK7CoslPLy3fkWFJQ8J8rb5KiibLYIWSz+X89FReYXca/pTY7cH4wcigi3Fa+xWbyxUPGmQhG17IoIdygiwqZatRyKjHAoPMKm6OhIxcXWVkQtT6DT7g10SkWyyKmICLt3MyKXy6UDBw6oQYMGIbX4vBS6G9jk5eUpOTm5Qm3mT3l/R/bt26dp06bp9ttvV6NG/tePDQY12Yc4kZrYeMIwDGVl5yg7K9e7WU5mZr42bzmkzX8c1O+/H9SWbYeKl9/w71TbBK/ieYfm+4NZx+tnulyFcrnM/w3nOeKr9HMkPNzm3izQE/AMs8pqLVRYuHu5mbAw9/t6WJitVFr3+3d4hE0RYXaF13K4NxYMtyk6OkJ168a5z4fbfYKd1b2Zpsvl0sFDhxRfv/4J/y5GRPjpQxRXPTs7W05nUelDZZZMKFm307ffbLG4+xAOh8NvuszMTLlcTt+8jinj2DoZhiFnkVM2u02xsbGyWcs+/yyWsn0If3368so49r2m9P3y9CEqsnGkP/QhgNMDIyNPkoiICMXGxppafP54bDab4uLi/P7x3Z+SqUkvr1ZqarZSDmT5rOdSEVarXVaruadEZKRDDRKi1aBBtBITotWgQZQSEqK9x2pHl7/LpcUi2exSdFSEHI7KT/P2t7FDoNSuXbtK1x9vJ8xAPzc8PM+RkyEsLExhYWGmg5HHExERURxQrGo+dpX9HJ5Y4etdLpdSUlL8BpBL0hjFAUzfwGdJANSpvLxC5ec7lZtbqPz8IuXkFionu1DZOQXKzilUTnaB+1hOqZ/cQuXmlqx5ZbefnN3+LBbrScvb83fE6ZRycqScHEPu9TkDO9La4bAWBzUdctilyMhwd8Az3K6wcFupD0YlH6DCwmzFH4bKngsP800TduzxcJscdnPLUJj9O+J5nR2vsx2sf0c8749mg2Khrib6EFXleX8INIvFotrRUaod7fte37ZtU/co+0KnsrPztG17mtZvTNFvv7mndqenVyygZrP5/4IiEMoLyh3/Got3xJpnSrCK10c05FmGRpLh8HPMvQqiZz1F93tJydI1FRl+UB3vDycn7/KDiVV1qj1HKipQ7ehda9v891PH5dkQ0PNlZa1adu/7u8+xUjMxyjsfEWGoyJmviAi7HHbfDZL89TNdLpfyCwoUG2vy72LxayoqsmqfRZxOeYOZx7LbK/8ccY81KpLdZldOdpEk/3lbrf6/lDhxAe6/L2lHj/d3Nly1a9cK+JJA9CGA0EEwMoQ4HDYt/8n8bsTHEx0d5g4sJkSpQYPiIGNxoLFBQrSioyv3AcRitSg8zOYd4eQObPGGguBgtVpUK8KhWhGB/+DjchnKy/MEL4sDlzkFysouUHa2+3dPMDOr+HZOTqGycwqVWxzQ9BxzBzfNT1s7lRUWulRYWKBM75cu/tcoCySbzVISxAwrPSXumEBmOUHQMgHQ4p+Icm67Ny1i8gLgj9VqKbWGrkXdzq+t7t1KApQ7d6Zp7fr9Wr8hRRs2HlBaWp57yqqt1LRVR/EmYw5ryYZjxdNUHY7iKasO9xcRDkfxRmR299IWDs/SFQ6rHA6797b7ek/6ktvevB224k3NSvKw26ze6bKeD+4V+WLMrJJgZUmQ0xNcqNix4uVvDN/bhuRdtsbpKlkSx3CVLF/jWXczP79AFou1eGMjz7IuxRseeZZ5cbqX03F5l29xnzdKLQtTct5dnuEqOeZeRkc+y+d4jvksAeM6ZiOh0psLeZeGKalT6SVonKU3HSq+X1ar7bjXll6GxpPH6TxPzRPsTE8PbL42m6VUsNJRMjsjwuENYIaH21RUVKDo6D2y263eZY88yyDZrNbitT5LlkNynyuVxub7uyfNia71rk/qOV7691L5MyUcQKgiGBlC6tWtpbAwm88U0oqKiQlXg4RoJSREqUFCtBKLg4ye21FRARjtYJHCHO4AZFiYzfvmykoBQAmr1aLISId7B9h6VR/V4AluZmXnKzMjV3n5LmXnFCo7q0DZnoBn8YhNz46fOTmFyst3T2HPK566nptXpPzikaC5eUWl1nQ6fTidhnJzi6o9wOsbvCwZ3Vn2tme6XHH6iOMHO/3mF2F+BChwKvAEGs8+O15nnx2vf1x7jncdutIbmJzOH/BLNvuomcfgZMyuOF6A1eUy/AdXDaPcwKrndmW4XC6lHkxVQnxCpQPInueovyCoZw1vd9CuqHjJGPfv3tt5Jbfz853eZWXK3i6dR9FxlzcIdk6n4e7fZBdKMr+RVE1zB0Ut3g2QqvKyNftyO3ZqeUV98uG1atCgarPMAIQugpEhxGKxKCEhSnv2ZJQ5Fxsb4R7VWGo0Y4MG0WoQ755OHRl58hZftzus7jXjwnzXhQFw8nmCm7Vq2VUnLjxgH/4KC53uwGSuO1Dp+d0drHRPN3cH7gq9Iz095/Lz3AG9krSeoKfnp/C02ZSoIrxT5HSCrdkDxGazeIOTY+7ppisua1Mt5QIni2ejN4SukxVg9QYnSwU0PRsjGioZeelO41R4mM39hbvV6h2pWXrUaHk8z9HqniXkchkqKCgd2Cwd1CwJZLrfrwtUWOBSvjd9OcHRvJI1u3Nzq7axEEpt6lMkScEVPGa8CYDjIRgZYi7u01LZ2YVq0CCqeO3GaCXERyniJEwnPR731AhHmY1oAIQG93REm2rXPjlraRUVubzBSt9AZ/GHnNxC5ea5p6IfOnhUjrBaKix0uXdULf6gVFDg/hBVUOD0Oe49n19yGyWcTsO7jmlBIY8NgNOXJ8hZkWC2y+VSdHSYYmMjyh0ZWXpUZslozLKjN8sEPz3XusyP3PTHarV4py8fj2EYKnK61yCs7Bea7oBnkfeLR8/7uXcGRqn3+pL3+UL/5485VnpHdQBAcCEYGWL+ce05AemcmGG1WpjmByAg7HaroqPDTrgebSDWVTMM98iQigQvved9jrtHkxQUFI8OKf6/vOOlR5yc6vhbDgCBU3oEZyD+unrX5TTKjuIsPWrTMyXdZahSIzYDwR3wdJyUgRGFhU7vCEzPzIoyQc28olLHfM/n5hYqJydPNpu91FT5UtPkS60PWrJ2acman56p9Kfj0jUAUFUEI1Elno1oPJstAECwsVhKpiWfrJGe/hiG4Q5aFpRd48uzI3tuToEKi4wyQcxj1wMrdx2x/OLAanHwtKioctPfK7s5GQCg+lgs7g1PqsonqFkqkOkZgel0ulRYZJHNZisZvWmUHblZ3QMivLM0os29d1dlnc/SPI+fO2jpWffTkMu7wdExv7tc5Qc4S22OVCYQWuGRoIacLqdsVptKli4w1zhVmWpduzZ9CADlIxh5kkRHR8tutwd0cxbDMLx5lpdvtXQEijei8Wx+UNWNaDzXheJGNhVps2BEmwWfUG2zYG8v9+Y0NtX2s767YRhyOp2y2WwB2+ShqMjlHdnpf0MD36DnWUn1A/64nqw2s9tDp0uTmJhYI32IYMTftuBDm52aSqaiW3TssE33+5H1hO9H5W0k5D53zHHJd1MhlXpOHPd4qVGdpY6bYRiG7LbAtFnJ2rQ1vzyVewd5dzCyJjfrCg8P7PuYRB8CCCW86k6STp06qU6dOioqCuyizXXq1JHL5ZLL5X90i7PIWfIGH2AOu827q6unw+J0Bm6aYSDzOpWcqM2CGW0WfEKxzUK5vaTAt1lYmEVhYQ7Vrl2xKXOBfh+TTk6b1alTJ2B51bRbbrlFUuAf+1B+rfC3LfjQZsGnsm1Wek8h35jYsQGywIzu9AQw3bfLOV78j/u4VbVqxZf57OQ3xnXMsdKBsGPT+/0sVub68vPzk7zM+fKCjBa5H2u7zVqci+E3bbkxynKO+9tR218epctyOp0yjMC/FuhDAKGBYORJsmbNGnXo0EHx8fEBy9Plcunw4cOqV69euVMJbHZbQEdGVsdGNCdj9M+poiJtFoxos+ATqm0Wqu0l0WaVdfDgwYDlVdOmT5+uq6++utr7EMGI10nwoc2CD20WXEK1vST6EEAoIRh5kmRlZamoqCigbwAWi8WbZ7nfhgWgvJraiOZ49ytYVaTNglko3i/aLLiEentJtFlFnYwRnDUlJSWlRvoQwSzU7leot5dEmwWjULtvod5moXi/6EMAoYNgJNwsUkTxBg5sRAMAAAAAAICTgWDk6aycjWgAAAAAAACAk4Fg5GnI7rB6R0GW7JwHAAAAAAAAnFwEI08TNpt7HciICPtJ24gGAAAAAAAAOB6CkSHMYrUoPNymiAh7tW5EAwAAAAAAAPhDMDLEWCzuACQb0QAAAAAAAOBUQzAyxNSrW4uNaAAAAAAAAHBKYvHAEEMgEgAAAAAAAKcqgpEAAAAAAAAAqkWVg5GZmZl64YUX1KtXL8XHxys8PFzx8fG66KKLNHHiRGVmZgaingAAAAAAAACCXJXWjPzll180ePBg7du3T5JkGIYk6fDhw1q6dKmWLl2qiRMn6pNPPtF5551X9doCAAAAAAAACFqmg5F//vmn+vfvr4yMDNlsNnXs2FHNmzdXZGSkcnJytHPnTq1bt0579uzRpZdeqrVr16pZs2aBrDsAAAAAAACAIGI6GDlu3DhlZGTonnvu0X//+1/Vq1evTJrDhw9r/PjxevnllzV+/HhNnz69SpUFAAAAAAAAELxMByPnzZun2267TZMmTSo3Tb169TR58mTl5OTo66+/NlsUAAAAAAAAgBBgegObw4cP64YbbqhQ2htvvFGHDx82WxQAAAAAAACAEGA6GFm3bl3VqlWrQmkjIyMVHx9vtigAAAAAAAAAIcB0MLJHjx5asmRJhdIuWbJEvXv39jl28OBBjR8/3mzxAAAAAAAAAIKM6WDkQw89pKefflq//PLLcdP9/PPPevnllzVu3Dif46mpqWWOAQAAAAAAAAhdpjew2bhxo/r06aMePXrokksuUY8ePZSYmCi73a6ioiIdOHBAS5cu1YIFCzRmzBgtXbpUS5cu9V6/Z8+egNwBAAAAAAAAAMHBdDBy+PDhslgsMgxD8+bN07x58/ymMwxDzz33nOkKAgAAAAAAAAgNpoORktSwYUM5HA5T1xYWFmr//v1VKR4AAAAAAABAEDEdjLRYLPruu+/Utm1bU9dv3LhRHTt2NFs8AAAAAAAAgCBjegMbwzCqVLBnijcAAAAAAACA04PpkZEul6tKBbdr167KeQAAAAAAAAAIHqZHRgIAAAAAAABAZVQ5GLlz506NHj1aHTp0UFxcnH7//XdJ0tdff63HHntMqampVa4kAAAAAAAAgOBXpWDkF198oQ4dOujll1/Wb7/9pszMTO86kCkpKXryySd19tln67vvvgtIZQEAAAAAAAAEL9PByB07duiGG25Qdna2kpKSNHDgQFksFu/5YcOGafbs2UpMTNTVV1+tHTt2BKTCAAAAAAAAAIKT6WDkpEmTVFRUpE8//VSbN2/W7NmzfYKRNptNAwcO1C+//KIzzjhDL7zwQkAqDAAAAAAAACA4mQ5Gzp8/X//+97911VVXHTdddHS0HnjgAX3//fdmiwIAAAAAAAAQAkwHI3fv3q3evXtXKG379u21e/dus0UBAAAAAAAACAGmg5Eul0thYWEVSpuZmSm73W62KAAAAAAAAAAhwHQwsmnTplqyZEmF0n700Uc688wzzRYFAAAAAAAAIASYDkYOGDBAEyZM0IIFC8pNYxiGXnzxRU2fPl1XXHGF2aIAAAAAAAAAhADTc6fvv/9+TZ8+Xf369VPfvn3Vq1cvGYahzz77TPPnz9fmzZv1zTffaNeuXapTp47GjBkTyHoDAAAAAAAACDKmg5ENGzbUZ599pquuukrz58/3jpB8/PHHvWkMw1BMTIw+++wzxcfHV722AAAAAAAAAIKW6WnaktS3b1+tWbNG1157rSIiImQYhvcnIiJC//jHP7Rq1SpdeOGFgaovAAAAAAAAgCBV5S2uW7ZsqQ8//FCFhYXasmWL0tPTFRsbq6SkpArvtg0AAAAAAAAg9FU5GOnhcDjUrl07n2NHjx5VZmammjZtGqhiAAAAAAAAAAQp09O0b775Zu3fv/+4ab777js1b95cXbt21a5du8wWBQAAAAAAACAEmA5GvvPOOzp69Ohx05x77rkaP368UlJS9NBDD5ktCgAAAAAAAEAIMD1N2zCME6Y588wz9eijj6pTp0664447zBYFAAAAAAAAIARUaTftioqJidHBgweroygAAAAAAAAAp6gKj4x89913yxybPXu2Vq5cWe41hmHoyJEjeuedd9SoUSNzNQQAAAAAAAAQEiocjBw+fLgsFovPsUcffbRC1xqGwZqRAAAAAAAAwGmuwsHIpk2b+gQjd+3apYYNG8rhcJSfud2uxMREDRo0SGPGjKlaTQEAAAAAAAAEtQoHI3fu3Olz22q16rvvvlPbtm0DXScAAAAAAAAAIcj0btrNmjVTWFhYIOtiSkZGhl577TUtW7ZMo0aNUt++fSt1/QcffKCZM2eWe/7pp58m4AoAAAAAAAAEgOlgZHJyciDrYcry5cv12muvqaioqEr51K5dWzExMX7PhYeHVylvAAAAAAAAAG6mg5En4nK5dOTIEdWvX/+k5P/111/r448/1j333KNly5Zp4cKFpvO6/PLLdd111wWwdgAAAAAAAACOZTV7YV5enp544gmNHz++zDTnRx55RFFRUWrQoIFatWpVpUBheZo3b65XXnlFXbt2DXjeAAAAAAAAAALP9MjIOXPm6PHHH5ck/f3vf9fQoUMlSS+99JL+97//edPt2LFDAwcO1Pr169WyZcsqVrcE6zgCAAAAAAAAwcX0yMi5c+eqbt26WrJkiXdkpMvl0jPPPCOLxaLBgwdr7dq1+vDDDxUeHq6JEycGrNKBlpycrPHjx+umm27S1Vdfrdtuu02vv/66Dh8+XNNVAwAAAAAAAEKG6ZGRv/zyi/7zn/+oR48e3mM//PCD9u/fr/j4eL377ruKiIjQOeeco507d+rtt98ORH1Pik2bNunmm2/WvffeK7vdrtWrV+u1117Tjz/+qAkTJqhp06Y1XUUAAAAAAAAg6JkeGblr1y5169bN59jcuXMlSddff70iIiK8x7t3765du3aZLeqk6tWrl1544QX17dtX0dHRioiIUPfu3TVy5EhlZGToxRdfrOkqAgAAAAAAACHB9MhIh8Mhm83mc+zLL7+UxWLRNddc43O8Vq1aKioqMlvUSdW4cWO/x8877zzFxcVpx44d2rlzp5o3b+433f79+7V//36fYwcPHlR2drYk99T1QPHkFcg8TwWGYcjlcsnlcslisdR0dQKKNgs+tFlwCdX2kmiz05nD4ZBEH6IieJ0EH9os+NBmwSVU20sK3TYDTkemg5FNmzbV+vXrdd5550mSfv75Z23dulUNGzbUBRdc4JN2586dqlOnTtVqWs0sFosaNGigtLQ07dmzp9xg5NSpUzVu3Lgyxz0b+qSkpAS8bqmpqQHPEycXbRZ8aLPgQnsFH9qsfCNGjJBEHwK0VzCizYIPbRZ8aDMg+JkORl544YV64okn1LJlS0VFRemOO+6QxWLRDTfc4JPOMAxNmzZNbdq0qXJlq5thGCdMc8cdd2jQoEE+xw4ePKj58+dLkhITEwNWH5fLpdTUVCUkJMhqNT3D/pRjGIaKiopkt9tD8ts72iy40GbBJVTbS6LNKutkBO5qyltvvaURI0bQh6gAXifBhzYLPrRZcAnV9pLoQwChxHQw8r777tOMGTN0ySWXSHL/0YuJidG//vUvb5qpU6fqww8/1NKlS/XYY49VvbYBdvDgQd13332aMmWKoqOjfc4ZhqEDBw5IKn8qtyQ1bNhQDRs29Dm2b98+/fTTT5J0Ut7YrFZryL1heu5TqL1hetBmwYc2Cy6h1l4SbXY6KywslEQfoiJ4nQQf2iz40GbBJdTbSwq9NgNOR6ZfwS1atNDcuXPVsWNHhYWFqUOHDvriiy/UpEkTb5qxY8dqyZIlMgxD1113XUAqbEZOTo7Gjx+viRMnyul0eo+7XC6lpaVp7dq1Za5Zvny50tPT1bx583KnaAMAAAAAAACoONMjIyWpT58+Wr16dbnnj93YpaasWbNGK1eulCRdccUVSkpKkiTvN0VTp06V0+lUp06dFBYWptWrV+u1115TdHS0xowZE7LfKAEAAAAAAADVqUrByJp04MAB3XbbbT7HJk+erMmTJyshIUFvvvmm93ibNm2UmJio2rVrq2nTpt7jCQkJeuGFF7R48WJ9/PHHevnll+VyuVS/fn316NFD11xzjeLj46vtPgEAAAAAAAChLCDBSJfLpTVr1mjXrl3q27evYmJilJOTo8jIyEBk71eDBg00Z86cCqWtV6+epk2b5vdcUlKSd6QkAAAAAAAAgJOnyqu+Pvvss2rQoIHOPfdcDR48WHv27JEkffjhh2rWrFm5QUAAAAAAAAAAp5cqBSNvuukm/ec//9Hhw4dlGIbPuRYtWigvL0933XVXmenUAAAAAAAAAE4/poORc+bM0XvvvaeGDRvqqaee0qxZs2S1lmTXu3dv7du3T4888ohmzJih2bNnB6TCAAAAAAAAAIKT6TUjZ8yYoVatWmn16tWKjo72m8Zms2n8+PHaunWrpk2bpiuvvNJ0RQEAAAAAAAAEN9MjI3/99Vc9/PDD5QYiS7vhhhu0cuVKs0UBAAAAAAAACAGmg5GHDx9W27ZtK5S2YcOGOnr0qNmiAAAAAAAAAIQA08HIqKgopaSkVCjtli1bFBsba7YoAAAAAAAAACHAdDDynHPO0VtvvXXCdPn5+Xr++efVqVMns0UBAAAAAAAACAGmg5HXX3+9Zs+erZtuukn79u3zHrdYLJIkwzC0cOFC9erVS2vWrNFNN91U9doCAAAAAAAACFqmd9MeMWKE3nnnHb333nt6//331aJFC7lcLt10001yOp3atm2bsrOzZRiGevfureuvvz6Q9QYAAAAAAAAQZEyPjLTZbPryyy/Vv39/GYah7du3yzAMrV69WmvXrlVWVpYMw9Bll12mzz77zDtiEgAAAAAAAMDpyfTISEmKi4vTN998o++++04ff/yx1q1bp/T0dMXGxqpjx4669tprdckllwSqrgAAAAAAAACCWJWCkR79+vVTv379ApEVAAAAAAAAgBBlepp2ZeTk5GjJkiXVURQAAAAAAACAU1S1BCOTk5PVu3fv6igKAAAAAAAAwCkqINO0d+3apf379ys/P9/v+R07dgSiGAAAAAAAAABBrErByBkzZuiJJ57Qrl27AlUfAAAAAAAAACHKdDDy7bff1m233SbDMCqU3mKxmC0KAAAAAAAAQAgwvWbkxIkTFR0drenTp2v37t0qLCyUy+Xy+7N+/fpA1hkAAAAAAABAEDI9MnLLli2aNGmSRowYccK0FoulwiMoAQAAAAAAAIQm0yMj69atqy5dulQobbt27eRyucwWBQAAAAAAACAEmA5GXn755dq+fXuF0ubk5GjJkiVmiwIAAAAAAAAQAkwHI5944glNnz69QjtpJycnq3fv3maLAgAAAAAAABACTK8Z2aBBA7333nu65557ZLFY1LlzZ9WrV09Wa9n45p49e6pUSQAAAAAAAADBz3QwUpJeffVVzZ49W/n5+froo48CVScAAAAAAAAAIch0MHLatGkaP368JCkiIkL16tWT3e4/u8LCQu3fv99sUQAAAAAAAABCgOlg5JQpU9S4cWN98MEH6tGjhywWS7lpN27cqI4dO5otCgAAAAAAAEAIMB2M3LZtm95880317NnzhGnDw8PVtGlTs0UBAAAAAAAACAGmd9OOjY1V69atK5Q2KSlJycnJZosCAAAAAAAAEAJMByMHDhyotWvXVijtwYMHvetLAgAAAAAAADg9mQ5GPvnkk5o6dap+/fXXE6ZNTU3VuHHjzBYFAAAAAAAAIARUaQObc889Vz169FDnzp3VuXNn1atXT1Zr2fhmampqlSoJAAAAAAAAIPiZDkaOHTtWFotFhmHo559/1i+//FJuWsMwjrvbNgAAAAAAAIDQZzoYKUmdO3dWVFTUCdNlZ2dr1apVVSkKAAAAAAAAQJCrUjDy7bffVtu2bU+YbuPGjerYsWNVigIAAAAAAAAQ5ExvYNOsWTOFhYVVKG10dLQuvPBCs0UBAAAAAAAACAGmR0YmJydXOG3z5s21aNEis0UBAAAAAAAACAGmR0ZWxr59+3TzzTdXR1EAAAAAAAAATlHVEow8evSo3nnnneooCgAAAAAAAMApqkLTtA8dOqSlS5eqf//+ioyMlCSNHz++woWkpqaaqx0AAAAAAACAkFGhYOSFF16oP/74Q1dddZVmzZolSRo7dqwsFkuFCjEMo8JpAQAAAAAAAISmCgUjDcPw/pTWuXNnRUVFnfD67OxsrVq1ylwNAQAAAAAAAISECgUjlyxZ4p2mXdrbb7+ttm3bnvD6jRs3qmPHjuZqCAAAAAAAACAkVCgYGR8fr6uvvtrnWLNmzRQWFlahQsLDw9W0adPK1w4AAAAAAABAyKhQMNKf5OTkCqdNSkqqVHoAAAAAAAAAocdq9sJ3331XGRkZx00za9YstWjRQv/+97+Vl5dntigAAAAAAAAAIcB0MHLEiBHas2fPcdOcccYZatGihSZPnqyxY8eaLQoAAAAAAABACDAdjDx2Z21/zjvvPM2fP1+vvvqqZs2aZbYoAAAAAAAAACHAdDCyMjp16nTCUZQAAAAAAAAAQluFN7DZtWuX93fPqMj9+/crOjq63GsMw9CRI0c0ceJExcTEVKGaAAAAAAAAAIJdhYORZ555Zplj/fr1q3BB1157bYXTAgAAAAAAAAg9FQ5G+lsjsiLrRtpsNvXr10+TJk2qVMWCXXR0tOx2e4Ueo4oyDMObZyDzrWme+xJK98mDNgs+tFlwCdX2kmizyrLbK9ylOeUlJibSh6ggXifBhzYLPrRZcAnV9pLoQwChpMKvuuTkZO/vhmGoZcuWmjdvnpKSksrP3G5X/fr1FR4eXrVaBqFOnTqpTp06KioqCmi+derUkcvlksvlCmi+pwKn01nTVTgpaLPgQ5sFl1BuL4k2q0yeoeKWW26RJPoQlcDrJPjQZsGHNgsuodheEn0IIFRUOBjZrFkzn9uGYahRo0ZljsNtzZo16tChg+Lj4wOWp8vl0uHDh1WvXj1ZrdWy91C1MAxDTqdTNptNFoulpqsTULRZ8KHNgkuotpdEm1XWwYMHA5ZXTZs+fbquvvpq+hAVwOsk+NBmwYc2Cy6h2l4SfQgglJgej5ycnKzGjRsHsi4hJSsrS0VFRQF9A7BYLN48Q+2NRVJI3i/aLPjQZsEl1NtLos0qKtCjCGtSSkoKfYhKCrX7FertJdFmwSjU7luot1ko3i/6EEDoMB2MZEQkAAAAAAAAgMoInfHoAAAAAAAAAE5pBCMBAAAAAAAAVAuCkQAAAAAAAACqBcFIAAAAAAAAANWCYCQAAAAAAACAakEwEgAAAAAAAEC1sJu9cNeuXd7fmzRpIquVuCYAAAAAAACA8pkORjZv3lwWi0WSlJycrKZNmwasUgAAAAAAAABCT5WGM7Zq1UrvvfeeEhMTA1UfAAAAAAAAACHK9MhIh8OhSZMmacCAAYGsDwAAAAAAAIAQZXpkZMOGDZWQkBDIugAAAAAAAAAIYaaDkf3799fSpUsrlPa3336TzWYzWxQAAAAAAACAEGA6GPnYY4/p1Vdf1cqVKyuU3jAMs0UBAAAAAAAACAGm14xcsGCBrr32WvXs2VP9+vXTBRdcoPj4eL8jIPfs2ePdeRsAAAAAAADA6cl0MHL48OGyWCwyDENfffWVvvrqq0DWCwAAAAAAAECIMR2MlNyb2DgcjhOmKyws1P79+6tSFAAAAAAAAIAgZzoYabFY9N1336lt27YnTLtx40Z17NjRbFEAAAAAAAAAQoDpDWwqsyFNeHi4mjZtarYoAAAAAAAAACHA9MhIl8tV4bRJSUlKTk42WxQAAAAAAACAEGB6ZCQAAAAAAAAAVEaVg5GZmZmaNGmSBg4cqI4dO2rbtm2SpKVLl2rGjBkqKCiociUBAAAAAAAABL8qBSN/+ukntW7dWvfdd5/mzp2rjRs3eoOPW7Zs0a233qqzzz5ba9euDURdAQAAAAAAAAQx08HIAwcOaNCgQTpw4IAiIyPVoUMHn/ODBw/W5MmTlZubq/79+ys1NbXKlQUAAAAAAAAQvEwHIydPnqwjR47ohRde0JEjR7Ru3TpZrSXZxcbG6l//+pdWrlwph8OhF154ISAVBgAAAAAAABCcTAcjv/nmG/3zn//UmDFj5HA4yk3XqFEjPfTQQ5o7d67ZogAAAAAAAACEANPByB07dujyyy+vUNouXbooOTnZbFEAAAAAAAAAQoDpYGRBQYFiY2MrlLaoqMhsMQAAAAAAAABChOlgZKNGjfTrr79WKO2XX36pM844w2xRAAAAAAAAAEKA6WBk3759NW7cOG3evPm46T777DO99NJL6tevn9miAAAAAAAAAIQAu9kL77//fr377rv6y1/+optuukm9evWSYRhasWKFtm3bps2bN+urr77SsmXLFBERoXvvvTeQ9QYAAAAAAAAQZEwHI5OSkjR9+nSNGDFC06dP1/Tp0yVJt9xyizeNYRiy2+16++231bx58ypXFgAAAAAAAEDwMj1NW5Kuv/56LVq0SOeee64Mwyjz061bN/3www8aMmRIoOoLAAAAAAAAIEiZHhnpccEFF+inn37Snj17tG7dOqWnpys2NlYdO3ZUkyZNAlFHAAAAAAAAACGgysFIjyZNmhB8BAAAAAAAAFCuKk3TPlZ2drb279+v7OzsQGYLAAAAAAAAIARUORi5a9cu/etf/1KzZs0UExOjJk2aKCYmRs2bN9eoUaO0a9euQNQTAAAAAAAAQJCrUjByzpw56tChg6ZMmaLdu3f7bF6za9cuvfLKK+rQoYPmzJkTqPoCAAAAAAAACFKm14xcv369hgwZosLCQtWvX18XXnihmjdvrsjISOXk5Gjnzp364YcfdPjwYf3973/Xr7/+qg4dOgSy7gAAAAAAAACCiOlg5JNPPimXy6WJEydq5MiRstvLZlVUVKSXX35ZDz74oJ588kl99NFHVaosAAAAAAAAgOBlepr2Dz/8oPvuu0+jRo3yG4iUJLvdrjFjxmjMmDFavHix2aIAAAAAAAAAvywWi8/P22+/XdNVCrjFixeXuZ87d+6s6WqZYjoYmZ6err/97W8VSnvVVVcpIyPDbFEAAAAAAACAXxs2bNCGDRvUqFGjmq7KSdO1a1dt2LBB8+bNq+mqVJnpadoNGjSoVPqGDRuaLQoAAAAAAADwq3379pIkh8NRwzU5eaKiotS+fXtFR0fXdFWqzPTIyD59+uibb76pUNpvvvlGl156qc+xffv26eabbzZbPAAAAAAAAIAgYzoY+eijj+q1117TrFmzjpvu448/1syZMzV+/Hif40ePHtU777xjtngAAAAAAAAAQcZ0MPL9999Xt27ddO2116pt27a6/fbb9dhjj2n8+PF67LHHdMcdd6ht27a6/vrr1bdvX02ZMkXjx4/3/rz22muBvB8AAAAAAABBYefOnWU2I1m8eLF+++03XX/99WrUqJHsdrv3XGmGYeiTTz7RgAEDFB8fr7CwMCUkJKh///5699135XQ6fdI3b968TFnH5pmdna3IyEg1bNhQLpfruNc3b97cey49PV3Tp0/X4MGD1aJFC0VERCgyMlKtW7fWXXfdpW3btvm9/8fmOXbsWB09elT33nuvkpKSFBER4fO4lL7v06dP13nnnafo6GjFxsbqvPPO0xtvvCHDMEy0hO/j+uWXX2rAgAE688wzFR4erjp16qhbt2566KGHtGLFinKv/eKLLzRw4EAlJibK4XAoLi5OnTt31qhRo/TDDz+USb9z5049/fTTuuSSS9SwYUM5HA7FxMSoc+fOGj9+fJX3Xansc6S6mV4zcuzYsbJYLDIMQ5s3b9Yff/xRJo3niTB16lS/54598te0jIwMvfbaa1q2bJlGjRqlvn371nSVAAAAAABAiGncuLE2bNggSerQoYMkadmyZXr77bf1wAMPaMyYMUpOTtbdd9+t1NRU73X5+fm6/vrr9emnn6p79+569dVX1axZM23fvl0vvviihg0bpnfffVdz5sxRZGSkJOm7777TggUL9M9//lM2m03Lli1TVFSUT32++uor5ebmKjc3Vz/++KMuvPBC77nvvvtOe/bsUd++ffXaa6+pT58+3nMTJ07UuHHjdOaZZ+o///mPzjnnHGVmZmrx4sWaNGmS/u///k9ffvmlevfu7VPed999p4KCAo0YMUIrV67UoUOH1KNHDw0ZMkT/93//p5ycHD388MP65ZdfvNe4XC5dd911+uijj9S8eXO9+uqrat++vVJSUvTyyy/r119/rVKb3HHHHXrjjTc0YMAATZ48WY0bN1Zqaqo++OADPfPMM3rmmWe0c+dONWvWzKc9brjhBs2aNUtdu3bVyy+/rBYtWmj//v368MMP9dJLL+mll17SK6+8opEjR3qvGz58uH744Qf16tVLr776qpo2bar9+/fro48+0tixY/Xuu+/qxx9/VGJiYqXvh5nnSHUzHYyUpM6dO5d5AldUdna2Vq1aVZXiA2r58uV67bXXVFRUVNNVAQAAAAAAIczhcHg3XfF4/vnntWbNGu/Iwy5dumjr1q165JFHvGlGjx6tTz/9VD179tSiRYtks9kkSeedd57+/ve/q2vXrlqwYIHuvfdevf7665Kk1q1b64wzztD999+v7Oxs7dq1S0OGDPEp+5NPPvH+PmvWLJ9gZOvWrbVw4UJFR0dr+PDhioiI8Lk2MjJSS5YsUZMmTbzHLr74YvXs2VOXXnqpbrjhBm3fvt3nutatW0uSN6b0+uuva+bMmRo8eLA3zYsvvqgLLrjAe/uFF17QRx99pNjYWC1dutSnvAEDBmjAgAHavXt3uY/58axfv15vvPGGmjZtqi+//NL7uHryDgsL04wZM8qMvhw1apRmzZqlTp06acmSJT738YorrlBCQoImTZqkwsLCMmV27txZ33//vc+mOwMHDlTTpk31v//9TyNHjtSnn35a6fti5jlS3UxP05akt99+W4sWLTL1M2PGjEDdhyr7+uuvNW3aNN1zzz0677zzaro6AAAAAADgNHP99df7TIGWpHvuuUfJycmSpM2bN3tnnj711FM+ATNJstvtuv/++yVJM2bM0IEDB7znatWqpcsuu0ySyuz9kZOTo2+++cYb+Pvss8/KBN0++eQTXXHFFWUCkRdddJGmTJniExj06N+/v5o3b659+/Zp4cKFx73vbdq08QlEStK5556r5ORknX/++crLy9PTTz8tSbrlllvKlGe1WvX444+XmWJeUZs2bZIkRURElHlcJenWW2/V5Zdf7jOS8Pfff9e0adMkSf/973/LPDaSvO1xrOHDh+uFF17wu/v3HXfcIUmaPXt2padrV+U5Up1MByObNWumsLAw0wWHh4eradOmpq8PpObNm+uVV15R165da7oqAAAAAADgNNSjR48yx6Kjo70Byk8++USGYSgiIkLnn3++3zzatGkjSSosLNSSJUt8zl1zzTWS3AOy8vLyvMfnzp0ri8XiDazt3btXP/30k/f8wYMH9cMPP5QJFkruYOSwYcPKvU+eKc2///57uWkk//fdbrerefPmioiI0I8//qgjR45Iks808dLOPfdc03Eqz0jNLVu2aOTIkT5T4yWpW7du+uqrr5SQkOA95mkPSeUu89eoUSMtXLhQV111lc/x4cOHq1evXn6v8TxmTqdTW7durdT9qOpzpLqYDkYmJyerVatWpgtOSkryRvdrWtu2bRUdHV3T1QAAAAAAAKep+Pj4455ft26dJCkvL0+1atWS3W4v83Puued60+/atcvn+ssvv1wRERHKysrSvHnzvMdnzZqlAQMGqG3bturcubP3mMfnn3+uiIgIDRgwwG+9li5dqhtvvFFJSUmqXbu2HA6Htz6ezVuysrKqdN89IxcllRk96mG321W/fv3j5lOev/71r941HadMmaLGjRvr4osv1sSJE8vdhGf9+vWSpPr16ysmJqbcvHv37u2zzqTkXv/yvffe0+WXX64mTZqUaU+PEz1ux6rqc6S6VGnNSAAAAAAAAFSdv+nBpaWnp0uSGjRooPnz558wvwYNGvjcjo6OVr9+/TRnzhx9+umnuvLKK5Wbm6u5c+dq+vTpkqTBgwdr1apV+vTTT/Xiiy9KKglW+tvsZOzYsRo3bpwiIiJ0zz33qG/fvmrYsKF3w2LPBjUn2un6RPe99HTlWrVqlZvO37TninrllVc0cOBAvfbaa/rmm2+0YMEC79qKPXr00Isvvugzo9bTHserjz+FhYW6/PLL9f3336tRo0Z64IEH1KlTJ9WtW9ebxrOpUWV3CK/qc6S6EIwEAAAAAAA4xcXGxkpyj3o7dvObirrmmms0Z84cffnllyosLNQ333wjp9Opyy+/3Hv+P//5j3bt2qVffvlFrVq10qJFi/Tee++VyWvt2rUaP368JGny5Mm6/fbby6Qxu+nxsUqPPMzJySk3nb+NYiqjf//+6t+/v9LT0/Xll1/q448/1tdff60ff/xRPXv21IoVK3TOOedIKmmP3NzcSpUxZcoUff/997Lb7fruu+/Url27KtW5tEA8R6pDlTawAQAAAAAAwMnXsWNHSe7RbykpKeWmW7Fihd58803t37+/zLlBgwbJ4XAoLS1NCxYs0CeffKL+/ft7l65LSkryBttmzZqlL774Qg6HQ1dccUWZvBYuXOgduXfsmoiB1rZtW+/vO3fu9JumqKhIhw4dCkh5sbGxuuGGGzRnzhytW7dO8fHxys/P1+TJk71pPO1x6NCh4240k52d7RNAXbBggST3OpWBDESWrlNVniPVgZGRVbR///4yjXfw4EFlZ2dLkumdnPzx5BXIPE8FhmHI5XLJ5XJ5h3KHCtos+NBmwSVU20uizU5nnulF9CFOjNdJ8KHNgg9tFlxCtb2k0G2zyhgyZIjGjh0rl8ulr776SrfeeqvfdHfddZd+//13/f3vfy9zLi4uTn379tW3336r999/X3PnztWUKVN80gwePFjr16/Xp59+qtatW+vSSy/1O8KxdFuUN524vMBhZfXo0UN169bVkSNHtHDhQr/B0RUrVqigoMBU/h999JFGjRqlTZs2+UyXlqR27drp+uuv16RJk3ziP6XbY/78+br66qvL5Lt161a1bt1a119/vXd0qedxOxmPWSCeI9WBYGQVTZ06VePGjStzfOjQoZJ03Ei0Wcfu6oRTH20WfGiz4EJ7BR/arHwjRoyQRB8CtFcwos2CD20WfE7nNmvTpo3uvPNOTZkyRU899ZSuuuoq1atXzyfNjBkztHr1aj3wwAPlbqpyzTXXeIORDodDAwcOLHP+scceU3Jysnbu3Ol3irYk9ezZ0/v7e++9p3vvvdfn/Ny5c/Xnn3+auatlRERE6KGHHtIDDzygGTNm6N5771WTJk28510ul9/YTEXl5ubqwIED+uyzz/wG8DZv3ixJPpu/lG6PJ598UpdddpkiIiJ8rhs7dqwsFot3cxzJ/bjNnTtXf/zxh3799VefdSgl6dVXXzV9PwL1HDnZCEZW0R133KFBgwb5HDt48KB3odDExMSAleVyuZSamqqEhARZraEzw94wDBUVFclut4fkt3e0WXChzYJLqLaXRJtV1skI3NWUt956SyNGjKAPUQG8ToIPbRZ8aLPgEqrtJYVmH2Ljxo0+t5OTk1W/fn2FhYWpdevWfq+ZOHGiDh8+rI8++kjnnXeeHn74YXXs2FGHDh3S7NmzNW3aNPXv39+7lqM/f/vb33TnnXfK6XTq4osv9q4z6NG2bVudffbZ+v333xUWFlYmWOlx3nnn6ZZbbtH06dP10EMPae/evbr88svlcDi0aNEiPfvss4qOjlZWVpZSU1O1ceNGJSQkKCEhQcnJycrOzvbOKvWcl6SzzjrL70Y09913n1auXKmPP/5YPXv21Lhx49S+fXulpKTo5ZdfVmFhoRo1aqR9+/Zp79692rhxo+Lj4yu0SYvn9XLPPfdoy5YtuuSSS1SvXj2lpKTovffe07fffqtOnTrpvvvuK9Mehw4d0scff6xevXrp/vvvV4sWLbRnzx698cYb+uqrr/TCCy+oW7du3mvuvvtuffjhh1q3bp0uu+wyPfzwwzr//POVkZGhmTNn6vPPP/em9TwnzjzzTO/tffv2ec9v2bJFWVlZOvPMM72jVwPxHDnpDPiYOHGiMXDgQGP+/Pmm89i7d6/x+OOPG3v37g1gzQzD6XQae/fuNZxOZ0DzrWkul8soKCgwXC5XTVcl4Giz4EObBZdQbS/DoM0q62S991Y3+hCVw+sk+NBmwYc2Cy6h2l6GEZp9CEl+f5o1a3bCa2fPnm1cccUVRkJCgmG32424uDijV69exvTp0yv0GPXu3duQZMyYMcPv+f/+97+GJGPgwIHHzcflchnTp083unXrZkRHRxsOh8No1KiRMWTIEGPZsmVGr169fO7b448/bhiGUeZ46Z/k5ORyy3M6ncYbb7xhdOnSxYiMjDSioqKMDh06GE8++aSRl5dnNGvWzCevBx988ISPhWEYRlFRkfHVV18Zt9xyi9GuXTsjOjrasNlsRlxcnNG9e3fjxRdfNHJzc8u9/vPPPzcuv/xyb3vUrVvXGDBggPH111/7TZ+ZmWn897//Nc4++2wjPDzcCA8PN5KSkoyRI0caO3fuLPOYLFq0yFi0aFG5j9miRYvKlFHV58jJdFJHRhYUFMhut4fUN00AAAAAAABVZZSzZmBFDBo0qMwszcpYuHDhcc+PHz++QiPnLBaLbr75Zt18881+zy9evLhSx0/EarXq1ltvLXctRLPrLdpsNl1++eXeXcUr629/+5v+9re/VTh9dHT0cR/j8p4blXnOVPU5cjKZjhKOHz/+hLsUff7556pVq5YGDx6sI0eOmC0KAAAAAAAAQAgwHYwcN27cCReObdeunW688UZ9//33evjhh80WddIdOHDAGzH2fDswefJkDRo0qNxoOwAAAAAAAIDKMT1NuyJDQ9u3b68333xTl1xyiR588EGzRZ10DRo00Jw5c2q6GgAAAAAAAEBIq5bFHJs1axZSu1wCAAAAAAAAqLwKj4xcsmRJmWMrV6487rqRhmHoyJEjevXVV1WvXj1zNQQAAAAAAAAQEiocjLzoootksVh8jo0YMaLCBd1+++0VrxUAAAAAAACAkFOpNSOPXSfyROtG2mw2JSYmatCgQXrmmWcqXzsAAAAAAAAAIaPCwUiXy+Vz22azacOGDWrbtm3AKwUAAAAAAAAg9JzU3bQBAAAAAADga9WqVTVdBR+dO3eu6SrgNGI6GHnsSEkAAAAAAAAAOB7TwUgAAAAAAACY17p165qugrZs2VLTVcBpxlrVDHbu3KnRo0erQ4cOiouL0++//y5J+vrrr/XYY48pNTW1ypUEAAAAAAAAEPyqFIz84osv1KFDB7388sv67bfflJmZ6V1LMiUlRU8++aTOPvtsfffddwGpLAAAAAAAAIDgZToYuWPHDt1www3Kzs5WUlKSBg4cKIvF4j0/bNgwzZ49W4mJibr66qu1Y8eOgFQYAAAAAAAAQHAyHYycNGmSioqK9Omnn2rz5s2aPXu2TzDSZrNp4MCB+uWXX3TGGWfohRdeCEiFAQAAAAAAAAQn08HI+fPn69///reuuuqq46aLjo7WAw88oO+//95sUQAAAAAAAABCgOlg5O7du9W7d+8KpW3fvr12795ttigAAAAAAADUgIyMDI0ZM0ZNmzZVRESEWrdurSeffFKFhYWVyqegoEDjxo1TUlKSIiIi1KxZM/373/9WVlZWudfs379fN998sxITE1WrVi2dc845mjJline/kvIsXrxYLVq08JnBi1OH3eyFLpdLYWFhFUqbmZkpu910UQAAAAAAACEjLa1AknToUE4N16SkLv5kZGToggsu0NGjRzVz5kx17txZ3377rW666SYtX75cX375pWw22wnLKCws1GWXXaZff/1V7733ni6++GKtWLFCQ4cO1cKFC7V06VJFRUX5XLNnzx6dd955qlOnjubNm6dWrVrp/fff18iRI7V27VpNmzatTDnZ2dl66KGH9MEHH+jIkSOVfzBQLUyPjGzatKmWLFlSobQfffSRzjzzTLNFAQAAAAAAoJo98sgj2rhxo6ZNm6YePXqoVq1auuqqqzR27Fh98803mjp1aoXyeemll7RgwQL973//08CBA1WrVi316tVLr7zyitasWaNx48aVueauu+7S/v37NXPmTHXs2FFRUVG6/fbbdeedd+qNN97Q119/XeaaPn36aPv27Vq/fn2V7ztOHtPByAEDBmjChAlasGBBuWkMw9CLL76o6dOn64orrjBbFAAAAAAAAKpRZmam3nzzTTVs2FADBgzwOTd8+HBZLBZNnDjxhPkYhqFJkybJ4XDoxhtv9Dl35ZVXqm7dunrttdeUl5fnPb5161Z99dVXOvfcc9W+fXufa26++WZJ8lv2o48+qq+//lqNGzeu8P1E9TMdjLz//vtlt9vVr18/9evXT0899ZQMw9Bnn32ml156Sf/85z/VokUL3X///YqLi9OYMWMCWW8AAAAAAACcJAsXLlReXp7OO++8Mmsv1qtXT61bt9a2bdu0ZcuW4+azfv167dmzR+3atVPt2rV9ztntdnXt2lVZWVk+s289ox67detWJr9zzjlHkZGRWrx4sXJyfKe5Dxw4sFL3ETXD9EKODRs21GeffaarrrpK8+fP946QfPzxx71pDMNQTEyMPvvsM8XHx1e9tgAAAAAAADjpNmzYIElq3ry53/PNmzfXH3/8oQ0bNqh169ZVyseTrl+/fie8xmaz6YwzztAff/yh33//XZ07d67AvcGpxPTISEnq27ev1qxZo2uvvVYREREyDMP7ExERoX/84x9atWqVLrzwwkDVFwAAAAAAACdZSkqKJKlOnTp+z8fFxUmSDhw4EPB8AlU2Tk1V3uK6ZcuW+vDDD1VYWKgtW7YoPT1dsbGxSkpKqvBu2wAAAAAAAKeL+x9eU/zbmuOmqy6rfyk7HTo3N1eS5HA4/F7jifkcO1U6EPkEqmycmkwHI8ePH+/9ffTo0YqJiVG7du0CUikAAAAAAADUnFq1akmSCgsL/Z4vKCiQJEVGRgY8n0CVjVOT6WDk2LFjZbFYFBkZqVtvvVUxMTGBrBcAAAAAAABqSGJioiTp6NGjfs+npaVJkho0aBDwfAJVNk5NVVozcsSIETp69KgaNWoUqPoAAAAAAACghnXo0EGSlJyc7Pf8zp07fdIFMp/jXeN0OrV7927ZbDadffbZxy0bpybTwcjatWvr9ttvl91e5WUnAQAAAAAAcArp06ePwsPDtWLFChmG4XPu8OHD2rJli1q2bHncnbQl6ZxzzlHjxo21adMmZWZm+pwrKirSr7/+qujoaJ/Njy+77DJJ0s8//1wmv/Xr1ysnJ0cXXXQR07SDlOlgZFJSkrKzsyuUNj09Xe+++67ZogAAAAAAAFCNateurVtuuUX79+/XN99843Pu7bfflmEYGj16tPdYRkaGrrjiCg0bNkxOp9N73GKxaNSoUSosLNT//d//+eQze/ZsHTlyRHfccYciIiK8x5OSknTZZZdpxYoV+u2333yumTFjhiT5lI3gYnpY4w033KB3331XvXv3PmHaPXv2aMSIEbrpppvMFgcAAAAAABASnpvQSZLUokWLGq6JtGPHjnLPTZgwQYsXL9btt9+umTNnqnPnzvr22281duxY9evXT3feeac37Xfffae5c+dKkv71r3+pS5cu3nOjR4/W119/rf/85z8644wzdPHFF2vFihW6++671bFjR40dO7ZM2a+99prOP/98DR06VO+//75atWql9957T6+//rpuvvlmXXHFFYF7EFCtTI+MvOeee5SWlqZRo0bp4MGDgawTAAAAAAAAalhsbKyWL1+uwYMH6x//+Ifi4uL0wAMP6IEHHtCXX37ps3Rf9+7d1aJFC3Xt2lXt2rXzycfhcOjbb7/V6NGjNXr0aMXFxenGG2/Uddddp6VLlyo6OrpM2U2bNtXKlSvVpUsXXXLJJapbt65eeuklTZw4UW+++abf+no2W7ZYLN5jntv+Ap6oGaZHRl588cUyDENz587VlClTlJSUpPj4eNlstjJpKzqdGwAAAAAAAKeO2NhYTZo0SZMmTTpuukaNGmn79u3lng8PD9e4ceM0bty4CpfdqFEjvfXWWxVOP3bsWIKOQcB0MHLx4sWyWCzeRUw3b96szZs3l5u+dFQaAAAAAAAAwOmnSlth33nnnUpISDhhugMHDmjq1KlVKQoAAAAAAABAkKtSMHLkyJFq27btCdNt3LhRr7/+elWKAgAAAAAAABDkTAcjhw0bpjp16lQobYMGDfT444+bLQoAAAAAACBkxMWFSZLq14+s4ZpIR46E1XQVcJoxHYyszAKi8fHxBCMBAAAAAACA05zV7IV9+vTRn3/+Gci6AAAAAAAAAAhhpoORixcvVk5OTiDrAgAAAAAAACCEVWkDm0ceeURxcXEVShsWFqaEhAT16NFD/fr1q0qxAAAAAAAAAIJQlYKRs2fP9rltGIb3d4vF4nO89O0OHTro008/VcuWLatSPAAAAAAAAIAgYjoYedNNN2n37t1atGiRYmJi1KVLFyUmJsrhcKiwsFApKSlauXKlsrKyNGTIEIWHhystLU2rV6/W+vXrdfHFF2vt2rWKjY0N5P0BAAAAAAAAcIoyHYx85pln1LlzZz355JO67777FB4eXiZNfn6+nn/+eX3++edasmSJIiPdW9a/8847uu222/TKK6/okUceMV97AAAAAAAAAEHDdDDyqaee0jXXXKOHH3643DTh4eF65JFHlJqaqieffFITJkyQJA0bNkzr1q3TF198QTASAAAAAACclrZs2VLTVQCqnelg5Ndff6233367QmmHDBmiW2+91RuMlKSBAwdqxowZZosHAAAAAAAISp07d67pKgA1xmr2wr179yoiIqJCacPDw7V7926fY3Xq1FF+fr7Z4gEAAAAAAAAEGdPByMjISC1YsKBCaRcsWFAmcJmSkqL69eubLR4AAAAAAABAkDEdjDzvvPP05JNP6uuvvz5uuq+++koTJkzQ+eef73P8o48+UsOGDc0WDwAAAAAAACDImF4z8sEHH9S8efM0cOBA/fWvf1WfPn3UvHlz1apVSzk5Odq5c6cWLlyoNWvWeNNL0o4dO/Tcc8/p3Xff1ZgxYwJzLwAAAAAAAACc8kwHI3v16qXJkydr9OjRWrVqlVavXl0mjWEYslqtmjRpki688EJJ0ltvvaWpU6dKkq688kqzxQMAAAAAAAAIMqanaUvS3XffrR9//FGXXnqp7Ha7DMPw/tjtdl122WVatmyZ7r77bu81TzzxhFwul1wul3r27FnlOwAAAAAAAAAgOJgeGelx/vnn6+uvv1ZeXp62bt2qjIwMxcTEKCkpqcK7bQMAAAAAAAAIfVUORnpERESoQ4cOgcoOAAAAAAAAQIip0jTt0g4fPqw1a9YoLy8vUFkCAAAAAAAACCFVHhn58ccfa8KECdqwYYMkacOGDWrbtq3eeustvfXWW3r00UfVr1+/Klc02ERHR3vX0QwUz1qcnnU5Q4XnvoTSffKgzYIPbRZcQrW9JNqssuz2gE32qHGJiYn0ISqI10nwoc2CD20WXEK1vST6EEAoqdKr7pFHHtHTTz/t/UNgsVi85+rVq6cVK1ZowIABGjt2rP773/9WraZBplOnTqpTp46KiooCmm+dOnW8GwCFGqfTWdNVOClos+BDmwWXUG4viTarTJ6h4pZbbpEk+hCVwOsk+NBmwYc2Cy6h2F4SfQggVJgORi5dulT/+9//FBkZqeuvv15nnXWWHnzwQe/5QYMGad++fRozZozGjh2rXr166cILLwxIpYPBmjVr1KFDB8XHxwcsT5fLpcOHD6tevXqyWgM2w77GGYYhp9Mpm83mE9AOBbRZ8KHNgkuotpdEm1XWwYMHA5ZXTZs+fbquvvpq+hAVwOsk+NBmwYc2Cy6h2l4SfQgglJgORk6ZMkWJiYlasWKFmjRpIkk+wUhJqlu3rt555x2lpKTo5ZdfPq2CkVlZWSoqKgroG4DFYvHmGWpvLJJC8n7RZsGHNgsuod5eEm1WUYEeRViTUlJS6ENUUqjdr1BvL4k2C0ahdt9Cvc1C8X7RhwBCh+mvE5YvX67//ve/3kDk8dxxxx1avny52aIAAAAAAAAAhADTwcjU1FT95S9/qVDa5s2b69ChQ2aLAgAAAAAAABACTAcjw8PDlZ6eXqG0u3fvVlRUlNmiAAAAAAAAAIQA08HINm3aaNasWSdMZxiGXn75ZbVv395sUQAAAAAAAABCgOlg5JAhQ/TWW2/pscceU0FBgfd46YVkd+zYoauvvlqLFi3StddeW7WaAgAAAAAAAAhqpnfTHjlypGbMmKGnnnpKkydP1rnnnivDMPTQQw/JZrNp8+bN+uOPPyRJHTp00O233x6wSgMAAAAAAAAIPqaDkREREfr22281cOBArV+/XgsWLJDFYtFXX30lyT09W5L+8pe/aM6cOXI4HIGpMQAAAAAAAICgZHqatiSdccYZWrFihV577TX16dNHdevWlc1mU926ddWnTx9NnTpVv/zyi5o0aRKo+gIAAAAAAAAIUqZHRnqEhYXpjjvu0B133BGI+gAAAAAAAAAIUaaDkX369PH+PnPmTCUkJASkQgAAAAAAAABCk+lp2osXL9YPP/wgh8Mhu73KAywBAAAAAAAAhLgqrRn54osvat68eapbt26g6gMAAAAAAAAgRJkORtarV089e/YMZF0AAAAAAAAAhDDTwchOnTpp9+7dFUq7b98+3XzzzWaLAgAAAAAAABACTAcj77nnHj333HMqLCw8YdqjR4/qnXfeMVsUAAAAAAAAgBBgOhh5xRVX6Oqrr9aFF16ozz//XKmpqTIMI5B1AwAAAAAAABBCTG+DbbPZvL8PHjw4IJUBAAAAAAAAELpMByMrOwrSYrGYLQoAAAAAAABACDAdjJSkt956S82bNz9huh07dujWW2+tSlEAAAAAAAAAglyVgpFdu3ZV27ZtT5iufv36rCcJAAAAAAAAnOZMb2Dz1ltvqUmTJhVKe+aZZ2rRokVmiwIAAAAAAAAQAkyPjBw2bFiF00ZGRqpXr15miwIAAAAAAAAQAkyPjAQAAAAAAACAyiAYCQAAAAAAAKBaEIwEAAAAAAAAUC0IRgIAAAAAAACoFgQjAQAAAAAAAFQLgpEAAAAAAAAAqgXBSAAAAAAAAADVgmAkAAAAAAAAgGoRkGDkwYMH9emnn2rixIk6fPiwJOnAgQPKysoKRPYAAAAAAAAAQkCVgpF5eXn65z//qTPOOEN///vf9e9//1sHDhyQJH311VdKTEzUww8/rMLCwoBUFgAAAAAAAEDwMh2MdLlcGjRokKZOnaqCggIZhuFz/pxzztFZZ52lp59+Wn/729+qWk8AAAAAAAAAQc50MPL999/X/Pnz1bFjR73//vtauXKlbDab93zXrl21atUqvfnmm/ruu+/0zjvvBKTCAAAAAAAAAIKT3eyF77//vrp06aKffvrJG4Q8dnSkJN18881auXKl3nnnHQ0bNsx8TQEAAAAAAAAENdMjI9esWaN7773XZzRkef72t79p3bp1ZosCAAAAAAAAEAJMByPT0tLUsmXLCqWtX78+O2sDAAAAAAAApznTwcjY2Fjt2rWrQmnXrVununXrmi0KAAAAAAAAQAgwHYzs0qWLJk2a5HedyNKOHDmiCRMm6NxzzzVbFAAAAAAAAIAQYDoYOWLECC1btkx9+vTR8uXLVVRUJEmyWCySpNTUVM2YMUNdu3bVjh07dNtttwWmxgAAAAAAAACCkundtIcMGaKPPvpIn332mXr27KmIiAi5XC717dtXeXl5Sk9Pl+TeYXvo0KG64oorAlZpAAAAAAAAAMHH9MhISfrggw90xx13SJJyc3NlGIZSUlKUlpYmwzBksVj0z3/+U++8805AKgsAAAAAAAAgeJkeGSlJYWFheu211zR69Gh98sknWrdundLT0xUbG6uOHTtqyJAhOuusswJVVwAAAAAAAABBrErBSI+zzjpLjz76aCCyAgAAAAAAABCiTE/TXrJkiXJzcwNZFwAAAAAAAAAhzHQwsnfv3kpOTg5kXQAAAAAAAACEMNPTtA3D0P79+xUdHV2h9GFhYapXr54cDofZIn3k5OTogw8+0PLly5Wenq74+Hj17t1b11xzjez2it2tDz74QDNnziz3/NNPP622bdsGpL4AAAAAAADA6a5Ka0b269evUultNpu6du2q++67T1dffbXpcnNycvTggw8qKytL999/v1q2bKnVq1dr0qRJ2rx5sx599FHZbLYK5VW7dm3FxMT4PRceHm66jgAAAAAAAAB8VSkYaRhGpdIXFRXpp59+0pAhQ/Tggw9qwoQJpsr9v//7P/3555967LHHvCMXu3XrppSUFL311luaN2+eLrvssgrldfnll+u6664zVQ8AAAAAAAAAFWd6zcjk5GRdd911SkxM1FNPPaUlS5Zoy5YtSk5O1pYtW7RkyRI9+eSTaty4sZ588klt375dq1at0tSpU9WmTRs988wzWrx4caXLzcnJ0ffff6+6deuqc+fOPuf69u0ri8Wi2bNnm71bAAAAAAAAAE4S0yMjV6xYoVWrVmnjxo2qW7dumfOtWrVSjx49dPvtt+vCCy9U9+7dddFFF6lTp066/vrr1b17d02ZMkUXXXRRpcpdv369CgoK1Lp1a1ksFp9zMTExatSokfbu3au9e/eqcePGZu8eAAAAAAAAgAAzPTLy9ddf13//+1+/gcjS6tevr0ceeUTPPPOM91hkZKTGjBmjn376qdLl/vnnn5KkhIQEv+c9xz3pTiQ5OVnjx4/XTTfdpKuvvlq33XabXn/9dR0+fLjSdQMAAAAAAABQPtPByHXr1unss8+uUNq2bdtq5cqVPsc6dOiggwcPVrrco0ePSlK5u3h7jqelpVUov02bNumCCy7QlClT9MEHH2jEiBFatmyZRo0apV27dlW6fgAAAAAAAAD8Mx2MzM7O1v79+yuUdt++fcrKyvI5lp+fr8jIyEqXW1BQIEnl7pZtt9u9+Z9Ir1699MILL6hv376Kjo5WRESEunfvrpEjRyojI0MvvvhipesHAAAAAAAAwD/TwchmzZrphRdekNPpPG46p9OpF154QU2bNvU5vnbtWjVo0KDS5YaFhXnz9aeoqEiSFB4efsK8GjdurMTExDLHzzvvPMXFxWnHjh3auXNnpesIAAAAAAAAoCzTG9gMGTJETz31lC688EI98sgjuuiii3xGOmZnZ2vRokWaMGGCfvnlFz3yyCPec7t27dKzzz6rc845p9Ll1qlTR5LKjLT08ByPi4urdN4eFotFDRo0UFpamvbs2aPmzZuXm3b//v1lRogePHhQ2dnZkiSXy2W6Hsfy5BXIPE8FhmHI5XLJ5XKV2ZQo2NFmwYc2Cy6h2l4SbXY6czgckuhDVASvk+BDmwUf2iy4hGp7SaHbZsDpyHQw8qGHHtLnn3+un376SQMHDpTk3qymVq1aysnJ8W4AYxiG2rVrpwcffFCS9MYbb+hf//qXCgsL9fDDD1e63GbNmkmSDhw44Pd8amqqTzqzDMOoULqpU6dq3LhxZY4PHTpUkpSSklKlevjjuY8IHrRZ8KHNggvtFXxos/KNGDFCEn0I0F7BiDYLPrRZ8KHNgOBnOhgZFRWlRYsWafjw4frmm28kye+GNJdddpneeustRUVFSZJatWql//znP5Kkq666qtLlnnPOOXI4HNq6dasMw/D5ticjI0P79u1TYmKiGjdufNx8Dh48qPvuu09TpkwpsxmOYRjeYOeJ8rnjjjs0aNCgMnnPnz9fkvxOAzfL5XIpNTVVCQkJslpNz7A/5RiGoaKiItnt9pD89o42Cy60WXAJ1faSaLPKOhmBu5ry1ltvacSIEfQhKoDXSfChzYIPbRZcQrW9JPoQQCgxHYyUpPj4eM2dO1e//vqr5syZo02bNikjI0MxMTFq27atrrzySnXp0sXnmt69e6t3796my4yMjNQll1yir7/+WqtWrfLJf8GCBTIMwyc4mJOTo+eff161a9fWPffc4934xuVyKS0tTWvXrlWPHj18yli+fLnS09PVvHnz407RlqSGDRuqYcOGPsf27dunn376SZJOyhub1WoNuTdMz30KtTdMD9os+NBmwSXU2kuizU5nhYWFkuhDVASvk+BDmwUf2iy4hHp7SaHXZsDpqErBSI+uXbuqa9eugciqQm688UZt2LBBr776qu6//361bNlSq1ev1syZM9WpUycNGDDAm3bNmjVauXKlJOmKK65QUlKSJHn/ME+dOlVOp1OdOnVSWFiYVq9erddee03R0dEaM2ZMyP4BBwAAAAAAAKpbQIKRJ5KTk6OVK1fqwgsvDEh+UVFRevbZZ/XBBx/o+eefV1pamuLj43XVVVfpmmuu8Y5+lKQ2bdooMTFRtWvX9tnROyEhQS+88IIWL16sjz/+WC+//LJcLpfq16+vHj166JprrlF8fHxA6gsAAAAAAACgmoKRycnJ6t27t5xOZ8DyjIqK0m233abbbrvtuOnq1aunadOm+T2XlJTkHSkJAAAAAAAA4OQKSDAyKytLW7duVVZWlt9dqHfs2BGIYgAAAAAAAAAEsSoFI1NTUzVy5EjNnj07oKMeAQAAAAAAAIQe08HIzMxM9ejRQ9u2batQejaCAQAAAAAAAE5vVrMXTpo0Sdu3b9d//vMf7dy5Uy6XSzabTRs3bpTL5ZLL5VJycrLuu+8+xcXFaefOnQGsNgAAAAAAAIBgYzoYOXv2bF1//fV66qmnfHapLq1Zs2Z67rnn9Le//U3PP/+86UoCAAAAAAAACH6mg5Fbt27VtddeW6G0Q4cO1bx588wWBQAAAAAAACAEmA5G5ubmqmHDhj7HHA6Hjhw5UiZtTEyMdu3aZbYoAAAAAAAAACHAdDCyfv36ZQKM9erV09q1a8uk/fnnn80WAwAAAAAAACBEmA5Gtm/fXi+99JKcTqf3WMeOHfXMM89o8+bN3mOrVq3ShAkT1KJFi6rVFAAAAAAAAEBQMx2M7Nu3rxYvXqzu3btr6dKlktxrQ+7du1cdO3ZUhw4d1L59e51//vk6fPiwBg8eHLBKAwAAAAAAAAg+poORQ4cO1YUXXqjIyEglJydLkq6//npdfPHFKiws1G+//aZNmzbJ6XSqY8eOeuCBBwJWaQAAAAAAAADBx272wmbNmmnx4sU+xywWi77++mu9+uqrWrhwoVwul3r27Km7775bkZGRVa0rAAAAAAAAgCBmOhhZboZ2u0aNGqVRo0YFOmsAAAAAAAAAQcz0NG2bzeb9OXZXbQAAAAAAAAA4lumRkYZhKCEhQaNGjVL9+vUDWScAAAAAAAAAIch0MNJms+nVV1/VNddcE8j6AAAAAAAAAAhRpqdpJyQk6MwzzwxkXQAAAAAAAACEMNPByN69e2vNmjUVSrt161a1aNHCbFEA8P/t3Xt8jHfe//H3JJOQiNQpBCUoajWE0tUDdQjr0Ntqpd1GW4u73Nw3qqutolVLb9Wi2C09aJ22rWq1ulq01rHbRW/qHDaVEuIQh6iICIlkrt8ffjPtmInGZDIz1+T1fDzyeMj1va7v9Znr8/i6vvnMdQAAAAAAAEHA42Lk+PHjNW3aNB07duxX1y0oKNDRo0c93RUAAAAAAACAIODxMyOzsrI0YMAAtWrVSk888YTuu+8+xcTEKDQ01GXdw4cPlypIAAAAAAAAAObncTGyU6dOslgskqQ5c+Zozpw5XgsKAAAAAAAAQPDxuBgpSYZhlHhde+ESAAAAAAAAQPnk8TMjLRaLUlJSZLPZfvVn79693owZAAAAAAAAgAl5XIy82asib2Z9AAAAAAAAAMHH49u009PTVbdu3RKte8cdd8hms3m6KwAAAAAAAABBwONiZFxcnDfjAAAAAAAAABDkPL5N284wDP3973/XyJEj1adPH2VkZEiSdu/erQ0bNpQ6QAAAAAAAAADBoVTFyLS0NLVs2VJJSUl68803tXLlSuXm5kqSduzYoa5du+q+++5zFCgBAAAAAAAAlF8eFyNzcnLUvXt37d+/X4ZhqHLlyk7t3bt315/+9Cft3btXiYmJjiIlAAAAAAAAgPLJ42Lk3LlzdeTIEY0YMUInTpxQdna2QkJ+7u7WW2/V66+/ri1btujcuXOaPXu2N+IFAAAAAAAAYFIeFyNXrFihfv366a9//atq165d7HotWrTQc889p+XLl3u6KwAAAAAAAABBwONi5MGDB5WcnFyidTt06KC0tDRPdwUAAAAAAAAgCHhcjMzLy1OtWrVKtK7ValVhYaGnuwIAAAAAAAAQBDwuRtasWVP79u0r0bobNmy44a3cAAAAAAAAAIKfx8XIDh06aNKkScrKyrrhetu2bdO0adPUuXNnT3cFAAAAAAAAIAhYPd1w9OjRWrp0qZo1a6bRo0erY8eOkqTjx4+rsLBQqampWrlypT7++GPZbDY9/fTT3ooZAAAAAAAAgAl5XIxs06aNpk6dqrFjx2rChAmO5T179nRazzAMzZw5Uy1atPA8SgAAAAAAAACm5/Ft2pI0ZswYffTRR6pbt64Mw3D5qVevnj7++GOuigQAAAAAAADg+ZWRdo8++qgefvhhbd26VXv27NGFCxd0yy23KCEhQffcc49CQ0O9EScAAAAAAAAAk/O4GJmRkaG6desqNDRUoaGhat++vdq3b+/N2AAAAAAAAAAEEY9v027YsKEOHjzozVgAAAAAAAAABDGPi5GGYejNN99Uenq6N+MBAAAAAAAAEKRK9QKbRYsWqUmTJurevbs+//xzFRUVeSsuAAAAAAAAAEGmVMXIb7/9Vh988IGuXr2qpKQk1atXTxMmTFBGRoa34gMAAAAAAAAQJDwuRnbs2FFVq1ZVcnKyNmzYoNTUVD322GN65513dNttt+mBBx7Ql19+KZvN5s14AQAAAAAAAJiUx8XIjRs3Ki4uzvF706ZNNWPGDB0/flx/+9vfdOnSJfXp00dxcXGaNGmSjh8/7pWAAQAAAAAAAJhTqW7Tdic8PFz9+vXTpk2b9MYbb+j06dOaPHmyGjVq5O1dAQAAAAAAADARq7c7zMrK0sKFC/Xuu+/q0KFDMgxDklSjRg1v7woAAAAAAACAiXh8ZWRoaKgOHDjg+H3Tpk3q16+fbr31Vo0dO1Y//vijJCkxMVHLli3TsWPHSh8tAAAAAAAAANPy+MpIwzCUlZWlmTNnat68eUpLS3Msr169ugYOHKihQ4eqcePGXgsWAAAAAAAAgHmV6jbtLl26yDAMx63Y7du317Bhw/Twww8rPDzcKwECAAAAAAAACA6lKkbabDbdcsst6t+/v4YNG6bmzZt7Ky7Ti4qKktVqdRRqvcEwDEef3uzX3+yfJZg+kx05Mx9yZi7Bmi+JnN0sq9Xrj8H2m9jYWOYQJcQ4MR9yZj7kzFyCNV8ScwggmJRq1E2bNk3Dhw9XRESEt+IJGq1bt1bVqlVVWFjo1X6rVq0qm80mm83m1X4DQVFRkb9DKBPkzHzImbkEc74kcnYzfQaLJ598UpKYQ9wExon5kDPzIWfmEoz5kphDAMGiVMXIXr16UYgsxq5du9SiRQvFxMR4rU+bzaZz586pevXqCgnx+N1DAccwDBUVFSk0NFQWi8Xf4XgVOTMfcmYuwZoviZzdrLNnz3qtL3+bP3+++vbtyxyiBBgn5kPOzIecmUuw5ktiDgEEE4+LkTfzTUReXp6+//573X///Z7uznRyc3NVWFjo1ROAxWJx9BlsJxZJQfm5yJn5kDNzCfZ8SeSspLx9FaE/nTp1ijnETQq2zxXs+ZLImRkF22cL9pwF4+diDgEED598BZSenq7OnTv7YlcAAAAAAAAAApRXntSam5urtLQ05ebmun2Q7OHDh72xGwAAAAAAAAAmVqpi5JkzZzR8+HCtWLEiaB+QCwAAAAAAAMA7PC5GXrx4Ue3bt9ePP/5YovWD7XkVAAAAAAAAAG6Ox8+MnD17tg4dOqRx48bpyJEjstlsCg0NVUpKimw2m2w2m9LT0/XMM8+oSpUqOnLkiBfDBgAAAAAAAGA2HhcjV6xYoccff1xTpkxR/fr13a4TFxen6dOn68EHH9SMGTM8DhIAAAAAAACA+XlcjExLS9Ojjz5aonWTk5O1Zs0aT3cFAAAAAAAAIAh4XIy8fPmyateu7bQsLCxMP/30k8u60dHRysjI8HRXAAAAAAAAAIKAx8XIGjVquBQYq1evrt27d7us+91333m6GwAAAAAAAABBwuNiZHx8vP7617+qqKjIsSwhIUGvvfaaUlNTHct27NihV155RY0aNSpdpAAAAAAAAABMzeNiZGJiojZt2qR7771X3377raRrz4Y8ceKEEhIS1KJFC8XHx+vuu+/WuXPn9PDDD3staAAAAAAAAADm43ExMjk5Wffff78iIyOVnp4uSXr88cfVtWtXXb16Vfv379eBAwdUVFSkhIQEjRkzxmtBAwAAAAAAADAfq6cbxsXFadOmTU7LLBaLVq9erblz52rDhg2y2Wzq0KGDRowYocjIyNLGCgAAAAAAAMDEPC5GFtuh1apRo0Zp1KhR3u4aAAAAAAAAgIl5fJs2AAAAAAAAANwMipEAAAAAAAAAfIJiJAAAAAAAAACfoBgJAAAAAAAAwCcoRgIAAAAAAADwCYqRAAAAAAAAAHyCYiQAAAAAAAAAn6AYCQAAAAAAAMAnKEYCAAAAAAAA8AmKkQAAAAAAAAB8gmIkAAAAAAAAAJ+gGAkAAAAAAADAJyhGAgAAAAAAAPAJipEAAAAAAAAAfIJiJAAAAAAAAACfoBgJAAAAAAAAwCcoRgIAAAAAAADwCYqRAAAAAAAAAHyCYiQAAAAAAAAAn6AYCQAAAAAAAMAnKEYCAAAAAAAA8AmKkQAAAAAAAAB8gmIkAAAAAAAAAJ+gGAkAAAAAAADAJyhGAgAAAAAAAPAJipEAAAAAAAAAfIJiJAAAAAAAAACfoBgJAAAAAAAAwCcoRgIAAAAAAADwCYqRAAAAAAAAAHyCYiQAAAAAAAAAn6AYCQAAAAAAAMAnrP4OIFDk5eVpyZIl2rJliy5cuKCYmBh17txZSUlJslo5TAAAAAAAAEBpUWXTtULk888/r9zcXD333HO67bbbtHPnTs2ePVupqal68cUXFRoa6u8wAQAAAAAAAFPjNm1J77//vo4eParhw4erefPmqlChgu655x4lJydrx44dWrNmjb9DBAAAAAAAAEyv3Bcj8/LytHbtWlWrVk1t2rRxaktMTJTFYtGKFSv8FB0AAAAAAAAQPMp9MXLv3r0qKChQ06ZNZbFYnNqio6NVp04dZWZm6sSJE36KEAAAAAAAAAgO5b4YefToUUlSzZo13bbbl9vXAwAAAAAAAOCZcl+MPH/+vCQpKirKbbt9eXZ2tq9CAgAAAAAAAIJSuS9GFhQUSFKxb8u2Wq+9cDw/P99nMQEAAAAAAADBqNwXI8PDwyVJRUVFbtsLCwslSRUqVPBZTAAAAAAAAEAwsvo7AH+rWrWqJCk3N9dtu315lSpV3LZnZmYqMzPTadnZs2d16dIlSZLNZvNSpD/35c0+A4FhGLLZbLLZbC4vETI7cmY+5MxcgjVfEjkrz8LCwiQxhygJxon5kDPzIWfmEqz5koI3Z0B5VO6LkXFxcZKk06dPu20/c+aM03rXe+eddzRp0iSX5cnJyZKkU6dOeSNMtzHBPMiZ+ZAzcyFf5kPOijdo0CBJzCFAvsyInJkPOTMfcgaYX7kvRrZs2VJhYWFKS0uTYRhO3x7l5OTo5MmTio2NVd26dd1uP3ToUP3+9793Wnb27FmtW7dOkhQbG+u1WG02m86cOaOaNWsqJCR47rA3DEOFhYWyWq1B+e0dOTMXcmYuwZoviZzdrLIo3PnLwoULNWjQIOYQJcA4MR9yZj7kzFyCNV8ScwggmJT7YmRkZKS6deum1atXa8eOHWrbtq2jbf369TIMw6XY+Eu1a9dW7dq1nZadPHlSW7dulaQyObGFhIQE3QnT/pmC7YRpR87Mh5yZS7DlSyJn5dnVq1clMYcoCcaJ+ZAz8yFn5hLs+ZKCL2dAecQIltS/f3/Vq1dPc+fO1YEDB5Sfn6+tW7dq6dKlat26tXr27OnvEAEAAAAAAADTK/dXRkpSpUqVNG3aNC1ZskQzZsxQdna2YmJi9NBDDykpKUmhoaH+DhEAAAAAAAAwPYqR/1+lSpU0ZMgQDRkyxN+hAAAAAAAAAEGJ27QBAAAAAAAA+ATFSAAAAAAAAAA+QTESAAAAAAAAgE9QjAQAAAAAAADgExQjAQAAAAAAAPgExUgAAAAAAAAAPkExEgAAAAAAAIBPUIwEAAAAAAAA4BMUIwEAAAAAAAD4BMVIAAAAAAAAAD5BMRIAAAAAAACAT1CMBAAAAAAAAOATFCMBAAAAAAAA+ATFSAAAAAAAAAA+QTESAAAAAAAAgE9Y/R1AMMvKyiqTfk+dOlUm/fqL1WpV1apVdfbsWRUWFvo7nDJBzsyHnJlLsOVLImc3q6zOuf7CHKJkGCfmQ87Mh5yZS7DnS2IOAQQDipFlIDIyUmFhYVq+fLlX+7148aJ27NihNm3aqHLlyl7tG2WDnJkPOTMX8mU+ZZmzsLAwRUZGerVPX2MOAYl8mRE5Mx9yZj7MIYDgYTEMw/B3EMEoOztbeXl5Xu1z37596tGjh77++mu1aNHCq32jbJAz8yFn5kK+zKcscxYZGakqVap4tU9/YA4B8mU+5Mx8yJn5MIcAggdXRpaRKlWqeP0/M/vl6DExMapTp45X+0bZIGfmQ87MhXyZDzn7dcwhQL7Mh5yZDzkzH3IGBA9eYAMAAAAAAADAJyhGAgAAAAAAAPAJipEAAAAAAAAAfIJipInUrl1bEydOVO3atf0dCkqInJkPOTMX8mU+5Mw/OO7mQr7Mh5yZDzkzH3IGBA/epg0AAAAAAADAJ7gyEgAAAAAAAIBPUIwEAAAAAAAA4BMUIwEAAAAAAAD4hNXfAeDX5eXlacmSJdqyZYsuXLigmJgYde7cWUlJSbJaSWFpGYah7du365tvvtG///1vZWdnq0KFCoqLi1P37t3VuXNnl20GDx6sM2fOuO0vNjZW8+bNc9u2Y8cOffrppzp8+LBCQkL0m9/8Ro899pgaN27sdn2bzaZVq1ZpzZo1OnXqlKKiotS2bVs98cQTqlKlisefORjMnj1bGzZsKLZ9wYIFqlGjhtOyEydO6P3339e+fftUUFCguLg49enTRx06dCi2H3JWeuvXr9df/vKXX11vypQpatGihSTGmD/k5OTorbfe0ubNmzVq1CglJiYWu26gjiXOl644JmWH+YM5MX8wF+YQgY/5AwBPcGVkgMvLy9Pzzz+vzZs369lnn9WSJUs0YMAALV++XFOmTFFRUZG/QzS9Tz75RP/7v/+rnJwcvfDCC/roo480bdo0RUVFadasWcVOgGJjY1W3bl2Xn+Le7rZ27VpNmjRJDRs21Hvvvac33nhDVqtVY8aM0b59+9xu85e//EULFy7Ugw8+qA8//FATJkzQgQMH9Mwzz+j8+fNeOwZmVbVqVbc5qFu3rkJDQ53WTU9P1+jRo5WTk6Pp06dr8eLFatu2raZPn65PPvnEbf/kzHvCw8OLzVXlypUVEhLiMnYYY76zZcsWDR8+XLt37/7VdQN1LHG+dMUxKVvMH8yL+YO5MIcIXMwfAHjMQEB7++23jd69exvbt293Wr58+XKjd+/exqpVq/wUWfB4//33jf79+xt5eXlOywsKCowhQ4YYvXv3Nnbv3u3U9uSTTxqnTp0q8T7Onj1rJCUlGc8884xhs9kcyy9fvmz079/fGDRokFFQUOC0zebNm43evXsbCxYscFqelpZm9O7d23j11VdLvP9gNGvWLGPdunUlWreoqMgYOXKk8cgjjxjnz593aps8ebLRp08f48iRI07LyZn3rFu3zhg3blyx7ePHjzemTJnitIwx5jurVq0yBgwYYGzbts2YNWuW0bt372LHViCPJc6XrjgmZYv5gzkxfzAX5hCBi/kDgNLgysgAlpeXp7Vr16patWpq06aNU1tiYqIsFotWrFjhp+iCR7Vq1dSlSxdFREQ4LQ8LC1OrVq0kSXv27CnVPr7++msVFBQ48mZXsWJFdejQQVlZWdq8ebPTNvbcduvWzWl548aN1aBBA23ZskVZWVmliqu82Lt3r44cOaK77rrL5faMrl27ymaz6csvv3RaTs68p1atWmrZsqXbtmPHjmnfvn3q2bNnqfZBvjzXoEEDzZkzR3fdddevrhuoY4nzpSuOSdlj/hD8AvX/vPKEOUTgYv4AoDQoRgawvXv3qqCgQE2bNnX6D1iSoqOjVadOHWVmZurEiRN+ijA49OrVSwMHDnTbZv8DwzCMUu1j+/btkqRmzZq5tN1+++2SpO+//96xLDc3V6mpqapUqZJuvfVWl22aNWsmwzCctkHx7MfJfqx/yZ6T648lOfOe+Ph4JScnu21bvXq16tSp4/jD3VPky3PNmzdXVFRUidYN1LHE+dIVx6TsMX8IfoH6f155whwicDF/AFAaPI01gB09elSSVLNmTbftNWvW1IkTJ3T06FHVrVvXl6GVG/YTT3x8vEvb119/rZ07dyozM1MWi0X16tVTly5d1KNHD4WE/FznLyoq0rFjxyS5z6V9mT3fkpSRkSHDMG6Y++u3KY/27t2rDRs26MiRI8rPz1fNmjXVrl07JSUlOU2ObjSWqlatqvDwcP3000/KyclRdHQ0OfORy5cva+PGjUpOTnaZAEqMsUAUqGOJ86Urjol/MX8IbMwfzI85hLkE6ljiXAn4D8XIAGZ/wG5x3zjZl2dnZ/sqpHLl4sWL2rVrlxo1aqQ777zTpf2HH37Q8OHD1bBhQ+Xk5OiLL77Q22+/rZ07d2rcuHGOB6BfunRJhYWFslgsqlSpkks/7vL4a7m391Pec79//34NHjxYrVq1UmFhobZu3ap58+Zp8+bNevXVV1WtWjVJv348IyMjVVBQoOzsbEVHR5MzH9m0aZMKCwvVtWtXt+2MscATqGOJ86Urjon/MH8IfMwfzI85hLkE6ljiXAn4D8XIAFZQUCBJLm/1s7Nar6UvPz/fZzGVJ4sWLZLFYtGf/vQnl29cR44cqebNmyssLEySVL16dQ0aNEgnT57U//3f/2nVqlX6/e9/L+nn/NxMHu25t7eVZJvypk+fPvrjH//o+INBuvZ8mLy8PM2fP19vv/22xo8fL+nmjyc5843Vq1erQ4cObieAjLHAFKhjifOlK46J/zB/CGzMH4IDcwhzCdSxxLkS8B+eGRnAwsPDJV27fcCdwsJCSVKFChV8FlN5sWnTJq1fv16jR49WXFycS3tCQoJjgvNL3bt3lyRt3LjRscyen5vJoz339raSbFPeNGzY0OkPCbvu3bvLYrFo27Ztys3NlXTzx5Oclb39+/fr6NGj6tWrl9t2xlhgCtSxxPnSFcfEP5g/BD7mD+bHHMJ8AnUsca4E/IdiZACrWrWqJDkmRNezL7/+jWQonV27dmnOnDkaPny47r333pvaNjY2VpJ0/Phxx7JKlSrJarXKMAxdunTJZRt3efy13Nv7IfeuKlasqCpVqshmsykzM1PSrx/PvLw8ST8fT3JW9lavXq0mTZqoSZMmN7UdY8y/AnUscb50xTHxPeYP5sb8wTyYQ5hPoI4lzpWA/1CMDGD2b9RPnz7ttv3MmTNO66H0du/eralTp2ro0KHq1q2bV/oMDQ1VvXr1JLnPpbs81q9fXxaLxdFWkm3ws+vfXnqjsXT+/HkVFBSoWrVqio6OlkTOytr58+e1devWYq9ouFnky3cCdSxxvnTFMfEt5g/BgflD4GMOYU6BOpY4VwL+QzEygLVs2VJhYWFKS0tzmRzl5OTo5MmTio2N5c1eXrJnzx698sorGjx4sNMfEhkZGfr2228dv3/++eeaNWuW2z7s36Rfn5O2bdtKuvYw7evZl7Vp08axLCoqSrfffrsuXbrk9O2tXWpqqiwWi9M25cm///1vDR061G3b5cuXdeHCBYWEhKh27dqSfj62Bw8edFk/NTXVaR07clZ2/vGPfygiIkIdOnRw284YC1yBOpY4X7rimPgO8wfzYP5gfswhzClQxxLnSsB/KEYGsMjISHXr1k0//fSTduzY4dS2fv16GYbhePgySmfPnj2aMmWKBg8erN/97ndObWlpafrqq68cv1++fFm7du1y3E7wS/b1OnXq5LS8R48eCg8Pd+TN7sqVK/rXv/6lGjVq6L777nPaxp7btWvXOi3/8ccfdeTIEd1zzz2KiYm5+Q8bBAoLC5WZmam0tDSXtq+//lqGYaht27aOh5onJCQoLi5O27dvd3kb3rp16xQSEqL/+I//cFpOzspGUVGR1qxZo8TERMdzeq7HGAtcgTqWOF+64pj4BvMHc2H+YG7MIcwrUMcS50rAfyhGBrj+/furXr16mjt3rg4cOKD8/Hxt3bpVS5cuVevWrdWzZ09/h2h6e/fu1csvv6yIiAjt2bNH06dPd/r55R8SkmSxWJSdna2pU6cqLS1N+fn5OnfunObPn6/vv/9erVu3djmZxsTEaMiQITp48KDeffddXbx4UefOndPMmTN18eJFjRo1ymVS1b59e3Xs2FFffvml1q1bp/z8fB06dEgzZ85UjRo1NGTIkDI/NoHK/nbS6dOna/v27bp06ZIuXbqkf/zjH/rwww8VExOjYcOGOdYPCQnR008/LYvFomnTpikzM1N5eXlaunSptm/fruTkZDVs2NBpH+SsbGzbtk3nzp274f9djLHAFchjifOlK45J2WL+YD7MH8yNOYR5BfJY4lwJ+IfFuP56ZAScS5cuacmSJdq6dauys7MVExOjzp07Kykpye2b4nBzZs+erQ0bNtxwnfj4eL3yyiuSpPz8fG3btk3ffvutDh48qAsXLig8PFz169dXp06d1KNHD4WGhrrtZ8eOHVq2bJkOHz6s0NBQNWvWTI899lixD+C22WxauXKl1qxZo1OnTikqKkpt27bVE0884XjgcnlkGIZSUlL0zTffaN++fcrKypLFYlGtWrX029/+Vn379lXlypVdtjt+/Lg++OAD7du3T/n5+apfv7769Omjjh07FrsvcuZdEyZMUEhIiCZNmlTsOowx3zp9+nSxfzTVrFlT7733nsvyQB1LnC9dcUzKDvMH82H+YG7MIQIL8wcApUExEgAAAAAAAIBPcJs2AAAAAAAAAJ+gGAkAAAAAAADAJyhGAgAAAAAAAPAJipEAAAAAAAAAfIJiJAAAAAAAAACfoBgJAAAAAAAAwCcoRgIAAAAAAADwCYqRAAAAAAAAAHyCYiQAAAAAAAAAn6AYCQAAAAAAAMAnKEYCAAAAAAAA8AmKkQAAAAAAAAB8gmIkAAAAAAAAAJ+gGAkAAExhxowZqly5smbMmOHvUG6oU6dOslgsjp+BAwf6OyQAAAAgYFCMBAAAprB48WLl5uZq8eLF/g7lhhYuXKh9+/apT58+/g4FAAAACDgUIwEAgCm89NJLatu2rSZMmODvUG6oYcOGio+PV5UqVfwdCgAAABBwrP4OAAAAoCQeeeQRPfLII/4OAwAAAEApcGUkAAAAAAAAAJ+gGAkAAG6aYRhatmyZevbsqZiYGIWHh6tmzZrq3r27/va3v6moqMix7p///GenF7o0aNBA+fn5eu2119S6dWtVrlxZUVFRateunebPny/DMJz2tWjRIqftLRaL25gyMzM1btw4JSQkqFq1aqpYsaIaNWqkP/zhD1qwYIEuXLhQ7HZjxoxRfHy8KlWqpEqVKik+Pl5jxozRqVOnbngcvvnmG/Xq1UvVqlVTZGSkmjVrphdeeEGXLl0q0XE8efKkRo8erWbNmikyMlJRUVH6zW9+o5EjR+rQoUMl6gMAAAAwE4tx/YwfAADgBvLz8/X444/rs88+07333qtRo0YpLi5Ohw4d0syZM7Vjxw4lJibqiy++UGRkpM6cOaMzZ85oxYoVevHFF1WnTh01bdpUFStW1IgRIxQbG6uUlBRNnDhRR48e1aOPPqolS5YoJOTad6bZ2dk6fvy4tm/frv/8z/+UJJeCZUpKiu6//37ZbDZNmDBB7dq1k9Vq1a5duzR16lQdO3ZMAwcO1MKFC522W79+vZKSknTlyhWNGTNGPXv2lCStXr1a06dPV0REhD7//HN16tTJ5TjMmTNHTz31lCIiIvTCCy+oa9euunLlipYtW6YtW7botttu07JlyzRgwAAtWrTIZfv169erb9++Kigo0Lhx49SxY0cVFBRo48aNev3112W1WvXBBx/ooYce8kLWAAAAgABhAAAA3IRhw4YZkowOHToYhYWFTm1Xr141WrVqZUgyhg4d6tS2cOFCQ5IhyejVq5dRVFTk1H706FGjcuXKhiRj+vTpLvvduHGjY/vrPfTQQ4YkY968eS5taWlpRnh4uDFgwACn5T/88INjf5988onLdkuWLDEkGdHR0caPP/7o1LZ161YjJCTEkGR88cUXLtu+/PLLjvbr92uPyb7vNWvWuLR/+umnhiQjMjLSOHTokEs7AAAAYFbcpg0AAEosNTVV77zzjiRpypQpCg0NdWq3Wq167rnnJEkLFizQ6dOn3fYzYcIEx5WPdvXr13dc+fjqq6/qypUrJY7rwIEDkqSoqCiXtsaNG+u//uu/1KpVK6flL730ki5evKiWLVu6fTFOv379dMcddygnJ8flDd6TJ0+WzWbTnXfeqd69e7ts++yzz7qNxW7ChAm6ePGiunTpot/97ncu7UlJSWratKny8vI0e/bsYvsBAAAAzIZiJAAAKLFly5bJMAxVrFhRd999t9t1mjVrJkm6evWq/vnPf7q0V6hQQXfddZfbbRMTEyVJ586d0+bNm0scV9OmTSVJzz//vNasWeNyG/cbb7yhp59+2vF7fn6+VqxYIUnq2rVrsf3aC4V///vfVVBQIEm6fPmy1q1bJ0nq0qWL2+0qVqyotm3bum0rKChw7Nvd7d92t99+u6Rrt3MDAAAAwYJiJAAAKLE9e/ZIkq5cuaKIiAhZrVaXn9/+9reO9TMyMlz6qFGjhssVlXYNGjRw/Nt+tWNJTJ06VbVq1dKxY8fUo0cP1a9fX//zP/+jlStXKj8/32X9tLQ0x5WXjRo1Krbfhg0bSrpWgExLS3Nse/XqVZd4rxcbG+t2+cGDB3X58mVJ117u4+4YWq1WrVy5UpL7YwgAAACYldXfAQAAAPOwv5G6Vq1ajqsDb6RWrVouy6zW4qcfkZGRjn/n5OSUOK477rhDKSkpmjt3rhYvXqz09HS99dZbeuutt1SlShWNHDlSL774osLDw50+hyRFRESUKB77Nr+M60bbhoWFuV3+y31PnDhRffv2veFnK+7t4QAAAIAZUYwEAAAldsstt0i6dmVkfHy8R30UFhYW25aXl+f4d3R09E31W6NGDU2cOFETJ07Uzp079dlnn+n999/XsWPH9PLLLystLU0fffSRpJ8/x/X7vFE89m1+GdeNtrVfPXm9X+47Ojra4+MIAAAAmBG3aQMAgBJLSEiQdO3qvlOnThW73rZt2/Tee+8pMzPTpS0rK0tFRUVutzty5Ijj33fccYfHcd55552aMmWKDh8+rKeeekqStHTpUh07dkyS1KRJE8dVjYcPHy62H3tbZGSkmjRp4tjWftXjL+O9XnHH55f7Tk1NLXb7wsJCzZ8/X6tWrSp2HQAAAMBsKEYCAIASe+SRRxxvwbY/09Cd//7v/9ZTTz2lSpUqubTl5+dr+/btbrez3/pdvXp13XvvvSWO66677tL48eNdllutVk2ePNnxu704WqFCBfXp00eStHbt2mL7tbc9+OCDjlu8IyIi1K1bN0nShg0b3G535coVff/9927bKlSooAcffFCS9NVXXxVbmP3qq680ePBgbd26tdj4AAAAALOhGAkAAEqsWbNmGjZsmCRpypQpOnfunMs6CxYs0M6dOzVy5Ei3t1qHhITo5ZdfdnnjdUZGhhYuXChJGjt2rCpWrFjiuM6ePatPP/3U8WKYX7JffVipUiU1b97csXzy5MmqXLmyUlJSHLdv/9JHH32k/fv3Kzo62qmgKUkTJkxQSEiIdu3apS+//NJl29dff/2Gz7ycPHmyoqOjlZGRodmzZ7u05+bmauzYsbrllls0YsSIYvsBAAAAzIZnRgIAgJsya9YsnTt3Th9//LHatWun8ePHKyEhQVlZWVqxYoXmzZun7t27uxTw7OrVq6c6derogQce0IgRIxQbG6uUlBS99NJLunjxov7whz9o9OjRjvWzs7N1/PhxpaenO5alpKRIkm6//XaFhYXJYrEoLS1N999/v0aNGqUmTZqoqKhIu3bt0tSpUxUSEqI333xTUVFRjj6aNGmizz//XElJSRo0aJAOHDigXr16Sbp2VeK0adNUpUoVLV++XLfddpvTZ7j77rs1e/ZsPfXUU+rXr59eeOEFJSYmKj8/X8uWLdPy5cvVpUsXbdiwQdnZ2UpJSVFkZKTjzd2NGzfWihUr1LdvXz333HP64Ycf9Oijj6py5crav3+/XnvtNWVkZOizzz4r9q3cAAAAgBlZjOsvSwAAACiBL774Qu+++662bdumn376SVFRUUpISNAf//hHDRw40HE7t92iRYs0aNAgxcXFKT09XW+//bYWLFig1NRU2Ww2NW/eXEOHDtWTTz7p9AZp+3bupKenq0GDBjp+/Lg+/PBDrV27VgcOHFBWVpYsFovq1q2r9u3ba9SoUWrTpo3bPjIzMzVz5kytWrXK8QzIBg0a6IEHHtAzzzxzw2Lgpk2b9Nprr+m7777T5cuXVbt2bfXo0UMTJ07U2LFjtXjxYse67dq103fffee0/enTpzVr1iytXLlS6enpKiwsVL169dS1a1c9++yzaty48Q1zAAAAAJgNxUgAAOATvyxG3ujFLwAAAACCF8+MBAAAAAAAAOATFCMBAAAAAAAA+AQvsAEAAGXqzJkzOnPmjE6cOCFJunr1quMFNPHx8f4MDQAAAICP8cxIAABQpv785z9r0qRJbtuYhgAAAADlC8VIAAAAAAAAAD7BMyMBAAAAAAAA+ATFSAAAAAAAAAA+QTESAAAAAAAAgE9QjAQAAAAAAADgExQjAQAAAAAAAPgExUgAAAAAAAAAPkExEgAAAAAAAIBPUIwEAAAAAAAA4BMUIwEAAAAAAAD4xP8D9VZ+HXMkCVkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "mnist_scale_analysis.plot_learning(mnist_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nTCeZEkTuy9q" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for reward_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "G-KfqyMQ4wEa" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "mnist_scale_analysis.plot_seeds(mnist_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BM9Dde95Ngwn" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PweN9CwBIEps" + }, + "source": [ + "### Catch scale" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xv0kzFFGiLnL" + }, + "source": [ + "\"catch\n", + "\n", + "\n", + "DeepMind's internal \"hello world\" for RL agents.\n", + "\n", + "- The environment is a 5x10 grid with a single falling block per episodes (similar to Tetris).\n", + "- The agent controls a single \"paddle\" pixel that it should use to \"catch\" the falling block.\n", + "- If the agent catches the block reward +1, if the agent misses the block reward -1.\n", + "- Run reward_scale = [0.01, 0.1, 1., 10, 100] for 4 seeds for 10k episodes.\n", + "- Score is percentage of successful \"catch\" over first 10k episodes.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "C03JJqYkIEpv" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('scale', 'credit_assignment')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "catch_scale_df = DF[DF.bsuite_env == 'catch_scale'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'catch_scale', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "d_vt5a__IEpz" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret over learning (lower is better)\n", + "catch_scale_analysis.plot_average(catch_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FMf_UvCFupuv" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for reward_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "VSXonpvuIEp5" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "catch_scale_analysis.plot_learning(catch_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tyE8auVluzqa" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for reward_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "Q0CtosBw4wwx" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "catch_scale_analysis.plot_seeds(catch_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DG5P82d-NhoP" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-Tbhu6tKIEqG" + }, + "source": [ + "### Mountain car scale" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0reSPxfYiVNL" + }, + "source": [ + "\"mountaincar\n", + "\n", + "A classic benchmark problem in RL.\n", + "The agent controls an underpowered car and must drive it out of a valley.\n", + "\n", + "- Reward of -1 each step until the car reaches the goal.\n", + "- Maximum episode length of 1000 steps.\n", + "- Run reward_scale = [0.01, 0.1, 1., 10, 100] for 4 seeds for 1k episodes.\n", + "- Score is based on regret against \"good\" policy that solves in 25 steps.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "xtDJON_4IEqH" + }, + "outputs": [], + "source": [ + "#@title parsing data\n", + "# mountain_car_scale_df = DF[DF.bsuite_env == 'mountain_car_scale'].copy()\n", + "# summary_analysis.plot_single_experiment(BSUITE_SCORE, 'mountain_car_scale', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "-EfiYNQhIEqI" + }, + "outputs": [], + "source": [ + "#@title average regret over learning (lower is better)\n", + "# mountain_car_scale_analysis.plot_average(mountain_car_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_WtMKupHurkM" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for reward_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "bZMxcgQkIEqL" + }, + "outputs": [], + "source": [ + "#@title average regret through learning (lower is better)\n", + "# mountain_car_scale_analysis.plot_learning(mountain_car_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZfIb7ZNnu1UK" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for reward_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "HzzdOtA_4yXu" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# mountain_car_scale_analysis.plot_seeds(mountain_car_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NcQJaFUBNjQe" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "USfDNwCtIEp9" + }, + "source": [ + "### Cartpole scale" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F0LcbVm3iSM6" + }, + "source": [ + "\n", + "\"cartpole\n", + "\n", + "A classic benchmark problem in RL.\n", + "The agent controls a cart on a frictionless plane.\n", + "\n", + "- The poles starts near-to upright.\n", + "- The observation is [x, x_dot, sin(theta), sin(theta)_dot, cos(theta), cos(theta)_dot, time_elapsed]\n", + "- Episodes end once 1000 steps have occured, or |x| is greater than 1.\n", + "- Reward of +1 when pole > 0.8 height.\n", + "- Run reward_scale = [0.01, 0.1, 1., 10, 100] for 4 seeds for 1k episodes.\n", + "- Score is percentage of timesteps balancing the pole.\n", + "- Must log `episode`, `total_regret` for standard analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "mfSO4Q4gIEp-" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('scale', 'generalization')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "cartpole_scale_df = DF[DF.bsuite_env == 'cartpole_scale'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'cartpole_scale', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "gdZXo0QwIEqB" + }, + "outputs": [], + "source": [ + "#@title average regret over learning (lower is better)\n", + "# cartpole_scale_analysis.plot_average(cartpole_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rbV2q1snuqdy" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agents.\n", + "- Look for reward_scale with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "eFZ2_koZIEqE" + }, + "outputs": [], + "source": [ + "#@title average regret through learning (lower is better)\n", + "# cartpole_scale_analysis.plot_learning(cartpole_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TOBg2c5Ku0Xq" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by reward_scale (lower is better)\n", + "- Dashed line shows the performance of a random agent baseline.\n", + "- Look for reward_scale with performance significantly better than baseline." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "fyTcpBud4xlP" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# cartpole_scale_analysis.plot_seeds(cartpole_scale_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nawk_01lNifm" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tV8NnR1pJIkN" + }, + "source": [ + "## Exploration\n", + "\n", + "Exploration is the problem of prioritizing useful information for learning." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "NMY_PV_PJWvy" + }, + "source": [ + "### Deep sea\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2G2dMRuhJWvz" + }, + "source": [ + "\"deep\n", + "\n", + "Scalable chain domains that test for\n", + "[deep exploration](https://arxiv.org/abs/1703.07608).\n", + "\n", + "The environment is an N x N grid with falling blocks similar to catch. However\n", + "the block always starts in the top left. In each timestep, the agent can move\n", + "the block \"left\" or \"right\". At each timestep, there is a small cost for moving\n", + "\"right\" and no cost for moving \"left\". However, the agent can receive a large\n", + "reward for choosing \"right\" N-times in a row and reaching the bottom right. This\n", + "is the single rewarding policy, all other policies receive zero or negative\n", + "return making this a very difficult exploration problem.\n", + "\n", + "- Run deep_sea sizes N=5,6,7,..,50 for at least 10k episodes.\n", + "- Score is the percentage of N for which average regret < 0.9 faster than 2^N.\n", + "- Must log `episode`, `total_return` for standard analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "BIAMOfnzJWv0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('exploration',)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "deep_sea_df = DF[DF.bsuite_env == 'deep_sea'].copy()\n", + "deep_sea_plt = deep_sea_analysis.find_solution(deep_sea_df, SWEEP_VARS)\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'deep_sea', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "0Scr29pYJWv3" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret by size through learning (lower is better)\n", + "deep_sea_analysis.plot_regret(deep_sea_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JNt8bTBkJWv9" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average regret through time (lower is better).\n", + "- Dashed line shows the performance of suboptimal \"greedy\" algorithm\n", + "- Look for largest size with performance significantly better than greedy agent.\n", + "- Curves also show dynamics through time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "aGZnDiV_JWv-" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title scaling of learning time with deep_sea size (lower + more blue is better)\n", + "deep_sea_analysis.plot_scaling(deep_sea_plt, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "XRTs5_yxJWwC" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Compute the number of episodes until the average regret < 0.9 for each problem size.\n", + "- Red dots have *not* solved the problem, but have simply performed only that many episodes.\n", + "- Dashed line shows curve 2^N, which is the scaling we expect for agents without deep exploration.\n", + "- Want to see consistent curve of blue dots signficantly *below* the dashed line -> deep exploration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "L5SYqq4IJWwD" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title scaling of learning time with deep_sea size on log scale (lower + more blue is better)\n", + "deep_sea_analysis.plot_scaling_log(deep_sea_plt, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mCMKo6h0JWwG" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Plots exactly the same data as above, but on a logarithmic scale.\n", + "- If we see polynomial scaling -> this should result in a linear relationship between log(learning time) and log(size).\n", + "- Want to see consistent line of blue dots significantly below the dashed line -> deep exploration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "DtoFkEw9IzjO" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "deep_sea_analysis.plot_seeds(deep_sea_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2kHPsxo-NkUP" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Fada-WLrKDdA" + }, + "source": [ + "### Stochastic deep sea\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "80Ih3cX4KDdD" + }, + "source": [ + "\"deep\n", + "\n", + "Scalable chain domains that test for\n", + "[deep exploration](https://arxiv.org/abs/1703.07608).\n", + "\n", + "The environment is an N x N grid with falling blocks similar to catch. However\n", + "the block always starts in the top left. In each timestep, the agent can move\n", + "the block \"left\" or \"right\". At each timestep, there is a small cost for moving\n", + "\"right\" and no cost for moving \"left\". However, the agent can receive a large\n", + "reward for choosing \"right\" N-times in a row and reaching the bottom right. This\n", + "is the single rewarding policy, all other policies receive zero or negative\n", + "return making this a very difficult exploration problem.\n", + "\n", + "The stochastic version of this domain only transitions to the right with\n", + "probability (1 - 1/N) and adds N(0,1) noise to the 'end' states of the chain.\n", + "\n", + "- Run deep_sea sizes N=5,6,7,..,50 for at least 10k episodes.\n", + "- Score is the percentage of N for which average regret < 0.9 faster than 2^N.\n", + "- Must log `episode`, `total_return` for standard analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "1qJ96InzKDdE" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('exploration', 'noise')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "deep_sea_stochastic_df = DF[DF.bsuite_env == 'deep_sea_stochastic'].copy()\n", + "deep_sea_stochastic_plt = deep_sea_stochastic_analysis.find_solution(deep_sea_stochastic_df, SWEEP_VARS)\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'deep_sea_stochastic', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "f1vKIKoMKDdH" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret by size through learning (lower is better)\n", + "deep_sea_stochastic_analysis.plot_regret(deep_sea_stochastic_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Sr0evA1DKDdN" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average regret through time (lower is better).\n", + "- Dashed line shows the performance of suboptimal \"greedy\" algorithm\n", + "- Look for largest size with performance significantly better than greedy agent.\n", + "- Curves also show dynamics through time." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "T1oUdaXnKDdO" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title scaling of learning time with deep_sea_stochastic size (lower + more blue is better)\n", + "deep_sea_stochastic_analysis.plot_scaling(deep_sea_stochastic_plt, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aIcze9ScKDdR" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Compute the number of episodes until the average regret < 0.9 for each problem size.\n", + "- Red dots have *not* solved the problem, but have simply performed only that many episodes.\n", + "- Dashed line shows curve 2^N, which is the scaling we expect for agents without deep exploration.\n", + "- Want to see consistent curve of blue dots signficantly *below* the dashed line -> deep exploration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "syBJ_aGmKDdS" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title scaling of learning time with deep_sea size on log scale (lower + more blue is better)\n", + "deep_sea_stochastic_analysis.plot_scaling_log(deep_sea_stochastic_plt, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rQF9BDzoKDdY" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Plots exactly the same data as above, but on a logarithmic scale.\n", + "- If we see polynomial scaling -> this should result in a linear relationship between log(learning time) and log(size).\n", + "- Want to see consistent line of blue dots significantly below the dashed line -> deep exploration." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "s_bWpZ5UJrwJ" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "deep_sea_stochastic_analysis.plot_seeds(deep_sea_stochastic_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "DhGbNwJfNl1m" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g_mroLiVK1RE" + }, + "source": [ + "### Cartpole swingup\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "S2KWDe9dK1RH" + }, + "source": [ + "\n", + "\"cartpole\n", + "\n", + "A difficult cartpole swingup task with sparse rewards and a cost for moving.\n", + "This domain is somewhat similar to \"deep sea\" but cannot be solved easily by tabular reinforcement learning algorithms.\n", + "\n", + "- The observation is `[x, cos_theta, sin_theta, x_dot, theta_dot, x_central]`\n", + "- The dynamics are given by the classic cartpole from dm [control suite](https://github.com/deepmind/dm_control/blob/master/all_domains.png)\n", + "- Each episode begins with the pole hanging downwards and ends after 1000 timesteps.\n", + "- There is a small cost of -0.1 for any movement of the pole.\n", + "- There is a reward of +1 only if:\n", + " - x_dot, theta_dot < 1\n", + " - pole_height > 1 - `difficulty_scale`\n", + " - x < 1 - `difficulty_scale`\n", + "\n", + "The parameter `difficulty_scale` acts as a scaling for the depth of exploration, similar to the \"size\" in deep sea.\n", + "To run this experiment:\n", + "\n", + "- Run the agent on difficulty_scale = 0, 0.05, 0.1, .. , 0.95 for 1k episodes\n", + "- Score is proportion of runs that achieve an average_return > 0 at any point.\n", + "- Must log `episode`, `total_return` for standard analysis\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "odVWa8S5K1RJ" + }, + "outputs": [], + "source": [ + "#@title parsing data\n", + "# cartpole_swingup_df = DF[DF.bsuite_env == 'cartpole_swingup'].copy()\n", + "# summary_analysis.plot_single_experiment(BSUITE_SCORE, 'cartpole_swingup', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "Gc4VSuUsK1RO" + }, + "outputs": [], + "source": [ + "#@title scaling with difficulty scale (higher + more blue is better)\n", + "# cartpole_swingup_analysis.plot_scale(cartpole_swingup_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "X4HWtEcIK1RT" + }, + "source": [ + "**Parsing the plot above:**\n", + "- For each height threshold, look at the best observed return.\n", + "- If the observed return is greater than 500 ==> the pole was swung upright and balanced for at least 5 seconds.\n", + "- Look for higher scores and more blue." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "r5HeI4rrK1RV" + }, + "outputs": [], + "source": [ + "#@title average regret through learning (lower is better)\n", + "# cartpole_swingup_analysis.plot_learning(cartpole_swingup_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Uta3sgNOK1RY" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average return through time (higher is better).\n", + "- Dashed line shows the performance of an agent that does not move = 0.\n", + "- Look for largest difficulty_scale with performance significantly better than staying still." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "M3tiBC9442n1" + }, + "outputs": [], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "# cartpole_swingup_analysis.plot_seeds(cartpole_swingup_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FAlAYE7oNms2" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Jpj7JjESSs_J" + }, + "source": [ + "## Credit assignment\n", + "\n", + "This is a collection of domains for credit assignment." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k4S-Q5B5Sysn" + }, + "source": [ + "### Umbrella length" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "swsqn6tXSysr" + }, + "source": [ + "\"umbrella\n", + "\n", + "A stylized problem designed to highlight problems to do with temporal credit assignment and scaling with time horizon.\n", + "\n", + "- The state observation is [need_umbrella, have_umbrella, time_to_go,] + n \"distractor\" features that are iid Bernoulli.\n", + "- At the start of each episode the agent observes if it will need an umbrella.\n", + "- It then has the chance to pick up an umbrella only in the first timestep.\n", + "- At the end of the episode the agent receives a reward of +1 if it made the correct choice of umbrella, but -1 if it made the incorrect choice.\n", + "- During chain_length intermediate steps rewards are random +1 or -1.\n", + "\n", + "The experiment setup:\n", + "- Run umbrella_chain with n_distractor=20 and sweep chain_length=1..100 logarithmically spaced for 10k episodes.\n", + "- Score is percent of tasks with average reward per episode > 0.5.\n", + "- Must log `episode`, `total_return`, `total_regret` for standard analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "H22CVW-gSyss" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('credit_assignment', 'noise')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "umbrella_length_df = DF[DF.bsuite_env == 'umbrella_length'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'umbrella_length', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "YW9UOQTRSysw" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret after 10k episodes (lower is better)\n", + "umbrella_length_analysis.plot_scale(umbrella_length_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "besZfRI7Sys1" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Compute the average regret after 10k episodes for each chain_length problem scale.\n", + "- Red dots have *not* solved the problem, blue dots made significant progress (average regret < 0.5)\n", + "- Dashed line shows regret of a random agent = 1.0.\n", + "- We want to see lots of blue dots with low regret for large chain_length." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "3STrnTWrSys2" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "umbrella_length_analysis.plot_learning(umbrella_length_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "InmXA_iKSys5" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average regret through time (lower is better).\n", + "- Dashed line shows the performance of a random agents (regret = 1.0)\n", + "- Look for largest chain_length with performance significantly better than random agent.\n", + "- Curves also show dynamics through time.\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "O1pSwPi-430_" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "umbrella_length_analysis.plot_seeds(umbrella_length_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "u8GX_ZBxNnXe" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kDKk7PhyTEif" + }, + "source": [ + "### Umbrella distract" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2SqqFSKaTEii" + }, + "source": [ + "\"umbrella\n", + "\n", + "\n", + "A stylized problem designed to highlight problems to do with temporal credit assignment and scaling with time horizon.\n", + "\n", + "- The state observation is [need_umbrella, have_umbrella, time_to_go,] + n \"distractor\" features that are iid Bernoulli.\n", + "- At the start of each episode the agent observes if it will need an umbrella.\n", + "- It then has the chance to pick up an umbrella only in the first timestep.\n", + "- At the end of the episode the agent receives a reward of +1 if it made the correct choice of umbrella, but -1 if it made the incorrect choice.\n", + "- During chain_length intermediate steps rewards are random +1 or -1.\n", + "\n", + "The experiment setup:\n", + "- Run umbrella_chain with n_distractor=20 and sweep chain_length=1..100 logarithmically spaced for 10k episodes.\n", + "- Score is percent of tasks with average reward per episode > 0.5.\n", + "- Must log `episode`, `total_return`, `total_regret` for standard analysis." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "fWP2zwM8TEij" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('credit_assignment', 'noise')\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "umbrella_distract_df = DF[DF.bsuite_env == 'umbrella_distract'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'umbrella_distract', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "IiVxaDffTEim" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret after 10k episodes (lower is better)\n", + "umbrella_distract_analysis.plot_scale(umbrella_distract_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_xYIXBJwTEiq" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Compute the average regret after 10k episodes for each chain_length problem scale.\n", + "- Red dots have *not* solved the problem, blue dots made significant progress (average regret < 0.5)\n", + "- Dashed line shows regret of a random agent = 1.0.\n", + "- We want to see lots of blue dots with low regret for large chain_length." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "XZSfnKjcTEir" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "umbrella_distract_analysis.plot_learning(umbrella_distract_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "05vEFGn7TEiv" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average regret through time (lower is better).\n", + "- Dashed line shows the performance of a random agents (regret = 1.0)\n", + "- Look for largest chain_length with performance significantly better than random agent.\n", + "- Curves also show dynamics through time.\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "IFvHvi5H47yH" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "umbrella_distract_analysis.plot_seeds(umbrella_distract_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "TCnnE435NoHv" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5_NxfUeUUTCz" + }, + "source": [ + "### Discounting chain" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O30h3qfmUTC3" + }, + "source": [ + "\"discount\n", + "\n", + "A stylized problem designed to highlight an agent's ability to correctly maximize cumulative rewards without discounting bias.\n", + "- The only decision that actually matters is the agent's *first* of the episode, after which the agent is locked into a \"chain\" irrespective of actions.\n", + "- Each chain gives a non-zero reward only at one step of the length-100 episode: [1, 3, 10, 30, 100] steps.\n", + "- Each chain gives a reward of +1, except for the optimal_horizon, which gives a reward of +1.1\n", + "- Many agents with discounting will struggle to maximize cumulative returns.\n", + "\n", + "The experiment setup:\n", + "- Run each optimal_horizon [1, 3, 10, 30, 100], each with 5 seeds for 1k episodes.\n", + "- Score is average regret * 10.\n", + "- Must log `episode`, `total_return` for standard analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "GpSud5k1UTC4" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('credit_assignment',)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "discounting_chain_df = DF[DF.bsuite_env == 'discounting_chain'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'discounting_chain', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "both", + "id": "l-Qyf4CqUTC8" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret after 1k episodes (lower is better)\n", + "discounting_chain_analysis.plot_average(discounting_chain_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "YaBqIHXQUTDD" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Display the average regret after 10k episodes by optimal_horizon (lower is better)\n", + "- Dashed line shows the performance of a random agents (regret = 0.8)\n", + "- Look for largest horizon with performance significantly better than random agent." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "6JQbVV9dUTDE" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "discounting_chain_analysis.plot_learning(discounting_chain_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "QLri9ZsjUTDJ" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average regret through time (lower is better).\n", + "- Dashed line shows the performance of a random agents (regret = 0.8)\n", + "- Look for largest horizon with performance significantly better than random agent.\n", + "- Curves also show dynamics through time.\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "11uMqmE9484R" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "discounting_chain_analysis.plot_seeds(discounting_chain_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "GEhg1QutNpbb" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3tACBZKzTfNS" + }, + "source": [ + "## Memory\n", + "\n", + "A collection of experiments designed to test memory capabilities." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "F1i-6W76Tiba" + }, + "source": [ + "### Memory length" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Ajm0qATFTibe" + }, + "source": [ + "\"memory\n", + "\n", + "\n", + "A stylized [T-maze](https://en.wikipedia.org/wiki/T-maze) problem designed to highlight an agent's ability to remember important information and use it to make good decisions.\n", + "- At the beginning of the episode the agent is provided a context of +1 or -1.\n", + "- At all future timesteps the context is equal to zero and a countdown until the end of the episode.\n", + "- At the end of the episode the agent must select the correct action corresponding to the context to reward +1 or -1.\n", + "\n", + "The experiment setup:\n", + "- Run memory sizes 1..100 logarithmically spaced.\n", + "- Score is proportion of memory sizes with average regret < 0.5.\n", + "- Must log `episode`, `total_return` for standard analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "8cMpQ1AHTibf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('memory',)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "memory_len_df = DF[DF.bsuite_env == 'memory_len'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'memory_len', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "RH8ko4YFTibi" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title memory scaling (lower + more blue is better)\n", + "memory_len_analysis.plot_scale(memory_len_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "aqTarGL-Tibm" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Compute the average regret after 10k episodes for each memory_length problem scale.\n", + "- Red dots have *not* solved the problem, blue dots made significant progress (average regret < 0.5)\n", + "- Dashed line shows regret of a random agent = 1.0.\n", + "- We want to see lots of blue dots with low regret for large memory_length." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "Gvee-SBNTibn" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "memory_len_analysis.plot_learning(memory_len_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "r3f55zyLTibs" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average regret through time (lower is better).\n", + "- Dashed line shows the performance of a random agents (regret = 1.0)\n", + "- Look for largest memory_length with performance significantly better than random agent.\n", + "- Curves also show dynamics through time.\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "FTxbDm_G8-O9" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "memory_len_analysis.plot_seeds(memory_len_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FPginvBeNqju" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eWua8ocyT5eE" + }, + "source": [ + "### Memory size)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "n5EmxcwJT5eK" + }, + "source": [ + "\"memory\n", + "\n", + "A stylized [T-maze](https://en.wikipedia.org/wiki/T-maze) problem designed to highlight an agent's ability to remember important information and use it to make good decisions.\n", + "- At the beginning of an episode the agent is provided an N bit context vector.\n", + "- After a couple of steps the agent is provided a query as an integer number between `0` and `num_bits-1` and must select the correct action corresponding to `context[query]`.\n", + "\n", + "The experiment setup:\n", + "- Run memory sizes 1..100 logarithmically spaced.\n", + "- Score is proportion of memory sizes with average regret < 0.5.\n", + "- Must log `episode`, `total_return` for standard analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "AVTgmQufT5eM" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tags=('memory',)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title parsing data\n", + "memory_size_df = DF[DF.bsuite_env == 'memory_size'].copy()\n", + "summary_analysis.plot_single_experiment(BSUITE_SCORE, 'memory_size', SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "6-ebdsGrT5eP" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title memory scaling (lower + more blue is better)\n", + "memory_size_analysis.plot_scale(memory_size_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "la_nvowET5eU" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Compute the average regret after 10k episodes for each memory_sizegth problem scale.\n", + "- Red dots have *not* solved the problem, blue dots made significant progress (average regret < 0.5)\n", + "- Dashed line shows regret of a random agent = 1.0.\n", + "- We want to see lots of blue dots with low regret for large memory_sizegth." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "BbdlXbUGT5eV" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title average regret through learning (lower is better)\n", + "memory_size_analysis.plot_learning(memory_size_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FIIFRKiBT5ea" + }, + "source": [ + "**Parsing the plot above:**\n", + "- Learning curves of average regret through time (lower is better).\n", + "- Dashed line shows the performance of a random agents (regret = 1.0)\n", + "- Look for largest memory_length with performance significantly better than random agent.\n", + "- Curves also show dynamics through time.\n", + "- Smoothing is performed with rolling mean over 10% of data with confidence bar at 95% Gaussian standard error." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "cellView": "form", + "id": "-1qX20c_4_JW" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#@title plot performance by seed (higher is better)\n", + "memory_size_analysis.plot_seeds(memory_size_df, SWEEP_VARS).draw();" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fNxUm-A2Nx42" + }, + "source": [ + "**Parsing the plot above:**\n", + "\n", + "- Here we can see the performance of each agent individually through time.\n", + "- Higher scores are better, but individual runs may be noisy.\n", + "- Use this plot to diagnose strange agent behaviour." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "KWdGnbSPIbmd" + }, + "source": [ + "## Exporting as PDF\n", + "\n", + "- Run all colab cells above in `Colaboratory`\n", + "- Run the cell below to download a compressed `images.zip`\n", + "- Copy `images/` in `bsuite/reports/images`\n", + "- Run `bsuite/reports/bsuite_report.tex` to generate a summary pdf report" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "VwAKOdzHfmAr" + }, + "outputs": [], + "source": [ + "import os\n", + "from google.colab import files\n", + "\n", + "# Save images required for the reports in an `images/` folder.\n", + "if not os.path.exists('images'):\n", + " os.makedirs('images')\n", + "\n", + "__radar_fig__.savefig('images/radar_plot.png', bbox_inches=\"tight\")\n", + "\n", + "# Compress folder and download\n", + "!zip -r /images.zip /content/images > /dev/null\n", + "try:\n", + " files.download(\"images.zip\")\n", + "except:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "ds789Mrq5LmR", + "dwIcX62dDnNE", + "vQmNzVbBDqZa", + "_ypLP6DZHZc8", + "GrTjfY11MD5E", + "YtCu7IUwFYOY", + "iKRx2R7DEz5R", + "UQ010l9tFsbG", + "SWm2u8lpFsbK", + "XeeO3UdkHvro", + "BhNvrDHtFsbW", + "PvkWAhKAFsbo", + "_OXjiYVTFsbe", + "zCNVq9M0IEpT", + "U5B77UDjIEpY", + "hPlIUnPgIBb5", + "PweN9CwBIEps", + "-Tbhu6tKIEqG", + "USfDNwCtIEp9", + "tV8NnR1pJIkN", + "NMY_PV_PJWvy", + "Fada-WLrKDdA", + "g_mroLiVK1RE", + "Jpj7JjESSs_J", + "k4S-Q5B5Sysn", + "kDKk7PhyTEif", + "5_NxfUeUUTCz", + "3tACBZKzTfNS", + "F1i-6W76Tiba", + "eWua8ocyT5eE", + "KWdGnbSPIbmd" + ], + "name": "results.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.10" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/pytest.ini b/pytest.ini index c847223f..4a8c8222 100644 --- a/pytest.ini +++ b/pytest.ini @@ -1,6 +1,6 @@ [pytest] -addopts = --ignore=./envs --disable-warnings --showlocals --color=yes -python_files = utest_*.py +addopts = --ignore=./envs --showlocals --color=yes +python_files = utest_comm.py python_functions = test_* testpaths = utests console_output_style = classic diff --git a/setup/setup.py b/setup/setup.py index 616e9276..e087b43a 100644 --- a/setup/setup.py +++ b/setup/setup.py @@ -3,6 +3,7 @@ setup(name='exarl', version='0.0.1', description='ExaRL is a high performance reinforcement learning framework', - install_requires=['tensorflow-gpu>=2.0.0', 'mpi4py', 'gym', 'ase', 'plotille', - 'Lmfit', 'scikit-learn', 'pandas', 'numba', 'pybind11', 'pytest'] + install_requires=['tensorflow-gpu>=2.0.0', 'mpi4py', 'gym==0.15.4', 'ase', 'plotille', + 'Lmfit', 'scikit-learn', 'pandas', 'numba', 'pybind11', 'pytest', + 'pytest-cov'] ) diff --git a/setup/summit_environment.yml b/setup/summit_environment.yml new file mode 100644 index 00000000..d62e7402 --- /dev/null +++ b/setup/summit_environment.yml @@ -0,0 +1,306 @@ +name: exarl_summit +channels: + - file:///sw/sources/open-ce/conda-channel-v1.4.0 + - conda-forge + - https://public.dhe.ibm.com/ibmdl/export/pub/software/server/ibm-ai/conda-early-access/linux-ppc64le/ + - https://public.dhe.ibm.com/ibmdl/export/pub/software/server/ibm-ai/conda-early-access/ + - defaults + - file:///sw/sources/open-ce/conda-channel-v1.1.3 + - file:///sw/sources/open-ce/conda-channel/ + - file:///sw/sources/ibm-wml-ce/conda-channel/ +dependencies: + - _libgcc_mutex=0.1=main + - _pytorch_select=2.0=cuda_2 + - _tensorflow_select=2.0=cuda_2 + - abseil-cpp=20200923.3=h29c3540_0 + - absl-py=0.12.0=py37h6ffa863_0 + - aiohttp=3.7.4.post0=py37h140841e_2 + - arrow-cpp=3.0.0=py37h16b90d4_15_cuda11.0 + - arrow-cpp-proc=3.0.0=cuda + - astunparse=1.6.3=py_0 + - async-timeout=3.0.1=py37h6ffa863_0 + - attrs=21.2.0=pyhd3eb1b0_0 + - av=8.0.3=py37h4eda063_3 + - blas=1.0=openblas + - blinker=1.4=py37h6ffa863_0 + - boost_mp11=1.76.0=h99772c1_2 + - boto=2.49.0=py37_0 + - boto3=1.18.21=pyhd3eb1b0_0 + - botocore=1.21.41=pyhd3eb1b0_1 + - bottleneck=1.3.2=py37heb32a55_1 + - brotli=1.0.9=he6710b0_2 + - brotlipy=0.7.0=py37h140841e_1003 + - bzip2=1.0.8=h7b6447c_0 + - c-ares=1.17.1=h140841e_0 + - ca-certificates=2021.10.8=h1084571_0 + - cached-property=1.5.2=py_0 + - cachetools=4.2.2=pyhd3eb1b0_0 + - cairo=1.16.0=he491a88_1 + - catalogue=2.0.4=py37h6ffa863_0 + - certifi=2021.10.8=py37h35e4cab_1 + - cffi=1.14.6=py37hf9d8e4b_0 + - chardet=4.0.0=py37h6ffa863_1003 + - charset-normalizer=2.0.4=pyhd3eb1b0_0 + - clang=10.0.1=default_hc9b7fb1_0 + - clang-tools=10.0.1=default_hc9b7fb1_0 + - clangdev=10.0.1=default_hc9b7fb1_0 + - clangxx=10.0.1=default_h77df600_0 + - click=7.1.2=pyhd3eb1b0_0 + - cloudpickle=1.6.0=pyhd3eb1b0_0 + - colorama=0.4.4=pyhd3eb1b0_0 + - coverage=5.5=py37h140841e_2 + - cryptography=3.4.8=py37h7ed74fa_0 + - cudatoolkit=11.0.221=h6bb024c_0 + - cudnn=8.1.1_11.0=hf655df6_1 + - cycler=0.11.0=pyhd8ed1ab_0 + - cymem=2.0.5=py37h29c3540_0 + - cython=0.29.24=py37h29c3540_0 + - cython-blis=0.7.4=py37h140841e_1 + - dataclasses=0.8=pyh6d0b6a4_7 + - decorator=5.1.0=pyhd3eb1b0_0 + - dill=0.3.4=pyhd3eb1b0_0 + - dm-tree=0.1.5=py37h00c0e08_4 + - ffmpeg=4.2.2=h20bf706_0 + - filelock=3.0.12=pyhd3eb1b0_1 + - fire=0.4.0=pyhccecc47_0 + - fontconfig=2.13.1=ha0a49a9_0 + - fonttools=4.25.0=pyhd3eb1b0_0 + - freeglut=3.0.0=hf484d3e_5 + - freetype=2.10.4=h5ab3b9f_0 + - fsspec=0.8.7=pyhd3eb1b0_0 + - future=0.18.2=py37_1 + - gast=0.4.0=pyhd3eb1b0_0 + - gflags=2.2.2=he6710b0_0 + - giflib=5.2.1=h7b6447c_0 + - glib=2.69.1=h1318424_0 + - glog=0.5.0=h29c3540_0 + - gmock=1.10.0=h15a1290_2 + - gmp=6.2.1=h29c3540_0 + - gnutls=3.6.15=hd39c10c_0 + - google-api-core=1.25.1=pyhd3eb1b0_0 + - google-auth=1.23.0=pyhd3eb1b0_0 + - google-auth-oauthlib=0.4.4=pyhd3eb1b0_0 + - google-cloud-core=1.6.0=pyhd3eb1b0_0 + - google-cloud-storage=1.40.0=pyhd3eb1b0_0 + - google-crc32c=1.1.2=py37h140841e_0 + - google-pasta=0.2.0=pyhd3eb1b0_0 + - google-resumable-media=1.3.1=pyhd3eb1b0_1 + - googleapis-common-protos=1.52.0=py37h6ffa863_0 + - graphite2=1.3.14=h23475e2_0 + - grpc-cpp=1.36.4=h0cec4b6_pb3.14_3 + - grpcio=1.35.0=py37hedb86c2_1 + - gtest=1.10.0=h15a1290_2 + - h5py=3.2.1=py37hf727584_0 + - harfbuzz=1.8.8=hffaf4a1_0 + - hdf5=1.10.6=hb1b8bf9_0 + - horovod=0.22.1=cuda11.0_system_py37_1 + - huggingface_hub=0.0.16=pyhc556d71_1 + - icu=58.2=he6710b0_3 + - idna=3.2=pyhd3eb1b0_0 + - importlib_metadata=4.8.1=hd3eb1b0_0 + - importlib_resources=5.2.0=pyhd3eb1b0_1 + - jansson=2.13.1=h3275034_0 + - jasper=2.0.14=h07fcdf6_1 + - jinja2=3.0.1=pyhd3eb1b0_0 + - jmespath=0.10.0=pyhd3eb1b0_0 + - joblib=0.17.0=py_0 + - jpeg=9d=h140841e_0 + - keras=2.6.0=pyhddf08d5_1 + - keras-preprocessing=1.1.2=pyhd3eb1b0_0 + - kiwisolver=1.3.2=py37h29c3540_0 + - lame=3.100=h7b6447c_0 + - lcms2=2.12=h2045e0b_0 + - ld_impl_linux-ppc64le=2.33.1=h0f24833_7 + - leveldb=1.20=hf484d3e_1 + - libclang=10.0.1=default_hc9b7fb1_0 + - libclang-cpp=10.0.1=default_hc9b7fb1_0 + - libclang-cpp10=10.0.1=default_hc9b7fb1_0 + - libcrc32c=1.1.1=he6710b0_2 + - libdate=3.0.1=h99772c1_3 + - libevent=2.1.11=hafc74fa_3 + - libffi=3.3=he6710b0_2 + - libgcc-ng=8.2.0=h822a55f_1 + - libgfortran-ng=7.3.0=h822a55f_1 + - libglu=9.0.0=hf484d3e_1 + - libidn2=2.3.2=h140841e_0 + - liblightgbm=3.2.1=hf16effb_3_cuda11.0_system + - libllvm10=10.0.1=h9b6764f_5 + - libllvm11=11.1.0=h621ed2f_0 + - libopenblas=0.3.13=h989ec91_0 + - libopencv=3.4.14=hf70ba83_py37_pb3.14_3 + - libopus=1.3.1=h7b6447c_0 + - libpng=1.6.37=hbc83047_0 + - libprotobuf=3.14.0=h5f94dde_0 + - libstdcxx-ng=8.2.0=h822a55f_1 + - libtasn1=4.16.0=h140841e_0 + - libtensorflow=2.6.0=h4328f3b_cuda11.0_py37_pb3.14_1 + - libthrift=0.15.0=heb2aae8_0 + - libtiff=4.2.0=h781710b_0 + - libunistring=0.9.10=h140841e_0 + - libutf8proc=2.6.1=h140841e_0 + - libuuid=1.0.3=h140841e_2 + - libvpx=1.7.0=hf484d3e_0 + - libwebp=1.2.0=he32dc1f_0 + - libwebp-base=1.2.0=h140841e_0 + - libxcb=1.14=h7b6447c_0 + - libxgboost=1.4.2=cuda11.0_4 + - libxml2=2.9.12=hcd9f32a_0 + - lightgbm=3.2.1=py37hbf25c51_3_cuda11.0_system + - lightgbm-proc=3.2.1=cuda + - llvm-tools=10.0.1=h66086b3_5 + - llvmdev=10.0.1=h66086b3_5 + - llvmlite=0.37.0=py37h29c3540_1 + - lmdb=0.9.29=h29c3540_0 + - lz4-c=1.9.3=h29c3540_1 + - magma=2.5.4=cuda11.0_6 + - markdown=3.3.3=py37h6ffa863_0 + - markupsafe=2.0.1=py37h140841e_0 + - matplotlib=3.4.3=py37h6ffa863_0 + - matplotlib-base=3.4.3=py37he087750_0 + - more-itertools=8.8.0=pyhd3eb1b0_0 + - multidict=5.1.0=py37h140841e_2 + - munkres=1.1.4=pyh9f0ad1d_0 + - murmurhash=1.0.5=py37h29c3540_0 + - nccl=2.8.3=cuda11.0_3 + - ncurses=6.2=he6710b0_1 + - nettle=3.7.3=hdc176a3_1 + - networkx=2.6.2=pyhd3eb1b0_0 + - nlohmann_json=3.9.1=h8ec9abc_3 + - nomkl=3.0=0 + - numactl=2.0.12=h459fe5f_5 + - numba=0.54.1=py37haab0e66_0 + - numexpr=2.7.3=py37h546262a_1 + - numpy=1.19.2=py37h6163131_0 + - numpy-base=1.19.2=py37h75fe3a5_0 + - oauthlib=3.1.1=pyhd3eb1b0_0 + - olefile=0.46=py37_0 + - onnx=1.7.0=h27538de_py37_pb3.14_4 + - onnxconverter-common=1.8.1=py_pb3.14_1 + - onnxmltools=1.9.1=py_pb3.14_1 + - onnxruntime=1.7.2=ha2a263d_cuda11.0_py37_pb3.14_2 + - openblas=0.3.13=h6ffa863_0 + - openblas-devel=0.3.13=h6ffa863_0 + - opencv=3.4.14=py37_pb3.14_3 + - openh264=2.1.0=hd408876_0 + - openssl=1.1.1m=h140841e_0 + - opt_einsum=3.3.0=pyhd3eb1b0_1 + - optional-lite=3.4.0=h99772c1_2 + - orc=1.6.5=hb77ef19_2 + - packaging=21.0=pyhd3eb1b0_0 + - pandas=1.3.3=py37h724cb3c_0 + - pathy=0.5.2=pyhd3eb1b0_0 + - pcre=8.45=h29c3540_0 + - pillow=8.3.1=py37h3f95422_0 + - pip=21.2.2=py37h6ffa863_0 + - pixman=0.40.0=h140841e_1 + - pluggy=0.13.1=py37h6ffa863_0 + - portpicker=1.3.1=py37h6ffa863_0 + - preshed=3.0.5=py37h29c3540_4 + - promise=2.3=py37h6ffa863_0 + - protobuf=3.14.0=py37h29c3540_1 + - psutil=5.8.0=py37h140841e_1 + - py=1.10.0=pyhd3eb1b0_0 + - py-opencv=3.4.14=hfeb2f93_py37_pb3.14_3 + - pyarrow=3.0.0=py37hfa44ca5_15_cuda11.0 + - pyasn1=0.4.8=pyhd3eb1b0_0 + - pyasn1-modules=0.2.8=py_0 + - pycparser=2.20=py_2 + - pydantic=1.8.2=py37h140841e_0 + - pydeprecate=0.3.1=pyhccecc47_1 + - pyjwt=2.1.0=py37h6ffa863_0 + - pyopenssl=20.0.1=pyhd3eb1b0_1 + - pyparsing=2.4.7=pyhd3eb1b0_0 + - pysocks=1.7.1=py37_1 + - pytest=5.4.3=py37h6ffa863_0 + - python=3.7.11=h836d2c2_0 + - python-clang=10.0.1=default_h1154ca9_0 + - python-dateutil=2.8.2=pyhd3eb1b0_0 + - python-flatbuffers=1.12=pyhd3eb1b0_0 + - python_abi=3.7=2_cp37m + - pytorch=1.9.0=cuda11.0_py37_1 + - pytorch-base=1.9.0=h1234567_cuda11.0_py37_pb3.14_1 + - pytorch-lightning=1.4.4=py_1 + - pytorch-lightning-bolts=0.3.4=py_1 + - pytz=2021.1=pyhd3eb1b0_0 + - pyyaml=5.4.1=py37h140841e_1 + - re2=2020.11.01=h29c3540_1 + - readline=8.1=h140841e_0 + - regex=2020.11.13=py37h140841e_0 + - requests=2.26.0=pyhd3eb1b0_0 + - requests-oauthlib=1.3.0=py_0 + - rsa=4.7.2=pyhd3eb1b0_1 + - s3transfer=0.5.0=pyhd3eb1b0_0 + - sacremoses=0.0.45=py_1 + - safeint=3.0.26=h3da053b_3 + - scikit-learn=0.24.2=py37haab0e66_0 + - scipy=1.7.1=py37h45bdd02_2 + - sentencepiece=0.1.91=hd4d1946_py37_pb3.14_7 + - setuptools=50.3.2=py37h6ffa863_2 + - shellingham=1.3.1=pyhd3eb1b0_0 + - six=1.15.0=py37h6ffa863_0 + - skl2onnx=1.9.0=py_pb3.14_1 + - smart_open=3.0.0=py_0 + - snappy=1.1.8=he6710b0_0 + - spacy=3.1.2=py37h329fde5_1 + - spacy-legacy=3.0.8=py_1 + - sqlite=3.36.0=hd7247d8_0 + - srsly=2.4.1=py37h29c3540_0 + - tabulate=0.8.9=py37h6ffa863_0 + - tbb=2021.5.0=h66086b3_0 + - tensorboard=2.6.0=py_pb3.14_1 + - tensorboard-data-server=0.6.1=pyhb80c3c2_1 + - tensorboard-plugin-wit=1.6.0=py_0 + - tensorflow=2.6.0=cuda11.0_py37_1 + - tensorflow-addons=0.14.0=py37he000102_2_cuda11.0 + - tensorflow-addons-proc=0.14.0=cuda + - tensorflow-base=2.6.0=h1234567_cuda11.0_py37_pb3.14_1 + - tensorflow-datasets=4.4.0=h3ec5bd5_py37_pb3.14_1 + - tensorflow-estimator=2.6.0=py_1 + - tensorflow-hub=0.12.0=py_pb3.14_4 + - tensorflow-metadata=1.0.0=py_pb3.14_3 + - tensorflow-model-optimization=0.6.0=py37_1 + - tensorflow-probability=0.14.0=py37_1 + - tensorflow-text=2.6.0=h05bd93f_py37_pb3.14_1 + - termcolor=1.1.0=py37h6ffa863_1 + - tf2onnx=1.9.2=py37he902cde_1 + - thinc=8.0.8=py37h66e1fcb_1 + - threadpoolctl=2.2.0=pyh0d69192_0 + - tk=8.6.11=h7e00dab_0 + - tokenizers=0.10.3=py37h4ba5e45_1 + - torchmetrics=0.5.0=pyh078a8f9_1 + - torchtext=0.10.0=py37_1 + - torchvision=0.10.0=cuda11.0_py37_1 + - torchvision-base=0.10.0=cuda11.0_py37_1 + - tornado=6.1=py37h140841e_0 + - tqdm=4.62.2=pyhd3eb1b0_1 + - transformers=4.9.2=py_pb3.14_1 + - typeguard=2.12.0=py_0 + - typer=0.3.2=pyhd3eb1b0_0 + - typing-extensions=3.7.4.3=hd3eb1b0_0 + - typing_extensions=3.7.4.3=pyh06a4308_0 + - urllib3=1.26.6=pyhd3eb1b0_1 + - uwsgi=2.0.19.1=py37h980472c_3 + - wasabi=0.8.2=pyhd3eb1b0_0 + - wcwidth=0.2.5=pyhd3eb1b0_0 + - werkzeug=1.0.1=pyhd3eb1b0_0 + - wheel=0.37.0=pyhd3eb1b0_1 + - wrapt=1.12.1=py37h7b6447c_1 + - x264=1!157.20191217=h7b6447c_0 + - xgboost=1.4.2=cuda11.0_py37_4 + - xgboost-ext=1.4.2=ha8d749a_4 + - xgboost-proc=1.4.2=cuda + - xz=5.2.5=h7b6447c_0 + - yaml=0.2.5=h7b6447c_0 + - yarl=1.5.1=py37h7b6447c_0 + - zipp=3.5.0=pyhd3eb1b0_0 + - zlib=1.2.11=h7b6447c_3 + - zstd=1.4.9=hc52992f_0 + - pip: + - flake8==4.0.1 + - importlib-metadata==4.2.0 + - mccabe==0.6.1 + - mpi4py==3.1.1 + - plotille==4.0.2 + - pycodestyle==2.8.0 + - pyflakes==2.4.0 +prefix: /ccs/home/${USER}/.conda/envs/exarl_summit diff --git a/utests/README.md b/utests/README.md index aca60e82..c0cb4aeb 100644 --- a/utests/README.md +++ b/utests/README.md @@ -1,60 +1,65 @@ # Unit Testing for ExaRL -A pytest based unit testing is implemented to evaluate ExaRL agents. So far this implementation is limited to a DQN agent in ExaRL. -Using this implementation as an example, more unit test cases can be implemented and unit testing can be extended to evaluate other agents in ExaRL to generalize the unit testing for custom agents. +A pytest based unit testing is implemented to evaluate ExaRL. Our current testing strategy is focused on the base classes of ExaRL +including environments, agents, workflows, communicators, and data structures. ## Unit Test Cases for DQN agent -The pytest framework runs each test case method as an independent instance. Multiple test cases are grouped in a TestClass, as implemented in utest_dqn.py -Each method in TestClass, with a prefix test_*, will be run by the pytest framework as an independent instance. There are 14 such methods in TestClass, each dedicated for a specific unit test case. -* Test case 1: Tests MPI comm initialization -``` -def test_initialize_parameters(self) -``` -* Test case 2: Tests DQN agent's init(), which includes testing correct parameter configuration, and test if the model.compile() (LSTM and MLP) is executed correctly by the DQN agent. -``` -def test_init(self) -``` -* Test case 3: Tests if the set_learner() method of the DQN agent is correctly executed. -``` -def test_set_learner(self) -``` -* Test case 4: Test if remember() method of the DQN agent is correctly executed. -``` -def test_remember(self) -``` -* Test case 5: Tests is get_weights() method returns -``` -def test_get_weights(self) -``` -* Test case 6: Tests set_weights() methods corrects sets weights -``` -def test_set_weights(self) -``` -* Test case 7: Tests action() returns correct action value and policy value -``` -def test_action(self) -``` -* Test case 8: Tests generate_data() yields correctly from memory -``` -def test_generate_data(self) -``` -* Test case 9: Tests train() method to check if model.fit() is executed correctly inside train() by the DQN agent +The pytest framework allows for tests to be divided by file, class, and individual test. +We spread our unit tests across the following files: +* utest_comm.py : This module tests the basic communicator wrappers. It focuses on class members and comm splitting. +* utest_data_structure.py : This module test RMA data structures for correctness. There are some performance tests which can be manually tuned (they are turned off by default). +* utest_env.py : This module can tests the functionality set by openAI gym that is required by ExaRL. +* utest_agent.py : This module tests various members of the ExaRL agent. It checks for required methods, it does not check for correct learning. +* utest_workflow.py : This module tests for correct functionality of a workflow. + +utest_env.py and utest_agent.py designed to help users of ExaRL create correct environment and agents. Each test has configurable arguments which can be set. + +For utest_env.py: +* test_env_name - gym name for test (e.g. ExaCartPoleStatic-v0) +* test_env_class - name of the class for test module (e.g. ExaCartpoleStatic) +* test_env_file - name of the file containing test_env_class omitting the ".py" (e.g. ExaCartpoleStatic) +To use call: ``` -def test_train(self) +./utest_env.py --test_env_name ExaCartPoleStatic-v0 --test_env_class ExaCartpoleStatic --test_env_file ExaCartpoleStatic ``` -* Test case 10: Tests target_train() methods to check if weights are updated +If only test_env_name is given, we assume the environment is already in the gym registry. If no arguments are given a synthetic environment is generated. + +For utest_agent.py: +This is a pytest fixture to add an agent to the agent registry based on command line arguments. +* test_agent_name - gym name for test (e.g. DQN-v0) +* test_agent_class - name of the class for test module (e.g. DQN) +* test_agent_file - name of the file containing test_env_class omitting the ".py" (e.g. dqn) +* test_env_name - gym name for test (e.g. ExaCartPoleStatic-v0) +* test_env_class - name of the class for test module (e.g. ExaCartpoleStatic) +* test_env_file - name of the file containing test_env_class omitting the ".py" (e.g. ExaCartpoleStatic) +* test_save_load_dir - this is the path to a directory to use for testing saving and loading weights +To use call: +``` +pytest ./utest_agent.py --test_agent_name DQN-v0 --test_agent_class DQN --test_agent_file dqn +``` +If the environment parameters are omitted a synthetic environment is generated. + +There are additional flags which can be used for utest_workflow.py +* on-policy - configures how off policy an actor can be before asserting. Set to -1 to just record (default). +* behind - configures how old of data a learner can accept from an actor before asserting. Set to -1 to just record (default). +* rank_sleep - Toggles on/off rank based sleeping scheme for training and stepping. Default is off. +* random_sleep - Toggles on/off random sleeping for training and stepping. Default is off. +To use call: ``` -def test_target_train(self) +pytest ./utest_workflow.py --on-policy 1 --behind 1 --random_sleep ``` -* Test case 11 to Test 14 are implemented to check if abstract methods are implemented in DQN agent. + +## Run +There are many ways to run pytest. The following is a helpful guide: +https://docs.pytest.org/en/7.1.x/how-to/usage.html + +Batch schedulers wrap nicely around pytest: ``` -def test_load(self) # 11 -def test_save(self) # 12 -def test_update(self) # 13 -def test_monitor(self) # 14 +srun -N 1 -n 2 pytest utests/utest_workflow.py ``` +The current test will try to create various configurations of leaners and actors based on the number of ranks provided. If a current node count is not support within a test, it will skip all the tests. This will happen for the utest_env.py test if invoked with only a single rank. All other tests can be run with a single rank, but care should be taken to make sure it is meaningful. For example testing an async learner with only one rank would be problematic. -## Run -The test methods (test_*) are executed by the pytest framework by running 'pytest' command from the ExaRL parent directory (exarl/). +## pytest.ini +The test methods (test_*) can be executed by the pytest framework by running 'pytest' command from the ExaRL parent directory (exarl/). ``` ExaRL/utests % cd .. ExaRL % pytest @@ -64,7 +69,7 @@ The pytest.ini file is a configuration file used by the pytest framework. It inc ``` pytest.ini file -addopts = --ignore=./envs --disable-warnings --showlocals --color=yes --code-highlight=yes +addopts = --ignore=./envs --showlocals --color=yes ``` Other configuration parameters in pytest.ini are: * python_files: It identifies *.py files which are only run by pytest command. @@ -72,31 +77,5 @@ Other configuration parameters in pytest.ini are: * testpaths: It specifies folder names in ExaRL/ which are the only folders run by the pytest command. * Other configurations are dedicated for logging. -The ExaRL/pytest.ini file looks like: -``` -[pytest] -addopts = --ignore=./envs --disable-warnings --showlocals --color=yes --code-highlight=yes -python_files = utest_*.py -python_functions = test_* -testpaths = utests -console_output_style = classic -log_cli = True -log_file_date_format = %Y-%m-%d %H:%M:%S -log_file_format = %(asctime)s %(levelname)s %(message)s -log_file = ./utests/logs/pytest-utest.log -``` ## Integration with Travis CI The pytest framework for unit testing has been integrated with build test framework provided by Travis CI. Consequently, ExaRL/.travis.yml and ExaRL/setup.py files have been updated to take effect. - -## Example Runs -The live status logging for each test case is enabled. This shows whether a test case has PASSED or FAILED. -* When all test cases are PASSED the console output will look like: -![](allpass.png) -* To show a scenario when a test case fails, test_train() is used to check if the train() method in the DQN agent correctly executes model.fit(). This is done by comparing history objects from two different model.fit() runs. The history contains metrics returned by model.fit(). -The following console output shows the failed test and a trace of the error occurred: -![](trainfail1.png) -![](trainfail2.png) - - -This error occurred because two values (such as loss, accuracy, etc) in the history metrics are exactly the same. This is not possible if the model.fit() is setup and run correctly. -The final pytest results for this run shows that 1 test failed, and 13 tests passed. diff --git a/utests/__init__.py b/utests/__init__.py index afed129c..e69de29b 100644 --- a/utests/__init__.py +++ b/utests/__init__.py @@ -1 +0,0 @@ -from exarl.agents.agent_vault.dqn import DQN diff --git a/utests/allpass.png b/utests/allpass.png deleted file mode 100644 index 4a242954..00000000 Binary files a/utests/allpass.png and /dev/null differ diff --git a/utests/conftest.py b/utests/conftest.py new file mode 100644 index 00000000..cf6cd54b --- /dev/null +++ b/utests/conftest.py @@ -0,0 +1,19 @@ +# conftest.py + +def pytest_addoption(parser): + """ + These are the options for all pytests. + See individual tests for meanings. + """ + parser.addoption("--test_env_name", action="store", default=None) + parser.addoption("--test_env_class", action="store", default=None) + parser.addoption("--test_env_file", action="store", default=None) + parser.addoption("--test_agent_name", action="store", default="DQN-v0") + parser.addoption("--test_agent_class", action="store", default="DQN") + parser.addoption("--test_agent_file", action="store", default="dqn") + parser.addoption("--on-policy", action="store", default=-1) + parser.addoption("--behind", action="store", default=-1) + parser.addoption("--rank_sleep", action="store_true", default=False) + parser.addoption("--random_sleep", action="store_true", default=False) + parser.addoption("--test_save_load_dir", action="store", default='./save_load_dir') + parser.addoption("--mpi4py_rc", action="store_false", default=True) diff --git a/utests/learner_cfg.json b/utests/learner_cfg.json deleted file mode 100644 index 204e1f7a..00000000 --- a/utests/learner_cfg.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "agent": "DQN-v0", - "env": "CartPole-v0", - "workflow": "async", - "n_episodes": 10, - "n_steps": 10, - "output_dir": "./results_dir/", - "process_per_env": 1, - "model_type": "LSTM", - "action_type": "variable", - "log_level": 1 -} diff --git a/utests/trainfail1.png b/utests/trainfail1.png deleted file mode 100644 index 2e7c88aa..00000000 Binary files a/utests/trainfail1.png and /dev/null differ diff --git a/utests/trainfail2.png b/utests/trainfail2.png deleted file mode 100644 index 0fae3d77..00000000 Binary files a/utests/trainfail2.png and /dev/null differ diff --git a/utests/utest_agent.py b/utests/utest_agent.py new file mode 100644 index 00000000..cb73b776 --- /dev/null +++ b/utests/utest_agent.py @@ -0,0 +1,995 @@ +import os +import importlib +import pytest +import numpy as np +import gym +from exarl.utils.candleDriver import initialize_parameters +from exarl.utils.globals import ExaGlobals +from exarl.base.comm_base import ExaComm +from exarl.network.simple_comm import ExaSimple +from exarl.base.env_base import ExaEnv +from exarl.envs.env_vault.UnitEvn import EnvGenerator +import exarl.agents +import pickle + +import mpi4py +# Unfortunatly, this line is starting MPI instead of the communicators. +# I can't figure out how to parameterize a fixture from a fixture which +# ultimately causes the problem. +from mpi4py import MPI + +class TestAgentHelper: + """" + This is a helper class with constants used throughout the agent tests. + + Attributes + ---------- + dqn_args : dictionary + These are required arguments from dqn config + ddpg_args : dictionary + These are required arguments from ddpg config + ac_args : dictionary + These are the actor critic arguments for ddpg + lstm_args : dictionary + These are the arguments for lstm from config + mlp_args : dictionary + These are the arguments for mlp from config + model_types : dictionary + This is used to pass different models as parameters to fixtures + priority_scale : list + List of numbers between 0 and 1 representing priority scale. + max_attempts : int + Max amount of times to test behavior + """ + + dqn_args = { + "gamma": 0.75, + "epsilon": 0.9, + "epsilon_min": 0.01, + "epsilon_decay": 0.999, + "learning_rate": 0.001, + "batch_size": 5, + "tau": 0.5, + "nactions": 10, + "priority_scale": 0.0, + "buffer_capacity": 1000, + "xla": "True" + } + + ddpg_args = { + "epsilon": 1.0, + "epsilon_min": 0.01, + "epsilon_decay": 0.999, + "gamma": 0.99, + "tau": 0.005, + "batch_size": 64, + "buffer_capacity": 50000 + } + + ac_args = { + "actor_lr": 0.001, + "actor_dense_act": "relu", + "actor_dense": [256, 256], + "actor_out_act": "tanh", + "actor_optimizer": "adam", + "critic_lr": 0.002, + "critic_state_dense": [16, 32], + "critic_state_dense_act": "relu", + "critic_action_dense": [32], + "critic_action_dense_act": "relu", + "critic_concat_dense": [256, 256], + "critic_concat_dense_act": "relu", + "critic_out_act": "linear", + "critic_optimizer": "adam", + "loss": "mse", + "std_dev": 0.2 + } + + lstm_args = { + "dense": [64, 128], + "optimizer": "adam", + "loss": "mse", + "lstm_layers": [56, 56, 56], + "activation": "tanh", + "gauss_noise": [0.1, 0.1, 0.1], + "out_activation": "linear", + "regularizer": [0.001, 0.001], + "clipnorm": 1.0, + "clipvalue": 0.5 + } + + mlp_args = { + "dense": [64, 128], + "activation": "relu", + "optimizer": "adam", + "out_activation": "linear", + "loss": "mse" + } + + model_types = {"LSTM": lstm_args, "MLP": mlp_args} + priority_scale = [0.0, 1.0] + max_attempts = 100 + + def get_configs(): + """ + This is a generator that spits out configurations of learners, agents, and procs per agent. + This is used to generate tests for split. If there are no configurations (i.e. size=1) + then nothing will be returned and the test will be skipped + + Returns + ------- + Pair + Number of learners and proccesses per environment for comm setup + """ + size = mpi4py.MPI.COMM_WORLD.Get_size() + yield 1, size + for num_learners in range(1, size): + rem = size - num_learners + # Iterate over all potential procs_per_env counts + for i in range(0, rem): + # Add one since we want the size of the env_count not index + procs_per_env = i + 1 + # Does it fit, then return it + if rem % procs_per_env == 0: + yield num_learners, procs_per_env + + def compare_weights(a, b): + """ + This is a helper function is used to compare weights. + + Attributes + ---------- + a : np.array + Weights to compare + b : np.array + Weights to comapre + + Returns + ------- + Bool + True if identical, false otherwise + """ + if len(a) != len(b): + return False + for i, j in zip(a, b): + if not np.array_equal(i, j): + return False + return True + + def make_weights_from_old_weights(weights): + """ + This is a helper function creates a new list of weights based on the + size and type of the old ones. The new ones will be filled with the + index of their position in the list. + + Attributes + ---------- + weights : List + List of old weights + + Returns + ------- + Bool + True if identical, false otherwise + """ + new_weights = [] + for i, some_array in enumerate(weights): + new_weights.append(np.full_like(some_array, i)) + return new_weights + +@pytest.fixture(scope="session") +def mpi4py_rc(pytestconfig): + """ + This function sets up the mpi4py import. + + Attributes + ---------- + pytestconfig : + Parameters passed from pytest. + """ + mpi_flag = pytestconfig.getoption("mpi4py_rc") + initialize_parameters(params={"mpi4py_rc": mpi_flag, + "log_level": [3, 3]}) + +@pytest.fixture(scope="session", params=list(TestAgentHelper.get_configs())) +def init_comm(request, mpi4py_rc): + """ + This sets up a comm to test agent with. This test must be run + with at least two ranks. + + Attributes + ---------- + request : + This is the parameter from fixture decorator. Use request.param to get value. + Each request.param is a tuple of Number of learners and Process per environment + configuration. + + Returns + ------- + Pair + Number of learners and proccesses per environment for comm setup + """ + num_learners, procs_per_env = request.param + ExaSimple(None, procs_per_env, num_learners) + assert ExaComm.num_learners == num_learners + assert ExaComm.procs_per_env == procs_per_env + yield num_learners, procs_per_env + + ExaComm.reset() + assert ExaComm.global_comm is None + assert ExaComm.agent_comm is None + assert ExaComm.env_comm is None + assert ExaComm.num_learners == 1 + assert ExaComm.procs_per_env == 1 + +@pytest.fixture(scope="session") +def registered_environment(pytestconfig, init_comm): + """ + This is a pytest fixture to add an environment to the gym registry based on command line arguments. + The parser comes from conftest.py. We require: + test_env_name - gym name for test (e.g. ExaCartPoleStatic-v0) + test_env_class - name of the class for test module (e.g. ExaCartpoleStatic) + test_env_file - name of the file containing test_env_class omitting the ".py" (e.g. ExaCartpoleStatic) + To use call pytest ./utest_env.py --test_env_name ExaCartPoleStatic-v0 --test_env_class ExaCartpoleStatic --test_env_file ExaCartpoleStatic + If only test_env_name is given, we assume the environment is already in the gym registry. + If no arguments are given an synthetic environment is generated. + The scope is set to session as to only add to the gym registry once per pytest session (run). + In order to make sure that environments are not re-registered for a given configuration, + we form a cantor pair from the number of learners and the processes per environment + https://en.wikipedia.org/wiki/Pairing_function#Cantor_pairing_function. + + Parameters + ---------- + pytestconfig : + Hook for pytest argument parser + init_comm : pair + Number of learners and the proccesses per environment coming from init_comm fixture + + Returns + ------- + String + Returns the new environment name that was registered + """ + env_name = pytestconfig.getoption("test_env_name") + env_class = pytestconfig.getoption("test_env_class") + env_file_name = pytestconfig.getoption("test_env_file") + if env_name is not None: + if env_class is not None and env_file_name is not None: + entry = getattr(importlib.import_module("exarl.envs.env_vault." + env_file_name), env_class) + # Assume it is already in the gym registry + else: + return env_name + else: + entry = EnvGenerator.createClass("Discrete", "Box", False, False, True, 75, 20) + env_name = entry.name + + # Cantor pair + num_learners, procs_per_env = init_comm + cantor_pair = int(((num_learners + procs_per_env) * (num_learners + procs_per_env + 1)) / 2 + procs_per_env) + + # We are going to strip of the v0 and instead add vCommSize + # This doesn't matter since we are consistent with the name within the test + temp = env_name.split("-") + if len(temp) > 1: + temp.pop() + temp.append("v" + str(cantor_pair)) + env_name = "-".join(temp) + gym.envs.registration.register(id=env_name, entry_point=entry) + return env_name + +@pytest.fixture(scope="session") +def registered_synth_environment(): + """ + This is a pytest fixture to add synthetic environment to the gym registry. + All synthetic environments will have -v0 + """ + for env in EnvGenerator.generator(): + gym.envs.registration.register(id=env.name, entry_point=env) + +@pytest.fixture(scope="session") +def registered_agent(pytestconfig, init_comm): + """ + This is a pytest fixture to add an agent to the agent registry based on command line arguments. + The parser comes from conftest.py. We require: + test_agent_name - gym name for test (e.g. DQN-v0) + test_agent_class - name of the class for test module (e.g. DQN) + test_agent_file - name of the file containing test_env_class omitting the ".py" (e.g. dqn) + To use call pytest ./utest_agent.py --test_agent_name DQN-v0 --test_agent_class DQN --test_agent_file dqn + The scope is set to session as to only add to the registry once per pytest session (run). + In order to allow for multiple agents of the same class but with different comm configs, we pass in + a cantor pair of the number of learners and process per environment and append that to the name of the agent. + + Parameters + ---------- + pytestconfig : + Hook for pytest argument parser + init_comm : pair + The number of learners and process per environment + + Returns + ------- + String + Returns the environment name that was passed in to command line + """ + agent_name = pytestconfig.getoption("test_agent_name") + agent_class = pytestconfig.getoption("test_agent_class") + agent_file_name = pytestconfig.getoption("test_agent_file") + entry = getattr(importlib.import_module("exarl.agents.agent_vault." + agent_file_name), agent_class) + + # Cantor pair + num_learners, procs_per_env = init_comm + cantor_pair = int(((num_learners + procs_per_env) * (num_learners + procs_per_env + 1)) / 2 + procs_per_env) + + # We are going to strip of the v0 and instead add vCommSize + # This doesn't matter since we are consistent with the name within the test + temp = agent_name.split("-") + if len(temp) > 1: + temp.pop() + temp.append("v" + str(cantor_pair)) + agent_name = "-".join(temp) + exarl.agents.registration.register(id=agent_name, entry_point=entry) + + return agent_name + +@pytest.fixture(scope="function", params=TestAgentHelper.model_types.keys()) +def run_params(request): + """ + Attempt to set candle drivers run_params. We set this up instead of the + candle driver. + + Parameters + ---------- + request : + This is the parameter from fixture decorator. Use request.param to get value. + Model types are passed in as request.param. + """ + ExaGlobals.set_param('output_dir', "./test") + ExaGlobals.set_params(TestAgentHelper.dqn_args) + ExaGlobals.set_param("model_type", request.param) + ExaGlobals.set_params(TestAgentHelper.model_types[request.param]) + return request.param + +@pytest.fixture(scope="function") +def agent(registered_agent, registered_environment, run_params): + """ + This fixture generates an new agent from the agent registry. + Parameters + ---------- + registered_agent : String + Names of agent to create passed in from fixture + registered_environment : String + Name of environment to create passed in from fixture + run_params : None + Ensures run_params fixture runs before this + + Returns + ------- + ExaAgent + Returns an agent to test + """ + env = ExaEnv(gym.make(registered_environment).unwrapped) + agent = None + if ExaComm.is_agent(): + agent = exarl.agents.make(registered_agent, env=env, is_learner=ExaComm.is_learner()) + return agent + +@pytest.fixture(scope="function") +def agent_with_priority_scale(registered_agent, registered_environment, run_params, request): + """ + This fixture generates an new agent from the agent registry. This fixture also + sets the candleDriver parameter priority_scale which is used in the train + set_priorities functions. + Parameters + ---------- + registered_agent : String + Names of agent to create passed in from fixture + registered_environment : String + Name of environment to create passed in from fixture + run_params : None + Ensures run_params fixture runs before this + request : float + request.param is the value to set for priority_scale + + Returns + ------- + ExaAgent + Returns an agent to test + """ + ExaGlobals.set_param("priority_scale", request.param) + env = ExaEnv(gym.make(registered_environment).unwrapped) + agent = None + if ExaComm.is_agent(): + agent = exarl.agents.make(registered_agent, env=env, is_learner=ExaComm.is_learner()) + return agent + +@pytest.fixture(scope="function") +def pre_agent(registered_agent, registered_synth_environment, run_params, request): + """ + This fixture is used for testing synthetic creation. It returns the name + of the agent (given via command line) as well as an environment passed in as request. + This is done via indirect=True being set on @pytest.mark.parametrize: + (e.g. @pytest.mark.parametrize("pre_agent", list(EnvGenerator.getNames()), indirect=True) ) + + Parameters + ---------- + registered_agent : String + Name of agent to be created passed in from fixture + registered_synth_environment : None + Ensures all synthetic environments have been registered via fixture + run_params : None + Ensures run_params fixture runs before this + request : String + request.param is the name of the synthetic environment to create + + Returns + ------- + Pair + Name of the agent to build and a environment + """ + env = ExaEnv(gym.make(request.param).unwrapped) + return registered_agent, env + +@pytest.fixture(scope="function") +def agent_with_synth_env(registered_agent, registered_synth_environment, run_params, request): + """ + This fixture generates an new agent from the agent registry with an environment. + The environment is passed via request allowing it to be passed by setting + indirect=True being in @pytest.mark.parametrize: + (e.g. @pytest.mark.parametrize("syth_agent", listOfEnvs, indirect=True) ) + This allows us to test other environments than what we passed in on command line. + Ultimately the list that should be passed in is the list of synthetic environments. + + Parameters + ---------- + registered_agent : String + Names of agent to create passed in from fixture + registered_synth_environment : None + Ensures all synthetic environments have been registered via fixture + run_params : None + Ensures run_params fixture runs before this + request : + request.param is the name of the synthetic environment to create + + Returns + ------- + ExaAgent + Returns an agent to test + """ + env = ExaEnv(gym.make(request.param).unwrapped) + agent = None + if ExaComm.is_agent(): + agent = exarl.agents.make(registered_agent, env=env, is_learner=ExaComm.is_learner()) + return agent + +@pytest.fixture(scope="session") +def save_load_dir(init_comm, pytestconfig): + """ + This fixture creates a directory to store saved weights in. + It is created once a session and torn down at the end. + The barriers are to make sure all ranks are synchronized prior + to file/dir creation and descruction. The temp directory for + storing and loading weights can be changed by the + --test_save_load_dir option. By default it will write to + ./save_load_dir. + + Example: + pytest ./utest_env.py --test_save_load_dir /path/to/my/dir + + Parameters + ---------- + init_comm : pair + Ensures the comms are initialized before running + + Returns + ------- + String + Directory to use + """ + rank = ExaComm.global_comm.rank + made_dir = False + dir_name = pytestconfig.getoption("test_save_load_dir") + if rank == 0 and not os.path.isdir(dir_name): + os.mkdir(dir_name) + made_dir = True + + ExaComm.global_comm.barrier() + yield dir_name + + ExaComm.global_comm.barrier() + if made_dir: + os.rmdir(dir_name) + +@pytest.fixture(scope="function") +def save_load_file(save_load_dir): + """ + This fixture returns the file name needed to test save and load + weights. On tear down the file is removed from the save_load_dir. + This is called for each function requiring save_load_file. + + Parameters + ---------- + save_load_dir : String + Dir where to add file. + + Returns + ------- + String + Filename to use + """ + rank = ExaComm.global_comm.rank + file_name = save_load_dir + "/weights_" + str(rank) + ".dump" + yield file_name + + if os.path.isfile(file_name): + os.remove(file_name) + + +class TestAgentMembers: + + @pytest.mark.skip(reason="This is a really long test... Fails because agent models are broken!!!") + @pytest.mark.parametrize("pre_agent", list(EnvGenerator.getNames()), indirect=True) + def test_agent_creation(self, pre_agent): + """ + Tests the initialization of synthetic agents. The synthetic agents iterate over all possible + gym action/observation space combinations. This will test the agents ability to handle creating + a model (mlp/lstm) for such spaces. + + Parameters + ---------- + pre_agent : Pair + Agent name and environment to create. + """ + agent_name, env = pre_agent + agent = None + if ExaComm.is_agent(): + agent = exarl.agents.make(agent_name, env=env, is_learner=ExaComm.is_learner()) + assert agent.is_learner == ExaComm.is_learner() + else: + assert agent is None + + def test_init(self, agent): + """ + Tests the initialization of agents relative to comm. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + """ + if ExaComm.is_agent(): + assert agent.is_learner == ExaComm.is_learner() + assert hasattr(agent, 'batch_size') + else: + assert agent is None + + def test_get_weights(self, agent): + """ + Test getting weights from an agent. Currently get weights calls + into tensorflow get_weights + (https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer#get_weights). + To check, we are asserting we get a list of numpy arrays. + A better check would be to assert the size and length of these array + but no sure what the values should be. + TODO: Figure out dimensions... + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'get_weights') + assert callable(getattr(agent, 'get_weights')) + weights = agent.get_weights() + assert isinstance(weights, list) + # if run_params == 'MLP': + # assert len(weights) == len(TestAgentHelper.mlp_args["dense"]) + # elif run_params == 'LSTM': + # assert len(weights) == len(TestAgentHelper.lstm_args["lstm_layers"]) + # else: + # assert False, "Unclear the number of layers of ml model for " + run_params + # TODO: Check the length of each np.array + for layer_weights in weights: + assert isinstance(layer_weights, np.ndarray) + else: + assert agent is None + + def test_set_weights(self, agent): + """ + Test set target model weights. This test works by getting weights, + setting arbitrary values for "new" weights, updating, and then + re-calling get to see if the new return equals the set values. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'set_weights') + assert callable(getattr(agent, 'set_weights')) + # Get old weights + weights = agent.get_weights() + # Make new weights + new_weights = TestAgentHelper.make_weights_from_old_weights(weights) + # Set weights + agent.set_weights(new_weights) + # Check weights + to_check = agent.get_weights() + assert TestAgentHelper.compare_weights(new_weights, to_check) + else: + assert agent is None + + def test_save(self, agent, save_load_file): + """ + Tests save weights. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + save_load_file : String + Name of weights file from fixture + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'save') + assert callable(getattr(agent, 'save')) + + weights = agent.get_weights() + agent.save(save_load_file) + assert os.path.isfile(save_load_file) + with open(save_load_file, 'rb') as f: + read_weights = pickle.load(f) + # Strip off layer name from save file + # read_weights = [x[1] for x in read_weights] + # assert len(weights) == len(read_weights) + # for i, j in zip(weights, read_weights): + # assert np.array_equal(i, j) + assert TestAgentHelper.compare_weights(weights, read_weights) + else: + assert agent is None + + def test_load(self, agent, save_load_file): + """ + Tests loading weights. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + save_load_file : String + Name of weights file from fixture + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'load') + assert callable(getattr(agent, 'load')) + + # Get old weights + old_weights = agent.get_weights() + # Make new weights + new_weights = TestAgentHelper.make_weights_from_old_weights(old_weights) + # Set new weights, save, check file exists + agent.set_weights(new_weights) + agent.save(save_load_file) + assert os.path.isfile(save_load_file) + # Reset old weights and check set + agent.set_weights(old_weights) + to_check = agent.get_weights() + assert TestAgentHelper.compare_weights(old_weights, to_check) + # Load weights and check + agent.load(save_load_file) + to_check = agent.get_weights() + assert TestAgentHelper.compare_weights(new_weights, to_check) + else: + assert agent is None + + def test_has_data(self, agent): + """ + This tests that has_data returns false when the agent + is first initialized. Testing if has_data == True is + tested under test_remember. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'has_data') + assert callable(getattr(agent, 'has_data')) + assert agent.has_data() == False + else: + assert agent is None + + def test_remember(self, agent, max_attempts=TestAgentHelper.max_attempts): + """ + This tests that the remember function stores entries up to + max_add times. We verify using has_data method. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + max_attempts : int + Max number of entries to add + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'remember') + assert callable(getattr(agent, 'remember')) + + assert agent.has_data() == False + for i in range(max_attempts): + state = agent.env.observation_space.sample() + next_state = agent.env.observation_space.sample() + action = agent.env.action_space.sample() + reward = 100 + done = False + + agent.remember(state, action, reward, next_state, done) + assert agent.has_data() == True + else: + assert agent is None + + def test_generate_data_size(self, agent, max_attempts=TestAgentHelper.max_attempts): + """ + This tests that the return of generate_data. When there is no + data stored, generate data outputs fake data. This is to setup + RMA windows for data structures. This test checks that the size + of the fake data is >= the size of real data. Sometimes the size + issue is related to how pickle operates. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + max_attempts : int + Max number of entries to add + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'generate_data') + assert callable(getattr(agent, 'generate_data')) + assert hasattr(agent, 'batch_size') + + data = next(agent.generate_data()) + pickle_empty_data = pickle.dumps(data) + for i in range(max_attempts): + for j in range(agent.batch_size): + state = agent.env.observation_space.sample() + next_state = agent.env.observation_space.sample() + action = agent.env.action_space.sample() + reward = 100 + done = False + agent.remember(state, action, reward, next_state, done) + + data = next(agent.generate_data()) + pickle_full_data = pickle.dumps(data) + assert len(pickle_empty_data) >= len(pickle_full_data) + else: + assert agent is None + + def test_generate_data_small(self, agent): + """ + This tests that the return of generate_data when the data is less + than the batch size. When there is no data stored, generate data + outputs fake data. This test checks that the size of the fake + data is > the size of real data. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'batch_size') + + data = next(agent.generate_data()) + pickle_empty_data = pickle.dumps(data) + for i in range(agent.batch_size - 1): + state = agent.env.observation_space.sample() + next_state = agent.env.observation_space.sample() + action = agent.env.action_space.sample() + reward = 100 + done = False + agent.remember(state, action, reward, next_state, done) + + data = next(agent.generate_data()) + pickle_full_data = pickle.dumps(data) + assert len(pickle_empty_data) > len(pickle_full_data) + else: + assert agent is None + + @pytest.mark.parametrize("agent_with_priority_scale", TestAgentHelper.priority_scale, indirect=True) + def test_train(self, agent_with_priority_scale): + """ + This tests to see if there is a train method and its return values. + The return value passes back the indices and lost if scale_priority + is set greater than 0. We check to see that the number of indices + matches the total amount of data. Only learner is able to call train. + + Parameters + ---------- + agent_with_priority_scale : ExaAgent + Agent to test from fixture with priority_scale set + """ + agent = agent_with_priority_scale + if ExaComm.is_agent(): + assert hasattr(agent, 'train') + assert callable(getattr(agent, 'train')) + assert hasattr(agent, 'priority_scale') + + if ExaComm.is_learner(): + for i in range(agent.batch_size): + state = agent.env.observation_space.sample() + next_state = agent.env.observation_space.sample() + action = agent.env.action_space.sample() + reward = 100 + done = False + agent.remember(state, action, reward, next_state, done) + data = next(agent.generate_data()) + if agent.priority_scale != 0.0: + assert len(data) == 4 + assert len(data[2]) == i + 1 + else: + assert len(data) == 2 + + ret = agent.train(data) + if agent.priority_scale != 0.0: + assert len(ret) == 2 + assert len(ret[0]) == i + 1 + else: + assert ret is None + else: + assert agent is None + + def test_update_target(self, agent): + """ + This tests the functionality of target train. + Target train uses the agents tau to update the + weights of the target model. Only the learner + will update the weights. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'update_target') + assert callable(getattr(agent, 'update_target')) + assert hasattr(agent, 'tau') + assert agent.tau > 0 + + if ExaComm.is_learner(): + old_weights = agent.get_weights() + agent.update_target() + weights = agent.get_weights() + assert not TestAgentHelper.compare_weights(weights, old_weights), "Weights should have changed" + else: + assert agent is None + + def test_for_changing_weights(self, agent, max_attempts=TestAgentHelper.max_attempts): + """ + This test is used to see if the agent can "learn." We check + this by passing data coming from generate data to the train + function and compare the new weights. Problem is weights are + only updated to the target model when target trained is called. + Previous tests shows target train is guaranteed to change the + weights. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + max_attempts : int + Max number of times to test weight changes + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'train') + assert callable(getattr(agent, 'train')) + + if ExaComm.is_learner(): + for j in range(max_attempts): + for i in range(agent.batch_size): + state = agent.env.observation_space.sample() + next_state = agent.env.observation_space.sample() + action = agent.env.action_space.sample() + reward = 100 + done = False + agent.remember(state, action, reward, next_state, done) + + data = next(agent.generate_data()) + old_weights = agent.get_weights() + agent.train(data) + # This masks the test but we have to do it for now... + agent.update_target() + weights = agent.get_weights() + assert not TestAgentHelper.compare_weights(weights, old_weights), "Weights should have changed" + else: + assert agent is None + + def do_actions(self, agent, max_attempts): + """ + This function tests the action method of an agent. Action will perform inference + using its internal model and will return an appropriate action to take. We test + that the action is "correct" by ensuring that it is part of the action space. + The contains method given by gym checks both the type and if the action falls + within the bounds of a given space. + + Parameters + ---------- + agent : ExaAgent + Agent to test + max_attempts : int + The number of times to check actions + """ + if ExaComm.is_agent(): + assert hasattr(agent, 'action') + assert callable(getattr(agent, 'action')) + assert hasattr(agent, "env") + + env = agent.env + assert hasattr(env, "action_space") + assert isinstance(env.action_space, gym.Space) + + for i in range(max_attempts): + action, policy_type = agent.action(env.observation_space.sample()) + assert env.action_space.contains(action) + + else: + assert agent is None + + def test_action(self, agent, max_attempts=TestAgentHelper.max_attempts): + """ + This test check the action method ensuring the given action is appropriate. + This will test the environment passed in at command line or the default. + + Parameters + ---------- + agent : ExaAgent + Agent to test from fixture + max_attempts : int + The number of times to check actions + """ + self.do_actions(agent, max_attempts) + + @pytest.mark.skip(reason="This is a really long test... Fails because agent models are broken!!!") + @pytest.mark.parametrize("agent_with_synth_env", list(EnvGenerator.getNames()), indirect=True) + def test_action_synth(self, agent_with_synth_env, max_attempts=TestAgentHelper.max_attempts): + """ + This test check the action method ensuring the given action is appropriate. + This will test the environment passed in at command line or the default. + We are using the synthetic environments to test what type of gym spaces + the agent can handle. + + Parameters + ---------- + agent_with_synth_env : ExaAgent + Agent to test from fixture with synthetic environment + max_attempts : int + The number of times to check action + """ + self.do_actions(agent_with_synth_env, max_attempts) + + @pytest.mark.parametrize("agent_with_priority_scale", TestAgentHelper.priority_scale, indirect=True) + def test_set_priorities(self, agent_with_priority_scale): + """ + This tests to see if there is a set_priorities method. This method + is to support experience replay. The agent must internally use + the priorities to adjust the values of the chosen by generate data. + To test that the priorities are being reflected, we need to test + the priority replay buffers. To try to infer what is being passed + back by the agent is too difficult to due at this level. + TODO: Create priority replay unit tests. + + Parameters + ---------- + agent_with_priority_scale : ExaAgent + Agent to test from fixture with priority_scale set + """ + agent = agent_with_priority_scale + if ExaComm.is_agent(): + assert hasattr(agent, 'set_priorities') + assert callable(getattr(agent, 'set_priorities')) + assert hasattr(agent, "buffer_capacity") + else: + assert agent is None diff --git a/utests/utest_comm.py b/utests/utest_comm.py new file mode 100644 index 00000000..988d6d1f --- /dev/null +++ b/utests/utest_comm.py @@ -0,0 +1,396 @@ +import pytest +from exarl.utils.globals import ExaGlobals +from exarl.utils.candleDriver import initialize_parameters +from exarl.base.comm_base import ExaComm +from exarl.network.simple_comm import ExaSimple +from exarl.network.mpi_comm import ExaMPI + +import mpi4py +# Unfortunatly, this line is starting MPI instead of the communicators. +# I can't figure out how to parameterize a fixture from a fixture which +# ultimately causes the problem. +from mpi4py import MPI + +class TestCommHelper: + """" + This is a helper class with constants used throughout the comm tests. + + Attributes + ---------- + comm_types : list + List of comm types to test + """ + comm_types = [ExaSimple, ExaMPI] + + def get_configs(): + """ + This is a generator that spits out configurations of learners, agents, and procs per agent. + This is used to generate tests for split. If there are no configurations (i.e. size=1) + then nothing will be returned and the test will be skipped + + Returns + ------- + Pair + Number of learners and proccesses per environment for comm setup + """ + size = MPI.COMM_WORLD.Get_size() + yield 1, size + for num_learners in range(1, size): + rem = size - num_learners + # Iterate over all potential procs_per_env counts + for i in range(0, rem): + # Add one since we want the size of the env_count not index + procs_per_env = i + 1 + # Does it fit, then return it + if rem % procs_per_env == 0: + yield num_learners, procs_per_env + +@pytest.fixture(scope="session") +def mpi4py_rc(pytestconfig): + """ + This function sets up the mpi4py import. + + Attributes + ---------- + pytestconfig : + Parameters passed from pytest. + """ + mpi_flag = pytestconfig.getoption("mpi4py_rc") + initialize_parameters(params={"mpi4py_rc": mpi_flag, + "log_level": [3, 3]}) + return mpi_flag + +@pytest.fixture(scope="function", autouse=True) +def reset_comm(mpi4py_rc): + """ + This decorator is used to reset the comm before each function + """ + ExaComm.reset() + assert ExaComm.global_comm is None + assert ExaComm.agent_comm is None + assert ExaComm.env_comm is None + assert ExaComm.num_learners == 1 + assert ExaComm.procs_per_env == 1 + +class TestEnvMembers: + """ + This class test the basic functionality of the ExaComm class. + These tests focus on testing the make up of a comm as well + as its initialization. + We are omitting test for the message passing and synchronization + for now. + TODO: Write tests for general functionality! + """ + + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_MPI_flags(self, comm, mpi4py_rc): + """ + THIS TEST IS TO CHECK THAT THE MPI LAYERS SET THE FOLLOWING FLAGS!!! + In reality this test will look to see the first comm imported and + if it sets these flags. Subsequent imports will not help. I am + unsure how to unload and reload modules in meaningful way such that + it resets these flags. This is why I have the simple_comm loaded + before mpi_comm or mpi4py since it is the comm that is used 99% of + the time. If this test fails, PUT THE FLAGS BACK ON! + + Parameters + ---------- + comm : ExaComm + Type of comm to test + """ + acomm = comm(None, 1, 1) + assert mpi4py.rc.threads == mpi4py_rc + assert mpi4py.rc.recv_mprobe == mpi4py_rc + + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_has_MPI(self, comm): + """ + Tests that each class has a static member called MPI. + Comms using MPI should be the first to import mpi4py + as certain systems require: + mpi4py.rc.threads = False + mpi4py.rc.recv_mprobe = False + When other files need to use the raw MPI than can + access this or the raw method if they have a ExaComm + instance. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + """ + assert hasattr(comm, "MPI") + acomm = comm(None, 1, 1) + assert isinstance(comm.MPI, type(mpi4py.MPI)) + assert isinstance(comm.MPI.COMM_WORLD, mpi4py.MPI.Comm) + + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_raw(self, comm): + """ + Test the raw member of the ExaComm class. Raw + give access to mpi4py's MPI. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + """ + acomm = comm(None, 1, 1) + assert isinstance(acomm.raw(), mpi4py.MPI.Comm) + + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_has_size(self, comm): + """ + Test the size of a vanilla comm. Compares against + the global comm size. Splits will occur on the + static members of ExaComm. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + """ + a_comm = comm(None, 1, 1) + assert hasattr(a_comm, "size") + assert isinstance(a_comm.size, int) + assert a_comm.size == mpi4py.MPI.COMM_WORLD.Get_size() + + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_has_rank(self, comm): + """ + Test the rank of a vanilla comm. Compares against + the global comm rank. Splits will occur on the + static members of ExaComm. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + """ + a_comm = comm(None, 1, 1) + assert hasattr(a_comm, "rank") + assert isinstance(a_comm.size, int) + assert a_comm.rank == mpi4py.MPI.COMM_WORLD.Get_rank() + + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_comm_empty_init(self, comm): + """ + Checks the static member of ExaComm after a + vanilla comm. We don't check agent_comm and env_comm + because 1 learner and 1 agent is only valid for 2 rank + case and we should be running more ranks to test. + The rest of the parameters are tested in test_comm_split. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + """ + comm(None, 1, 1) + assert isinstance(ExaComm.global_comm, ExaComm) + assert hasattr(ExaComm.global_comm, "rank") + assert hasattr(ExaComm.global_comm, "size") + assert ExaComm.num_learners == 1 + assert ExaComm.procs_per_env == 1 + + @pytest.mark.parametrize("num_learners, procs_per_env", list(TestCommHelper.get_configs())) + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_comm_split(self, comm, num_learners, procs_per_env): + """ + Ranks should be divided into three parts: + Learner - Number of learners (continuous ranks) + Agent - Number of agents (1 per environment group + 1 per learner) + Environment - Number per agent + + The following is an example of how ranks should be layed + out assuming 14 ranks (2 Learners, 5 Agents, 4 Environment) + Rank 0 1 2 3 4 5 6 7 8 9 10 11 12 13 + L 0 1 - - - - - - - - - - - - + A 0 1 2 - - - 3 - - - 4 - - - + E - - 0 1 2 3 0 1 2 3 0 1 2 3 + + This is also a valid rank for sync workflow. + Rank 0 1 2 3 + L 0 - - - + A 0 - - - + E 0 1 2 3 + + Parameters + ---------- + comm : ExaComm + Type of comm to test + num_learners : int + Number of learners to create + procs_per_env : int + Number of ranks per env/agent to create + """ + rank = mpi4py.MPI.COMM_WORLD.Get_rank() + size = mpi4py.MPI.COMM_WORLD.Get_size() + + if procs_per_env == size: + assert num_learners == 1, "Only single learner is supported when procs_per_env == global comm size" + else: + total_env = procs_per_env * int((size - num_learners) / procs_per_env) + assert total_env > 0 + assert size == total_env + num_learners, "Invalided configuration" + + # Do the split + comm(None, procs_per_env, num_learners) + + # Check the static members + assert ExaComm.num_learners == num_learners + assert ExaComm.procs_per_env == procs_per_env + + # Check the global comm + assert isinstance(ExaComm.global_comm, ExaComm) + assert ExaComm.global_comm.rank == rank + assert ExaComm.global_comm.size == size + + # Check the learner comm + if rank < num_learners: + assert isinstance(ExaComm.learner_comm, ExaComm) + assert ExaComm.learner_comm.size == num_learners + assert ExaComm.learner_comm.rank == rank + else: + assert ExaComm.learner_comm is None + + # Check the agent comm + if procs_per_env == size: + if rank == 0: + assert isinstance(ExaComm.learner_comm, ExaComm) + assert ExaComm.agent_comm.size == 1 + assert ExaComm.agent_comm.rank == 0 + else: + assert ExaComm.agent_comm is None + else: + num_agents = num_learners + (size - num_learners) / procs_per_env + if rank < num_learners: + assert isinstance(ExaComm.agent_comm, ExaComm) + assert ExaComm.agent_comm.size == num_agents + assert ExaComm.agent_comm.rank == rank + else: + checked = False + for i, global_rank in enumerate(range(num_learners, size, procs_per_env)): + if rank == global_rank: + assert isinstance(ExaComm.agent_comm, ExaComm) + assert ExaComm.agent_comm.size == num_agents + assert ExaComm.agent_comm.rank == i + num_learners + checked = True + else: + assert ExaComm.learner_comm is None + checked = True + assert checked == True, "Double check on logic failed. Rank " + str(rank) + " was not checked!" + + # Check the env comm + if procs_per_env == size: + assert isinstance(ExaComm.env_comm, ExaComm) + assert ExaComm.env_comm.size == procs_per_env + assert ExaComm.env_comm.rank == rank + elif rank < num_learners: + assert ExaComm.env_comm is None + else: + checked = 0 + for global_rank in range(num_learners, size, procs_per_env): + for j in range(procs_per_env): + checked += 1 + if global_rank + j == rank: + assert isinstance(ExaComm.env_comm, ExaComm) + assert ExaComm.env_comm.size == procs_per_env + assert ExaComm.env_comm.rank == j + assert checked == size - num_learners, "Double check on logic failed. Rank " + str(rank) + " was not checked!" + + @pytest.mark.parametrize("num_learners, procs_per_env", list(TestCommHelper.get_configs())) + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_comm_is_learner(self, comm, num_learners, procs_per_env): + """ + Checks the is_learner method of ExaComm and is child classes. + This uses and alternate approach from split to validate against + global rank. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + num_learners : int + Number of learners to create + procs_per_env : int + Number of ranks per env/agent to create + """ + a_comm = comm(None, procs_per_env, num_learners) + if mpi4py.MPI.COMM_WORLD.Get_rank() < num_learners: + assert ExaComm.is_learner() + assert a_comm.is_learner() + else: + assert not ExaComm.is_learner() + assert not a_comm.is_learner() + + @pytest.mark.parametrize("num_learners, procs_per_env", list(TestCommHelper.get_configs())) + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_comm_is_agent(self, comm, num_learners, procs_per_env): + """ + Checks the is_agent method of ExaComm and is child classes. + This uses and alternate approach from split to validate against + global rank. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + num_learners : int + Number of learners to create + procs_per_env : int + Number of ranks per env/agent to create + """ + rank = mpi4py.MPI.COMM_WORLD.Get_rank() + size = mpi4py.MPI.COMM_WORLD.Get_size() + a_comm = comm(None, procs_per_env, num_learners) + + if ExaComm.global_comm.size == procs_per_env: + if rank == 0: + assert ExaComm.is_agent() + assert a_comm.is_agent() + else: + assert not ExaComm.is_agent() + assert not a_comm.is_agent() + else: + if rank < num_learners: + assert ExaComm.is_agent() + assert a_comm.is_agent() + elif (rank - num_learners) % procs_per_env == 0: + assert ExaComm.is_agent() + assert a_comm.is_agent() + else: + assert not ExaComm.is_agent(), str(ExaComm.is_agent()) + assert not a_comm.is_agent(), a_comm.is_agent() + + @pytest.mark.parametrize("num_learners, procs_per_env", list(TestCommHelper.get_configs())) + @pytest.mark.parametrize("comm", TestCommHelper.comm_types) + def test_comm_is_actor(self, comm, num_learners, procs_per_env): + """ + Checks the is_actor method of ExaComm and is child classes. + An actor is anyone who is not a learner. + This uses and alternate approach from split to validate against + global rank. + + Parameters + ---------- + comm : ExaComm + Type of comm to test + num_learners : int + Number of learners to create + procs_per_env : int + Number of ranks per env/agent to create + """ + rank = mpi4py.MPI.COMM_WORLD.Get_rank() + size = mpi4py.MPI.COMM_WORLD.Get_size() + a_comm = comm(None, procs_per_env, num_learners) + if ExaComm.global_comm.size == procs_per_env: + assert ExaComm.is_actor() + assert a_comm.is_actor() + else: + if rank < num_learners: + assert not ExaComm.is_actor() + assert not a_comm.is_actor() + else: + assert ExaComm.is_actor() + assert a_comm.is_actor() diff --git a/utests/utest_data_structures.py b/utests/utest_data_structures.py new file mode 100644 index 00000000..45f8df2b --- /dev/null +++ b/utests/utest_data_structures.py @@ -0,0 +1,866 @@ +import pytest +import tensorflow +import numpy as np +from exarl.utils.candleDriver import initialize_parameters +from exarl.base.comm_base import ExaComm +from exarl.network.simple_comm import ExaSimple +import exarl.network.data_structures as ds + +@pytest.fixture(scope="session", autouse=True) +def mpi4py_rc(pytestconfig): + """ + This function sets up the mpi4py import. + + Attributes + ---------- + pytestconfig : + Parameters passed from pytest. + """ + mpi_flag = pytestconfig.getoption("mpi4py_rc") + initialize_parameters(params={"mpi4py_rc": mpi_flag, + "log_level": [3, 3]}) + return ExaSimple(None, 1, 1) + +class TestDataStructure: + """ + This class contains useful constants, access to MPI networking functionality via simple_comm, + and helper functions for creating and verifying packets. + + Attributes + ---------- + packet_size : int + Standard size of random data to send in bytes + constructor : dictionary + Names for easy reference to data structures/constructors + length_list : list + Data structure lengths to test + over_list : list + Amounts of packets to send past the total length of data structure to test. This is for testing lost data. + num_packets_list : list + List of number of packets for pattern tests + reps : int + Number of reps for pattern tests + max_try: int + Number of max tries for the pattern free for all tests + loss_per_rank : number + This is a number between 0 and 1. Represents the percentage of data that can be lost per rank for pattern tests. + lossy_length_list : list + This is the length of the data structure to test for loosing packets. We invert the numbers because it is easier + to not loose data for bigger sizes and we want the test to go as far as possible before failing. + """ + packet_size = 1000 + constructor = {"buff_unchecked": ds.ExaMPIBuffUnchecked, + "buff_checked": ds.ExaMPIBuffChecked, + "queue_distribute": ds.ExaMPIDistributedQueue, + "stack_distribute": ds.ExaMPIDistributedStack} + + length_list = [1, 10, 100, 1000] + over_list = [0, 1, 10, 100] + num_packets_list = [1, 10, 100] + reps = 10 + max_try = 1000000 + loss_per_rank = .5 + lossy_length_list = [100000, 10000, 1000, 100, 10] + + def filter(to_remove): + """ + Convince function to reduce test cases + + Parameters + ---------- + to_remove : list + Names to take out of constructors names + + Returns + ------- + list + With names removed + """ + ret = [] + for i in TestDataStructure.constructor: + for j in to_remove: + if j not in i: + ret.append(i) + return ret + + def make_packet(self, data_size, seq_num): + """ + Constructs a standard (testing) packet. + A packet will contain a sequence number, data size, random data, checksum, and rank. + + Sequence Number: user provided identifier + Data Size: the size of the random data in bytes + Data: random bytes + Checksum: integer sum of all the bytes in random data + Rank: the rank of the constructing (typically sending) rank + + Parameters + ---------- + data_size : int + Size of the data section + seq_num : int + Sequence number + + Returns + ------- + list + Standard packet + """ + data = np.random.bytes(data_size) + checksum = sum([int(x) for x in data]) + return (seq_num, data_size, data, checksum, ExaComm.global_comm.rank) + + def check_packet(self, packet, data_size, name): + """ + Check a packet conforms to standard construction. This does not check the sequence number as it is + a user defined parameter. + + Parameters + ---------- + packet : tuple + Packet to check for correctness + data_size : int + Size of the data section + name : string + Name of the data structure for error reporting + """ + assert packet is not None, name + " packet is None" + assert data_size == packet[1], name + " failed packet size should be " + str(data_size) + " but is " + str(packet[1]) + assert data_size == len(packet[2]), name + " size of data should be " + str(data_size) + " but is " + str(len(packet[2])) + checksum = sum([int(x) for x in packet[2]]) + assert checksum == packet[3], name + " failed packet checksum " + str(checksum) + " but is " + str(packet[3]) + assert packet[4] >= 0 and packet[4] < ExaComm.global_comm.size + + def compare_packet(self, A, B): + """ + Compares to standard packets element-by-element to check for correctness. + Returns False if either packet is None. + + Parameters + ---------- + A : tuple + First standard packet to compare + B : tuple + Second standard packet to compare + + Returns + ------- + bool + True if packets match, False otherwise + """ + if A is None or B is None: + return False + if len(A) != len(B): + return False + for a, b in zip(A, B): + if isinstance(a, np.ndarray): + if not np.array_equal(a, b): + return False + else: + if a != b: + return False + return True + + def check_order(self, name, seq_num, N): + """ + Compares the order of sequence numbers popped assuming a given data structure. + This functions only takes the sequence numbers not a list of standard packets. + This function assumes that sequence numbers range from 0 to N-1 where N is the + number of messages. To use this check, N packets should be pushed into the + data structure first. Once all data is pushed, N packets should be popped. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + seq_num : list + List of sequence numbers in order received from a pop + N: int + Number of packets pushed + + Returns + ------- + bool + True if packets order is correct, False otherwise + """ + if "queue" in name: + return seq_num == list(range(N)) + if "stack" in name: + return seq_num == list(range(N - 1, -1, -1)) + if "buff_unchecked" in name: + return seq_num == N * [N - 1] + if "buff_checked" in name: + return seq_num == [N - 1] + return False + + def init_data_structure(self, name, data=None, length=10, rank_mask=True, max_model_lag=None, failPush=False, size=None): + """ + Convenience wrapper for data structure creation. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + data : list + This should be a standard packet used to initialize the data structure. + This is required for data structures built on MPI RMA. The initial + sequence number of the standard packet should be -1. + length: int + Size of the desired data structure + rank_mask: bool + What ranks should participate in the data structure. An example use for this parameter is + rank_mask=ExaComm.global_comm.rank < 5. For most tests this parameter should be True to + include all ranks. + size: int + Override the size from data + + Returns + ------- + ExaData : + The data structure constructed with the requested parameters + """ + if data is None: + data = self.make_packet(TestDataStructure.packet_size, -1) + else: + assert data[0] == -1, name + " should have an initial standard packet with sequence number -1 but got " + str(data[0]) + return TestDataStructure.constructor[name](ExaComm.global_comm, + data, + name=name, + length=length, + rank_mask=rank_mask, + fail_push=failPush, + size=size) + +class TestDataStructureMembers(TestDataStructure): + """ + This class is a collection of basic tests for data structures. These include tests to check the basic required + members and the return values of the methods for popping and pushing data. + """ + + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_name(self, name): + """ + This test checks the ability to test naming the data structure. + The name is set by TestDataStructure.constructor in TestDataStructure.init_data_structure. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor. + """ + data_structure = self.init_data_structure(name) + assert data_structure.name == name, name + " failed name comparison but got " + data_structure.name + assert isinstance(data_structure, TestDataStructure.constructor[name]) + + + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_empty(self, name, length): + """ + This test checks the return of a data structure that is empty. For an unchecked data structure (e.g. unchecked_buffer) + the return value should be the data it was initialized with. Otherwise, a data structure should not return any data. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + """ + data_structure = self.init_data_structure(name, length=length) + for i in range(length * 2): + packet = data_structure.pop(ExaComm.global_comm.rank) + if packet: + assert "unchecked" in name, name + " should not return packet" + assert packet[0] == -1, name + " should have -1 sequence number from empty pop " + str(packet[0]) + assert packet[-1] == ExaComm.global_comm.rank, (name + + " rank should be " + + str(ExaComm.global_comm.rank) + + " from empty pop put got " + + str(packet[-1])) + self.check_packet(packet, TestDataStructure.packet_size, name) + else: + assert packet is None, name + " should not return a packet" + + # def test_rank_mask(self): + # for name in TestDataStructure.constructor: + # # data_structure = self.init_data_structure(name, rank_mask=TestClass.comm.rank%2==0) + # data_structure = self.init_data_structure(name, rank_mask=False) + # for i in range(ExaComm.global_comm.size): + # # if i%2==1: + # try: + # data_structure.push(self.make_packet(TestDataStructure.packet_size, 0), i) + # except: + # print("x") + + @pytest.mark.parametrize("failPush", [True, False]) + @pytest.mark.parametrize("over", TestDataStructure.over_list) + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_push_return(self, name, length, over, failPush): + """ + This test checks the return value of the push method. The push method should return two values: + Current capacity - what is the current capacity of the data after the push. + Data Lost - if any data is lost in the transaction. + + The failPush method changes the meaning of lost: + failPush == True - The data lost value will indicate that the push did not succeed + 0 - successful push + 1 - failed push + failPush == False - The data lost value in the data structure was overwritten and the push succeeded + 0 - No data was lost + 1 - One entry of data was overwritten + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + over : int + The amount of pushes to perform over the length of the data structure + failPush : bool + Flag to indicate failPush value of data structure + """ + data_structure = self.init_data_structure(name, length=length, failPush=failPush) + for i in range(length + over): + packet = self.make_packet(TestDataStructure.packet_size, i) + capacity, lost = data_structure.push(packet, ExaComm.global_comm.rank) + if "buff" in name: + assert capacity == 1, name + " capacity should be one " + str(capacity) + if "unchecked" not in name and i > 0: + assert lost == 1, name + " can only hold one element so data should be lost on every push" + str(lost) + else: + if i < length: + assert capacity == i + 1, name + " should have capacity of " + str(i) + " instead of " + str(capacity) + assert lost == 0, name + " no data should be lost but got " + str(lost) + else: + assert capacity == length, name + " should have a max capacity of " + str(length) + " instead of " + str(capacity) + assert lost == 1, name + " data should be lost but got " + str(lost) + + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_pop_order(self, name, length): + """ + This test checks the order in which data is popped. This test is based on the naming convention of + the data structures found in TestDataStructure.constructor (i.e. queue, stack, buffer) + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + """ + data_structure = self.init_data_structure(name, length=length) + + for i in range(length): + packet = self.make_packet(TestDataStructure.packet_size, i) + data_structure.push(packet, ExaComm.global_comm.rank) + + pop_packets = [] + for i in range(length): + packet = data_structure.pop(ExaComm.global_comm.rank) + if packet: + self.check_packet(packet, TestDataStructure.packet_size, name) + pop_packets.append(packet[0]) + + assert self.check_order(name, pop_packets, length), name + " sequence numbers out of order " + str(pop_packets) + + def length_single_rank(self, name, length, over, failPush): + """ + This function is used to test simple pushing and popping functionality. Each rank pushes and pops + from its local data structure. When over > 0 pops should fail for all checked data structures. + Further data from pops should correspond to the length of the data structure. Unchecked data structures + will return multiple copies of the same data. We compare the expected received packets with the packets sent. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + over : int + The amount of pushes to perform over the length of the data structure + failPush : bool + Flag to indicate failPush value of data structure + """ + data_structure = self.init_data_structure(name, length=length, failPush=failPush) + + push_packets = [] + for i in range(length + over): + packet = self.make_packet(TestDataStructure.packet_size, i) + data_structure.push(packet, ExaComm.global_comm.rank) + # Set up the list of packets pushed to compare against + push_packets.append(packet) + if i >= data_structure.length: + if failPush and "buff" not in name: + push_packets.pop() + else: + push_packets.pop(0) + + pop_packets = [] + for i in range(length + over): + packet = data_structure.pop(ExaComm.global_comm.rank) + if i < data_structure.length: + self.check_packet(packet, TestDataStructure.packet_size, name) + pop_packets.append(packet) + elif "unchecked" not in name: + assert packet is None, name + " pop should fail" + assert len(pop_packets) == data_structure.length, (name + " data structure length " + + str(data_structure.length) + + " doesn't match " + + str(len(pop_packets))) + + # For the buffer only the last element should popped + # In the case of unchecked there will be length copies of the last push + # For checked buffer there will only be one + # Reverse sort will capture this + # The pattern/order is already tested in test_pop_order + push_packets = sorted(push_packets, key=lambda x: x[0], reverse=True) + pop_packets = sorted(pop_packets, key=lambda x: x[0], reverse=True) + for i in range(data_structure.length): + assert self.compare_packet(push_packets[i], pop_packets[i]), name + " packets don't match " + str(push_packets[i][0]) + " " + str(pop_packets[i][0]) + + def length_multiple_ranks(self, name, length, over=0, failPush=False): + """ + This function is used to test pushing and popping functionality across ranks. The data structure + is initialized to a size of length * number of ranks to ensure that when over = 0, no data will be + lost. Every rank (including rank 0) pushes length + over packets of data to rank 0. All ranks + then hit a barrier. Rank 0 then pops all the data and checks for the appropriate number of packets. + If over == 0, we check to see all packets have arrived from each rank. We are not guaranteed any + other packets when over > 0 since data will be overwritten. The last check looks for a packet with + the last data sequence number. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + over : int + The amount of pushes to perform over the length of the data structure + failPush : bool + Flag to indicate failPush value of data structure + """ + data_structure = self.init_data_structure(name, length=length * ExaComm.global_comm.size, failPush=failPush) + + for i in range(length + over): + data_structure.push(self.make_packet(TestDataStructure.packet_size, i), 0) + ExaComm.global_comm.barrier() + + if ExaComm.global_comm.rank == 0: + pop_packets = [] + for i in range((length + over) * ExaComm.global_comm.size): + packet = data_structure.pop(0) + if i < data_structure.length: + self.check_packet(packet, TestDataStructure.packet_size, name) + pop_packets.append(packet) + elif "unchecked" not in name: + assert packet is None, name + " pop should fail" + assert len(pop_packets) == data_structure.length, (name + " data structure length " + + str(data_structure.length) + + " doesn't match " + + str(len(pop_packets))) + + if ((length + over) * ExaComm.global_comm.size) == data_structure.length: + reduced = sorted([(x[0], x[-1]) for x in pop_packets]) + for i in range(length): + ranks = [x[1] for x in reduced if i == x[0]] + assert ranks == list(range(ExaComm.global_comm.size)), name + " missing packets " + str(i) + " " + str(ranks) + + # Will have duplicates seq numbers coming from different ranks + # We can't guarantee the order without more synchronization + # Instead check to see that the last seq number exists if failPush=False since we are guaranteed someone has to be last + # Check the inverse is true for failPush=True + seq_num = set([x[0] for x in pop_packets]) + if failPush and over > 0 and "buff" not in name: + assert over + length - 1 not in seq_num, name + " sequence number should not be received " + str(over + length - 1) + else: + assert over + length - 1 in seq_num, name + " sequence number should be received " + str(over + length - 1) + + ExaComm.global_comm.barrier() + + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_simple_push_pop_single_rank(self, name, length): + """ + This tests basic pushing and popping to and from local rank. All pushes and pops + do not exceed the total size of the data structure's length. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + """ + self.length_single_rank(name, length, over=0, failPush=False) + + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_simple_push_pop_single_multi_rank(self, name, length): + """ + This tests basic pushing and popping to and from rank 0. All pushes and pops + do not exceed the total size of the data structure's length. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + """ + self.length_multiple_ranks(name, length, over=0, failPush=False) + + @pytest.mark.parametrize("failPush", [False, True]) + @pytest.mark.parametrize("over", TestDataStructure.over_list) + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_failPush_single_rank(self, name, length, over, failPush): + """ + This tests basic pushing and popping to and from a single rank. All pushes and pops + will exceed the total size of the data structure's length to test data loss and failPush. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + over : int + The amount of pushes to perform over the length of the data structure + failPush : bool + Flag to indicate failPush value of data structure + """ + self.length_single_rank(name, length, over=over, failPush=failPush) + + @pytest.mark.parametrize("failPush", [False, True]) + @pytest.mark.parametrize("over", TestDataStructure.over_list) + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.constructor.keys()) + def test_failPush_multi_rank(self, name, length, over, failPush): + """ + TODO: WRITE COMMENT HOW DID I FORGET THIS ONE + """ + self.length_multiple_ranks(name, length, over=over, failPush=failPush) + +class TestMessagePatterClass(TestDataStructure): + """ + This class is a collection of tests for data structures to test communication patterns used in Exarl. + """ + + @pytest.mark.parametrize("spread", [False, True]) + @pytest.mark.parametrize("num_packets", TestDataStructure.num_packets_list) + @pytest.mark.parametrize("name", TestDataStructure.filter("buff")) + def test_sync(self, name, num_packets, spread, reps=TestDataStructure.reps): + """ + This tests all ranks but one pushing, and rank 0 pops all data. There is a barrier between + the pushing and popping phase of the test. The number of packets and their order is checked. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + num_packets : int + The number of packets to push per rank + spread : bool + True data pushes to local data structure, False pushes data to rank 0 + reps : int + Number of reps to perform + """ + if spread: + data_structure = self.init_data_structure(name, length=num_packets) + else: + data_structure = self.init_data_structure(name, length=num_packets * ExaComm.global_comm.size) + for rep in range(reps): + # All ranks > 0 will send data + if ExaComm.global_comm.rank > 0: + for i in range(num_packets): + # Push to my local ds + if spread: + # Should push to own rank + _, loss = data_structure.push(self.make_packet(TestDataStructure.packet_size, i)) + else: + # Pushes to rank 0 + _, loss = data_structure.push(self.make_packet(TestDataStructure.packet_size, i), 0) + assert loss == 0, name + " should not loose any data for sync test" + # Barrier makes sure all data has been sent + ExaComm.global_comm.barrier() + + # Rank 0 will read all the data + else: + # This keeps track of the seq numbers per rank + seq_num = [[] for x in range(ExaComm.global_comm.size)] + + # Barrier makes sure we wont pop data until all data is there + ExaComm.global_comm.barrier() + for j in range(ExaComm.global_comm.size - 1): + for i in range(num_packets): + if spread: + # Pops from individual rank + packet = data_structure.pop(j + 1) + else: + # Pops from rank 0 + packet = data_structure.pop(0) + self.check_packet(packet, TestDataStructure.packet_size, name) + # Update the sequence per rank + seq_num[packet[-1]].append(packet[0]) + + # Check to see that all packets have arrived and in the correct order + for i, val in enumerate(seq_num): + if i > 0: + assert len(val) == num_packets, name + " missing packet " + str(i) + " " + str(len(val)) + " != " + str(num_packets) + assert self.check_order(data_structure.name, val, num_packets), (name + " sequence number out of order " + + data_structure.name + " " + str(val)) + else: + assert len(val) == 0, name + " no data should be received from rank 0" + + # Block between iterations + ExaComm.global_comm.barrier() + + @pytest.mark.parametrize("num_packets", TestDataStructure.num_packets_list) + @pytest.mark.parametrize("name", TestDataStructure.filter("buff")) + def test_broadcast(self, name, num_packets, reps=TestDataStructure.reps): + """ + This tests rank 0 pushing and all other ranks popping data There is a barrier between + the pushing and popping phase of the test. Each packet checks that they receive data from + rank 0. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + num_packets : int + The number of packets to push per rank + reps : int + Number of reps to perform + """ + + data_structure = self.init_data_structure(name, length=num_packets) + for rep in range(reps): + # Rank 0 will send all the data + if ExaComm.global_comm.rank == 0: + for j in range(ExaComm.global_comm.size - 1): + for i in range(num_packets): + # Should push to other ranks + _, loss = data_structure.push(self.make_packet(TestDataStructure.packet_size, i), j + 1) + assert loss == 0, name + " should not loose any data for broadcast test" + # Barrier makes sure we wont pop data until all data is there + ExaComm.global_comm.barrier() + + # All ranks > 0 read data + else: + # This keeps track of the seq numbers per rank + seq_num = [[] for x in range(ExaComm.global_comm.size)] + + # Barrier makes sure all data has been sent + ExaComm.global_comm.barrier() + for i in range(num_packets): + # Pops from individual rank + packet = data_structure.pop(ExaComm.global_comm.rank) + self.check_packet(packet, TestDataStructure.packet_size, name) + # Update the sequence per rank + seq_num[packet[-1]].append(packet[0]) + + # Check to see that all packets have arrived and in the correct order + for i, val in enumerate(seq_num): + if i == 0: + assert len(val) == num_packets, name + " missing packet " + str(i) + " " + str(len(val)) + " != " + str(num_packets) + assert self.check_order(data_structure.name, val, num_packets), (name + " sequence number out of order " + + data_structure.name + " " + str(val)) + else: + assert len(val) == 0, name + " no data should be received from rank 0" + + # Block between iterations + ExaComm.global_comm.barrier() + + @pytest.mark.parametrize("spread", [False, True]) + @pytest.mark.parametrize("num_packets", TestDataStructure.num_packets_list) + @pytest.mark.parametrize("length", TestDataStructure.length_list) + @pytest.mark.parametrize("name", TestDataStructure.filter("buff")) + def test_free_for_all(self, name, length, num_packets, spread, reps=TestDataStructure.reps, max_try=TestDataStructure.max_try): + """ + This test has all ranks other than rank 0 pushing data. At the same time rank 0 will pop data max_try attempts. + Pushing ranks will continue pushing a given packet until it succeeds. FailPush=True guaranteeing no data will be + lost since we push until success. Buffers cannot be used in the test as they cannot cannot guarantee data will + not be lost on a push. We check that all data is received + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + num_packets : int + The number of packets to push per rank + spread : bool + True data pushes to local data structure, False pushes data to rank 0 + reps : int + Number of reps to perform + max_try : int + Number of total read attempts + """ + data_structure = self.init_data_structure(name, length=length, failPush=True) + for rep in range(reps): + # Block between iterations + ExaComm.global_comm.barrier() + + # All ranks > 0 will send data + if ExaComm.global_comm.rank > 0: + for i in range(num_packets): + for t in range(max_try): + # Push to my local ds + if spread: + # Should push to own rank + capacity, lost = data_structure.push(self.make_packet(TestDataStructure.packet_size, i)) + else: + # Pushes to rank 0 + capacity, lost = data_structure.push(self.make_packet(TestDataStructure.packet_size, i), 0) + # With failPush on this will indicate if the push succeeded + if lost == 0: + break + + # Rank 0 will read all the data + else: + # This keeps track of the seq numbers per rank + seq_num = [[] for x in range(ExaComm.global_comm.size)] + # This is the src to read from + src = 0 + # Total number of received packets + total_packets = 0 + # Time out based on max_try + num_try = 0 + while total_packets < (ExaComm.global_comm.size - 1) * num_packets and num_try < max_try: + packet = data_structure.pop(src) + + if packet is not None: + self.check_packet(packet, TestDataStructure.packet_size, name) + # Update the sequence per rank + assert packet[0] > -1, name + " gave invalid packet sequence number " + packet[0] + assert not spread or packet[-1] == src, (name + " packet " + str(packet[-1]) + " and src " + + str(src) + " do not match for spread: " + spread) + seq_num[packet[-1]].append(packet[0]) + total_packets += 1 + + if spread: + src = (src + 1) % ExaComm.global_comm.size + src = 1 if src == 0 else src + + num_try += 1 + + # Check to see that all packets have arrived + assert num_try != max_try, name + " did not collect all packets in less than max_try: " + str(num_try) + for i, val in enumerate(seq_num): + if i > 0: + assert len(val) == num_packets, name + " missing packet " + str(i) + " " + str(len(val)) + " != " + str(num_packets) + # The order of the data will be based on both the type of data structure and the when the data was pushed/popped + # We will just check that all sequence numbers have arrived + val = sorted(val) + assert self.check_order("queue", val, num_packets), name + " sequence number out of order " + data_structure.name + " " + str(val) + else: + assert len(val) == 0 + ExaComm.global_comm.barrier() + + @pytest.mark.skip(reason="This test requires manual tuning, but is useful for workflow design") + @pytest.mark.parametrize("spread", [False, True]) + @pytest.mark.parametrize("failPush", [False, True]) + @pytest.mark.parametrize("num_packets", TestDataStructure.num_packets_list) + @pytest.mark.parametrize("length", TestDataStructure.lossy_length_list) + @pytest.mark.parametrize("name", TestDataStructure.filter("buff")) + def test_lossy_free_for_all(self, name, length, num_packets, failPush, spread, + reps=TestDataStructure.reps, + max_try=TestDataStructure.max_try, + loss_per_rank=TestDataStructure.loss_per_rank): + """ + This test has all ranks other than rank 0 pushing data. At the same time rank 0 will pop data max_try attempts. + Pushing ranks will push a given packet once. FailPush=True guaranteeing no data will be + lost since we push until success. Buffers cannot be used in the test as they cannot cannot guarantee data will + not be lost on a push. We check that all data is received. + + This test checks to see how much data is lost in a free for all. The acceptable amount is not hard and fast. + We originally set it to 50% of the data as a good approximation, but ultimately the performance of a data + structure is a combination of number of ranks, length of the data structure, and the number of pop tries by + rank zero. + + TODO: For RMA workflows consider how this test should be incorporated with the timing of an + environment vs training. + + Parameters + ---------- + name : string + Name of the data structure corresponding to TestDataStructure.constructor + length : int + Length of the data structure to initialize + num_packets : int + The number of packets to push per rank + failPush : bool + Flag to indicate failPush value of data structure + spread : bool + True data pushes to local data structure, False pushes data to rank 0 + reps : int + Number of reps to perform + max_try : int + Number of total read attempts + loss_per_rank : number + This is a number between 0 and 1. Represents the percentage of data that can be lost per rank. + """ + data_structure = self.init_data_structure(name, length=length, failPush=failPush) + for rep in range(reps): + ExaComm.global_comm.barrier() + # All ranks > 0 will send data + if ExaComm.global_comm.rank > 0: + for i in range(num_packets): + # Push to my local ds + if spread: + # Should push to own rank + capacity, lost = data_structure.push(self.make_packet(TestDataStructure.packet_size, i)) + else: + # Pushes to rank 0 + capacity, lost = data_structure.push(self.make_packet(TestDataStructure.packet_size, i), 0) + + # Rank 0 will read all the data + else: + # This keeps track of the seq numbers per rank + seq_num = [[] for x in range(ExaComm.global_comm.size)] + # This is the src to read from + src = 0 + # Total number of received packets + total_packets = 0 + # Time out based on max_try + num_try = 0 + while total_packets < (ExaComm.global_comm.size - 1) * num_packets and num_try < max_try: + packet = data_structure.pop(src) + if packet is not None: + self.check_packet(packet, TestDataStructure.packet_size, name) + # Update the sequence per rank + assert packet[0] > -1, name + " gave invalid packet sequence number " + str(packet[0]) + assert not spread or packet[-1] == src, (name + " packet " + str(packet[-1]) + " and src " + + str(src) + " do not match for spread: " + spread) + seq_num[packet[-1]].append(packet[0]) + total_packets += 1 + + if spread: + src = (src + 1) % ExaComm.global_comm.size + src = 1 if src == 0 else src + + num_try += 1 + + if ExaComm.global_comm.rank == 0: + print("Total Packets:", total_packets) + print("Rank", "NumPackets", "NumUniqueSeqNums") + for i, val in enumerate(seq_num): + print(i, len(val), len(set(val))) + print(val) + + # Check how many packets arrived + for i, val in enumerate(seq_num): + if i > 0: + val = set(val) + assert len(val) >= num_packets * (1 - loss_per_rank), (name + " rank " + str(i) + + " did not collect enough packets total unique packets: " + + str(len(val)) + " < " + str(num_packets * (1 - loss_per_rank))) + else: + assert len(val) == 0 + + ExaComm.global_comm.barrier() diff --git a/utests/utest_dqn.py b/utests/utest_dqn.py deleted file mode 100644 index d6c7b232..00000000 --- a/utests/utest_dqn.py +++ /dev/null @@ -1,337 +0,0 @@ -import tensorflow as tf -import sys -import numpy as np -import exarl as erl -import pytest -import exarl.utils.candleDriver as cd -from exarl.base.comm_base import ExaComm - -from tensorflow.keras.layers import Dense, GaussianNoise, BatchNormalization, LSTM -from tensorflow.python.client import device_lib -from tensorflow.keras import optimizers, activations, losses -from exarl.agents.agent_vault.dqn import DQN -from exarl.utils.candleDriver import initialize_parameters -from exarl.network.simple_comm import ExaSimple -MPI = ExaSimple.MPI - - -class TestClass: - - # initialize a test_agent - def __init_test_agent(self): - global test_agent - global test_learner - try: - test_learner = erl.ExaLearner(comm) - test_agent = DQN(test_learner.env, True) # run_params).env) - except TypeError: - pytest.fail('Abstract class methods not handled correctly', pytrace=True) - except: - pytest.fail('Bad Agent Implementation', pytrace=True) - - return test_agent - - # look into model layers Attribute - # TODO: add functionality to check for any type of layers attribute - def _peek_layers_attribute(self): - types = (LSTM, GaussianNoise, BatchNormalization, Dense) - - if self.device == 'CPU': - - lstms = len(test_agent.lstm_layers) - gauss_noise = len(test_agent.gauss_noise) - - for layer in test_agent.target_model.layers: - if isinstance(layer, types) is False: - return False - - if isinstance(layer, types[0]): - lstms -= 1 - elif isinstance(layer, types[1]): - gauss_noise -= 1 - - return lstms == 0 and gauss_noise == 0 - - elif self.device == 'GPU': - - dense = len(test_agent.dense) - - for layer in test_agent.model.layers: - if isinstance(layer, types) is False: - return False - if isinstance(layer, types[3]): - dense -= 1 - - return dense == 0 - - else: - return False - - # 1: test MPI init - def test_initialize_parameters(self): - global comm # run_params - try: - comm = MPI.COMM_WORLD - rank = comm.Get_rank() - size = comm.Get_size() - # run_params = initialize_parameters() - # assert type(run_params) is dict - except: - pytest.fail('Bad MPI comm', pytrace=True) - # pytest.fail('Bad initialize_parameters()',pytrace=True) - - # 2: test agent __init__ for DQN agent - def test_init(self): - - try: - self.__init_test_agent() - - assert test_agent.results_dir == cd.run_params['output_dir'] - assert test_agent.gamma == cd.run_params['gamma'] and \ - 0 < test_agent.gamma < 1 and \ - isinstance(test_agent.gamma, float) is True - assert test_agent.epsilon == cd.run_params['epsilon'] and \ - 0 < test_agent.epsilon > test_agent.epsilon_min and \ - isinstance(test_agent.epsilon, float) is True - assert test_agent.epsilon_min == cd.run_params['epsilon_min'] and \ - test_agent.epsilon_min > 0 and \ - isinstance(test_agent.epsilon_min, float) is True - assert test_agent.epsilon_decay == cd.run_params['epsilon_decay'] and \ - 0 < test_agent.epsilon_decay < 1 and \ - isinstance(test_agent.epsilon_decay, float) is True - assert test_agent.learning_rate == cd.run_params['learning_rate'] and \ - test_agent.learning_rate > 0 and \ - isinstance(test_agent.learning_rate, float) is True - assert test_agent.batch_size == cd.run_params['batch_size'] and \ - test_agent.batch_size > 0 and \ - test_agent.maxlen % test_agent.batch_size == 0 and \ - isinstance(test_agent.batch_size, int) is True - assert test_agent.tau == cd.run_params['tau'] and \ - 0 < test_agent.tau < 1 and \ - isinstance(test_agent.tau, float) is True - assert test_agent.model_type == cd.run_params['model_type'] and \ - test_agent.model_type.upper() in ("LSTM", "MLP") - - # for mlp - if test_agent.model_type.upper() == "MLP": - assert test_agent.dense == cd.run_params['dense'] and \ - isinstance(test_agent.dense, list) is True and \ - len(test_agent.dense) > 0 and \ - all([(l > 0 and isinstance(l, int)) for l in test_agent.dense]) - - # for lstm - if test_agent.model_type.upper() == "LSTM": - assert test_agent.lstm_layers == cd.run_params['lstm_layers'] and \ - isinstance(test_agent.lstm_layers, list) is True and \ - len(test_agent.lstm_layers) > 0 and \ - all([(l > 0 and isinstance(l, int)) for l in test_agent.lstm_layers]) - - assert test_agent.gauss_noise == cd.run_params['gauss_noise'] and \ - isinstance(test_agent.gauss_noise, list) is True and \ - len(test_agent.gauss_noise) == len(test_agent.lstm_layers) and \ - len(test_agent.gauss_noise) > 0 and \ - all([(l > 0 and isinstance(l, float)) for l in test_agent.gauss_noise]) - - assert test_agent.regularizer == cd.run_params['regularizer'] and \ - isinstance(test_agent.regularizer, list) is True and \ - len(test_agent.regularizer) > 0 and \ - all([(0 < l < 1 and isinstance(l, float)) for l in test_agent.regularizer]) - - # for both - assert test_agent.activation == cd.run_params['activation'] and \ - isinstance(test_agent.activation, str) is True - try: - # check if it is a valid activation - activations.get(test_agent.activation) - except ValueError: - pytest.fail('Bad activation function for TensorFlow Keras', pytrace=True) - - assert test_agent.out_activation == cd.run_params['out_activation'] and \ - isinstance(test_agent.out_activation, str) is True - try: - # check if it is a valid activation - activations.get(test_agent.out_activation) - except ValueError: - pytest.fail('Bad activation function for TensorFlow Keras', pytrace=True) - - assert test_agent.optimizer == cd.run_params['optimizer'] and \ - isinstance(test_agent.optimizer, str) is True - try: - # check if it is a valid optimizer - optimizers.get(test_agent.optimizer) - except ValueError: - pytest.fail('Bad optimizer for TensorFlow Keras', pytrace=True) - - assert test_agent.loss == cd.run_params['loss'] and \ - isinstance(test_agent.loss, str) is True - try: - # check if it is a valid loss - losses.get(test_agent.loss) - except ValueError: - pytest.fail('Bad loss function for TensorFlow Keras', pytrace=True) - - # Currently unused - # assert test_agent.clipnorm == cd.run_params['clipnorm'] and \ - # isinstance(test_agent.clipnorm, float) is True - # assert test_agent.clipvalue == cd.run_params['clipvalue'] and \ - # isinstance(test_agent.clipvalue, float) is True - - assert test_agent.maxlen == cd.run_params['mem_length'] - - # test model.compile() - # gpu_names = [x.name for x in device_lib.list_local_devices() if x.device_type == 'GPU'] - # if len(gpu_names) > 0: - # self.device = 'GPU' - # assert self._peek_layers_attribute() is True - - # on device /CPU:0 - # self.device = 'CPU' - # assert isinstance(test_agent.target_model.layers, list) is True and \ - # self._peek_layers_attribute() is True - - except ValueError: - pytest.fail('Invalid Arguments in model.compile() for optimizer, loss, or metrics', pytrace=True) - except: - pytest.fail("Bad DQN()", pytrace=True) - sys.exit() - - # 3: test set_learner() for agent - def test_set_learner(self): - - try: - test_agent.set_learner() - assert test_agent.is_learner is True - - except ValueError: - pytest.fail('Invalid argumensts for optimizer, loss, or metrics in compile()', pytrace=True) - - # 4: test remember() for agent - def test_remember(self): - - current_state = test_agent.env.reset() - total_reward = 0 - next_state = test_agent.env.reset() - action = 0 - done = 0 - reward = 0 - - memory = (current_state, action, reward, next_state, done, total_reward) - try: - test_agent.remember(memory[0], memory[1], memory[2], memory[3], memory[4]) - minibatch, _, _ = test_agent.replay_buffer.sample(test_agent.batch_size, test_agent.priority_scale) - assert minibatch[-1][1] == action - assert minibatch[-1][2] == reward - assert minibatch[-1][4] == done - assert all([a == b for a, b in zip(minibatch[-1][0], current_state)]) - assert all([a == b for a, b in zip(minibatch[-1][3], next_state)]) - except: - pytest.fail("Bad remember()", pytrace=True) - - # 5: test get_weights() for agent - def test_get_weights(self): - assert test_agent.get_weights() is not None - - # 6: test set_weight() for agent - def test_set_weights(self): - - test_agent_comm = ExaComm.agent_comm - test_target_weights = test_agent.get_weights() - test_current_weights = test_agent_comm.bcast(test_target_weights, root=0) - - try: - test_agent.set_weights(test_current_weights) - assert np.array_equal(test_current_weights[0], test_agent.get_weights()[0]) is True - except: - pytest.fail("Bad set_weights()", pytrace=True) - - # 7: test action() for agent - # TODO: Add testcase to verify difference between before and after an action - def test_action(self): - - try: - action, policy = test_agent.action(test_agent.env.reset()) - assert action >= 0 - assert policy in [0, 1] - except: - pytest.fail("Bad action()", pytrace=True) - - # 8: test generate_data() for agent - # TODO: Need to generalize for a custom agent? - def test_generate_data(self): - - # global batch # test_batch_state, test_batch_target - try: - [test_agent.remember(test_agent.env.reset(), 0, 0, test_agent.env.reset(), 0) for _ in range(test_agent.maxlen)] - batch1 = next(test_agent.generate_data()) - assert isinstance(batch1, tuple) is True - batch2 = next(test_agent.generate_data()) - assert isinstance(batch2, tuple) is True - if type(batch1[0]).__module__ == np.__name__ and type(batch2[0]).__module__ == np.__name__: - assert np.array_equal(batch1[0], batch2[0]) is False - except: - pytest.fail("Bad generate_data()", pytrace=True) - - # 9: test model.fit() in train() for agent - def test_train(self): - - try: - - with tf.device(test_agent.device): - test_agent.train(next(test_agent.generate_data())) - epsilon1 = test_agent.epsilon - test_agent.train(next(test_agent.generate_data())) - epsilon2 = test_agent.epsilon - - assert epsilon1 > test_agent.epsilon_min and \ - epsilon2 > test_agent.epsilon_min and \ - epsilon2 <= epsilon1 - - # for h1, h2 in zip(history1.history.values(), history2.history.values()): - # if isinstance(h1, list) and isinstance(h2, list): - # assert all([a != b for a, b in zip(h1, h2)]) - # else: - # assert h1 != h2 - - except RuntimeError: - pytest.fail('Model fit() failed. Model never compiled, or model.fit is wrapped in tf.function', pytrace=True) - except ValueError: - pytest.fail('Mismatch between input data and expected data', pytrace=True) - except: - pytest.fail('Bad train()', pytrace=True) - - # 10: test target_train() for agent - def test_target_train(self): - - try: - initial_weights = test_agent.get_weights() - test_agent.target_train() - changed_weights = test_agent.get_weights() - for w1, w2 in zip(initial_weights, changed_weights): - if type(w1).__module__ == np.__name__ and type(w2).__module__ == np.__name__: - assert np.array_equal(w1, w2) is False - elif isinstance(w1, list) and isinstance(w2, list): - assert any(a != b for a, b in zip(w1, w2)) - else: - assert w1 != w2 - except: - pytest.fail('Incorrect target weights update', pytrace=True) - - # 11: test load() for agents - def test_load(self): - - # checking if abstractmethod load() is in agent (DQN) class - try: - method = getattr(test_agent, 'load') - assert callable(method) - except AttributeError: - pytest.fail('Must implement abstractmethod load()', pytrace=True) - - # 12: test save() for agents - def test_save(self): - - # checking if abstractmethod save() is in agent (DQN) class - try: - method = getattr(test_agent, 'save') - assert callable(method) - except AttributeError: - pytest.fail('Must implement abstractmethod save()', pytrace=True) diff --git a/utests/utest_env.py b/utests/utest_env.py new file mode 100644 index 00000000..f67d9ea4 --- /dev/null +++ b/utests/utest_env.py @@ -0,0 +1,409 @@ +import gym +import pytest +import importlib +import numpy as np +from exarl.base.comm_base import ExaComm +from exarl.network.simple_comm import ExaSimple +from exarl.base.env_base import ExaEnv +from exarl.envs.env_vault.UnitEvn import EnvGenerator +from exarl.utils.candleDriver import initialize_parameters + +import mpi4py +# Unfortunatly, this line is starting MPI instead of the communicators. +# I can't figure out how to parameterize a fixture from a fixture which +# ultimately causes the problem. +from mpi4py import MPI + +class TestEnvHelper: + """" + This is a helper class with constants used throughout the environment tests. + + Attributes + ---------- + max_steps : int + Max allotted steps taken to perform tests + max_resets : dictionary + Max allotted resets taken to perform tests + """ + max_steps = 10000 + max_resets = 10000 + + def get_configs(): + """ + This is a generator that spits out configurations of learners, agents, and procs per agent. + This is used to generate tests for split. + + Returns + ------- + Pair + Number of learners and proccesses per environment for comm setup + """ + + size = MPI.COMM_WORLD.Get_size() + yield 1, size + for num_learners in range(1, size): + rem = size - num_learners + # Iterate over all potential procs_per_env counts + for i in range(0, rem): + # Add one since we want the size of the env_count not index + procs_per_env = i + 1 + # Does it fit, then return it + if rem % procs_per_env == 0: + yield num_learners, procs_per_env + + def reset(env): + """ + This helper resets the environment and checks that the + resulting state is consistent across ranks. + + Attributes + ---------- + env : ExaComm + Environment to reset + + Returns + ------- + gym.space + Current observation state after reset + """ + count = 0 + state = env.reset() + for i in range(0, ExaComm.env_comm.size): + to_check = ExaComm.env_comm.bcast(state, i) + if isinstance(state, np.ndarray): + if np.array_equal(to_check, state): + count += 1 + else: + if to_check == state: + count += 1 + assert count == ExaComm.env_comm.size + return state + +@pytest.fixture(scope="session") +def mpi4py_rc(pytestconfig): + """ + This function sets up the mpi4py import. + + Attributes + ---------- + pytestconfig : + Parameters passed from pytest. + """ + mpi_flag = pytestconfig.getoption("mpi4py_rc") + initialize_parameters(params={"mpi4py_rc": mpi_flag, + "log_level": [3, 3]}) + +@pytest.fixture(scope="session", params=list(TestEnvHelper.get_configs())) +def init_comm(request, mpi4py_rc): + """ + This sets up a comm to test environment with. This test must be run + with at least two ranks. + + Attributes + ---------- + env : ExaComm + Environment to reset + + Returns + ------- + Pair + Number of learners and proccesses per environment for comm setup + """ + num_learners, procs_per_env = request.param + ExaSimple(None, procs_per_env, num_learners) + assert ExaComm.num_learners == num_learners + assert ExaComm.procs_per_env == procs_per_env + yield num_learners, procs_per_env + + ExaComm.reset() + assert ExaComm.global_comm is None + assert ExaComm.agent_comm is None + assert ExaComm.env_comm is None + assert ExaComm.num_learners == 1 + assert ExaComm.procs_per_env == 1 + +@pytest.fixture(scope="session") +def registered_environment(pytestconfig, init_comm): + """ + This is a pytest fixture to add an environment to the gym registry based on command line arguments. + The parser comes from conftest.py. We require: + test_env_name - gym name for test (e.g. ExaCartPoleStatic-v0) + test_env_class - name of the class for test module (e.g. ExaCartpoleStatic) + test_env_file - name of the file containing test_env_class omitting the ".py" (e.g. ExaCartpoleStatic) + To use call pytest ./utest_env.py --test_env_name ExaCartPoleStatic-v0 --test_env_class ExaCartpoleStatic --test_env_file ExaCartpoleStatic + If only test_env_name is given, we assume the environment is already in the gym registry. + If no arguments are given an synthetic environment is generated. + The scope is set to session as to only add to the gym registry once per pytest session (run). + In order to make sure that environments are not re-registered for a given configuration, + we form a cantor pair from the number of learners and the processes per environment + https://en.wikipedia.org/wiki/Pairing_function#Cantor_pairing_function. + + Parameters + ---------- + pytestconfig : + Hook for pytest argument parser + init_comm : pair + Number of learners and the proccesses per environment coming from init_comm fixture + + Returns + ------- + String + Returns the new environment name that was registered + """ + env_name = pytestconfig.getoption("test_env_name") + env_class = pytestconfig.getoption("test_env_class") + env_file_name = pytestconfig.getoption("test_env_file") + if env_name is not None: + if env_class is not None and env_file_name is not None: + entry = getattr(importlib.import_module("exarl.envs.env_vault." + env_file_name), env_class) + # Assume it is already in the gym registry + else: + return env_name + else: + entry = EnvGenerator.createClass("Discrete", "Box", False, False, True, 75, 20) + env_name = entry.name + + # Cantor pair + num_learners, procs_per_env = init_comm + cantor_pair = int(((num_learners + procs_per_env) * (num_learners + procs_per_env + 1)) / 2 + procs_per_env) + + # We are going to strip of the v0 and instead add vCommSize + # This doesn't matter since we are consistent with the name within the test + temp = env_name.split("-") + if len(temp) > 1: + temp.pop() + temp.append("v" + str(cantor_pair)) + env_name = "-".join(temp) + gym.envs.registration.register(id=env_name, entry_point=entry) + return env_name + +@pytest.fixture(scope="function") +def environment(registered_environment): + """ + This fixture generates an new environment from the gym registry. + + Parameters + ---------- + registered_environment : String + Names of environment to create passed in from fixture + + Returns + ------- + ExaEnv + Returns an environment to test + """ + return ExaEnv(gym.make(registered_environment).unwrapped) + +class TestEnvMembers: + """ + This class checks an environment has the appropriate memember and methods. + """ + + def test_exa_env(self, environment): + """ + Checks that environment is of type ExaEnv. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + """ + assert isinstance(environment, ExaEnv) + + def test_action_space(self, environment): + """ + Checks that class has a gym action space. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + """ + assert hasattr(environment, "action_space") + assert isinstance(environment.action_space, gym.Space) + + def test_observation_space(self, environment): + """ + Checks that class has a gym observation space. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + """ + assert hasattr(environment, "observation_space") + assert isinstance(environment.observation_space, gym.Space) + + def test_reset(self, environment): + """ + Checks that class has a callable reset function and has the correct return type. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + """ + assert hasattr(environment, "reset") + assert callable(getattr(environment, 'reset')) + + ret = environment.reset() + assert isinstance(ret, type(environment.observation_space.sample())) + + def test_step(self, environment): + """ + Checks that class has a callable step fuction and has the correct return types. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + """ + assert hasattr(environment, "step") + assert callable(getattr(environment, 'step')) + + # Must call reset to use a fresh environment + environment.reset() + ret = environment.step(environment.action_space.sample()) + assert len(ret) == 4 + assert isinstance(ret[0], type(environment.observation_space.sample())) + assert isinstance(ret[1], int) or isinstance(ret[1], float) + assert isinstance(ret[2], bool) + + def test_env_comm(self, environment, init_comm): + """ + Checks that class has an env_comm. This should be the case as + it is an ExaComm. The comm is only set when called from MPI. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + init_comm : Pair + The number of learners and the processes per environment coming from init_comm fixture + """ + assert hasattr(environment, "env_comm") + if ExaComm.is_actor(): + assert isinstance(environment.env_comm, ExaComm) + assert init_comm[1] == environment.env_comm.size + + def test_base_dir(self, environment): + """ + Checks that class has an base_dir. This should be the case as + it is an ExaComm. The base_dir is used to store environment specfic results. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + """ + assert hasattr(environment, "base_dir") + +class TestEnvFunctionality: + """ + This class checks the step and reset methods. + """ + + def test_step(self, environment, max_steps=TestEnvHelper.max_steps): + """ + Records the initial state after reset and compares the difference after taking a step. + Will take up to max steps to see if state will change. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + max_steps : int + The most step to be taken to attempt a change in state + """ + if ExaComm.is_actor(): + changed = False + old = TestEnvHelper.reset(environment) + for i in range(max_steps): + new, _, done, _ = environment.step(environment.action_space.sample()) + if isinstance(old, np.ndarray): + changed = not np.array_equal(old, new) + else: + changed = old != new + if changed: + break + # Keep trying after a reset if we didn't already break + if done: + TestEnvHelper.reset(environment) + assert changed == True, "Did not observe change in " + str(max_steps) + " steps" + ExaComm.global_comm.barrier() + + def test_reset(self, environment, max_steps=TestEnvHelper.max_steps): + """ + Records the compares the state after taking one step and after reset. + Will attempt max_steps to see a change from first reset. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + max_steps : int + The most step to be taken to attempt a change in state + """ + if ExaComm.is_actor(): + TestEnvHelper.reset(environment) + # Attempt to change the state + done = False + count = 0 + while not done and count < max_steps: + old, _, done, _ = environment.step(environment.action_space.sample()) + count += 1 + # Hit reset and compare + new = TestEnvHelper.reset(environment) + if isinstance(old, np.ndarray): + assert not np.array_equal(old, new), "Did not observe change on reset np array" + else: + assert old != new, "Did not observe change on reset" + ExaComm.global_comm.barrier() + + def test_seeds(self, environment, num_resets=TestEnvHelper.max_resets): + """ + Resets the environment num_resets times and looks for how often initial observation space repeats. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + num_resets : int + Max number of resets to check + """ + if ExaComm.is_actor(): + reset_states = [TestEnvHelper.reset(environment)] + for i in range(num_resets): + new = TestEnvHelper.reset(environment) + if isinstance(new, np.ndarray): + if any([np.array_equal(old, new) for old in reset_states]): + reset_states.append(new) + else: + if new not in reset_states: + reset_states.append(new) + assert len(reset_states) > 1, "Environment has only one initialization seed after " + str(num_resets) + " resets" + ExaComm.global_comm.barrier() + + def test_max_steps(self, environment, max_steps=TestEnvHelper.max_steps): + """ + Test for a max number of steps for a given environment. This looks for an environment + to return that it is finished by taking random actions up until some threshold. + + Parameters + ---------- + environment : ExaEnv + Environment from fixture to check. + max_steps : int + Max number of steps to check + """ + if ExaComm.is_actor(): + end_step = max_steps + TestEnvHelper.reset(environment) + for i in range(max_steps): + _, _, done, _ = environment.step(environment.action_space.sample()) + if done: + end_step = i + break + + assert end_step < max_steps, "Did not encounter a done state after " + str(max_steps) + " steps" + ExaComm.global_comm.barrier() diff --git a/utests/utest_workflow.py b/utests/utest_workflow.py new file mode 100644 index 00000000..b0767b05 --- /dev/null +++ b/utests/utest_workflow.py @@ -0,0 +1,631 @@ +import os +import pytest +import gym +from gym import spaces +from exarl.utils.candleDriver import initialize_parameters +from exarl.utils.globals import ExaGlobals +from exarl.base.comm_base import ExaComm +from exarl.network.simple_comm import ExaSimple +from exarl.base.env_base import ExaEnv +import exarl.agents +from .workflow import FakeLearner +from .workflow import FakeAgent +from .workflow import FakeEnv +from .workflow import WorkflowTestConstants +from .workflow import record + +import mpi4py +# Unfortunatly, this line is starting MPI instead of the communicators. +# I can't figure out how to parameterize a fixture from a fixture which +# ultimately causes the problem. +from mpi4py import MPI + +class TestWorkflowHelper: + """" + This is a helper class with constants used throughout the workflow tests. + + Attributes + ---------- + workflows : list + These are the workflows to test + episodes : list + The number of episodes to test with + env_steps : list + The cut off for the max steps built into the environment to test + workflow_steps : list + The max steps per episode set by the workflow to test + block : list + Indicates if we should do off-policy (0) or on-policy (1) learning + priority_scale : list + Turns on or off priority replay + batch_frequency : list + Indicates how often a batch of data should be sent to learner. + 1 sends data each step, -1 sends data each episode. + """ + workflows = ["sync", "async", "rma"] + episodes = [1, 10, 100] + env_steps = [1, 10, 100] + workflow_steps = [1, 10, 100] + block = [True, False] + batch_frequency = [1, -1] + + # workflows = ["simple_rma"] + # episodes = [10] + # env_steps = [10] + # workflow_steps = [10] + # block = [False] + # batch_frequency = [1] + + def get_configs(workflow): + """ + This is a generator that spits out configurations of learners, agents, and procs per agent. + This is used to generate tests for split. + + Currently, multi-learner configs are turned off + Parameters + ---------- + workflow : string + Name of workflow. For sync we only give out 1 learner/agent. + The rest go to env. For rest we do various combinations of learner/actor. + + Currently, multi-learner configs are turned off + Parameters + ---------- + workflow : string + Name of workflow. For sync we only give out 1 learner/agent. + The rest go to env. For rest we do various combinations of learner/actor. + + Returns + ------- + Pair + Number of learners and proccesses per environment for comm setup + """ + size = MPI.COMM_WORLD.Get_size() + if workflow == "sync": + yield 1, size + else: + # We start at 1 because we have to have at least one learner + # for num_learners in range(1, size): + for num_learners in range(1, 2): + rem = size - num_learners + # Iterate over all potential procs_per_env counts + for i in range(0, rem): + # Add one since we want the size of the env_count not index + procs_per_env = i + 1 + # Does it fit, then return it + if rem % procs_per_env == 0: + yield num_learners, procs_per_env + + def get_workflows(): + """ + This function generates combinations of parameters for testing + + Returns + ------- + List + Number of learners, processes per environment, workflow name, + number of episodes, number of max steps from the environments perspective, + number of max steps from the workflows perspective, blocking (on/off-policy), + and batch frequency. + """ + for workflows in TestWorkflowHelper.workflows: + for episodes in TestWorkflowHelper.episodes: + for env_steps in TestWorkflowHelper.env_steps: + for workflow_steps in TestWorkflowHelper.workflow_steps: + for block in TestWorkflowHelper.block: + for batch_frequency in TestWorkflowHelper.batch_frequency: + for num_learners, procs_per_env in TestWorkflowHelper.get_configs(workflows): + yield (num_learners, procs_per_env, workflows, episodes, + env_steps, workflow_steps, block, batch_frequency) + + def reduce_value(value): + """ + This function is used to aggregate a single value from multiple + counters on multiple ranks. Values are aggregated on rank 0. + + Parameters + ---------- + value : int + Counter to aggregate + """ + total = value + if ExaComm.global_comm.rank: + ExaComm.global_comm.send(value, 0) + else: + data = None + for i in range(1, ExaComm.global_comm.size): + data = ExaComm.global_comm.recv(data, source=i) + total += data + return total + +@pytest.fixture(scope="session") +def get_args(pytestconfig): + """ + This sets arguments that can be passed to this test. + on_policy and behind set how far off-policy/behind when training the workflow can be. + The parser comes from conftest.py. We require: + --on_policy - set to 1 to be on policy. Otherwise set to number to indicate how far off-policy + to be. -1 just records not asserting. -1 is the default + --behind - how old of data to train on. -1 just records not asserting. -1 is default. + Sleeping is also added to the train and step calls. There are two sleeps that can be + turned on (they are off by default). + --rank_sleep - sleep unique and fixed about base on global rank + --random_sleep - sleeps for a random time + + To use call pytest ./utest_env.py --on_policy -1 --behind -1 --random_sleep + + Parameters + ---------- + pytestconfig : + Hook for pytest argument parser + """ + WorkflowTestConstants.on_policy = int(pytestconfig.getoption("on_policy")) + WorkflowTestConstants.behind = int(pytestconfig.getoption("behind")) + WorkflowTestConstants.rank_sleep = bool(pytestconfig.getoption("rank_sleep")) + WorkflowTestConstants.random_sleep = bool(pytestconfig.getoption("random_sleep")) + +@pytest.fixture(scope="session") +def mpi4py_rc(pytestconfig): + """ + This function sets up the mpi4py import. + + Attributes + ---------- + pytestconfig : + Parameters passed from pytest. + """ + mpi_flag = pytestconfig.getoption("mpi4py_rc") + initialize_parameters(params={"mpi4py_rc": mpi_flag, + "log_level": [3, 3]}) + +@pytest.fixture(scope="session", params=list(TestWorkflowHelper.get_workflows())) +def init_comm(request, mpi4py_rc): + """ + This sets up a comm to test agent with. + + Attributes + ---------- + request : + This is the parameter from fixture decorator. Use request.param to get value. + Each request.param has a tuple with the Number of learners and Process per environment + configuration. + + Returns + ------- + List + Returns the test parameters + """ + num_learners, procs_per_env, *rem = request.param + ExaSimple(None, procs_per_env, num_learners) + assert ExaComm.num_learners == num_learners + assert ExaComm.procs_per_env == procs_per_env + yield request.param + + ExaComm.reset() + assert ExaComm.global_comm is None + assert ExaComm.agent_comm is None + assert ExaComm.env_comm is None + assert ExaComm.num_learners == 1 + assert ExaComm.procs_per_env == 1 + +@pytest.fixture(scope="session") +def log_dir(init_comm): + """ + This fixture creates a directory to store workflow logs in. + It is created once a session and torn down at the end. + The barriers are to make sure all ranks are synchronized prior + to file/dir creation and descruction. + + Parameters + ---------- + init_comm : pair + Ensures the comms are initialized before running + + Returns + ------- + String + Directory to use + """ + rank = ExaComm.global_comm.rank + made_dir = False + dir_name = './log_dir' + if rank == 0 and not os.path.isdir(dir_name): + os.mkdir(dir_name) + made_dir = True + + ExaGlobals.set_param('output_dir', dir_name) + ExaComm.global_comm.barrier() + yield dir_name + + ExaComm.global_comm.barrier() + if made_dir: + os.rmdir(dir_name) + +@pytest.fixture(scope="session") +def run_params(log_dir, init_comm): + """ + Attempt to set candle drivers run_params. We set this up instead of the + candle driver. + + Parameters + ---------- + log_dir : + Makes sure the first candleDriver.run_params is created + init_comm : + Test parameters used to populate candleDriver.run_params + + Returns + ------- + List : + Returns the test parameters + """ + _, _, workflow_name, episodes, env_steps, workflow_steps, block, batch_frequency = init_comm + ExaGlobals.set_param("n_episodes", episodes) + ExaGlobals.set_param("n_steps", workflow_steps) + ExaGlobals.set_param("episode_block", block) + ExaGlobals.set_param("priority_scale", 1) + ExaGlobals.set_param("batch_frequency", batch_frequency) + ExaGlobals.set_param("save_weights_per_episode", "false") + ExaGlobals.set_param("profile", "None") + return init_comm + +@pytest.fixture(scope="session") +def registration(): + """ + This fixture registers the fake environment and agent. Only happens + once per run (i.e. scope="session"). + """ + gym.envs.registration.register(id=FakeEnv.name, entry_point=FakeEnv) + exarl.agents.registration.register(id=FakeAgent.name, entry_point=FakeAgent) + +@pytest.fixture(scope="session") +def learner(registration, log_dir, get_args, run_params): + """ + This fixture generates an new workflow from the workflow registry. + + Parameters + ---------- + init_comm : pair + Number of learners and the proccesses per environment coming from init_comm fixture + registration : None + Ensures the registration fixture has run and we can load fake env and agent + + Returns + ------- + FakeLearner + The fake learner containing the env, agent, and workflow + """ + _, _, workflow_name, episodes, env_steps, workflow_steps, block, batch_frequency = run_params + WorkflowTestConstants.episodes = episodes + WorkflowTestConstants.env_max_steps = env_steps + WorkflowTestConstants.workflow_max_steps = workflow_steps + record.reset() + + env = None + agent = None + if ExaComm.is_actor(): + env = ExaEnv(gym.make(FakeEnv.name).unwrapped) + if ExaComm.is_agent(): + agent = exarl.agents.make(FakeAgent.name, env=env, is_learner=ExaComm.is_learner()) + workflow = exarl.workflows.make(workflow_name) + return FakeLearner(episodes, workflow_steps, agent, env, workflow, log_dir) + +@pytest.fixture(scope="session") +def steps(learner): + """ + This fixture returns the maximum steps per episode allowed. + This is so we don't have to recalculate it all the time. + + Parameters + ---------- + learner : FakeLearner + From fixture, ensures WorkflowTestConstants are set. + + Returns + ------- + int + Steps per episode + """ + return min(WorkflowTestConstants.env_max_steps, WorkflowTestConstants.workflow_max_steps) + +@pytest.fixture(scope="session") +def run_learner(learner): + """ + This fixture returns a Fake Learner after its ran. + It only returns a single one per session. + + Parameters + ---------- + learner : FakeLearner + From fixture, ensures WorkflowTestConstants are set. + + Returns + ------- + FakeLearner + The fake learner after its already run + """ + ExaComm.global_comm.barrier() + learner.run() + ExaComm.global_comm.barrier() + return learner + +@pytest.mark.skip(reason="This is for debugging other broken tests") +def test_run(learner, init_comm): + """ + This tests just running a learner. The workflow class has asserts in it + and if they crash, it can be hard to figure out the configuration and + why. This test can be turned on to help this processes. + It is also helpful to run pytest with -s to see the config: + Parameters + ---------- + learner : FakeLearner + From fixture, ensures WorkflowTestConstants are set. + init_comm : list + This is the configuration we are running. + """ + print("RUNNING:", init_comm) + ExaComm.global_comm.barrier() + learner.run() + ExaComm.global_comm.barrier() + +class TestWorkflowEnv: + """ + This is a class of tests that looks at the environment counters. + """ + def test_steps_per_rank(self, run_learner, steps): + """ + Checks if all actors have run at least one step. + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + print("PARAMETERS:", init_comm, flush=True) + if ExaComm.is_actor(): + assert run_learner.env.total_steps > 0 + + def test_steps(self, run_learner, steps): + """ + Checks if total steps is equal to the episodes * steps + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + steps : int + Maximum steps per episode + """ + total = 0 if not ExaComm.is_actor() else run_learner.env.total_steps + total = TestWorkflowHelper.reduce_value(total) + if not ExaComm.global_comm.rank: + assert total >= WorkflowTestConstants.episodes * steps * ExaComm.procs_per_env + + def test_reset_per_rank(self, run_learner): + """ + Checks if all actors reset their env at least once + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_actor(): + assert run_learner.env.total_resets > 0 + + def test_reset(self, run_learner): + """ + Checks if the total number of resets is at least the number of episodes + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + total = 0 if not ExaComm.is_actor() else run_learner.env.total_resets + total = TestWorkflowHelper.reduce_value(total) + if not ExaComm.global_comm.rank: + assert total >= WorkflowTestConstants.episodes + +class TestWorkflowAgent: + """ + This is a class of tests that looks at the agent counters. + """ + def test_has_data(self, run_learner, steps): + """ + Checks if the total number of remember calls is equal to the total steps + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + steps : int + Maximum steps per episode + """ + total = 0 if not ExaComm.is_agent() else run_learner.agent._has_data + total = TestWorkflowHelper.reduce_value(total) + if not ExaComm.global_comm.rank: + assert total >= WorkflowTestConstants.episodes * steps + + def test_train_per_learner(self, run_learner): + """ + Checks if each learner calls train + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_learner(): + assert run_learner.agent._train > 0 + + def test_train(self, run_learner): + """ + Checks if the total number of train calls is at least the number of episodes + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + total = 0 if not ExaComm.is_agent() else run_learner.agent._train + total = TestWorkflowHelper.reduce_value(total) + if not ExaComm.global_comm.rank: + assert total >= WorkflowTestConstants.episodes + + def test_target_train_per_learner(self, run_learner): + """ + Checks if each learner calls target_train + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_learner(): + assert run_learner.agent._target_train > 0 + + def test_target_train(self, run_learner): + """ + Checks if the total number of target_train calls is at least the number of episodes + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + total = 0 if not ExaComm.is_agent() else run_learner.agent._target_train + total = TestWorkflowHelper.reduce_value(total) + if not ExaComm.global_comm.rank: + assert total >= WorkflowTestConstants.episodes + + def test_action_per_learner(self, run_learner): + """ + Checks if the actions called on each agent with env comm = 0 + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_agent() and ExaComm.is_actor(): + assert run_learner.agent._total_action > 0 + + def test_action(self, run_learner, steps): + """ + Checks if all the actions called is at least the number of episodes * steps + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + total = 0 if not ExaComm.is_agent() else run_learner.agent._total_action + total = TestWorkflowHelper.reduce_value(total) + if not ExaComm.global_comm.rank: + assert total >= WorkflowTestConstants.episodes * steps + + def test_priority_replay(self, run_learner): + """ + Checks to see all indices where updated after a train. + An agents _weight_loss_check should be empty, otherwise + the generate_data call that sent indices was never returned. + We can accept if the last indices were not returned... + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_agent() and ExaComm.is_actor(): + assert len(run_learner.agent._weights_loss_check) <= 1 + +@pytest.mark.skip(reason="This is a test that requires manual tunning") +class TestWorkflowDelays: + """ + This class is designed to test how a workflow deals with delay. + We measure delay in the number of models generated by the learner + (model delay). A workflow can have 3 types of delay: + + 1. Data from old models: + This is related to off-policy learning. When we get data + it comes from an actor who does inference with some model. + This records compares how many models have been generated + since when this data was created + + 2. Off-policy learning: + This is the other side of the 1. The actor records how + out of data its model is when it is updated with a new + model by the learner. + + 3. Priority replay delay: + This records how long in model generations did it take + to receive the indices and weights from the learner + after training. + + The constants are used to configure the max allowed delays. + + Attributes + ---------- + max_behind : int + Max model delay for training on data + max_off_policy : int + Max model delay for updating actor's model + max_delay : int + Max model delay for updating indices and weights + for priority replay + """ + max_behind = 1 + max_off_policy = 1 + max_delay = 1 + + def test_oldest_model_data(self, run_learner): + """ + Checks max model delay for training on data by learner + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_learner(): + assert max(run_learner.agent._behind) <= TestWorkflowDelays.max_behind + + def test_most_off_policy(self, run_learner): + """ + Checks max model delay for updating an actor's model + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_agent() and ExaComm.is_actor(): + assert max(run_learner.agent._off_policy) <= TestWorkflowDelays.max_off_policy + + def test_max_delayed_priority_update(self, run_learner): + """ + Checks max model delay for updating indices and weights using priority replay + + Parameters + ---------- + run_learner : FakeLearner + Contains workflow that has already run + """ + if ExaComm.is_agent() and ExaComm.is_actor(): + assert max(run_learner.agent._priority_delay) <= TestWorkflowDelays.max_delay + +# Notes on things to check: + +# Number of steps +# Number of episodes +# Data passed back and forth matches +# Is the data passed between actor and learner correct +# Does everyone in the env comm do the same action +# Is the environment reset +# Is the state updated + +# Call Pattern +# How often are the weights updated +# Do they have current_state, total_reward +# Epsilon??? diff --git a/utests/workflow.py b/utests/workflow.py new file mode 100644 index 00000000..0681b4a6 --- /dev/null +++ b/utests/workflow.py @@ -0,0 +1,790 @@ +import os +import sys +import tensorflow +import gym +from gym import spaces +from exarl.utils.candleDriver import initialize_parameters +from exarl.utils.globals import ExaGlobals +from exarl.base.comm_base import ExaComm +from exarl.network.simple_comm import ExaSimple +from exarl.base.env_base import ExaEnv +from exarl.base.agent_base import ExaAgent +from exarl.envs.env_vault.UnitEvn import EnvGenerator +import exarl.agents +import functools +import time +import random +import traceback + +# We fix the seed for repeatablish sleeping +random.seed(7) + +class record: + """ + This class is a helper to replay when something goes wrong + with a fake environment and agent. + + Attributes + ---------- + counters : Dictionary + This contains a name of each function and how many times it ran + events : List + This contains a list of events that have occurred on a single node + verbose : bool + Flag indicating to print on each event + """ + counters = {} + events = [] + + verbose = True + + def reset(verbose=True): + """ + Resets the record. + + Parameters + ---------- + verbose : bool + Flag indicating to print on each event + """ + record.counters = {} + record.events = [] + record.verbose = verbose + + def event(func): + """ + This is a decorator to put ontop of a function. It will record + how many times it has been call in the counters dictionary and + add an entry under events. + + Parameters + ---------- + func : function + This is the function to record + + Returns + ------- + result + Returns the result of the function + """ + @functools.wraps(func) + def wrapper(*args, **kwargs): + if func.__name__ in record.counters: + record.counters[func.__name__] += 1 + else: + record.counters[func.__name__] = 1 + if record.verbose: + print("[STAND-ALONE WORKFLOW TEST]", ExaComm.global_comm.rank, record.counters[func.__name__], func.__name__, flush=True) + record.events.append((ExaComm.global_comm.rank, record.counters[func.__name__], func.__name__,)) + result = func(*args, **kwargs) + return result + return wrapper + + +class WorkflowTestConstants: + """ + This is a helper class/namespace to add a constants set by the workflow + for the fake environment. Environment creation goes through gym and + it is easier to just set a global. + + Attributes + ---------- + episodes : int + The maximum number of episodes + env_max_steps : int + The maximum number of steps set in the environment + workflow_max_steps : int + The maximum number of steps set in the workflow + on_policy : int + How much delay an agent can tolerate. Set to -1 + to ignore assert. + behind : int + How old data can be to use to train. Set to -1 + to ignore assert. + rank_sleep : bool + Flag to turn on sleeping in step and train based on + rank + random_sleep : bool + Flag to turn on sleeping in step and train based on + a random amount + """ + episodes = None + env_max_steps = None + workflow_max_steps = None + on_policy = -1 + behind = -1 + rank_sleep = False + random_sleep = True + + def do_random_sleep(): + """ + This function look at the constants and performs a sleep + for some amount of microseconds + """ + if WorkflowTestConstants.rank_sleep > 0: + time.sleep(ExaComm.global_comm.rank * 10**(-3)) + elif WorkflowTestConstants.random_sleep > 0: + time.sleep(int(random.random() * 100) * 10**(-4)) + +class FakeLearner: + """ + This class is used to fake out a learner base. It seems all we really + need is something that can link the workflow, agent, and environment + together plus the number of episodes and steps. + + Attributes + ---------- + global_comm : ExaComm + The global comm + global_size : int + Size of the global comm + nepisodes : int + Number of total episodes to run + nsteps : int + Number of max steps per episode + agent : ExaAgent + Fake agent to use for testing + env : ExaEnv + Fake environment to use for testing + workflow : ExaWorkflow + Workflow to test + results_dir : String + Directory to put logs into + action_type : int + Used to indicate what actions to take + """ + def __init__(self, nepisodes, nsteps, agent, env, workflow, results_dir): + """ + Parameters + ---------- + nepisodes : int + Total number of episodes to run + nsteps : int + Max number of steps per episode to run + agent : ExaAgent + Fake agent used for testing + env : ExaEnv + Fake environment used for testing + workflow : ExaWorkflow + The environment to test + results_dir : String + Directory where logs are written + """ + # Doubt we actually need self.global_comm and self.global_size + self.global_comm = ExaComm.global_comm + self.global_size = ExaComm.global_comm.size + self.nepisodes = nepisodes + self.nsteps = nsteps + self.agent = agent + self.env = env + self.workflow = workflow + self.results_dir = results_dir + self.action_type = None + + def run(self): + """ + Runs the workflow to test. + """ + self.workflow.run(self) + + def print_delays(self): + """ + This function prints out statistics about the model + delays observed by the agent. + """ + if ExaComm.is_learner() and len(self.agent._behind): + print("Learner Rank:Min:Max:Ave", ExaComm.global_comm.rank, + min(self.agent._behind), max(self.agent._behind), sum(self.agent._behind) / len(self.agent._behind)) + if ExaComm.is_agent() and len(self.agent._off_policy): + print("Agent Rank:Min:Max:Ave", ExaComm.global_comm.rank, + min(self.agent._off_policy), max(self.agent._off_policy), sum(self.agent._off_policy) / len(self.agent._off_policy)) + if ExaComm.is_agent() and len(self.agent._train_return_delay): + print("Agent Priority Rank:Min:Max:Ave", ExaComm.global_comm.rank, + min(self.agent._train_return_delay), max(self.agent._train_return_delay), sum(self.agent._train_return_delay) / len(self.agent._train_return_delay)) + +class FakeEnv(gym.Env): + """ + This is a fake environment. We use it in coordination with the + fake agent to ensure that the correct data is passed between + the environment and the learner. The state returned from this + environment always starts at zero (from reset). State increases + by one each time until it sets done. We assert that the action + is increasing by one at the same rate as the state. We also + assert that the step is not called when the environment is done. + + Attributes + ---------- + name : string + Name of the fake environment + action_space : gym space + Env's action space. We set this to discrete for counting. + It shouldn't matter that we only test one type. Space type + testing is done in agent tests. + observation_space : gym space + Env's observation space. We set this to discrete for counting. + It shouldn't matter that we only test one type. Space type + testing is done in agent tests. + done : bool + Indicates if the environment is done based on max_steps of the environment. + state : int + The current state of the environment. Is int because we are using discrete space. + max_steps : int + The max steps the environment can take. + total_step : ExaEnv + Total steps the environment has performed + total_reset : ExaWorkflow + The total number or resets + """ + + name = "FakeEnv-v0" + + def __init__(self): + super().__init__() + # We allow it to be well over max_steps to see if there will be error + self.action_space = spaces.Discrete(WorkflowTestConstants.env_max_steps * 10) + self.observation_space = spaces.Discrete(WorkflowTestConstants.env_max_steps * 10) + + # Init env in bad state to check + # that workflow call reset first! + self.done = True + self.state = WorkflowTestConstants.env_max_steps + self.max_steps = WorkflowTestConstants.env_max_steps + + self.total_steps = 0 + self.total_resets = 0 + + @record.event + def step(self, action): + """ + This is a single step. If number of calls == max steps + done is set. State and total_steps are always incremented by 1. + The action should match the state. Actions are dictated by the + inference done on an agent. This needs to be propageted by + the head of the env comm. The state will always just increase + by one. + + Parameters + ---------- + action : int + This is the step to perform. Its an int since the action + space is Discrete. + + Returns + ------- + Pair + Next state, reward, done, and info + """ + # We are configuring agent to expect + # to see same number as state + assert self.state == action + assert self.done == False + self.state += 1 + if self.state == self.max_steps: + self.done = True + self.total_steps += 1 + # print("STEP", self.state, 1, self.done) + WorkflowTestConstants.do_random_sleep() + return self.state, 1, self.done, {} + + @record.event + def reset(self): + """ + This resets the environment. It resets the internal state + and the done flag. We also count the total number of resets. + + Returns + ------- + int + The fresh restated state + """ + self.state = 0 + self.done = False + self.total_resets += 1 + return self.state + +class FakeAgent(ExaAgent): + """ + This is a fake agent. It is used in coordination with the fake env + to test a given workflow. In this agent we have several counters + (_has_data, _train, _target_train, _action, and _total_action) which + we can query after running to ensure that the correct number of actions + is taken. We also have counters (_weights, _indices, and _loss) which + always count up and are used to ensure correct coordination of the + workflow. These counters' values are asserted at runtime + (i.e. workflow.run). The previous counters are (mostly) asserted post + run. + + The _weights counter is a list of two. The first element is the counter + for the learner. The second is the counter for the actor. This counter + is split into two to support single rank tests. The _indices counter is + also similarly split. For this counter the actor increments the second + element and the learner will acknowledge its acceptance by + setting the first element to the second element. The third element of + _indices is set to the actors rank for roundtrip verification. + + As workflows become uncoupled, it is harder to guarantee how often a + model will be updated and how far off-policy learning can occurs. We + attempt to provide hooks for this using the WorkloadTestConstants. + However, this will probably require tuning with a given workflow in + conjunction with these tests!!! This process should help the developer + to understand how a workflow impacts the learning process. + + Attributes + ---------- + name : string + Name of the fake agent + _has_data : int + Counts how many times remember has been called + _train : int + Counts how many times train has been called + _target_train : int + Counts how many times target_train has been called + _action : int + Keeps track of the action to perform. It counts up + until the max number of steps for the workflow or + environment is reached. + _total_action : int + Counts how many times action has been called + _weights : List + This is the fake weights to pass around. The list contains + two counter that counts up. _weights[0] increase after a train + performed by learner. _weights[1] is set to _weights[0] when + it is received in set_weights. + _indices : List + This is fake indices to pass around. This is similar to + the fake weights. _indices[0] is incremented by + generate data. _indices[1] is set by the learner in train. + _indices[2] is set to the global rank id. + _weight_loss_check : List + This list consists of the model indices of an actor + (given by _weights[1]) when priority_replay is set. + We use this list to check set priority is returning + to the actor a valid set of "indices and loss" + _state : int + The expected state to see coming from the environment. + This number increase by one unless it is reset when + done is sent to remember. + _observed_action : int + This is the expected observed action coming from the + environment. We expect the action to increase by one + after each call to step. + _reward : int + The expected reward from a step. Is always set to one. + _next_state : int + The expected state from calling step. This number should + always be one larger than _state. + _done : bool + The expected done flag. This should only change when + the max number of steps for the environment or workflow + is reached. + _update_weights_on_get : bool + This flag indicates when to increase the weights. We + update the weights on a get after a train. + env : ExaEnv + The fake environment + is_learner : bool + Flag indicating if we are a learner. + priority_scale : float + Indicates if we are using experience replay + batch_size : int + The max size of a single batch + buffer_capacity : int + The capacity of the memory for the agent + epsilon : float + Not well used... + tau : float + Commonly used in target train, but not in the fake one. + _off_policy : List + This list is the differences between a new model and + old model recorded when setting weights by the actor + _behind : List + This list is the differences between a current model and + the model "used to generate data" recorded during train + by the learner. + _train_return_delay : List + This list is the delay in models from the time between + generate_data and set_priority observed in set_priority + by an actor. + """ + + name = "FakeAgent-v0" + + def __init__(self, env=None, is_learner=False): + """ + Parameters + ---------- + env : ExaEnv + The fake environment used in test + is_learner : bool + Indicates if agent is learner + """ + # These are counters + self._has_data = 0 + self._train = 0 + self._target_train = 0 + self._action = 0 + self._total_action = 0 + + # Counter/Messages + self._weights = [0, 0] + self._indices = [0, 0, ExaComm.global_comm.rank] + self._weights_loss_check = [] + + # Expected values for remember + self._state = 0 + self._observed_action = 0 + self._reward = 1 + self._next_state = 1 + self._done = False + + # We start this flag true for learner + # so set_weights on actors see +1 + self._update_weights_on_get = is_learner + + # These are required members + self.env = env + self.is_learner = is_learner + self.priority_scale = 1 + self.batch_size = 0 + self.buffer_capacity = 0 + + # For post processing + self._off_policy = [] + self._duplicate_weights = [] + self._behind = [] + self._train_return_delay = [] + + @record.event + def get_weights(self): + """ + This returns the weights. _weight[0] is updated when the + train flag is set (meaning a train has happened). + We use this delay because set_weights expect the weights + to be increased by at least one. From the perspective of + the learner this should only happen when train + is called. On startup however we do a get and set without + calling any trains. By initializing the + _update_weights_on_get we can + have increase the weights on the first get. + + This also has the effect that multiple calls to train without + calling get_weights will look like a single model update. + This works with our approximation of on-policy learning. + + Returns + ------- + list + Weights to be sent + """ + if self._update_weights_on_get: + self._weights[0] += 1 + self._update_weights_on_get = False + return self._weights[:] + + @record.event + def set_weights(self, weights): + """ + This sets the weights. The workflow should call set_weights + when it receives an update from the learner. The weights + for this fake agent are a constantly increasing counter(s) that + keeps track of how often train has been called. + From the point of view of the agents, we expect this value to + always be increase by some amount. For on-policy learning this + should only increase by 1. Off-policy learning will increase by + some factor. We can assert how far "off-policy" we find + acceptable. + + Parameters + ---------- + weights : list + The fake weights (counter) to evaluate + """ + # weights[0] is from the learner _weights[1] is on the actor + diff = weights[0] - self._weights[1] + assert diff > 0, "set_weights: recv duplicate weights " + str(weights[0]) + ", " + str(self._weights[1]) + if WorkflowTestConstants.on_policy > -1: + # This wont work for multiple agents... i.e. off-policy + assert diff <= WorkflowTestConstants.on_policy, ("set_weights: off-policy " + str(weights[0]) + + ", " + str(self._weights[1]) + ", policy " + + str(WorkflowTestConstants.on_policy)) + else: + self._off_policy.append(diff) + self._weights[1] = weights[0] + + @record.event + def remember(self, state, action, reward, next_state, done): + """ + This function is used to evaluate if the agent is observing the correct actions + across the environment, agent, and workflow. Each input has an expected state + which is asserted. If the max steps per episode given by the environment or + workflow is given, the expected observations are reset. This test should catch + if the workflow is not updating the current_state = next_state. This will + also increase the _has_data counter which is used by generate data. _has_data + will indicate the total number of times remember has been called. + + Parameters + ---------- + state : int + This is the current state given by the workflow. + The state should be increase by one each time except on reset. + After a reset the value should be zero. + action : int + The is the action given by the workflow. It should be + a number increasing by one each time except on reset. + After a reset the value should be zero. + reward : int + The reward given by the workflow. This should be 1. + next_state : int + The next state following an action given by the workflow. + This value should be one larger than the current state. + done : bool + This flag indicates if the environment is finished coming from + the workflow. This flag should be set if the max number of steps + per episode for the environment or workflow has been reached. + """ + assert self._state == state, "remember: state " + str(self._state) + " == " + str(state) + self._state += 1 + assert self._observed_action == action, "remember: action " + str(self._observed_action) + " == " + str(action) + self._observed_action += 1 + assert self._reward == reward, "remember: reward " + str(self._reward) + " == " + str(reward) + assert self._next_state == next_state, "remember: next_state" + str(self._next_state) + " == " + str(next_state) + self._next_state += 1 + + # We only are concerned with done being set on env max not workflow max... + if next_state == self.env.max_steps or next_state == WorkflowTestConstants.workflow_max_steps: + assert done == (next_state == self.env.max_steps), "remember: done " + str(done) + " == " + str(next_state == self.env.max_steps) + self._action = 0 + self._observed_action = 0 + self._state = 0 + self._next_state = 1 + else: + assert done == False, "remember: done " + str(done) + " == " + str(False) + + # This counter store how many experience we have seen + self._has_data += 1 + + @record.event + def train(self, batch): + """ + This function is used to check if the states given by the environment are + correct. The generate_data function will pass back the weight counters + given to it and a counter for indices/loss. For on-policy learning + the weights should be the same as the current weights. For off-policy + learning the weights should be some reasonable value less. We use this + function to keep a count of how many times train is called. + + We send back "indices and loss" with updated indices[0] to show we have + processed the data. The remaining parts are untouched. + + Parameters + ---------- + batch : pair + The first value is the weights that the learner passed to the agent. + The second value is indices counter given by the agent. + + Returns + ------- + pair + When using priority replay, the indices and weights are passed back + for the agent to validate. + """ + # For a real agent this would be: + # states, target = batch + weights, indices = batch + assert weights[1] <= self._weights[0], "train: data from the future " + str(weights[0]) + ", " + str(self._weights[0]) + if WorkflowTestConstants.behind > -1: + # This assert wont work for multiple agents + assert self._weights[0] - weights[1] <= WorkflowTestConstants.behind, ("train: data is too old " + str(weights[0]) + + ", " + str(self._weights[0]) + ", behind " + + str(WorkflowTestConstants.behind)) + else: + self._behind.append(self._weights[0] - weights[1]) + self._train += 1 + WorkflowTestConstants.do_random_sleep() + + # JS: This comes from old target_train + self._update_weights_on_get = True + + if self.priority_scale: + indices[0] = indices[1] + return indices, weights + + @record.event + def action(self, state): + """ + This is where an agent does inference for a given state to determine the + next action. In this function, we increase the action at the same rate + as the state. We assert the workflow is giving us the correct state. + The action is reset in the remember function when we know done has been + observed by the workflow. We also count the total number of actions + performed. + + Parameters + ---------- + state : int + Current state given by the workflow. This should match what we our + expected state in self._state. + + Returns + ------- + int + The action counter + """ + assert self._state == state, "action: " + str(self._state) + " == " + str(state) + assert self._action < self.env.max_steps, "action: " + str(self._action) + " < " + str(self.env.max_steps) + ret = self._action + self._action += 1 + self._total_action += 1 + return ret, 1 + + @record.event + def has_data(self): + """ + This returns if remember has been called yet (i.e. _has_data counter). + This should correspond to running a step and storing the result in the agent. + + Returns + ------- + bool + If remember has been called. + """ + return self._has_data > 0 + + @record.event + def generate_data(self): + """ + This is a generator that returns the current weights of an agent. This + is linked to the train function of the learner who is expecting to + receive the weights counter back. We increment the indices counter to + keep track of how many times generate data is called before that batch has + been processed. + + Returns + ------- + pair + The weights counters to send to learner's train function. + """ + self._indices[1] += 1 + self._weights_loss_check.append(self._weights[1]) + assert len(self._weights_loss_check) == len(set(self._weights_loss_check)), "There are multiple batches generated from a single model" + yield self._weights[:], self._indices[:] + + @record.event + def train_return(self, args): + """ + This function takes the indices and loss counters sent from the learner. + In this case the indices are a counter and the loss is the weights counter + sent from the agent to the learner and back to the agent for round-trip + verification. We expect them to be the same as what we sent. Since then + the workflow may have updated our weights, sent another batch, or both, + the difference between weights and indices counter will let us know how + long it is taking for the round trip of set_priorities. + + Parameters + ---------- + indices : list + Counter originally coming from agent, sent to learner, and sent back to agent + loss : list + Counter of the weights used when training. See comment in function. + """ + indices, weights = args + assert indices[0] == self._indices[1], "set_priorities: " + str(indices[0]) + " == " + str(self._indices[1]) + assert indices[2] == ExaComm.global_comm.rank, "indices are not for this rank " + str(ExaComm.global_comm.rank) + " " + str(indices[2]) + assert weights[1] in self._weights_loss_check, "set_priorities: " + str(weights[1]) + " not in " + str(self._weights_loss_check) + self._weights_loss_check.remove(weights[1]) + self._train_return_delay.append(self._weights[1] - weights[1]) + + +if __name__ == "__main__": + """ + This is if we want to run this outside of pytest. + """ + + # Defaults + num_learners = 1 + procs_per_env = 1 + workflow_name = 'rma' + episodes = 10 + steps = 10 + + # Command line parameters + if len(sys.argv) == 6: + num_learners = int(sys.argv[1]) + procs_per_env = int(sys.argv[2]) + workflow_name = str(sys.argv[3]) + episodes = int(sys.argv[4]) + steps = int(sys.argv[5]) + else: + print("[STAND-ALONE WORKFLOW TEST] Require 5 args: num_learners procs_per_env workflow_name episodes steps") + print("[STAND-ALONE WORKFLOW TEST] Running with default.") + + print("[STAND-ALONE WORKFLOW TEST] num_learners:", num_learners, + "procs_per_env", procs_per_env, + "workflow_name", workflow_name, + "episodes", episodes, + "steps", steps, + flush=True) + + # Set constants + WorkflowTestConstants.episodes = episodes + WorkflowTestConstants.env_max_steps = steps + WorkflowTestConstants.workflow_max_steps = steps + + # Set params + dir_name = './log_dir' + initialize_parameters(params={"mpi4py_rc": False, + "log_level": [3, 3], + "log_frequency": 1, + "output_dir": dir_name, + "episode_block": False, + "batch_episode_frequency": 1, + "batch_step_frequency": 1, + "n_episodes": episodes, + "n_steps": steps, + "save_weights_per_episode": False, + "profile": None, + "clip_rewards": False, + "rolling_reward_length": 4, + "cutoff" : 0.00000}) + + # Set up comm + ExaSimple(None, procs_per_env, num_learners) + + # Make log dir + rank = ExaComm.global_comm.rank + made_dir = False + if rank == 0 and not os.path.isdir(dir_name): + os.mkdir(dir_name) + made_dir = True + + # Register fake env and agent + gym.envs.registration.register(id=FakeEnv.name, entry_point=FakeEnv) + exarl.agents.registration.register(id=FakeAgent.name, entry_point=FakeAgent) + + # Create fake env, agent, and learner with real workflow + env = None + agent = None + if ExaComm.is_actor(): + env = ExaEnv(gym.make(FakeEnv.name).unwrapped) + if ExaComm.is_agent(): + agent = exarl.agents.make(FakeAgent.name, env=env, is_learner=ExaComm.is_learner()) + workflow = exarl.workflows.make(workflow_name) + learner = FakeLearner(episodes, steps, agent, env, workflow, dir_name) + + # learner.run() + # learner.print_delays() + + # Run and print record if failure + try: + print("[STAND-ALONE WORKFLOW TEST] Running from rank", ExaComm.global_comm.rank, flush=True) + learner.run() + except Exception as e: + for i in record.events: + print(i) + traceback.print_exc() + print("Exception", e, flush=True) + + # Clean up log if created + ExaComm.global_comm.barrier() + if made_dir: + os.rmdir(dir_name) diff --git a/utests/workflow_trace.py b/utests/workflow_trace.py new file mode 100644 index 00000000..3c9d8cc0 --- /dev/null +++ b/utests/workflow_trace.py @@ -0,0 +1,711 @@ +import sys +import os +import numpy as np +import gym +from gym import spaces +import exarl +from exarl.utils.candleDriver import initialize_parameters +from exarl.utils.globals import ExaGlobals +from exarl.base.comm_base import ExaComm +from exarl.network.simple_comm import ExaSimple +from exarl.base.env_base import ExaEnv +from exarl.base.agent_base import ExaAgent +from exarl.envs.env_vault.UnitEvn import EnvGenerator +import functools +import time +import random + +class record: + """" + This class implements vector clocks: + https://en.wikipedia.org/wiki/Vector_clock + https://people.cs.rutgers.edu/~pxk/417/notes/logical-clocks.html + Vector clock give us the ability to create partial orderings. + We can use this to under stand what things are happening in parallel + and this gives us a better view of how workflows are working. + + Vector clocks are implemented by having p counters (i.e. clock) on + each process (i.e. rank). P is the total number of processes (thus + we have P^2 total clock across all ranks). We increase our clock + (i.e. clock[rank]) every event we encounter. When we "send" a + receive a message we update our vector of clocks to the max time + (i.e. count) observed by each clock. + + When an event occurs and we increase our clock, we also record + the event with a timestamp (i.e. the state of a rank's vector clock). + At the end we can create a partial order by merging the records + from every rank into one based on two key conditions: + + 1. Two event happen at the same time if all of the clock are equal. + 2. Assuming two event have clocks that are not equal, an event a + happens before event b if all of a's clocks are less than or equal + to b's clocks + + To check for greater than we invert condition 2 and evaluate b vs a. + If the events are neither = < >, then the events are happening + "concurrently" (i.e. we have a partial order). + + This is not a complete DAG, as we are still developing the partial + order based on the observed order of events. In otherwords, events + could be reordered from the point of view of execution reduce the + number of dependencies. + + To create a complete view of the events across a run, we gather all + the events from each node and stitch them together. Since events + are recorded in order on a single node, we do not need to perform + a complete sort (rather we have just log(n) merging). + + Events are recorded via a decorator, which we attach to each function + we care about. Functions that can be seen as message sends, will + call get_clock_to_send while messages that receive will call update_clocks. + + Attributes + ---------- + counters : Dictionary + This contains a name of each function and how many times it ran + events : List + This contains a list of events that have occurred on a single node + clocks : list + These are clocks, one for each rank + """ + counters = None + events = None + clocks = None + + def reset(num_nodes): + """ + Resets the record. + + Parameters + ---------- + verbose : bool + Flag indicating to print on each event + """ + record.counters = {} + record.events = [] + record.clocks = [0] * num_nodes + + def get_clock_to_send(): + """ + This function adds one to ranks clock and returns + a copy of the clock to send. + + Returns + ------- + list + A copy of the vector clock + """ + record.clocks[ExaComm.global_comm.rank] += 1 + return record.clocks[:] + + def update_clock(clocks): + """ + This receives a vector clock and updates the local + vector clock with the max per rank. + + Parameters + ---------- + clocks : list + Incoming vector clock + """ + record.clocks = [max(a, b) for a, b in zip(record.clocks, clocks)] + + def equal(A, B): + """ + This compares two clocks to see if they are equal. + They are only equal if all of clocks are equal. + + Parameters + ---------- + A : list + Vector clock + A : list + Vector clock + """ + for a, b in zip(A[2], B[2]): + if(a != b): + return False + return True + + def less_than(A, B): + """ + This compares two clocks to see if A is less than B. + We assume that A != B !!! A's clocks must be + less than or equal to B for event A to have occurred + before B. + + Parameters + ---------- + A : list + Vector clock + B : list + Vector clock + + Returns + ------- + bool + If A occurred before B + """ + # We assume that A != B + for a, b in zip(A[2], B[2]): + if(a > b): + return False + return True + + def compare(A, B): + """ + This does a full comparison of two vector clocks. We return: + -1 iff A occurs before B + 1 iff B occurs before A + 0 otherwise + We do this by checking A == B, A < B, B < A in order. + + Parameters + ---------- + A : list + Vector clock + B : list + Vector clock + + Returns + ------- + int + -1 iff A occurs before B, 1 iff B occurs before A, and 0 otherwise + """ + if record.equal(A, B): + return 0 + if record.less_than(A, B): + return -1 + # We still have to check again because the + # two could still be concurrent + if record.less_than(B, A): + return 1 + # They are concurrent! + return 0 + + def sort(data): + """ + This function sorts events from every rank. + We assume that events within a rank are ordered + based on observation. + + Parameters + ---------- + data : list + List of list of events + + Returns + ------- + list + Single list of all events + """ + total_size = sum([len(i) for i in data]) + total = data[0] + for B in data[1:]: + aIndex = 0 + bIndex = 0 + while bIndex < len(B): + if aIndex == len(total): + total += B[bIndex:] + break + elif record.compare(total[aIndex], B[bIndex]) == 1: + total.insert(aIndex, B[bIndex]) + bIndex += 1 + aIndex += 1 + assert total_size == len(total), str(total_size) + " vs " + str(len(total)) + return total + + def event(func): + """ + This is a decorator to put ontop of a function. It will record + how many times it has been call in the counters dictionary and + add an entry under events. It will also increment the appropriate + clock within the vector clocks. + + Parameters + ---------- + func : function + This is the function to record + + Returns + ------- + result + Returns the result of the function + """ + @functools.wraps(func) + def wrapper(*args, **kwargs): + result = func(*args, **kwargs) + if func.__name__ in record.counters: + record.counters[func.__name__] += 1 + else: + record.counters[func.__name__] = 1 + record.clocks[ExaComm.global_comm.rank] += 1 + record.events.append((ExaComm.global_comm.rank, record.counters[func.__name__], record.clocks[:], func.__name__,)) + + return result + return wrapper + +class WorkflowTestConstants: + """ + This is a helper class/namespace to add a constants set by the workflow + for the fake environment. Environment creation goes through gym and + it is easier to just set a global. + + Attributes + ---------- + episodes : int + The maximum number of episodes + env_max_steps : int + The maximum number of steps set in the environment + workflow_max_steps : int + The maximum number of steps set in the workflow + rank_sleep : bool + Flag to turn on sleeping in step and train based on + rank + random_sleep : bool + Flag to turn on sleeping in step and train based on + a random amount + """ + episodes = None + env_max_steps = None + workflow_max_steps = None + rank_sleep = False + random_sleep = False + + def do_random_sleep(): + """ + This function look at the constants and performs a sleep + for some amount of microseconds + """ + if WorkflowTestConstants.rank_sleep > 0: + time.sleep(ExaComm.global_comm.rank * 10**(-3)) + elif WorkflowTestConstants.random_sleep > 0: + time.sleep(int(random.random() * 100) * 10**(-4)) + +class FakeLearner: + """ + This class is used to fake out a learner base. It seems all we really + need is something that can link the workflow, agent, and environment + together plus the number of episodes and steps. + + Attributes + ---------- + global_comm : ExaComm + The global comm + global_size : int + Size of the global comm + nepisodes : int + Number of total episodes to run + nsteps : int + Number of max steps per episode + agent : ExaAgent + Fake agent to use for testing + env : ExaEnv + Fake environment to use for testing + workflow : ExaWorkflow + Workflow to test + results_dir : String + Directory to put logs into + action_type : int + Used to indicate what actions to take + """ + def __init__(self, nepisodes, nsteps, agent, env, workflow, results_dir): + """ + Parameters + ---------- + nepisodes : int + Total number of episodes to run + nsteps : int + Max number of steps per episode to run + agent : ExaAgent + Fake agent used for testing + env : ExaEnv + Fake environment used for testing + workflow : ExaWorkflow + The environment to test + results_dir : String + Directory where logs are written + """ + # Doubt we accually need self.global_comm and self.global_size + self.global_comm = ExaComm.global_comm + self.global_size = ExaComm.global_comm.size + self.nepisodes = nepisodes + self.nsteps = nsteps + self.agent = agent + self.env = env + self.workflow = workflow + self.results_dir = results_dir + self.action_type = None + + def run(self): + """ + Runs the workflow to test. + """ + self.workflow.run(self) + +class FakeEnv(gym.Env): + """ + This is a fake environment. We use it in coordination with the + fake agent to ensure that the correct data is passed between + the environment and the learner. The state returned from this + environment always starts at zero (from reset). State increases + by one each time until it sets done. We assert that the action + is increasing by one at the same rate as the state. We also + assert that the step is not called when the environment is done. + + Attributes + ---------- + name : string + Name of the fake environment + action_space : gym space + Env's action space. We set this to discrete for counting. + It shouldn't matter that we only test one type. Space type + testing is done in agent tests. + observation_space : gym space + Env's observation space. We set this to discrete for counting. + It shouldn't matter that we only test one type. Space type + testing is done in agent tests. + state : int + The current state of the environment. Is int because we are using discrete space. + max_steps : int + The max steps the environment can take. + """ + + name = "FakeEnv-v0" + + def __init__(self): + super().__init__() + self.action_space = spaces.Discrete(WorkflowTestConstants.env_max_steps) + self.observation_space = spaces.Discrete(WorkflowTestConstants.env_max_steps) + + self.state = 0 + self.max_steps = WorkflowTestConstants.env_max_steps + + @record.event + def step(self, action): + """ + This is a single step. If number of calls == max steps + done is set. State is always incremented by 1. + + Parameters + ---------- + action : int + This is the step to perform. Its an int since the action + space is Discrete. + + Returns + ------- + Pair + Next state, reward, done, and info + """ + if self.state < self.max_steps: + self.state += 1 + done = self.state == self.max_steps + + WorkflowTestConstants.do_random_sleep() + return self.state, 1, done, {} + + @record.event + def reset(self): + """ + This resets the environment. + + Returns + ------- + int + The fresh restated state + """ + self.state = 0 + return self.state + +class FakeAgent(ExaAgent): + """ + This class is a fake agent. Each method is tagged with vector clocks to + keep track of events. A send is a method that will generate data for + another rank. A receive is a method that will take data in from another + rank. Instead of passing weight, indices, or loss around, we replace + this with passing the vector clocks allowing us to create the partial + orders. + + Attributes + ---------- + name : string + Name of the fake agent + _has_data : int + Counts how many times remember has been called + _data : int + Garbage data to satisfy the api requirements + env : ExaEnv + The fake environment + is_learner : bool + Flag indicating if we are a learner. + priority_scale : float + Indicates if we are using experience replay + batch_size : int + The max size of a single batch + buffer_capacity : int + The capacity of the memory for the agent + epsilon : float + Not well used... + tau : float + Commonly used in target train, but not in the fake one. + """ + name = "FakeAgent-v0" + + def __init__(self, env=None, is_learner=False): + """ + Parameters + ---------- + env : ExaEnv + The fake environment used in test + is_learner : bool + Indicates if agent is learner + """ + self._has_data = 0 + self._data = [0] + + # These are "required" members + self.env = env + self.is_learner = is_learner + self.priority_scale = 1 + self.batch_size = 0 + self.buffer_capacity = 0 + self.epsilon = 1 + self.tau = 1 + + @record.event + def get_weights(self): + """ + Getting the weights can be seen as a send + function as the weights are collected to pass + to another rank. We replace the weights with + the clock. + + Returns + ------- + list + Weights aka the rank's vector clock + """ + # This is where the learner sends to the actors + return record.get_clock_to_send() + + @record.event + def set_weights(self, weights): + """ + This is the receive for the vector clocks originating + from get_weights. We update our local clock with + incoming clocks. + + Parameters + ---------- + weights : list + This is the incoming vector clock + """ + # This is where actor receives learner + record.update_clock(weights) + + @record.event + def remember(self, state, action, reward, next_state, done): + """ + We keep track that data has been generated, but do not + require to keep track of anything else. All parameters + are ignored. When using priority_scale this function + sends its vector clock back to the agent. + """ + self._has_data += 1 + + @record.event + def train(self, batch): + """ + This is the receive of a vector clock coming from a agent rank. + We update our clock accordingly. + + Parameters + ---------- + batch : pair + The first is junk data. The second is the incoming vector clock. + + Returns + ------- + pair + When using priority replay, the first value is junk and the second + is our vector clock. + """ + _, clocks = batch + # This is where the learner receives from the agent + record.update_clock(clocks) + WorkflowTestConstants.do_random_sleep() + if self.priority_scale: + # This is where the learner sends to the agent + return self._data, record.get_clock_to_send() + + @record.event + def target_train(self): + """ + This function does not need to do anything + but record via its decorator. + """ + pass + + @record.event + def action(self, state): + """ + This function is a send from the lead of the environment + to the rest of the environment ranks in its env comm. + + Parameters + ---------- + state : int + Don't care + + Returns + ------- + List + Our vector clock to send + """ + return record.get_clock_to_send(), 1 + + @record.event + def has_data(self): + """ + This returns if remember has been called yet (i.e. _has_data counter). + This should correspond to the total ran steps for a given agent. + + Returns + ------- + bool + If remember has been called. + """ + return self._has_data > 0 + + @record.event + def generate_data(self): + """ + This is generator is a send from the agent to the learner. + + Returns + ------- + pair + The first value is junk and the second is our vector clock. + """ + # This is where the agent sends to the learner + yield [self._data], record.get_clock_to_send() + + @record.event + def set_priorities(self, indices, loss): + """ + This is the receive function coming from the learners train + when priority_scale is turned on. + + Parameters + ---------- + indices : list + Don't care + loss : list + This is the incoming vector clock + """ + record.update_clock(loss) + + +if __name__ == "__main__": + """ + This is if we want to run this outside of pytest. + """ + num_learners = 1 + procs_per_env = 1 + workflow_name = 'sync' + episodes = 10 + steps = 10 + + # Command line parameters + if len(sys.argv) == 6: + num_learners = int(sys.argv[1]) + procs_per_env = int(sys.argv[2]) + workflow_name = str(sys.argv[3]) + episodes = int(sys.argv[4]) + steps = int(sys.argv[5]) + else: + print("[STAND-ALONE WORKFLOW TEST] Require 5 args: num_learners procs_per_env workflow_name episodes steps") + print("[STAND-ALONE WORKFLOW TEST] Running with default.") + + print("[STAND-ALONE WORKFLOW TEST] num_learners:", num_learners, + "procs_per_env", procs_per_env, + "workflow_name", workflow_name, + "episodes", episodes, + "steps", steps, + flush=True) + + # Set constants + WorkflowTestConstants.episodes = episodes + WorkflowTestConstants.env_max_steps = steps + WorkflowTestConstants.workflow_max_steps = steps + + # Set params + dir_name = './log_dir' + initialize_parameters(params={"mpi4py_rc": "false", + "log_level": [3, 3], + "output_dir": dir_name, + "episode_block": "false", + "batch_frequency": 1, + "n_episodes": episodes, + "n_steps": steps, + "save_weights_per_episode": "false", + "profile": "None"}) + + # Init comms and record + ExaSimple(None, procs_per_env, num_learners) + record.reset(ExaComm.global_comm.size) + + # Make log dir + rank = ExaComm.global_comm.rank + made_dir = False + if rank == 0 and not os.path.isdir(dir_name): + os.mkdir(dir_name) + made_dir = True + + # Register fake env and agent + gym.envs.registration.register(id=FakeEnv.name, entry_point=FakeEnv) + exarl.agents.registration.register(id=FakeAgent.name, entry_point=FakeAgent) + + # Create fake env, agent, and learner with real workflow + env = None + agent = None + if ExaComm.is_actor(): + env = ExaEnv(gym.make(FakeEnv.name).unwrapped) + if ExaComm.is_agent(): + agent = exarl.agents.make(FakeAgent.name, env=env, is_learner=ExaComm.is_learner()) + workflow = exarl.workflows.make(workflow_name) + learner = FakeLearner(episodes, steps, agent, env, workflow, dir_name) + + # Run workflow + learner.run() + # record.print() + + # Collect records, sort, and print + if ExaComm.global_comm.rank: + ExaComm.global_comm.send(record.events, 0) + else: + data = None + all = [record.events] + for i in range(1, ExaComm.global_comm.size): + data = ExaComm.global_comm.recv(data, source=i) + all.append(data) + all = record.sort(all) + + last = 0 + group = [(0, 0)] + for i in range(1, len(all)): + res = record.compare(all[i - 1], all[i]) + if res == -1: + last += 1 + group.append((last, res)) + + for i, j in zip(all, group): + print(i[0], i[1], j[0], j[1], i[2], i[3]) + +# TODO: Make test out of record +# Use batch size for the lower bound on over-training +# Use memory size / window size for losing data + +# To figure out how many look at sorted list and find where comp = 0 +# then back track to where learner