class_docstr: A fully connected network that takes FloatFeatures input
  and supports distributional prediction.
code: def __init__(
      self,
      state_dim,
      output_dim,
      sizes,
      activations,
      *,
      output_activation: str = "linear",
      num_atoms: Optional[int] = None,
      use_batch_norm: bool = False,
      dropout_ratio: float = 0.0,
      normalized_output: bool = False,
      use_layer_norm: bool = False,
  ):
      super().__init__()
      assert state_dim > 0, "state_dim must be > 0, got {}".format(
          state_dim
      )
      assert output_dim > 0, "output_dim must be > 0, got {}".format(
          output_dim
      )
      self.state_dim = state_dim
      self.output_dim = output_dim
      assert len(sizes) == len(
          activations
      ), "The numbers of sizes and activations must match; got {} vs {}".format(
          len(sizes), len(activations)
      )
      self.num_atoms = num_atoms
      self.fc = FullyConnectedNetwork(
          [state_dim] + sizes + [output_dim * (num_atoms or 1)],
          activations + [output_activation],
          use_batch_norm=use_batch_norm,
          dropout_ratio=dropout_ratio,
          normalize_output=normalized_output,
          use_layer_norm=use_layer_norm,
      )
  
imports: import logging
  import math
  from typing import List, Optional
  import torch
  import torch.nn
  import torch.nn.init
  from reagent.core import types
  from reagent.models.base import ModelBase
  from reagent.models.residual_wrapper import ResidualWrapper
label_desc: Use image node_id 1 to create a new FloatFeatureFullyConnected object from inherited base classes: ModelBase with example: obj = FloatFeatureFullyConnected(state_dim, output_dim, sizes, activations)