What is the resolution of the control parameters in D-Wave devices?
I couldn't find this easily on D-Wave documentation, only on third-party papers.
Even though the sampler takes double-precision floating point values as inputs for h and J, what is the actual precision to which these values are scaled when using auto_scale?
I've read that it is "4 to 5" precision bits, but I'd like to know where I can find the official documentation of this.
Comments
https://docs.dwavequantum.com/en/latest/quantum_research/errors.html
There are a couple of factors at play here.
To understand why it's about "4 to 5 precision bits", we first need to look at some documentation.
One really useful place to look is the ICE (integrated control errors) documentation.
It outlines a number of sources of errors which will also come into play, however, figure 95 describes the "4 to 5 bits of precision".
Here is a link to the ICE documentation:
Here is a link to the figure mentioned above, which is in the section "DAC Quantization" in "Sources of ICE":
https://docs.dwavequantum.com/en/latest/quantum_research/errors.html#qpu-ice-dac-quantization
The two charts in this figure correspond to h and j values as the labels suggest, h values being linear/qubit biases, and j being quadratic/coupler biases.
To get the specs for a specific solver, you can view them in the documentation:
https://docs.dwavequantum.com/en/latest/quantum_research/solver_properties_specific.html
See also:
https://support.dwavesys.com/hc/en-us/articles/360005268633-QPU-Specific-Physical-Properties
In these documents, figures 8 and 9 correspond to the ICE figure 95 mentioned above.
To read these diagrams, you have to think of what value you plan to program into the h or j value and then see what error value it corresponds to.
If you want to program a value of -1 for an h input, for example, you will have an error of about 0.005, which means that value would be in the range of -1 +/- 0.005 (i.e. between -1.005 and -0.995).
Likewise if you want to program a value of +1 for an h input, you will have an error of about 0.013, which means the value would be in the range of +1 +/- 0.013 (i.e. between +0.98705 and +1.013).
Note that the h and j quantization errors behave differently for the same input values (i.e. an input of +1 has an error of about 0.013 for h and 0.0002 for j.
Again, I want to stress that this is not the only source of error, but is a good place to start when considering precision/quantization.
It is important to look at the other sources of ICE to consider if these will also affect a problem.
Another thing to consider is that these precision values are not the same as numerical precision values.
With numerical precision values a failure is guaranteed if the precision is too small for the inputs.
For the QPU, the only cases that matter are those where nearby energy states exist that can be mistaken for optimal energy states.
If the maximum quantization error values do not result in nearby (i.e. equally optimal or more optimal, but invalid) energy states, then the precision might not make a difference to the solution at all.
I hope this was helpful!
Thank you!
Just to make sure I understand, how are those quantization errors put into terms of precision bits?
I'll give it a try...
e.g. DW_2000Q_2_1 has a min error of 0.002 and a max error of 0.016 for values of h in the range [-2, 2], therefore, in a scale [0, 1], h values in DW_2000Q_2_1 can be configured with precision steps of 0.0005 for values close to 0, and 0.004 for values close to 1; or, reliably, in unit steps within [0,250] --- only using the max here. This gives me a resolution of 7.
I understand that the source of errors is more complex, and that the resolution would only represent worst case.
No problem!
I believe you are on the right track.
Keep in mind these are all rough, eyeball values.
So for h values on the DW_2000Q_2_1 that are near -1 the error is about +/- 0.005, for +1 it's about 0.012, and for +2 it's about 0.015.
This means that if you input values [1, -1, 2], you might get [1.012, -1.003, 1.985], or [0.989, -1, 2], or [1.01, -0.998, 1.985], etc.
Another way of looking at this is that an input value of -0.01 will effectively be a value between -0.018 and -0.002, since it will be -0.01 +/- 0.008.
So, to convert this to precision bits, you could look at the two extremes.
For h we have a range of 4 and an error of 0.003 at one end and 0.015 at the other end.
That gives approximate values of:
log(4/0.003) = 5.4
log(4/0.015) = 7.6
As you've pointed out, these values seem a lot higher, and they are!
That's because there are a bunch of other sources of error that will bring these values down to 4 to 5 ish precision bits.
Long answer short:
You are correct! The values are higher, but we need to take into account the rest of the sources of ICE.
Also note that binary values are more accurate (but again we need to take into account sources of ICE):
log(4/0.003)/log(2) = 7.8
log(4/0.015)/log(2) = 11.0
This is exactly what I was looking for. Thanks a lot!
Happy to help!
Please sign in to leave a comment.