code: def __init__(
      self,
      layers,
      activations,
      prior_var,
      *,
      noise_tol: float = 0.1,
      use_batch_norm: bool = False,
      min_std: float = 0.0,
      dropout_ratio: float = 0.0,
      use_layer_norm: bool = False,
      normalize_output: bool = False,
      orthogonal_init: bool = False,
  ) -> None:
      super().__init__()
  
      self.input_dim = layers[0]
      self.use_batch_norm = use_batch_norm
  
      modules: List[nn.Module] = []
      linear_bbbs: List[nn.Module] = []
      self.noise_tol = noise_tol
      self.layers = layers
  
      assert len(layers) == len(activations) + 1
  
      for i, ((in_dim, out_dim), activation) in enumerate(
          zip(zip(layers, layers[1:]), activations)
      ):
          # Add BatchNorm1d
          if use_batch_norm:
              modules.append(SlateBatchNorm1d(in_dim))
          # Add Linear
          linear_bbb = LinearBBB(
              in_dim, out_dim, activation, prior_var=prior_var
          )
          linear_bbbs.append(linear_bbb)
          # assuming activation is valid
  
          modules.append(linear_bbb)
          # Add LayerNorm
          if use_layer_norm and (
              normalize_output or i < len(activations) - 1
          ):
              modules.append(nn.LayerNorm(out_dim))  # type: ignore
          # Add activation
          if activation in ACTIVATION_MAP:
              modules.append(ACTIVATION_MAP[activation]())
          else:
              # See if it matches any of the nn modules
              modules.append(getattr(nn, activation)())
          # Add Dropout
          if dropout_ratio > 0.0 and (
              normalize_output or i < len(activations) - 1
          ):
              modules.append(nn.Dropout(p=dropout_ratio))
  
      self.dnn = nn.Sequential(*modules)  # type: ignore
      self.linear_bbbs = nn.ModuleList(linear_bbbs)
  
imports: import logging
  from typing import List
  import torch
  import torch.nn
  import torch.nn.functional
  from reagent.models.base import ModelBase
  from reagent.models.fully_connected_network import ACTIVATION_MAP, gaussian_fill_w_gain, SlateBatchNorm1d
  from torch.distributions import Normal
label_desc: Use image node_id 1 to create a new FullyConnectedProbabilisticNetwork object from inherited base classes: ModelBase with example: obj = FullyConnectedProbabilisticNetwork(layers, activations, prior_var)