k3-node 1.0.0__py3-none-any.whl

k3_node/layers/conv/wl_conv.py

@@ -0,0 +1,151 @@
+import numpy as np
+import keras
+from keras import ops
+from k3_node.layers.conv.message_passing import MessagePassing
+from k3_node.layers.conv.utils import scatter
+
+
+class WLConv(keras.layers.Layer):
+    r"""The Weisfeiler Lehman (WL) operator from the `"A Reduction of a Graph
+    to a Canonical Form and an Algebra Arising During this Reduction"
+    <https://www.iti.zcu.cz/wl2018/pdf/wl_paper_translation.pdf>`_ paper.
+
+    Args:
+        **kwargs: Additional layer arguments.
+
+    Example:
+        ```python
+        import numpy as np
+        from k3_node.layers import WLConv
+
+        colors = np.array([0, 1, 0, 1])  # discrete node colors (labels)
+        edge_index = np.array([[0, 1, 2, 3], [1, 2, 3, 0]])
+        layer = WLConv()
+        new_colors = layer(colors, edge_index)  # one Weisfeiler-Lehman refinement step
+        print(tuple(new_colors.shape))  # (4,)
+        print(tuple(layer.histogram(new_colors).shape))  # (1, 2): color histogram per graph
+        ```
+    """
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self.hashmap = {}
+
+    def reset_parameters(self):
+        self.hashmap = {}
+
+    def build(self, input_shape=None):
+        self.built = True
+
+    def call(self, x, edge_index=None, num_nodes=None):
+        if edge_index is None:
+            if isinstance(x, (tuple, list)) and len(x) >= 2:
+                x, edge_index = x[0], x[1]
+            elif ops.shape(x)[0] == 2:
+                edge_index = x
+                if num_nodes is None:
+                    num_nodes = int(ops.max(edge_index)) + 1
+                x = ops.zeros((num_nodes,), dtype="int64")
+
+        if len(ops.shape(x)) > 1:
+            x = ops.argmax(x, axis=-1)
+
+        x_np = ops.convert_to_numpy(x)
+        edge_index_np = ops.convert_to_numpy(edge_index)
+
+        num_nodes = len(x_np)
+        row, col = edge_index_np[0], edge_index_np[1]
+
+        # Group neighbors by target node col
+        neighbors_dict = {i: [] for i in range(num_nodes)}
+        for src, dst in zip(row, col):
+            neighbors_dict[int(dst)].append(int(x_np[src]))
+
+        out = []
+        for i in range(num_nodes):
+            node_color = int(x_np[i])
+            sorted_neighs = sorted(neighbors_dict[i])
+            key = hash((node_color, tuple(sorted_neighs)))
+            if key not in self.hashmap:
+                self.hashmap[key] = len(self.hashmap)
+            out.append(self.hashmap[key])
+
+        return ops.convert_to_tensor(np.array(out, dtype=np.int64))
+
+    def histogram(self, x, batch=None, norm: bool = False):
+        x_np = ops.convert_to_numpy(x)
+        num_nodes = len(x_np)
+        if batch is None:
+            batch_np = np.zeros(num_nodes, dtype=np.int64)
+        else:
+            batch_np = ops.convert_to_numpy(batch).astype(np.int64)
+
+        num_colors = len(self.hashmap)
+        batch_size = int(np.max(batch_np)) + 1 if len(batch_np) > 0 else 1
+
+        hist = np.zeros((batch_size, num_colors), dtype=np.float32)
+        for b, c in zip(batch_np, x_np):
+            hist[b, c] += 1.0
+
+        if norm:
+            norms = np.linalg.norm(hist, axis=-1, keepdims=True)
+            hist = hist / np.maximum(norms, 1e-12)
+
+        return ops.convert_to_tensor(hist)
+
+
+class WLConvContinuous(MessagePassing):
+    r"""The Weisfeiler Lehman operator from the `"Wasserstein
+    Weisfeiler-Lehman Graph Kernels" <https://arxiv.org/abs/1906.01277>`_ paper.
+
+    Args:
+        **kwargs: Additional arguments of :class:`MessagePassing`.
+
+    Example:
+        ```python
+        import numpy as np
+        from k3_node.layers import WLConvContinuous
+
+        x = np.random.rand(10, 8).astype("float32")  # 10 nodes with 8 features each
+        edge_index = np.random.randint(0, 10, size=(2, 30))  # 30 random edges
+
+        layer = WLConvContinuous()
+        out = layer(x, edge_index)
+        print(tuple(out.shape))  # (10, 8)
+        ```
+    """
+
+    def __init__(self, **kwargs):
+        kwargs.setdefault("aggr", "add")
+        super().__init__(**kwargs)
+
+    def build(self, input_shape=None):
+        self.built = True
+
+    def call(self, x, edge_index, edge_weight=None):
+        if isinstance(x, (tuple, list)):
+            x_src, x_dst = x[0], x[1]
+        else:
+            x_src = x_dst = x
+
+        out = self.propagate(edge_index, x=(x_src, x_dst), edge_weight=edge_weight)
+
+        dst_index = edge_index[1]
+        if edge_weight is None:
+            edge_weight = ops.ones((ops.shape(dst_index)[0],), dtype=out.dtype)
+
+        num_nodes = ops.shape(out)[0]
+        deg = scatter(edge_weight, dst_index, dim=0, dim_size=num_nodes, reduce="sum")
+        deg_inv = ops.where(ops.equal(deg, 0), 0.0, 1.0 / deg)
+        out = ops.expand_dims(deg_inv, axis=-1) * out
+
+        if x_dst is not None:
+            out = 0.5 * (x_dst + out)
+
+        return out
+
+    def message(self, x_j, edge_weight=None):
+        if edge_weight is not None:
+            return ops.expand_dims(edge_weight, axis=-1) * x_j
+        return x_j
+

