Here are some pictures of the most recent Washington generation chips. These are C16 chips — 16*16*8 = 2,048 physical qubits. Enjoy!
Colin Williams recently presented some new results in the UK. Here you can see some advance looks at the first results on up to 933 qubits. These are very early days for the Washington generation. Things will get a lot better on this one before it’s released (Rainier and Vesuvius both took 7 generations of iteration before they stabilized). But some good results on the first few prototypes.
One of the interesting things we’re playing with now is the following idea (starts at around 22:30 of the presentation linked to above). Imagine instead of measuring the time to find the ground state of a problem with some probability, instead measure the difference between the ground state energy and the median energy of samples returned, as a function of time and problem size. If we do this what we find is that the median distance from the ground state scales like where is the number of qubits, and is the number of couplers in the instance (proportional to for the current generation). More important, the scaling with time flattens out and becomes nearly constant. This is consistent with the main error mechanism being mis-specification of problem parameters in the Hamiltonian (what we call ICE or Intrinsic Control Errors).
In other words, the first sample from the processor (ie constant time), with high probability, will return a sample no further than from the ground state. That’s pretty cool.
Hi everyone! Sorry for being silent for a while. Working. :-)
Two interesting papers appeared on the arxiv this week, both from people at Ames working on their D-Wave Two.
A new paper published today in Phys Rev X. It demonstrates eight qubit entanglement in a D-Wave processor, which I believe is a world record for solid state qubits. This is an exceptional paper with an important result. The picture to the left measures a quantity that, if negative, verifies entanglement. The quantity s is the time — the quantum annealing procedure goes from the left to the right, with entanglement maximized near the area where the energy gap is smallest.
Here is the abstract:
Entanglement lies at the core of quantum algorithms designed to solve problems that are intractable by classical approaches. One such algorithm, quantum annealing (QA), provides a promising path to a practical quantum processor. We have built a series of architecturally scalable QA processors consisting of networks of manufactured interacting spins (qubits). Here, we use qubit tunneling spectroscopy to measure the energy eigenspectrum of two- and eight-qubit systems within one such processor, demonstrating quantum coherence in these systems. We present experimental evidence that, during a critical portion of QA, the qubits become entangled and entanglement persists even as these systems reach equilibrium with a thermal environment. Our results provide an encouraging sign that QA is a viable technology for large scale quantum computing.
Here’s a neat paper from UCL and USC researchers ruling out several classical models for the D-Wave Two, including the SSSV model (“…the SSSV model can be rejected as a classical model for the D-Wave device”), and giving indirect evidence for up to 40 qubit entanglement in a real computer processor.
There are a lot of physical neural nets on planet Earth. Just the humans alone account for about 7.139 billion of them. You have one, hidden in close to perfect darkness inside your skull — a complex graph with about 100 billion neurons and 0.15 quadrillion connections between those neurons.
Of course we’d like to be able to build machines that do what that lump of squishy pink-gray goo does. Mostly because it’s really hard and therefore fun. But also because having an army of sentient robots would be super sweet. And it seems sad that all matter can’t be made aware of its own mortality and suffer the resultant existential angst. Stupid 5 billion year old rocks. See how smug you are when you learn about the heat death of the universe.
One thing that is also hard, but not that hard, is trying to build different kinds of physical neural nets that are somewhat inspired by our brains. ‘Somewhat inspired’ is a little vague. We don’t actually understand a lot about how brains actually work. But we know a bit. In some cases, such as our visual perception system, we know quite a bit. This knowledge has really helped the algorithmic side of building better and better learning systems.
So let’s explore engineering our own non-biological but biologically inspired physical neural nets. Does this idea make sense? How would we use such things?
Training a Deep Boltzmann Machine
One kind of neural net that’s quite interesting is a Deep Boltzmann Machine (DBM). Recall that a DBM can be thought of as a graph comprising both visible and hidden units. The visible units act as an interface layer between the external universe that the DBM is learning from, and the hidden units which are used to build an internal representation of the DBM’s universe.
A method for training a DBM was demonstrated in this paper. As we discussed earlier, the core mathematical problem for training a DBM is sampling from two different distributions — one where the visible units are clamped to data (the Creature is ‘looking at the world’), and one where the entire network is allowed to run freely (the Creature is ‘dreaming about the world’). In the general case, this is hard to do because the distributions we need to sample from are Boltzmann distributions over all the unclamped nodes of the network. In practice, the connectivity of the graph is restricted and approximate techniques are used to perform the sampling. These ideas allow very large networks to be trained, but this comes with a potentially serious loss of modeling efficiency.
Using physical hardware to perform the sampling steps
Because the sampling steps are a key bottleneck for training DBMs, maybe we could think of a better way to do it. What if we built an actual physical neural net? Could we design something that could do this task better than the software approaches typically used?
Here’s the necessary ingredients:
- A two-state device that would play the part of the neurons
- The ability to locally programmatically bias each neuron to preferentially be in either of their states
- Communications channels between pairs of neurons, where the relative preference of the pair could be set programmatically
- The ability of the system to reach thermal equilibrium with its environment at a temperature with energy scale comparable to the energy scales of the individual neurons
- The ability to read out each neuron’s state with high fidelity
If you had these ingredients, you could place the neurons where you wanted them for your network; connect them like you want for your network; program in their local biases and connection weights; allow them to reach thermal equilibrium (i.e. reach a Boltzmann distribution); and then sample by measuring their states.
The key issue here is step 4. The real question, which is difficult to answer without actually building whatever you have in mind, is whether or not whatever the distribution you get in hardware is effective for learning or not. It might not be Boltzmann, because the general case takes exponential time to thermally equilibrate. However the devil is in the details here. The distribution sampled from when alternating Gibbs sampling is done is also not Boltzmann, but it works pretty well. A physical system might be equilibrated well enough by being smart about helping it equilibrate, using sparsely connected graphs, principles like thermal and / or quantum annealing, or other condensed matter physics / statistical mechanics inspired tricks.
The D-Wave architecture satisfies all five of these requirements. You can read about it in detail here. So if you like you can think of that particular embodiment in what follows, but this is more general than that. Any system meeting our five requirements might also work. In the D-Wave design, the step 4 equilibration algorithm is quantum annealing in the presence of a fixed physical temperature and a sparsely locally connected hardware graph, which seems to work very well in practice.
One specific idea for doing this
Let’s focus for a moment on the Vesuvius architecture. Here’s what it looks like for one of the chips in the lab. The grey circles are the qubits (think of them as neurons in this context) and the lines connecting them are the programmable pairwise connection strengths (think of them as connection strengths between neurons).
There are about 500 neurons in this graph. That’s not very many, but it’s enough to maybe do some interesting experiments. For example, the MNIST dataset is typically analyzed using 784 visible units, and a few thousand hidden units, so we’re not all that far off.
Here’s an idea of how this might work. In a typical DBM approach, there are multiple layers. Each individual layers has no connections within it, but adjacent layers are fully connected. Training proceeds by doing alternating Gibbs sampling between two sets of bipartite neurons — none of the even layer neurons are connected, none of the odd layer neurons are connected, but there is dense connectivity between the two groups. The two groups are conditionally independent because of the bipartite structure.
We could try the following. Take all of the neurons in the above graph, and ‘stretch them out’ in a line. The vertices will then have the connections from the above graph. Here’s the idea for a smaller subgraph comprising a single unit cell so you can get the idea.
If you do this with the entire Vesuvius graph, the resultant building block is a set of about 500 neurons with sparse inter-layer connectivity with the same connectivity structure as the Vesuvius architecture.
If we assume that we can draw good Boltzmann-esque samples from this building block, we can tile out enough of them to do what we want using the following idea.
To train this network, we do alternating Gibbs sampling as in a standard DBM, but using the probability distributions obtained by actually running the Vesuvius graph in hardware (biased suitably by the clamped variables) instead of the usual procedure.
What might this buy us?
Alright so let’s imagine we could equilibrate and draw samples from the above graph really quickly. What does this buy us?
Well the obvious thing is that you can now learn about possible inter-layer correlations. For example, in an image, we know that pixels have local correlations — pixels that are close to each other in an image will tend to be correlated. This type of correlation might be very useful for our model to be able to directly learn. This is the sort of thing that inter-layer correlations within the visible layer might be useful for.
Another interesting possibility is that these inter-layer connections could represent the same input but at different times, the intuition being that inputs that are close in time are also likely to be correlated.
OK well why don’t you try it out?
That is a fabulous idea! I’m going to try this on MNIST and see if I can make it work. Stand by!