parameters: (
      inputs,
      num_outputs,
      activation_fn=nn.relu,
      normalizer_fn=None,
      normalizer_params=None,
      weights_initializer=initializers.xavier_initializer(),
      weights_regularizer=None,
      biases_initializer=init_ops.zeros_initializer(),
      biases_regularizer=None,
      reuse=None,
      variables_collections=None,
      outputs_collections=None,
      trainable=True,
      scope=None)
docstring: Adds a sparse fully connected layer. The weight matrix is masked.
  
    `fully_connected` creates a variable called `weights`, representing a fully
    connected weight matrix, which is multiplied by the `inputs` to produce a
    `Tensor` of hidden units. If a `normalizer_fn` is provided (such as
    `batch_norm`), it is then applied. Otherwise, if `normalizer_fn` is
    None and a `biases_initializer` is provided then a `biases` variable would be
    created and added the hidden units. Finally, if `activation_fn` is not `None`,
    it is applied to the hidden units as well.
  
    Note: that if `inputs` have a rank greater than 2, then `inputs` is flattened
    prior to the initial matrix multiply by `weights`.
  
    Args:
      inputs: A tensor of at least rank 2 and static value for the last dimension;
        i.e. `[batch_size, depth]`, `[None, None, None, channels]`.
      num_outputs: Integer or long, the number of output units in the layer.
      activation_fn: Activation function. The default value is a ReLU function.
        Explicitly set it to None to skip it and maintain a linear activation.
      normalizer_fn: Normalization function to use instead of `biases`. If
        `normalizer_fn` is provided then `biases_initializer` and
        `biases_regularizer` are ignored and `biases` are not created nor added.
        default set to None for no normalizer function
      normalizer_params: Normalization function parameters.
      weights_initializer: An initializer for the weights.
      weights_regularizer: Optional regularizer for the weights.
      biases_initializer: An initializer for the biases. If None skip biases.
      biases_regularizer: Optional regularizer for the biases.
      reuse: Whether or not the layer and its variables should be reused. To be
        able to reuse the layer scope must be given.
      variables_collections: Optional list of collections for all the variables or
        a dictionary containing a different list of collections per variable.
      outputs_collections: Collection to add the outputs.
      trainable: If `True` also add variables to the graph collection
        `GraphKeys.TRAINABLE_VARIABLES` (see tf.Variable).
      scope: Optional scope for variable_scope.
  
    Returns:
       The tensor variable representing the result of the series of operations.
  
    Raises:
      ValueError: If x has rank less than 2 or if its last dimension is not set.