k3_node/layers/conv/x_conv.py

@@ -0,0 +1,187 @@
+from math import ceil
+from typing import Optional
+import keras
+from keras import ops
+from k3_node.layers.conv.message_passing import MessagePassing
+from k3_node.ops.creation import repeat
+
+
+class GroupedConv1dFlat(keras.layers.Layer):
+    """A 1D convolution over input of shape (N, C, K) with kernel_size=K and groups=C."""
+
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int, **kwargs):
+        super().__init__(**kwargs)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.kernel_size = kernel_size
+        self.multiplier = out_channels // in_channels
+
+    def build(self, input_shape=None):
+        self.kernel = self.add_weight(
+            shape=(self.in_channels, self.multiplier, self.kernel_size),
+            initializer="glorot_uniform",
+            trainable=True,
+            name="kernel",
+        )
+        self.bias = self.add_weight(
+            shape=(self.out_channels,),
+            initializer="zeros",
+            trainable=True,
+            name="bias",
+        )
+        super().build(input_shape)
+
+    def call(self, x):
+        # x: (N, C, K)
+        out = ops.einsum("nck,cmk->ncm", x, self.kernel)
+        out = ops.reshape(out, (-1, self.out_channels)) + self.bias
+        return out
+
+
+class XConv(keras.layers.Layer):
+    r"""The convolutional operator on :math:`\mathcal{X}`-transformed points
+    from the `"PointCNN: Convolution On X-Transformed Points"
+    <https://arxiv.org/abs/1801.07791>`_ paper.
+
+    Args:
+        in_channels (int): Size of each input sample.
+        out_channels (int): Size of each output sample.
+        dim (int): Point cloud dimensionality.
+        kernel_size (int): Size of the convolving kernel.
+        hidden_channels (int, optional): Dimensionality of lifted points.
+        dilation (int, optional): Dilation factor. (default: :obj:`1`)
+        bias (bool, optional): Whether to learn an additive bias. (default: :obj:`True`)
+        num_workers (int, optional): Kept for PyG compatibility.
+
+    Example:
+        ```python
+        import numpy as np
+        from k3_node.layers import XConv
+
+        x = np.random.rand(10, 8).astype("float32")  # 10 nodes with 8 features each
+        edge_index = np.random.randint(0, 10, size=(2, 30))  # 30 random edges
+        pos = np.random.rand(10, 3).astype("float32")  # 3D node positions
+
+        layer = XConv(in_channels=8, out_channels=16, dim=3, kernel_size=2)
+        out = layer(x, pos)  # neighborhoods are built from `pos`
+        print(tuple(out.shape))  # (10, 16)
+        ```
+    """
+
+    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,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        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.use_bias = bias
+
+        C_in, C_delta, C_out = in_channels, hidden_channels, out_channels
+        D, K = dim, kernel_size
+
+        # mlp1
+        self.mlp1_l1 = keras.layers.Dense(C_delta)
+        self.mlp1_bn1 = keras.layers.BatchNormalization(axis=-1, momentum=0.9, epsilon=1e-5)
+        self.mlp1_l2 = keras.layers.Dense(C_delta)
+        self.mlp1_bn2 = keras.layers.BatchNormalization(axis=-1, momentum=0.9, epsilon=1e-5)
+
+        # mlp2
+        self.mlp2_l1 = keras.layers.Dense(K * K)
+        self.mlp2_bn1 = keras.layers.BatchNormalization(axis=-1, momentum=0.9, epsilon=1e-5)
+        self.mlp2_conv1 = GroupedConv1dFlat(K, K * K, K)
+        self.mlp2_bn2 = keras.layers.BatchNormalization(axis=-1, momentum=0.9, epsilon=1e-5)
+        self.mlp2_conv2 = GroupedConv1dFlat(K, K * K, K)
+        self.mlp2_bn3 = keras.layers.BatchNormalization(axis=-1, momentum=0.9, epsilon=1e-5)
+
+        # conv
+        C_total = C_in + C_delta
+        depth_multiplier = int(ceil(C_out / C_total))
+        self.conv_op = GroupedConv1dFlat(C_total, C_total * depth_multiplier, K)
+        self.conv_lin = keras.layers.Dense(C_out, use_bias=bias)
+
+    def _mlp1(self, pos, training=None):
+        # pos: (N*K, D)
+        h = ops.elu(self.mlp1_l1(pos))
+        h = self.mlp1_bn1(h, training=training)
+        h = ops.elu(self.mlp1_l2(h))
+        h = self.mlp1_bn2(h, training=training)
+        return h
+
+    def _mlp2(self, pos_flat, training=None):
+        # pos_flat: (N, K * D)
+        K = self.kernel_size
+        h = ops.elu(self.mlp2_l1(pos_flat))
+        h = self.mlp2_bn1(h, training=training)
+        h = ops.reshape(h, (-1, K, K))
+        h = ops.elu(self.mlp2_conv1(h))
+        h = self.mlp2_bn2(h, training=training)
+        h = ops.reshape(h, (-1, K, K))
+        h = self.mlp2_conv2(h)
+        h = self.mlp2_bn3(h, training=training)
+        return ops.reshape(h, (-1, K, K))
+
+    def _conv(self, x_transformed):
+        # x_transformed: (N, C_total, K)
+        h = self.conv_op(x_transformed)
+        return self.conv_lin(h)
+
+    def call(self, x, pos, batch=None, training=None):
+        if len(ops.shape(pos)) == 1:
+            pos = ops.expand_dims(pos, axis=-1)
+        N = ops.shape(pos)[0]
+        K = self.kernel_size
+        D = self.dim
+
+        # Pairwise distance KNN
+        diff = ops.expand_dims(pos, axis=1) - ops.expand_dims(pos, axis=0)
+        dist = ops.sum(diff * diff, axis=-1)
+
+        if batch is not None:
+            mask = ops.equal(ops.expand_dims(batch, axis=1), ops.expand_dims(batch, axis=0))
+            dist = ops.where(mask, dist, 1e10)
+
+        _, top_k = ops.top_k(-dist, k=K * self.dilation, sorted=True)
+        if self.dilation > 1:
+            top_k = top_k[:, ::self.dilation]
+
+        row = repeat(ops.arange(N), K)
+        col = ops.reshape(top_k, (-1,))
+
+        pos_diff = ops.take(pos, col, axis=0) - ops.take(pos, row, axis=0)
+
+        x_star = self._mlp1(pos_diff, training=training)
+        x_star = ops.reshape(x_star, (N, K, self.hidden_channels))
+
+        if x is not None:
+            if len(ops.shape(x)) == 1:
+                x = ops.expand_dims(x, axis=-1)
+            x_col = ops.take(x, col, axis=0)
+            x_col = ops.reshape(x_col, (N, K, self.in_channels))
+            x_star = ops.concatenate([x_star, x_col], axis=-1)
+
+        x_star = ops.transpose(x_star, (0, 2, 1))  # (N, C_total, K)
+
+        transform_matrix = self._mlp2(ops.reshape(pos_diff, (N, K * D)), training=training)  # (N, K, K)
+
+        x_transformed = ops.matmul(x_star, transform_matrix)  # (N, C_total, K)
+
+        out = self._conv(x_transformed)
+        return out
+

