SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 1706.02275 · 2017

Multi-Agent Actor-Critic for Mixed Cooperative-Competitive Environments

Ryan Lowe, Pieter Abbeel, Yi Wu, Aviv Tamar, Jean Harb, Igor Openai

arXiv · PDF · Open in the Atlas

Code that ran

75 of 143 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (54 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 0 violated it and 66 have no contract verdict; 7 failures of our instrument; 68 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/1706.02275.json · badge: /api/ran/1706.02275.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning community
Papers with Code archive
8 ran · 3 no recorded run
Chan1998/MAAC community
Papers with Code archive
5 ran · 6 no recorded run
Yutongamber/MADDPG community
Papers with Code archive
5 ran · 3 no recorded run
baoqianwang/iros22_darl1n community
Papers with Code archive
4 ran · 30 no recorded run
MrDaubinet/collaboration-and-competition community
Papers with Code archive
4 ran · 2 no recorded run
krasing/DRLearningCollaboration community
not in the paper's declared repositories
4 ran · 1 no recorded run
petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity community
not in the paper's declared repositories
4 ran · 1 no recorded run
isp1tze/MAProj community
not in the paper's declared repositories
4 ran · 1 no recorded run
baradist/multiagent-particle-envs community
Papers with Code archive
4 ran · 1 no recorded run
zowiezhang/stas community
not in the paper's declared repositories
4 ran · 0 no recorded run
philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients community
not in the paper's declared repositories
4 ran · 0 no recorded run
biemann/Collaboration-and-Competition community
Papers with Code archive
4 ran · 0 no recorded run
rainandwind1/MADDPG-reconstruct community
not in the paper's declared repositories
3 ran · 2 no recorded run
bonniesjli/MADDPG_Tennis_UnityML community
Papers with Code archive
3 ran · 2 no recorded run
thechrisyoon08/marl community
not in the paper's declared repositories
3 ran · 2 no recorded run
xuehy/pytorch-maddpg community
not in the paper's declared repositories
3 ran · 0 no recorded run
morning9393/HAPPO-HATRPO community
not in the paper's declared repositories
3 ran · 0 no recorded run
EyaRhouma/collaboration-competition-MADDPG community
Papers with Code archive
2 ran · 3 no recorded run
starry-sky6688/MADDPG community
not in the paper's declared repositories
2 ran · 1 no recorded run
Ah31/maddpg_pytorch community
Papers with Code archive
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
mauricemager/multiagent-robot community
not in the paper's declared repositories
0 ran · 2 no recorded run
ksajan/DDPG-MAPE community
not in the paper's declared repositories
0 ran · 1 no recorded run
johannesharmse/multi_agent_RL community
not in the paper's declared repositories
0 ran · 1 no recorded run
rainandwind1/Maddpg_multiagent community
not in the paper's declared repositories
0 ran · 1 no recorded run
FunctionStatusWhere it lives
ACTLayer Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("788933ff608baaea")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, ACTLayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import gym
from gym.spaces import Discrete, Box, MultiBinary, MultiDiscrete

torch.manual_seed(0)

# Create a simple Discrete action space
action_space_discrete = Discrete(n=5)

# Create inputs_dim parameter
inputs_dim = 4

# Create use_orthogonal parameter
use_orthogonal = True

# Create gain parameter
gain = 0.01

# Create a simple args object with std_x_coef and std_y_coef attributes
class SimpleArgs:
    def __init__(self):
        self.std_x_coef = 1.0
        self.std_y_coef = 0.5

args = SimpleArgs()

# Define ARGS dictionary with all parameters for ACTLayer
ARGS = {
    'action_space': action_space_discrete,
    'inputs_dim': inputs_dim,
    'use_orthogonal': use_orthogonal,
    'gain': gain,
    'args': args
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
gym, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ACTLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ACTLayer output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Actor Ran
ran on a synthesized input · constructed an object; no result was computed
zowiezhang/stas/models/policy/COMA.py
pointer only (licence: NONE) · get_code("d33580612fa8578d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zowiezhang/stas when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
rainandwind1/MADDPG-reconstruct/MADDPG/model.py
code served (permissive licence) · get_code("394e91b566a8e7eb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Actor: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

# The Actor class expects args to be a tuple/list of (input_size, output_size)
# Based on the __init__ method, it unpacks args into self.input_size and self.output_size
# The forward method takes inputs tensor and passes it through the sequential model

ARGS = {
    "args": (4, 3)  # (input_size=4, output_size=3)
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Actor — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Actor output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Actor Ran
ran on a synthesized input · constructed an object; no result was computed
MrDaubinet/collaboration-and-competition/maddpg.py
pointer only (licence: NONE) · get_code("147d57177bbffdd9")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, MrDaubinet/collaboration-and-competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
starry-sky6688/MADDPG/maddpg/maddpg.py
pointer only (licence: NONE) · get_code("b1b715fc5cea22be")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, starry-sky6688/MADDPG when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
krasing/DRLearningCollaboration/failed_collaborative/ddpg_agent_multi_2.py
pointer only (licence: NONE) · get_code("ab8b87babe2b659e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, krasing/DRLearningCollaboration when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity/multiagent_resources.py
pointer only (licence: NONE) · get_code("a17bd67f978b7355")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
isp1tze/MAProj/algo/maddpg/maddpg_agent.py
pointer only (licence: NONE) · get_code("cbd481c5cf284628")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isp1tze/MAProj when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Actor Ran
ran on a synthesized input · constructed an object; no result was computed
bonniesjli/MADDPG_Tennis_UnityML/MADDPG.py
pointer only (licence: NONE) · get_code("af7b2cc00bcf3971")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, bonniesjli/MADDPG_Tennis_UnityML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Actor Ran
ran on a synthesized input
thechrisyoon08/marl/MADDPG/maddpg.py
code served (permissive licence) · get_code("19cc670e3070c844")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

class Actor(nn.Module):

    def __init__(self, obs_dim, action_dim):
        super(Actor, self).__init__()
        self.obs_dim = obs_dim
        self.action_dim = action_dim
        self.linear1 = nn.Linear(self.obs_dim, 512)
        self.linear2 = nn.Linear(512, 128)
        self.linear3 = nn.Linear(128, self.action_dim)

    def forward(self, obs):
        x = F.relu(self.linear1(obs))
        x = F.relu(self.linear2(x))
        x = torch.tanh(self.linear3(x))
        return x


INIT_ARGS = {
    'obs_dim': 4,
    'action_dim': 3,
}

ARGS = {
    'obs': torch.randn(2, 4),
}

if __name__ == '__main__':
    actor = Actor(**INIT_ARGS)
    output = actor(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Actor Ran
ran on a synthesized input
Ah31/maddpg_pytorch/MADDPG_model.py
code served (permissive licence) · get_code("e0a77db60f82cb02")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

class Actor(nn.Module):

    def __init__(self, state_size, action_size, seed, fc1_units=64, fc2_units=64):
        """Initialize parameters and build model.
        Params
        ======
            state_size (int): Dimension of each state
            action_size (int): Dimension of each action
            seed (int): Random seed
            fc1_units (int): Number of nodes in first hidden layer
            fc2_units (int): Number of nodes in second hidden layer
        """
        super(Actor, self).__init__()
        self.seed = torch.manual_seed(seed)
        self.fc1 = nn.Linear(out_features=fc1_units, in_features=state_size)
        self.fc2 = nn.Linear(out_features=fc2_units, in_features=fc1_units)
        self.fc3 = nn.Linear(out_features=action_size, in_features=fc2_units)

    def forward(self, state):
        """Build an actor (policy) network that maps states -> actions."""
        x = F.relu(self.fc1(state))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x


INIT_ARGS = {
    'state_size': 4,
    'action_size': 3,
    'seed': 42,
    'fc1_units': 8,
    'fc2_units': 6,
}

ARGS = {
    'state': torch.randn(2, 4),
}

if __name__ == '__main__':
    actor = Actor(**INIT_ARGS)
    output = actor(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
ActorModel Ran
ran on a synthesized input
EyaRhouma/collaboration-competition-MADDPG/MADDPG_agent.py
pointer only (licence: NONE) · get_code("7153bd2279c31cfb")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, EyaRhouma/collaboration-competition-MADDPG when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ActorNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
baradist/multiagent-particle-envs/multiagent/ddpg/ddpg_agent.py
code served (permissive licence) · get_code("5d2b3c4f1fd1a9f4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, ActorNetwork: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import numpy as np
import torch as T
import torch.nn as nn

T.manual_seed(0)

ARGS = {
    'alpha': 0.0003,
    'input_dims': (4,),
    'fc1_dims': 8,
    'fc2_dims': 6,
    'n_actions': 2,
    'name': 'actor_test',
    'chkpt_dir': 'tmp'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ActorNetwork — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ActorNetwork output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ActorNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients/maddpg.py
pointer only (licence: NONE) · get_code("19dd2e9c270f0dc6")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Agent Ran
ran on a synthesized input · constructed an object; no result was computed
philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients/maddpg.py
pointer only (licence: NONE) · get_code("6e3b52a2c0014b70")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

AttentionCritic Ran
ran on a synthesized input · constructed an object; no result was computed
Chan1998/MAAC/algorithms/attention_sac.py
pointer only (licence: NOASSERTION) · get_code("23a16fcf13d93070")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Chan1998/MAAC (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

BasePolicy Ran
ran on a synthesized input · constructed an object; no result was computed
Chan1998/MAAC/algorithms/attention_sac.py
pointer only (licence: NOASSERTION) · get_code("e3579cc107de4c0a")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Chan1998/MAAC (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Bernoulli Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("ce4cd71349aedb12")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Bernoulli: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "num_inputs": 4,
    "num_outputs": 3,
    "use_orthogonal": True,
    "gain": 0.01,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Bernoulli — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Bernoulli output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
COMA Ran
ran on a synthesized input · constructed an object; no result was computed
zowiezhang/stas/models/policy/COMA.py
pointer only (licence: NONE) · get_code("e6b6fc2b3a05ee48")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zowiezhang/stas when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

CentralizedCritic Ran
ran on a synthesized input
thechrisyoon08/marl/MADDPG/maddpg.py
code served (permissive licence) · get_code("5809fd7ddfdc55c2")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float, shape (2, 1) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

class CentralizedCritic(nn.Module):

    def __init__(self, obs_dim, action_dim):
        super(CentralizedCritic, self).__init__()
        self.obs_dim = obs_dim
        self.action_dim = action_dim
        self.linear1 = nn.Linear(self.obs_dim, 1024)
        self.linear2 = nn.Linear(1024 + self.action_dim, 512)
        self.linear3 = nn.Linear(512, 300)
        self.linear4 = nn.Linear(300, 1)

    def forward(self, x, a):
        x = F.relu(self.linear1(x))
        xa_cat = torch.cat([x, a], 1)
        xa = F.relu(self.linear2(xa_cat))
        xa = F.relu(self.linear3(xa))
        qval = self.linear4(xa)
        return qval


INIT_ARGS = {
    'obs_dim': 4,
    'action_dim': 3,
}

ARGS = {
    'x': torch.randn(2, 4),
    'a': torch.randn(2, 3),
}

if __name__ == '__main__':
    critic = CentralizedCritic(**INIT_ARGS)
    output = critic(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 1) — shape (2, 1) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Critic Ran
ran on a synthesized input · constructed an object; no result was computed
zowiezhang/stas/models/policy/COMA.py
pointer only (licence: NONE) · get_code("6879c98b93ce7112")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zowiezhang/stas when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
rainandwind1/MADDPG-reconstruct/MADDPG/model.py
code served (permissive licence) · get_code("30449e98cba1cf61")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, Critic: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
from torch import nn

torch.manual_seed(0)

# The Critic class expects args to be a tuple/list of (input_size, output_size)
# Looking at the forward method, it takes inputs (a tensor) and passes through the network
# The network expects input_size features and outputs 1 value

input_size = 4
output_size = 1

args = (input_size, output_size)

ARGS = {
    'args': args
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Critic — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a Critic output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
Critic Ran
ran on a synthesized input · constructed an object; no result was computed
MrDaubinet/collaboration-and-competition/maddpg.py
pointer only (licence: NONE) · get_code("6c1f59af0972c70e")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, MrDaubinet/collaboration-and-competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
starry-sky6688/MADDPG/maddpg/maddpg.py
pointer only (licence: NONE) · get_code("601cec5195b4709d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, starry-sky6688/MADDPG when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
krasing/DRLearningCollaboration/failed_collaborative/ddpg_agent_multi_2.py
pointer only (licence: NONE) · get_code("9af882c88cb87dda")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, krasing/DRLearningCollaboration when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity/multiagent_resources.py
pointer only (licence: NONE) · get_code("6d943b1d04649de3")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
isp1tze/MAProj/algo/maddpg/maddpg_agent.py
pointer only (licence: NONE) · get_code("0d8d2fce5fa8c834")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isp1tze/MAProj when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
xuehy/pytorch-maddpg/MADDPG.py
pointer only (licence: NONE) · get_code("a7f0fe3c4dffccc9")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, xuehy/pytorch-maddpg when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Critic Ran
ran on a synthesized input · constructed an object; no result was computed
bonniesjli/MADDPG_Tennis_UnityML/MADDPG.py
pointer only (licence: NONE) · get_code("b89abb00e73f1560")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, bonniesjli/MADDPG_Tennis_UnityML when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

CriticModel Ran
ran on a synthesized input
EyaRhouma/collaboration-competition-MADDPG/MADDPG_agent.py
pointer only (licence: NONE) · get_code("1e89d38fb0c5b84b")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, EyaRhouma/collaboration-competition-MADDPG when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

CriticNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
baradist/multiagent-particle-envs/multiagent/ddpg/ddpg_agent.py
code served (permissive licence) · get_code("619856d2049bc612")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, CriticNetwork: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import os
import numpy as np
import torch as T
import torch.nn as nn
import torch.optim as optim

T.manual_seed(0)

ARGS = {
    'beta': 0.001,
    'input_dims': (4,),
    'fc1_dims': 8,
    'fc2_dims': 6,
    'n_actions': 3,
    'name': 'critic_test',
    'chkpt_dir': 'tmp'
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type CriticNetwork — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a CriticNetwork output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
CriticNetwork Ran
ran on a synthesized input · constructed an object; no result was computed
philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients/maddpg.py
pointer only (licence: NONE) · get_code("1a6507f0b27d66e3")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DDPGAgent Ran
ran on a synthesized input · constructed an object; no result was computed
biemann/Collaboration-and-Competition/maddpg.py
pointer only (licence: NONE) · get_code("bbf8b2fce98ed3c3")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, biemann/Collaboration-and-Competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

DDPGAgent Ran
ran on a synthesized input
thechrisyoon08/marl/MADDPG/maddpg.py
code served (permissive licence) · get_code("4471e9be4006d33f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned NoneType. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np
import torch.nn as nn
import torch.optim as optim
import torch.autograd as autograd
import torch.nn.functional as F
from torch.autograd import Variable

# Mock environment class
class MockEnv:
    def __init__(self):
        self.n = 3  # 3 agents
        
        # Mock observation spaces
        class MockObsSpace:
            def __init__(self, shape):
                self.shape = shape
        
        self.observation_space = [
            MockObsSpace((5,)),  # agent 0: obs_dim=5
            MockObsSpace((6,)),  # agent 1: obs_dim=6
            MockObsSpace((7,))   # agent 2: obs_dim=7
        ]
        
        # Mock action spaces
        class MockActionSpace:
            def __init__(self, n):
                self.n = n
        
        self.action_space = [
            MockActionSpace(4),  # agent 0: 4 actions
            MockActionSpace(4),  # agent 1: 4 actions
            MockActionSpace(4)   # agent 2: 4 actions
        ]

env = MockEnv()
agent_id = 1

INIT_ARGS = {
    'env': env,
    'agent_id': agent_id,
    'actor_lr': 0.0001,
    'critic_lr': 0.001,
    'gamma': 0.99,
    'tau': 0.01
}

# For agent_id=1:
# - obs_dim = 6
# - action_dim = 4
# - num_agents = 3
# - critic_input_dim = 5 + 6 + 7 = 18
# - total actions = 4 * 3 = 12

batch_size = 2

# Individual agent observations (agent 1 only)
indiv_obs_batch = np.random.randn(batch_size, 6).astype(np.float32)

# Individual agent rewards (agent 1 only)
indiv_reward_batch = np.random.randn(batch_size).astype(np.float32)

# Global state: concatenated observations of all agents
global_state_batch = np.random.randn(batch_size, 18).astype(np.float32)

# Global next state: concatenated observations of all agents
global_next_state_batch = np.random.randn(batch_size, 18).astype(np.float32)

# Global actions: concatenated actions of all agents (one-hot or continuous)
# Total action dim = 4 * 3 = 12
global_actions_batch = [torch.randn(12) for _ in range(batch_size)]

# Next global actions: concatenated next actions of all agents
next_global_actions = torch.randn(batch_size, 12)

METHOD = 'update'

ARGS = {
    'indiv_reward_batch': indiv_reward_batch,
    'indiv_obs_batch': indiv_obs_batch,
    'global_state_batch': global_state_batch,
    'global_actions_batch': global_actions_batch,
    'global_next_state_batch': global_next_state_batch,
    'next_global_actions': next_global_actions
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type NoneType — a NoneType output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a NoneType output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
DiagGaussian Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("6072c4350e278037")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, DiagGaussian: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# Stand-in class for args parameter
class Args:
    def __init__(self):
        self.std_x_coef = 1.0
        self.std_y_coef = 0.5

# Define parameters for DiagGaussian
num_inputs = 4
num_outputs = 3
use_orthogonal = True
gain = 0.01
args = Args()

ARGS = {
    "num_inputs": num_inputs,
    "num_outputs": num_outputs,
    "use_orthogonal": use_orthogonal,
    "gain": gain,
    "args": args
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type DiagGaussian — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a DiagGaussian output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
DiscretePolicy Ran
ran on a synthesized input
Chan1998/MAAC/algorithms/attention_sac.py
pointer only (licence: NOASSERTION) · get_code("b4fe457a99be3144")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, Chan1998/MAAC (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ExperienceBuffer Ran
ran on a synthesized input · constructed an object; no result was computed
petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity/multiagent_resources.py
pointer only (licence: NONE) · get_code("b4481f38bbb906b5")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

FixedBernoulli Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("a48b952a1d356122")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, FixedBernoulli: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# FixedBernoulli inherits from torch.distributions.Bernoulli
# The parent class Bernoulli requires either 'probs' or 'logits' parameter
# Looking at the methods:
# - log_probs(actions): calls super().log_prob(actions) and uses actions.size(0)
# - entropy(): calls super().entropy() 
# - mode(): accesses self.probs and compares with 0.5
# So we need to provide 'probs' parameter to the Bernoulli distribution

# Create a small probs tensor (batch_size=2, event_shape=4)
probs = torch.rand(2, 4)

ARGS = {
    'probs': probs
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type FixedBernoulli — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a FixedBernoulli output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
FixedNormal Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("2430b3c71fa829d4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, FixedNormal: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# FixedNormal is a subclass of torch.distributions.Normal
# Normal requires loc (mean) and scale (standard deviation) parameters
# Both should be tensors with compatible shapes for broadcasting

loc = torch.randn(2, 4)  # batch_size=2, event_shape=4
scale = torch.ones(2, 4)  # batch_size=2, event_shape=4

ARGS = {
    'loc': loc,
    'scale': scale,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type FixedNormal — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a FixedNormal output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
HAPPO Ran
ran on a synthesized input · constructed an object; no result was computed
morning9393/HAPPO-HATRPO/algorithms/happo_trainer.py
code served (permissive licence) · get_code("14f32d9aecd1c394")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, HAPPO: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import numpy as np

torch.manual_seed(0)

# Create a minimal policy class that satisfies HAPPO's usage
class DummyPolicy(nn.Module):
    def __init__(self):
        super().__init__()
        self.actor = nn.Linear(4, 3)
        self.critic = nn.Linear(4, 1)
    
    def forward(self, obs):
        action = self.actor(obs)
        value = self.critic(obs)
        return action, value
    
    def get_action_value(self, obs, masks=None):
        return self.forward(obs)

# Create a minimal args object
class Args:
    def __init__(self):
        self.clip_param = 0.2
        self.ppo_epoch = 2
        self.num_mini_batch = 2
        self.data_chunk_length = 4
        self.value_loss_coef = 1.0
        self.entropy_coef = 0.01
        self.max_grad_norm = 0.5
        self.huber_delta = 10.0
        self.use_recurrent_policy = False
        self.use_naive_recurrent_policy = False
        self.use_max_grad_norm = True
        self.use_clipped_value_loss = True
        self.use_huber_loss = False
        self.use_popart = True
        self.use_value_active_masks = True
        self.use_policy_active_masks = True

args = Args()
policy = DummyPolicy()
device = torch.device('cpu')

ARGS = {
    'args': args,
    'policy': policy,
    'device': device
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type HAPPO — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a HAPPO output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MADDPG Ran
ran on a synthesized input
biemann/Collaboration-and-Competition/maddpg.py
pointer only (licence: NONE) · get_code("a3dd086ac1fbb639")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, biemann/Collaboration-and-Competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MADDPG Ran
ran on a synthesized input · constructed an object; no result was computed
isp1tze/MAProj/algo/maddpg/maddpg_agent.py
pointer only (licence: NONE) · get_code("cc58450c6eb52f3a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, isp1tze/MAProj when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MADDPG Ran
ran on a synthesized input · constructed an object; no result was computed
xuehy/pytorch-maddpg/MADDPG.py
pointer only (licence: NONE) · get_code("bcbd9c4a35e9a9e0")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, xuehy/pytorch-maddpg when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MADDPG Ran
ran on a synthesized input · constructed an object; no result was computed
philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients/maddpg.py
pointer only (licence: NONE) · get_code("af4f065d2ca09a90")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, philtabor/Multi-Agent-Deep-Deterministic-Policy-Gradients when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MLPBase Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("eb97113b662895e7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MLPBase: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

class ArgsConfig:
    def __init__(self):
        self.use_feature_normalization = True
        self.use_orthogonal = True
        self.use_ReLU = True
        self.stacked_frames = 1
        self.layer_N = 2
        self.hidden_size = 8

args = ArgsConfig()
obs_shape = (4,)

ARGS = {
    'args': args,
    'obs_shape': obs_shape,
    'cat_self': True,
    'attn_internal': False
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MLPBase — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLPBase output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MLPLayer Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("052cdd66a800bf26")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, MLPLayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'input_dim': 8,
    'hidden_size': 16,
    'layer_N': 2,
    'use_orthogonal': True,
    'use_ReLU': True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type MLPLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLPLayer output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
MLPNetwork Ran
ran on a synthesized input
Yutongamber/MADDPG/maddpg-pytorch/algorithms/maddpg.py
code served (permissive licence) · get_code("d91c262ff01c1192")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float, shape (2, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import torch.nn.functional as F

INIT_ARGS = {
    'input_dim': 4,
    'out_dim': 3,
    'hidden_dim': 64,
    'nonlin': F.relu,
    'constrain_out': False,
    'norm_in': True,
    'discrete_action': True,
}

ARGS = {
    'X': torch.randn(2, 4),
}

if __name__ == '__main__':
    from torch.nn import Module
    
    class MLPNetwork(nn.Module):
        """
        MLP network (can be used as value or policy)
        """

        def __init__(self, input_dim, out_dim, hidden_dim=64, nonlin=F.relu, constrain_out=False, norm_in=True, discrete_action=True):
            """
            Inputs:
                input_dim (int): Number of dimensions in input
                out_dim (int): Number of dimensions in output
                hidden_dim (int): Number of hidden dimensions
                nonlin (PyTorch function): Nonlinearity to apply to hidden layers
            """
            super(MLPNetwork, self).__init__()
            if norm_in:
                self.in_fn = nn.BatchNorm1d(input_dim)
                self.in_fn.weight.data.fill_(1)
                self.in_fn.bias.data.fill_(0)
            else:
                self.in_fn = lambda x: x
            self.fc1 = nn.Linear(input_dim, hidden_dim)
            self.fc2 = nn.Linear(hidden_dim, hidden_dim)
            self.fc3 = nn.Linear(hidden_dim, out_dim)
            self.nonlin = nonlin
            if constrain_out and (not discrete_action):
                self.fc3.weight.data.uniform_(-0.003, 0.003)
                self.out_fn = F.tanh
            else:
                self.out_fn = lambda x: x

        def forward(self, X):
            """
            Inputs:
                X (PyTorch Matrix): Batch of observations
            Outputs:
                out (PyTorch Matrix): Output of network (actions, values, etc)
            """
            h1 = self.nonlin(self.fc1(self.in_fn(X)))
            h2 = self.nonlin(self.fc2(h1))
            out = self.out_fn(self.fc3(h2))
            return out

    model = MLPNetwork(**INIT_ARGS)
    output = model(ARGS['X'])
    print(f"Output shape: {output.shape}")
    print(f"Output: {output}")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 3) — shape (2, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
Memory Ran
ran on a synthesized input · constructed an object; no result was computed
zowiezhang/stas/models/policy/COMA.py
pointer only (licence: NONE) · get_code("51c877df80bace64")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, zowiezhang/stas when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Network Ran
ran on a synthesized input · constructed an object; no result was computed
biemann/Collaboration-and-Competition/maddpg.py
pointer only (licence: NONE) · get_code("f6fceb14173df844")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, biemann/Collaboration-and-Competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

OUActionNoise Ran
ran on a synthesized input · constructed an object; no result was computed
baradist/multiagent-particle-envs/multiagent/ddpg/ddpg_agent.py
code served (permissive licence) · get_code("1ea60fdd30545832")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, OUActionNoise: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Construct valid arguments for OUActionNoise
# The function expects:
# - mu: array-like, the mean of the OU process (used in arithmetic operations and .shape)
# - sigma: float, standard deviation (default 0.15)
# - theta: float, mean reversion rate (default 0.2)
# - dt: float, time step (default 0.01)
# - x0: optional array-like, initial state (default None)

# Create a small mu array (action space dimension = 4)
mu = np.array([0.0, 0.0, 0.0, 0.0])

# Create optional x0 with same shape as mu
x0 = np.zeros_like(mu)

ARGS = {
    "mu": mu,
    "sigma": 0.15,
    "theta": 0.2,
    "dt": 0.01,
    "x0": x0
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type OUActionNoise — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a OUActionNoise output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
OUActionNoise Ran
ran on a synthesized input · constructed an object; no result was computed
petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity/multiagent_resources.py
pointer only (licence: NONE) · get_code("458174da77a0b0ce")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, petsol/MultiAgentCooperation_UnityAgent_MADDPG_Udacity when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

OUNoise Ran
ran on a synthesized input · constructed an object; no result was computed
MrDaubinet/collaboration-and-competition/maddpg.py
pointer only (licence: NONE) · get_code("db3bd13d21d6150c")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, MrDaubinet/collaboration-and-competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

OUNoise Ran
ran on a synthesized input · constructed an object; no result was computed
biemann/Collaboration-and-Competition/maddpg.py
pointer only (licence: NONE) · get_code("555ae48ebffc59d4")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, biemann/Collaboration-and-Competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

OUNoise Ran
ran on a synthesized input · constructed an object; no result was computed
krasing/DRLearningCollaboration/failed_collaborative/ddpg_agent_multi_2.py
pointer only (licence: NONE) · get_code("a169b2555a871836")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, krasing/DRLearningCollaboration when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

PlacholderTfInput Ran
ran on a synthesized input
baoqianwang/iros22_darl1n/maddpg_o/maddpg_local/trainer/maddpg.py
pointer only (licence: NONE) · get_code("bab2a198c923111d")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, baoqianwang/iros22_darl1n when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

PopArt Ran
ran on a synthesized input · constructed an object; no result was computed
morning9393/HAPPO-HATRPO/algorithms/happo_trainer.py
code served (permissive licence) · get_code("cf971b9dc43b13b4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, PopArt: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn
import numpy as np

torch.manual_seed(0)

ARGS = {
    "input_shape": (4,),
    "norm_axes": 1,
    "beta": 0.99999,
    "per_element_update": False,
    "epsilon": 1e-05,
    "device": torch.device('cpu')
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type PopArt — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a PopArt output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
RNNLayer Ran
ran on a synthesized input · constructed an object; no result was computed
anonymous-iclr22/trust-region-in-multi-agent-reinforcement-learning/algorithms/happo_policy.py
code served (permissive licence) · get_code("ff5a06e4902f81ab")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, RNNLayer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'inputs_dim': 4,
    'outputs_dim': 3,
    'recurrent_N': 2,
    'use_orthogonal': True,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type RNNLayer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a RNNLayer output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ReplayBuffer Ran
ran on a synthesized input · constructed an object; no result was computed
MrDaubinet/collaboration-and-competition/maddpg.py
pointer only (licence: NONE) · get_code("ae26aa48075ee6cb")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, MrDaubinet/collaboration-and-competition when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

ReplayBuffer Ran
ran on a synthesized input · constructed an object; no result was computed
baradist/multiagent-particle-envs/multiagent/ddpg/ddpg_agent.py
code served (permissive licence) · get_code("c90519f77627be1f")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned an instance of its own class, ReplayBuffer: the run constructed the object and did not call it, so no result was computed. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

ARGS = {
    'max_size': 100,
    'input_shape': (4, 3),
    'n_actions': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ReplayBuffer — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ReplayBuffer output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ReplayBuffer Ran
ran on a synthesized input · constructed an object; no result was computed
krasing/DRLearningCollaboration/failed_collaborative/ddpg_agent_multi_2.py
pointer only (licence: NONE) · get_code("4cbc44a206f6120a")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, krasing/DRLearningCollaboration when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

Showing the first 60. An agent gets every one from get_harvested_code_for_paper("1706.02275").

Also present in other papers' code

Of 143 samples lifted from this paper's linked repositories, 143 carry a function identity and 0 do not. Of the 143 distinct functions with an identity, 18 are also present in other papers whose code we hold (8 with at least one paper dated earlier, 0 the same month, 13 later) and 125 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
hidden_init
brick of this paper's assembly: helper
11 other papers
2 dated earlier, 9 later · 5 only as an assembly brick
1509.02971 (2015-09)
Continuous control with deep reinforcement learning
1602.01783 (2016-02)
Asynchronous Methods for Deep Reinforcement Learning
1801.01290 (2018-01)
Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor
and 8 more not named here
check
brick of this paper's assembly: helper
10 other papers
10 later · 3 only as an assembly brick
2106.14334 (2021-06)
Policy Regularization via Noisy Advantage Values for Cooperative Multi-agent Actor-Critic methods
2109.11251 (2021-09)
Trust Region Policy Optimisation in Multi-Agent Reinforcement Learning
2207.05631 (2022-07)
DGPO: Discovering Multiple Strategies with Diversity-Guided Policy Optimization
and 7 more not named here
var
brick of this paper's assembly: helper
5 other papers
5 later
1710.00814 (2017-10)
Detecting Adversarial Attacks on Neural Network Policies with Visual Foresight
1803.00933 (2018-03)
Distributed Prioritized Experience Replay
2105.06022 (2021-05)
Principled Exploration via Optimistic Bootstrapping and Backward Induction
and 2 more not named here
hard_update
brick of this paper's assembly: helper
4 other papers
4 later · 3 only as an assembly brick
1801.01290 (2018-01)
Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor
2007.01932 (2020-07)
Meta-SAC: Auto-tune the Entropy Temperature of Soft Actor-Critic via Metagradient
2010.08830 (2020-10)
MESA: Boost Ensemble Imbalanced Learning with MEta-SAmpler
and 1 more not named here
soft_update
brick of this paper's assembly: helper
4 other papers
4 later · 3 only as an assembly brick
1801.01290 (2018-01)
Soft Actor-Critic: Off-Policy Maximum Entropy Deep Reinforcement Learning with a Stochastic Actor
2007.01932 (2020-07)
Meta-SAC: Auto-tune the Entropy Temperature of Soft Actor-Critic via Metagradient
2010.08830 (2020-10)
MESA: Boost Ensemble Imbalanced Learning with MEta-SAmpler
and 1 more not named here
Critic
brick of this paper's assembly: model
2 other papers
2 dated earlier · 2 only as an assembly brick
1509.02971 (2015-09)
Continuous control with deep reinforcement learning
1602.01783 (2016-02)
Asynchronous Methods for Deep Reinforcement Learning
absolute_scope_name
brick of this paper's assembly: helper
2 other papers
1 dated earlier, 1 later
1509.06461 (2015-09)
Deep Reinforcement Learning with Double Q-learning
1806.02473 (2018-06)
Graph Convolutional Policy Network for Goal-Directed Molecular Graph Generation
mean
brick of this paper's assembly: helper
2 other papers
2 later
2212.02705 (2022-12)
What is the Solution for State-Adversarial Multi-Agent Reinforcement Learning?
2307.16212 (2023-07)
Robust Multi-Agent Reinforcement Learning with State Uncertainty
sample_gumbel
brick of this paper's assembly: helper
2 other papers
2 later
1810.02912 (2018-10)
Actor-Attention-Critic for Multi-Agent Reinforcement Learning
2006.09447 (2020-06)
Agent Modelling under Partial Observability for Deep Reinforcement Learning
scope_vars
brick of this paper's assembly: helper
2 other papers
1 dated earlier, 1 later
1509.06461 (2015-09)
Deep Reinforcement Learning with Double Q-learning
1806.02473 (2018-06)
Graph Convolutional Policy Network for Goal-Directed Molecular Graph Generation
sum
brick of this paper's assembly: helper
2 other papers
2 later
2212.02705 (2022-12)
What is the Solution for State-Adversarial Multi-Agent Reinforcement Learning?
2307.16212 (2023-07)
Robust Multi-Agent Reinforcement Learning with State Uncertainty
Actor
brick of this paper's assembly: model
1 other paper
1 dated earlier
1509.02971 (2015-09)
Continuous control with deep reinforcement learning
Bernoulli
brick of this paper's assembly: helper
1 other paper
1 later
2402.02097 (2024-02)
Settling Decentralized Multi-Agent Coordinated Exploration by Novelty Sharing
Memory
brick of this paper's assembly: helper
1 other paper
1 later · 1 only as an assembly brick
2303.08447 (2023-03)
MAHTM: A Multi-Agent Framework for Hierarchical Transactive Microgrids
OUNoise
brick of this paper's assembly: helper
1 other paper
1 dated earlier · 1 only as an assembly brick
1509.02971 (2015-09)
Continuous control with deep reinforcement learning
ReplayBuffer
brick of this paper's assembly: sampler
1 other paper
1 dated earlier · 1 only as an assembly brick
1511.05952 (2015-11)
Prioritized Experience Replay
onehot_from_logits
brick of this paper's assembly: helper
1 other paper
1 later
1810.02912 (2018-10)
Actor-Attention-Critic for Multi-Agent Reinforcement Learning
scope_name
brick of this paper's assembly: helper
1 other paper
1 dated earlier
1509.06461 (2015-09)
Deep Reinforcement Learning with Double Q-learning

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

More are linked than shown here.

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

We explore deep reinforcement learning methods for multi-agent domains. We begin by analyzing the difficulty of traditional algorithms in the multi-agent case: Q-learning is challenged by an inherent non-stationarity of the environment, while policy gradient suffers from a variance that increases as the number of agents grows. We then present an adaptation of actor-critic methods that considers action policies of other agents and is able to successfully learn policies that require complex multiagent coordination. Additionally, we introduce a training regimen utilizing an ensemble of policies for each agent that leads to more robust multi-agent policies. We show the strength of our approach compared to existing methods in cooperative as well as competitive scenarios, where agent populations are able to discover various physical and informational coordination strategies.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("1706.02275")
get_code_for_paper("1706.02275")
have("1706.02275")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/1706.02275.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/1706.02275.svg)](https://syntology.ai/paper/1706.02275)

Connect an agent — have() is free.