docs: def _build(self, inputs):
      """Connects the Linear module into the graph, with input Tensor `inputs`.
  
      If this is not the first time the module has been connected to the graph,
      the Tensor provided here must have the same final dimension, in order for
      the existing variables to be the correct size for the multiplication. The
      batch size may differ for each connection.
  
      Args:
        inputs: A 2D Tensor of size [batch_size, input_size].
  
      Returns:
        A 2D Tensor of size [batch_size, output_size].
  
      Raises:
        base.IncompatibleShapeError: If the input is not a 2-D `Tensor` with
            the size of the second dimension specified.
        base.IncompatibleShapeError: If reconnecting an already connected module
            into the graph, and the shape of the input is not compatible with
            previous inputs.
      """
      input_shape = tuple(inputs.get_shape().as_list())
  
      if len(input_shape) != 2:
        raise base.IncompatibleShapeError(
            "{}: rank of shape must be 2 not: {}".format(
                self.scope_name, len(input_shape)))
  
      if input_shape[1] is None:
        raise base.IncompatibleShapeError(
            "{}: Input size must be specified at module build time".format(
                self.scope_name))
  
      if self._input_shape is not None and input_shape[1] != self._input_shape[1]:
        raise base.IncompatibleShapeError(
            "{}: Input shape must be [batch_size, {}] not: [batch_size, {}]"
            .format(self.scope_name, self._input_shape[1], input_shape[1]))
  
      self._input_shape = input_shape
      dtype = inputs.dtype
  
      if "w" not in self._initializers:
        self._initializers["w"] = create_linear_initializer(self._input_shape[1],
                                                            dtype)
  
      if "b" not in self._initializers and self._use_bias:
        self._initializers["b"] = create_bias_initializer(self._input_shape[1],
                                                          dtype)
  
      weight_shape = (self._input_shape[1], self.output_size)
      self._w = tf.get_variable("w",
                                shape=weight_shape,
                                dtype=dtype,
                                initializer=self._initializers["w"],
                                partitioner=self._partitioners.get("w", None),
                                regularizer=self._regularizers.get("w", None))
      outputs = tf.matmul(inputs, self._w)
  
      if self._use_bias:
        bias_shape = (self.output_size,)
        self._b = tf.get_variable("b",
                                  shape=bias_shape,
                                  dtype=dtype,
                                  initializer=self._initializers["b"],
                                  partitioner=self._partitioners.get("b", None),
                                  regularizer=self._regularizers.get("b", None))
        outputs += self._b
  
      return outputs