def __init__(self):
super(Net, self).__init__()
#self.conv1 = TAGConv(4, 128, 3)
#self.conv2 = TAGConv(128, 128, 3)
self.conv1 = BallConv(MLP([2*3, 128, 128, 128]), 'max')
self.conv2 = BallConv(MLP([2*128, 256]), 'max')
self.lin1 = torch.nn.Sequential(
torch.nn.Linear(256,128),
torch.nn.ReLU(),
#BN(512),
)
self.lin2 = torch.nn.Sequential(
BN(128),
torch.nn.Linear(128,128),
torch.nn.ReLU(),
BN(128),
torch.nn.Dropout(0.5)
)
self.lin3 = torch.nn.Sequential(
torch.nn.Linear(128,128),
torch.nn.ReLU(),
BN(128),
torch.nn.Dropout(0.5),
)
self.output = torch.nn.Sequential(
torch.nn.Linear(128, 10)
)
def __init__(
self,
in_channels,
out_channels,
dim,
kernel_size,
hidden_channels=None,
dilation=1,
bias=True,
**kwargs,
):
super(XConv, self).__init__()
self.in_channels = in_channels
if hidden_channels is None:
hidden_channels = in_channels // 4
assert hidden_channels > 0
self.hidden_channels = hidden_channels
self.out_channels = out_channels
self.dim = dim
self.kernel_size = kernel_size
self.dilation = dilation
self.kwargs = kwargs
C_in, C_delta, C_out = in_channels, hidden_channels, out_channels
D, K = dim, kernel_size
self.mlp1 = S(
L(dim, C_delta),
ELU(),
BN(C_delta),
L(C_delta, C_delta),
ELU(),
BN(C_delta),
Reshape(-1, K, C_delta),
)
self.mlp2 = S(
L(D * K, K**2),
ELU(),
BN(K**2),
Reshape(-1, K, K),
Conv1d(K, K**2, K, groups=K),
ELU(),
BN(K**2),
Reshape(-1, K, K),
Conv1d(K, K**2, K, groups=K),
BN(K**2),
Reshape(-1, K, K),
)
C_in = C_in + C_delta
depth_multiplier = int(ceil(C_out / C_in))
self.conv = S(
Conv1d(C_in, C_in * depth_multiplier, K, groups=C_in),
Reshape(-1, C_in * depth_multiplier),
L(C_in * depth_multiplier, C_out, bias=bias),
)
self.reset_parameters()
def __init__(self, params):
super(CVAE, self).__init__()
self.model_str = 'CVAE'
self.is_cuda = False
self.latent_dim = latent_dim = params.get('latent_dim', 2)
self.hdim = hdim = params.get('hdim', 100)
self.batchnorm = params.get('batchnorm', True)
# encoder
self.fc1 = fc(784 + 10, hdim)
if self.batchnorm:
self.bn_1 = BN(hdim, momentum=.9)
self.fc_mu = fc(hdim, latent_dim) # output the mean of z
if self.batchnorm:
self.bn_mu = BN(latent_dim, momentum=.9)
self.fc_logvar = fc(hdim,
latent_dim) # output the log of the variance of z
if self.batchnorm:
self.bn_logvar = BN(latent_dim, momentum=.9)
# decoder
self.fc2 = fc(latent_dim + 10, hdim)
if self.batchnorm:
self.bn_2 = BN(hdim, momentum=.9)
self.fc3 = fc(hdim, 784)
if self.batchnorm:
self.bn_3 = BN(784, momentum=.9)
def __init__(self, dataset, num_layers, hidden, mode='cat'):
super(GIN0WithJK, self).__init__()
self.conv1 = GINConv(Sequential(
Linear(dataset.num_features, hidden),
ReLU(),
Linear(hidden, hidden),
ReLU(),
BN(hidden),
),
train_eps=False)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(
GINConv(Sequential(
Linear(hidden, hidden),
ReLU(),
Linear(hidden, hidden),
ReLU(),
BN(hidden),
),
train_eps=False))
self.jump = JumpingKnowledge(mode)
if mode == 'cat':
self.lin1 = Linear(num_layers * hidden, hidden)
else:
self.lin1 = Linear(hidden, hidden)
self.lin2 = Linear(hidden, dataset.num_classes)
def __init__(self, dataset, num_layers, hidden1, hidden2, deltas, elasticity=0.01, num_iterations = 30):
super(cut_MPNN, self).__init__()
self.hidden1 = hidden1
self.hidden2 = hidden2
self.conv1 = GINConv(Sequential(
Linear(1, self.hidden1),
ReLU(),
Linear(self.hidden1, self.hidden1),
ReLU(),
BN( self.hidden1),
),train_eps=False)
self.num_iterations = num_iterations
self.convs = torch.nn.ModuleList()
self.deltas = deltas
self.numlayers = num_layers
self.elasticity = elasticity
self.bns = torch.nn.ModuleList()
for i in range(num_layers-1):
self.bns.append(BN( self.hidden1))
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(GINConv(Sequential(
Linear( self.hidden1, self.hidden1),
ReLU(),
Linear( self.hidden1, self.hidden1),
ReLU(),
BN(self.hidden1),
),train_eps=False))
self.conv2 = GATAConv( self.hidden1, self.hidden2 ,heads=8)
self.lin1 = Linear(8*self.hidden2, self.hidden1)
self.bn2 = BN(self.hidden1)
self.lin2 = Linear(self.hidden1, 1)
def __init__(self, features):
super().__init__()
self.c1 = Conv1d(features, int(features / 2), kernel_size=1)
self.c2 = Conv1d(int(features / 2), int(features / 2), kernel_size=1)
self.c3 = Conv1d(int(features / 2), features, kernel_size=1)
self.bn1 = BN(int(features))
self.bn2 = BN(int(features / 2))
def __init__(self, in_channels, out_channels, dim, kernel_size,
hidden_channels=None, dilation=1, bias=True, BiLinear=BiLinear, BiConv1d=BiConv1d, ifFirst=False, **kwargs):
super(BiXConv, self).__init__()
if knn_graph is None:
raise ImportError('`XConv` requires `torch-cluster`.')
self.in_channels = in_channels
if hidden_channels is None:
hidden_channels = in_channels // 4
assert hidden_channels > 0
self.hidden_channels = hidden_channels
self.out_channels = out_channels
self.dim = dim
self.kernel_size = kernel_size
self.dilation = dilation
self.kwargs = kwargs
C_in, C_delta, C_out = in_channels, hidden_channels, out_channels
D, K = dim, kernel_size
if ifFirst:
Lin1 = Lin
else:
Lin1 = BiLinear
self.mlp1 = S(
Lin1(dim, C_delta),
Hardtanh(),
BN(C_delta),
BiLinear(C_delta, C_delta),
Hardtanh(),
BN(C_delta),
Reshape(-1, K, C_delta),
)
self.mlp2 = S(
Lin1(D * K, K**2),
Hardtanh(),
BN(K**2),
Reshape(-1, K, K),
BiConv1d(K, K**2, K, groups=K),
Hardtanh(),
BN(K**2),
Reshape(-1, K, K),
BiConv1d(K, K**2, K, groups=K),
BN(K**2),
Reshape(-1, K, K),
)
C_in = C_in + C_delta
depth_multiplier = int(ceil(C_out / C_in))
self.conv = S(
BiConv1d(C_in, C_in * depth_multiplier, K, groups=C_in),
Reshape(-1, C_in * depth_multiplier),
BiLinear(C_in * depth_multiplier, C_out, bias=bias),
)
self.reset_parameters()
def __init__(self, edge_dim, dim_init, dim):
super(GINE0Conv, self).__init__(aggr="add")
self.edge_encoder = Sequential(Linear(edge_dim, dim_init), ReLU(),
Linear(dim_init, dim_init), ReLU(),
BN(dim_init))
self.mlp = Sequential(Linear(dim_init, dim), ReLU(), Linear(dim, dim),
ReLU(), BN(dim))
def MLP(channels,
batch_norm=True,
act='relu',
bn_kwargs={},
dropout=0.0,
dropout_position="right",
batchnorm_position="right",
bias=True):
if batch_norm:
# bad practice to mix these two
assert dropout == 0.0
if dropout > 0.0:
# bad practice to mix these two
assert not batch_norm
if isinstance(act, str) or act is None:
act = [act] * (len(channels) - 1)
if isinstance(batch_norm, bool):
batch_norm = [batch_norm] * (len(channels) - 1)
if isinstance(dropout, float):
dropout = [dropout] * (len(channels) - 1)
activation = []
for a in act:
if a is None:
activation.append(Identity)
elif a == 'relu':
activation.append(ReLU)
elif a == 'elu':
activation.append(ELU)
elif a == 'tanh':
activation.append(Tanh)
elif a == "prelu":
activation.append(PReLU)
else:
raise ValueError("unrecognized keyword: {}".format(act))
layers = []
for i in range(1, len(channels)):
if dropout[i - 1] > 0 and dropout_position == "left":
layers.append(Dropout(p=dropout[i - 1]))
layers.append(Lin(channels[i - 1], channels[i], bias=bias))
if batch_norm[i - 1] and batchnorm_position == "left":
layers.append(BN(channels[i], **bn_kwargs))
layers.append(activation[i - 1]())
if batch_norm[i - 1] and batchnorm_position == "right":
layers.append(BN(channels[i], **bn_kwargs))
if dropout[i - 1] > 0 and dropout_position == "right":
layers.append(Dropout(p=dropout[i - 1]))
return Seq(*layers)
def __init__(self, edge_dim, dim_init, dim):
super(GINEConv, self).__init__(aggr="add")
self.edge_encoder = Sequential(Linear(edge_dim, dim_init), ReLU(),
Linear(dim_init, dim_init), ReLU(),
BN(dim_init))
self.mlp = Sequential(Linear(dim_init, dim), ReLU(), Linear(dim, dim),
ReLU(), BN(dim))
self.eps = torch.nn.Parameter(torch.Tensor([0]))
self.initial_eps = 0
def __init__(self, in_channels: int, out_channels: int, dim: int,
kernel_size: int, hidden_channels: Optional[int] = None,
dilation: int = 1, bias: bool = True, num_workers: int = 1):
super(XConv, self).__init__()
if knn_graph is None:
raise ImportError('`XConv` requires `torch-cluster`.')
self.in_channels = in_channels
if hidden_channels is None:
hidden_channels = in_channels // 4
assert hidden_channels > 0
self.hidden_channels = hidden_channels
self.out_channels = out_channels
self.dim = dim
self.kernel_size = kernel_size
self.dilation = dilation
self.num_workers = num_workers
C_in, C_delta, C_out = in_channels, hidden_channels, out_channels
D, K = dim, kernel_size
self.mlp1 = S(
L(dim, C_delta),
ELU(),
BN(C_delta),
L(C_delta, C_delta),
ELU(),
BN(C_delta),
Reshape(-1, K, C_delta),
)
self.mlp2 = S(
L(D * K, K**2),
ELU(),
BN(K**2),
Reshape(-1, K, K),
Conv1d(K, K**2, K, groups=K),
ELU(),
BN(K**2),
Reshape(-1, K, K),
Conv1d(K, K**2, K, groups=K),
BN(K**2),
Reshape(-1, K, K),
)
C_in = C_in + C_delta
depth_multiplier = int(ceil(C_out / C_in))
self.conv = S(
Conv1d(C_in, C_in * depth_multiplier, K, groups=C_in),
Reshape(-1, C_in * depth_multiplier),
L(C_in * depth_multiplier, C_out, bias=bias),
)
self.reset_parameters()
def __init__(
self,
n_actions,
hidden_dim,
featurizer,
game_info,
player_id,
#neural_network_history,
#neural_network_loss,
learning_rate,
optimizer,
tensorboard=None,
grad_clip=None,
shared_network=None,
q_network=None,
cuda=False):
super(PiNetworkBN, self).__init__()
self.is_cuda = cuda
self.n_actions = n_actions
self.featurizer = featurizer
self.hidden_dim = hidden_dim
hdim = self.hidden_dim
# SHARE WEIGHTS
assert not (shared_network is not None and q_network is not None
), "you should provide either q_network or shared_network"
if q_network is not None:
self.shared_network = q_network.shared_network
else:
if shared_network is not None:
self.shared_network = shared_network
else:
self.shared_network = SharedNetworkBN(n_actions, hidden_dim)
for i in range(19, 27):
setattr(self, 'fc' + str(i),
getattr(self.shared_network, 'fc' + str(i)))
setattr(self, 'bn' + str(i),
getattr(self.shared_network, 'bn' + str(i)))
# LAST PERSONAL LAYERS
self.fc27 = fc(hdim, hdim)
self.bn27 = BN(hdim, momentum=.99)
self.fc28 = fc(hdim, n_actions)
self.bn28 = BN(n_actions, momentum=.99)
self.optim = optim.Adam(self.parameters(), lr=learning_rate)
if cuda:
self.cuda()
# for saving neural network history data
self.game_info = game_info
self.player_id = player_id # know the owner of the network
#self.neural_network_history = neural_network_history
#self.neural_network_loss = neural_network_loss
self.tensorboard = tensorboard
def __init__(self, params):
super(Discriminator, self).__init__()
self.model_str = 'WDisc'
self.h_dim = params.get('hidden_dim', 100)
self.batchnorm = False
# self.batchnorm = params.get('batchnorm', True)
self.fc1 = fc(784, self.h_dim)
self.fc2 = fc(self.h_dim, 1)
if self.batchnorm:
self.bn_1 = BN(self.h_dim, eps=1e-5, momentum=.9)
self.bn_2 = BN(1, eps=1e-5, momentum=.9)
def __init__(self, params):
super(Generator, self).__init__()
self.model_str = 'WGen'
self.latent_dim = params.get('latent_dim', 2)
self.h_dim = params.get('hidden_dim', 100)
self.batchnorm = params.get('batchnorm', True)
self.fc1 = fc(self.latent_dim, self.h_dim)
self.fc2 = fc(self.h_dim, 784)
if self.batchnorm:
self.bn_1 = BN(self.h_dim, eps=1e-5, momentum=.9)
self.bn_2 = BN(784, eps=1e-5, momentum=.9)
def __init__(self, inp_dim, inter_dim, oup_dim, cls):
super(GraphSAGE, self).__init__()
self.conv1 = SAGEConv(inp_dim, inter_dim)
self.bn1 = BN(inter_dim)
self.conv2 = SAGEConv(inter_dim, inter_dim)
self.bn2 = BN(inter_dim)
self.conv3 = SAGEConv(inter_dim, inter_dim)
self.bn3 = BN(inter_dim)
self.conv4 = SAGEConv(inter_dim, inter_dim)
self.bn4 = BN(inter_dim)
self.lin1 = torch.nn.Linear(inter_dim, inter_dim)
self.lin2 = torch.nn.Linear(inter_dim, inter_dim)
self.lin3 = torch.nn.Linear(inter_dim, oup_dim)
self.cls = cls
def __init__(self, n_actions, hidden_dim, cuda=False):
super(SharedNetworkBN, self).__init__()
self.n_actions = n_actions
self.hidden_dim = hidden_dim
hdim = hidden_dim
self.fc19 = fc(5 * 6 * 2, hdim)
self.bn19 = BN(hdim, momentum=.99)
self.fc20 = fc(5 * 6 * 2 + hdim, hdim)
self.bn20 = BN(hdim, momentum=.99)
self.fc21 = fc(5 * 6 * 2 + hdim, hdim)
self.bn21 = BN(hdim, momentum=.99)
self.fc22 = fc(5 * 6 * 2 + hdim, hdim)
self.bn22 = BN(hdim, momentum=.99)
self.fc23 = fc(hdim, hdim)
self.bn23 = BN(hdim, momentum=.99)
self.fc24 = fc(6, hdim)
self.bn24 = BN(hdim, momentum=.99)
self.fc25 = fc(3 * hdim, hdim)
self.bn25 = BN(hdim, momentum=.99)
self.fc26 = fc(hdim, hdim)
self.bn26 = BN(hdim, momentum=.99)
if cuda:
self.cuda()
def FirstBiMLP(channels,
batch_norm=True,
activation='ReLU',
bilinear='BiLinear'):
part1 = [
Seq(Lin(channels[0], channels[1]), activations[activation](),
BN(channels[1]))
]
part2 = [
Seq(biLinears[bilinear](channels[i - 1],
channels[i]), activations[activation](),
BN(channels[i])) for i in range(2, len(channels))
]
obj = part1 + part2
return Seq(*obj)
def __init__(self,
hidden_channels,
num_layers,
max_z,
train_dataset,
use_feature=False,
node_embedding=None,
dropout=0.5,
jk=True,
train_eps=False):
super(GIN, self).__init__()
self.use_feature = use_feature
self.node_embedding = node_embedding
self.max_z = max_z
self.z_embedding = Embedding(self.max_z, hidden_channels)
self.jk = jk
initial_channels = hidden_channels
if self.use_feature:
initial_channels += train_dataset.num_features
if self.node_embedding is not None:
initial_channels += node_embedding.embedding_dim
self.conv1 = GINConv(Sequential(
Linear(initial_channels, hidden_channels),
ReLU(),
Linear(hidden_channels, hidden_channels),
ReLU(),
BN(hidden_channels),
),
train_eps=train_eps)
self.convs = torch.nn.ModuleList()
for i in range(num_layers - 1):
self.convs.append(
GINConv(Sequential(
Linear(hidden_channels, hidden_channels),
ReLU(),
Linear(hidden_channels, hidden_channels),
ReLU(),
BN(hidden_channels),
),
train_eps=train_eps))
self.dropout = dropout
if self.jk:
self.lin1 = Linear(num_layers * hidden_channels, hidden_channels)
else:
self.lin1 = Linear(hidden_channels, hidden_channels)
self.lin2 = Linear(hidden_channels, 1)
def __init__(self, inp_dim, inter_dim, oup_dim, cls):
super(GAT, self).__init__()
self.conv1 = GATConv(inp_dim, inter_dim)
self.bn1 = BN(inter_dim)
self.conv2 = GATConv(inter_dim, inter_dim)
self.bn2 = BN(inter_dim)
self.conv3 = GATConv(inter_dim, inter_dim)
self.bn3 = BN(inter_dim)
self.conv4 = GATConv(inter_dim, inter_dim)
self.bn4 = BN(inter_dim)
#self.conv5 = GATConv(inter_dim, inter_dim)
#self.bn5 = BN(inter_dim)
self.lin1 = torch.nn.Linear(inter_dim, inter_dim)
self.lin2 = torch.nn.Linear(inter_dim, inter_dim)
self.lin3 = torch.nn.Linear(inter_dim, oup_dim)
self.cls = cls
def __init__(self,
input_size,
embedding_size,
n_classes,
pool_op='max',
same_size=False):
super(GCNConvNetBN, self).__init__()
channels = [input_size, 64, 64, 64, 128, 1024]
self.convs = nn.ModuleList()
batch_norm = True
for i in range(1, len(channels)):
if batch_norm:
self.convs.append(
Seq(GCN(channels[i - 1], channels[i]), ReLU(),
BN(channels[i])))
else:
self.convs.append(
Seq(GCN(channels[i - 1], channels[i]), ReLU()))
if pool_op == 'max':
self.pool = global_max_pool
self.mlp = MLP([1024, 512, 256, embedding_size])
self.fc = torch.nn.Linear(embedding_size, n_classes)
self.emb_size = embedding_size
self.same_size = same_size
self.embedding = None
print(self)
def __init__(self, n_layers, hidden_dim, input_dim, action_dim=2, gain=math.sqrt(2 / 1.01), activation=LeakyReLU(.01)):
super().__init__()
self.n_layers = n_layers
self.action_dim = action_dim
self.hidden_dim = hidden_dim
self.activation = activation
for l in range(n_layers - 1): # in the last block there is no u
if l > 0:
setattr(self, 'u' + str(l), t.nn.Linear(hidden_dim, hidden_dim))
else:
setattr(self, 'u' + str(l), t.nn.Linear(input_dim, hidden_dim))
if l < n_layers - 2: # the last u does not have activation nor BN
setattr(self, 'bn_u' + str(l), BN(hidden_dim, momentum=.9, eps=1e-3))
for l in range(n_layers):
output_dim = (l < n_layers - 1) * hidden_dim + (l == n_layers - 1) * 1 # the last z has dim 1 (Q value)
idim = (l > 0) * hidden_dim + (l == 0) * input_dim # the first block has input dim input dim, the next ones hidden dim
setattr(self, 'z_u' + str(l), t.nn.Linear(idim, output_dim))
setattr(self, 'z_au' + str(l), t.nn.Linear(idim, action_dim))
setattr(self, 'z_au_' + str(l), t.nn.Linear(action_dim, output_dim, bias=False))
if l > 0: # at the first block, z is not yet defined
setattr(self, 'z_zu' + str(l), t.nn.Linear(idim, hidden_dim))
setattr(self, 'z_zu_' + str(l), t.nn.Linear(hidden_dim, output_dim, bias=False))
self.initialize_weights_xavier(gain)
# enforce convexity (or rather concavity)
self.make_cvx()
def MLP(channels, batch_norm=True):
net = []
for i in range(1, len(channels)):
net.append(Lin(channels[i-1], channels[i]))
net.append(ReLU())
net.append(BN(channels[i]))
return Seq(*net)
def MLP(channels, activation=nn.LeakyReLU(0.2), bn_momentum=0.1, bias=True):
return Seq(
*[
Seq(Lin(channels[i - 1], channels[i], bias=bias), BN(channels[i], momentum=bn_momentum), activation)
for i in range(1, len(channels))
]
)
def MLP(channels, batch_norm=True):
return Seq(*[
Seq(Lin(channels[i - 1], channels[i]),
BN(channels[i]),
ReLU())
for i in range(1, len(channels))
])
def __init__(self, hidden, config, **kwargs):
super(CombAConv, self).__init__(aggr='add', **kwargs)
if config.fea_activation == 'ELU':
self.fea_activation = ELU()
elif config.fea_activation == 'ReLU':
self.fea_activation = ReLU()
self.fea_mlp = Sequential(
Linear(hidden, hidden),
ReLU(),
Linear(hidden, hidden),
self.fea_activation)
self.aggr_mlp = Sequential(
Linear(hidden * 2, hidden),
Tanh())
if config.BN == 'Y':
self.BN = BN(hidden)
else:
self.BN = None
self.edge_encoder = torch.nn.Linear(7, hidden)
self.reset_parameters()
def __init__(self, hidden, num_aggr, config, **kwargs):
super(ExpandingBConv, self).__init__(aggr='add', **kwargs)
self.hidden = hidden
self.num_aggr = num_aggr
if config.fea_activation == 'ELU':
self.fea_activation = ELU()
elif config.fea_activation == 'ReLU':
self.fea_activation = ReLU()
self.fea_mlp = Sequential(
Linear(hidden * self.num_aggr, hidden),
ReLU(),
Linear(hidden, hidden),
self.fea_activation)
self.aggr_mlp = Sequential(
Linear(hidden * 2, self.num_aggr),
Tanh())
self.edge_encoder = torch.nn.Linear(5, hidden)
if config.BN == 'Y':
self.BN = BN(hidden)
else:
self.BN = None
self.reset_parameters()
def vggnet(self, num_classes=21, groups=2):
self.conv.add_module(
'conv1_s1', nn.Conv2d(3, 96, kernel_size=11, stride=4, padding=0))
self.conv.add_module('relu1_s1', nn.ReLU(inplace=True))
# self.conv.add_module('bn1_s1',nn.BatchNorm2d(96))
self.conv.add_module('pool1_s1', nn.MaxPool2d(kernel_size=3, stride=2))
self.conv.add_module('lrn1_s1',
BN(local_size=5, alpha=0.0001, beta=0.75))
self.conv.add_module(
'conv2_s1',
nn.Conv2d(96, 256, kernel_size=5, padding=2, groups=groups))
self.conv.add_module('relu2_s1', nn.ReLU(inplace=True))
# self.conv.add_module('bn2_s1',nn.BatchNorm2d(256))
self.conv.add_module('pool2_s1', nn.MaxPool2d(kernel_size=3, stride=2))
self.conv.add_module('lrn2_s1',
BN(local_size=5, alpha=0.0001, beta=0.75))
self.conv.add_module('conv3_s1',
nn.Conv2d(256, 384, kernel_size=3, padding=1))
self.conv.add_module('relu3_s1', nn.ReLU(inplace=True))
# self.conv.add_module('bn3_s1',nn.BatchNorm2d(384))
self.conv.add_module(
'conv4_s1',
nn.Conv2d(384, 384, kernel_size=3, padding=1, groups=groups))
# self.conv.add_module('bn4_s1',nn.BatchNorm2d(384))
self.conv.add_module('relu4_s1', nn.ReLU(inplace=True))
self.conv.add_module(
'conv5_s1',
nn.Conv2d(384, 256, kernel_size=3, padding=1, groups=groups))
# self.conv.add_module('bn5_s1',nn.BatchNorm2d(256))
self.conv.add_module('relu5_s1', nn.ReLU(inplace=True))
self.conv.add_module('pool5_s1', nn.MaxPool2d(kernel_size=3, stride=2))
self.fc6.add_module('fc6_s1', nn.Linear(256 * 6 * 6, 4096))
self.fc6.add_module('relu6_s1', nn.ReLU(inplace=True))
self.fc6.add_module('drop6_s1', nn.Dropout(p=0.5))
self.fc7 = nn.Sequential()
self.fc7.add_module('fc7', nn.Linear(4096, 4096))
self.fc7.add_module('relu7', nn.ReLU(inplace=True))
self.fc7.add_module('drop7', nn.Dropout(p=0.5))
self.classifier = nn.Sequential()
self.classifier.add_module('fc8', nn.Linear(4096, num_classes))
def __init__(self, num_classes, num_layers, feat_dim, embed_dim, jk_layer,
process_step, dropout):
super(Net, self).__init__()
self.dropout = dropout
self.num_layers = num_layers
self.convs = torch.nn.ModuleList()
for i in range(num_layers):
if i == 0:
self.convs.append(
AGGINConv(Sequential(Linear(feat_dim, embed_dim), ReLU(),
Linear(embed_dim, embed_dim), ReLU(),
BN(embed_dim)),
train_eps=True,
dropout=self.dropout))
else:
self.convs.append(
AGGINConv(Sequential(Linear(embed_dim, embed_dim), ReLU(),
Linear(embed_dim, embed_dim), ReLU(),
BN(embed_dim)),
train_eps=True,
dropout=self.dropout))
if jk_layer.isdigit():
jk_layer = int(jk_layer)
self.jump = JumpingKnowledge(mode='lstm',
channels=embed_dim,
num_layers=jk_layer)
self.gpl = (Set2Set(embed_dim, processing_steps=process_step))
self.fc1 = Linear(2 * embed_dim, embed_dim)
# self.fc1 = Linear(embed_dim, embed_dim)
self.fc2 = Linear(embed_dim, num_classes)
elif jk_layer == 'cat':
self.jump = JumpingKnowledge(mode=jk_layer)
self.gpl = (Set2Set(num_layers * embed_dim,
processing_steps=process_step))
self.fc1 = Linear(2 * embed_dim, embed_dim)
# self.fc1 = Linear(num_layers * embed_dim, embed_dim)
self.fc2 = Linear(embed_dim, num_classes)
elif jk_layer == 'max':
self.jump = JumpingKnowledge(mode=jk_layer)
self.gpl = (Set2Set(embed_dim, processing_steps=process_step))
self.fc1 = Linear(2 * embed_dim, embed_dim)
# self.fc1 = Linear(embed_dim, embed_dim)
self.fc2 = Linear(embed_dim, num_classes)
def BwMLP(channels, batch_norm=True, activation='ReLU', bilinear='BiLinear'):
return Seq(*[
Seq(
biLinears[bilinear](channels[i -
1], channels[i], binary_act=False),
activations[activation](), BN(channels[i]))
for i in range(1, len(channels))
])
def MLP(channels, batch_norm=True):
"""Multi-layer perceptron, with ReLU non-linearities and batch normalization."""
return Seq(*[
Seq(
Lin(channels[i - 1], channels[i]),
BN(channels[i]) if batch_norm else nn.Identity(),
LeakyReLU(negative_slope=0.2),
) for i in range(1, len(channels))
])