docstring_summary: Adds a sparse fully connected layer. The weight matrix is masked.
docstring_tokens: Adds a sparse fully connected layer . The weight matrix is masked .
function: def masked_fully_connected(
      inputs,
      num_outputs,
      activation_fn=nn.relu,
      normalizer_fn=None,
      normalizer_params=None,
      weights_initializer=initializers.xavier_initializer(),
      weights_regularizer=None,
      biases_initializer=init_ops.zeros_initializer(),
      biases_regularizer=None,
      reuse=None,
      variables_collections=None,
      outputs_collections=None,
      trainable=True,
      scope=None):
    """Adds a sparse fully connected layer. The weight matrix is masked.
  
    `fully_connected` creates a variable called `weights`, representing a fully
    connected weight matrix, which is multiplied by the `inputs` to produce a
    `Tensor` of hidden units. If a `normalizer_fn` is provided (such as
    `batch_norm`), it is then applied. Otherwise, if `normalizer_fn` is
    None and a `biases_initializer` is provided then a `biases` variable would be
    created and added the hidden units. Finally, if `activation_fn` is not `None`,
    it is applied to the hidden units as well.
  
    Note: that if `inputs` have a rank greater than 2, then `inputs` is flattened
    prior to the initial matrix multiply by `weights`.
  
    Args:
      inputs: A tensor of at least rank 2 and static value for the last dimension;
        i.e. `[batch_size, depth]`, `[None, None, None, channels]`.
      num_outputs: Integer or long, the number of output units in the layer.
      activation_fn: Activation function. The default value is a ReLU function.
        Explicitly set it to None to skip it and maintain a linear activation.
      normalizer_fn: Normalization function to use instead of `biases`. If
        `normalizer_fn` is provided then `biases_initializer` and
        `biases_regularizer` are ignored and `biases` are not created nor added.
        default set to None for no normalizer function
      normalizer_params: Normalization function parameters.
      weights_initializer: An initializer for the weights.
      weights_regularizer: Optional regularizer for the weights.
      biases_initializer: An initializer for the biases. If None skip biases.
      biases_regularizer: Optional regularizer for the biases.
      reuse: Whether or not the layer and its variables should be reused. To be
        able to reuse the layer scope must be given.
      variables_collections: Optional list of collections for all the variables or
        a dictionary containing a different list of collections per variable.
      outputs_collections: Collection to add the outputs.
      trainable: If `True` also add variables to the graph collection
        `GraphKeys.TRAINABLE_VARIABLES` (see tf.Variable).
      scope: Optional scope for variable_scope.
  
    Returns:
       The tensor variable representing the result of the series of operations.
  
    Raises:
      ValueError: If x has rank less than 2 or if its last dimension is not set.
    """
    if not isinstance(num_outputs, six.integer_types):
      raise ValueError('num_outputs should be int or long, got %s.' %
                       (num_outputs,))
  
    layer_variable_getter = _build_variable_getter({
        'bias': 'biases',
        'kernel': 'weights'
    })
  
    with variable_scope.variable_scope(
        scope,
        'fully_connected', [inputs],
        reuse=reuse,
        custom_getter=layer_variable_getter) as sc:
      inputs = ops.convert_to_tensor(inputs)
      layer = core.MaskedFullyConnected(
          units=num_outputs,
          activation=None,
          use_bias=not normalizer_fn and biases_initializer,
          kernel_initializer=weights_initializer,
          bias_initializer=biases_initializer,
          kernel_regularizer=weights_regularizer,
          bias_regularizer=biases_regularizer,
          activity_regularizer=None,
          trainable=trainable,
          name=sc.name,
          dtype=inputs.dtype.base_dtype,
          _scope=sc,
          _reuse=reuse)
      outputs = layer.apply(inputs)
  
      # Add variables to collections.
      _add_variable_to_collections(layer.kernel, variables_collections, 'weights')
      if layer.bias is not None:
        _add_variable_to_collections(layer.bias, variables_collections, 'biases')
  
      # Apply normalizer function / layer.
      if normalizer_fn is not None:
        if not normalizer_params:
          normalizer_params = {}
        outputs = normalizer_fn(outputs, **normalizer_params)
  
      if activation_fn is not None:
        outputs = activation_fn(outputs)
  
      return utils.collect_named_outputs(outputs_collections,
                                         sc.original_name_scope, outputs)
function_tokens: def masked_fully_connected ( inputs , num_outputs , activation_fn = nn . relu , normalizer_fn = None , normalizer_params = None , weights_initializer = initializers . xavier_initializer ( ) , weights_regularizer = None , biases_initializer = init_ops . zeros_initializer ( ) , biases_regularizer = None , reuse = None , variables_collections = None , outputs_collections = None , trainable = True , scope = None ) : if not isinstance ( num_outputs , six . integer_types ) : raise ValueError ( 'num_outputs should be int or long, got %s.' % ( num_outputs , ) ) layer_variable_getter = _build_variable_getter ( { 'bias' : 'biases' , 'kernel' : 'weights' } ) with variable_scope . variable_scope ( scope , 'fully_connected' , [ inputs ] , reuse = reuse , custom_getter = layer_variable_getter ) as sc : inputs = ops . convert_to_tensor ( inputs ) layer = core . MaskedFullyConnected ( units = num_outputs , activation = None , use_bias = not normalizer_fn and biases_initializer , kernel_initializer = weights_initializer , bias_initializer = biases_initializer , kernel_regularizer = weights_regularizer , bias_regularizer = biases_regularizer , activity_regularizer = None , trainable = trainable , name = sc . name , dtype = inputs . dtype . base_dtype , _scope = sc , _reuse = reuse ) outputs = layer . apply ( inputs ) # Add variables to collections. _add_variable_to_collections ( layer . kernel , variables_collections , 'weights' ) if layer . bias is not None : _add_variable_to_collections ( layer . bias , variables_collections , 'biases' ) # Apply normalizer function / layer. if normalizer_fn is not None : if not normalizer_params : normalizer_params = { } outputs = normalizer_fn ( outputs , * * normalizer_params ) if activation_fn is not None : outputs = activation_fn ( outputs ) return utils . collect_named_outputs ( outputs_collections , sc . original_name_scope , outputs )