def __init__(self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
max_degree: int = 10,
bias=True,
**kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.max_degree = max_degree
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.lins_l = ModuleList([
Linear(in_channels[0], out_channels, bias=bias)
for _ in range(max_degree + 1)
])
self.lins_r = ModuleList([
Linear(in_channels[1], out_channels, bias=False)
for _ in range(max_degree + 1)
])
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
diag_lambda: float = 0.,
add_self_loops: bool = True,
bias: bool = True,
**kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.diag_lambda = diag_lambda
self.add_self_loops = add_self_loops
self.lin_out = Linear(in_channels,
out_channels,
bias=bias,
weight_initializer='glorot')
self.lin_root = Linear(in_channels,
out_channels,
bias=False,
weight_initializer='glorot')
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
heads: int = 1,
add_self_loops: bool = True,
bias: bool = True,
**kwargs):
kwargs.setdefault('aggr', 'mean')
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.heads = heads
self.add_self_loops = add_self_loops
self.lin = Linear(in_channels,
heads * out_channels,
bias=False,
weight_initializer='uniform')
self.u = Linear(in_channels,
heads,
bias=False,
weight_initializer='uniform')
self.c = Parameter(torch.Tensor(heads))
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self, in_channels: int, out_channels: int,
improved: bool = False, cached: bool = False,
add_self_loops: bool = True, normalize: bool = True,
bias: bool = True, **kwargs):
kwargs.setdefault('aggr', 'add')
super(GCNConv, self).__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.improved = improved
self.cached = cached
self.add_self_loops = add_self_loops
self.normalize = normalize
self._cached_edge_index = None
self._cached_adj_t = None
self.lin = Linear(in_channels, out_channels, bias=False,
weight_initializer='glorot')
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
channels: int,
eps: float = 0.1,
dropout: float = 0.0,
cached: bool = False,
add_self_loops: bool = True,
normalize: bool = True,
**kwargs):
kwargs.setdefault('aggr', 'add')
super(FAConv, self).__init__(**kwargs)
self.channels = channels
self.eps = eps
self.dropout = dropout
self.cached = cached
self.add_self_loops = add_self_loops
self.normalize = normalize
self._cached_edge_index = None
self._cached_adj_t = None
self._alpha = None
self.att_l = Linear(channels, 1, bias=False)
self.att_r = Linear(channels, 1, bias=False)
self.reset_parameters()
def __init__(self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
nn: Callable,
aggr: str = 'add',
root_weight: bool = True,
bias: bool = True,
**kwargs):
super().__init__(aggr=aggr, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.nn = nn
self.root_weight = root_weight
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.in_channels_l = in_channels[0]
if root_weight:
self.lin = Linear(in_channels[1],
out_channels,
bias=False,
weight_initializer='uniform')
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_features: int,
out_features: int,
n_heads: int,
residual: bool,
dropout: float = 0.6,
slope: float = 0.2,
activation: nn.Module = nn.ELU()):
super(GraphAttentionLayer, self).__init__(aggr='add', node_dim=0)
self.in_features = in_features
self.out_features = out_features
self.heads = n_heads
self.residual = residual
self.attn_dropout = nn.Dropout(dropout)
self.feat_dropout = nn.Dropout(dropout)
self.leakyrelu = nn.LeakyReLU(negative_slope=slope)
self.activation = activation
self.feat_lin = Linear(in_features,
out_features * n_heads,
bias=True,
weight_initializer='glorot')
self.attn_vec = nn.Parameter(torch.Tensor(1, n_heads, out_features))
# use 'residual' parameters to instantiate residual structure
if residual:
self.proj_r = Linear(in_features,
out_features,
bias=False,
weight_initializer='glorot')
else:
self.register_parameter('proj_r', None)
self.reset_parameters()
def __init__(self, nn: torch.nn.Module, eps: float = 0.,
train_eps: bool = False, edge_dim: Optional[int] = None,
**kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(**kwargs)
self.nn = nn
self.initial_eps = eps
if train_eps:
self.eps = torch.nn.Parameter(torch.Tensor([eps]))
else:
self.register_buffer('eps', torch.Tensor([eps]))
if edge_dim is not None:
if isinstance(self.nn, torch.nn.Sequential):
nn = self.nn[0]
if hasattr(nn, 'in_features'):
in_channels = nn.in_features
elif hasattr(nn, 'in_channels'):
in_channels = nn.in_channels
else:
raise ValueError("Could not infer input channels from `nn`.")
self.lin = Linear(edge_dim, in_channels)
else:
self.lin = None
self.reset_parameters()
def __init__(
self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
dim: int,
kernel_size: Union[int, List[int]],
is_open_spline: bool = True,
degree: int = 1,
aggr: str = 'mean',
root_weight: bool = True,
bias: bool = True,
**kwargs,
):
super().__init__(aggr=aggr, **kwargs)
if spline_basis is None:
raise ImportError("'SplineConv' requires 'torch-spline-conv'")
self.in_channels = in_channels
self.out_channels = out_channels
self.dim = dim
self.degree = degree
self.root_weight = root_weight
kernel_size = torch.tensor(repeat(kernel_size, dim), dtype=torch.long)
self.register_buffer('kernel_size', kernel_size)
is_open_spline = repeat(is_open_spline, dim)
is_open_spline = torch.tensor(is_open_spline, dtype=torch.uint8)
self.register_buffer('is_open_spline', is_open_spline)
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.K = kernel_size.prod().item()
if in_channels[0] > 0:
self.weight = Parameter(
torch.Tensor(self.K, in_channels[0], out_channels))
else:
self.weight = torch.nn.parameter.UninitializedParameter()
self._hook = self.register_forward_pre_hook(
self.initialize_parameters)
if root_weight:
self.lin = Linear(in_channels[1],
out_channels,
bias=False,
weight_initializer='uniform')
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
dim: int,
kernel_size: int,
separate_gaussians: bool = False,
aggr: str = 'mean',
root_weight: bool = True,
bias: bool = True,
**kwargs):
super(GMMConv, self).__init__(aggr=aggr, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.dim = dim
self.kernel_size = kernel_size
self.separate_gaussians = separate_gaussians
self.root_weight = root_weight
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.rel_in_channels = in_channels[0]
if in_channels[0] > 0:
self.g = Parameter(
Tensor(in_channels[0], out_channels * kernel_size))
if not self.separate_gaussians:
self.mu = Parameter(Tensor(kernel_size, dim))
self.sigma = Parameter(Tensor(kernel_size, dim))
if self.separate_gaussians:
self.mu = Parameter(
Tensor(in_channels[0], out_channels, kernel_size, dim))
self.sigma = Parameter(
Tensor(in_channels[0], out_channels, kernel_size, dim))
else:
self.g = torch.nn.parameter.UninitializedParameter()
self.mu = torch.nn.parameter.UninitializedParameter()
self.sigma = torch.nn.parameter.UninitializedParameter()
self._hook = self.register_forward_pre_hook(
self.initialize_parameters)
if root_weight:
self.root = Linear(in_channels[1],
out_channels,
bias=False,
weight_initializer='glorot')
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self, in_channels: Union[int, Tuple[int, int]],
out_channels: Optional[int], in_edge_channels: int = None,
aggr: str = 'add', skip_linear: str = False,
directed_msg: bool = True, heads: int = 1,
attention: bool = False, attention_type: str = 'additive',
l2_normalize: bool = False, bias: bool = True,
**kwargs): # yapf: disable
kwargs.setdefault('aggr', aggr)
super().__init__(node_dim=0, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.in_edge_channels = in_edge_channels
self.aggr = aggr
self.skip_linear = skip_linear
self.directed_msg = directed_msg
self.heads = heads
self.attention = attention
self.attention_type = attention_type
self.normalize_l2 = l2_normalize
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
if self.directed_msg:
self.lin_msg = Linear(in_channels[0],
out_channels * self.heads,
bias=bias)
else:
self.lin_msg = Linear(in_channels[0],
out_channels * self.heads,
bias=bias)
self.lin_msg_i = Linear(in_channels[0],
out_channels * self.heads,
bias=bias)
if self.skip_linear or self.in_channels != self.out_channels:
self.lin_self = Linear(in_channels[1], out_channels, bias=bias)
else:
self.lin_self = torch.nn.Identity()
if self.in_edge_channels is not None:
self.lin_edge = Linear(in_edge_channels,
out_channels * self.heads,
bias=bias)
# todo: A general torch_geometric.nn.AttentionLayer
if self.attention:
if self.attention_type == 'additive':
self.att_msg = Parameter(
torch.Tensor(1, self.heads, self.out_channels))
elif self.attention_type == 'dot_product':
self.scaler = torch.sqrt(
torch.tensor(out_channels, dtype=torch.float))
else:
raise ValueError('attention_type: {} not supported'.format(
self.attention_type))
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
heads: int = 1,
concat: bool = True,
negative_slope: float = 0.2,
dropout: float = 0.0,
add_self_loops: bool = True,
bias: bool = True,
attention_type: str = 'MX',
neg_sample_ratio: float = 0.5,
edge_sample_ratio: float = 1.0,
is_undirected: bool = False,
**kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(node_dim=0, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.heads = heads
self.concat = concat
self.negative_slope = negative_slope
self.dropout = dropout
self.add_self_loops = add_self_loops
self.attention_type = attention_type
self.neg_sample_ratio = neg_sample_ratio
self.edge_sample_ratio = edge_sample_ratio
self.is_undirected = is_undirected
assert attention_type in ['MX', 'SD']
assert 0.0 < neg_sample_ratio and 0.0 < edge_sample_ratio <= 1.0
self.lin = Linear(in_channels,
heads * out_channels,
bias=False,
weight_initializer='glorot')
if self.attention_type == 'MX':
self.att_l = Parameter(torch.Tensor(1, heads, out_channels))
self.att_r = Parameter(torch.Tensor(1, heads, out_channels))
else: # self.attention_type == 'SD'
self.register_parameter('att_l', None)
self.register_parameter('att_r', None)
self.att_x = self.att_y = None # x/y for self-supervision
if bias and concat:
self.bias = Parameter(torch.Tensor(heads * out_channels))
elif bias and not concat:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
aggregators: List[str],
scalers: List[str],
deg: Tensor,
edge_dim: Optional[int] = None,
towers: int = 1,
pre_layers: int = 1,
post_layers: int = 1,
divide_input: bool = False,
**kwargs):
kwargs.setdefault('aggr', None)
super().__init__(node_dim=0, **kwargs)
if divide_input:
assert in_channels % towers == 0
assert out_channels % towers == 0
self.in_channels = in_channels
self.out_channels = out_channels
self.aggregators = aggregators
self.scalers = scalers
self.edge_dim = edge_dim
self.towers = towers
self.divide_input = divide_input
self.F_in = in_channels // towers if divide_input else in_channels
self.F_out = self.out_channels // towers
deg = deg.to(torch.float)
self.avg_deg: Dict[str, float] = {
'lin': deg.mean().item(),
'log': (deg + 1).log().mean().item(),
'exp': deg.exp().mean().item(),
}
if self.edge_dim is not None:
self.edge_encoder = Linear(edge_dim, self.F_in)
self.pre_nns = ModuleList()
self.post_nns = ModuleList()
for _ in range(towers):
modules = [Linear((3 if edge_dim else 2) * self.F_in, self.F_in)]
for _ in range(pre_layers - 1):
modules += [ReLU()]
modules += [Linear(self.F_in, self.F_in)]
self.pre_nns.append(Sequential(*modules))
in_channels = (len(aggregators) * len(scalers) + 1) * self.F_in
modules = [Linear(in_channels, self.F_out)]
for _ in range(post_layers - 1):
modules += [ReLU()]
modules += [Linear(self.F_out, self.F_out)]
self.post_nns.append(Sequential(*modules))
self.lin = Linear(out_channels, out_channels)
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
space_dimensions: int,
propagate_dimensions: int,
k: int,
num_workers: int = 1,
**kwargs):
super(GravNetConv, self).__init__(flow='target_to_source', **kwargs)
if knn is None:
raise ImportError('`GravNetConv` requires `torch-cluster`.')
self.in_channels = in_channels
self.out_channels = out_channels
self.k = k
self.num_workers = num_workers
self.lin_s = Linear(in_channels, space_dimensions)
self.lin_h = Linear(in_channels, propagate_dimensions)
self.lin_out1 = Linear(in_channels, out_channels, bias=False)
self.lin_out2 = Linear(2 * propagate_dimensions, out_channels)
self.reset_parameters()
def __init__(self, in_channels: int, out_channels: int, filter_size: int,
**kwargs):
kwargs.setdefault('aggr', 'add')
super(PANConv, self).__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.filter_size = filter_size
self.lin = Linear(in_channels, out_channels)
self.weight = Parameter(torch.Tensor(filter_size + 1))
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
space_dimensions: int,
propagate_dimensions: int,
k: int,
num_workers: Optional[int] = None,
**kwargs):
super().__init__(aggr=['mean', 'max'],
flow='source_to_target',
**kwargs)
if knn is None:
raise ImportError('`GravNetConv` requires `torch-cluster`.')
if num_workers is not None:
warnings.warn(
"'num_workers' attribute in '{self.__class__.__name__}' is "
"deprecated and will be removed in a future release")
self.in_channels = in_channels
self.out_channels = out_channels
self.k = k
self.lin_s = Linear(in_channels, space_dimensions)
self.lin_h = Linear(in_channels, propagate_dimensions)
self.lin_out1 = Linear(in_channels, out_channels, bias=False)
self.lin_out2 = Linear(2 * propagate_dimensions, out_channels)
self.reset_parameters()
def __init__(
self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
heads: int = 1,
concat: bool = True,
negative_slope: float = 0.2,
dropout: float = 0.0,
add_self_loops: bool = True,
edge_dim: Optional[int] = None,
fill_value: Union[float, Tensor, str] = 'mean',
bias: bool = True,
**kwargs,
):
kwargs.setdefault('aggr', 'add')
super().__init__(node_dim=0, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.heads = heads
self.concat = concat
self.negative_slope = negative_slope
self.dropout = dropout
self.add_self_loops = add_self_loops
self.edge_dim = edge_dim
self.fill_value = fill_value
# In case we are operating in bipartite graphs, we apply separate
# transformations 'lin_src' and 'lin_dst' to source and target nodes:
if isinstance(in_channels, int):
self.lin_src = Linear(in_channels, heads * out_channels,
bias=False, weight_initializer='glorot')
self.lin_dst = self.lin_src
else:
self.lin_src = Linear(in_channels[0], heads * out_channels, False,
weight_initializer='glorot')
self.lin_dst = Linear(in_channels[1], heads * out_channels, False,
weight_initializer='glorot')
# The learnable parameters to compute attention coefficients:
self.att_src = Parameter(torch.Tensor(1, heads, out_channels))
self.att_dst = Parameter(torch.Tensor(1, heads, out_channels))
if edge_dim is not None:
self.lin_edge = Linear(edge_dim, heads * out_channels, bias=False,
weight_initializer='glorot')
self.att_edge = Parameter(torch.Tensor(1, heads, out_channels))
else:
self.lin_edge = None
self.register_parameter('att_edge', None)
if bias and concat:
self.bias = Parameter(torch.Tensor(heads * out_channels))
elif bias and not concat:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
K: int = 3,
bias: bool = True,
normalize: bool = True,
**kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.K = K
self.normalize = normalize
self.lins = torch.nn.ModuleList([
Linear(in_channels, out_channels, bias=False) for _ in range(K + 1)
])
if bias:
self.bias = torch.nn.Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
K: int,
normalization: Optional[str] = 'sym',
bias: bool = True,
**kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(**kwargs)
assert K > 0
assert normalization in [None, 'sym', 'rw'], 'Invalid normalization'
self.in_channels = in_channels
self.out_channels = out_channels
self.normalization = normalization
self.lins = torch.nn.ModuleList([
Linear(in_channels,
out_channels,
bias=False,
weight_initializer='glorot') for _ in range(K)
])
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
heads: int = 1,
concat: bool = True,
negative_slope: float = 0.2,
dropout: float = 0.,
add_self_loops: bool = True,
bias: bool = True,
share_weights: bool = False,
**kwargs):
super(GATv2Conv, self).__init__(node_dim=0, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.heads = heads
self.concat = concat
self.negative_slope = negative_slope
self.dropout = dropout
self.add_self_loops = add_self_loops
self.share_weights = share_weights
self.lin_l = Linear(in_channels,
heads * out_channels,
bias=bias,
weight_initializer='glorot')
if share_weights:
self.lin_r = self.lin_l
else:
self.lin_r = Linear(in_channels,
heads * out_channels,
bias=bias,
weight_initializer='glorot')
self.att = Parameter(torch.Tensor(1, heads, out_channels))
if bias and concat:
self.bias = Parameter(torch.Tensor(heads * out_channels))
elif bias and not concat:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self._alpha = None
self.reset_parameters()
def __init__(self, in_channels: int, out_channels: int, K: int = 1,
cached: bool = False, add_self_loops: bool = True,
bias: bool = True, **kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.K = K
self.cached = cached
self.add_self_loops = add_self_loops
self._cached_x = None
self.lin = Linear(in_channels, out_channels, bias=bias)
self.reset_parameters()
def __init__(self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
pos_nn: Optional[Callable] = None,
attn_nn: Optional[Callable] = None,
add_self_loops: bool = True,
**kwargs):
kwargs.setdefault('aggr', 'mean')
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.add_self_loops = add_self_loops
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.pos_nn = pos_nn
if self.pos_nn is None:
self.pos_nn = Linear(3, out_channels)
self.attn_nn = attn_nn
self.lin = Linear(in_channels[0], out_channels, bias=False)
self.lin_src = Linear(in_channels[0], out_channels, bias=False)
self.lin_dst = Linear(in_channels[1], out_channels, bias=False)
self.reset_parameters()
def __init__(
self,
in_channels: int,
out_channels: int,
aggregators: List[str],
scalers: List[str],
deg: Tensor,
edge_dim: Optional[int] = None,
towers: int = 1,
pre_layers: int = 1,
post_layers: int = 1,
divide_input: bool = False,
act: Union[str, Callable, None] = "relu",
act_kwargs: Optional[Dict[str, Any]] = None,
**kwargs,
):
aggr = DegreeScalerAggregation(aggregators, scalers, deg)
super().__init__(aggr=aggr, node_dim=0, **kwargs)
if divide_input:
assert in_channels % towers == 0
assert out_channels % towers == 0
self.in_channels = in_channels
self.out_channels = out_channels
self.edge_dim = edge_dim
self.towers = towers
self.divide_input = divide_input
self.F_in = in_channels // towers if divide_input else in_channels
self.F_out = self.out_channels // towers
if self.edge_dim is not None:
self.edge_encoder = Linear(edge_dim, self.F_in)
self.pre_nns = ModuleList()
self.post_nns = ModuleList()
for _ in range(towers):
modules = [Linear((3 if edge_dim else 2) * self.F_in, self.F_in)]
for _ in range(pre_layers - 1):
modules += [activation_resolver(act, **(act_kwargs or {}))]
modules += [Linear(self.F_in, self.F_in)]
self.pre_nns.append(Sequential(*modules))
in_channels = (len(aggregators) * len(scalers) + 1) * self.F_in
modules = [Linear(in_channels, self.F_out)]
for _ in range(post_layers - 1):
modules += [activation_resolver(act, **(act_kwargs or {}))]
modules += [Linear(self.F_out, self.F_out)]
self.post_nns.append(Sequential(*modules))
self.lin = Linear(out_channels, out_channels)
self.reset_parameters()
def __init__(self, in_channels, out_channels, improved=False, bias=True):
super().__init__()
self.in_channels = in_channels
self.out_channels = out_channels
self.improved = improved
self.lin = Linear(in_channels,
out_channels,
bias=False,
weight_initializer='glorot')
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(self, in_channels: Union[int, Tuple[int, int]],
out_channels: int, normalize: bool = False,
root_weight: bool = True, bias: bool = True, **kwargs):
kwargs.setdefault('aggr', 'mean')
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.normalize = normalize
self.root_weight = root_weight
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.lin_l = Linear(in_channels[0], out_channels, bias=bias)
if self.root_weight:
self.lin_r = Linear(in_channels[1], out_channels, bias=False)
self.reset_parameters()
def __init__(self, nn: Callable, eps: float = 0., train_eps: bool = False,
edge_dim: Optional[int] = None, **kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(**kwargs)
self.nn = nn
self.initial_eps = eps
if train_eps:
self.eps = torch.nn.Parameter(torch.Tensor([eps]))
else:
self.register_buffer('eps', torch.Tensor([eps]))
if edge_dim is not None:
if hasattr(self.nn[0], 'in_features'):
in_channels = self.nn[0].in_features
else:
in_channels = self.nn[0].in_channels
self.lin = Linear(edge_dim, in_channels)
else:
self.lin = None
self.reset_parameters()
def __init__(self,
n_in_features: int,
n_hid_layers: int,
hid_features: list,
n_heads: list,
n_rna: int,
n_dis: int,
add_layer_attn: bool,
residual: bool,
dropout: float = 0.6):
super(AGAEMD, self).__init__()
assert n_hid_layers == len(hid_features) == len(
n_heads), f'Enter valid arch params.'
self.n_rna = n_rna
self.n_dis = n_dis
self.n_hid_layers = n_hid_layers
self.dropout = nn.Dropout(dropout)
# stack graph attention layers
self.conv = nn.ModuleList()
tmp = [n_in_features] + hid_features
for i in range(n_hid_layers):
self.conv.append(
GraphAttentionLayer(tmp[i],
tmp[i + 1],
n_heads[i],
residual=residual), )
if n_in_features != hid_features[0]:
self.proj = Linear(n_in_features,
hid_features[0],
weight_initializer='glorot',
bias=True)
else:
self.register_parameter('proj', None)
if add_layer_attn:
self.JK = JumpingKnowledge('lstm', tmp[-1], n_hid_layers + 1)
else:
self.register_parameter('JK', None)
if self.proj is not None:
self.proj.reset_parameters()
def __init__(self,
in_channels,
out_channels,
use_attention=False,
heads=1,
concat=True,
negative_slope=0.2,
dropout=0,
bias=True,
**kwargs):
kwargs.setdefault('aggr', 'add')
super().__init__(flow='source_to_target', node_dim=0, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.use_attention = use_attention
if self.use_attention:
self.heads = heads
self.concat = concat
self.negative_slope = negative_slope
self.dropout = dropout
self.lin = Linear(in_channels,
heads * out_channels,
bias=False,
weight_initializer='glorot')
self.att = Parameter(torch.Tensor(1, heads, 2 * out_channels))
else:
self.heads = 1
self.concat = True
self.lin = Linear(in_channels,
out_channels,
bias=False,
weight_initializer='glorot')
if bias and concat:
self.bias = Parameter(torch.Tensor(heads * out_channels))
elif bias and not concat:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()
def __init__(
self,
channel_list: Optional[Union[List[int], int]] = None,
*,
in_channels: Optional[int] = None,
hidden_channels: Optional[int] = None,
out_channels: Optional[int] = None,
num_layers: Optional[int] = None,
dropout: float = 0.,
act: str = "relu",
batch_norm: bool = True,
act_first: bool = False,
act_kwargs: Optional[Dict[str, Any]] = None,
batch_norm_kwargs: Optional[Dict[str, Any]] = None,
plain_last: bool = True,
bias: bool = True,
relu_first: bool = False,
):
super().__init__()
act_first = act_first or relu_first # Backward compatibility.
batch_norm_kwargs = batch_norm_kwargs or {}
if isinstance(channel_list, int):
in_channels = channel_list
if in_channels is not None:
assert num_layers >= 1
channel_list = [hidden_channels] * (num_layers - 1)
channel_list = [in_channels] + channel_list + [out_channels]
assert isinstance(channel_list, (tuple, list))
assert len(channel_list) >= 2
self.channel_list = channel_list
self.dropout = dropout
self.act = activation_resolver(act, **(act_kwargs or {}))
self.act_first = act_first
self.plain_last = plain_last
self.lins = torch.nn.ModuleList()
iterator = zip(channel_list[:-1], channel_list[1:])
for in_channels, out_channels in iterator:
self.lins.append(Linear(in_channels, out_channels, bias=bias))
self.norms = torch.nn.ModuleList()
iterator = channel_list[1:-1] if plain_last else channel_list[1:]
for hidden_channels in iterator:
if batch_norm:
norm = BatchNorm1d(hidden_channels, **batch_norm_kwargs)
else:
norm = Identity()
self.norms.append(norm)
self.reset_parameters()
def __init__(
self,
in_channels: Union[int, Tuple[int, int]],
out_channels: int,
aggr: str = 'add',
bias: bool = True,
**kwargs,
):
super().__init__(aggr=aggr, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.lin_rel = Linear(in_channels[0], out_channels, bias=bias)
self.lin_root = Linear(in_channels[1], out_channels, bias=False)
self.reset_parameters()
