class_docstr: Represents multiple applications of the Householder bijective transformation. A
  single Householder transformation takes the form,
  
      :math:`\mathbf{y} = (I - 2*\frac{\mathbf{u}\mathbf{u}^T}{||\mathbf{u}||^2})\mathbf{x}`
  
  where :math:`\mathbf{x}` are the inputs, :math:`\mathbf{y}` are the outputs,
  and the learnable parameters are :math:`\mathbf{u}\in\mathbb{R}^D` for input
  dimension :math:`D`.
  
  The transformation represents the reflection of :math:`\mathbf{x}` through the
  plane passing through the origin with normal :math:`\mathbf{u}`.
  
  :math:`D` applications of this transformation are able to transform standard
  i.i.d. standard Gaussian noise into a Gaussian variable with an arbitrary
  covariance matrix. With :math:`K<D` transformations, one is able to approximate
  a full-rank Gaussian distribution using a linear transformation of rank
  :math:`K`.
  
  Together with :class:`~pyro.distributions.TransformedDistribution` this provides
  a way to create richer variational approximations.
  
  Example usage:
  
  >>> base_dist = dist.Normal(torch.zeros(10), torch.ones(10))
  >>> transform = Householder(10, count_transforms=5)
  >>> pyro.module("my_transform", p) # doctest: +SKIP
  >>> flow_dist = dist.TransformedDistribution(base_dist, [transform])
  >>> flow_dist.sample()  # doctest: +SKIP
  
  :param input_dim: the dimension of the input (and output) variable.
  :type input_dim: int
  :param count_transforms: number of applications of Householder transformation to
      apply.
  :type count_transforms: int
  
  References:
  
  [1] Jakub M. Tomczak, Max Welling. Improving Variational Auto-Encoders using
  Householder Flow. [arXiv:1611.09630]
code: def __init__(self, input_dim, count_transforms=1):
      super().__init__()
  
      self.input_dim = input_dim
      if count_transforms < 1:
          raise ValueError(
              "Number of Householder transforms, {}, is less than 1!".format(
                  count_transforms
              )
          )
      elif count_transforms > input_dim:
          warnings.warn(
              "Number of Householder transforms, {}, is greater than input dimension {}, which is an \
  over-parametrization!".format(
                  count_transforms, input_dim
              )
          )
      self.u_unnormed = nn.Parameter(
          torch.Tensor(count_transforms, input_dim)
      )
      self.reset_parameters()
  
imports: import math
  import warnings
  from functools import partial
  import torch
  import torch.nn
  from torch.distributions import Transform, constraints
  from pyro.nn import DenseNN
  from ..conditional import ConditionalTransformModule
  from ..torch_transform import TransformModule
  from ..util import copy_docs_from
label_desc: Use image node_id 1 to create a new Householder object from inherited base classes: ConditionedHouseholder, TransformModule with example: obj = Householder(input_dim, count_transforms)