Function quantize_row_q2_K_ref

src/quant.cpp:147–215

}

void quantize_row_q2_K_ref(const float * __restrict__ x, block_q2_K * __restrict__ y, int64_t k) {
  assert(k % QK_K == 0);
  const int nb = k / QK_K;

  uint8_t L[QK_K];
  uint8_t Laux[16];
  float   weights[16];
  float mins[QK_K/16];
  float scales[QK_K/16];

  const float q4scale = 15.f;

  for (int i = 0; i < nb; i++) {
    float max_scale = 0; // as we are deducting the min, scales are always positive
    float max_min = 0;
    for (int j = 0; j < QK_K/16; ++j) {
      for (int l = 0; l < 16; ++l) weights[l] = fabsf(x[16*j + l]);
      scales[j] = make_qkx2_quants(16, 3, x + 16*j, weights, L + 16*j, &mins[j], Laux, -0.5f, 0.1f, 15, true);
      float scale = scales[j];
      if (scale > max_scale) {
        max_scale = scale;
      }
      float min = mins[j];
      if (min > max_min) {
        max_min = min;
      }
    }

    if (max_scale > 0) {
      float iscale = q4scale/max_scale;
      for (int j = 0; j < QK_K/16; ++j) {
        int l = nearest_int(iscale*scales[j]);
        y[i].scales[j] = l;
      }
      y[i].d = float_to_half(max_scale/q4scale);
    } else {
      for (int j = 0; j < QK_K/16; ++j) y[i].scales[j] = 0;
      y[i].d = float_to_half(0.f);
    }
    if (max_min > 0) {
      float iscale = q4scale/max_min;
      for (int j = 0; j < QK_K/16; ++j) {
        int l = nearest_int(iscale*mins[j]);
        y[i].scales[j] |= (l << 4);
      }
      y[i].dmin = float_to_half(max_min/q4scale);
    } else {
      y[i].dmin = float_to_half(0.f);
    }
    for (int j = 0; j < QK_K/16; ++j) {
      const float d = half_to_float(y[i].d) * (y[i].scales[j] & 0xF);
      if (!d) continue;
      const float dm = half_to_float(y[i].dmin) * (y[i].scales[j] >> 4);
      for (int ii = 0; ii < 16; ++ii) {
        int l = nearest_int((x[16*j + ii] + dm)/d);
        l = std::max(0, std::min(3, l));
        L[16*j + ii] = l;
      }