Gostaria de saber como um trabalho para um dispositivo D-Wave é escrito em código e enviado ao dispositivo.

Na resposta, seria melhor ver um exemplo específico disso para um problema simples. Eu acho que o "Hello World" de um dispositivo D-Wave seria algo como encontrar os estados básicos de um modelo Ising 2D simples , já que esse é o tipo de problema percebido diretamente pelo hardware. Talvez esse seja um bom exemplo para ver. Mas se aqueles com experiência em um exemplo alternativo forem adequados, ficaria feliz em ver uma alternativa.

O equivalente 'Hello World' no mundo D-Wave é o exemplo do tabuleiro de xadrez 2D. Neste exemplo, você recebe o seguinte gráfico quadrado com 4 nós:

                                                 

Vamos definir que vértice σ i preto se σ i = - 1 e branco se σ i = + 1 . O objetivo é criar um padrão quadriculado com os quatro vértices no gráfico. Há várias maneiras de definir h e J para alcançar este resultado. Primeiro de tudo, existem duas soluções possíveis para esse problema:$\sigma_{i}$$\sigma_{i} = -1$$\sigma_{i} = +1$$h$$J$

              

O recozedor quântico D-Wave minimiza o ising hamiltoniano que definimos e é importante entender o efeito das diferentes configurações do acoplador. Considere, por exemplo , o acoplador :$J_{0,1}$

Se o definirmos como , o Hamiltoniano será minimizado se ambos os qubits tiverem o mesmo valor. Dizemos que acopladores negativos se correlacionam . Enquanto que se o definirmos como J 0 , 1 = + 1 , o Hamiltoniano será minimizado se os dois qubits tiverem valores opostos. Assim, acopladores positivos se correlacionam .$J_{0,1}=-1$$J_{0,1}=+1$

No exemplo do tabuleiro de damas, queremos anti-correlacionar cada par de qubits vizinhos, o que dá origem ao seguinte hamiltoniano:

$$H = \sigma_{0}\sigma_{1} + \sigma_{0}\sigma_{2} + \sigma_{1}\sigma_{3} + \sigma_{2}\sigma_{3}$$

$0$$\sigma_{0}=-1$$h_{0}=1$

$$H = \sigma_{0} + \sigma_{0}\sigma_{1} + \sigma_{0}\sigma_{2} + \sigma_{1}\sigma_{3} + \sigma_{2}\sigma_{3}$$

Então, vamos codificá-lo!

NOTA: VOCÊ PRECISA acessar o serviço em nuvem da D-Wave para que tudo funcione.

