class_docstr: Represents multiple applications of the Householder bijective transformation
  conditioning on an additional context. 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 with dimension :math:`D`,
  :math:`\mathbf{y}` are the outputs, and :math:`\mathbf{u}\in\mathbb{R}^D`
  is the output of a function, e.g. a NN, with input :math:`z\in\mathbb{R}^{M}`
  representing the context variable to condition on.
  
  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.ConditionalTransformedDistribution`
  this provides a way to create richer variational approximations.
  
  Example usage:
  
  >>> from pyro.nn.dense_nn import DenseNN
  >>> input_dim = 10
  >>> context_dim = 5
  >>> batch_size = 3
  >>> base_dist = dist.Normal(torch.zeros(input_dim), torch.ones(input_dim))
  >>> param_dims = [input_dim]
  >>> hypernet = DenseNN(context_dim, [50, 50], param_dims)
  >>> transform = ConditionalHouseholder(input_dim, hypernet)
  >>> z = torch.rand(batch_size, context_dim)
  >>> flow_dist = dist.ConditionalTransformedDistribution(base_dist,
  ... [transform]).condition(z)
  >>> flow_dist.sample(sample_shape=torch.Size([batch_size])) # doctest: +SKIP
  
  :param input_dim: the dimension of the input (and output) variable.
  :type input_dim: int
  :param nn: a function inputting the context variable and outputting a triplet of
      real-valued parameters of dimensions :math:`(1, D, D)`.
  :type nn: callable
  :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 _u_unnormed(self, context):
      # u_unnormed ~ (count_transforms, input_dim)
      # Hence, input_dim must divide
      u_unnormed = self.nn(context)
      if self.count_transforms == 1:
          u_unnormed = u_unnormed.unsqueeze(-2)
      else:
          u_unnormed = torch.stack(u_unnormed, dim=-2)
      return u_unnormed
  
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 2 for calling the ConditionalHouseholder obj's underlying member method code with example usage: obj._u_unnormed(context) and returns: u_unnormed