repo stringlengths 1 99 | file stringlengths 13 215 | code stringlengths 12 59.2M | file_length int64 12 59.2M | avg_line_length float64 3.82 1.48M | max_line_length int64 12 2.51M | extension_type stringclasses 1
value |
|---|---|---|---|---|---|---|
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/rMAPPOPolicy.py | import torch
from onpolicy.algorithms.r_mappo.algorithm.r_actor_critic import R_Actor, R_Critic
from onpolicy.utils.util import update_linear_schedule
from onpolicy.algorithms.utils.util import *
import igraph as ig
from onpolicy.algorithms.r_mappo.algorithm.probabilistic_dag_model.probabilistic_dag import *
from onpol... | 17,456 | 54.419048 | 271 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/graph_net_trans.py | import torch
import torch.nn as nn
import torch.nn.functional as f
from onpolicy.algorithms.utils.util import init, check
import numpy as np
import math
class TransEncoder(nn.Module):
def __init__(self, n_xdims, nhead, num_layers):
super(TransEncoder, self).__init__()
self.encoder_layer = nn.Transf... | 7,668 | 35.519048 | 126 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/soft_sort.py | import torch
from torch import Tensor
### Sinkhorn soft sort ###
"""A PyTorch lib of ops with permutations, and sinkhorn balancing.
A PyTorch implementation of the library of operations and sampling with permutations
and their approximation with doubly-stochastic matrices, through Sinkhorn
balancing
Original referenc... | 7,648 | 41.259669 | 99 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/temp.py | from asyncio import base_tasks
import torch
from probabilistic_dag import ProbabilisticDAG
n_nodes=7
input_dim = 24
hidden_dim = 49
batch_size = 3000
permutation_net_type = 'set_transformer' #'deep_set'
model = ProbabilisticDAG(n_nodes, input_dim, hidden_dim, permutation_net_type = permutation_net_type)
max1 = -10
ma... | 1,021 | 24.55 | 127 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/gumbel_softmax.py | import torch
import torch.nn.functional as F
from torch.autograd import Variable
class GumbleSoftmax(torch.nn.Module):
def __init__(self, device = 'cpu', temp=1):
super(GumbleSoftmax, self).__init__()
self.device = device
self.temp = temp
def sample_gumbel(self, shape, eps=1e-10):
... | 2,495 | 39.918033 | 90 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/modules.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class MAB(nn.Module):
def __init__(self, dim_Q, dim_K, dim_V, num_heads, ln=False):
super(MAB, self).__init__()
self.dim_V = dim_V
self.num_heads = num_heads
self.fc_q = nn.Linear(dim_Q, dim_V)
se... | 2,270 | 34.484375 | 77 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/probabilistic_dag.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from .gumbel_softmax import *
from .soft_sort import gumbel_sinkhorn
from .sinkhorn_net import Sinkhorn_Net
from .models import DeepSet
# ------------------------------------------------------------------------------
class Probabil... | 5,565 | 41.815385 | 172 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/sinkhorn_net.py |
"""Model class for sorting numbers."""
import torch.nn as nn
class Sinkhorn_Net(nn.Module):
def __init__(self, input_dim, latent_dim, output_dim):
"""
In the constructor we instantiate two nn.Linear modules and assign them as
member variables.
in_flattened_vector: input flattene... | 1,499 | 34.714286 | 82 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/utils/distributions.py | import torch
import torch.nn as nn
from .util import init
"""
Modify standard PyTorch distributions so they to make compatible with this codebase.
"""
#
# Standardize distribution interfaces
#
# Categorical
class FixedCategorical(torch.distributions.Categorical):
def sample(self):
return super().sample(... | 3,478 | 28.235294 | 86 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/utils/cnn.py | import torch.nn as nn
from .util import init
"""CNN Modules and utils."""
class Flatten(nn.Module):
def forward(self, x):
return x.view(x.size(0), -1)
class CNNLayer(nn.Module):
def __init__(self, obs_shape, hidden_size, use_orthogonal, use_ReLU, kernel_size=3, stride=1):
super(CNNLayer, sel... | 1,852 | 30.40678 | 124 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/utils/mlp.py | import torch.nn as nn
from .util import init, get_clones
"""MLP modules."""
class MLPLayer(nn.Module):
def __init__(self, input_dim, hidden_size, layer_N, use_orthogonal, use_ReLU):
super(MLPLayer, self).__init__()
self._layer_N = layer_N
active_func = [nn.Tanh(), nn.ReLU()][use_ReLU]
... | 1,892 | 32.803571 | 93 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/utils/util.py | import copy
import numpy as np
import torch
import torch.nn as nn
import math
import igraph as ig
################# utils ##################################################
def is_acyclic(adjacency):
prod = np.eye(adjacency.shape[0])
for _ in range(1, adjacency.shape[0] + 1):
prod = np.matmul(adjacen... | 4,304 | 27.509934 | 108 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/utils/act.py | from .distributions import Bernoulli, Categorical, DiagGaussian
import torch as th
import torch.nn as nn
import numpy as np
from onpolicy.utils.util import *
import igraph as ig
from datetime import datetime, timedelta
import numpy as np
class ACTLayer(nn.Module):
"""
MLP Module to compute actions.
:param... | 13,584 | 47.866906 | 148 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/algorithms/utils/rnn.py | import torch
import torch.nn as nn
"""RNN modules."""
class RNNLayer(nn.Module):
def __init__(self, inputs_dim, outputs_dim, recurrent_N, use_orthogonal):
super(RNNLayer, self).__init__()
self._recurrent_N = recurrent_N
self._use_orthogonal = use_orthogonal
self.rnn = nn.GRU(inpu... | 2,849 | 34.185185 | 116 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/scripts/train/train_aloha.py | #!/usr/bin/env python
import sys
import os
import socket
import numpy as np
from pathlib import Path
import torch
from onpolicy.config import get_config
from onpolicy.envs.aloha.aloha import AlohaEnv
from onpolicy.envs.env_wrappers import SubprocVecEnv, DummyVecEnv
from datetime import datetime, timedelta
def make_tra... | 3,423 | 28.264957 | 93 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/runner/shared/aloha_runner.py | import time
import numpy as np
import torch
from onpolicy.runner.shared.base_runner import Runner
import os
import json
import sys
def _t2n(x):
return x.detach().cpu().numpy()
class AlohaRunner(Runner):
"""Runner class to perform training, evaluation. and data collection for the MPEs. See parent class for de... | 13,029 | 50.501976 | 171 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/runner/shared/base_runner.py | # import wandb
import os
import numpy as np
import torch
from tensorboardX import SummaryWriter
from onpolicy.utils.shared_buffer import SharedReplayBuffer
def _t2n(x):
"""Convert torch tensor to a numpy array."""
return x.detach().cpu().numpy()
class Runner(object):
"""
Base class for training recurr... | 6,845 | 41.7875 | 141 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/utils/rewarder_basic.py | import numpy as np
import torch
def calc_reward(rew, prev_obs, obs):
ball_x, ball_y, ball_z = obs['ball']
MIDDLE_X, PENALTY_X, END_X = 0.2, 0.64, 1.0
PENALTY_Y, END_Y = 0.27, 0.42
ball_position_r = 0.0
if (-END_X <= ball_x and ball_x < -PENALTY_X) and (-PENALTY_Y < ball_y and ball_y < PENALTY_Y):... | 1,651 | 38.333333 | 101 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/utils/popart.py |
import numpy as np
import torch
import torch.nn as nn
class PopArt(nn.Module):
""" Normalize a vector of observations - across the first norm_axes dimensions"""
def __init__(self, input_shape, norm_axes=1, beta=0.99999, per_element_update=False, epsilon=1e-5, device=torch.device("cpu")):
super(PopA... | 3,106 | 39.881579 | 131 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/utils/shared_buffer.py | import torch
import numpy as np
from onpolicy.utils.util import get_shape_from_obs_space, get_shape_from_act_space
def _flatten(T, N, x):
return x.reshape(T * N, *x.shape[2:])
def _cast(x):
return x.transpose(1, 2, 0, 3).reshape(-1, *x.shape[3:])
def get_graph_data(data):
bz, num_threads, n_agents, dim ... | 34,158 | 52.963665 | 268 | py |
BNPG | BNPG-main/BN_MAPPO_Aloha/onpolicy/utils/util.py | import numpy as np
import math
import torch
def check(input):
if type(input) == np.ndarray:
return torch.from_numpy(input)
def get_gard_norm(it):
sum_grad = 0
for x in it:
if x.grad is None:
continue
sum_grad += x.grad.norm() ** 2
return math.sqrt(sum_grad)
... | 2,949 | 32.146067 | 91 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/config.py | import argparse
def get_config():
"""
The configuration parser for common hyperparameters of all environment.
Please reach each `scripts/train/<env>_runner.py` file to find private hyperparameters
only used in <env>.
Prepare parameters:
--algorithm_name <algorithm_name>
specifi... | 16,701 | 55.809524 | 261 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/envs/env_wrappers.py | """
Modified from OpenAI Baselines code to work with multi-agent envs
"""
import numpy as np
import torch
from multiprocessing import Process, Pipe
from abc import ABC, abstractmethod
from onpolicy.utils.util import tile_images
class CloudpickleWrapper(object):
"""
Uses cloudpickle to serialize contents (other... | 28,231 | 33.262136 | 118 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/envs/coordination_game/cg.py | from re import I
from typing import SupportsAbs
import torch
import numpy as np
import torch.nn.functional as F
import copy
import torch.optim as optim
import torch.nn as nn
from torch.nn.utils import clip_grad_norm_
from torch import distributions
from gym import spaces
from .multi_discrete import MultiDiscrete
import... | 16,631 | 38.319149 | 265 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/r_mappo.py | import numpy as np
import torch
import torch.nn as nn
from onpolicy.utils.util import get_gard_norm, huber_loss, mse_loss
from onpolicy.algorithms.utils.util import _h_A
from onpolicy.utils.popart import PopArt
from onpolicy.algorithms.utils.util import check
import json
class R_MAPPO():
"""
Trainer class for ... | 11,637 | 47.491667 | 266 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/r_actor_critic.py | import torch
import torch.nn as nn
from onpolicy.algorithms.utils.util import init, check
from onpolicy.algorithms.utils.cnn import CNNBase
from onpolicy.algorithms.utils.mlp import MLPBase
from onpolicy.algorithms.utils.rnn import RNNLayer
from onpolicy.algorithms.utils.act import ACTLayer
from onpolicy.utils.util imp... | 11,553 | 51.518182 | 137 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/rMAPPOPolicy.py | import torch
from onpolicy.algorithms.r_mappo.algorithm.r_actor_critic import R_Actor, R_Critic
from onpolicy.utils.util import update_linear_schedule
from onpolicy.algorithms.utils.util import *
import igraph as ig
from onpolicy.algorithms.r_mappo.algorithm.probabilistic_dag_model.probabilistic_dag import *
from onpol... | 17,477 | 55.563107 | 271 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/graph_net_trans.py | import torch
import torch.nn as nn
import torch.nn.functional as f
from onpolicy.algorithms.utils.util import init, check
import numpy as np
import math
class TransEncoder(nn.Module):
def __init__(self, n_xdims, nhead, num_layers):
super(TransEncoder, self).__init__()
self.encoder_layer = nn.Transf... | 7,668 | 35.519048 | 126 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/soft_sort.py | import torch
from torch import Tensor
### Sinkhorn soft sort ###
"""A PyTorch lib of ops with permutations, and sinkhorn balancing.
A PyTorch implementation of the library of operations and sampling with permutations
and their approximation with doubly-stochastic matrices, through Sinkhorn
balancing
Original referenc... | 7,648 | 41.259669 | 99 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/temp.py | from asyncio import base_tasks
import torch
from probabilistic_dag import ProbabilisticDAG
n_nodes=7
input_dim = 24
hidden_dim = 49
batch_size = 3000
permutation_net_type = 'set_transformer' #'deep_set'
model = ProbabilisticDAG(n_nodes, input_dim, hidden_dim, permutation_net_type = permutation_net_type)
max1 = -10
ma... | 1,021 | 24.55 | 127 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/gumbel_softmax.py | import torch
import torch.nn.functional as F
from torch.autograd import Variable
class GumbleSoftmax(torch.nn.Module):
def __init__(self, device = 'cpu', temp=1):
super(GumbleSoftmax, self).__init__()
self.device = device
self.temp = temp
def sample_gumbel(self, shape, eps=1e-10):... | 2,495 | 40.6 | 90 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/modules.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class MAB(nn.Module):
def __init__(self, dim_Q, dim_K, dim_V, num_heads, ln=False):
super(MAB, self).__init__()
self.dim_V = dim_V
self.num_heads = num_heads
self.fc_q = nn.Linear(dim_Q, dim_V)
se... | 2,270 | 34.484375 | 77 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/probabilistic_dag.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from .gumbel_softmax import *
from .soft_sort import gumbel_sinkhorn
from .sinkhorn_net import Sinkhorn_Net
from .models import DeepSet
class ProbabilisticDAG(nn.Module):
def __init__(self, n_nodes, input_dim, hidden_dim, tempe... | 5,572 | 42.539063 | 155 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/sinkhorn_net.py |
"""Model class for sorting numbers."""
import torch.nn as nn
class Sinkhorn_Net(nn.Module):
def __init__(self, input_dim, latent_dim, output_dim):
"""
In the constructor we instantiate two nn.Linear modules and assign them as
member variables.
in_flattened_vector: input flattene... | 1,499 | 34.714286 | 82 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/utils/distributions.py | import torch
import torch.nn as nn
from .util import init
"""
Modify standard PyTorch distributions so they to make compatible with this codebase.
"""
#
# Standardize distribution interfaces
#
# Categorical
class FixedCategorical(torch.distributions.Categorical):
def sample(self):
return super().sample(... | 3,478 | 28.235294 | 86 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/utils/cnn.py | import torch.nn as nn
from .util import init
"""CNN Modules and utils."""
class Flatten(nn.Module):
def forward(self, x):
return x.view(x.size(0), -1)
class CNNLayer(nn.Module):
def __init__(self, obs_shape, hidden_size, use_orthogonal, use_ReLU, kernel_size=3, stride=1):
super(CNNLayer, sel... | 1,852 | 30.40678 | 124 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/utils/mlp.py | import torch.nn as nn
from .util import init, get_clones
"""MLP modules."""
class MLPLayer(nn.Module):
def __init__(self, input_dim, hidden_size, layer_N, use_orthogonal, use_ReLU):
super(MLPLayer, self).__init__()
self._layer_N = layer_N
active_func = [nn.Tanh(), nn.ReLU()][use_ReLU]
... | 1,892 | 32.803571 | 93 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/utils/util.py | import copy
import numpy as np
import torch
import torch.nn as nn
import math
import igraph as ig
################# utils ##################################################
def is_acyclic(adjacency):
prod = np.eye(adjacency.shape[0])
for _ in range(1, adjacency.shape[0] + 1):
prod = np.matmul(adjacen... | 4,304 | 27.509934 | 108 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/utils/act.py | from .distributions import Bernoulli, Categorical, DiagGaussian
import torch as th
import torch.nn as nn
import numpy as np
from onpolicy.utils.util import *
import igraph as ig
from datetime import datetime, timedelta
import numpy as np
class ACTLayer(nn.Module):
"""
MLP Module to compute actions.
:param... | 13,402 | 47.916058 | 148 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/algorithms/utils/rnn.py | import torch
import torch.nn as nn
"""RNN modules."""
class RNNLayer(nn.Module):
def __init__(self, inputs_dim, outputs_dim, recurrent_N, use_orthogonal):
super(RNNLayer, self).__init__()
self._recurrent_N = recurrent_N
self._use_orthogonal = use_orthogonal
self.rnn = nn.GRU(inpu... | 2,849 | 34.185185 | 116 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/scripts/train/train_coordination_game.py | #!/usr/bin/env python
import sys
import os
import socket
import numpy as np
from pathlib import Path
import torch
from onpolicy.config import get_config
from onpolicy.envs.coordination_game.cg import CoordinationGame
from onpolicy.envs.env_wrappers import SubprocVecEnv, DummyVecEnv
from datetime import datetime, timede... | 3,536 | 28.231405 | 110 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/runner/shared/coordination_game_runner.py | import time
import numpy as np
import torch
from onpolicy.runner.shared.base_runner import Runner
import os
import json
import sys
from onpolicy.envs.coordination_game.cg import CoordinationGame
def _t2n(x):
return x.detach().cpu().numpy()
class Coordination_GameRunner(Runner):
"""Runner class to perform tra... | 12,734 | 50.558704 | 198 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/runner/shared/base_runner.py | # import wandb
import os
import numpy as np
import torch
from tensorboardX import SummaryWriter
from onpolicy.utils.shared_buffer import SharedReplayBuffer
def _t2n(x):
"""Convert torch tensor to a numpy array."""
return x.detach().cpu().numpy()
class Runner(object):
"""
Base class for training recurr... | 6,870 | 41.94375 | 182 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/utils/rewarder_basic.py | import numpy as np
import torch
def calc_reward(rew, prev_obs, obs):
ball_x, ball_y, ball_z = obs['ball']
MIDDLE_X, PENALTY_X, END_X = 0.2, 0.64, 1.0
PENALTY_Y, END_Y = 0.27, 0.42
ball_position_r = 0.0
if (-END_X <= ball_x and ball_x < -PENALTY_X) and (-PENALTY_Y < ball_y and ball_y < PENALTY_Y):... | 1,651 | 38.333333 | 101 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/utils/popart.py |
import numpy as np
import torch
import torch.nn as nn
class PopArt(nn.Module):
""" Normalize a vector of observations - across the first norm_axes dimensions"""
def __init__(self, input_shape, norm_axes=1, beta=0.99999, per_element_update=False, epsilon=1e-5, device=torch.device("cpu")):
super(PopA... | 3,106 | 39.881579 | 131 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/utils/shared_buffer.py | import torch
import numpy as np
from onpolicy.utils.util import get_shape_from_obs_space, get_shape_from_act_space
def _flatten(T, N, x):
return x.reshape(T * N, *x.shape[2:])
def _cast(x):
return x.transpose(1, 2, 0, 3).reshape(-1, *x.shape[3:])
def get_graph_data(data):
bz, num_threads, n_agents, dim ... | 34,170 | 52.982622 | 268 | py |
BNPG | BNPG-main/BN_MAPPO_Coordination_Game/onpolicy/utils/util.py | import numpy as np
import math
import torch
def check(input):
if type(input) == np.ndarray:
return torch.from_numpy(input)
def get_gard_norm(it):
sum_grad = 0
for x in it:
if x.grad is None:
continue
sum_grad += x.grad.norm() ** 2
return math.sqrt(sum_grad)
... | 2,949 | 32.146067 | 91 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/config.py | import argparse
def get_config():
"""
The configuration parser for common hyperparameters of all environment.
Please reach each `scripts/train/<env>_runner.py` file to find private hyperparameters
only used in <env>.
Prepare parameters:
--algorithm_name <algorithm_name>
specif... | 16,197 | 55.439024 | 261 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/envs/env_wrappers.py | """
Modified from OpenAI Baselines code to work with multi-agent envs
"""
import numpy as np
import torch
from multiprocessing import Process, Pipe
from abc import ABC, abstractmethod
from onpolicy.utils.util import tile_images
class CloudpickleWrapper(object):
"""
Uses cloudpickle to serialize contents (other... | 28,209 | 33.277035 | 118 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/r_mappo.py | import numpy as np
import torch
import torch.nn as nn
from onpolicy.utils.util import get_gard_norm, huber_loss, mse_loss
from onpolicy.utils.valuenorm import ValueNorm
from onpolicy.algorithms.utils.util import check
class R_MAPPO():
"""
Trainer class for MAPPO to update policies.
:param args: (argparse.N... | 11,635 | 46.688525 | 157 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/r_actor_critic.py | import torch
import torch.nn as nn
from onpolicy.algorithms.utils.util import init, check
from onpolicy.algorithms.utils.cnn import CNNBase
from onpolicy.algorithms.utils.mlp import MLPBase
from onpolicy.algorithms.utils.rnn import RNNLayer
from onpolicy.algorithms.utils.act import ACTLayer
from onpolicy.algorithms.uti... | 9,914 | 50.910995 | 191 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/rMAPPOPolicy.py | import torch
from onpolicy.algorithms.r_mappo.algorithm.r_actor_critic import R_Actor, R_Critic
from onpolicy.utils.util import update_linear_schedule
from onpolicy.algorithms.r_mappo.algorithm.probabilistic_dag_model.probabilistic_dag import *
from onpolicy.algorithms.utils.util import check
from onpolicy.utils.util i... | 13,902 | 56.929167 | 182 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/soft_sort.py | import torch
from torch import Tensor
### Sinkhorn soft sort ###
"""A PyTorch lib of ops with permutations, and sinkhorn balancing.
A PyTorch implementation of the library of operations and sampling with permutations
and their approximation with doubly-stochastic matrices, through Sinkhorn
balancing
Original referenc... | 7,552 | 41.195531 | 99 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/temp.py | from asyncio import base_tasks
import torch
from probabilistic_dag import ProbabilisticDAG
n_nodes=7
input_dim = 24
hidden_dim = 49
batch_size = 3000
permutation_net_type = 'set_transformer' #'deep_set'
model = ProbabilisticDAG(n_nodes, input_dim, hidden_dim, permutation_net_type = permutation_net_type)
max1 = -10
ma... | 1,021 | 24.55 | 127 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/gumbel_softmax.py | import torch
import torch.nn.functional as F
from torch.autograd import Variable
class GumbleSoftmax(torch.nn.Module):
def __init__(self, device = 'cpu', temp=1):
super(GumbleSoftmax, self).__init__()
self.device = device
self.temp = temp
def sample_gumbel(self, shape, eps=1e-10):
... | 2,495 | 39.918033 | 90 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/modules.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import math
class MAB(nn.Module):
def __init__(self, dim_Q, dim_K, dim_V, num_heads, ln=False):
super(MAB, self).__init__()
self.dim_V = dim_V
self.num_heads = num_heads
self.fc_q = nn.Linear(dim_Q, dim_V)
se... | 2,270 | 34.484375 | 77 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/probabilistic_dag.py | import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from .gumbel_softmax import *
from .soft_sort import gumbel_sinkhorn
from .sinkhorn_net import Sinkhorn_Net
class ProbabilisticDAG(nn.Module):
def __init__(self, n_nodes, input_dim, hidden_dim, temperature=1.0, hard=True, noise... | 5,073 | 39.269841 | 144 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/r_mappo/algorithm/probabilistic_dag_model/sinkhorn_net.py |
"""Model class for sorting numbers."""
import torch.nn as nn
class Sinkhorn_Net(nn.Module):
def __init__(self, input_dim, latent_dim, output_dim):
"""
In the constructor we instantiate two nn.Linear modules and assign them as
member variables.
in_flattened_vector: input flattene... | 1,489 | 33.651163 | 82 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/distributions.py | import torch
import torch.nn as nn
from .util import init
"""
Modify standard PyTorch distributions so they to make compatible with this codebase.
"""
#
# Standardize distribution interfaces
#
# Categorical
class FixedCategorical(torch.distributions.Categorical):
def sample(self):
return super().sample(... | 3,475 | 28.210084 | 86 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/cnn.py | import torch.nn as nn
from .util import init
"""CNN Modules and utils."""
class Flatten(nn.Module):
def forward(self, x):
return x.view(x.size(0), -1)
class CNNLayer(nn.Module):
def __init__(self, obs_shape, hidden_size, use_orthogonal, use_ReLU, kernel_size=3, stride=1):
super(CNNLayer, sel... | 1,852 | 30.40678 | 124 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/mlp.py | import torch.nn as nn
from .util import init, get_clones
"""MLP modules."""
class MLPLayer(nn.Module):
def __init__(self, input_dim, hidden_size, layer_N, use_orthogonal, use_ReLU):
super(MLPLayer, self).__init__()
self._layer_N = layer_N
active_func = [nn.Tanh(), nn.ReLU()][use_ReLU]
... | 1,892 | 32.803571 | 93 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/popart.py | import math
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
class PopArt(torch.nn.Module):
def __init__(self, input_shape, output_shape, norm_axes=1, beta=0.99999, epsilon=1e-5, device=torch.device("cpu")):
super(PopArt, self).__init__()
self.bet... | 3,944 | 38.848485 | 119 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/util.py | import copy
import numpy as np
import torch
import torch.nn as nn
def init(module, weight_init, bias_init, gain=1):
weight_init(module.weight.data, gain=gain)
bias_init(module.bias.data)
return module
def get_clones(module, N):
return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
def chec... | 425 | 22.666667 | 76 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/act.py | from .distributions import Bernoulli, Categorical, DiagGaussian
import torch
import torch.nn as nn
from .models import model_factory
from onpolicy.algorithms.utils.rnn import RNNLayer
from onpolicy.algorithms.r_mappo.algorithm.probabilistic_dag_model.models import DeepSetOA
class ACTLayer(nn.Module):
"""
MLP M... | 12,084 | 52.004386 | 181 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/rnn.py | import torch
import torch.nn as nn
"""RNN modules."""
class RNNLayer(nn.Module):
def __init__(self, inputs_dim, outputs_dim, recurrent_N, use_orthogonal):
super(RNNLayer, self).__init__()
self._recurrent_N = recurrent_N
self._use_orthogonal = use_orthogonal
self.rnn = nn.GRU(inpu... | 2,849 | 34.185185 | 116 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/models/test_net_hetro.py | """Implements some basic test."""
import unittest
import torch
from models.graph_net import GraphNetHetro
from models.mlp_net import MlpNet
from models.graph_layers import GraphConvLayer
from models.model_factory import get_model_fn
class TestNet(unittest.TestCase):
"""Basic tests for graph net."""
def setUp(se... | 989 | 25.756757 | 65 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/models/graph_layers.py | """Implements graph layers."""
import torch
import torch.nn as nn
from torch.nn.parameter import Parameter
from torch.nn.modules.module import Module
class GraphConvLayer(Module):
"""Implements a GCN layer."""
def __init__(self, input_dim, output_dim):
super(GraphConvLayer, self).__init__()
... | 2,732 | 31.152941 | 78 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/models/graph_net.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from .graph_layers import GraphConvLayer
class GraphNetHetro(nn.Module):
# A graph net that supports different edge attributes.
def __init__(self, sa_dim, n_agents, hidden_size, agent_groups, agent_id=0,
pool_type='avg', use_a... | 19,694 | 37.168605 | 138 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/algorithms/utils/models/mlp_net.py | """Implements a simple two layer mlp network."""
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
class MlpNet(nn.Module):
"""Implements a simple fully connected mlp network."""
def __init__(self, sa_dim, n_agents, hidden_size,
agent_id=0, agent_shuffle='none'... | 3,613 | 30.426087 | 93 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/scripts/eval/eval_hanabi.py | #!/usr/bin/env python
import sys
import os
import wandb
import socket
import setproctitle
import numpy as np
from pathlib import Path
import torch
from onpolicy.config import get_config
from onpolicy.envs.hanabi.Hanabi_Env import HanabiEnv
from onpolicy.envs.env_wrappers import ChooseSubprocVecEnv, ChooseDummyVecEnv... | 6,394 | 34.137363 | 189 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/scripts/eval/eval_smac.py | #!/usr/bin/env python
import sys
sys.path.append("/content/gdrive/MyDrive/Baysian_PPO_P_Replay")
import os
import json
#import wandb
#import socket
#import setproctitle
import numpy as np
from pathlib import Path
import torch
from onpolicy.config import get_config
from onpolicy.envs.starcraft2.StarCraft2_Env import Sta... | 6,198 | 37.265432 | 181 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/scripts/render/render_football.py | #!/usr/bin/env python
# python standard libraries
import os
from pathlib import Path
import sys
import socket
# third-party packages
import numpy as np
import setproctitle
import torch
# code repository sub-packages
from onpolicy.config import get_config
from onpolicy.envs.football.Football_Env import FootballEnv
fro... | 6,053 | 36.602484 | 141 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/scripts/render/render_mpe.py | #!/usr/bin/env python
import sys
import os
import wandb
import socket
import setproctitle
import numpy as np
from pathlib import Path
import torch
from onpolicy.config import get_config
from onpolicy.envs.mpe.MPE_env import MPEEnv
from onpolicy.envs.env_wrappers import SubprocVecEnv, DummyVecEnv
def make_render_env... | 4,728 | 33.518248 | 191 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/scripts/train/train_smac.py | #!/usr/bin/env python
import sys
import os
import numpy as np
from pathlib import Path
import torch
from onpolicy.config import get_config
from onpolicy.envs.starcraft2.StarCraft2_Env import StarCraft2Env
from onpolicy.envs.starcraft2.smac_maps import get_map_params
from onpolicy.envs.env_wrappers import ShareSubprocVe... | 5,860 | 37.559211 | 181 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/runner/shared/hanabi_runner_forward.py |
import time
import wandb
import os
import numpy as np
from itertools import chain
import torch
from onpolicy.utils.util import update_linear_schedule
from onpolicy.runner.shared.base_runner import Runner
def _t2n(x):
return x.detach().cpu().numpy()
class HanabiRunner(Runner):
"""Runner class to perform ... | 17,083 | 50.927052 | 167 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/runner/shared/smac_runner.py | import time
import wandb
import numpy as np
from functools import reduce
import torch
from onpolicy.runner.shared.base_runner import Runner
import os
import json
def _t2n(x):
return x.detach().cpu().numpy()
class SMACRunner(Runner):
"""Runner class to perform training, evaluation. and data collection for SMAC... | 17,554 | 49.30086 | 171 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/runner/shared/mpe_runner.py | import time
import numpy as np
import torch
from onpolicy.runner.shared.base_runner import Runner
import os
import json
def _t2n(x):
return x.detach().cpu().numpy()
class MPERunner(Runner):
"""Runner class to perform training, evaluation. and data collection for the MPEs. See parent class for details."""
... | 11,935 | 46.935743 | 150 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/runner/shared/football_runner.py | from collections import defaultdict, deque
from itertools import chain
import os
import time
import imageio
import numpy as np
import torch
import wandb
from onpolicy.utils.util import update_linear_schedule
from onpolicy.runner.shared.base_runner import Runner
def _t2n(x):
return x.detach().cpu().numpy()
clas... | 12,999 | 44.614035 | 167 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/runner/shared/base_runner.py | import wandb
import os
import numpy as np
import torch
from tensorboardX import SummaryWriter
from onpolicy.utils.shared_buffer import SharedReplayBuffer
from onpolicy.algorithms.r_mappo.algorithm.probabilistic_dag_model.probabilistic_dag import *
def _t2n(x):
"""Convert torch tensor to a numpy array."""
retur... | 7,615 | 42.028249 | 185 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/runner/separated/mpe_runner.py |
import time
import wandb
import os
import numpy as np
from itertools import chain
import torch
from onpolicy.utils.util import update_linear_schedule
from onpolicy.runner.separated.base_runner import Runner
import imageio
def _t2n(x):
return x.detach().cpu().numpy()
class MPERunner(Runner):
def __init__... | 15,423 | 48.277955 | 143 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/runner/separated/base_runner.py |
import time
import wandb
import os
import numpy as np
from itertools import chain
import torch
from tensorboardX import SummaryWriter
from onpolicy.utils.separated_buffer import SeparatedReplayBuffer
from onpolicy.utils.util import update_linear_schedule
def _t2n(x):
return x.detach().cpu().numpy()
class Ru... | 7,371 | 42.364706 | 150 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/utils/valuenorm.py |
import numpy as np
import torch
import torch.nn as nn
class ValueNorm(nn.Module):
""" Normalize a vector of observations - across the first norm_axes dimensions"""
def __init__(self, input_shape, norm_axes=1, beta=0.99999, per_element_update=False, epsilon=1e-5):
super(ValueNorm, self).__init__()
... | 3,132 | 38.658228 | 105 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/utils/shared_buffer.py | import torch
import numpy as np
from onpolicy.utils.util import get_shape_from_obs_space, get_shape_from_act_space
def _flatten(T, N, x):
return x.reshape(T * N, *x.shape[2:])
def _cast(x):
return x.transpose(1, 2, 0, 3).reshape(-1, *x.shape[3:])
def get_graph_data(data, cast=True):
bz, num_threads, n_... | 32,757 | 51.496795 | 158 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/utils/util.py | import numpy as np
import math
import torch
def check(input):
if type(input) == np.ndarray:
return torch.from_numpy(input)
def get_gard_norm(it):
sum_grad = 0
for x in it:
if x.grad is None:
continue
sum_grad += x.grad.norm() ** 2
return math.sqrt(sum_grad)
... | 2,239 | 29.684932 | 80 | py |
BNPG | BNPG-main/BN_MAPPO_SMAC/onpolicy/utils/separated_buffer.py | import torch
import numpy as np
from collections import defaultdict
from onpolicy.utils.util import check, get_shape_from_obs_space, get_shape_from_act_space
def _flatten(T, N, x):
return x.reshape(T * N, *x.shape[2:])
def _cast(x):
return x.transpose(1,0,2).reshape(-1, *x.shape[2:])
class SeparatedReplayBu... | 21,466 | 53.484772 | 231 | py |
BNPG | BNPG-main/Tabular_Coordination_Game/cg.py | import torch
import numpy as np
import torch.nn.functional as F
import copy
import torch.optim as optim
import torch.nn as nn
from torch.nn.utils import clip_grad_norm_
class Net(nn.Module):
def __init__(self, n, policy = 'tabular', G_type = 'all_zeros', device = 'cpu'):
super(Net, self).__init__()
... | 16,065 | 39.265664 | 163 | py |
BNPG | BNPG-main/Tabular_Coordination_Game/run.py | import torch
import os
import json
import numpy as np
import cg
seeds = [i for i in range(1,50)]
ns = [2,3,5]
policy = 'tabular_baysian'
optimizer_type = 'SGD'
device ='cuda'
num_iterations = 2000
iterations = [i for i in range(num_iterations)]
if not os.path.exists('./results'):
os.makedirs('./results')
for n i... | 2,909 | 35.835443 | 157 | py |
GWG_release | GWG_release-main/rbm_svgd.py | import argparse
import toy_data
import rbm
import torch
import numpy as np
import samplers_old as samplers
import mmd
import torch.nn as nn
import matplotlib.pyplot as plt
import os
import torchvision
device = torch.device('cuda:' + str(0) if torch.cuda.is_available() else 'cpu')
import utils
def makedirs(dirname):
... | 6,911 | 36.16129 | 119 | py |
GWG_release | GWG_release-main/eval_protein.py | import argparse
import torch
import numpy as np
import matplotlib.pyplot as plt
import os
device = torch.device('cuda:' + str(0) if torch.cuda.is_available() else 'cpu')
import utils
import pickle
def makedirs(dirname):
"""
Make directory only if it's not already there.
"""
if not os.path.exists(dirna... | 9,334 | 42.018433 | 133 | py |
GWG_release | GWG_release-main/rbm_sample.py | import argparse
import rbm
import torch
import numpy as np
import samplers
import mmd
import matplotlib.pyplot as plt
import os
device = torch.device('cuda:' + str(0) if torch.cuda.is_available() else 'cpu')
import utils
import tensorflow_probability as tfp
import block_samplers
import time
import pickle
def makedirs... | 9,401 | 34.213483 | 126 | py |
GWG_release | GWG_release-main/ising_sample.py | import argparse
import rbm
import torch
import numpy as np
import samplers
import matplotlib.pyplot as plt
import os
import torchvision
device = torch.device('cuda:' + str(0) if torch.cuda.is_available() else 'cpu')
import tensorflow_probability as tfp
import block_samplers
import time
import pickle
def makedirs(dirn... | 6,532 | 33.566138 | 130 | py |
GWG_release | GWG_release-main/vamp_utils.py | from __future__ import print_function
import torch
import torch.utils.data as data_utils
import torchvision
import numpy as np
from scipy.io import loadmat
import os
import pickle
# -=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
# ============... | 20,045 | 42.109677 | 159 | py |
GWG_release | GWG_release-main/pcd_potts.py | import argparse
import toy_data
import rbm
import torch
import numpy as np
import samplers
import mmd
import torch.nn as nn
import matplotlib.pyplot as plt
import os
device = torch.device('cuda:' + str(0) if torch.cuda.is_available() else 'cpu')
import utils
def makedirs(dirname):
"""
Make directory only if i... | 14,601 | 41.821114 | 138 | py |
GWG_release | GWG_release-main/fhmm_sample.py | import argparse
import torch
import numpy as np
import samplers
import fhmm
import matplotlib.pyplot as plt
import os
device = torch.device('cuda:' + str(0) if torch.cuda.is_available() else 'cpu')
import time
import block_samplers
import pickle
def makedirs(dirname):
"""
Make directory only if it's not alrea... | 8,635 | 34.983333 | 118 | py |
GWG_release | GWG_release-main/mmd.py | import torch
def assert_shape(x, s):
assert x.size() == s
def avg_hamming(x, y):
diffs = (x[None, :] != y[:, None, :]).float().mean(-1)
return diffs
def exp_avg_hamming(x, y):
diffs = avg_hamming(x, y)
return (-diffs).exp()
def scaled_exp_avg_hamming(x, y, s):
diffs = avg_hamming(x, y) ... | 2,932 | 25.1875 | 79 | py |
GWG_release | GWG_release-main/rbm.py | import torch
import torch.nn as nn
import torch.distributions as dists
from tqdm import tqdm
import igraph as ig
import numpy as np
import torch.nn.functional as F
class BernoulliRBM(nn.Module):
def __init__(self, n_visible, n_hidden, data_mean=None):
super().__init__()
linear = nn.Linear(n_visibl... | 7,403 | 34.596154 | 119 | py |
GWG_release | GWG_release-main/ais.py | import torch
import torch.nn as nn
import numpy as np
from tqdm import tqdm
class AISModel(nn.Module):
def __init__(self, model, init_dist):
super().__init__()
self.model = model
self.init_dist = init_dist
def forward(self, x, beta):
logpx = self.model(x).squeeze()
log... | 2,303 | 26.428571 | 77 | py |
GWG_release | GWG_release-main/mlp.py | import torch
import torch.nn as nn
class Swish(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return x * torch.sigmoid(x)
def mlp_ebm(nin, nint=256, nout=1):
return nn.Sequential(
nn.Linear(nin, nint),
Swish(),
nn.Linear(nint, ni... | 5,205 | 31.742138 | 103 | py |
GWG_release | GWG_release-main/pcd.py | import argparse
import toy_data
import rbm
import torch
import numpy as np
import samplers
import mmd
import torch.nn as nn
import matplotlib.pyplot as plt
import os
import torchvision
device = torch.device('cuda:' + str(0) if torch.cuda.is_available() else 'cpu')
import utils
from tqdm import tqdm
import pickle
def ... | 11,634 | 41.775735 | 116 | py |
GWG_release | GWG_release-main/utils.py | import torch
import torch.nn as nn
import toy_data
import torchvision
import torchvision.transforms as tr
from torch.utils.data import DataLoader, TensorDataset
import numpy as np
import visualize_flow
import matplotlib.pyplot as plt
import pickle
import rbm
import samplers
from tqdm import tqdm
import os
def differe... | 15,215 | 38.317829 | 118 | py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.