record_hessian Namespace Reference

Data Structures
class	HessianComputer
class	HessianObserver
struct	HessianVector

Typedefs
using	HessianMap = std::unordered_map< const luci::CircleNode *, std::vector< float > >
	Record approximated hessian matrix from GPTQ paper(https://arxiv.org/abs/2210.17323).
using	HessianVectorMap = std::unordered_map< const luci::CircleNode *, HessianVector >

Functions
void	unfold (std::vector< float > &buf, uint32_t input_n, uint32_t input_h, uint32_t input_w, uint32_t input_c, uint32_t stride_h, uint32_t stride_w, uint32_t dilation_h, uint32_t dilation_w, uint32_t kernel_h, uint32_t kernel_w, uint32_t kernel_ic)
	unfold the vector with NHWC shape, inherently acting in an in-place manner.

Typedef Documentation

HessianMap

using record_hessian::HessianMap = typedef std::unordered_map<const luci::CircleNode *, std::vector<float> >

Record approximated hessian matrix from GPTQ paper(https://arxiv.org/abs/2210.17323).

Definition at line 35 of file HessianComputer.h.

HessianVectorMap

using record_hessian::HessianVectorMap = typedef std::unordered_map<const luci::CircleNode *, HessianVector>

Definition at line 36 of file HessianComputer.h.

Function Documentation

unfold()

void record_hessian::unfold	(	std::vector< float > &	buf,
		uint32_t	input_n,
		uint32_t	input_h,
		uint32_t	input_w,
		uint32_t	input_c,
		uint32_t	stride_h,
		uint32_t	stride_w,
		uint32_t	dilation_h,
		uint32_t	dilation_w,
		uint32_t	kernel_h,
		uint32_t	kernel_w,
		uint32_t	kernel_ic
	)

unfold the vector with NHWC shape, inherently acting in an in-place manner.

Note

(N, H, W, C) -> (N, L, K_h * K_w * C). See details(https://pytorch.org/docs/stable/generated/torch.nn.Unfold.html).

Definition at line 29 of file HessianComputer.cpp.

{
  assert(input_n > 0 && input_h > 0 && input_w > 0 && input_c > 0);
  assert(stride_h > 0 && stride_w > 0);
  assert(kernel_h > 0 && kernel_w > 0 && kernel_ic > 0);
 
  if (input_c != kernel_ic)
    throw std::runtime_error("RecordHessian: Input channels do not match kernel channels.");
  uint32_t out_height = (input_h - dilation_h * (kernel_h - 1) - 1) / stride_h + 1;
  uint32_t out_width = (input_w - dilation_w * (kernel_w - 1) - 1) / stride_w + 1;
  uint32_t patch_size = kernel_h * kernel_w * kernel_ic;
  std::vector<float> unfolded_buf(input_n * out_height * out_width * patch_size, 0.0f);
 
  uint32_t index = 0;
  uint32_t in_y, in_x;
  for (uint32_t n = 0; n < input_n; ++n)
  {
    for (uint32_t y = 0; y < out_height; ++y)
    {
      for (uint32_t x = 0; x < out_width; ++x)
      {
        for (uint32_t in_c = 0; in_c < input_c; ++in_c)
        {
          for (uint32_t ky = 0; ky < kernel_h; ++ky)
          {
            for (uint32_t kx = 0; kx < kernel_w; ++kx)
            {
              in_y = y * stride_h + ky * dilation_h;
              in_x = x * stride_w + kx * dilation_w;
              if (in_y < input_h && in_x < input_w)
              {
                unfolded_buf[index] = buf[((n * input_h + in_y) * input_w + in_x) * input_c + in_c];
              }
              index++;
            }
          }
        }
      }
    }
  }
 
  buf.swap(unfolded_buf);
}