code: def simulated_quantize(x, num_bits, noise):
    
    shape = x.get_shape().as_list()
    if not (len(shape) >= 2 and shape[-1] > 1):
      return x
    max_abs = tf.reduce_max(tf.abs(x), -1, keepdims=True) + 1e-9
    max_int = 2 ** (num_bits - 1) - 1
    scale = max_abs / max_int
    x /= scale
    x = tf.floor(x + noise)
    # dequantize before storing (since this is a simulation)
    x *= scale
    return x
docs: Simulate quantization to num_bits bits, with externally-stored scale.
  
    num_bits is the number of bits used to store each value.
    noise is a float32 Tensor containing values in [0, 1).
    Each value in noise should take different values across
    different steps, approximating a uniform distribution over [0, 1).
    In the case of replicated TPU training, noise should be identical
    across replicas in order to keep the parameters identical across replicas.
  
    The natural choice for noise would be tf.random_uniform(),
    but this is not possible for TPU, since there is currently no way to seed
    the different cores to produce identical values across replicas.  Instead we
    use noise_from_step_num() (see below).
  
    The quantization scheme is as follows:
  
    Compute the maximum absolute value by row (call this max_abs).
    Store this either in an auxiliary variable or in an extra column.
  
    Divide the parameters by (max_abs / (2^(num_bits-1)-1)).  This gives a
    float32 value in the range [-2^(num_bits-1)-1, 2^(num_bits-1)-1]
  
    Unbiased randomized roundoff by adding noise and rounding down.
  
    This produces a signed integer with num_bits bits which can then be stored.
  
    Args:
      x: a float32 Tensor
      num_bits: an integer between 1 and 22
      noise: a float Tensor broadcastable to the shape of x.
  
    Returns:
      a float32 Tensor