Primeiro, verifique se você tem o pacote Python dwave_sapi2( https://cloud.dwavesys.com/qubist/downloads/ ) instalado. Tudo será Python 2.7, já que o D-Wave atualmente não suporta nenhuma versão superior do Python. Dito isto, vamos importar o essencial:

from dwave_sapi2.core import solve_ising
from dwave_sapi2.embedding import find_embedding, embed_problem, unembed_answer
from dwave_sapi2.util import get_hardware_adjacency
from dwave_sapi2.remote import RemoteConnection

Para conectar-se à API do D-Wave Solver, você precisará de um token de API válido para o solucionador SAPI, o URL da SAPI e decidir qual processador quântico deseja usar:

DWAVE_SAPI_URL = 'https://cloud.dwavesys.com/sapi'
DWAVE_TOKEN = [your D-Wave API token]
DWAVE_SOLVER = 'DW_2000Q_VFYC_1'

Eu recomendo usar a quimera virtual de rendimento total D-Wave 2000Q (VFYC), que é um chip totalmente funcional sem qubits mortos! Aqui está o layout do chip Chimera:

Neste ponto, estou dividindo o tutorial em duas partes distintas. Na primeira seção, estamos incorporando manualmente o problema no gráfico de hardware do Chimera e na segunda seção, estamos usando as heurísticas de incorporação da D-Wave para encontrar uma incorporação de hardware.

Incorporação manual

---

A célula unitária no canto superior esquerdo no layout do chip D-Wave 2000Q acima é assim:

$0$$1$$0\rightarrow0$$1\rightarrow4$$2\rightarrow7$$3\rightarrow3$$h$$J$

J = {(0,4): 1, (4,3): 1, (3,7): 1, (7,0): 1}
h = [-1,0,0,0,0,0,0,0,0]

$h$

connection = RemoteConnection(DWAVE_SAPI_URL, DWAVE_TOKEN)
solver = connection.get_solver(DWAVE_SOLVER)

Agora, podemos definir o número de leituras e optar answer_modepor ser "histograma", que já classifica os resultados pelo número de ocorrências para nós. Agora estamos prontos para resolver a instância de Ising com o recozedor quântico D-Wave:

params = {"answer_mode": 'histogram', "num_reads": 10000}
results = solve_ising(solver, h, J, **params)
print results

Você deve obter o seguinte resultado:

{
  'timing': {
    'total_real_time': 1655206,
    'anneal_time_per_run': 20,
    'post_processing_overhead_time': 13588,
    'qpu_sampling_time': 1640000,
    'readout_time_per_run': 123,
    'qpu_delay_time_per_sample': 21,
    'qpu_anneal_time_per_sample': 20,
    'total_post_processing_time': 97081,
    'qpu_programming_time': 8748,
    'run_time_chip': 1640000,
    'qpu_access_time': 1655206,
    'qpu_readout_time_per_sample': 123
  },
  'energies': [-5.0],
  'num_occurrences': [10000],
  'solutions': [
      [1, 3, 3, 1, -1, 3, 3, -1, {
          lots of 3 's that I am omitting}]]}

energies$-5.0$$3$$0\rightarrow0$$4\rightarrow1$$7\rightarrow2$$3\rightarrow3$$[1, -1, -1, 1]$

Incorporação heurística

---

$J$$h$

J = {(0,1): 1, (0,2): 1, (1,3): 1, (2,3): 1}
h = [-1,0,0,0]

Novamente estabelecemos a conexão remota e obtemos a instância do solucionador D-Wave 2000Q VFYC:

connection = RemoteConnection(DWAVE_SAPI_URL, DWAVE_TOKEN)
solver = connection.get_solver(DWAVE_SOLVER)

Para encontrar uma incorporação do nosso problema, precisamos primeiro obter a matriz de adjacência do gráfico de hardware atual:

adjacency = get_hardware_adjacency(solver)

Agora vamos tentar encontrar uma incorporação do nosso problema:

embedding = find_embedding(J.keys(), adjacency)

Se você estiver lidando com grandes instâncias Ising, convém procurar por incorporações em vários encadeamentos (paralelizados por várias CPUs) e selecionar a incorporação com o menor comprimento de cadeia! Uma cadeia é quando vários qubits são forçados a agir como um único qubit para aumentar o grau de conectividade. No entanto, quanto maior a cadeia, maior a probabilidade de que ela se quebre. E correntes quebradas dão maus resultados!

Agora estamos prontos para incorporar nosso problema no gráfico:

[h, j0, jc, embeddings] = embed_problem(h, J, embedding, adjacency)

j0jc$J$

J = j0.copy()
J.update(jc)

Agora, estamos prontos para resolver o problema incorporado:

params = {"answer_mode": 'histogram', "num_reads": 10000}
raw_results = solve_ising(solver, h, J, **params)

print 'Lowest energy found: {}'.format(raw_results['energies'])
print 'Number of occurences: {}'.format(raw_results['num_occurrences'])

A raw_resultsvontade não fará sentido para nós, a menos que resolvamos o problema. No caso, algumas cadeias quebraram, estamos corrigindo-as através de uma votação majoritária, conforme definido pelo argumento opcional broken_chains:

unembedded_results = unembed_answer(raw_results['solutions'],
                                    embedding, broken_chains='vote')

print 'Solution string: {}'.format(unembedded_results)

Se você executar isso, deverá obter o resultado correto em todas as leituras:

Lowest energy found: [-5.0]
Number of occurences: [10000]
Solution string: [[1, -1, -1, 1]]

Espero que isso tenha respondido à sua pergunta e eu recomendo verificar todos os parâmetros adicionais que você pode passar para a solve_isingfunção para melhorar a qualidade de suas soluções, como num_spin_reversal_transformsou postprocess.

O título e o corpo da pergunta parecem fazer duas perguntas diferentes. No título, você pergunta "Como você escreve um programa simples para um dispositivo D-Wave?", Enquanto no corpo da pergunta você pergunta como encontrar os estados básicos de um modelo Ising 2D simples usando o hardware subjacente do D-Wave dispositivo e qual seria o código correspondente (que é uma pergunta mais específica).

Responderei ao primeiro, pois é a pergunta mais geral.

De acordo com a página do software D-Wave :

O sistema D-Wave 2000Q fornece uma API da Internet padrão (baseada em serviços RESTful), com bibliotecas de clientes disponíveis para C / C ++, Python e MATLAB. Essa interface permite que os usuários acessem o sistema como um recurso de nuvem em uma rede ou integrados a seus ambientes de computação de alto desempenho (HPC) e data centers. O acesso também está disponível através do serviço de nuvem hospedado da D-Wave. Usando as ferramentas de desenvolvimento e as bibliotecas clientes da D-Wave, os desenvolvedores podem criar algoritmos e aplicativos em seus ambientes existentes usando ferramentas padrão do setor.

Embora os usuários possam enviar problemas ao sistema de várias maneiras diferentes, em última análise, um problema representa um conjunto de valores que correspondem aos pesos dos qubits e à força dos acopladores. O sistema leva esses valores junto com outros parâmetros especificados pelo usuário e envia uma única instrução de máquina quântica (QMI) para a QPU. As soluções de problemas correspondem à configuração ideal de qubits encontrada; isto é, os pontos mais baixos no cenário energético. Esses valores são retornados ao programa do usuário pela rede.

Como os computadores quânticos são probabilísticos e não determinísticos, vários valores podem ser retornados, fornecendo não apenas a melhor solução encontrada, mas também outras alternativas muito boas para você escolher. Os usuários podem especificar o número de soluções que desejam que o sistema retorne.

Os usuários podem enviar problemas ao computador quântico D-Wave de várias maneiras:

1. Usando um programa em C, C ++, Python ou MATLAB para criar e executar QMIs

2. Usando uma ferramenta D-Wave, como:

   • QSage , um tradutor projetado para problemas de otimização

   • ToQ , um tradutor de idiomas de alto nível usado para problemas de satisfação de restrições e projetado para permitir que os usuários “falem” no idioma do domínio do problema

   • qbsolv , um solucionador de otimização de particionamento híbrido de código aberto para problemas maiores do que caberão nativamente na QPU. O Qbsolv pode
     ser baixado aqui .

   • dw , que executa QMIs criadas por meio de um editor de texto

3. Ao programar diretamente o sistema via QMIs

Faça o download deste white paper para saber mais sobre o modelo de programação para um sistema D-Wave

As entradas para o D-Wave são uma lista de interações e, mais recentemente, o tempo de recozimento dos qubits.

$J_{ij} = 1$

Eu recomendo os apêndices deste documento para uma descrição concisa de como o hardware D-Wave opera. (Divulgação completa: sou coautor).