k3_node/layers/dense/__init__.py

@@ -0,0 +1,40 @@
+r"""Dense neural network module package.
+
+This package provides modules applicable for operating on dense tensor
+representations.
+"""
+
+from .linear import Linear, HeteroLinear, HeteroDictLinear
+from .dense_gat_conv import DenseGATConv
+from .dense_sage_conv import DenseSAGEConv
+from .dense_gcn_conv import DenseGCNConv
+from .dense_graph_conv import DenseGraphConv
+from .dense_gin_conv import DenseGINConv
+from .diff_pool import dense_diff_pool
+diff_pool = dense_diff_pool
+from .mincut_pool import dense_mincut_pool
+mincut_pool = dense_mincut_pool
+from .dmon_pool import DMoNPooling, dense_dmon_pool, dmon_pool
+
+__all__ = [
+    "Linear",
+    "HeteroLinear",
+    "HeteroDictLinear",
+    "DenseGCNConv",
+    "DenseGINConv",
+    "DenseGraphConv",
+    "DenseSAGEConv",
+    "DenseGATConv",
+    "dense_diff_pool",
+    "diff_pool",
+    "dense_mincut_pool",
+    "mincut_pool",
+    "DMoNPooling",
+    "dense_dmon_pool",
+    "dmon_pool",
+]
+
+lin_classes = __all__[:3]
+conv_classes = __all__[3:8]
+pool_classes = __all__[8:]
+

