class_docstr: A CensNet convolutional layer from the paper
  
  > [Co-embedding of Nodes and Edges with Graph Neural Networks](https://arxiv.org/abs/2010.13242)<br>
  > Xiaodong Jiang et al.
  
  This implements both the node and edge propagation rules as a single layer.
  
  **Mode**: single, disjoint, batch.
  
  **Input**
  
  - Node features of shape `([batch], n_nodes, n_node_features)`;
  - A tuple containing:
      - Modified Laplacian of shape `([batch], n_nodes, n_nodes)`; can be
          computed with `spektral.utils.convolution.gcn_filter`.
      - Modified line graph Laplacian of shape `([batch], n_edges, n_edges)`;
          can be computed with `spektral.utils.convolution.line_graph` and
          `spektral.utils.convolution.gcn_filter`.
      - Incidence matrix of shape `([batch], n_nodes, n_edges)`; can be
          computed with `spektral.utils.convolution.incidence_matrix`.
  - Edge features of shape `([batch], n_edges, n_edge_features)`;
  
  **Output**
  
  - Node features with the same shape as the input, but with the last
  dimension changed to `node_channels`.
  - Edge features with the same shape as the input, but with the last
  dimension changed to `edge_channels`.
  
  **Arguments**
  
  - `node_channels`: number of output channels for the node features;
  - `edge_channels`: number of output channels for the edge features;
  - `activation`: activation function;
  - `use_bias`: bool, add a bias vector to the output;
  - `kernel_initializer`: initializer for the weights;
  - `node_initializer`: initializer for the node feature weights (P_n);
  - `edge_initializer`: initializer for the edge feature weights (P_e);
  - `bias_initializer`: initializer for the bias vector;
  - `kernel_regularizer`: regularization applied to the weights;
  - `edge_regularizer`: regularization applied to the edge feature weights;
  - `bias_regularizer`: regularization applied to the bias vector;
  - `activity_regularizer`: regularization applied to the output;
  - `kernel_constraint`: constraint applied to the weights;
  - `edge_constraint`: constraint applied to the edge feature weights;
  - `bias_constraint`: constraint applied to the bias vector.
code: def __init__(
      self,
      node_channels,
      edge_channels,
      activation=None,
      use_bias=True,
      kernel_initializer="glorot_uniform",
      node_initializer="glorot_uniform",
      edge_initializer="glorot_uniform",
      bias_initializer="zeros",
      kernel_regularizer=None,
      node_regularizer=None,
      edge_regularizer=None,
      bias_regularizer=None,
      activity_regularizer=None,
      kernel_constraint=None,
      node_constraint=None,
      edge_constraint=None,
      bias_constraint=None,
      **kwargs,
  ):
      super().__init__(
          activation=activation,
          use_bias=use_bias,
          kernel_initializer=kernel_initializer,
          bias_initializer=bias_initializer,
          kernel_regularizer=kernel_regularizer,
          bias_regularizer=bias_regularizer,
          activity_regularizer=activity_regularizer,
          kernel_constraint=kernel_constraint,
          bias_constraint=bias_constraint,
          **kwargs,
      )
  
      self.node_channels = node_channels
      self.edge_channels = edge_channels
  
      self.__node_initializer = tf.keras.initializers.get(
          node_initializer
      )
      self.__node_regularizer = tf.keras.regularizers.get(
          node_regularizer
      )
      self.__node_constraint = tf.keras.constraints.get(node_constraint)
  
      self.__edge_initializer = tf.keras.initializers.get(
          edge_initializer
      )
      self.__edge_regularizer = tf.keras.regularizers.get(
          edge_regularizer
      )
      self.__edge_constraint = tf.keras.constraints.get(edge_constraint)
  
file_path: spektral/spektral/layers/convolutional/censnet_conv.py
imports: import tensorflow
  from spektral.layers import ops
  from spektral.layers.convolutional.conv import Conv
  from spektral.utils.convolution import gcn_filter, incidence_matrix, line_graph
label_desc: Use image node_id 1 to create a new CensNetConv object from inherited base classes: Conv with example: obj = CensNetConv(node_channels, edge_channels, activation, use_bias, kernel_initializer, node_initializer, edge_initializer, bias_initializer, kernel_regularizer, node_regularizer, edge_regularizer, bias_regularizer, activity_regularizer, kernel_constraint, node_constraint, edge_constraint, bias_constraint)