code: def forward(
      self, x: Tensor, edge_index: Adj, edge_weight: OptTensor = None
  ) -> Tensor:
      """"""
  
      if self.normalize and edge_weight is None:
          if isinstance(edge_index, Tensor):
              cache = self._cached_edge_index
              if cache is None:
                  edge_index, edge_weight = gcn_norm(  # yapf: disable
                      edge_index,
                      edge_weight,
                      x.size(self.node_dim),
                      self.improved,
                      self.add_self_loops,
                      dtype=x.dtype,
                  )
                  if self.cached:
                      self._cached_edge_index = (
                          edge_index,
                          edge_weight,
                      )
              else:
                  edge_index, edge_weight = cache[0], cache[1]
  
          elif isinstance(edge_index, SparseTensor):
              cache = self._cached_adj_t
              if cache is None:
                  edge_index = gcn_norm(
                      edge_index,
                      edge_weight,
                      x.size(self.node_dim),
                      self.improved,
                      self.add_self_loops,
                      dtype=x.dtype,
                  )
                  if self.cached:
                      self._cached_adj_t = edge_index
              else:
                  edge_index = cache
  
      # new
      elif not self.normalize:
          if isinstance(edge_index, Tensor):
              cache = self._cached_edge_index
              if cache is None:
                  if edge_weight is None:
                      edge_weight = torch.ones(
                          (edge_index.size(1),),
                          device=edge_index.device,
                      )
                  if self.add_self_loops:
                      edge_index, edge_weight = add_self_loops(
                          edge_index,
                          edge_weight,
                          num_nodes=x.size(self.node_dim),
                      )
                  if self.cached:
                      self._cached_edge_index = (
                          edge_index,
                          edge_weight,
                      )
              else:
                  edge_index, edge_weight = cache[0], cache[1]
  
          elif isinstance(edge_index, SparseTensor):
              cache = self._cached_adj_t
              if cache is None:
                  adj_t = edge_index
                  if not adj_t.has_value():
                      adj_t = adj_t.fill_value(1.0)
                  if self.add_self_loops:
                      adj_t = fill_diag(adj_t, 1.0)
                  edge_index = adj_t
                  if self.cached:
                      self._cached_adj_t = edge_index
  
      # --- add require_grad ---
      edge_weight.requires_grad_(True)
  
      # propagate_type: (x: Tensor, edge_weight: OptTensor)
      out = self.propagate(
          edge_index, x=x, edge_weight=edge_weight, size=None
      )
  
      out = torch.matmul(out, self.weight)
  
      if self.bias is not None:
          out += self.bias
  
      # --- My: record edge_weight ---
      self.edge_weight = edge_weight
  
      return out
  
imports: import torch
  import torch.nn
  from functools import partial
  from typing import Union, List
  import torch.nn.functional
  from torch_geometric.data import Batch
  from torch_geometric.nn.conv.gcn_conv import gcn_norm
  from torch_geometric.nn.conv import GCNConv
  from torch_geometric.nn.glob import global_mean_pool, global_add_pool, global_max_pool
  from torch import Tensor
  from torch_sparse import SparseTensor, fill_diag
  from torch_geometric.typing import Adj, OptTensor, Size
  from torch_geometric.utils import add_self_loops
  from dig.xgraph.models import GNNPool
  from collections import OrderedDict
label_desc: Use image node_id 2 for calling the GCNConv obj's underlying member method code with example usage: obj.forward(x, edge_index, edge_weight) and returns: out