docstr: Test mixed topology batches (random vertices and neighbors).
code: def test_feature_steered_convolution_padding_random(
      self,
      batch_size,
      num_vertices,
      in_channels,
      out_channels,
      num_weight_matrices,
  ):
      """Test mixed topology batches (random vertices and neighbors)."""
      data, neighbors, sizes = _random_data(
          batch_size,
          num_vertices,
          in_channels,
          padding=True,
          only_self_edges=False,
      )
      u, v, c, w, b = _random_variables(
          in_channels, out_channels, num_weight_matrices
      )
  
      with self.subTest(name="if_w_is_0_then_y_is_b"):
          y = gc.feature_steered_convolution(
              data=data,
              neighbors=neighbors,
              sizes=sizes,
              var_u=u,
              var_v=v,
              var_c=c,
              var_w=tf.zeros_like(w),
              var_b=b,
          )
          for k in range(batch_size):
              y_crop = y[k, : sizes[k], :]
              y_expected = tf.broadcast_to(b, y_crop.shape)
  
              self.assertAllEqual(y_crop, y_expected)
              # Check for zeros in the padded region.
              self.assertAllEqual(
                  y[k, sizes[k] :, :],
                  tf.zeros((num_vertices - sizes[k], out_channels)),
              )
  
      with self.subTest(name="convolve_with_constant"):
          constant_data = data
          for k in range(batch_size):
              constant_data[k, : sizes[k], :] = np.tile(
                  data[k, 0, :], (sizes[k], 1)
              )
  
          y = gc.feature_steered_convolution(
              data=constant_data,
              neighbors=neighbors,
              sizes=sizes,
              var_u=u,
              var_v=v,
              var_c=c,
              var_w=w,
              var_b=b,
          )
          for k in range(batch_size):
              y_crop = y[k, : sizes[k], :]
              y_const = tf.broadcast_to(y_crop[0, :], y_crop.shape)
  
              self.assertAllClose(y_crop, y_const)
              # Check for zeros in the padded region.
              self.assertAllEqual(
                  y[k, sizes[k] :, :],
                  tf.zeros([num_vertices - sizes[k], out_channels]),
              )
  
imports: from __future__ import absolute_import
  from __future__ import division
  from __future__ import print_function
  import itertools
  from absl.testing import parameterized
  import numpy
  from six.moves import range
  import tensorflow
  import tensorflow_graphics.geometry.convolution.graph_convolution
  from tensorflow_graphics.util import test_case
label_desc: Use image node_id 7 for calling the GraphConvolutionTestFeatureSteeredConvolutionTests obj's underlying member method code with example usage: obj.test_feature_steered_convolution_padding_random(batch_size, num_vertices, in_channels, out_channels, num_weight_matrices) without return types