class_docstr: Creates a new kernel according to
  
      :math:`k_{new}(x, z) = q(k(f(x), f(z))),`
  
  where :math:`f` is an function and :math:`q` is a polynomial with non-negative
  coefficients ``owarping_coef``.
  
  We can take advantage of :math:`f` to combine a Gaussian Process kernel with a deep
  learning architecture. For example:
  
      >>> linear = torch.nn.Linear(10, 3)
      >>> # register its parameters to Pyro's ParamStore and wrap it by lambda
      >>> # to call the primitive pyro.module each time we use the linear function
      >>> pyro_linear_fn = lambda x: pyro.module("linear", linear)(x)
      >>> kernel = gp.kernels.Matern52(input_dim=3, lengthscale=torch.ones(3))
      >>> warped_kernel = gp.kernels.Warping(kernel, pyro_linear_fn)
  
  Reference:
  
  [1] `Deep Kernel Learning`,
  Andrew G. Wilson, Zhiting Hu, Ruslan Salakhutdinov, Eric P. Xing
  
  :param callable iwarping_fn: An input warping function :math:`f`.
  :param list owarping_coef: A list of coefficients of the output warping polynomial.
      These coefficients must be non-negative.
code: def forward(self, X, Z=None, diag=False):
      if self.iwarping_fn is None:
          K_iwarp = self.kern(X, Z, diag=diag)
      elif Z is None:
          K_iwarp = self.kern(self.iwarping_fn(X), None, diag=diag)
      else:
          K_iwarp = self.kern(
              self.iwarping_fn(X), self.iwarping_fn(Z), diag=diag
          )
  
      if self.owarping_coef is None:
          return K_iwarp
      else:
          return _Horner_evaluate(K_iwarp, self.owarping_coef)
  
imports: import numbers
  from pyro.contrib.gp.parameterized import Parameterized
label_desc: Use image node_id 2 for calling the Warping obj's underlying member method code with example usage: obj.forward(X, Z, diag) and returns: K_iwarp, _Horner_evaluate