class_docstr: A stack of :class:`.GraphConvolution` layers together with a `SortPooling` layer
  that implement a supervised graph classification network (DGCNN) using the GCN convolution operator
  (https://arxiv.org/abs/1609.02907).
  
  The DGCNN model was introduced in the paper, "An End-to-End Deep Learning Architecture for Graph Classification" by
  M. Zhang, Z. Cui, M. Neumann, and Y. Chen, AAAI 2018, https://www.cse.wustl.edu/~muhan/papers/AAAI_2018_DGCNN.pdf
  
  The model minimally requires specification of the GCN layer sizes as a list of int corresponding to the feature
  dimensions for each hidden layer, activation functions for each hidden layer, a generator object, and the number of
  output nodes for the class:`SortPooling` layer.
  
  To use this class as a Keras model, the features and preprocessed adjacency matrix should be supplied using the
  :class:`.PaddedGraphGenerator` class.
  
  Examples:
      Creating a graph classification model from a list of :class:`.StellarGraph`
      objects (``graphs``). We also add two one-dimensional convolutional layers, a max pooling layer, and two fully
      connected dense layers one with dropout one used for binary classification::
  
          generator = PaddedGraphGenerator(graphs)
          model = DeepGraphCNN(
                           layer_sizes=[32, 32, 32, 1],
                           activations=["tanh","tanh", "tanh", "tanh"],
                           generator=generator,
                           k=30
              )
          x_inp, x_out = model.in_out_tensors()
  
          x_out = Conv1D(filters=16, kernel_size=97, strides=97)(x_out)
          x_out = MaxPool1D(pool_size=2)(x_out)
          x_out = Conv1D(filters=32, kernel_size=5, strides=1)(x_out)
          x_out = Flatten()(x_out)
          x_out = Dense(units=128, activation="relu")(x_out)
          x_out = Dropout(rate=0.5)(x_out)
          predictions = Dense(units=1, activation="sigmoid")(x_out)
  
          model = Model(inputs=x_inp, outputs=predictions)
  
  
  .. seealso::
  
     Example using DGCNN: `graph classification <https://stellargraph.readthedocs.io/en/stable/demos/graph-classification/gcn-supervised-graph-classification.html>`__.
  
     Appropriate data generator: :class:`.PaddedGraphGenerator`.
  
     Related models:
  
     - :class:`.GCNSupervisedGraphClassification` for the general form, supporting more customisation
     - :class:`.GCN` for predictions for individual nodes or links
  
  Args:
      layer_sizes (list of int): list of output sizes of the graph GCN layers in the stack.
      activations (list of str): list of activations applied to each GCN layer's output.
      k (int): size (number of rows) of output tensor.
      generator (GraphGenerator): an instance of :class:`.GraphGenerator` class constructed on the graphs used for
          training.
      bias (bool, optional): toggles an optional bias in graph convolutional layers.
      dropout (float, optional): dropout rate applied to input features of each GCN layer.
      kernel_initializer (str or func, optional): The initialiser to use for the weights of each graph
          convolutional layer.
      kernel_regularizer (str or func, optional): The regulariser to use for the weights of each graph
          convolutional layer.
      kernel_constraint (str or func, optional): The constraint to use for the weights of each layer graph
          convolutional.
      bias_initializer (str or func, optional): The initialiser to use for the bias of each layer graph
          convolutional.
      bias_regularizer (str or func, optional): The regulariser to use for the bias of each layer graph
          convolutional.
      bias_constraint (str or func, optional): The constraint to use for the bias of each layer graph
          convolutional.
code: def __init__(
      self,
      layer_sizes,
      activations,
      k,
      generator,
      bias=True,
      dropout=0.0,
      kernel_initializer=None,
      kernel_regularizer=None,
      kernel_constraint=None,
      bias_initializer=None,
      bias_regularizer=None,
      bias_constraint=None,
  ):
      super().__init__(
          layer_sizes=layer_sizes,
          activations=activations,
          generator=generator,
          bias=bias,
          dropout=dropout,
          pooling=SortPooling(k=k, flatten_output=True),
          pool_all_layers=True,
          kernel_initializer=kernel_initializer,
          kernel_regularizer=kernel_regularizer,
          kernel_constraint=kernel_constraint,
          bias_initializer=bias_initializer,
          bias_regularizer=bias_regularizer,
          bias_constraint=bias_constraint,
      )
  
file_path: stellargraph/stellargraph/layer/graph_classification.py
imports: import tensorflow
  from tensorflow.keras import backend
  from .misc import deprecated_model_function
  from ..mapper import PaddedGraphGenerator
  from .gcn import GraphConvolution
  from .sort_pooling import SortPooling
  from tensorflow.keras.layers import Input, Dropout, GlobalAveragePooling1D
label_desc: Use image node_id 1 to create a new DeepGraphCNN object from inherited base classes: GCNSupervisedGraphClassification with example: obj = DeepGraphCNN(layer_sizes, activations, k, generator, bias, dropout, kernel_initializer, kernel_regularizer, kernel_constraint, bias_initializer, bias_regularizer, bias_constraint)