{ "cells": [ { "cell_type": "markdown", "id": "eace5ee0-82ec-459a-80e8-faa2c7030f73", "metadata": { "tags": [] }, "source": [ "# Scaling CMA-MAE on the Sphere Benchmark\n", "\n", "_This tutorial is part of the series of pyribs tutorials! See [here](https://docs.pyribs.org/en/stable/tutorials.html) for the list of all tutorials and the order in which they should be read._\n", "\n", "One challenge in applying CMA-MAE is its quadratic time complexity. Internally, CMA-MAE relies on CMA-ES, which has $\\Theta(n^2)$ time and space complexity due to operations on an $n \\times n$ covariance matrix. Thus, CMA-ES and hence CMA-MAE can be computationally intractable when a problem involves millions or even just thousands of parameters. To address this issue, [Tjanaka 2022](https://scalingcmamae.github.io) proposes to replace CMA-ES with more efficient evolution strategies (ESs), resulting in several variants of CMA-MAE. The CMA-MAE variants proposed in the paper and supported in pyribs are as follows:\n", "\n", "- LM-MA-MAE: Replaces CMA-ES with [Limited Memory Matrix Adaptation ES (LM-MA-ES)](https://ieeexplore.ieee.org/document/8410043), which has $\\Theta(kn)$ runtime.\n", "- sep-CMA-MAE: Replaces CMA-ES with [separable CMA-ES (sep-CMA-ES)](https://inria.hal.science/inria-00270901v1/document), which constrains the covariance matrix to be diagonal and has $\\Theta(n)$ runtime.\n", "- OpenAI-MAE: Replaces CMA-ES with [OpenAI-ES](https://arxiv.org/abs/1703.03864), which performs search by sampling from an isotropic Gaussian and has $\\Theta(n)$ runtime.\n", "\n", "This tutorial shows how these different variants of CMA-MAE can be accessed by changing the `es` parameter in the [`EvolutionStrategyEmitter`](https://docs.pyribs.org/en/stable/api/ribs.emitters.EvolutionStrategyEmitter.html).\n", "\n", "_Note: This tutorial is based on the [CMA-MAE tutorial](https://docs.pyribs.org/en/stable/tutorials/cma_mae.html). As such, we skim over details like how to set up the archives. For more details on these steps, please refer to that tutorial._" ] }, { "cell_type": "markdown", "id": "4e35386c", "metadata": { "id": "4e35386c", "tags": [] }, "source": [ "## Setup" ] }, { "cell_type": "code", "execution_count": null, "id": "9562ca7d-0e1a-4916-86b0-67b8254a79c7", "metadata": {}, "outputs": [], "source": [ "%pip install ribs[visualize] tqdm" ] }, { "cell_type": "code", "execution_count": 2, "id": "fa90af0b-d7bb-477e-84a6-f384327e9d34", "metadata": {}, "outputs": [], "source": [ "import sys\n", "\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from tqdm import tqdm, trange" ] }, { "cell_type": "markdown", "id": "e1900b33", "metadata": { "id": "e1900b33" }, "source": [ "## The Sphere Linear Projection Benchmark\n", "\n", "In this tutorial, we use a 1000-dimensional version of the sphere benchmark. At this dimensionality, CMA-MAE becomes extremely slow due to its quadratic complexity." ] }, { "cell_type": "code", "execution_count": 3, "id": "8cb2801c", "metadata": { "id": "8cb2801c" }, "outputs": [], "source": [ "def sphere(solution_batch):\n", " \"\"\"Sphere function evaluation and measures for a batch of solutions.\n", "\n", " Args:\n", " solution_batch (np.ndarray): (batch_size, dim) batch of solutions.\n", " Returns:\n", " objective_batch (np.ndarray): (batch_size,) batch of objectives.\n", " measures_batch (np.ndarray): (batch_size, 2) batch of measures.\n", " \"\"\"\n", " dim = solution_batch.shape[1]\n", "\n", " # Shift the Sphere function so that the optimal value is at x_i = 2.048.\n", " sphere_shift = 5.12 * 0.4\n", "\n", " # Normalize the objective to the range [0, 100] where 100 is optimal.\n", " best_obj = 0.0\n", " worst_obj = (-5.12 - sphere_shift)**2 * dim\n", " raw_obj = np.sum(np.square(solution_batch - sphere_shift), axis=1)\n", " objective_batch = (raw_obj - worst_obj) / (best_obj - worst_obj) * 100\n", "\n", " # Calculate measures.\n", " clipped = solution_batch.copy()\n", " clip_mask = (clipped < -5.12) | (clipped > 5.12)\n", " clipped[clip_mask] = 5.12 / clipped[clip_mask]\n", " measures_batch = np.concatenate(\n", " (\n", " np.sum(clipped[:, :dim // 2], axis=1, keepdims=True),\n", " np.sum(clipped[:, dim // 2:], axis=1, keepdims=True),\n", " ),\n", " axis=1,\n", " )\n", "\n", " return objective_batch, measures_batch" ] }, { "cell_type": "markdown", "id": "256a9c7a-a20a-4ab2-8376-65ccd640fc83", "metadata": {}, "source": [ "## Archive Setup\n", "\n", "Note this archive has higher resolution (250x250) than the one in the CMA-MAE tutorial (100x100). As described in Appendix K of the [CMA-MAE paper](https://arxiv.org/abs/2205.10752), this is necessary due to the high dimensionality of the domain." ] }, { "cell_type": "code", "execution_count": 4, "id": "aa4e5b4d", "metadata": { "id": "aa4e5b4d" }, "outputs": [], "source": [ "from ribs.archives import GridArchive\n", "\n", "max_bound = 1000 / 2 * 5.12\n", "\n", "archive = GridArchive(solution_dim=1000,\n", " dims=(250, 250),\n", " ranges=[(-max_bound, max_bound), (-max_bound, max_bound)],\n", " learning_rate=0.01,\n", " threshold_min=0.0)\n", "\n", "result_archive = GridArchive(solution_dim=1000,\n", " dims=(250, 250),\n", " ranges=[(-max_bound, max_bound), (-max_bound, max_bound)])" ] }, { "cell_type": "markdown", "id": "1e4d7086-15c2-4c1c-a313-a2b36929ee8e", "metadata": {}, "source": [ "## Emitter Setup with the `es` Parameter\n", "\n", "Exactly like in the regular CMA-MAE, scalable variants of CMA-MAE are built with the [`EvolutionStrategyEmitter`](https://docs.pyribs.org/en/stable/api/ribs.emitters.EvolutionStrategyEmitter.html). The key difference is the choice of ES, which is indicated with the `es` parameter. `es` has the following options:\n", "\n", "- `lm_ma_es`: Indicates LM-MA-ES\n", "- `sep_cma_es`: Indicates sep-CMA-ES\n", "- `openai_es`: Indicates OpenAI-ES\n", "\n", "Below, we first show how to use `sep_cma_es` by passing `es=\"sep_cma_es\"`." ] }, { "cell_type": "code", "execution_count": 5, "id": "beb8f299", "metadata": { "id": "beb8f299" }, "outputs": [], "source": [ "from ribs.emitters import EvolutionStrategyEmitter\n", "\n", "emitters = [\n", " EvolutionStrategyEmitter(\n", " archive,\n", " x0=np.zeros(1000),\n", " sigma0=0.5,\n", " ranker=\"imp\",\n", " es=\"sep_cma_es\",\n", " selection_rule=\"mu\",\n", " restart_rule=\"basic\",\n", " batch_size=36\n", " ) for _ in range(15)\n", "]" ] }, { "cell_type": "markdown", "id": "9df5e6fc-1840-4365-8f71-9b22f54731b0", "metadata": {}, "source": [ "It is also possible to pass in `es` as a class, as the string options to `es` are simply translated to a corresponding ES class (the documentation for all ES classes is [here](https://docs.pyribs.org/en/stable/api/ribs.emitters.opt.html)). All ES classes are subclasses of [`EvolutionStrategyBase`](https://docs.pyribs.org/en/stable/api/ribs.emitters.opt.EvolutionStrategyBase.html)." ] }, { "cell_type": "code", "execution_count": 6, "id": "5714de30-8e36-4752-83d8-1a567776ff98", "metadata": {}, "outputs": [], "source": [ "from ribs.emitters.opt import SeparableCMAEvolutionStrategy\n", "\n", "emitters_v2 = [\n", " EvolutionStrategyEmitter(\n", " archive,\n", " x0=np.zeros(1000),\n", " sigma0=0.5,\n", " ranker=\"imp\",\n", " es=SeparableCMAEvolutionStrategy,\n", " selection_rule=\"mu\",\n", " restart_rule=\"basic\",\n", " batch_size=36\n", " ) for _ in range(15)\n", "]" ] }, { "cell_type": "markdown", "id": "80c2f899-2d38-468b-a42d-c3a162855a67", "metadata": {}, "source": [ "Some ESs also accept kwargs. For instance, in [LMMAEvolutionStrategy](https://docs.pyribs.org/en/stable/api/ribs.emitters.opt.LMMAEvolutionStrategy.html), the size of the approximation can be adjusted with the `n_vectors` parameter. kwargs can be passed to the ESs with the `es_kwargs` parameter in `EvolutionStrategyEmitter`, as shown below." ] }, { "cell_type": "code", "execution_count": 7, "id": "a34a3026-2beb-43f2-8858-22ae06f70a5d", "metadata": {}, "outputs": [], "source": [ "# Regular instantiation of EvolutionStrategyEmitter with `lm_ma_es`.\n", "lm_ma_emitters = [\n", " EvolutionStrategyEmitter(\n", " archive,\n", " x0=np.zeros(1000),\n", " sigma0=0.5,\n", " ranker=\"imp\",\n", " es=\"lm_ma_es\",\n", " selection_rule=\"mu\",\n", " restart_rule=\"basic\",\n", " batch_size=36\n", " ) for _ in range(15)\n", "]\n", "\n", "# Instantiation of EvolutionStrategyEmitter with `lm_ma_es` and kwargs.\n", "lm_ma_emitters_v2 = [\n", " EvolutionStrategyEmitter(\n", " archive,\n", " x0=np.zeros(1000),\n", " sigma0=0.5,\n", " ranker=\"imp\",\n", " es=\"lm_ma_es\",\n", " es_kwargs={\"n_vectors\": 20},\n", " selection_rule=\"mu\",\n", " restart_rule=\"basic\",\n", " batch_size=36\n", " ) for _ in range(15)\n", "]" ] }, { "cell_type": "markdown", "id": "cb8ef8be-945e-475e-a7c0-7ea2c0039e51", "metadata": {}, "source": [ "Finally, [`GradientArborescenceEmitter`](https://docs.pyribs.org/en/stable/api/ribs.emitters.GradientArborescenceEmitter.html) also has as `es` parameter. However, it is less common to use a scalable ES in `GradientArborescenceEmitter` since the ES only operates in objective-measure coefficient space, and that space usually has only a few dimensions." ] }, { "cell_type": "markdown", "id": "1a1b940d", "metadata": { "id": "1a1b940d" }, "source": [ "## Scheduler Setup\n", "\n", "Note that we only use the `emitters` created above with `es=\"sep_cma_es\"`." ] }, { "cell_type": "code", "execution_count": 8, "id": "e5c4f108", "metadata": { "id": "e5c4f108" }, "outputs": [], "source": [ "from ribs.schedulers import Scheduler\n", "\n", "scheduler = Scheduler(archive, emitters, result_archive=result_archive)" ] }, { "cell_type": "markdown", "id": "391d7c7a-c9b5-4e46-910a-3ef66940f50d", "metadata": {}, "source": [ "## Running Scalable CMA-MAE\n", "\n", "Finally, we run the scalable CMA-MAE variant created above on a 1000-dimensional sphere function." ] }, { "cell_type": "code", "execution_count": 9, "id": "9bf03e8d", "metadata": { "colab": { "base_uri": "https://localhost:8080/" }, "id": "9bf03e8d", "outputId": "c89a1865-76df-4b27-8225-2afefffa151d" }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Iteration 500 | Archive Coverage: 7.370% Normalized QD Score: 6.729 \n", "Iteration 1000 | Archive Coverage: 12.394% Normalized QD Score: 10.728 \n", "Iteration 1500 | Archive Coverage: 15.531% Normalized QD Score: 13.100 \n", "Iteration 2000 | Archive Coverage: 17.366% Normalized QD Score: 14.356 \n", "Iteration 2500 | Archive Coverage: 19.149% Normalized QD Score: 15.670 \n", "Iteration 3000 | Archive Coverage: 19.944% Normalized QD Score: 16.195 \n", "Iteration 3500 | Archive Coverage: 21.136% Normalized QD Score: 17.101 \n", "Iteration 4000 | Archive Coverage: 22.966% Normalized QD Score: 18.396 \n", "Iteration 4500 | Archive Coverage: 24.563% Normalized QD Score: 19.464 \n", "Iteration 5000 | Archive Coverage: 25.526% Normalized QD Score: 20.108 \n", "Iteration 5500 | Archive Coverage: 26.158% Normalized QD Score: 20.590 \n", "Iteration 6000 | Archive Coverage: 26.355% Normalized QD Score: 20.834 \n", "Iteration 6500 | Archive Coverage: 26.579% Normalized QD Score: 21.059 \n", "Iteration 7000 | Archive Coverage: 26.579% Normalized QD Score: 21.132 \n", "Iteration 7500 | Archive Coverage: 26.667% Normalized QD Score: 21.257 \n", "Iteration 8000 | Archive Coverage: 26.667% Normalized QD Score: 21.340 \n", "Iteration 8500 | Archive Coverage: 26.667% Normalized QD Score: 21.377 \n", "Iteration 9000 | Archive Coverage: 26.667% Normalized QD Score: 21.441 \n", "Iteration 9500 | Archive Coverage: 26.667% Normalized QD Score: 21.455 \n", "Iteration 10000 | Archive Coverage: 26.667% Normalized QD Score: 21.479 \n", "Iterations: 100%|███████████████████████████████████████| 10000/10000 [03:30<00:00, 47.41it/s]\n" ] } ], "source": [ "total_itrs = 10_000\n", "\n", "for itr in trange(1, total_itrs + 1, file=sys.stdout, desc='Iterations'):\n", " solution_batch = scheduler.ask()\n", " objective_batch, measure_batch = sphere(solution_batch)\n", " scheduler.tell(objective_batch, measure_batch)\n", "\n", " # Output progress every 500 iterations or on the final iteration.\n", " if itr % 500 == 0 or itr == total_itrs:\n", " tqdm.write(f\"Iteration {itr:5d} | \"\n", " f\"Archive Coverage: {result_archive.stats.coverage * 100:6.3f}% \"\n", " f\"Normalized QD Score: {result_archive.stats.norm_qd_score:6.3f}\")" ] }, { "cell_type": "markdown", "id": "17207b65", "metadata": { "id": "17207b65" }, "source": [ "## Visualization" ] }, { "cell_type": "code", "execution_count": 10, "id": "3d03f124-0073-4f6c-9401-454b0b00afdf", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from ribs.visualize import grid_archive_heatmap\n", "\n", "plt.figure(figsize=(8, 6))\n", "grid_archive_heatmap(result_archive, vmin=0, vmax=100)" ] }, { "cell_type": "markdown", "id": "b31610ae-18aa-430b-bc9d-ca9d75f216b0", "metadata": {}, "source": [ "## Citation\n", "\n", "If you find this tutorial useful, please cite it as:\n", "\n", "```text\n", "@article{pyribs_scalable_cma_mae,\n", " title = {Scaling CMA-MAE on the Sphere Benchmark},\n", " author = {Henry Chen and Bryon Tjanaka and Stefanos Nikolaidis},\n", " journal = {pyribs.org},\n", " year = {2023},\n", " url = {https://docs.pyribs.org/en/stable/tutorials/cma_mae.html}\n", "}\n", "```" ] } ], "metadata": { "colab": { "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.8.17" } }, "nbformat": 4, "nbformat_minor": 5 }