def create(self) -> Module:
return ReLU(self.inplace)
def __init__(self, i_dim, h_dim, e_dim, times):
super(BaselineRegressNet, self).__init__()
self.lin0 = Sequential(Linear(i_dim, h_dim), ReLU())
self.conv_layer = ConvLayer(h_dim, e_dim, times)
self.lin1 = Sequential(Linear(h_dim, h_dim), ReLU(), Linear(h_dim, 1))
def __init__(self, h_dim, e_dim, times=3):
super(ConvLayer, self).__init__()
nn = Sequential(Linear(e_dim, h_dim), ReLU(), Linear(h_dim, h_dim * h_dim))
self.conv = NNConv(h_dim, h_dim, nn, aggr='mean')
self.gru = GRU(h_dim, h_dim)
self.times = times
def __init__(self, MODEL_PARAMS):
super(DGN, self).__init__()
self.model_params = MODEL_PARAMS
nn = Sequential(Linear(self.model_params["Linear1"]["in"], self.model_params["Linear1"]["out"]), ReLU())
self.conv1 = NNConv(self.model_params["conv1"]["in"], self.model_params["conv1"]["out"], nn, aggr='mean')
nn = Sequential(Linear(self.model_params["Linear2"]["in"], self.model_params["Linear2"]["out"]), ReLU())
self.conv2 = NNConv(self.model_params["conv2"]["in"], self.model_params["conv2"]["out"], nn, aggr='mean')
nn = Sequential(Linear(self.model_params["Linear3"]["in"], self.model_params["Linear3"]["out"]), ReLU())
self.conv3 = NNConv(self.model_params["conv3"]["in"], self.model_params["conv3"]["out"], nn, aggr='mean')
def __init__(self, dim):
super(NetGIN, self).__init__()
num_features = 445
nn1_1 = Sequential(Linear(num_features, dim), ReLU(), Linear(dim, dim))
nn1_2 = Sequential(Linear(num_features, dim), ReLU(), Linear(dim, dim))
self.conv1_1 = GINConv(nn1_1, train_eps=True)
self.conv1_2 = GINConv(nn1_2, train_eps=True)
self.bn1 = torch.nn.BatchNorm1d(dim)
self.mlp_1 = Sequential(Linear(2 * dim, dim), ReLU(), Linear(dim, dim))
nn2_1 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
nn2_2 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
self.conv2_1 = GINConv(nn2_1, train_eps=True)
self.conv2_2 = GINConv(nn2_2, train_eps=True)
self.bn2 = torch.nn.BatchNorm1d(dim)
self.mlp_2 = Sequential(Linear(2 * dim, dim), ReLU(), Linear(dim, dim))
nn3_1 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
nn3_2 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
self.conv3_1 = GINConv(nn3_1, train_eps=True)
self.conv3_2 = GINConv(nn3_2, train_eps=True)
self.bn3 = torch.nn.BatchNorm1d(dim)
self.mlp_3 = Sequential(Linear(2 * dim, dim), ReLU(), Linear(dim, dim))
nn4_1 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
nn4_2 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
self.conv4_1 = GINConv(nn4_1, train_eps=True)
self.conv4_2 = GINConv(nn4_2, train_eps=True)
self.bn4 = torch.nn.BatchNorm1d(dim)
self.mlp_4 = Sequential(Linear(2 * dim, dim), ReLU(), Linear(dim, dim))
self.fc1 = Linear(4 * dim, dim)
self.fc2 = Linear(dim, dim)
self.fc3 = Linear(dim, dim)
self.fc4 = Linear(dim, 1)
def __init__(self):
super(XENON_GCNN, self).__init__()
self.lin = Sequential(Linear(FINAL_OUT * 127, 16), ReLU(),
Linear(16, 2))
self.conv1 = GCNConv(3, 16)
self.conv2 = GCNConv(16, FINAL_OUT)
def __init__(self, num_classes, is_test=False, config=None, num_lstm=5):
"""Compose a SSD model using the given components.
"""
super(ResNetLSTM3, self).__init__()
# alpha = 1
# alpha_base = alpha
# alpha_ssd = 0.5 * alpha
# alpha_lstm = 0.25 * alpha
resnet = resnet101(pretrained=True)
all_modules = list(resnet.children())
modules = all_modules[:-4]
self.base_net = nn.Sequential(*modules)
modules = all_modules[6:7]
self.conv_final = nn.Sequential(*modules)
self.num_classes = num_classes
self.is_test = is_test
self.config = config
# lstm_layers = [BottleNeckLSTM(1024, 256),
# BottleNeckLSTM(256, 64),
# BottleNeckLSTM(64, 16),
# ConvLSTMCell(16, 16),
# ConvLSTMCell(16, 16)]
lstm_layers = [
BottleNeckLSTM(1024, 1024),
BottleNeckLSTM(512, 512),
BottleNeckLSTM(256, 256),
ConvLSTMCell(256, 256),
ConvLSTMCell(256, 256)
]
self.lstm_layers = nn.ModuleList(
[lstm_layers[i] for i in range(num_lstm)])
self.extras = ModuleList([
Sequential(
Conv2d(in_channels=1024, out_channels=256, kernel_size=1),
ReLU(),
Conv2d(in_channels=256,
out_channels=512,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=512, out_channels=128, kernel_size=1),
ReLU(),
Conv2d(in_channels=128,
out_channels=256,
kernel_size=3,
stride=2,
padding=1), ReLU()),
Sequential(
Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(), Conv2d(in_channels=128,
out_channels=256,
kernel_size=3), ReLU()),
Sequential(
Conv2d(in_channels=256, out_channels=128, kernel_size=1),
ReLU(), Conv2d(in_channels=128,
out_channels=256,
kernel_size=3), ReLU())
])
self.regression_headers = ModuleList([
Conv2d(in_channels=512,
out_channels=4 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=1024,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=512,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * 4,
kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
self.classification_headers = ModuleList([
Conv2d(in_channels=512,
out_channels=4 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=1024,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=512,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=6 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=256,
out_channels=4 * num_classes,
kernel_size=3,
padding=1), # TODO: change to kernel_size=1, padding=0?
])
self.device = torch.device(
f"cuda:{args.gpu}" if torch.cuda.is_available() else "cpu")
if is_test:
self.config = config
self.priors = config.priors.to(self.device)
def test_run_funcs_model_forward():
funcs = ModuleRunFuncs()
assert funcs.model_forward.__name__ == tensors_module_forward.__name__
out = funcs.model_forward(torch.randn(8, 4), Sequential(Linear(4, 8), ReLU()))
assert out.shape[0] == 8
assert out.shape[1] == 8
def test_run_funcs_model_backward():
funcs = ModuleRunFuncs()
assert funcs.model_backward.__name__ == def_model_backward.__name__
losses = {DEFAULT_LOSS_KEY: default_calcs_for_backwards()}
module = Sequential(Linear(8, 8), ReLU())
funcs.model_backward(losses, module)
# PyTorch imports
from torch import cat
from torch.nn import Module, Sequential, Linear, Conv2d, ConvTranspose2d, BatchNorm2d, ReLU
from torch.nn.init import kaiming_normal_, constant_
# -
# WatChMaL imports
from models import resnetblocks
# Global variables
__all__ = [
'etworesnet18', 'etworesnet34', 'etworesnet50', 'etworesnet101',
'etworesnet152', 'dtworesnet18', 'dtworesnet34', 'dtworesnet50',
'dtworesnet101', 'dtworesnet152'
]
_RELU = ReLU()
# -------------------------------
# Encoder architecture layers
# -------------------------------
class EtworesNet(Module):
def __init__(self,
block,
layers,
num_input_channels,
num_latent_dims,
zero_init_residual=False):
super().__init__()
def test_run_results(name, loss_tensors, batch_size, expected_mean, expected_std):
results = ModuleRunResults()
for loss in loss_tensors:
results.append({name: loss}, batch_size)
mean = results.result_mean(name)
std = results.result_std(name)
assert len(results.result(name)) == len(loss_tensors)
assert (mean - expected_mean).abs() < 0.0001
assert (std - expected_std).abs() < 0.0001
TEST_MODULE = Sequential(
Linear(8, 16), ReLU(), Linear(16, 32), ReLU(), Linear(32, 1), ReLU()
)
class DatasetImpl(Dataset):
def __init__(self, length: int):
self._length = length
self._x_feats = [torch.randn(8) for _ in range(length)]
self._y_labs = [torch.randn(1) for _ in range(length)]
def __getitem__(self, index: int):
return self._x_feats[index], self._y_labs[index]
def __len__(self) -> int:
return self._length
def __init__(self,
n_output=1,
num_features_xd=78,
num_features_xt=25,
n_filters=32,
embed_dim=128,
output_dim=128,
dropout=0.2):
super(GINConvNetClassification, self).__init__()
dim = 32
self.n_output = n_output
# variables to store gradient
self.grads = {}
self.grad_x = 0
self.grad_embedded_xt = 0
self.grad_conv_xt = 0
self.grad_conv = 0
self.conv = 0
self.conv_xt = 0
self.dropout = nn.Dropout(dropout)
self.relu = nn.ReLU()
# convolution layers for drug
nn1 = Sequential(Linear(num_features_xd, dim), ReLU(),
Linear(dim, dim))
self.conv1 = GINConv(nn1)
self.bn1 = torch.nn.BatchNorm1d(dim)
nn2 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
self.conv2 = GINConv(nn2)
self.bn2 = torch.nn.BatchNorm1d(dim)
nn3 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
self.conv3 = GINConv(nn3)
self.bn3 = torch.nn.BatchNorm1d(dim)
nn4 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
self.conv4 = GINConv(nn4)
self.bn4 = torch.nn.BatchNorm1d(dim)
nn5 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim))
self.conv5 = GINConv(nn5)
self.bn5 = torch.nn.BatchNorm1d(dim)
#linear layer for drug
self.fc1_xd = Linear(dim, output_dim)
# embed layer for protein
self.embedding_xt = nn.Embedding(num_features_xt + 1, embed_dim)
self.embedding_xt.weight.requires_grad = False
# 1D convolution on protein sequence
self.conv_xt_1 = nn.Conv1d(in_channels=1000,
out_channels=n_filters,
kernel_size=8)
# linear layer for protein
self.fc1_xt = nn.Linear(32 * 121, output_dim)
# combined layers
self.fc1 = nn.Linear(256, 1024)
self.fc2 = nn.Linear(1024, 256)
self.classifyout = nn.Linear(
256, 2 * self.n_output) # n_output = 2 for classification task
self.prefix = prefix
def __len__(self):
return len(os.listdir(self.datadir))
def __getitem__(self, idx):
if type(idx) is slice:
res = [
self.__getitem__(i) for i in range(
*list(filter(None, [idx.start, idx.stop, idx.step])))
]
return res
fname = os.path.join(self.datadir,
self.prefix + '_' + f"{idx:06}" + '.xyz')
dat = process(fname)
nx_graph = rdkit_process(dat)
return from_networkx(nx_graph)
qm9 = QM9Dataset('xyzfiles', 'dsgdb9nsd')
nn = Seq(Lin(4, 32), ReLU(), Lin(32, 1))
conv = GINEConv(nn, train_eps=True, edge_dim=1)
for i in range(1, 11):
mol = qm9[i]
print(mol.bond_type)
processed = conv(mol.coord.float(), mol.edge_index,
mol.bond_type.float().view(-1, 1))
print(processed)
def create_Mb_Tiny_RFB_fd(num_classes, is_test=False, device="cuda"):
base_net = Mb_Tiny_RFB(2)
base_net_model = base_net.model # disable dropout layer
source_layer_indexes = [8, 11, 13]
extras = ModuleList([
Sequential(
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=base_net.base_channel * 4,
kernel_size=1), ReLU(),
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=base_net.base_channel * 16,
kernel_size=3,
stride=2,
padding=1), ReLU())
])
regression_headers = ModuleList([
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=3 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 8,
out_channels=2 * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 16,
out_channels=2 * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=3 * 4,
kernel_size=3,
padding=1)
])
classification_headers = ModuleList([
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=3 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 8,
out_channels=2 * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 16,
out_channels=2 * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=3 * num_classes,
kernel_size=3,
padding=1)
])
return SSD(num_classes,
base_net_model,
source_layer_indexes,
extras,
classification_headers,
regression_headers,
is_test=is_test,
config=config,
device=device)
def __init__(self, i, o):
super(Residual, self).__init__()
self.fc = Linear(i, o)
self.bn = BatchNorm1d(o)
self.relu = ReLU()
def test_def_model_backward():
losses = {DEFAULT_LOSS_KEY: default_calcs_for_backwards()}
module = Sequential(Linear(8, 8), ReLU())
def_model_backward(losses, module)
def __init__(self):
super(Stage_x, self).__init__()
self.conv1_L1 = Conv2d(in_channels=185,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv2_L1 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv3_L1 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv4_L1 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv5_L1 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv6_L1 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=1,
stride=1,
padding=0)
self.conv7_L1 = Conv2d(in_channels=128,
out_channels=38,
kernel_size=1,
stride=1,
padding=0)
self.conv1_L2 = Conv2d(in_channels=185,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv2_L2 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv3_L2 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv4_L2 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv5_L2 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=7,
stride=1,
padding=3)
self.conv6_L2 = Conv2d(in_channels=128,
out_channels=128,
kernel_size=1,
stride=1,
padding=0)
self.conv7_L2 = Conv2d(in_channels=128,
out_channels=19,
kernel_size=1,
stride=1,
padding=0)
self.relu = ReLU()
def __init__(self, n_features, n_embeddings, n_units):
super(Net, self).__init__()
self.n_features = n_features
self.n_embeddings = n_embeddings
self.n_units = n_units
self.encoder = ModuleDict({
'gru':
GRU(self.n_features,
self.n_units,
3,
dropout=0.1,
bidirectional=True,
batch_first=True),
'linear':
Linear(2 * self.n_units, self.n_embeddings)
})
self.decoder = ModuleDict({
'gru':
GRU(self.n_embeddings,
self.n_units,
3,
dropout=0.1,
bidirectional=True,
batch_first=True),
'linear':
Linear(2 * self.n_units, self.n_features)
})
self.decoder1 = ModuleDict({
'gru':
GRU(16,
self.n_units,
3,
dropout=0.1,
bidirectional=True,
batch_first=True),
'linear':
Linear(2 * self.n_units, 16)
})
self.decoder2 = ModuleDict({
'gru':
GRU(10,
self.n_units,
3,
dropout=0.1,
bidirectional=True,
batch_first=True),
'linear':
Linear(2 * self.n_units, 10)
})
self.decoder3 = ModuleDict({
'gru':
GRU(self.n_embeddings,
self.n_units,
3,
dropout=0.1,
bidirectional=True,
batch_first=True),
'linear':
Linear(2 * self.n_units, 1)
})
self.decoder4 = ModuleDict({
'gru':
GRU(self.n_embeddings,
self.n_units,
3,
dropout=0.1,
bidirectional=True,
batch_first=True),
'linear':
Linear(2 * self.n_units, 1)
})
self.relu = ReLU()
self.sigmoid = Sigmoid()
def __init__(self,
in_channels,
channels,
kernel_size,
stride=(1, 1),
padding=(0, 0),
dilation=(1, 1),
groups=1,
bias=True,
radix=2,
reduction_factor=4,
rectify=False,
rectify_avg=False,
norm=None,
dropblock_prob=0.0,
**kwargs):
super(SplAtConv2d, self).__init__()
padding = _pair(padding)
self.rectify = rectify and (padding[0] > 0 or padding[1] > 0)
self.rectify_avg = rectify_avg
inter_channels = max(in_channels * radix // reduction_factor, 32)
self.radix = radix
self.cardinality = groups
self.channels = channels
self.dropblock_prob = dropblock_prob
if self.rectify:
from rfconv import RFConv2d
self.conv = RFConv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
average_mode=rectify_avg,
**kwargs)
else:
self.conv = Conv2d(in_channels,
channels * radix,
kernel_size,
stride,
padding,
dilation,
groups=groups * radix,
bias=bias,
**kwargs)
self.use_bn = norm is not None
if self.use_bn:
self.bn0 = get_norm(norm, channels * radix)
self.relu = ReLU(inplace=True)
self.fc1 = Conv2d(channels, inter_channels, 1, groups=self.cardinality)
if self.use_bn:
self.bn1 = get_norm(norm, inter_channels)
self.fc2 = Conv2d(inter_channels,
channels * radix,
1,
groups=self.cardinality)
if dropblock_prob > 0.0:
self.dropblock = DropBlock2D(dropblock_prob, 3)
self.rsoftmax = rSoftMax(radix, groups)
def __new__(cls, ndim):
ind, hd1, hd2, hd3 = ndim
net = Sequential(Linear(ind, hd1), ReLU(), Linear(hd1, hd2), ReLU(),
Linear(hd2, hd3), ReLU())
return net
def test_conv_bn_relu(
self,
batch_size,
input_channels_per_group,
height,
width,
output_channels_per_group,
groups,
kernel_h,
kernel_w,
stride_h,
stride_w,
pad_h,
pad_w,
dilation,
padding_mode,
use_relu,
eps,
momentum,
freeze_bn
):
# **** WARNING: This is used to temporarily disable MKL-DNN convolution due
# to a bug: https://github.com/pytorch/pytorch/issues/23825
# Once this bug is fixed, this context manager as well as its callsites
# should be removed!
with torch.backends.mkldnn.flags(enabled=False):
input_channels = input_channels_per_group * groups
output_channels = output_channels_per_group * groups
dilation_h = dilation_w = dilation
conv_op = Conv2d(
input_channels,
output_channels,
(kernel_h, kernel_w),
(stride_h, stride_w),
(pad_h, pad_w),
(dilation_h, dilation_w),
groups,
False, # No bias
padding_mode
).to(dtype=torch.double)
bn_op = BatchNorm2d(output_channels, eps, momentum).to(dtype=torch.double)
relu_op = ReLU()
cls = ConvBnReLU2d if use_relu else ConvBn2d
qat_op = cls(
input_channels,
output_channels,
(kernel_h, kernel_w),
(stride_h, stride_w),
(pad_h, pad_w),
(dilation_h, dilation_w),
groups,
None, # bias
padding_mode,
eps,
momentum,
freeze_bn=True,
qconfig=default_qat_qconfig
).to(dtype=torch.double)
qat_op.apply(torch.quantization.disable_fake_quant)
if freeze_bn:
qat_op.apply(torch.nn.intrinsic.qat.freeze_bn_stats)
else:
qat_op.apply(torch.nn.intrinsic.qat.update_bn_stats)
# align inputs and internal parameters
input = torch.randn(batch_size, input_channels, height, width, dtype=torch.double, requires_grad=True)
conv_op.weight = torch.nn.Parameter(qat_op.weight.detach())
bn_op.running_mean = qat_op.bn.running_mean.clone()
bn_op.running_var = qat_op.bn.running_var.clone()
bn_op.weight = torch.nn.Parameter(qat_op.bn.weight.detach())
bn_op.bias = torch.nn.Parameter(qat_op.bn.bias.detach())
def compose(functions):
# functions are reversed for natural reading order
return reduce(lambda f, g: lambda x: f(g(x)), functions[::-1], lambda x: x)
if not use_relu:
def relu_op(x):
return x
if freeze_bn:
def ref_op(x):
x = conv_op(x)
x = (x - bn_op.running_mean.reshape([1, -1, 1, 1])) * \
(bn_op.weight / torch.sqrt(bn_op.running_var + bn_op.eps)) \
.reshape([1, -1, 1, 1]) + bn_op.bias.reshape([1, -1, 1, 1])
x = relu_op(x)
return x
else:
ref_op = compose([conv_op, bn_op, relu_op])
input_clone = input.clone().detach().requires_grad_()
for i in range(2):
result_ref = ref_op(input)
result_actual = qat_op(input_clone)
self.assertEqual(result_ref, result_actual)
# backward
dout = torch.randn(result_ref.size(), dtype=torch.double)
loss = (result_ref - dout).sum()
loss.backward()
input_grad_ref = input.grad.cpu()
weight_grad_ref = conv_op.weight.grad.cpu()
gamma_grad_ref = bn_op.weight.grad.cpu()
beta_grad_ref = bn_op.bias.grad.cpu()
running_mean_ref = bn_op.running_mean
running_var_ref = bn_op.running_var
num_batches_tracked_ref = bn_op.num_batches_tracked
loss = (result_actual - dout).sum()
loss.backward()
input_grad_actual = input_clone.grad.cpu()
weight_grad_actual = qat_op.weight.grad.cpu()
gamma_grad_actual = qat_op.bn.weight.grad.cpu()
beta_grad_actual = qat_op.bn.bias.grad.cpu()
running_mean_actual = qat_op.bn.running_mean
running_var_actual = qat_op.bn.running_var
num_batches_tracked_actual = qat_op.bn.num_batches_tracked
precision = 1e-10
self.assertEqual(input_grad_ref, input_grad_actual, atol=precision, rtol=0)
self.assertEqual(weight_grad_ref, weight_grad_actual, atol=precision, rtol=0)
self.assertEqual(gamma_grad_ref, gamma_grad_actual, atol=precision, rtol=0)
self.assertEqual(beta_grad_ref, beta_grad_actual, atol=precision, rtol=0)
self.assertEqual(num_batches_tracked_ref, num_batches_tracked_actual, atol=precision, rtol=0)
self.assertEqual(running_mean_ref, running_mean_actual, atol=precision, rtol=0)
self.assertEqual(running_var_ref, running_var_actual, atol=precision, rtol=0)
def DeConv2D(in_channels, out_channels):
return Sequential(
ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2),
ReLU(inplace=True),
)
input_nodes=val_input_nodes,
**kwargs)
else:
train_loader = HGTLoader(data,
num_samples=[1024] * 4,
shuffle=True,
input_nodes=train_input_nodes,
**kwargs)
val_loader = HGTLoader(data,
num_samples=[1024] * 4,
input_nodes=val_input_nodes,
**kwargs)
model = Sequential('x, edge_index', [
(SAGEConv((-1, -1), 64), 'x, edge_index -> x'),
ReLU(inplace=True),
(SAGEConv((-1, -1), 64), 'x, edge_index -> x'),
ReLU(inplace=True),
(Linear(-1, dataset.num_classes), 'x -> x'),
])
model = to_hetero(model, data.metadata(), aggr='sum').to(device)
@torch.no_grad()
def init_params():
# Initialize lazy parameters via forwarding a single batch to the model:
batch = next(iter(train_loader))
batch = batch.to(device, 'edge_index')
model(batch.x_dict, batch.edge_index_dict)
def forward(self, y_pred_real, y_pred_fake):
return mn(ReLU()(1.0 - (y_pred_real - mn(y_pred_fake))) +
ReLU()(1.0 + (y_pred_fake - mn(y_pred_real)))) / 2
def create_mb_tiny_fd(num_classes, is_test=False, device="cuda"):
base_net = Mb_Tiny(num_classes)
base_net_model = base_net.model # disable dropout layer
prior_nums = [len(item) for item in config.min_boxes_w]
print('prior_nums in create_mb_tiny_fd: ', prior_nums)
print('num_classes in create_mb_tiny_fd: ', num_classes)
source_layer_indexes = [8, 11, 13]
extras = ModuleList([
Sequential(
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=base_net.base_channel * 4,
kernel_size=1), ReLU(),
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=base_net.base_channel * 16,
kernel_size=3,
stride=2,
padding=1), ReLU())
])
regression_headers = ModuleList([
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=prior_nums[0] * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 8,
out_channels=prior_nums[1] * 4,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 16,
out_channels=prior_nums[2] * 4,
kernel_size=3,
padding=1),
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=prior_nums[3] * 4,
kernel_size=3,
padding=1)
])
classification_headers = ModuleList([
SeperableConv2d(in_channels=base_net.base_channel * 4,
out_channels=prior_nums[0] * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 8,
out_channels=prior_nums[1] * num_classes,
kernel_size=3,
padding=1),
SeperableConv2d(in_channels=base_net.base_channel * 16,
out_channels=prior_nums[2] * num_classes,
kernel_size=3,
padding=1),
Conv2d(in_channels=base_net.base_channel * 16,
out_channels=prior_nums[3] * num_classes,
kernel_size=3,
padding=1)
])
return SSD(num_classes,
base_net_model,
source_layer_indexes,
extras,
classification_headers,
regression_headers,
is_test=is_test,
config=config,
device=device)
def __init__(self):
super(Net, self).__init__()
num_features = dataset.num_features
dim = args.hidden
nn1 = Sequential(Linear(num_features, dim), ReLU(), Linear(dim, dim),
ReLU(), torch.nn.BatchNorm1d(dim))
self.conv1 = GINConv(nn1)
nn2 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim), ReLU(),
torch.nn.BatchNorm1d(dim))
self.conv2 = GINConv(nn2)
nn3 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim), ReLU(),
torch.nn.BatchNorm1d(dim))
self.conv3 = GINConv(nn3)
nn4 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim), ReLU(),
torch.nn.BatchNorm1d(dim))
self.conv4 = GINConv(nn4)
nn5 = Sequential(Linear(dim, dim), ReLU(), Linear(dim, dim), ReLU(),
torch.nn.BatchNorm1d(dim))
self.conv5 = GINConv(nn5)
self.fc1 = Sequential(Linear(num_features, dim), ReLU(),
torch.nn.BatchNorm1d(dim))
self.fc2 = Sequential(Linear(dim, dim), ReLU(),
torch.nn.BatchNorm1d(dim))
self.lin = Linear(dim, dataset.num_classes)
def __init__(self, i_dim, h_dim, e_dim, times):
super(IpsClassifyNet, self).__init__()
self.lin0 = Sequential(Linear(i_dim, h_dim), ReLU())
self.conv_layer = ConvLayer(h_dim, e_dim, times)
self.lin1 = Sequential(Linear(h_dim, h_dim), ReLU(), Linear(h_dim, 2))
counter += 1
if pred.item() == data[1]:
num_correct += 1
accuracy = num_correct / (ldr.__len__())
print("Accuracy: ", accuracy)
#return model to training mode
set_grad_enabled(True)
net.train()
return accuracy
#Define binary classifier network
net = Sequential(
Conv2d(3, filter1, kernel_size=2, stride=1, padding=0),
ReLU(),
MaxPool2d(kernel_size=2, stride=2),
Conv2d(filter1, filter2, kernel_size=4, stride=1, padding=0),
ReLU(),
#MaxPool2d(kernel_size=2, stride=2),
Flatten(),
Linear(input_dim, layer1),
ReLU(),
Linear(layer1, layer2),
ReLU(),
Linear(layer2, layer3),
ReLU(),
Linear(layer3, out_dim),
)
# x = randn(1, 3, image_size, image_size)
def __init__(self, i_dim, h_dim, e_dim, times):
super(CausalFeatureNet, self).__init__()
self.lin0 = Sequential(Linear(i_dim, h_dim), ReLU())
self.conv_layer = ConvLayer(h_dim, e_dim, times)
def MLP(channels, batch_norm=True):
return Seq(*[
Seq(Lin(channels[i - 1], channels[i]), ReLU(), BN(channels[i]))
for i in range(1, len(channels))
])
