Solution options to Large-scale mixed models
Hello,
I'm trying to gauge the potential for the Leap Solvers to solve large scale problems, approximately 30k binary variables, and 20k real-valued variables. (I assume hybrid solvers are the best for large-scale problems, but let me know if that's not the case).
According to Fiona's answer here: https://support.dwavesys.com/hc/en-us/community/posts/360029426154-Solving-a-large-QUBO-problem-, the solver "hybrid_v1" is able to solve up to 10K variables "fully-connected".
1). I know there is an important distinction between "physical qubits" and "logical qubits". Does "10K variables" mean Logical qubits as part of the original model? Or is it 10K "physical qubits" (which means 100 logical qubits)? Also, does "10k variables" mean binary variables, real-valued variables, or either one?
2). I don't see "hybrid_v1" on my dashboard, but I do see the following:
- hybrid_binary_quadratic_model_version2p
- hybrid_constrained_quadratic_model_version1p
- hybrid_discrete_quadratic_model_version1p
- Advantage2_prototype1.1
- Advantage_system4.1
- Advantage_system6.2
Since that post was 3 years ago, does "hybrid_v1" go under a different name now? Or does it seem like I do not have access to this solver?
Comments
Jordan,
You are correct; using hybrid solvers are absolutely the best way to go for large-scale problems!
1. With the hybrid_v1 solver "10k variables" would refer to 10k logical qubits. All of our hybrid solvers' variable limits (linked here) are given as logical variables as opposed to physical qubits. When using the pure QPU without any hybrid offerings, the distinction between logical and physical qubits becomes much more important. Hybrid tools abstract that step away!
2. The six items you listed refer to three hybrid and three pure quantum solvers, respectively. Since that post hybrid_v1 was replaced with our more advanced hybrid solvers.
For large-scale applications with binary and real-valued variables, you should likely use our Constrained Quadratic Model (CQM) hybrid solver hybrid_constrained_quadratic_model_version1p, which is callable as LeapHybridCQMSampler. This is the only solver we offer which is capable of handling real-valued variables.
I hope that this helps,
Ken
Thanks, very helpful. I have 2 follow-up questions. So, it seems like BQMs are obviously the best solver if your problem involves only binary variables. However, I've seen several types of samplers applied to BQMs. For example, I've seen both the EmbeddingComposite and LeapHybridSampler used. Is there a clear advantage of using one sampler over the other when solving BQMs?
Thanks for your continued attention to this question. I guess my understanding of the pdf you linked to is slightly different now. So, correct me if I'm wrong: The biggest divider of performance between BQM/CQM is not only domain of your variables, but also whether it is constrained/unconstrained ?
Second, but related question: Is there an easy way to convert a BQM to a CQM to avoid re-writing it again from scratch? (And vice versa from CQM to BQM?).
Yes, it is important to consider constraints when selecting your solver. The CQM object handles constraints separately from the objective while BQMs have to include the constraints in the main objective function as a penalty model.
There is a from_bqm method which can transform a BQM to a CQM. It is important to note that from_bqm does not convert the penalty functions of the BQM into the CQM's versions of constraints so you would likely want to reconstruct the CQM from scratch.
We do not offer a "from_cqm" method. To do so you must manually transform the CQM's constraints into penalty functions and add them to the QUBO.
Thanks, very helpful. Last thing - if `fom_bqm` doesn't convert penalty functions into constraints, I'm wondering what is it useful for?. I can't find any documentation/examples on it except for the source code: https://github.com/dwavesystems/dimod/blob/0.12.14/dimod/constrained/constrained.py#L900.
The from_bqm function can be useful if you're comparing LeapHybridSolver and LeapHybridCQMSolver performance on problems which are formulated identically.
I see. Given an unconstrained binary problem, one could compare the performance of LeapHybridSolver, and LeapHybridCQMSolver using `from_bqm`. Thanks Ken, I learned a lot from this discussion.
Hi Ken. Sorry to open this up again, but in regards to your comment https://support.dwavesys.com/hc/en-us/community/posts/17970984255511/comments/21519333112983 why is it that I see a method `dimod.cqm_to_bqm` here: https://docs.ocean.dwavesys.com/en/stable/docs_dimod/reference/generated/dimod.cqm_to_bqm.html#dimod.cqm_to_bqm. And how is that different from the functionality of "from_cqm" that you referred to in your comment?
Thanks again.
Jordan,
I'm happy to reopen this discussion! It appears that I was incorrect, and you have found our "from_cqm" function that I did not realize existed. Many of our other conversion functions take the form "from_***" and so I had simply never come across "cqm_to_bqm."
This function has an extra step that the "from_bqm" function would not have: converting the innate constraint representations of CQM objects to the penalty functions of BQM objects. This means that Lagrange parameters need to be specified. The documentation page you linked in your comment indicates that it defaults to 10*(largest bias) but can be controlled by the user.
Please sign in to leave a comment.