def testFullyConnectedLayerParamsTensorToMat2d(self):
   with ops.Graph().as_default(), self.test_session() as sess:
     random_seed.set_random_seed(200)
     layer_params = self._fully_connected_layer_params()
     output = utils.layer_params_to_mat2d(layer_params[0])
     self.assertListEqual([2, 2], output.get_shape().as_list())
     self.assertAllClose(sess.run(output), np.array([[1., 2.], [4., 3.]]))

 def multiply_matpower(self, vector, exp):
   reshaped_vector = utils.layer_params_to_mat2d(vector)
   reshaped_out = self._output_factor.right_multiply_matpower(
       reshaped_vector, exp, self._output_damping_func)
   reshaped_out = self._input_factor.left_multiply_matpower(
       reshaped_out, exp, self._input_damping_func)
   if self._renorm_coeff != 1.0:
     renorm_coeff = math_ops.cast(self._renorm_coeff, dtype=reshaped_out.dtype)
     reshaped_out *= math_ops.cast(renorm_coeff**exp, dtype=reshaped_out.dtype)
   return utils.mat2d_to_layer_params(vector, reshaped_out)

 def multiply_inverse(self, vector):
   left_factor_inv = self._input_factor.get_inverse(self._input_damping)
   right_factor_inv = self._output_factor.get_inverse(self._output_damping)
   reshaped_vector = utils.layer_params_to_mat2d(vector)
   reshaped_out = math_ops.matmul(left_factor_inv,
                                  math_ops.matmul(reshaped_vector,
                                                  right_factor_inv))
   if self._renorm_coeff != 1.0:
     reshaped_out /= math_ops.cast(
         self._renorm_coeff, dtype=reshaped_out.dtype)
   return utils.mat2d_to_layer_params(vector, reshaped_out)

 def multiply(self, vector):
   left_factor = self._input_factor.get_cov()
   right_factor = self._output_factor.get_cov()
   reshaped_vector = utils.layer_params_to_mat2d(vector)
   reshaped_out = (math_ops.matmul(reshaped_vector, right_factor) +
                   self._output_damping * reshaped_vector)
   reshaped_out = (math_ops.matmul(left_factor, reshaped_out) +
                   self._input_damping * reshaped_out)
   if self._renorm_coeff != 1.0:
     reshaped_out *= math_ops.cast(
         self._renorm_coeff, dtype=reshaped_out.dtype)
   return utils.mat2d_to_layer_params(vector, reshaped_out)

  def multiply(self, vector):
    """Approximate damped Fisher-vector product.

    Args:
      vector: Tensor or 2-tuple of Tensors. if self._has_bias, Tensor of shape
        [input_size, output_size] corresponding to layer's weights. If not, a
        2-tuple of the former and a Tensor of shape [output_size] corresponding
        to the layer's bias.

    Returns:
      Tensor of the same shape, corresponding to the Fisher-vector product.
    """
    reshaped_vect = utils.layer_params_to_mat2d(vector)
    reshaped_out = reshaped_vect * (self._factor.get_cov() + self._damping)
    return utils.mat2d_to_layer_params(vector, reshaped_out)

 def testConvLayerParamsTupleToMat2d(self):
   with ops.Graph().as_default():
     random_seed.set_random_seed(200)
     layer_params = self._conv_layer_params()
     output = utils.layer_params_to_mat2d(layer_params)
     self.assertListEqual([2 * 2 * 3 + 1, 4], output.get_shape().as_list())

 def multiply(self, vector):
   reshaped_vect = utils.layer_params_to_mat2d(vector)
   reshaped_out = self._factor.left_multiply(
       reshaped_vect, self._damping)
   return utils.mat2d_to_layer_params(vector, reshaped_out)