def __init__(self, in_channels: int, out_channels: int,
num_node_types: int, num_edge_types: int,
edge_type_emb_dim: int, edge_dim: int, edge_attr_emb_dim: int,
heads: int = 1, concat: bool = True,
negative_slope: float = 0.2, dropout: float = 0.0,
root_weight: bool = True, 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.root_weight = root_weight
self.hetero_lin = HeteroLinear(in_channels, out_channels,
num_node_types, bias=bias)
self.edge_type_emb = Embedding(num_edge_types, edge_type_emb_dim)
self.edge_attr_emb = Linear(edge_dim, edge_attr_emb_dim, bias=False)
self.att = Linear(
2 * out_channels + edge_type_emb_dim + edge_attr_emb_dim,
self.heads, bias=False)
self.lin = Linear(out_channels + edge_attr_emb_dim, out_channels,
bias=bias)
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: Union[int, Tuple[int, int]],
out_channels: int,
aggr: str = 'mean',
normalize: bool = False,
root_weight: bool = True,
project: bool = False,
bias: bool = True,
**kwargs,
):
kwargs['aggr'] = aggr if aggr != 'lstm' else None
super().__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.normalize = normalize
self.root_weight = root_weight
self.project = project
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
if self.project:
self.lin = Linear(in_channels[0], in_channels[0], bias=True)
if self.aggr is None:
self.fuse = False # No "fused" message_and_aggregate.
self.lstm = LSTM(in_channels[0], in_channels[0], batch_first=True)
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,
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,
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,
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,
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: 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,
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: 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: 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, out_channels, bias=True, **kwargs):
kwargs.setdefault('aggr', 'add')
super(LEConv, self).__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.lin1 = Linear(in_channels, out_channels, bias=bias)
self.lin2 = Linear(in_channels, out_channels, bias=False)
self.lin3 = Linear(in_channels, out_channels, bias=bias)
self.reset_parameters()
def __init__(self,
in_channels: int,
out_channels: int,
first_aggr: bool,
bias: bool = True,
**kwargs):
kwargs.setdefault('aggr', 'mean')
super(SignedConv, self).__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.first_aggr = first_aggr
if first_aggr:
self.lin_pos_l = Linear(in_channels, out_channels, False)
self.lin_pos_r = Linear(in_channels, out_channels, bias)
self.lin_neg_l = Linear(in_channels, out_channels, False)
self.lin_neg_r = Linear(in_channels, out_channels, bias)
else:
self.lin_pos_l = Linear(2 * in_channels, out_channels, False)
self.lin_pos_r = Linear(in_channels, out_channels, bias)
self.lin_neg_l = Linear(2 * in_channels, out_channels, False)
self.lin_neg_r = Linear(in_channels, out_channels, bias)
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,
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_channels: Union[int, Tuple[int, int]],
out_channels: int, bias: bool = True, **kwargs):
kwargs.setdefault('aggr', 'add')
super(LEConv, self).__init__(**kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.lin1 = Linear(in_channels[0], out_channels, bias=bias)
self.lin2 = Linear(in_channels[1], out_channels, bias=False)
self.lin3 = Linear(in_channels[1], out_channels, bias=bias)
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,
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,
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: Union[int, Tuple[int, int]],
out_channels: int,
aggr: Optional[Union[str, List[str], Aggregation]] = "mean",
normalize: bool = False,
root_weight: bool = True,
project: bool = False,
bias: bool = True,
**kwargs,
):
self.in_channels = in_channels
self.out_channels = out_channels
self.normalize = normalize
self.root_weight = root_weight
self.project = project
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
if aggr == 'lstm':
kwargs.setdefault('aggr_kwargs', {})
kwargs['aggr_kwargs'].setdefault('in_channels', in_channels[0])
kwargs['aggr_kwargs'].setdefault('out_channels', in_channels[0])
super().__init__(aggr, **kwargs)
if self.project:
self.lin = Linear(in_channels[0], in_channels[0], bias=True)
if self.aggr is None:
self.fuse = False # No "fused" message_and_aggregate.
self.lstm = LSTM(in_channels[0], in_channels[0], batch_first=True)
if isinstance(self.aggr_module, MultiAggregation):
aggr_out_channels = self.aggr_module.get_out_channels(
in_channels[0])
else:
aggr_out_channels = in_channels[0]
self.lin_l = Linear(aggr_out_channels, 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,
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,
heads: int = 1,
concat: bool = True,
beta: bool = False,
dropout: float = 0.,
edge_dim: Optional[int] = None,
bias: bool = True,
root_weight: bool = True,
**kwargs,
):
kwargs.setdefault('aggr', 'add')
super(TransformerConv, self).__init__(node_dim=0, **kwargs)
self.in_channels = in_channels
self.out_channels = out_channels
self.heads = heads
self.beta = beta and root_weight
self.root_weight = root_weight
self.concat = concat
self.dropout = dropout
self.edge_dim = edge_dim
self._alpha = None
if isinstance(in_channels, int):
in_channels = (in_channels, in_channels)
self.lin_key = Linear(in_channels[0], heads * out_channels)
self.lin_query = Linear(in_channels[1], heads * out_channels)
self.lin_value = Linear(in_channels[0], heads * out_channels)
if edge_dim is not None:
self.lin_edge = Linear(edge_dim, heads * out_channels, bias=False)
else:
self.lin_edge = self.register_parameter('lin_edge', None)
if concat:
self.lin_skip = Linear(in_channels[1],
heads * out_channels,
bias=bias)
if self.beta:
self.lin_beta = Linear(3 * heads * out_channels, 1, bias=False)
else:
self.lin_beta = self.register_parameter('lin_beta', None)
else:
self.lin_skip = Linear(in_channels[1], out_channels, bias=bias)
if self.beta:
self.lin_beta = Linear(3 * out_channels, 1, bias=False)
else:
self.lin_beta = self.register_parameter('lin_beta', None)
self.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, 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,
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()
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: 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] = ["symnorm"],
num_heads: int = 8,
num_bases: int = 4,
cached: bool = False,
add_self_loops: bool = True,
bias: bool = True,
**kwargs):
super().__init__(node_dim=0, **kwargs)
if out_channels % num_heads != 0:
raise ValueError(
'out_channels must be divisible by the number of heads')
for a in aggregators:
if a not in ['sum', 'mean', 'symnorm', 'min', 'max', 'var', 'std']:
raise ValueError(f"Unsupported aggregator: '{a}'")
self.in_channels = in_channels
self.out_channels = out_channels
self.num_heads = num_heads
self.num_bases = num_bases
self.cached = cached
self.add_self_loops = add_self_loops
self.aggregators = aggregators
self.bases_lin = Linear(in_channels,
(out_channels // num_heads) * num_bases,
bias=False,
weight_initializer='glorot')
self.comb_lin = Linear(in_channels,
num_heads * num_bases * len(aggregators))
if bias:
self.bias = Parameter(torch.Tensor(out_channels))
else:
self.register_parameter('bias', None)
self.reset_parameters()