code: def __init__(
      self,
      G,
      name=None,
      method="gcn",
      k=1,
      sparse=True,
      transform=None,
      teleport_probability=0.1,
      weighted=False,
  ):
      if self.multiplicity is None:
          raise TypeError(
              "Can't instantiate abstract class 'FullBatchGenerator', please"
              "instantiate either 'FullBatchNodeGenerator' or 'FullBatchLinkGenerator'"
          )
  
      if not isinstance(G, StellarGraph):
          raise TypeError(
              "Graph must be a StellarGraph or StellarDiGraph object."
          )
  
      self.graph = G
      self.name = name
      self.k = k
      self.teleport_probability = teleport_probability
      self.method = method
  
      # Check if the graph has features
      G.check_graph_for_ml()
  
      # Check that there is only a single node type for GAT or GCN
      node_type = G.unique_node_type(
          "G: expected a graph with a single node type, found a graph with node types: %(found)s"
      )
  
      # Create sparse adjacency matrix:
      # Use the node orderings the same as in the graph features
      self.node_list = G.nodes()
      self.Aadj = G.to_adjacency_matrix(weighted=weighted)
  
      # Power-user feature: make the generator yield dense adjacency matrix instead
      # of the default sparse one.
      # If sparse is specified, check that the backend is tensorflow
      if sparse and K.backend() != "tensorflow":
          warnings.warn(
              "Sparse adjacency matrices are only supported in tensorflow."
              " Falling back to using a dense adjacency matrix."
          )
          self.use_sparse = False
  
      else:
          self.use_sparse = sparse
  
      # Get the features for the nodes
      self.features = G.node_features(node_type=node_type)
  
      if transform is not None:
          if callable(transform):
              self.features, self.Aadj = transform(
                  features=self.features, A=self.Aadj
              )
          else:
              raise ValueError(
                  "argument 'transform' must be a callable."
              )
  
      elif self.method in ["gcn", "sgc"]:
          self.features, self.Aadj = GCN_Aadj_feats_op(
              features=self.features,
              A=self.Aadj,
              k=self.k,
              method=self.method,
          )
  
      elif self.method in ["gat", "self_loops"]:
          self.Aadj = self.Aadj + sps.diags(
              np.ones(self.Aadj.shape[0]) - self.Aadj.diagonal()
          )
  
      elif self.method in ["ppnp"]:
          if self.use_sparse:
              raise ValueError(
                  "sparse: method='ppnp' requires 'sparse=False', found 'sparse=True' "
                  "(consider using the APPNP model for sparse support)"
              )
          self.features, self.Aadj = PPNP_Aadj_feats_op(
              features=self.features,
              A=self.Aadj,
              teleport_probability=self.teleport_probability,
          )
  
      elif self.method in [None, "none"]:
          pass
  
      else:
          raise ValueError(
              "Undefined method for adjacency matrix transformation. "
              "Accepted: 'gcn' (default), 'sgc', and 'self_loops'."
          )
  
imports: import warnings
  import operator
  import random
  import numpy
  import itertools
  import networkx
  import scipy.sparse
  from tensorflow.keras import backend
  from functools import reduce
  from tensorflow.keras.utils import Sequence
  from .None import Generator, FullBatchSequence, SparseFullBatchSequence, RelationalFullBatchNodeSequence, GraphSAGENodeGenerator, DirectedGraphSAGENodeGenerator
  from ..core.graph import StellarGraph
  from ..core.utils import is_real_iterable
  from ..core.utils import GCN_Aadj_feats_op, PPNP_Aadj_feats_op
  from ..core.validation import comma_sep
label_desc: Use image node_id 1 to create a new FullBatchGenerator object from inherited base classes: Generator with example: obj = FullBatchGenerator(G, name, method, k, sparse, transform, teleport_probability, weighted)