{"repo_id":"blackbox-gradient-sensing","entity_id":"py:train","uri":"program://blackbox-gradient-sensing/module/train#L1-L112","kind":"module","name":"train","path":"train.py","language":"python","start_line":1,"end_line":112,"context_start_line":1,"context_end_line":112,"code":"from adam_atan2_pytorch import AdoptAtan2\nfrom blackbox_gradient_sensing import BlackboxGradientSensing, Actor\n\n# sim environment, example using gymansium\n\nimport gymnasium as gym\n\ncontinuous = True\n\nsim = gym.make(\n    'LunarLander-v3',\n    render_mode = 'rgb_array',\n    continuous = continuous\n)\n\ndim_state = sim.observation_space.shape[0]\n\n# hyperparams\n\nnum_noises = 100      # number of noise perturbations, from which top is chosen for a weighted update - in paper this was 200 for sim, 3 for real\nnum_selected = 15     # number of elite perturbations chosen\nnum_repeats = 4       # number of repeats (j in eq) - in paper they did ~10 for sim, then 3 for real\n\nuse_genetic_algorithm = False\ndim_gene = 32\nnum_genes = 3\nnum_selected = 2\ntournament_size = 2\n\nuse_cpu = True\ntorch_compile_actor = False\n\n# recording\n\nmin_eps_before_update = 1000\n\n# instantiate BlackboxGradientSensing with the Actor (with right number of actions), and then forward your environment for the actor to learn from it\n# you can also supply your own Actor, which simply receives a state tensor and outputs action logits\n\nnum_actions = sim.action_space.n if not continuous else sim.action_space.shape[0]\n\nactor = Actor(\n    dim_state = dim_state,\n    num_actions = num_actions,\n    continuous = continuous,\n    dim_latent = dim_gene,\n    accepts_latent = use_genetic_algorithm,\n    sample = True,\n    weight_norm_linears = True\n)\n\nbgs = BlackboxGradientSensing(\n    actor,    \n    noise_pop_size = num_noises,\n    num_selected = num_selected,\n    num_rollout_repeats = num_repeats,\n    actor_is_recurrent = True,\n    use_ema = True,\n    optim_klass = AdoptAtan2,\n    optim_step_post_hook = lambda: actor.norm_weights_(),\n    torch_compile_actor = torch_compile_actor,\n    mutate_latent_genes = True,\n    crossover_after_step = 100,\n    crossover_every_step = 50,\n    num_std_below_mean_thres_accept = -0.25,\n    sample_actions_from_actor = False,\n    factorized_noise = True,\n    orthogonalized_noise = True,\n    cpu = use_cpu,\n    optim_kwargs = dict(\n        cautious_factor = 0.1,\n    ),\n    state_norm = dict(\n        dim_state = dim_state\n    ),\n    latent_gene_pool = dict(\n        dim = dim_gene,\n        num_islands = 1,\n        num_genes_per_island = num_genes,\n        num_selected = num_selected,\n        tournament_size = tournament_size\n    ) if use_genetic_algorithm else None\n)\n\n# recording logic\n\nif bgs.is_main:\n    from math import ceil\n    from shutil import rmtree\n\n    video_folder = './recording'\n    rmtree(video_folder, ignore_errors = True)\n\n    den = bgs.num_episodes_per_learning_cycle\n\n    total_eps_before_update = ceil(min_eps_before_update / den) * den\n\n    sim = gym.wrappers.RecordVideo(\n        env = sim,\n        video_folder = video_folder,\n        name_prefix = 'lunar-lander',\n        episode_trigger = lambda eps_num: (eps_num % total_eps_before_update == 0),\n        disable_logger = True\n    )\n\n# pass the simulation environment in - say for 1000 interactions with env\n\nbgs(sim, 10000)\n\n# after much training, save and then finetune on real environment\n\nbgs.save('./sim-trained-actor-and-state-norm.pt')","source_hash":"048fadfa9432532ea46961e6d6ba080276229eb36660f33b0db333a9b2e8028e","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs","uri":"program://blackbox-gradient-sensing/module/blackbox_gradient_sensing.bgs#L1-L1204","kind":"module","name":"blackbox_gradient_sensing.bgs","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":1,"end_line":1204,"context_start_line":1,"context_end_line":1204,"code":"from __future__ import annotations\n\nimport random\nfrom random import randrange, choice\n\nfrom math import sqrt\nfrom copy import deepcopy\nfrom functools import partial\nfrom pathlib import Path\nfrom typing import Callable\n\nimport numpy as np\n\nimport torch\nfrom torch import cat, stack, nn, tensor, Tensor\nimport torch.nn.functional as F\nfrom torch.nn import Module, ModuleList, Parameter\nfrom torch.optim import Adam\nfrom torch.func import functional_call\n\nimport torch.distributed as dist\ntorch.set_float32_matmul_precision('high')\n\nfrom torch.nn.utils.parametrizations import weight_norm\n\nimport einx\nfrom einops import reduce, repeat, rearrange, einsum, pack, unpack\nfrom einops.layers.torch import Rearrange\n\nfrom ema_pytorch import EMA\n\nfrom tqdm import tqdm as orig_tqdm\n\nfrom accelerate import Accelerator\n\n# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)\n\n    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())\n    return t * sqrt(t.shape[-1])\n\ndef from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n\n    if isinstance(t, np.ndarray):\n        t = torch.from_numpy(t)\n\n    return t.float()\n\n# distributed\n\ndef maybe_all_reduce_mean(t):\n    if not dist.is_initialized() or dist.get_world_size() == 1:\n        return t\n\n    dist.all_reduce(t)\n    return t / dist.get_world_size()\n\n# networks\n\nclass StateNorm(Module):\n    def __init__(\n        self,\n        dim_state,\n        eps = 1e-5,\n    ):\n        # equation (3) in https://arxiv.org/abs/2410.09754\n        super().__init__()\n        self.dim = dim_state\n        self.eps = eps\n\n        self.register_buffer('step', tensor(1))\n        self.register_buffer('running_mean', torch.zeros(dim_state))\n        self.register_buffer('running_variance', torch.ones(dim_state))\n\n    def forward(\n        self,\n        state\n    ):\n        assert state.shape[-1] == self.dim, f'expected feature dimension of {self.dim} but received {state.shape[-1]}'\n\n        time = self.step.item()\n        mean = self.running_mean\n        variance = self.running_variance\n\n        normed = (state - mean) / variance.sqrt().clamp(min = self.eps)\n\n        if not self.training:\n            return normed\n\n        # update running mean and variance\n\n        new_obs_mean = reduce(state, '... d -> d', 'mean')\n        new_obs_mean = maybe_all_reduce_mean(new_obs_mean)\n\n        delta = new_obs_mean - mean\n\n        new_mean = mean + delta / time\n        new_variance = (time - 1) / time * (variance + (delta ** 2) / time)\n\n        self.step.add_(1)\n        self.running_mean.copy_(new_mean)\n        self.running_variance.copy_(new_variance)\n\n        return normed\n\nclass Actor(Module):\n    def __init__(\n        self,\n        dim_state,\n        *,\n        num_actions,\n        continuous = False,\n        hidden_dim = 32,\n        accepts_latent = False,\n        dim_latent = None,\n        sample = False,\n        weight_norm_linears = True,\n        eps = 1e-5\n    ):\n        super().__init__()\n        maybe_weight_norm = weight_norm if weight_norm_linears else identity\n        self.weight_norm_linears = weight_norm_linears\n\n        self.mem_norm = nn.RMSNorm(hidden_dim)\n\n        self.proj_in = nn.Linear(dim_state, hidden_dim + 1, bias = False)\n        self.proj_in = maybe_weight_norm(self.proj_in, name = 'weight', dim = None)\n\n        self.to_embed = nn.Linear(hidden_dim, hidden_dim, bias = False)\n        self.to_embed = maybe_weight_norm(self.to_embed, name = 'weight', dim = None)\n\n        self.final_norm = nn.RMSNorm(hidden_dim)\n\n        if continuous:\n            self.to_mean = nn.Linear(hidden_dim, num_actions, bias = False)\n            self.to_log_var = nn.Linear(hidden_dim, num_actions, bias = False)\n\n            self.to_mean = maybe_weight_norm(self.to_mean, name = 'weight', dim = None)\n            self.to_log_var = maybe_weight_norm(self.to_log_var, name = 'weight', dim = None)\n        else:\n            self.to_logits = nn.Linear(hidden_dim, num_actions, bias = False)\n            self.to_logits = maybe_weight_norm(self.to_logits, name = 'weight', dim = None)\n\n        self.continuous = continuous\n\n        self.norm_weights_()\n\n        # whether to sample from the output discrete logits\n\n        self.sample = sample\n\n        # for genes -> expression network (the analogy is growing on me)\n\n        self.accepts_latent = accepts_latent\n        if accepts_latent:\n            assert exists(dim_latent)\n\n            self.encode_latent = nn.Linear(dim_latent, hidden_dim)\n            self.encode_latent = maybe_weight_norm(self.encode_latent, name = 'weight', dim = None)\n            self.post_norm_latent_added = nn.RMSNorm(hidden_dim)\n\n        self.register_buffer('init_hiddens', torch.zeros(hidden_dim))\n\n    def norm_weights_(self):\n        if not self.weight_norm_linears:\n            return\n\n        for param in self.parameters():\n            if not isinstance(param, nn.Linear):\n                continue\n\n            param.parametrization.weight.original.copy_(param.weight)\n\n    def forward(\n        self,\n        x,\n        hiddens = None,\n        latent = None,\n        sample_temperature = 1.\n    ):\n        assert xnor(exists(latent), self.accepts_latent)\n\n        x = self.proj_in(x)\n        x, forget = x[:-1], x[-1]\n\n        x = F.silu(x)\n\n        if exists(hiddens):\n            past_mem = self.mem_norm(hiddens) * forget.sigmoid()\n            x = x + past_mem\n\n        if self.accepts_latent:\n            latent = l2norm(latent) # could be noised\n            x = x + self.encode_latent(latent)\n            x = self.post_norm_latent_added(x)\n\n        x = self.to_embed(x)\n        hiddens = F.silu(x)\n\n        embed = self.final_norm(hiddens)\n\n        if not self.continuous:\n            raw_actions = self.to_logits(embed)\n        else:\n            mean, log_var = self.to_mean(embed), self.to_log_var(embed)\n            raw_actions = stack((mean, log_var))\n\n        if not self.sample:\n            return raw_actions, hiddens\n\n        # actor can return sampled action(s) for the simulation / environment\n\n        if not self.continuous:\n            action_logits = raw_actions\n            actions = gumbel_sample(action_logits, temp = sample_temperature)\n        else:\n            mean, raw_std = raw_actions\n            std = raw_std.sigmoid() * 3.\n            actions = torch.normal(mean, std * sample_temperature).tanh() # todo - accept action range and do scale and shift\n            actions = actions.tanh()\n\n        return actions, hiddens\n\n# an actor wrapper that contains the state normalizer and latent gene pool, defaults to calling the fittest gene\n\nclass ActorWrapper(Module):\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        state_norm: StateNorm | None = None,\n        latent_gene_pool: LatentGenePool | None = None,\n        default_latent_gene_id = 0\n    ):\n        super().__init__()\n        self.actor = actor\n        self.state_norm = state_norm\n        self.latents = latent_gene_pool\n\n        self.default_latent_gene_id = default_latent_gene_id\n\n    def forward(\n        self,\n        state,\n        hiddens = None,\n        latent_gene_id = None\n    ):\n        latent_gene_id = default(latent_gene_id, self.default_latent_gene_id)\n\n        if exists(self.state_norm):\n            self.state_norm.eval()\n\n            with torch.no_grad():\n                state = self.state_norm(state)\n\n        latent = None\n\n        if exists(self.latents):\n            latent = self.latents[latent_gene_id]\n\n        out = self.actor(\n            state,\n            hiddens = hiddens,\n            latent = latent\n        )\n\n        return out\n\n# latent gene pool\n\n# proposed by Wang et al. evolutionary policy optimization (EPO)\n# https://arxiv.org/abs/2503.19037\n\nclass LatentGenePool(Module):\n    def __init__(\n        self,\n        dim,\n        num_genes_per_island,\n        num_selected,\n        tournament_size,\n        num_elites = 1,             # exempt from genetic mutation and migration\n        mutation_std_dev = 0.1,\n        num_islands = 1,\n        migrate_genes_every = 10,   # every number of evolution step to do a migration between islands, if using multi-islands for increasing diversity\n        num_frac_migrate = 0.1      # migrate 10 percent of the bottom population\n    ):\n        super().__init__()\n        assert num_islands >= 1\n        assert num_genes_per_island > 2\n\n        self.num_islands = num_islands\n\n        num_genes = num_genes_per_island * num_islands\n        self.num_genes = num_genes\n        self.num_genes_per_island = num_genes_per_island\n\n        assert 2 <= num_selected < num_genes_per_island, f'must select at least 2 genes for mating'\n\n        self.num_selected = num_selected\n        self.num_children = num_genes_per_island - num_selected\n        self.tournament_size = tournament_size\n\n        self.dim_gene = dim\n        self.genes = nn.Parameter(l2norm(torch.randn(num_genes, dim)))\n\n        self.split_islands = Rearrange('(i g) ... -> i g ...', i = num_islands)\n        self.merge_islands = Rearrange('i g ... -> (i g) ...')\n\n        self.num_elites = num_elites # todo - redo with affinity maturation algorithm from artificial immune system field\n        self.mutation_std_dev = mutation_std_dev\n\n        assert 0. <= num_frac_migrate <= 1.\n\n        self.num_frac_migrate = num_frac_migrate\n        self.migrate_genes_every = migrate_genes_every\n\n        self.register_buffer('step', tensor(0))\n\n    def __getitem__(self, idx):\n        return l2norm(self.genes[idx])\n\n    @torch.inference_mode()\n    def evolve(\n        self,\n        fitnesses,\n        temperature = 1.5\n    ):\n        device, num_selected = fitnesses.device, self.num_selected\n        assert fitnesses.ndim == 1 and fitnesses.shape[0] == self.num_genes\n\n        # split out the islands\n\n        genes = self.genes\n        num_islands = self.num_islands\n        has_elites = self.num_elites > 0\n\n        fitnesses = self.split_islands(fitnesses)\n        genes = self.split_islands(genes)\n\n        # local competition within each island\n\n        sorted_fitness, sorted_gene_ids = fitnesses.sort(dim = -1, descending = True)\n\n        selected_gene_ids = sorted_gene_ids[:, :num_selected]\n        selected_fitness = sorted_fitness[:, :num_selected]\n\n        selected_gene_ids_for_gather = repeat(selected_gene_ids, '... -> ... d', d = self.dim_gene)\n\n        selected_genes = genes.gather(1, selected_gene_ids_for_gather)\n\n        # tournament\n\n        num_children = self.num_children\n\n        batch_randperm = torch.randn((num_islands, num_children, num_selected), device = device).argsort(dim = -1)\n        tourn_ids = batch_randperm[..., :self.tournament_size]\n\n        sorted_fitness = repeat(sorted_fitness, '... -> ... d', d = tourn_ids.shape[-1])\n\n        tourn_fitness_ids = sorted_fitness.gather(1, tourn_ids)\n\n        parent_ids = tourn_fitness_ids.topk(2, dim = -1).indices\n\n        parent_ids = rearrange(parent_ids, 'i g parents -> i (g parents)')\n\n        parent_ids = repeat(parent_ids, '... -> ... d', d = self.dim_gene)\n\n        parents = selected_genes.gather(1, parent_ids)\n        parents = rearrange(parents, 'i (g parents) d -> parents i g d', parents = 2)\n\n        # cross over\n\n        parent1, parent2 = parents\n\n        children = parent1.lerp(parent2, (torch.randn_like(parent1) / temperature).sigmoid())\n\n        # maybe migration\n\n        if (\n            divisible_by(self.step.item() + 1, self.migrate_genes_every) and\n            self.num_islands > 1 and\n            self.num_frac_migrate > 0.\n        ):\n\n            if has_elites:\n                elites, selected_genes = selected_genes[:, :1], selected_genes[:, 1:]\n\n            num_can_migrate = selected_genes.shape[1]\n\n            num_migrate = max(1, num_can_migrate * self.num_frac_migrate)\n\n            # fixed migration pattern - what i observe to work best, for now\n            # todo - option to make it randomly selected with a mask\n\n            selected_genes, migrants = selected_genes[:, -num_migrate:], selected_genes[:, :-num_migrate]\n\n            migrants = torch.roll(migrants, 1, dims = (1,))\n\n            selected_genes = cat((selected_genes, migrants), dim = 1)\n\n            if has_elites:\n                selected_genes = cat((elites, selected_genes), dim = 1)\n\n        # concat children\n\n        genes = torch.cat((selected_genes, children), dim = 1)\n\n        # mutate\n\n        if self.mutation_std_dev > 0:\n\n            if has_elites:\n                elites, genes = genes[:, :1], genes[:, 1:]\n\n            genes.add_(torch.randn_like(genes) * self.mutation_std_dev)\n\n            if has_elites:\n                genes = torch.cat((elites, genes), dim = 1)\n\n        genes = self.merge_islands(genes)\n\n        self.genes.copy_(l2norm(genes))\n\n        self.step.add_(1)\n\n        return selected_gene_ids # return the selected gene ids, for the outer learning orchestrator to determine which mutations to accept\n\n# main class\n\nclass BlackboxGradientSensing(Module):\n\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        accelerator: Accelerator | None = None,\n        state_norm: StateNorm | Module | dict | None  = None,\n        actor_is_recurrent = False,\n        latent_gene_pool: LatentGenePool | dict | None = None,\n        concat_latent_to_state = False, # if False, will pass in the latents as a kwarg `latent`, else try to concat it to the state\n        crossover_every_step = 1,\n        crossover_after_step = 0,\n        num_env_interactions = 1000,\n        noise_pop_size = 40,\n        noise_std_dev: dict[str, float] | float = 0.1, # Appendix F in paper, appears to be constant for sim and real\n        mutate_latent_genes = False,\n        latent_gene_noise_std_dev = 1e-4,\n        factorized_noise = True,\n        orthogonalized_noise = True,\n        num_selected = 8,    # of the population, how many of the best performing noise perturbations to accept\n        num_rollout_repeats = 3,\n        optim_klass = Adam,\n        learning_rate = 8e-2,\n        weight_decay = 1e-4,\n        betas = (0.9, 0.95),\n        max_timesteps = 500,\n        calc_fitness: Callable[[Tensor], Tensor] | None = None,\n        param_names: set[str] | str | None = None,\n        modules_to_optimize: set[str] | str | None = None,\n        show_progress = True,\n        optim_kwargs: dict = dict(),\n        optim_step_post_hook: Callable | None = None,\n        accelerate_kwargs: dict = dict(),\n        num_std_below_mean_thres_accept = 0., # for each reward + anti, if they are below this number of standard deviations below the mean, reject it\n        frac_genes_pass_thres_accept = 0.9,    # in population based training, the fraction of genes that must be all above a given reward threshold for that noise to be accepted\n        cpu = False,\n        torch_compile_actor = True,\n        use_ema = False,\n        ema_decay = 0.9,\n        update_model_with_ema_every = 100,\n        sample_actions_from_actor = True\n    ):\n        super().__init__()\n        assert num_selected < noise_pop_size, f'number of selected noise must be less than the total population of noise'\n\n        # ES(1+1) related\n\n        self.num_selected = num_selected\n        self.noise_pop_size = noise_pop_size\n        self.num_rollout_repeats = num_rollout_repeats\n\n        self.orthogonalized_noise = orthogonalized_noise    # orthogonalized noise - todo: add the fast hadamard-rademacher ones proposed in paper\n        self.factorized_noise = factorized_noise            # maybe factorized gaussian noise\n\n        # use accelerate to manage distributed\n\n        if not exists(accelerator):\n\n            if cpu:\n                assert 'cpu' not in accelerate_kwargs\n                accelerate_kwargs = {'cpu': True, **accelerate_kwargs}\n\n            accelerator = Accelerator(**accelerate_kwargs)\n\n        device = accelerator.device\n        self.accelerator = accelerator\n\n        # net\n\n        self.actor = actor.to(device)\n\n        self.use_ema = use_ema\n        self.ema_actor = EMA(actor, beta = ema_decay, update_model_with_ema_every = update_model_with_ema_every, include_online_model = False) if use_ema else None\n\n        self.torch_compile_actor = torch_compile_actor\n\n        self.actor_is_recurrent = actor_is_recurrent # if set to True, actor must pass out the memory on forward on the second position, then receive it as a kwarg of `hiddens`\n\n        named_params = dict(actor.named_parameters())\n        named_modules = dict(actor.named_modules())\n\n        # whether to sample actions from the actor\n\n        self.sample_actions_from_actor = sample_actions_from_actor\n\n        # handle only a subset of parameters being optimized\n\n        if isinstance(param_names, str):\n            param_names = {param_names}\n\n        # also handle if module names are passed in\n        # ex. optimizing some gating / routing neural network that ties together a bunch of other pretrained policies\n\n        if isinstance(modules_to_optimize, str):\n            modules_to_optimize = {modules_to_optimize}\n\n        if exists(modules_to_optimize):\n            param_names = default(param_names, set())\n\n            for module_name in modules_to_optimize:\n                module = named_modules[module_name]\n                module_param_names = dict(module.named_parameters()).keys()\n                module_param_names_with_prefix = [f'{module_name}.{param_name}' for param_name in module_param_names]\n\n                param_names |= set(module_param_names_with_prefix)\n\n        param_names = default(param_names, set(named_params.keys()))\n\n        # validate and set parameters to optimize\n\n        assert len(param_names) > 0, f'no parameters to optimize with evolutionary strategy'\n\n        self.param_names = param_names\n\n        # noise std deviations, which can be one fixed value, or tailored to specific value per parameter name\n\n        if isinstance(noise_std_dev, float):\n            noise_std_dev = {name: noise_std_dev for name in self.param_names}\n\n        self.noise_std_dev = noise_std_dev\n\n        # env interactions\n\n        self.max_timesteps = max_timesteps\n\n        # gene pool, another axis for scaling and bitter lesson\n\n        num_genes = 1\n        gene_pool = None\n\n        if isinstance(latent_gene_pool, dict):\n            gene_pool = LatentGenePool(**latent_gene_pool)\n            gene_pool.to(device)\n\n            num_genes = gene_pool.num_genes\n\n        self.actor_accepts_latents = exists(gene_pool)\n        self.concat_latent_to_state = concat_latent_to_state\n\n        self.gene_pool = gene_pool\n        self.num_genes = num_genes\n\n        def default_calc_fitness(reward_stats):\n            return reduce(reward_stats[:, 0], 'g s e -> g', 'mean')\n\n        self.calc_fitness = default(calc_fitness, default_calc_fitness)\n\n        self.crossover_every_step = crossover_every_step\n        self.crossover_after_step = crossover_after_step\n\n        # whether to do heritable mutations to the latent genes\n\n        self.mutate_latent_genes = mutate_latent_genes\n\n        self.latent_gene_noise_std_dev = latent_gene_noise_std_dev\n\n        # opti\n# ... truncated ...","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":true}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.exists","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.exists#L38-L39","kind":"function","name":"exists","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":38,"end_line":39,"context_start_line":18,"context_end_line":59,"code":"from torch.optim import Adam\nfrom torch.func import functional_call\n\nimport torch.distributed as dist\ntorch.set_float32_matmul_precision('high')\n\nfrom torch.nn.utils.parametrizations import weight_norm\n\nimport einx\nfrom einops import reduce, repeat, rearrange, einsum, pack, unpack\nfrom einops.layers.torch import Rearrange\n\nfrom ema_pytorch import EMA\n\nfrom tqdm import tqdm as orig_tqdm\n\nfrom accelerate import Accelerator\n\n# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.default","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.default#L41-L42","kind":"function","name":"default","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":41,"end_line":42,"context_start_line":21,"context_end_line":62,"code":"import torch.distributed as dist\ntorch.set_float32_matmul_precision('high')\n\nfrom torch.nn.utils.parametrizations import weight_norm\n\nimport einx\nfrom einops import reduce, repeat, rearrange, einsum, pack, unpack\nfrom einops.layers.torch import Rearrange\n\nfrom ema_pytorch import EMA\n\nfrom tqdm import tqdm as orig_tqdm\n\nfrom accelerate import Accelerator\n\n# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.identity","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.identity#L44-L45","kind":"function","name":"identity","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":44,"end_line":45,"context_start_line":24,"context_end_line":65,"code":"from torch.nn.utils.parametrizations import weight_norm\n\nimport einx\nfrom einops import reduce, repeat, rearrange, einsum, pack, unpack\nfrom einops.layers.torch import Rearrange\n\nfrom ema_pytorch import EMA\n\nfrom tqdm import tqdm as orig_tqdm\n\nfrom accelerate import Accelerator\n\n# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.first","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.first#L47-L48","kind":"function","name":"first","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":47,"end_line":48,"context_start_line":27,"context_end_line":68,"code":"from einops import reduce, repeat, rearrange, einsum, pack, unpack\nfrom einops.layers.torch import Rearrange\n\nfrom ema_pytorch import EMA\n\nfrom tqdm import tqdm as orig_tqdm\n\nfrom accelerate import Accelerator\n\n# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.divisible_by","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.divisible_by#L50-L51","kind":"function","name":"divisible_by","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":50,"end_line":51,"context_start_line":30,"context_end_line":71,"code":"from ema_pytorch import EMA\n\nfrom tqdm import tqdm as orig_tqdm\n\nfrom accelerate import Accelerator\n\n# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.xnor","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.xnor#L53-L54","kind":"function","name":"xnor","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":53,"end_line":54,"context_start_line":33,"context_end_line":74,"code":"\nfrom accelerate import Accelerator\n\n# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.join","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.join#L56-L57","kind":"function","name":"join","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":56,"end_line":57,"context_start_line":36,"context_end_line":77,"code":"# helpers\n\ndef exists(val):\n    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.is_empty","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.is_empty#L59-L60","kind":"function","name":"is_empty","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":59,"end_line":60,"context_start_line":39,"context_end_line":80,"code":"    return val is not None\n\ndef default(v, d):\n    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.item","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.item#L62-L68","kind":"function","name":"item","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":62,"end_line":68,"context_start_line":42,"context_end_line":88,"code":"    return v if exists(v) else d\n\ndef identity(t, *args, **kwargs):\n    return t\n\ndef first(seq):\n    return seq[0]\n\ndef divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.arange_like","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.arange_like#L70-L76","kind":"function","name":"arange_like","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":70,"end_line":76,"context_start_line":50,"context_end_line":96,"code":"def divisible_by(num, den):\n    return (num % den) == 0\n\ndef xnor(x, y):\n    return not (x ^ y)\n\ndef join(arr, delimiter):\n    return delimiter.join(arr)\n\ndef is_empty(t):\n    return t.numel() == 0\n\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)\n\n    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.log","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.log#L721-L722","kind":"function","name":"log","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":721,"end_line":722,"context_start_line":701,"context_end_line":742,"code":"\n        assert 0 <= frac_genes_pass_thres_accept <= 1.\n        self.frac_genes_pass_thres_accept = frac_genes_pass_thres_accept\n\n        # expose a few computed variables\n\n        self.num_episodes_per_learning_cycle = self.rollouts_for_machine.shape[0] * num_rollout_repeats * 2\n\n        self.is_main = rank == 0\n\n        # keep track of number of steps\n\n        self.register_buffer('step', tensor(0))\n\n    def sync_seed_(self):\n        acc = self.accelerator\n        rand_int = torch.randint(0, int(1e7), (), device = acc.device)\n        seed = acc.reduce(rand_int)\n        torch.manual_seed(seed.item())\n\n    def log(self, **data):\n        return self.accelerator.log(data, step = self.step.item())\n\n    def save(self, path, overwrite = False):\n\n        acc = self.accelerator\n\n        acc.wait_for_everyone()\n\n        if not acc.is_main_process:\n            return\n\n        path = Path(path)\n        assert overwrite or not path.exists()\n\n        pkg = dict(\n            actor = self.actor.state_dict(),\n            ema_actor = self.ema_actor.state_dict() if self.use_ema else None,\n            state_norm = self.state_norm.state_dict() if self.use_state_norm else None,\n            latents = self.gene_pool.state_dict() if exists(self.gene_pool) else None,\n            step = self.step\n        )","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.gumbel_noise","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.gumbel_noise#L81-L82","kind":"function","name":"gumbel_noise","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":81,"end_line":82,"context_start_line":61,"context_end_line":102,"code":"\ndef item(t):\n    if t.numel() == 0:\n        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)\n\n    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())\n    return t * sqrt(t.shape[-1])\n\ndef from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.gumbel_sample","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.gumbel_sample#L84-L90","kind":"function","name":"gumbel_sample","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":84,"end_line":90,"context_start_line":64,"context_end_line":110,"code":"        out = t.item()\n    else:\n        out = t.tolist()\n\n    return out\n\ndef arange_like(t, *, dim = None, length = None):\n    assert exists(dim) or exists(length)\n\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)\n\n    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())\n    return t * sqrt(t.shape[-1])\n\ndef from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n\n    if isinstance(t, np.ndarray):\n        t = torch.from_numpy(t)\n\n    return t.float()\n\n# distributed\n\ndef maybe_all_reduce_mean(t):","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.l2norm","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.l2norm#L92-L93","kind":"function","name":"l2norm","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":92,"end_line":93,"context_start_line":72,"context_end_line":113,"code":"\n    if not exists(length):\n        length = t.shape[dim]\n\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)\n\n    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())\n    return t * sqrt(t.shape[-1])\n\ndef from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n\n    if isinstance(t, np.ndarray):\n        t = torch.from_numpy(t)\n\n    return t.float()\n\n# distributed\n\ndef maybe_all_reduce_mean(t):\n    if not dist.is_initialized() or dist.get_world_size() == 1:\n        return t\n","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.orthogonal_","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.orthogonal_#L95-L97","kind":"function","name":"orthogonal_","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":95,"end_line":97,"context_start_line":75,"context_end_line":117,"code":"\n    return torch.arange(length, device = t.device)\n\ndef log(t, eps = 1e-20):\n    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)\n\n    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())\n    return t * sqrt(t.shape[-1])\n\ndef from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n\n    if isinstance(t, np.ndarray):\n        t = torch.from_numpy(t)\n\n    return t.float()\n\n# distributed\n\ndef maybe_all_reduce_mean(t):\n    if not dist.is_initialized() or dist.get_world_size() == 1:\n        return t\n\n    dist.all_reduce(t)\n    return t / dist.get_world_size()\n\n# networks","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.from_numpy","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.from_numpy#L99-L106","kind":"function","name":"from_numpy","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":99,"end_line":106,"context_start_line":79,"context_end_line":126,"code":"    return t.clamp(min = eps).log()\n\ndef gumbel_noise(t):\n    return -log(-log(torch.rand_like(t)))\n\ndef gumbel_sample(t, temp = 1.):\n    is_greedy = temp <= 0.\n\n    if not is_greedy:\n        t = (t / temp) + gumbel_noise(t)\n\n    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())\n    return t * sqrt(t.shape[-1])\n\ndef from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n\n    if isinstance(t, np.ndarray):\n        t = torch.from_numpy(t)\n\n    return t.float()\n\n# distributed\n\ndef maybe_all_reduce_mean(t):\n    if not dist.is_initialized() or dist.get_world_size() == 1:\n        return t\n\n    dist.all_reduce(t)\n    return t / dist.get_world_size()\n\n# networks\n\nclass StateNorm(Module):\n    def __init__(\n        self,\n        dim_state,\n        eps = 1e-5,\n    ):\n        # equation (3) in https://arxiv.org/abs/2410.09754\n        super().__init__()","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.maybe_all_reduce_mean","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.maybe_all_reduce_mean#L110-L115","kind":"function","name":"maybe_all_reduce_mean","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":110,"end_line":115,"context_start_line":90,"context_end_line":135,"code":"    return t.argmax(dim = -1)\n\ndef l2norm(t):\n    return F.normalize(t, dim = -1, p = 2)\n\ndef orthogonal_(t):\n    nn.init.orthogonal_(t.t())\n    return t * sqrt(t.shape[-1])\n\ndef from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n\n    if isinstance(t, np.ndarray):\n        t = torch.from_numpy(t)\n\n    return t.float()\n\n# distributed\n\ndef maybe_all_reduce_mean(t):\n    if not dist.is_initialized() or dist.get_world_size() == 1:\n        return t\n\n    dist.all_reduce(t)\n    return t / dist.get_world_size()\n\n# networks\n\nclass StateNorm(Module):\n    def __init__(\n        self,\n        dim_state,\n        eps = 1e-5,\n    ):\n        # equation (3) in https://arxiv.org/abs/2410.09754\n        super().__init__()\n        self.dim = dim_state\n        self.eps = eps\n\n        self.register_buffer('step', tensor(1))\n        self.register_buffer('running_mean', torch.zeros(dim_state))\n        self.register_buffer('running_variance', torch.ones(dim_state))\n\n    def forward(\n        self,","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.StateNorm","uri":"program://blackbox-gradient-sensing/class/blackbox_gradient_sensing.bgs.StateNorm#L119-L163","kind":"class","name":"StateNorm","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":119,"end_line":163,"context_start_line":99,"context_end_line":183,"code":"def from_numpy(t):\n    if isinstance(t, np.float64):\n        t = np.array(t)\n\n    if isinstance(t, np.ndarray):\n        t = torch.from_numpy(t)\n\n    return t.float()\n\n# distributed\n\ndef maybe_all_reduce_mean(t):\n    if not dist.is_initialized() or dist.get_world_size() == 1:\n        return t\n\n    dist.all_reduce(t)\n    return t / dist.get_world_size()\n\n# networks\n\nclass StateNorm(Module):\n    def __init__(\n        self,\n        dim_state,\n        eps = 1e-5,\n    ):\n        # equation (3) in https://arxiv.org/abs/2410.09754\n        super().__init__()\n        self.dim = dim_state\n        self.eps = eps\n\n        self.register_buffer('step', tensor(1))\n        self.register_buffer('running_mean', torch.zeros(dim_state))\n        self.register_buffer('running_variance', torch.ones(dim_state))\n\n    def forward(\n        self,\n        state\n    ):\n        assert state.shape[-1] == self.dim, f'expected feature dimension of {self.dim} but received {state.shape[-1]}'\n\n        time = self.step.item()\n        mean = self.running_mean\n        variance = self.running_variance\n\n        normed = (state - mean) / variance.sqrt().clamp(min = self.eps)\n\n        if not self.training:\n            return normed\n\n        # update running mean and variance\n\n        new_obs_mean = reduce(state, '... d -> d', 'mean')\n        new_obs_mean = maybe_all_reduce_mean(new_obs_mean)\n\n        delta = new_obs_mean - mean\n\n        new_mean = mean + delta / time\n        new_variance = (time - 1) / time * (variance + (delta ** 2) / time)\n\n        self.step.add_(1)\n        self.running_mean.copy_(new_mean)\n        self.running_variance.copy_(new_variance)\n\n        return normed\n\nclass Actor(Module):\n    def __init__(\n        self,\n        dim_state,\n        *,\n        num_actions,\n        continuous = False,\n        hidden_dim = 32,\n        accepts_latent = False,\n        dim_latent = None,\n        sample = False,\n        weight_norm_linears = True,\n        eps = 1e-5\n    ):\n        super().__init__()\n        maybe_weight_norm = weight_norm if weight_norm_linears else identity\n        self.weight_norm_linears = weight_norm_linears\n\n        self.mem_norm = nn.RMSNorm(hidden_dim)","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.Actor","uri":"program://blackbox-gradient-sensing/class/blackbox_gradient_sensing.bgs.Actor#L165-L281","kind":"class","name":"Actor","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":165,"end_line":281,"context_start_line":145,"context_end_line":301,"code":"\n        if not self.training:\n            return normed\n\n        # update running mean and variance\n\n        new_obs_mean = reduce(state, '... d -> d', 'mean')\n        new_obs_mean = maybe_all_reduce_mean(new_obs_mean)\n\n        delta = new_obs_mean - mean\n\n        new_mean = mean + delta / time\n        new_variance = (time - 1) / time * (variance + (delta ** 2) / time)\n\n        self.step.add_(1)\n        self.running_mean.copy_(new_mean)\n        self.running_variance.copy_(new_variance)\n\n        return normed\n\nclass Actor(Module):\n    def __init__(\n        self,\n        dim_state,\n        *,\n        num_actions,\n        continuous = False,\n        hidden_dim = 32,\n        accepts_latent = False,\n        dim_latent = None,\n        sample = False,\n        weight_norm_linears = True,\n        eps = 1e-5\n    ):\n        super().__init__()\n        maybe_weight_norm = weight_norm if weight_norm_linears else identity\n        self.weight_norm_linears = weight_norm_linears\n\n        self.mem_norm = nn.RMSNorm(hidden_dim)\n\n        self.proj_in = nn.Linear(dim_state, hidden_dim + 1, bias = False)\n        self.proj_in = maybe_weight_norm(self.proj_in, name = 'weight', dim = None)\n\n        self.to_embed = nn.Linear(hidden_dim, hidden_dim, bias = False)\n        self.to_embed = maybe_weight_norm(self.to_embed, name = 'weight', dim = None)\n\n        self.final_norm = nn.RMSNorm(hidden_dim)\n\n        if continuous:\n            self.to_mean = nn.Linear(hidden_dim, num_actions, bias = False)\n            self.to_log_var = nn.Linear(hidden_dim, num_actions, bias = False)\n\n            self.to_mean = maybe_weight_norm(self.to_mean, name = 'weight', dim = None)\n            self.to_log_var = maybe_weight_norm(self.to_log_var, name = 'weight', dim = None)\n        else:\n            self.to_logits = nn.Linear(hidden_dim, num_actions, bias = False)\n            self.to_logits = maybe_weight_norm(self.to_logits, name = 'weight', dim = None)\n\n        self.continuous = continuous\n\n        self.norm_weights_()\n\n        # whether to sample from the output discrete logits\n\n        self.sample = sample\n\n        # for genes -> expression network (the analogy is growing on me)\n\n        self.accepts_latent = accepts_latent\n        if accepts_latent:\n            assert exists(dim_latent)\n\n            self.encode_latent = nn.Linear(dim_latent, hidden_dim)\n            self.encode_latent = maybe_weight_norm(self.encode_latent, name = 'weight', dim = None)\n            self.post_norm_latent_added = nn.RMSNorm(hidden_dim)\n\n        self.register_buffer('init_hiddens', torch.zeros(hidden_dim))\n\n    def norm_weights_(self):\n        if not self.weight_norm_linears:\n            return\n\n        for param in self.parameters():\n            if not isinstance(param, nn.Linear):\n                continue\n\n            param.parametrization.weight.original.copy_(param.weight)\n\n    def forward(\n        self,\n        x,\n        hiddens = None,\n        latent = None,\n        sample_temperature = 1.\n    ):\n        assert xnor(exists(latent), self.accepts_latent)\n\n        x = self.proj_in(x)\n        x, forget = x[:-1], x[-1]\n\n        x = F.silu(x)\n\n        if exists(hiddens):\n            past_mem = self.mem_norm(hiddens) * forget.sigmoid()\n            x = x + past_mem\n\n        if self.accepts_latent:\n            latent = l2norm(latent) # could be noised\n            x = x + self.encode_latent(latent)\n            x = self.post_norm_latent_added(x)\n\n        x = self.to_embed(x)\n        hiddens = F.silu(x)\n\n        embed = self.final_norm(hiddens)\n\n        if not self.continuous:\n            raw_actions = self.to_logits(embed)\n        else:\n            mean, log_var = self.to_mean(embed), self.to_log_var(embed)\n            raw_actions = stack((mean, log_var))\n\n        if not self.sample:\n            return raw_actions, hiddens\n\n        # actor can return sampled action(s) for the simulation / environment\n\n        if not self.continuous:\n            action_logits = raw_actions\n            actions = gumbel_sample(action_logits, temp = sample_temperature)\n        else:\n            mean, raw_std = raw_actions\n            std = raw_std.sigmoid() * 3.\n            actions = torch.normal(mean, std * sample_temperature).tanh() # todo - accept action range and do scale and shift\n            actions = actions.tanh()\n\n        return actions, hiddens\n\n# an actor wrapper that contains the state normalizer and latent gene pool, defaults to calling the fittest gene\n\nclass ActorWrapper(Module):\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        state_norm: StateNorm | None = None,\n        latent_gene_pool: LatentGenePool | None = None,\n        default_latent_gene_id = 0\n    ):\n        super().__init__()\n        self.actor = actor\n        self.state_norm = state_norm\n        self.latents = latent_gene_pool\n\n        self.default_latent_gene_id = default_latent_gene_id\n\n    def forward(","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.ActorWrapper","uri":"program://blackbox-gradient-sensing/class/blackbox_gradient_sensing.bgs.ActorWrapper#L285-L326","kind":"class","name":"ActorWrapper","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":285,"end_line":326,"context_start_line":265,"context_end_line":346,"code":"            raw_actions = stack((mean, log_var))\n\n        if not self.sample:\n            return raw_actions, hiddens\n\n        # actor can return sampled action(s) for the simulation / environment\n\n        if not self.continuous:\n            action_logits = raw_actions\n            actions = gumbel_sample(action_logits, temp = sample_temperature)\n        else:\n            mean, raw_std = raw_actions\n            std = raw_std.sigmoid() * 3.\n            actions = torch.normal(mean, std * sample_temperature).tanh() # todo - accept action range and do scale and shift\n            actions = actions.tanh()\n\n        return actions, hiddens\n\n# an actor wrapper that contains the state normalizer and latent gene pool, defaults to calling the fittest gene\n\nclass ActorWrapper(Module):\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        state_norm: StateNorm | None = None,\n        latent_gene_pool: LatentGenePool | None = None,\n        default_latent_gene_id = 0\n    ):\n        super().__init__()\n        self.actor = actor\n        self.state_norm = state_norm\n        self.latents = latent_gene_pool\n\n        self.default_latent_gene_id = default_latent_gene_id\n\n    def forward(\n        self,\n        state,\n        hiddens = None,\n        latent_gene_id = None\n    ):\n        latent_gene_id = default(latent_gene_id, self.default_latent_gene_id)\n\n        if exists(self.state_norm):\n            self.state_norm.eval()\n\n            with torch.no_grad():\n                state = self.state_norm(state)\n\n        latent = None\n\n        if exists(self.latents):\n            latent = self.latents[latent_gene_id]\n\n        out = self.actor(\n            state,\n            hiddens = hiddens,\n            latent = latent\n        )\n\n        return out\n\n# latent gene pool\n\n# proposed by Wang et al. evolutionary policy optimization (EPO)\n# https://arxiv.org/abs/2503.19037\n\nclass LatentGenePool(Module):\n    def __init__(\n        self,\n        dim,\n        num_genes_per_island,\n        num_selected,\n        tournament_size,\n        num_elites = 1,             # exempt from genetic mutation and migration\n        mutation_std_dev = 0.1,\n        num_islands = 1,\n        migrate_genes_every = 10,   # every number of evolution step to do a migration between islands, if using multi-islands for increasing diversity\n        num_frac_migrate = 0.1      # migrate 10 percent of the bottom population\n    ):\n        super().__init__()","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.LatentGenePool","uri":"program://blackbox-gradient-sensing/class/blackbox_gradient_sensing.bgs.LatentGenePool#L333-L485","kind":"class","name":"LatentGenePool","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":333,"end_line":485,"context_start_line":313,"context_end_line":505,"code":"                state = self.state_norm(state)\n\n        latent = None\n\n        if exists(self.latents):\n            latent = self.latents[latent_gene_id]\n\n        out = self.actor(\n            state,\n            hiddens = hiddens,\n            latent = latent\n        )\n\n        return out\n\n# latent gene pool\n\n# proposed by Wang et al. evolutionary policy optimization (EPO)\n# https://arxiv.org/abs/2503.19037\n\nclass LatentGenePool(Module):\n    def __init__(\n        self,\n        dim,\n        num_genes_per_island,\n        num_selected,\n        tournament_size,\n        num_elites = 1,             # exempt from genetic mutation and migration\n        mutation_std_dev = 0.1,\n        num_islands = 1,\n        migrate_genes_every = 10,   # every number of evolution step to do a migration between islands, if using multi-islands for increasing diversity\n        num_frac_migrate = 0.1      # migrate 10 percent of the bottom population\n    ):\n        super().__init__()\n        assert num_islands >= 1\n        assert num_genes_per_island > 2\n\n        self.num_islands = num_islands\n\n        num_genes = num_genes_per_island * num_islands\n        self.num_genes = num_genes\n        self.num_genes_per_island = num_genes_per_island\n\n        assert 2 <= num_selected < num_genes_per_island, f'must select at least 2 genes for mating'\n\n        self.num_selected = num_selected\n        self.num_children = num_genes_per_island - num_selected\n        self.tournament_size = tournament_size\n\n        self.dim_gene = dim\n        self.genes = nn.Parameter(l2norm(torch.randn(num_genes, dim)))\n\n        self.split_islands = Rearrange('(i g) ... -> i g ...', i = num_islands)\n        self.merge_islands = Rearrange('i g ... -> (i g) ...')\n\n        self.num_elites = num_elites # todo - redo with affinity maturation algorithm from artificial immune system field\n        self.mutation_std_dev = mutation_std_dev\n\n        assert 0. <= num_frac_migrate <= 1.\n\n        self.num_frac_migrate = num_frac_migrate\n        self.migrate_genes_every = migrate_genes_every\n\n        self.register_buffer('step', tensor(0))\n\n    def __getitem__(self, idx):\n        return l2norm(self.genes[idx])\n\n    @torch.inference_mode()\n    def evolve(\n        self,\n        fitnesses,\n        temperature = 1.5\n    ):\n        device, num_selected = fitnesses.device, self.num_selected\n        assert fitnesses.ndim == 1 and fitnesses.shape[0] == self.num_genes\n\n        # split out the islands\n\n        genes = self.genes\n        num_islands = self.num_islands\n        has_elites = self.num_elites > 0\n\n        fitnesses = self.split_islands(fitnesses)\n        genes = self.split_islands(genes)\n\n        # local competition within each island\n\n        sorted_fitness, sorted_gene_ids = fitnesses.sort(dim = -1, descending = True)\n\n        selected_gene_ids = sorted_gene_ids[:, :num_selected]\n        selected_fitness = sorted_fitness[:, :num_selected]\n\n        selected_gene_ids_for_gather = repeat(selected_gene_ids, '... -> ... d', d = self.dim_gene)\n\n        selected_genes = genes.gather(1, selected_gene_ids_for_gather)\n\n        # tournament\n\n        num_children = self.num_children\n\n        batch_randperm = torch.randn((num_islands, num_children, num_selected), device = device).argsort(dim = -1)\n        tourn_ids = batch_randperm[..., :self.tournament_size]\n\n        sorted_fitness = repeat(sorted_fitness, '... -> ... d', d = tourn_ids.shape[-1])\n\n        tourn_fitness_ids = sorted_fitness.gather(1, tourn_ids)\n\n        parent_ids = tourn_fitness_ids.topk(2, dim = -1).indices\n\n        parent_ids = rearrange(parent_ids, 'i g parents -> i (g parents)')\n\n        parent_ids = repeat(parent_ids, '... -> ... d', d = self.dim_gene)\n\n        parents = selected_genes.gather(1, parent_ids)\n        parents = rearrange(parents, 'i (g parents) d -> parents i g d', parents = 2)\n\n        # cross over\n\n        parent1, parent2 = parents\n\n        children = parent1.lerp(parent2, (torch.randn_like(parent1) / temperature).sigmoid())\n\n        # maybe migration\n\n        if (\n            divisible_by(self.step.item() + 1, self.migrate_genes_every) and\n            self.num_islands > 1 and\n            self.num_frac_migrate > 0.\n        ):\n\n            if has_elites:\n                elites, selected_genes = selected_genes[:, :1], selected_genes[:, 1:]\n\n            num_can_migrate = selected_genes.shape[1]\n\n            num_migrate = max(1, num_can_migrate * self.num_frac_migrate)\n\n            # fixed migration pattern - what i observe to work best, for now\n            # todo - option to make it randomly selected with a mask\n\n            selected_genes, migrants = selected_genes[:, -num_migrate:], selected_genes[:, :-num_migrate]\n\n            migrants = torch.roll(migrants, 1, dims = (1,))\n\n            selected_genes = cat((selected_genes, migrants), dim = 1)\n\n            if has_elites:\n                selected_genes = cat((elites, selected_genes), dim = 1)\n\n        # concat children\n\n        genes = torch.cat((selected_genes, children), dim = 1)\n\n        # mutate\n\n        if self.mutation_std_dev > 0:\n\n            if has_elites:\n                elites, genes = genes[:, :1], genes[:, 1:]\n\n            genes.add_(torch.randn_like(genes) * self.mutation_std_dev)\n\n            if has_elites:\n                genes = torch.cat((elites, genes), dim = 1)\n\n        genes = self.merge_islands(genes)\n\n        self.genes.copy_(l2norm(genes))\n\n        self.step.add_(1)\n\n        return selected_gene_ids # return the selected gene ids, for the outer learning orchestrator to determine which mutations to accept\n\n# main class\n\nclass BlackboxGradientSensing(Module):\n\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        accelerator: Accelerator | None = None,\n        state_norm: StateNorm | Module | dict | None  = None,\n        actor_is_recurrent = False,\n        latent_gene_pool: LatentGenePool | dict | None = None,\n        concat_latent_to_state = False, # if False, will pass in the latents as a kwarg `latent`, else try to concat it to the state\n        crossover_every_step = 1,\n        crossover_after_step = 0,\n        num_env_interactions = 1000,\n        noise_pop_size = 40,\n        noise_std_dev: dict[str, float] | float = 0.1, # Appendix F in paper, appears to be constant for sim and real\n        mutate_latent_genes = False,","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.BlackboxGradientSensing","uri":"program://blackbox-gradient-sensing/class/blackbox_gradient_sensing.bgs.BlackboxGradientSensing#L489-L1204","kind":"class","name":"BlackboxGradientSensing","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":489,"end_line":1204,"context_start_line":469,"context_end_line":1204,"code":"        if self.mutation_std_dev > 0:\n\n            if has_elites:\n                elites, genes = genes[:, :1], genes[:, 1:]\n\n            genes.add_(torch.randn_like(genes) * self.mutation_std_dev)\n\n            if has_elites:\n                genes = torch.cat((elites, genes), dim = 1)\n\n        genes = self.merge_islands(genes)\n\n        self.genes.copy_(l2norm(genes))\n\n        self.step.add_(1)\n\n        return selected_gene_ids # return the selected gene ids, for the outer learning orchestrator to determine which mutations to accept\n\n# main class\n\nclass BlackboxGradientSensing(Module):\n\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        accelerator: Accelerator | None = None,\n        state_norm: StateNorm | Module | dict | None  = None,\n        actor_is_recurrent = False,\n        latent_gene_pool: LatentGenePool | dict | None = None,\n        concat_latent_to_state = False, # if False, will pass in the latents as a kwarg `latent`, else try to concat it to the state\n        crossover_every_step = 1,\n        crossover_after_step = 0,\n        num_env_interactions = 1000,\n        noise_pop_size = 40,\n        noise_std_dev: dict[str, float] | float = 0.1, # Appendix F in paper, appears to be constant for sim and real\n        mutate_latent_genes = False,\n        latent_gene_noise_std_dev = 1e-4,\n        factorized_noise = True,\n        orthogonalized_noise = True,\n        num_selected = 8,    # of the population, how many of the best performing noise perturbations to accept\n        num_rollout_repeats = 3,\n        optim_klass = Adam,\n        learning_rate = 8e-2,\n        weight_decay = 1e-4,\n        betas = (0.9, 0.95),\n        max_timesteps = 500,\n        calc_fitness: Callable[[Tensor], Tensor] | None = None,\n        param_names: set[str] | str | None = None,\n        modules_to_optimize: set[str] | str | None = None,\n        show_progress = True,\n        optim_kwargs: dict = dict(),\n        optim_step_post_hook: Callable | None = None,\n        accelerate_kwargs: dict = dict(),\n        num_std_below_mean_thres_accept = 0., # for each reward + anti, if they are below this number of standard deviations below the mean, reject it\n        frac_genes_pass_thres_accept = 0.9,    # in population based training, the fraction of genes that must be all above a given reward threshold for that noise to be accepted\n        cpu = False,\n        torch_compile_actor = True,\n        use_ema = False,\n        ema_decay = 0.9,\n        update_model_with_ema_every = 100,\n        sample_actions_from_actor = True\n    ):\n        super().__init__()\n        assert num_selected < noise_pop_size, f'number of selected noise must be less than the total population of noise'\n\n        # ES(1+1) related\n\n        self.num_selected = num_selected\n        self.noise_pop_size = noise_pop_size\n        self.num_rollout_repeats = num_rollout_repeats\n\n        self.orthogonalized_noise = orthogonalized_noise    # orthogonalized noise - todo: add the fast hadamard-rademacher ones proposed in paper\n        self.factorized_noise = factorized_noise            # maybe factorized gaussian noise\n\n        # use accelerate to manage distributed\n\n        if not exists(accelerator):\n\n            if cpu:\n                assert 'cpu' not in accelerate_kwargs\n                accelerate_kwargs = {'cpu': True, **accelerate_kwargs}\n\n            accelerator = Accelerator(**accelerate_kwargs)\n\n        device = accelerator.device\n        self.accelerator = accelerator\n\n        # net\n\n        self.actor = actor.to(device)\n\n        self.use_ema = use_ema\n        self.ema_actor = EMA(actor, beta = ema_decay, update_model_with_ema_every = update_model_with_ema_every, include_online_model = False) if use_ema else None\n\n        self.torch_compile_actor = torch_compile_actor\n\n        self.actor_is_recurrent = actor_is_recurrent # if set to True, actor must pass out the memory on forward on the second position, then receive it as a kwarg of `hiddens`\n\n        named_params = dict(actor.named_parameters())\n        named_modules = dict(actor.named_modules())\n\n        # whether to sample actions from the actor\n\n        self.sample_actions_from_actor = sample_actions_from_actor\n\n        # handle only a subset of parameters being optimized\n\n        if isinstance(param_names, str):\n            param_names = {param_names}\n\n        # also handle if module names are passed in\n        # ex. optimizing some gating / routing neural network that ties together a bunch of other pretrained policies\n\n        if isinstance(modules_to_optimize, str):\n            modules_to_optimize = {modules_to_optimize}\n\n        if exists(modules_to_optimize):\n            param_names = default(param_names, set())\n\n            for module_name in modules_to_optimize:\n                module = named_modules[module_name]\n                module_param_names = dict(module.named_parameters()).keys()\n                module_param_names_with_prefix = [f'{module_name}.{param_name}' for param_name in module_param_names]\n\n                param_names |= set(module_param_names_with_prefix)\n\n        param_names = default(param_names, set(named_params.keys()))\n\n        # validate and set parameters to optimize\n\n        assert len(param_names) > 0, f'no parameters to optimize with evolutionary strategy'\n\n        self.param_names = param_names\n\n        # noise std deviations, which can be one fixed value, or tailored to specific value per parameter name\n\n        if isinstance(noise_std_dev, float):\n            noise_std_dev = {name: noise_std_dev for name in self.param_names}\n\n        self.noise_std_dev = noise_std_dev\n\n        # env interactions\n\n        self.max_timesteps = max_timesteps\n\n        # gene pool, another axis for scaling and bitter lesson\n\n        num_genes = 1\n        gene_pool = None\n\n        if isinstance(latent_gene_pool, dict):\n            gene_pool = LatentGenePool(**latent_gene_pool)\n            gene_pool.to(device)\n\n            num_genes = gene_pool.num_genes\n\n        self.actor_accepts_latents = exists(gene_pool)\n        self.concat_latent_to_state = concat_latent_to_state\n\n        self.gene_pool = gene_pool\n        self.num_genes = num_genes\n\n        def default_calc_fitness(reward_stats):\n            return reduce(reward_stats[:, 0], 'g s e -> g', 'mean')\n\n        self.calc_fitness = default(calc_fitness, default_calc_fitness)\n\n        self.crossover_every_step = crossover_every_step\n        self.crossover_after_step = crossover_after_step\n\n        # whether to do heritable mutations to the latent genes\n\n        self.mutate_latent_genes = mutate_latent_genes\n\n        self.latent_gene_noise_std_dev = latent_gene_noise_std_dev\n\n        # optim\n\n        optim_params = [named_params[param_name] for param_name in self.param_names]\n\n        self.optim = optim_klass(optim_params, lr = learning_rate, betas = betas, **optim_kwargs)\n\n        self.learning_rate = learning_rate\n        self.weight_decay = weight_decay\n\n        # hooks\n\n        if exists(optim_step_post_hook):\n            def hook(*_):\n                optim_step_post_hook()\n\n            self.optim.register_step_post_hook(hook)\n\n        # maybe state norm\n\n        if isinstance(state_norm, dict):\n            state_norm = StateNorm(**state_norm)\n\n        self.use_state_norm = exists(state_norm)\n\n        if self.use_state_norm:\n            self.state_norm = state_norm\n            state_norm.to(device)\n\n        # progress bar\n\n        self.show_progress = show_progress\n\n        # number of interactions with environment for learning\n\n        self.num_env_interactions = num_env_interactions\n\n        # calculate num of episodes per learning cycle for this machine\n\n        world_size, rank = accelerator.num_processes, accelerator.process_index\n\n        # for each gene, roll out for each noise candidate\n\n        gene_indices = torch.arange(num_genes)\n        mutation_indices = torch.arange(noise_pop_size + 1)\n\n        gene_mutation_indices = torch.cartesian_prod(gene_indices, mutation_indices)\n        rollouts_for_machine = gene_mutation_indices.chunk(world_size)[rank]\n\n        self.register_buffer('rollouts_for_machine', rollouts_for_machine, persistent = False)\n\n        # for each reward and its anti, the number of standard deviations below the baseline they can be for acceptance\n\n        self.num_std_below_mean_thres_accept = num_std_below_mean_thres_accept\n\n        # the fraction of genes that must be above the given reward threshold as defined by the variable above, in order for said noise to be accepted\n\n        assert 0 <= frac_genes_pass_thres_accept <= 1.\n        self.frac_genes_pass_thres_accept = frac_genes_pass_thres_accept\n\n        # expose a few computed variables\n\n        self.num_episodes_per_learning_cycle = self.rollouts_for_machine.shape[0] * num_rollout_repeats * 2\n\n        self.is_main = rank == 0\n\n        # keep track of number of steps\n\n        self.register_buffer('step', tensor(0))\n\n    def sync_seed_(self):\n        acc = self.accelerator\n        rand_int = torch.randint(0, int(1e7), (), device = acc.device)\n        seed = acc.reduce(rand_int)\n        torch.manual_seed(seed.item())\n\n    def log(self, **data):\n        return self.accelerator.log(data, step = self.step.item())\n\n    def save(self, path, overwrite = False):\n\n        acc = self.accelerator\n\n        acc.wait_for_everyone()\n\n        if not acc.is_main_process:\n            return\n\n        path = Path(path)\n        assert overwrite or not path.exists()\n\n        pkg = dict(\n            actor = self.actor.state_dict(),\n            ema_actor = self.ema_actor.state_dict() if self.use_ema else None,\n            state_norm = self.state_norm.state_dict() if self.use_state_norm else None,\n            latents = self.gene_pool.state_dict() if exists(self.gene_pool) else None,\n            step = self.step\n        )\n\n        torch.save(pkg, str(path))\n\n    def load(self, path):\n        path = Path(path)\n\n        assert path.exists()\n\n        pkg = torch.load(str(path), weights_only = True)\n\n        self.actor.load_state_dict(pkg['actor'])\n\n        if exists(self.gene_pool):\n            self.gene_pool.load_state_dict(pkg['latents'])\n\n        if self.use_ema:\n            assert 'ema_actor' in pkg\n            self.ema_actor.load_state_dict(pkg['ema_actor'])\n\n        if self.use_state_norm:\n            assert 'state_norm' in pkg\n            self.state_norm.load_state_dict(pkg['state_norm'])\n\n        self.step.copy_(pkg['step'])\n\n    def return_wrapped_actor(self) -> ActorWrapper | Module:\n\n        if not (self.use_state_norm or self.actor_accepts_latents):\n            return self.actor\n\n        wrapped_actor = ActorWrapper(\n            self.actor,\n            state_norm = self.state_norm if self.use_state_norm else None,\n            latent_gene_pool = self.gene_pool if self.actor_accepts_latents else None,\n        )\n\n        return wrapped_actor\n\n    @torch.inference_mode()\n    def forward(\n        self,\n        maybe_envs,\n        num_env_interactions = None,\n        show_progress = None,\n        seed = None,\n        max_timesteps_per_interaction = None,\n    ):\n        max_timesteps_per_interaction = default(max_timesteps_per_interaction, self.max_timesteps)\n        show_progress = default(show_progress, self.show_progress)\n        num_env_interactions = default(num_env_interactions, self.num_env_interactions)\n\n        (\n            learning_rate,\n            num_selected,\n            noise_pop_size,\n            num_rollout_repeats,\n            factorized_noise,\n            orthogonalized_noise,\n            noise_std_dev\n        ) = (\n            self.learning_rate,\n            self.num_selected,\n            self.noise_pop_size,\n            self.num_rollout_repeats,\n            self.factorized_noise,\n            self.orthogonalized_noise,\n            self.noise_std_dev\n        )\n\n        acc, optim = self.accelerator, self.optim\n\n        actor = self.actor if not self.use_ema else self.ema_actor.ema_model\n\n        is_recurrent_actor = self.actor_is_recurrent\n\n        if self.torch_compile_actor:\n            actor = torch.compile(actor)\n\n        is_distributed, is_main, device = (\n            acc.use_distributed,\n            acc.is_main_process,\n            acc.device\n        )\n\n        tqdm = partial(orig_tqdm, disable = not is_main or not show_progress)\n\n        if exists(seed):\n            torch.manual_seed(seed)\n\n        # params\n\n        params = dict(self.actor.named_parameters())\n\n        # outer learning update progress bar\n\n        learning_updates = tqdm(range(num_env_interactions), position = 0)\n\n        for _ in learning_updates:\n\n            self.step.add_(1)\n\n            # synchronize a global seed\n\n            if is_distributed:\n                self.sync_seed_()\n\n            # keep track of the rewards received per noise and its negative\n\n            pop_size_with_baseline = noise_pop_size + 1\n\n            reward_stats = torch.zeros((\n                self.num_genes,           # latent genes for cross over\n                pop_size_with_baseline,   # mutation\n                2,                        # mutation with its anti\n                num_rollout_repeats       # reducing variance with repeat\n            )).to(device)\n\n            # episode seed is shared for one learning cycle\n            # todo - allow for multiple episodes per learning cycle or mutation accumulation\n\n            episode_seed = torch.randint(0, int(1e7), ()).item()\n\n            random.seed(episode_seed)\n\n            # create noises upfront\n\n            episode_states = []\n            noises = dict()\n\n            for key, param in params.items():\n\n                if key not in self.param_names:\n                    continue\n\n                param_noise_std_dev = noise_std_dev[key]\n\n\n                if factorized_noise and param.ndim == 2:\n                    i, j = param.shape\n\n                    rows = torch.randn((pop_size_with_baseline, i), device = device)\n                    cols = torch.randn((pop_size_with_baseline, j), device = device)\n\n                    if orthogonalized_noise:\n                        rows = orthogonal_(rows)\n                        cols = orthogonal_(cols)\n\n                    rows, cols = tuple(t.sign() * t.abs().sqrt() for t in (rows, cols))\n\n                    noises_for_param = einx.multiply('p i, p j -> p i j', rows, cols)\n\n                elif orthogonalized_noise and param.ndim == 2:\n                    # p - population size\n\n                    noises_for_param = torch.randn((pop_size_with_baseline, *param.shape), device = device)\n\n                    noises_for_param, packed_shape = pack([noises_for_param], 'p *')\n                    orthogonal_(noises_for_param)\n                    noises_for_param = first(unpack(noises_for_param, packed_shape, 'p *'))\n\n                else:\n                    noises_for_param = torch.randn((pop_size_with_baseline, *param.shape), device = device)\n\n                noises_for_param[0].zero_() # first is for baseline\n\n                noises[key] = noises_for_param * param_noise_std_dev\n\n            # determine noise for latents\n\n            if self.mutate_latent_genes and self.actor_accepts_latents:\n                genes_shape = self.gene_pool.genes.shape\n                all_latent_noises = torch.randn((pop_size_with_baseline, *genes_shape), device = device) * self.latent_gene_noise_std_dev\n\n                all_latent_noises[0].zero_() # first for baseline\n\n            # maybe domain randomization\n\n            if isinstance(maybe_envs, (list, tuple)):\n                env = choice(maybe_envs)\n            else:\n                env = maybe_envs\n\n            # maybe shard the interaction with environments for the individual noise perturbations\n\n            for gene_noise_index in tqdm(self.rollouts_for_machine.tolist(), desc = 'noise index', position = 1, leave = False):\n\n                gene_index, noise_index = gene_noise_index\n\n                # prepare the latent gene, if needed\n\n                if self.actor_accepts_latents:\n                    latent_gene = self.gene_pool[gene_index]\n\n                    if self.mutate_latent_genes:\n                        latent_gene_noises = all_latent_noises[:, gene_index]\n\n                # prepare the mutation\n\n                noise = {key: noises_for_param[noise_index] for key, noises_for_param in noises.items()}\n\n                for sign_index, sign in tqdm(enumerate((1, -1)), desc = 'sign', position = 2, leave = False):\n\n                    param_with_noise = {name: Parameter(param + noise[name] * sign) if name in self.param_names else param for name, param in params.items()}\n\n                    for repeat_index in tqdm(range(num_rollout_repeats), desc = 'rollout repeat', position = 3, leave = False):\n\n                        state = env.reset(seed = episode_seed)\n\n                        if isinstance(state, tuple):\n                            state, *_ = state\n\n                        episode_states.clear()\n\n                        total_reward = 0.\n\n                        if is_recurrent_actor:\n                            assert hasattr(actor, 'init_hiddens'), 'your actor must have an `init_hiddens` buffer if to be used recurrently'\n                            mem = actor.init_hiddens\n\n                        for timestep in range(max_timesteps_per_interaction):\n\n                            state = from_numpy(state).to(device)\n\n                            episode_states.append(state)\n\n                            if self.use_state_norm:\n                                self.state_norm.eval()\n                                state = self.state_norm(state)\n\n                            kwargs = dict()\n\n                            if is_recurrent_actor:\n                                kwargs.update(hiddens = mem)\n\n                            actor_state_input = state\n\n                            if self.actor_accepts_latents:\n\n                                if self.mutate_latent_genes:\n                                    latent_gene_noise = latent_gene_noises[noise_index] * sign\n\n                                    latent_gene = latent_gene + latent_gene_noise\n\n                                if self.concat_latent_to_state:\n                                    actor_state_input = cat((state, latent_gene))\n                                else:\n                                    kwargs.update(latent = latent_gene)\n\n                            actor_out = functional_call(actor, param_with_noise, actor_state_input, kwargs = kwargs)\n\n                            # take care of recurrent network\n                            # the nicest thing about ES is learning recurrence / memory without much hassle (in fact, can be non-differentiable)\n\n                            if isinstance(actor_out, tuple):\n                                action_or_logits, *actor_rest_out = actor_out\n                            else:\n                                action_or_logits = actor_out\n                                actor_rest_out = []\n\n                            if is_recurrent_actor:\n                                assert len(actor_rest_out) > 0\n                                mem, *_ = actor_rest_out\n\n                            # sample\n\n                            if self.sample_actions_from_actor:\n                                action = gumbel_sample(action_or_logits)\n                                action = item(action)\n                            else:\n                                action = item(action_or_logits)\n\n                            env_out = env.step(action)\n\n                            # flexible output from env\n\n                            assert isinstance(env_out, tuple)\n\n                            len_env_out = len(env_out)\n\n                            if len_env_out >= 4:\n                                next_state, reward, terminated, truncated, *_ = env_out\n                                done = terminated or truncated\n                            elif len_env_out == 3:\n# ... truncated ...","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":true}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.__init__","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.__init__#L491-L713","kind":"function","name":"__init__","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":491,"end_line":713,"context_start_line":471,"context_end_line":733,"code":"            if has_elites:\n                elites, genes = genes[:, :1], genes[:, 1:]\n\n            genes.add_(torch.randn_like(genes) * self.mutation_std_dev)\n\n            if has_elites:\n                genes = torch.cat((elites, genes), dim = 1)\n\n        genes = self.merge_islands(genes)\n\n        self.genes.copy_(l2norm(genes))\n\n        self.step.add_(1)\n\n        return selected_gene_ids # return the selected gene ids, for the outer learning orchestrator to determine which mutations to accept\n\n# main class\n\nclass BlackboxGradientSensing(Module):\n\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        accelerator: Accelerator | None = None,\n        state_norm: StateNorm | Module | dict | None  = None,\n        actor_is_recurrent = False,\n        latent_gene_pool: LatentGenePool | dict | None = None,\n        concat_latent_to_state = False, # if False, will pass in the latents as a kwarg `latent`, else try to concat it to the state\n        crossover_every_step = 1,\n        crossover_after_step = 0,\n        num_env_interactions = 1000,\n        noise_pop_size = 40,\n        noise_std_dev: dict[str, float] | float = 0.1, # Appendix F in paper, appears to be constant for sim and real\n        mutate_latent_genes = False,\n        latent_gene_noise_std_dev = 1e-4,\n        factorized_noise = True,\n        orthogonalized_noise = True,\n        num_selected = 8,    # of the population, how many of the best performing noise perturbations to accept\n        num_rollout_repeats = 3,\n        optim_klass = Adam,\n        learning_rate = 8e-2,\n        weight_decay = 1e-4,\n        betas = (0.9, 0.95),\n        max_timesteps = 500,\n        calc_fitness: Callable[[Tensor], Tensor] | None = None,\n        param_names: set[str] | str | None = None,\n        modules_to_optimize: set[str] | str | None = None,\n        show_progress = True,\n        optim_kwargs: dict = dict(),\n        optim_step_post_hook: Callable | None = None,\n        accelerate_kwargs: dict = dict(),\n        num_std_below_mean_thres_accept = 0., # for each reward + anti, if they are below this number of standard deviations below the mean, reject it\n        frac_genes_pass_thres_accept = 0.9,    # in population based training, the fraction of genes that must be all above a given reward threshold for that noise to be accepted\n        cpu = False,\n        torch_compile_actor = True,\n        use_ema = False,\n        ema_decay = 0.9,\n        update_model_with_ema_every = 100,\n        sample_actions_from_actor = True\n    ):\n        super().__init__()\n        assert num_selected < noise_pop_size, f'number of selected noise must be less than the total population of noise'\n\n        # ES(1+1) related\n\n        self.num_selected = num_selected\n        self.noise_pop_size = noise_pop_size\n        self.num_rollout_repeats = num_rollout_repeats\n\n        self.orthogonalized_noise = orthogonalized_noise    # orthogonalized noise - todo: add the fast hadamard-rademacher ones proposed in paper\n        self.factorized_noise = factorized_noise            # maybe factorized gaussian noise\n\n        # use accelerate to manage distributed\n\n        if not exists(accelerator):\n\n            if cpu:\n                assert 'cpu' not in accelerate_kwargs\n                accelerate_kwargs = {'cpu': True, **accelerate_kwargs}\n\n            accelerator = Accelerator(**accelerate_kwargs)\n\n        device = accelerator.device\n        self.accelerator = accelerator\n\n        # net\n\n        self.actor = actor.to(device)\n\n        self.use_ema = use_ema\n        self.ema_actor = EMA(actor, beta = ema_decay, update_model_with_ema_every = update_model_with_ema_every, include_online_model = False) if use_ema else None\n\n        self.torch_compile_actor = torch_compile_actor\n\n        self.actor_is_recurrent = actor_is_recurrent # if set to True, actor must pass out the memory on forward on the second position, then receive it as a kwarg of `hiddens`\n\n        named_params = dict(actor.named_parameters())\n        named_modules = dict(actor.named_modules())\n\n        # whether to sample actions from the actor\n\n        self.sample_actions_from_actor = sample_actions_from_actor\n\n        # handle only a subset of parameters being optimized\n\n        if isinstance(param_names, str):\n            param_names = {param_names}\n\n        # also handle if module names are passed in\n        # ex. optimizing some gating / routing neural network that ties together a bunch of other pretrained policies\n\n        if isinstance(modules_to_optimize, str):\n            modules_to_optimize = {modules_to_optimize}\n\n        if exists(modules_to_optimize):\n            param_names = default(param_names, set())\n\n            for module_name in modules_to_optimize:\n                module = named_modules[module_name]\n                module_param_names = dict(module.named_parameters()).keys()\n                module_param_names_with_prefix = [f'{module_name}.{param_name}' for param_name in module_param_names]\n\n                param_names |= set(module_param_names_with_prefix)\n\n        param_names = default(param_names, set(named_params.keys()))\n\n        # validate and set parameters to optimize\n\n        assert len(param_names) > 0, f'no parameters to optimize with evolutionary strategy'\n\n        self.param_names = param_names\n\n        # noise std deviations, which can be one fixed value, or tailored to specific value per parameter name\n\n        if isinstance(noise_std_dev, float):\n            noise_std_dev = {name: noise_std_dev for name in self.param_names}\n\n        self.noise_std_dev = noise_std_dev\n\n        # env interactions\n\n        self.max_timesteps = max_timesteps\n\n        # gene pool, another axis for scaling and bitter lesson\n\n        num_genes = 1\n        gene_pool = None\n\n        if isinstance(latent_gene_pool, dict):\n            gene_pool = LatentGenePool(**latent_gene_pool)\n            gene_pool.to(device)\n\n            num_genes = gene_pool.num_genes\n\n        self.actor_accepts_latents = exists(gene_pool)\n        self.concat_latent_to_state = concat_latent_to_state\n\n        self.gene_pool = gene_pool\n        self.num_genes = num_genes\n\n        def default_calc_fitness(reward_stats):\n            return reduce(reward_stats[:, 0], 'g s e -> g', 'mean')\n\n        self.calc_fitness = default(calc_fitness, default_calc_fitness)\n\n        self.crossover_every_step = crossover_every_step\n        self.crossover_after_step = crossover_after_step\n\n        # whether to do heritable mutations to the latent genes\n\n        self.mutate_latent_genes = mutate_latent_genes\n\n        self.latent_gene_noise_std_dev = latent_gene_noise_std_dev\n\n        # optim\n\n        optim_params = [named_params[param_name] for param_name in self.param_names]\n\n        self.optim = optim_klass(optim_params, lr = learning_rate, betas = betas, **optim_kwargs)\n\n        self.learning_rate = learning_rate\n        self.weight_decay = weight_decay\n\n        # hooks\n\n        if exists(optim_step_post_hook):\n            def hook(*_):\n                optim_step_post_hook()\n\n            self.optim.register_step_post_hook(hook)\n\n        # maybe state norm\n\n        if isinstance(state_norm, dict):\n            state_norm = StateNorm(**state_norm)\n\n        self.use_state_norm = exists(state_norm)\n\n        if self.use_state_norm:\n            self.state_norm = state_norm\n            state_norm.to(device)\n\n        # progress bar\n\n        self.show_progress = show_progress\n\n        # number of interactions with environment for learning\n\n        self.num_env_interactions = num_env_interactions\n\n        # calculate num of episodes per learning cycle for this machine\n\n        world_size, rank = accelerator.num_processes, accelerator.process_index\n\n        # for each gene, roll out for each noise candidate\n\n        gene_indices = torch.arange(num_genes)\n        mutation_indices = torch.arange(noise_pop_size + 1)\n\n        gene_mutation_indices = torch.cartesian_prod(gene_indices, mutation_indices)\n        rollouts_for_machine = gene_mutation_indices.chunk(world_size)[rank]\n\n        self.register_buffer('rollouts_for_machine', rollouts_for_machine, persistent = False)\n\n        # for each reward and its anti, the number of standard deviations below the baseline they can be for acceptance\n\n        self.num_std_below_mean_thres_accept = num_std_below_mean_thres_accept\n\n        # the fraction of genes that must be above the given reward threshold as defined by the variable above, in order for said noise to be accepted\n\n        assert 0 <= frac_genes_pass_thres_accept <= 1.\n        self.frac_genes_pass_thres_accept = frac_genes_pass_thres_accept\n\n        # expose a few computed variables\n\n        self.num_episodes_per_learning_cycle = self.rollouts_for_machine.shape[0] * num_rollout_repeats * 2\n\n        self.is_main = rank == 0\n\n        # keep track of number of steps\n\n        self.register_buffer('step', tensor(0))\n\n    def sync_seed_(self):\n        acc = self.accelerator\n        rand_int = torch.randint(0, int(1e7), (), device = acc.device)\n        seed = acc.reduce(rand_int)\n        torch.manual_seed(seed.item())\n\n    def log(self, **data):\n        return self.accelerator.log(data, step = self.step.item())\n\n    def save(self, path, overwrite = False):\n\n        acc = self.accelerator\n\n        acc.wait_for_everyone()\n\n        if not acc.is_main_process:\n            return\n\n        path = Path(path)","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.forward","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.forward#L782-L1204","kind":"function","name":"forward","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":782,"end_line":1204,"context_start_line":762,"context_end_line":1204,"code":"        if self.use_state_norm:\n            assert 'state_norm' in pkg\n            self.state_norm.load_state_dict(pkg['state_norm'])\n\n        self.step.copy_(pkg['step'])\n\n    def return_wrapped_actor(self) -> ActorWrapper | Module:\n\n        if not (self.use_state_norm or self.actor_accepts_latents):\n            return self.actor\n\n        wrapped_actor = ActorWrapper(\n            self.actor,\n            state_norm = self.state_norm if self.use_state_norm else None,\n            latent_gene_pool = self.gene_pool if self.actor_accepts_latents else None,\n        )\n\n        return wrapped_actor\n\n    @torch.inference_mode()\n    def forward(\n        self,\n        maybe_envs,\n        num_env_interactions = None,\n        show_progress = None,\n        seed = None,\n        max_timesteps_per_interaction = None,\n    ):\n        max_timesteps_per_interaction = default(max_timesteps_per_interaction, self.max_timesteps)\n        show_progress = default(show_progress, self.show_progress)\n        num_env_interactions = default(num_env_interactions, self.num_env_interactions)\n\n        (\n            learning_rate,\n            num_selected,\n            noise_pop_size,\n            num_rollout_repeats,\n            factorized_noise,\n            orthogonalized_noise,\n            noise_std_dev\n        ) = (\n            self.learning_rate,\n            self.num_selected,\n            self.noise_pop_size,\n            self.num_rollout_repeats,\n            self.factorized_noise,\n            self.orthogonalized_noise,\n            self.noise_std_dev\n        )\n\n        acc, optim = self.accelerator, self.optim\n\n        actor = self.actor if not self.use_ema else self.ema_actor.ema_model\n\n        is_recurrent_actor = self.actor_is_recurrent\n\n        if self.torch_compile_actor:\n            actor = torch.compile(actor)\n\n        is_distributed, is_main, device = (\n            acc.use_distributed,\n            acc.is_main_process,\n            acc.device\n        )\n\n        tqdm = partial(orig_tqdm, disable = not is_main or not show_progress)\n\n        if exists(seed):\n            torch.manual_seed(seed)\n\n        # params\n\n        params = dict(self.actor.named_parameters())\n\n        # outer learning update progress bar\n\n        learning_updates = tqdm(range(num_env_interactions), position = 0)\n\n        for _ in learning_updates:\n\n            self.step.add_(1)\n\n            # synchronize a global seed\n\n            if is_distributed:\n                self.sync_seed_()\n\n            # keep track of the rewards received per noise and its negative\n\n            pop_size_with_baseline = noise_pop_size + 1\n\n            reward_stats = torch.zeros((\n                self.num_genes,           # latent genes for cross over\n                pop_size_with_baseline,   # mutation\n                2,                        # mutation with its anti\n                num_rollout_repeats       # reducing variance with repeat\n            )).to(device)\n\n            # episode seed is shared for one learning cycle\n            # todo - allow for multiple episodes per learning cycle or mutation accumulation\n\n            episode_seed = torch.randint(0, int(1e7), ()).item()\n\n            random.seed(episode_seed)\n\n            # create noises upfront\n\n            episode_states = []\n            noises = dict()\n\n            for key, param in params.items():\n\n                if key not in self.param_names:\n                    continue\n\n                param_noise_std_dev = noise_std_dev[key]\n\n\n                if factorized_noise and param.ndim == 2:\n                    i, j = param.shape\n\n                    rows = torch.randn((pop_size_with_baseline, i), device = device)\n                    cols = torch.randn((pop_size_with_baseline, j), device = device)\n\n                    if orthogonalized_noise:\n                        rows = orthogonal_(rows)\n                        cols = orthogonal_(cols)\n\n                    rows, cols = tuple(t.sign() * t.abs().sqrt() for t in (rows, cols))\n\n                    noises_for_param = einx.multiply('p i, p j -> p i j', rows, cols)\n\n                elif orthogonalized_noise and param.ndim == 2:\n                    # p - population size\n\n                    noises_for_param = torch.randn((pop_size_with_baseline, *param.shape), device = device)\n\n                    noises_for_param, packed_shape = pack([noises_for_param], 'p *')\n                    orthogonal_(noises_for_param)\n                    noises_for_param = first(unpack(noises_for_param, packed_shape, 'p *'))\n\n                else:\n                    noises_for_param = torch.randn((pop_size_with_baseline, *param.shape), device = device)\n\n                noises_for_param[0].zero_() # first is for baseline\n\n                noises[key] = noises_for_param * param_noise_std_dev\n\n            # determine noise for latents\n\n            if self.mutate_latent_genes and self.actor_accepts_latents:\n                genes_shape = self.gene_pool.genes.shape\n                all_latent_noises = torch.randn((pop_size_with_baseline, *genes_shape), device = device) * self.latent_gene_noise_std_dev\n\n                all_latent_noises[0].zero_() # first for baseline\n\n            # maybe domain randomization\n\n            if isinstance(maybe_envs, (list, tuple)):\n                env = choice(maybe_envs)\n            else:\n                env = maybe_envs\n\n            # maybe shard the interaction with environments for the individual noise perturbations\n\n            for gene_noise_index in tqdm(self.rollouts_for_machine.tolist(), desc = 'noise index', position = 1, leave = False):\n\n                gene_index, noise_index = gene_noise_index\n\n                # prepare the latent gene, if needed\n\n                if self.actor_accepts_latents:\n                    latent_gene = self.gene_pool[gene_index]\n\n                    if self.mutate_latent_genes:\n                        latent_gene_noises = all_latent_noises[:, gene_index]\n\n                # prepare the mutation\n\n                noise = {key: noises_for_param[noise_index] for key, noises_for_param in noises.items()}\n\n                for sign_index, sign in tqdm(enumerate((1, -1)), desc = 'sign', position = 2, leave = False):\n\n                    param_with_noise = {name: Parameter(param + noise[name] * sign) if name in self.param_names else param for name, param in params.items()}\n\n                    for repeat_index in tqdm(range(num_rollout_repeats), desc = 'rollout repeat', position = 3, leave = False):\n\n                        state = env.reset(seed = episode_seed)\n\n                        if isinstance(state, tuple):\n                            state, *_ = state\n\n                        episode_states.clear()\n\n                        total_reward = 0.\n\n                        if is_recurrent_actor:\n                            assert hasattr(actor, 'init_hiddens'), 'your actor must have an `init_hiddens` buffer if to be used recurrently'\n                            mem = actor.init_hiddens\n\n                        for timestep in range(max_timesteps_per_interaction):\n\n                            state = from_numpy(state).to(device)\n\n                            episode_states.append(state)\n\n                            if self.use_state_norm:\n                                self.state_norm.eval()\n                                state = self.state_norm(state)\n\n                            kwargs = dict()\n\n                            if is_recurrent_actor:\n                                kwargs.update(hiddens = mem)\n\n                            actor_state_input = state\n\n                            if self.actor_accepts_latents:\n\n                                if self.mutate_latent_genes:\n                                    latent_gene_noise = latent_gene_noises[noise_index] * sign\n\n                                    latent_gene = latent_gene + latent_gene_noise\n\n                                if self.concat_latent_to_state:\n                                    actor_state_input = cat((state, latent_gene))\n                                else:\n                                    kwargs.update(latent = latent_gene)\n\n                            actor_out = functional_call(actor, param_with_noise, actor_state_input, kwargs = kwargs)\n\n                            # take care of recurrent network\n                            # the nicest thing about ES is learning recurrence / memory without much hassle (in fact, can be non-differentiable)\n\n                            if isinstance(actor_out, tuple):\n                                action_or_logits, *actor_rest_out = actor_out\n                            else:\n                                action_or_logits = actor_out\n                                actor_rest_out = []\n\n                            if is_recurrent_actor:\n                                assert len(actor_rest_out) > 0\n                                mem, *_ = actor_rest_out\n\n                            # sample\n\n                            if self.sample_actions_from_actor:\n                                action = gumbel_sample(action_or_logits)\n                                action = item(action)\n                            else:\n                                action = item(action_or_logits)\n\n                            env_out = env.step(action)\n\n                            # flexible output from env\n\n                            assert isinstance(env_out, tuple)\n\n                            len_env_out = len(env_out)\n\n                            if len_env_out >= 4:\n                                next_state, reward, terminated, truncated, *_ = env_out\n                                done = terminated or truncated\n                            elif len_env_out == 3:\n                                next_state, reward, done = env_out\n                            elif len_env_out == 2:\n                                next_state, reward = env_out\n                                done = False\n                            else:\n                                raise RuntimeError('invalid number of items received from environment')\n\n                            total_reward += float(reward)\n\n                            if done:\n                                break\n\n                            state = next_state\n                    \n                        reward_stats[gene_index, noise_index, sign_index, repeat_index] = total_reward\n\n            # maybe synchronize reward stats, as well as min episode length for updating state norm\n\n            if is_distributed:\n                reward_stats = acc.reduce(reward_stats)\n\n                if self.use_state_norm:\n                    episode_state_len = tensor(len(episode_states), device = device)\n\n                    min_episode_state_len = acc.gather(episode_state_len).amin().item()\n\n                    episode_states = episode_states[:min_episode_state_len]\n\n            # update state norm with one episode worth (as it is repeated)\n\n            if self.use_state_norm:\n                self.state_norm.train()\n\n                for state in episode_states:\n                    self.state_norm(state)\n\n            # update based on eq (3) and (4) in the paper\n            # their contribution is basically to use reward deltas (for a given noise and its negative sign) for sorting for the 'elite' directions\n\n            # g - latent / gene, n - noise / mutation, s - sign, e - episode\n\n            reward_std = reward_stats.std()\n\n            reward_mean = reduce(reward_stats, 'g n s e -> g n s', 'mean')\n\n            # split out the baseline\n\n            baseline_mean, reward_mean = reward_mean[..., 0, :].mean(dim = -1), reward_mean[..., 1:, :]\n\n            reward_deltas = reward_mean[..., 0] - reward_mean[..., 1]\n\n            # mask out any noise candidates whose max reward mean is greater than baseline\n\n            reward_threshold_accept = baseline_mean - reward_std * self.num_std_below_mean_thres_accept\n\n            max_reward_mean = torch.amax(reward_mean, dim = -1)\n\n            accept_mask = einx.greater_equal('g n, g -> g n', max_reward_mean, reward_threshold_accept)\n            accept_mask = reduce(accept_mask.float(), 'g n -> n', 'mean') >= self.frac_genes_pass_thres_accept\n\n            reward_deltas = einx.multiply('g n, n', reward_deltas, accept_mask.float()) # just zero out the reward deltas that do not pass the threshold\n\n            # progress bar\n\n            pbar_descriptions = [\n                f'rewards: {baseline_mean.mean().item():.2f}',\n                f'best: {reward_mean.amax().item():.2f}',\n                f'accepted: {accept_mask.sum().item()} / {noise_pop_size}'\n            ]\n\n            def calculate_weights(reward_deltas, log = True):\n\n                # get the top performing noise indices\n\n                k = min(num_selected, reward_deltas.numel() // 2)\n\n                ranked_reward_deltas, ranked_reward_indices = reward_deltas.abs().topk(k, dim = -1)\n\n                # get the weights for the weighted sum of the topk noise according to eq (3)\n\n                weights = ranked_reward_deltas / reward_std.clamp(min = 1e-3)\n\n                # multiply by sign\n\n                weights *= torch.sign(reward_deltas.gather(-1, ranked_reward_indices))\n\n                if log:\n                    pbar_descriptions.append(f'best delta: {ranked_reward_deltas.amax().item():.2f}')\n\n                return weights, ranked_reward_indices\n\n            # get the weights for update\n\n            (\n                weights,\n                ranked_reward_indices,\n            ) = calculate_weights(reduce(reward_deltas, 'g n -> n', 'mean'))\n\n            # update the param one by one\n\n            for name, noise in noises.items():\n\n                param = params[name]\n\n                # add the best \"elite\" noise directions weighted by eq (3)\n\n                best_noises = noise[1:][ranked_reward_indices]\n\n                update = einsum(best_noises, weights, 'n ..., n -> ...')\n\n                param.grad = -update\n\n            # update latents if needed\n\n            if self.actor_accepts_latents and self.mutate_latent_genes:\n\n                (\n                    weights,\n                    ranked_reward_indices,\n                ) = calculate_weights(reward_deltas, log = False)\n\n                # [n] g d, g sel -> sel g d\n\n                ranked_reward_indices = rearrange(ranked_reward_indices, 'g sel -> sel g')\n\n                ranked_reward_indices_for_gather = repeat(ranked_reward_indices, '... -> ... d', d = all_latent_noises.shape[-1])\n\n                sel_noises = all_latent_noises.gather(0, ranked_reward_indices_for_gather)\n\n                # weighted update, accounting for population dimension\n\n                update = einsum(sel_noises, weights, 'sel g ..., g sel -> g ...')\n\n                genes = self.gene_pool.genes\n\n                # add to update\n\n                genes.add_(update * learning_rate)\n\n            # decay for norm gammas back to identity\n\n            for mod in actor.modules():\n                if isinstance(mod, nn.RMSNorm):\n                    mod.weight.lerp_(torch.ones_like(mod.weight), self.weight_decay)\n\n            # use optimizer to manage step\n\n            optim.step()\n            optim.zero_grad()\n\n            # maybe ema\n\n            if self.use_ema:\n                self.ema_actor.update()\n\n            # maybe crossover, if a genetic population is present\n            # the crossover needs to happen before the mutation, as we will discard the mutation contributions from the genes that get selected out.\n\n            if (\n                exists(self.gene_pool) and\n                self.step.item() > self.crossover_after_step and\n                divisible_by(self.step.item(), self.crossover_every_step)\n            ):\n                # only include baseline for now, but could include the mutation rewards for selecting for meta-learning attributes.\n\n                fitnesses = self.calc_fitness(reward_stats)\n\n                self.sync_seed_()\n                self.gene_pool.evolve(fitnesses)\n\n            # logging\n\n            learning_updates.set_description(join(pbar_descriptions, ' | '))\n\n            # log to experiment tracker\n\n            self.log(\n                rewards = baseline_mean.mean().item()\n            )","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.norm_weights_","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.norm_weights_#L223-L231","kind":"function","name":"norm_weights_","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":223,"end_line":231,"context_start_line":203,"context_end_line":251,"code":"        self.continuous = continuous\n\n        self.norm_weights_()\n\n        # whether to sample from the output discrete logits\n\n        self.sample = sample\n\n        # for genes -> expression network (the analogy is growing on me)\n\n        self.accepts_latent = accepts_latent\n        if accepts_latent:\n            assert exists(dim_latent)\n\n            self.encode_latent = nn.Linear(dim_latent, hidden_dim)\n            self.encode_latent = maybe_weight_norm(self.encode_latent, name = 'weight', dim = None)\n            self.post_norm_latent_added = nn.RMSNorm(hidden_dim)\n\n        self.register_buffer('init_hiddens', torch.zeros(hidden_dim))\n\n    def norm_weights_(self):\n        if not self.weight_norm_linears:\n            return\n\n        for param in self.parameters():\n            if not isinstance(param, nn.Linear):\n                continue\n\n            param.parametrization.weight.original.copy_(param.weight)\n\n    def forward(\n        self,\n        x,\n        hiddens = None,\n        latent = None,\n        sample_temperature = 1.\n    ):\n        assert xnor(exists(latent), self.accepts_latent)\n\n        x = self.proj_in(x)\n        x, forget = x[:-1], x[-1]\n\n        x = F.silu(x)\n\n        if exists(hiddens):\n            past_mem = self.mem_norm(hiddens) * forget.sigmoid()\n            x = x + past_mem\n\n        if self.accepts_latent:","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.__getitem__","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.__getitem__#L378-L379","kind":"function","name":"__getitem__","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":378,"end_line":379,"context_start_line":358,"context_end_line":399,"code":"        self.num_selected = num_selected\n        self.num_children = num_genes_per_island - num_selected\n        self.tournament_size = tournament_size\n\n        self.dim_gene = dim\n        self.genes = nn.Parameter(l2norm(torch.randn(num_genes, dim)))\n\n        self.split_islands = Rearrange('(i g) ... -> i g ...', i = num_islands)\n        self.merge_islands = Rearrange('i g ... -> (i g) ...')\n\n        self.num_elites = num_elites # todo - redo with affinity maturation algorithm from artificial immune system field\n        self.mutation_std_dev = mutation_std_dev\n\n        assert 0. <= num_frac_migrate <= 1.\n\n        self.num_frac_migrate = num_frac_migrate\n        self.migrate_genes_every = migrate_genes_every\n\n        self.register_buffer('step', tensor(0))\n\n    def __getitem__(self, idx):\n        return l2norm(self.genes[idx])\n\n    @torch.inference_mode()\n    def evolve(\n        self,\n        fitnesses,\n        temperature = 1.5\n    ):\n        device, num_selected = fitnesses.device, self.num_selected\n        assert fitnesses.ndim == 1 and fitnesses.shape[0] == self.num_genes\n\n        # split out the islands\n\n        genes = self.genes\n        num_islands = self.num_islands\n        has_elites = self.num_elites > 0\n\n        fitnesses = self.split_islands(fitnesses)\n        genes = self.split_islands(genes)\n\n        # local competition within each island","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.evolve","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.evolve#L382-L485","kind":"function","name":"evolve","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":382,"end_line":485,"context_start_line":362,"context_end_line":505,"code":"        self.dim_gene = dim\n        self.genes = nn.Parameter(l2norm(torch.randn(num_genes, dim)))\n\n        self.split_islands = Rearrange('(i g) ... -> i g ...', i = num_islands)\n        self.merge_islands = Rearrange('i g ... -> (i g) ...')\n\n        self.num_elites = num_elites # todo - redo with affinity maturation algorithm from artificial immune system field\n        self.mutation_std_dev = mutation_std_dev\n\n        assert 0. <= num_frac_migrate <= 1.\n\n        self.num_frac_migrate = num_frac_migrate\n        self.migrate_genes_every = migrate_genes_every\n\n        self.register_buffer('step', tensor(0))\n\n    def __getitem__(self, idx):\n        return l2norm(self.genes[idx])\n\n    @torch.inference_mode()\n    def evolve(\n        self,\n        fitnesses,\n        temperature = 1.5\n    ):\n        device, num_selected = fitnesses.device, self.num_selected\n        assert fitnesses.ndim == 1 and fitnesses.shape[0] == self.num_genes\n\n        # split out the islands\n\n        genes = self.genes\n        num_islands = self.num_islands\n        has_elites = self.num_elites > 0\n\n        fitnesses = self.split_islands(fitnesses)\n        genes = self.split_islands(genes)\n\n        # local competition within each island\n\n        sorted_fitness, sorted_gene_ids = fitnesses.sort(dim = -1, descending = True)\n\n        selected_gene_ids = sorted_gene_ids[:, :num_selected]\n        selected_fitness = sorted_fitness[:, :num_selected]\n\n        selected_gene_ids_for_gather = repeat(selected_gene_ids, '... -> ... d', d = self.dim_gene)\n\n        selected_genes = genes.gather(1, selected_gene_ids_for_gather)\n\n        # tournament\n\n        num_children = self.num_children\n\n        batch_randperm = torch.randn((num_islands, num_children, num_selected), device = device).argsort(dim = -1)\n        tourn_ids = batch_randperm[..., :self.tournament_size]\n\n        sorted_fitness = repeat(sorted_fitness, '... -> ... d', d = tourn_ids.shape[-1])\n\n        tourn_fitness_ids = sorted_fitness.gather(1, tourn_ids)\n\n        parent_ids = tourn_fitness_ids.topk(2, dim = -1).indices\n\n        parent_ids = rearrange(parent_ids, 'i g parents -> i (g parents)')\n\n        parent_ids = repeat(parent_ids, '... -> ... d', d = self.dim_gene)\n\n        parents = selected_genes.gather(1, parent_ids)\n        parents = rearrange(parents, 'i (g parents) d -> parents i g d', parents = 2)\n\n        # cross over\n\n        parent1, parent2 = parents\n\n        children = parent1.lerp(parent2, (torch.randn_like(parent1) / temperature).sigmoid())\n\n        # maybe migration\n\n        if (\n            divisible_by(self.step.item() + 1, self.migrate_genes_every) and\n            self.num_islands > 1 and\n            self.num_frac_migrate > 0.\n        ):\n\n            if has_elites:\n                elites, selected_genes = selected_genes[:, :1], selected_genes[:, 1:]\n\n            num_can_migrate = selected_genes.shape[1]\n\n            num_migrate = max(1, num_can_migrate * self.num_frac_migrate)\n\n            # fixed migration pattern - what i observe to work best, for now\n            # todo - option to make it randomly selected with a mask\n\n            selected_genes, migrants = selected_genes[:, -num_migrate:], selected_genes[:, :-num_migrate]\n\n            migrants = torch.roll(migrants, 1, dims = (1,))\n\n            selected_genes = cat((selected_genes, migrants), dim = 1)\n\n            if has_elites:\n                selected_genes = cat((elites, selected_genes), dim = 1)\n\n        # concat children\n\n        genes = torch.cat((selected_genes, children), dim = 1)\n\n        # mutate\n\n        if self.mutation_std_dev > 0:\n\n            if has_elites:\n                elites, genes = genes[:, :1], genes[:, 1:]\n\n            genes.add_(torch.randn_like(genes) * self.mutation_std_dev)\n\n            if has_elites:\n                genes = torch.cat((elites, genes), dim = 1)\n\n        genes = self.merge_islands(genes)\n\n        self.genes.copy_(l2norm(genes))\n\n        self.step.add_(1)\n\n        return selected_gene_ids # return the selected gene ids, for the outer learning orchestrator to determine which mutations to accept\n\n# main class\n\nclass BlackboxGradientSensing(Module):\n\n    def __init__(\n        self,\n        actor: Module,\n        *,\n        accelerator: Accelerator | None = None,\n        state_norm: StateNorm | Module | dict | None  = None,\n        actor_is_recurrent = False,\n        latent_gene_pool: LatentGenePool | dict | None = None,\n        concat_latent_to_state = False, # if False, will pass in the latents as a kwarg `latent`, else try to concat it to the state\n        crossover_every_step = 1,\n        crossover_after_step = 0,\n        num_env_interactions = 1000,\n        noise_pop_size = 40,\n        noise_std_dev: dict[str, float] | float = 0.1, # Appendix F in paper, appears to be constant for sim and real\n        mutate_latent_genes = False,","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.sync_seed_","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.sync_seed_#L715-L719","kind":"function","name":"sync_seed_","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":715,"end_line":719,"context_start_line":695,"context_end_line":739,"code":"\n        # for each reward and its anti, the number of standard deviations below the baseline they can be for acceptance\n\n        self.num_std_below_mean_thres_accept = num_std_below_mean_thres_accept\n\n        # the fraction of genes that must be above the given reward threshold as defined by the variable above, in order for said noise to be accepted\n\n        assert 0 <= frac_genes_pass_thres_accept <= 1.\n        self.frac_genes_pass_thres_accept = frac_genes_pass_thres_accept\n\n        # expose a few computed variables\n\n        self.num_episodes_per_learning_cycle = self.rollouts_for_machine.shape[0] * num_rollout_repeats * 2\n\n        self.is_main = rank == 0\n\n        # keep track of number of steps\n\n        self.register_buffer('step', tensor(0))\n\n    def sync_seed_(self):\n        acc = self.accelerator\n        rand_int = torch.randint(0, int(1e7), (), device = acc.device)\n        seed = acc.reduce(rand_int)\n        torch.manual_seed(seed.item())\n\n    def log(self, **data):\n        return self.accelerator.log(data, step = self.step.item())\n\n    def save(self, path, overwrite = False):\n\n        acc = self.accelerator\n\n        acc.wait_for_everyone()\n\n        if not acc.is_main_process:\n            return\n\n        path = Path(path)\n        assert overwrite or not path.exists()\n\n        pkg = dict(\n            actor = self.actor.state_dict(),\n            ema_actor = self.ema_actor.state_dict() if self.use_ema else None,\n            state_norm = self.state_norm.state_dict() if self.use_state_norm else None,","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.save","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.save#L724-L744","kind":"function","name":"save","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":724,"end_line":744,"context_start_line":704,"context_end_line":764,"code":"\n        # expose a few computed variables\n\n        self.num_episodes_per_learning_cycle = self.rollouts_for_machine.shape[0] * num_rollout_repeats * 2\n\n        self.is_main = rank == 0\n\n        # keep track of number of steps\n\n        self.register_buffer('step', tensor(0))\n\n    def sync_seed_(self):\n        acc = self.accelerator\n        rand_int = torch.randint(0, int(1e7), (), device = acc.device)\n        seed = acc.reduce(rand_int)\n        torch.manual_seed(seed.item())\n\n    def log(self, **data):\n        return self.accelerator.log(data, step = self.step.item())\n\n    def save(self, path, overwrite = False):\n\n        acc = self.accelerator\n\n        acc.wait_for_everyone()\n\n        if not acc.is_main_process:\n            return\n\n        path = Path(path)\n        assert overwrite or not path.exists()\n\n        pkg = dict(\n            actor = self.actor.state_dict(),\n            ema_actor = self.ema_actor.state_dict() if self.use_ema else None,\n            state_norm = self.state_norm.state_dict() if self.use_state_norm else None,\n            latents = self.gene_pool.state_dict() if exists(self.gene_pool) else None,\n            step = self.step\n        )\n\n        torch.save(pkg, str(path))\n\n    def load(self, path):\n        path = Path(path)\n\n        assert path.exists()\n\n        pkg = torch.load(str(path), weights_only = True)\n\n        self.actor.load_state_dict(pkg['actor'])\n\n        if exists(self.gene_pool):\n            self.gene_pool.load_state_dict(pkg['latents'])\n\n        if self.use_ema:\n            assert 'ema_actor' in pkg\n            self.ema_actor.load_state_dict(pkg['ema_actor'])\n\n        if self.use_state_norm:\n            assert 'state_norm' in pkg\n            self.state_norm.load_state_dict(pkg['state_norm'])","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.load","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.load#L746-L766","kind":"function","name":"load","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":746,"end_line":766,"context_start_line":726,"context_end_line":786,"code":"        acc = self.accelerator\n\n        acc.wait_for_everyone()\n\n        if not acc.is_main_process:\n            return\n\n        path = Path(path)\n        assert overwrite or not path.exists()\n\n        pkg = dict(\n            actor = self.actor.state_dict(),\n            ema_actor = self.ema_actor.state_dict() if self.use_ema else None,\n            state_norm = self.state_norm.state_dict() if self.use_state_norm else None,\n            latents = self.gene_pool.state_dict() if exists(self.gene_pool) else None,\n            step = self.step\n        )\n\n        torch.save(pkg, str(path))\n\n    def load(self, path):\n        path = Path(path)\n\n        assert path.exists()\n\n        pkg = torch.load(str(path), weights_only = True)\n\n        self.actor.load_state_dict(pkg['actor'])\n\n        if exists(self.gene_pool):\n            self.gene_pool.load_state_dict(pkg['latents'])\n\n        if self.use_ema:\n            assert 'ema_actor' in pkg\n            self.ema_actor.load_state_dict(pkg['ema_actor'])\n\n        if self.use_state_norm:\n            assert 'state_norm' in pkg\n            self.state_norm.load_state_dict(pkg['state_norm'])\n\n        self.step.copy_(pkg['step'])\n\n    def return_wrapped_actor(self) -> ActorWrapper | Module:\n\n        if not (self.use_state_norm or self.actor_accepts_latents):\n            return self.actor\n\n        wrapped_actor = ActorWrapper(\n            self.actor,\n            state_norm = self.state_norm if self.use_state_norm else None,\n            latent_gene_pool = self.gene_pool if self.actor_accepts_latents else None,\n        )\n\n        return wrapped_actor\n\n    @torch.inference_mode()\n    def forward(\n        self,\n        maybe_envs,\n        num_env_interactions = None,\n        show_progress = None,","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.return_wrapped_actor","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.return_wrapped_actor#L768-L779","kind":"function","name":"return_wrapped_actor","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":768,"end_line":779,"context_start_line":748,"context_end_line":799,"code":"\n        assert path.exists()\n\n        pkg = torch.load(str(path), weights_only = True)\n\n        self.actor.load_state_dict(pkg['actor'])\n\n        if exists(self.gene_pool):\n            self.gene_pool.load_state_dict(pkg['latents'])\n\n        if self.use_ema:\n            assert 'ema_actor' in pkg\n            self.ema_actor.load_state_dict(pkg['ema_actor'])\n\n        if self.use_state_norm:\n            assert 'state_norm' in pkg\n            self.state_norm.load_state_dict(pkg['state_norm'])\n\n        self.step.copy_(pkg['step'])\n\n    def return_wrapped_actor(self) -> ActorWrapper | Module:\n\n        if not (self.use_state_norm or self.actor_accepts_latents):\n            return self.actor\n\n        wrapped_actor = ActorWrapper(\n            self.actor,\n            state_norm = self.state_norm if self.use_state_norm else None,\n            latent_gene_pool = self.gene_pool if self.actor_accepts_latents else None,\n        )\n\n        return wrapped_actor\n\n    @torch.inference_mode()\n    def forward(\n        self,\n        maybe_envs,\n        num_env_interactions = None,\n        show_progress = None,\n        seed = None,\n        max_timesteps_per_interaction = None,\n    ):\n        max_timesteps_per_interaction = default(max_timesteps_per_interaction, self.max_timesteps)\n        show_progress = default(show_progress, self.show_progress)\n        num_env_interactions = default(num_env_interactions, self.num_env_interactions)\n\n        (\n            learning_rate,\n            num_selected,\n            noise_pop_size,\n            num_rollout_repeats,\n            factorized_noise,","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.default_calc_fitness","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.default_calc_fitness#L632-L633","kind":"function","name":"default_calc_fitness","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":632,"end_line":633,"context_start_line":612,"context_end_line":653,"code":"\n        self.max_timesteps = max_timesteps\n\n        # gene pool, another axis for scaling and bitter lesson\n\n        num_genes = 1\n        gene_pool = None\n\n        if isinstance(latent_gene_pool, dict):\n            gene_pool = LatentGenePool(**latent_gene_pool)\n            gene_pool.to(device)\n\n            num_genes = gene_pool.num_genes\n\n        self.actor_accepts_latents = exists(gene_pool)\n        self.concat_latent_to_state = concat_latent_to_state\n\n        self.gene_pool = gene_pool\n        self.num_genes = num_genes\n\n        def default_calc_fitness(reward_stats):\n            return reduce(reward_stats[:, 0], 'g s e -> g', 'mean')\n\n        self.calc_fitness = default(calc_fitness, default_calc_fitness)\n\n        self.crossover_every_step = crossover_every_step\n        self.crossover_after_step = crossover_after_step\n\n        # whether to do heritable mutations to the latent genes\n\n        self.mutate_latent_genes = mutate_latent_genes\n\n        self.latent_gene_noise_std_dev = latent_gene_noise_std_dev\n\n        # optim\n\n        optim_params = [named_params[param_name] for param_name in self.param_names]\n\n        self.optim = optim_klass(optim_params, lr = learning_rate, betas = betas, **optim_kwargs)\n\n        self.learning_rate = learning_rate\n        self.weight_decay = weight_decay","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.hook","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.hook#L658-L659","kind":"function","name":"hook","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":658,"end_line":659,"context_start_line":638,"context_end_line":679,"code":"        self.crossover_after_step = crossover_after_step\n\n        # whether to do heritable mutations to the latent genes\n\n        self.mutate_latent_genes = mutate_latent_genes\n\n        self.latent_gene_noise_std_dev = latent_gene_noise_std_dev\n\n        # optim\n\n        optim_params = [named_params[param_name] for param_name in self.param_names]\n\n        self.optim = optim_klass(optim_params, lr = learning_rate, betas = betas, **optim_kwargs)\n\n        self.learning_rate = learning_rate\n        self.weight_decay = weight_decay\n\n        # hooks\n\n        if exists(optim_step_post_hook):\n            def hook(*_):\n                optim_step_post_hook()\n\n            self.optim.register_step_post_hook(hook)\n\n        # maybe state norm\n\n        if isinstance(state_norm, dict):\n            state_norm = StateNorm(**state_norm)\n\n        self.use_state_norm = exists(state_norm)\n\n        if self.use_state_norm:\n            self.state_norm = state_norm\n            state_norm.to(device)\n\n        # progress bar\n\n        self.show_progress = show_progress\n\n        # number of interactions with environment for learning\n","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:blackbox_gradient_sensing.bgs.calculate_weights","uri":"program://blackbox-gradient-sensing/function/blackbox_gradient_sensing.bgs.calculate_weights#L1096-L1115","kind":"function","name":"calculate_weights","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":1096,"end_line":1115,"context_start_line":1076,"context_end_line":1135,"code":"\n            # mask out any noise candidates whose max reward mean is greater than baseline\n\n            reward_threshold_accept = baseline_mean - reward_std * self.num_std_below_mean_thres_accept\n\n            max_reward_mean = torch.amax(reward_mean, dim = -1)\n\n            accept_mask = einx.greater_equal('g n, g -> g n', max_reward_mean, reward_threshold_accept)\n            accept_mask = reduce(accept_mask.float(), 'g n -> n', 'mean') >= self.frac_genes_pass_thres_accept\n\n            reward_deltas = einx.multiply('g n, n', reward_deltas, accept_mask.float()) # just zero out the reward deltas that do not pass the threshold\n\n            # progress bar\n\n            pbar_descriptions = [\n                f'rewards: {baseline_mean.mean().item():.2f}',\n                f'best: {reward_mean.amax().item():.2f}',\n                f'accepted: {accept_mask.sum().item()} / {noise_pop_size}'\n            ]\n\n            def calculate_weights(reward_deltas, log = True):\n\n                # get the top performing noise indices\n\n                k = min(num_selected, reward_deltas.numel() // 2)\n\n                ranked_reward_deltas, ranked_reward_indices = reward_deltas.abs().topk(k, dim = -1)\n\n                # get the weights for the weighted sum of the topk noise according to eq (3)\n\n                weights = ranked_reward_deltas / reward_std.clamp(min = 1e-3)\n\n                # multiply by sign\n\n                weights *= torch.sign(reward_deltas.gather(-1, ranked_reward_indices))\n\n                if log:\n                    pbar_descriptions.append(f'best delta: {ranked_reward_deltas.amax().item():.2f}')\n\n                return weights, ranked_reward_indices\n\n            # get the weights for update\n\n            (\n                weights,\n                ranked_reward_indices,\n            ) = calculate_weights(reduce(reward_deltas, 'g n -> n', 'mean'))\n\n            # update the param one by one\n\n            for name, noise in noises.items():\n\n                param = params[name]\n\n                # add the best \"elite\" noise directions weighted by eq (3)\n\n                best_noises = noise[1:][ranked_reward_indices]\n\n                update = einsum(best_noises, weights, 'n ..., n -> ...')\n","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:tests.test_bgs","uri":"program://blackbox-gradient-sensing/module/tests.test_bgs#L1-L138","kind":"module","name":"tests.test_bgs","path":"tests/test_bgs.py","language":"python","start_line":1,"end_line":138,"context_start_line":1,"context_end_line":138,"code":"from __future__ import annotations\n\nimport pytest\n\nimport torch\nfrom torch import nn\n\nfrom blackbox_gradient_sensing.bgs import (\n    BlackboxGradientSensing,\n    Actor,\n    LatentGenePool\n)\n\n# mock env\n\nimport numpy as np\n\nclass Sim:\n    def reset(self, seed = None):\n        return np.random.randn(5) # state\n\n    def step(self, actions):\n        return np.random.randn(5), np.random.randn(1), False # state, reward, done\n\n# test BGS\n\n@pytest.mark.parametrize('factorized_noise', (True, False))\n@pytest.mark.parametrize('use_custom_actor', (True, False))\n@pytest.mark.parametrize('use_state_norm', (True, False))\n@pytest.mark.parametrize('actor_is_recurrent', (True, False))\n@pytest.mark.parametrize('use_genetic_algorithm', (True, False))\n@pytest.mark.parametrize('num_islands', (1, 2))\n@pytest.mark.parametrize('mutate_latent_genes', (True, False))\n@pytest.mark.parametrize('optimize_partial_network', (True, False))\n@pytest.mark.parametrize('use_ema', (True, False))\n@pytest.mark.parametrize('continuous', (True, False))\ndef test_bgs(\n    factorized_noise,\n    use_custom_actor,\n    use_state_norm,\n    actor_is_recurrent,\n    use_genetic_algorithm,\n    num_islands,\n    mutate_latent_genes,\n    optimize_partial_network,\n    use_ema,\n    continuous\n):\n\n    sim = Sim()\n\n    actor = Actor(\n        dim_state = 5,\n        num_actions = 2,\n        dim_latent = 32,\n        continuous = continuous,\n        accepts_latent = use_genetic_algorithm\n    ) # actor with weight norm\n\n    # test custom actor\n\n    if use_custom_actor:\n        actor = nn.Linear(5, 2)\n\n        if (\n            actor_is_recurrent or\n            use_genetic_algorithm or\n            optimize_partial_network or\n            continuous\n        ):\n            pytest.skip()\n\n    # maybe state norm\n\n    state_norm = None\n\n    if use_state_norm:\n        state_norm = dict(dim_state = 5)\n\n    # maybe genetic algorithm\n\n    latent_gene_pool = None\n\n    if use_genetic_algorithm:\n        latent_gene_pool = dict(\n            dim = 32,\n            num_genes_per_island = 3,\n            num_islands = num_islands,\n            migrate_genes_every = 1,\n            num_selected = 2,\n            tournament_size = 2\n        )\n\n    # main evo strat orchestrator\n\n    bgs = BlackboxGradientSensing(\n        actor = actor,\n        noise_pop_size = 2,      # number of noise perturbations\n        num_selected = 1,         # topk noise selected for update\n        num_rollout_repeats = 1,   # how many times to redo environment rollout, per noise\n        torch_compile_actor = False,\n        max_timesteps = 1,\n        mutate_latent_genes = mutate_latent_genes,\n        factorized_noise = factorized_noise,\n        state_norm = state_norm,\n        actor_is_recurrent = actor_is_recurrent,\n        latent_gene_pool = latent_gene_pool,\n        modules_to_optimize = {'to_embed'} if optimize_partial_network else None,\n        cpu = True,\n        use_ema = use_ema\n    )\n\n    bgs(sim, 2) # pass the simulation environment in - say for 100 interactions with env\n\n    # after much training, save your learned policy (and optional state normalization) for finetuning on real env\n\n    bgs.save('./actor-and-state-norm.pt', overwrite = True)\n\n    bgs.load('./actor-and-state-norm.pt')\n\n# test genetic algorithm\n\n@pytest.mark.parametrize('num_islands', (1, 4))\ndef test_cross_over(\n    num_islands\n):\n    gene_pool = LatentGenePool(\n        dim = 32,\n        num_genes_per_island = 3,\n        num_islands = num_islands,\n        migrate_genes_every = 1,\n        num_selected = 2,\n        tournament_size = 2\n    )\n\n    fitness = torch.randn(3 * num_islands)\n\n    gene_pool.evolve(fitness)","source_hash":"b299f38191e0a4bbb61a94a1c9107f804e31ddc598c8c56901d2255f4272978c","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:tests.test_bgs.Sim","uri":"program://blackbox-gradient-sensing/class/tests.test_bgs.Sim#L18-L23","kind":"class","name":"Sim","path":"tests/test_bgs.py","language":"python","start_line":18,"end_line":23,"context_start_line":1,"context_end_line":43,"code":"from __future__ import annotations\n\nimport pytest\n\nimport torch\nfrom torch import nn\n\nfrom blackbox_gradient_sensing.bgs import (\n    BlackboxGradientSensing,\n    Actor,\n    LatentGenePool\n)\n\n# mock env\n\nimport numpy as np\n\nclass Sim:\n    def reset(self, seed = None):\n        return np.random.randn(5) # state\n\n    def step(self, actions):\n        return np.random.randn(5), np.random.randn(1), False # state, reward, done\n\n# test BGS\n\n@pytest.mark.parametrize('factorized_noise', (True, False))\n@pytest.mark.parametrize('use_custom_actor', (True, False))\n@pytest.mark.parametrize('use_state_norm', (True, False))\n@pytest.mark.parametrize('actor_is_recurrent', (True, False))\n@pytest.mark.parametrize('use_genetic_algorithm', (True, False))\n@pytest.mark.parametrize('num_islands', (1, 2))\n@pytest.mark.parametrize('mutate_latent_genes', (True, False))\n@pytest.mark.parametrize('optimize_partial_network', (True, False))\n@pytest.mark.parametrize('use_ema', (True, False))\n@pytest.mark.parametrize('continuous', (True, False))\ndef test_bgs(\n    factorized_noise,\n    use_custom_actor,\n    use_state_norm,\n    actor_is_recurrent,\n    use_genetic_algorithm,\n    num_islands,","source_hash":"b299f38191e0a4bbb61a94a1c9107f804e31ddc598c8c56901d2255f4272978c","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:tests.test_bgs.test_bgs","uri":"program://blackbox-gradient-sensing/function/tests.test_bgs.test_bgs#L37-L119","kind":"function","name":"test_bgs","path":"tests/test_bgs.py","language":"python","start_line":37,"end_line":119,"context_start_line":17,"context_end_line":138,"code":"\nclass Sim:\n    def reset(self, seed = None):\n        return np.random.randn(5) # state\n\n    def step(self, actions):\n        return np.random.randn(5), np.random.randn(1), False # state, reward, done\n\n# test BGS\n\n@pytest.mark.parametrize('factorized_noise', (True, False))\n@pytest.mark.parametrize('use_custom_actor', (True, False))\n@pytest.mark.parametrize('use_state_norm', (True, False))\n@pytest.mark.parametrize('actor_is_recurrent', (True, False))\n@pytest.mark.parametrize('use_genetic_algorithm', (True, False))\n@pytest.mark.parametrize('num_islands', (1, 2))\n@pytest.mark.parametrize('mutate_latent_genes', (True, False))\n@pytest.mark.parametrize('optimize_partial_network', (True, False))\n@pytest.mark.parametrize('use_ema', (True, False))\n@pytest.mark.parametrize('continuous', (True, False))\ndef test_bgs(\n    factorized_noise,\n    use_custom_actor,\n    use_state_norm,\n    actor_is_recurrent,\n    use_genetic_algorithm,\n    num_islands,\n    mutate_latent_genes,\n    optimize_partial_network,\n    use_ema,\n    continuous\n):\n\n    sim = Sim()\n\n    actor = Actor(\n        dim_state = 5,\n        num_actions = 2,\n        dim_latent = 32,\n        continuous = continuous,\n        accepts_latent = use_genetic_algorithm\n    ) # actor with weight norm\n\n    # test custom actor\n\n    if use_custom_actor:\n        actor = nn.Linear(5, 2)\n\n        if (\n            actor_is_recurrent or\n            use_genetic_algorithm or\n            optimize_partial_network or\n            continuous\n        ):\n            pytest.skip()\n\n    # maybe state norm\n\n    state_norm = None\n\n    if use_state_norm:\n        state_norm = dict(dim_state = 5)\n\n    # maybe genetic algorithm\n\n    latent_gene_pool = None\n\n    if use_genetic_algorithm:\n        latent_gene_pool = dict(\n            dim = 32,\n            num_genes_per_island = 3,\n            num_islands = num_islands,\n            migrate_genes_every = 1,\n            num_selected = 2,\n            tournament_size = 2\n        )\n\n    # main evo strat orchestrator\n\n    bgs = BlackboxGradientSensing(\n        actor = actor,\n        noise_pop_size = 2,      # number of noise perturbations\n        num_selected = 1,         # topk noise selected for update\n        num_rollout_repeats = 1,   # how many times to redo environment rollout, per noise\n        torch_compile_actor = False,\n        max_timesteps = 1,\n        mutate_latent_genes = mutate_latent_genes,\n        factorized_noise = factorized_noise,\n        state_norm = state_norm,\n        actor_is_recurrent = actor_is_recurrent,\n        latent_gene_pool = latent_gene_pool,\n        modules_to_optimize = {'to_embed'} if optimize_partial_network else None,\n        cpu = True,\n        use_ema = use_ema\n    )\n\n    bgs(sim, 2) # pass the simulation environment in - say for 100 interactions with env\n\n    # after much training, save your learned policy (and optional state normalization) for finetuning on real env\n\n    bgs.save('./actor-and-state-norm.pt', overwrite = True)\n\n    bgs.load('./actor-and-state-norm.pt')\n\n# test genetic algorithm\n\n@pytest.mark.parametrize('num_islands', (1, 4))\ndef test_cross_over(\n    num_islands\n):\n    gene_pool = LatentGenePool(\n        dim = 32,\n        num_genes_per_island = 3,\n        num_islands = num_islands,\n        migrate_genes_every = 1,\n        num_selected = 2,\n        tournament_size = 2\n    )\n\n    fitness = torch.randn(3 * num_islands)\n\n    gene_pool.evolve(fitness)","source_hash":"b299f38191e0a4bbb61a94a1c9107f804e31ddc598c8c56901d2255f4272978c","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:tests.test_bgs.test_cross_over","uri":"program://blackbox-gradient-sensing/function/tests.test_bgs.test_cross_over#L124-L138","kind":"function","name":"test_cross_over","path":"tests/test_bgs.py","language":"python","start_line":124,"end_line":138,"context_start_line":104,"context_end_line":138,"code":"        factorized_noise = factorized_noise,\n        state_norm = state_norm,\n        actor_is_recurrent = actor_is_recurrent,\n        latent_gene_pool = latent_gene_pool,\n        modules_to_optimize = {'to_embed'} if optimize_partial_network else None,\n        cpu = True,\n        use_ema = use_ema\n    )\n\n    bgs(sim, 2) # pass the simulation environment in - say for 100 interactions with env\n\n    # after much training, save your learned policy (and optional state normalization) for finetuning on real env\n\n    bgs.save('./actor-and-state-norm.pt', overwrite = True)\n\n    bgs.load('./actor-and-state-norm.pt')\n\n# test genetic algorithm\n\n@pytest.mark.parametrize('num_islands', (1, 4))\ndef test_cross_over(\n    num_islands\n):\n    gene_pool = LatentGenePool(\n        dim = 32,\n        num_genes_per_island = 3,\n        num_islands = num_islands,\n        migrate_genes_every = 1,\n        num_selected = 2,\n        tournament_size = 2\n    )\n\n    fitness = torch.randn(3 * num_islands)\n\n    gene_pool.evolve(fitness)","source_hash":"b299f38191e0a4bbb61a94a1c9107f804e31ddc598c8c56901d2255f4272978c","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:tests.test_bgs.reset","uri":"program://blackbox-gradient-sensing/function/tests.test_bgs.reset#L19-L20","kind":"function","name":"reset","path":"tests/test_bgs.py","language":"python","start_line":19,"end_line":20,"context_start_line":1,"context_end_line":40,"code":"from __future__ import annotations\n\nimport pytest\n\nimport torch\nfrom torch import nn\n\nfrom blackbox_gradient_sensing.bgs import (\n    BlackboxGradientSensing,\n    Actor,\n    LatentGenePool\n)\n\n# mock env\n\nimport numpy as np\n\nclass Sim:\n    def reset(self, seed = None):\n        return np.random.randn(5) # state\n\n    def step(self, actions):\n        return np.random.randn(5), np.random.randn(1), False # state, reward, done\n\n# test BGS\n\n@pytest.mark.parametrize('factorized_noise', (True, False))\n@pytest.mark.parametrize('use_custom_actor', (True, False))\n@pytest.mark.parametrize('use_state_norm', (True, False))\n@pytest.mark.parametrize('actor_is_recurrent', (True, False))\n@pytest.mark.parametrize('use_genetic_algorithm', (True, False))\n@pytest.mark.parametrize('num_islands', (1, 2))\n@pytest.mark.parametrize('mutate_latent_genes', (True, False))\n@pytest.mark.parametrize('optimize_partial_network', (True, False))\n@pytest.mark.parametrize('use_ema', (True, False))\n@pytest.mark.parametrize('continuous', (True, False))\ndef test_bgs(\n    factorized_noise,\n    use_custom_actor,\n    use_state_norm,","source_hash":"b299f38191e0a4bbb61a94a1c9107f804e31ddc598c8c56901d2255f4272978c","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"py:tests.test_bgs.step","uri":"program://blackbox-gradient-sensing/function/tests.test_bgs.step#L22-L23","kind":"function","name":"step","path":"tests/test_bgs.py","language":"python","start_line":22,"end_line":23,"context_start_line":2,"context_end_line":43,"code":"\nimport pytest\n\nimport torch\nfrom torch import nn\n\nfrom blackbox_gradient_sensing.bgs import (\n    BlackboxGradientSensing,\n    Actor,\n    LatentGenePool\n)\n\n# mock env\n\nimport numpy as np\n\nclass Sim:\n    def reset(self, seed = None):\n        return np.random.randn(5) # state\n\n    def step(self, actions):\n        return np.random.randn(5), np.random.randn(1), False # state, reward, done\n\n# test BGS\n\n@pytest.mark.parametrize('factorized_noise', (True, False))\n@pytest.mark.parametrize('use_custom_actor', (True, False))\n@pytest.mark.parametrize('use_state_norm', (True, False))\n@pytest.mark.parametrize('actor_is_recurrent', (True, False))\n@pytest.mark.parametrize('use_genetic_algorithm', (True, False))\n@pytest.mark.parametrize('num_islands', (1, 2))\n@pytest.mark.parametrize('mutate_latent_genes', (True, False))\n@pytest.mark.parametrize('optimize_partial_network', (True, False))\n@pytest.mark.parametrize('use_ema', (True, False))\n@pytest.mark.parametrize('continuous', (True, False))\ndef test_bgs(\n    factorized_noise,\n    use_custom_actor,\n    use_state_norm,\n    actor_is_recurrent,\n    use_genetic_algorithm,\n    num_islands,","source_hash":"b299f38191e0a4bbb61a94a1c9107f804e31ddc598c8c56901d2255f4272978c","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"file:train.py","uri":"program://blackbox-gradient-sensing/file/train.py","kind":"file","name":"train.py","path":"train.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from adam_atan2_pytorch import AdoptAtan2\nfrom blackbox_gradient_sensing import BlackboxGradientSensing, Actor\n\n# sim environment, example using gymansium\n\nimport gymnasium as gym\n\ncontinuous = True\n\nsim = gym.make(\n    'LunarLander-v3',\n    render_mode = 'rgb_array',\n    continuous = continuous\n)\n\ndim_state = sim.observation_space.shape[0]\n\n# hyperparams\n\nnum_noises = 100      # number of noise perturbations, from which top is chosen for a weighted update - in paper this was 200 for sim, 3 for real\nnum_selected = 15     # number of elite perturbations chosen","source_hash":"048fadfa9432532ea46961e6d6ba080276229eb36660f33b0db333a9b2e8028e","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"file:blackbox_gradient_sensing/bgs.py","uri":"program://blackbox-gradient-sensing/file/blackbox_gradient_sensing/bgs.py","kind":"file","name":"blackbox_gradient_sensing/bgs.py","path":"blackbox_gradient_sensing/bgs.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\n\nimport random\nfrom random import randrange, choice\n\nfrom math import sqrt\nfrom copy import deepcopy\nfrom functools import partial\nfrom pathlib import Path\nfrom typing import Callable\n\nimport numpy as np\n\nimport torch\nfrom torch import cat, stack, nn, tensor, Tensor\nimport torch.nn.functional as F\nfrom torch.nn import Module, ModuleList, Parameter\nfrom torch.optim import Adam\nfrom torch.func import functional_call\n\nimport torch.distributed as dist","source_hash":"c37bc6a7122902a6ff126f61ecbba68c8423de36666998d867d765263aa1721a","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"file:blackbox_gradient_sensing/__init__.py","uri":"program://blackbox-gradient-sensing/file/blackbox_gradient_sensing/__init__.py","kind":"file","name":"blackbox_gradient_sensing/__init__.py","path":"blackbox_gradient_sensing/__init__.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":6,"code":"from blackbox_gradient_sensing.bgs import (\n    BlackboxGradientSensing,\n    Actor,\n    StateNorm,\n    LatentGenePool\n)","source_hash":"22b97bb55be0e3f133a42b50360d59edf84490a56b73216cb1e08e5cb4d000c5","truncated":false}
{"repo_id":"blackbox-gradient-sensing","entity_id":"file:tests/test_bgs.py","uri":"program://blackbox-gradient-sensing/file/tests/test_bgs.py","kind":"file","name":"tests/test_bgs.py","path":"tests/test_bgs.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"from __future__ import annotations\n\nimport pytest\n\nimport torch\nfrom torch import nn\n\nfrom blackbox_gradient_sensing.bgs import (\n    BlackboxGradientSensing,\n    Actor,\n    LatentGenePool\n)\n\n# mock env\n\nimport numpy as np\n\nclass Sim:\n    def reset(self, seed = None):\n        return np.random.randn(5) # state\n","source_hash":"b299f38191e0a4bbb61a94a1c9107f804e31ddc598c8c56901d2255f4272978c","truncated":false}