def __init__(self,
in_channels,
out_channels,
num_relations,
num_bases,
after_relu,
bias=False,
**kwargs):
super(MyRGCNConv, self).__init__(aggr='mean', **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.num_relations = num_relations
self.num_bases = num_bases
self.after_relu = after_relu
self.basis = Param(torch.Tensor(num_bases, in_channels, out_channels))
self.att = Param(torch.Tensor(num_relations, num_bases))
self.root = Param(torch.Tensor(in_channels, out_channels))
if bias:
self.bias = Param(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_channels,
out_channels,
num_relations,
num_bases,
root_weight=True,
bias=True,
**kwargs):
super(RGCNConv, self).__init__(aggr='add', **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.num_relations = num_relations
self.num_bases = num_bases
self.basis = Param(torch.Tensor(num_bases, in_channels, out_channels))
self.att = Param(torch.Tensor(num_relations, num_bases))
if root_weight:
self.root = Param(torch.Tensor(in_channels, out_channels))
else:
self.register_parameter('root', None)
if bias:
self.bias = Param(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_channels,
out_channels,
num_relations,
num_bases,
bias=True):
super(RGCNConv, self).__init__('add')
self.in_channels = in_channels
self.out_channels = out_channels
self.num_relations = num_relations
self.num_bases = num_bases
if num_bases == 0:
self.basis = Param(torch.Tensor(num_relations, in_channels, out_channels))
self.att = None
else:
self.basis = Param(torch.Tensor(num_bases, in_channels, out_channels))
self.att = Param(torch.Tensor(num_relations, num_bases))
self.root = Param(torch.Tensor(in_channels, out_channels))
if bias:
self.bias = Param(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_dim,
out_dim,
unigue_source_num,
unique_target_num,
is_after_relu=True,
is_bias=False,
**kwargs):
super(MyHierarchyConv, self).__init__(aggr='mean', **kwargs)
self.in_dim = in_dim
self.out_dim = out_dim
self.unique_source_num = unigue_source_num
self.unique_target_num = unique_target_num
self.is_after_relu = is_after_relu
# parameter setting
self.weight = Param(torch.Tensor(in_dim, out_dim))
if is_bias:
self.bias = Param(torch.Tensor(out_dim))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(
self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
num_relations: int,
num_bases: Optional[int] = None,
num_blocks: Optional[int] = None,
aggr: str = 'mean',
root_weight: bool = True,
bias: bool = True,
**kwargs,
):
kwargs.setdefault('aggr', aggr)
super().__init__(node_dim=0, **kwargs)
if num_bases is not None and num_blocks is not None:
raise ValueError('Can not apply both basis-decomposition and '
'block-diagonal-decomposition at the same time.')
self.in_channels = in_channels
self.out_channels = out_channels
self.num_relations = num_relations
self.num_bases = num_bases
self.num_blocks = num_blocks
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.in_channels_l = in_channels[0]
if num_bases is not None:
self.weight = Parameter(
torch.Tensor(num_bases, in_channels[0], out_channels))
self.comp = Parameter(torch.Tensor(num_relations, num_bases))
elif num_blocks is not None:
assert (in_channels[0] % num_blocks == 0
and out_channels % num_blocks == 0)
self.weight = Parameter(
torch.Tensor(num_relations, num_blocks,
in_channels[0] // num_blocks,
out_channels // num_blocks))
self.register_parameter('comp', None)
else:
self.weight = Parameter(
torch.Tensor(num_relations, in_channels[0], out_channels))
self.register_parameter('comp', None)
if root_weight:
self.root = Param(torch.Tensor(in_channels[1], out_channels))
else:
self.register_parameter('root', None)
if bias:
self.bias = Param(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self, out_channels, num_layers, aggr='add', bias=True):
super(InOutGGNN, self).__init__(aggr)
self.out_channels = out_channels
self.num_layers = num_layers
self.weight = Param(Tensor(num_layers, 2, out_channels, out_channels))
self.rnn = torch.nn.GRUCell(2 * out_channels, out_channels, bias=bias)
self.bias_in = Param(Tensor(self.out_channels))
self.bias_out = Param(Tensor(self.out_channels))
self.reset_parameters()
def __init__(self, g, in_channels, out_channels, num_relations, num_bases):
super(RGCNSPMVConv, self).__init__()
self.g = g
self.in_channels = in_channels
self.out_channels = out_channels
self.num_relations = num_relations
self.num_bases = num_bases
self.basis = Param(torch.Tensor(num_bases, in_channels, out_channels))
self.att = Param(torch.Tensor(num_relations, num_bases))
self.root = Param(torch.Tensor(in_channels, out_channels))
self.bias = Param(torch.Tensor(out_channels))
self.reset_parameters()
def __init__(self, in_dim, num_et):
super(MultiInnerProductDecoder, self).__init__()
self.num_et = num_et
self.in_dim = in_dim
self.weight = Param(torch.Tensor(num_et, in_dim))
self.reset_parameters()
def __init__(self,
out_channels: int,
num_layers: int,
num_rels=1,
residual_channels=0,
aggr: str = 'add',
bias: bool = True,
weight_dropout=0.2,
**kwargs):
super(GatedGraphConv, self).__init__(aggr=aggr, **kwargs)
self.out_channels = out_channels
self.num_layers = num_layers
self.num_rels = num_rels
self.weight = Param(
Tensor(num_layers, num_rels, out_channels, out_channels))
# self.weight = \
F.dropout(self.weight, p=weight_dropout,
training=True) #self.training)
self.rnn = torch.nn.GRUCell(out_channels + residual_channels,
out_channels,
bias=bias)
self.reset_parameters()
def __init__(self,
device,
in_dim_drug,
num_dd_et,
in_dim_prot,
uni_num_prot,
uni_num_drug,
prot_drug_dim=64,
num_base=32,
n_embed=64,
n_hid1=32,
n_hid2=16,
mod='add'):
'''
:param device:
:param in_dim_drug:
:param num_dd_et:
:param in_dim_prot:
:param uni_num_prot:
:param uni_num_drug:
:param prot_drug_dim:
:param num_base:
:param n_embed:
:param n_hid1:
:param n_hid2:
:param mod: 'cat', 'ave'
'''
super(FMEncoder, self).__init__()
self.num_et = num_dd_et
self.out_dim = n_hid2
self.uni_num_drug = uni_num_drug
self.uni_num_prot = uni_num_prot
# on pp-net
self.pp_encoder = PPEncoder(in_dim_prot)
# feat: drug index
self.embed = Param(torch.Tensor(in_dim_drug, n_embed))
# on pd-net
self.hgcn = MyHierarchyConv(self.pp_encoder.out_dim, prot_drug_dim,
uni_num_prot, uni_num_drug)
self.hdrug = torch.zeros(
(self.uni_num_drug, self.pp_encoder.out_dim)).to(device)
# on dd-net +self.hgcn.out_dim
self.rgcn1 = MyRGCNConv2(n_embed,
n_hid1,
num_dd_et,
num_base,
after_relu=False)
self.rgcn2 = MyRGCNConv2(n_hid1,
n_hid2,
num_dd_et,
num_base,
after_relu=True)
self.reset_parameters()
def __init__(self, in_dim, num_uni_edge_type, l1_dim=16):
""" in_dim: the feat dim of a drug
num_edge_type: num of dd edge type """
super(NNDecoder, self).__init__()
self.l1_dim = l1_dim # Decoder Lays' dim setting
# parameters
# for drug 1
self.w1_l1 = Param(torch.Tensor(in_dim, l1_dim))
self.w1_l2 = Param(torch.Tensor(num_uni_edge_type, l1_dim)) # dd_et
# specified
# for drug 2
self.w2_l1 = Param(torch.Tensor(in_dim, l1_dim))
self.w2_l2 = Param(torch.Tensor(num_uni_edge_type, l1_dim)) # dd_et
# specified
self.reset_parameters()
def __init__(self, source_dim, embed_dim, target_dim, uni_num_source,
uni_num_target):
super(HierEncoder, self).__init__()
self.embed = Param(torch.Tensor(source_dim, embed_dim))
self.hgcn = MyHierarchyConv(embed_dim, target_dim, uni_num_source,
uni_num_target)
self.reset_parameters()
def __init__(self, out_channels, num_layers, aggr='add', bias=True):
super(GatedGraphConv, self).__init__(aggr)
self.out_channels = out_channels
self.num_layers = num_layers
self.weight = Param(Tensor(num_layers, out_channels, out_channels))
self.rnn = torch.nn.GRUCell(out_channels, out_channels, bias=bias)
self.reset_parameters()
def __init__(self,
input_dim,
num_timesteps,
num_edge_types,
aggr='add',
bias=True,
dropout=0):
super(GatedGraphConv, self).__init__(aggr)
self._input_dim = input_dim
self.num_timesteps = num_timesteps
self.num_edge_types = num_edge_types
self.weight = Param(
Tensor(num_timesteps, num_edge_types, input_dim, input_dim))
self.bias = Param(Tensor(num_timesteps, num_edge_types, input_dim))
self.rnn = torch.nn.GRUCell(input_dim, input_dim, bias=bias)
self.dropout = torch.nn.Dropout(dropout)
self.reset_parameters()
def __init__(self,
in_channels,
out_channels,
num_relations,
num_bases,
device,
root_weight=True,
bias=True,
**kwargs):
super(RAGCNConv, self).__init__(aggr='add', **kwargs)
self.device = device
self.in_channels = in_channels
self.out_channels = out_channels
self.num_relations = num_relations
self.num_bases = num_bases
self.basis = Param(torch.Tensor(num_bases, in_channels,
out_channels)).to(self.device)
self.att_r = Param(torch.Tensor(num_relations,
num_bases)).to(self.device)
self.heads = 1
self.att = Param(torch.Tensor(1, self.heads,
2 * out_channels)).to(self.device)
self.gate_layer = nn.Linear(2 * out_channels, 1)
self.relu = nn.ReLU()
self.negative_slope = 0.2
if root_weight:
self.root = Param(torch.Tensor(in_channels,
out_channels)).to(self.device)
else:
self.register_parameter('root', None)
if bias:
self.bias = Param(torch.Tensor(out_channels)).to(self.device)
else:
self.register_parameter('bias', None)
self.reset_parameters()
self.dropout = 0
def __init__(self, out_channels, num_layers, edge_network, aggr="add", bias=True):
super(GatedGraphConv, self).__init__(aggr)
self.out_channels = out_channels
self.num_layers = num_layers
self.edge_network = (
edge_network # TODO: make into a list of neural networks for each edge_attr
)
self.weight = Param(Tensor(num_layers, out_channels, out_channels))
self.rnn = torch.nn.GRUCell(out_channels, out_channels, bias=bias)
self.reset_parameters()
def __init__(self,
out_channels: int,
num_layers: int,
aggr: str = 'add',
bias: bool = True,
**kwargs):
super().__init__(aggr=aggr, **kwargs)
self.out_channels = out_channels
self.num_layers = num_layers
self.weight = Param(Tensor(num_layers, out_channels, out_channels))
self.rnn = torch.nn.GRUCell(out_channels, out_channels, bias=bias)
self.reset_parameters()
def __init__(self, p):
super(LinReg, self).__init__()
self.b = Param(torch.randn(p, requires_grad=True))
self.log_sig = Param(torch.randn(1, requires_grad=True))
def __init__(self, size):
log_conc = torch.randn(size)
log_rate = torch.randn(size)
self.vp = Param(torch.stack([log_conc, log_rate]), requires_grad=True)
self.size = size
def __init__(self, size):
m = torch.randn(size)
log_s = torch.randn(size)
self.vp = Param(torch.stack([m, log_s]), requires_grad=True)
self.size = size