k3_node/layers/dense/dense_gat_conv.py

@@ -0,0 +1,149 @@
+from typing import Optional
+from keras import initializers, layers, ops
+from .linear import Linear
+
+
+class DenseGATConv(layers.Layer):
+    r"""See :class:`torch_geometric.nn.conv.GATConv`.
+
+    Example:
+        ```python
+        import numpy as np
+        from k3_node.layers import DenseGATConv
+
+        x = np.random.rand(2, 10, 8).astype("float32")  # batch of 2 graphs, 10 nodes, 8 features
+        adj = (np.random.rand(2, 10, 10) > 0.7).astype("float32")  # dense adjacency matrices
+
+        layer = DenseGATConv(in_channels=8, out_channels=16, heads=2)
+        out = layer(x, adj)
+        print(tuple(out.shape))  # (2, 10, 32)
+        ```
+    """
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        heads: int = 1,
+        concat: bool = True,
+        negative_slope: float = 0.2,
+        dropout: float = 0.0,
+        bias: bool = True,
+        **kwargs
+    ):
+        super().__init__(**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.use_bias = bias
+
+        self.lin = Linear(in_channels, heads * out_channels, bias=False,
+                          weight_initializer='glorot', name="lin")
+
+        self.att_src = self.add_weight(
+            shape=(1, 1, heads, out_channels),
+            initializer="glorot_uniform",
+            trainable=True,
+            name="att_src",
+        )
+        self.att_dst = self.add_weight(
+            shape=(1, 1, heads, out_channels),
+            initializer="glorot_uniform",
+            trainable=True,
+            name="att_dst",
+        )
+
+        if bias and concat:
+            self.bias = self.add_weight(
+                shape=(heads * out_channels,),
+                initializer="zeros",
+                trainable=True,
+                name="bias",
+            )
+        elif bias and not concat:
+            self.bias = self.add_weight(
+                shape=(out_channels,),
+                initializer="zeros",
+                trainable=True,
+                name="bias",
+            )
+        else:
+            self.bias = None
+
+    def reset_parameters(self):
+        self.lin.reset_parameters()
+        # A new initializer per tensor: a reused unseeded Keras 3 initializer returns the same values on every call.
+        glorot = lambda shape, dtype=None: initializers.GlorotUniform()(shape, dtype=dtype)
+        self.att_src.assign(glorot(self.att_src.shape, dtype=self.att_src.dtype))
+        self.att_dst.assign(glorot(self.att_dst.shape, dtype=self.att_dst.dtype))
+        if self.bias is not None:
+            self.bias.assign(ops.zeros(self.bias.shape, dtype=self.bias.dtype))
+
+    def build(self, input_shape):
+        if isinstance(input_shape, (tuple, list)):
+            x_shape = input_shape[0]
+        else:
+            x_shape = input_shape
+        self.lin.build(x_shape)
+        super().build(input_shape)
+
+    def call(self, x, adj, mask: Optional[any] = None, add_loop: bool = True, training=None):
+        is_2d_x = (len(ops.shape(x)) == 2)
+        if is_2d_x:
+            x = ops.expand_dims(x, axis=0)
+        if len(ops.shape(adj)) == 2:
+            adj = ops.expand_dims(adj, axis=0)
+
+        H, C = self.heads, self.out_channels
+        B = ops.shape(x)[0]
+        N = ops.shape(x)[1]
+
+        if add_loop:
+            eye = ops.expand_dims(ops.eye(N, dtype=adj.dtype), axis=0)
+            adj = adj * (1.0 - eye) + eye
+
+        x_proj = ops.reshape(self.lin(x), (B, N, H, C))
+
+        alpha_src = ops.sum(x_proj * self.att_src, axis=-1)  # [B, N, H]
+        alpha_dst = ops.sum(x_proj * self.att_dst, axis=-1)  # [B, N, H]
+
+        alpha = ops.expand_dims(alpha_src, axis=1) + ops.expand_dims(alpha_dst, axis=2)  # [B, N, N, H]
+        alpha = ops.leaky_relu(alpha, negative_slope=self.negative_slope)
+        alpha = ops.where(ops.expand_dims(adj, axis=-1) != 0, alpha, -1e9)
+        alpha = ops.softmax(alpha, axis=2)
+
+        # Transpose to [B, H, N, N] and [B, H, N, C]
+        alpha_perm = ops.transpose(alpha, (0, 3, 1, 2))
+        x_perm = ops.transpose(x_proj, (0, 2, 1, 3))
+        out = ops.matmul(alpha_perm, x_perm)  # [B, H, N, C]
+        out = ops.transpose(out, (0, 2, 1, 3))  # [B, N, H, C]
+
+        if self.concat:
+            out = ops.reshape(out, (B, N, H * C))
+        else:
+            out = ops.mean(out, axis=2)
+
+        if self.bias is not None:
+            out = out + self.bias
+
+        if mask is not None:
+            out = out * ops.cast(ops.reshape(mask, (-1, N, 1)), x.dtype)
+
+        if is_2d_x and ops.shape(out)[0] == 1:
+            out = ops.squeeze(out, axis=0)
+
+        return out
+
+    def compute_output_shape(self, input_shape):
+        if isinstance(input_shape, (tuple, list)):
+            x_shape = input_shape[0]
+        else:
+            x_shape = input_shape
+        out_dim = self.heads * self.out_channels if self.concat else self.out_channels
+        return (*x_shape[:-1], out_dim)
+
+    def __repr__(self) -> str:
+        return (f'{self.__class__.__name__}({self.in_channels}, '
+                f'{self.out_channels}, heads={self.heads})')

k3_node/layers/dense/dense_gcn_conv.py

@@ -0,0 +1,117 @@
+from keras import layers, ops
+from .linear import Linear
+
+
+class DenseGCNConv(layers.Layer):
+    r"""Applies the dense convolutional operator from the `"Semi-supervised
+    Classification with Graph Convolutional Networks"
+    <https://arxiv.org/abs/1609.02907>`_ paper.
+
+    .. math::
+        \mathbf{X}^{\prime} = \mathbf{\tilde{D}}^{-1/2} \mathbf{\tilde{A}}
+        \mathbf{\tilde{D}}^{-1/2} \mathbf{X} \mathbf{\Theta}
+
+    Args:
+        in_channels (int): Size of each input sample.
+        out_channels (int): Size of each output sample.
+        improved (bool, optional): If set to :obj:`True`, the layer computes
+            :math:`\mathbf{\tilde{A}} = \mathbf{A} + 2 \mathbf{I}`.
+            (default: :obj:`False`)
+        bias (bool, optional): If set to :obj:`False`, the layer will not learn
+            an additive bias. (default: :obj:`True`)
+
+    Example:
+        ```python
+        import numpy as np
+        from k3_node.layers import DenseGCNConv
+
+        x = np.random.rand(2, 10, 8).astype("float32")  # batch of 2 graphs, 10 nodes, 8 features
+        adj = (np.random.rand(2, 10, 10) > 0.7).astype("float32")  # dense adjacency matrices
+
+        layer = DenseGCNConv(in_channels=8, out_channels=16)
+        out = layer(x, adj)
+        print(tuple(out.shape))  # (2, 10, 16)
+        ```
+    """
+    def __init__(
+        self,
+        in_channels: int,
+        out_channels: int,
+        improved: bool = False,
+        bias: bool = True,
+        **kwargs
+    ):
+        super().__init__(**kwargs)
+        self.in_channels = in_channels
+        self.out_channels = out_channels
+        self.improved = improved
+        self.use_bias = bias
+
+        self.lin = Linear(in_channels, out_channels, bias=False,
+                          weight_initializer='glorot', name="lin")
+
+        if bias:
+            self.bias = self.add_weight(
+                shape=(out_channels,),
+                initializer="zeros",
+                trainable=True,
+                name="bias",
+            )
+        else:
+            self.bias = None
+
+    def reset_parameters(self):
+        self.lin.reset_parameters()
+        if self.bias is not None:
+            self.bias.assign(ops.zeros(self.bias.shape, dtype=self.bias.dtype))
+
+    def build(self, input_shape):
+        if isinstance(input_shape, (tuple, list)):
+            x_shape = input_shape[0]
+        else:
+            x_shape = input_shape
+        self.lin.build(x_shape)
+        super().build(input_shape)
+
+    def call(self, x, adj, mask=None, add_loop: bool = True):
+        is_2d_x = (len(ops.shape(x)) == 2)
+        if is_2d_x:
+            x = ops.expand_dims(x, axis=0)
+        if len(ops.shape(adj)) == 2:
+            adj = ops.expand_dims(adj, axis=0)
+
+        N = ops.shape(adj)[1]
+
+        if add_loop:
+            diag_val = 2.0 if self.improved else 1.0
+            eye = ops.expand_dims(ops.eye(N, dtype=adj.dtype), axis=0)
+            adj = adj * (1.0 - eye) + diag_val * eye
+
+        out = self.lin(x)
+        deg = ops.maximum(ops.sum(adj, axis=-1), 1.0)
+        deg_inv_sqrt = ops.power(deg, -0.5)
+
+        adj_norm = ops.expand_dims(deg_inv_sqrt, axis=-1) * adj * ops.expand_dims(deg_inv_sqrt, axis=-2)
+        out = ops.matmul(adj_norm, out)
+
+        if self.bias is not None:
+            out = out + self.bias
+
+        if mask is not None:
+            out = out * ops.cast(ops.reshape(mask, (-1, N, 1)), x.dtype)
+
+        if is_2d_x and ops.shape(out)[0] == 1:
+            out = ops.squeeze(out, axis=0)
+
+        return out
+
+    def compute_output_shape(self, input_shape):
+        if isinstance(input_shape, (tuple, list)):
+            x_shape = input_shape[0]
+        else:
+            x_shape = input_shape
+        return (*x_shape[:-1], self.out_channels)
+
+    def __repr__(self) -> str:
+        return (f'{self.__class__.__name__}({self.in_channels}, '
+                f'{self.out_channels})')