Vorrei sapere come un lavoro per un dispositivo D-Wave è scritto in codice e inviato al dispositivo.

Nella risposta sarebbe meglio vedere un esempio specifico di questo per un semplice problema. Immagino che il "Hello World" di un dispositivo D-Wave sarebbe come trovare gli stati fondamentali di un semplice modello Ising 2D , poiché questo è il tipo di problema realizzato direttamente dall'hardware. Quindi forse questo sarebbe un bell'esempio da vedere. Ma se quelli con esperienza rappresentassero un esempio alternativo, sarei felice di vedere un'alternativa.

L'equivalente "Hello World" nel mondo D-Wave è l'esempio della scacchiera 2D. In questo esempio, viene fornito il seguente grafico quadrato con 4 nodi:

                                                 

Definiamo che vertice nero se e bianco se . L'obiettivo è creare un motivo a scacchiera con i quattro vertici nel grafico. Esistono vari modi per definire e per ottenere questo risultato. Innanzitutto, ci sono due possibili soluzioni a questo problema:$\sigma_{i}$$\sigma_{i} = -1$$\sigma_{i} = +1$$h$$J$

              

La ricottura quantistica D-Wave minimizza la Hamiltoning Ising che definiamo ed è importante comprendere l'effetto delle diverse impostazioni dell'accoppiatore. Consideriamo ad esempio l' accoppiatore :$J_{0,1}$

Se lo impostiamo su , l'hamiltoniano viene ridotto a icona se entrambi i qubit assumono lo stesso valore. Diciamo che gli accoppiatori negativi sono correlati . Mentre se lo impostiamo su , l'Hamiltoniano è ridotto al minimo se i due qubit assumono valori opposti. Pertanto, gli accoppiatori positivi sono anti-correlati .$J_{0,1}=-1$$J_{0,1}=+1$

Nell'esempio a scacchiera, vogliamo anti-correlare ogni coppia di qubit vicini che danno origine al seguente hamiltoniano:

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

Per motivi di dimostrazione, aggiungiamo anche un termine di bias sul qubit modo tale da ottenere solo la soluzione n. 1. Questa soluzione richiede e quindi impostiamo il suo orientamento . L'Hamiltoniano finale è ora:$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}$$

Quindi codifichiamolo!

NOTA: AVETE BISOGNO dell'accesso al servizio cloud di D-Wave perché tutto funzioni.

Prima di tutto, assicurati di avere installato il pacchetto Python dwave_sapi2( https://cloud.dwavesys.com/qubist/downloads/ ). Tutto sarà Python 2.7 poiché D-Wave al momento non supporta versioni di Python superiori. Detto questo, importiamo gli elementi essenziali:

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

Per connettersi all'API Risolutore D-Wave è necessario un token API valido per il loro solutore SAPI, l'URL SAPI e sarà necessario decidere quale processore quantico si desidera utilizzare:

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

Consiglio di usare la Chimera D-Wave 2000Q Virtual Full Yield (VFYC) che è un chip perfettamente funzionante senza qubit morti! Ecco il layout del chip Chimera:

A questo punto sto dividendo il tutorial in due pezzi distinti. Nella prima sezione, stiamo incorporando manualmente il problema nel grafico hardware Chimera e nella seconda sezione stiamo usando l'euristica di incorporamento di D-Wave per trovare un incorporamento hardware.

Incorporamento manuale

---

La cella unitaria nell'angolo in alto a sinistra sul layout del chip D-Wave 2000Q sopra appare così:

$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)

Ora, possiamo definire il numero di letture e scegliere answer_modedi essere "istogramma" che ordina già i risultati in base al numero di occorrenze per noi. Ora siamo pronti a risolvere l'istanza di Ising con la ricottura quantistica D-Wave:

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

Dovresti ottenere il seguente risultato:

{
  '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]$

Incorporamento euristico

---

$J$$h$

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

Stabiliamo nuovamente la connessione remota e otteniamo l'istanza del solutore D-Wave 2000Q VFYC:

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

Per trovare un incorporamento del nostro problema, dobbiamo prima ottenere la matrice di adiacenza del grafico hardware corrente:

adjacency = get_hardware_adjacency(solver)

Ora proviamo a trovare un incorporamento del nostro problema:

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

Se hai a che fare con istanze di Ising di grandi dimensioni potresti voler cercare incorporamenti in più thread (parallelizzati su più CPU) e quindi selezionare l'incorporamento con la lunghezza della catena più piccola! Una catena è quando più qubit sono costretti ad agire come un singolo qubit al fine di aumentare il grado di connettività. Tuttavia, più lunga è la catena, maggiore è la probabilità che si spezzi. E le catene rotte danno risultati cattivi!

Ora siamo pronti per incorporare il nostro problema nel grafico:

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

j0jc$J$

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

Ora siamo pronti a risolvere il problema incorporato:

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'])

Non raw_resultsavrà senso per noi a meno che non abbiamo risolto il problema. Nel caso in cui alcune catene si siano rotte, le stiamo risolvendo con un voto a maggioranza come definito dall'argomento facoltativo broken_chains:

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

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

Se lo esegui, dovresti ottenere il risultato corretto in tutte le letture:

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

Spero che questo abbia risposto alla tua domanda e ti consiglio vivamente di controllare tutti i parametri aggiuntivi che puoi passare alla solve_isingfunzione per migliorare la qualità delle tue soluzioni come num_spin_reversal_transformso postprocess.

Il titolo e il corpo della domanda sembrano porre due domande diverse. Nel titolo chiedi "Come si scrive un semplice programma per un dispositivo D-Wave?", Mentre nel corpo della domanda si chiede come trovare gli stati fondamentali di un semplice modello Ising 2D usando l'hardware sottostante del D-Wave dispositivo e quale sarebbe il codice corrispondente (che è una domanda più specifica).

Risponderò alla prima, poiché è la domanda più generale.

Secondo la pagina del software D-Wave :

Il sistema D-Wave 2000Q fornisce un'API Internet standard (basata sui servizi RESTful), con librerie client disponibili per C / C ++, Python e MATLAB. Questa interfaccia consente agli utenti di accedere al sistema come risorsa cloud su una rete o integrato nei loro ambienti e data center di elaborazione ad alte prestazioni (HPC). L'accesso è disponibile anche tramite il servizio cloud ospitato di D-Wave. Utilizzando gli strumenti di sviluppo e le librerie client di D-Wave, gli sviluppatori possono creare algoritmi e applicazioni nei loro ambienti esistenti utilizzando strumenti standard del settore.

Mentre gli utenti possono presentare problemi al sistema in diversi modi, alla fine un problema rappresenta un insieme di valori che corrispondono ai pesi dei qubit e alla forza degli accoppiatori. Il sistema prende questi valori insieme ad altri parametri specificati dall'utente e invia una singola istruzione quantistica (QMI) alla QPU. Le soluzioni ai problemi corrispondono alla configurazione ottimale dei qubit trovati; cioè i punti più bassi nel panorama energetico. Questi valori vengono restituiti al programma utente sulla rete.

Poiché i computer quantistici sono probabilistici piuttosto che deterministici, è possibile restituire più valori, fornendo non solo la migliore soluzione trovata, ma anche altre ottime alternative tra cui scegliere. Gli utenti possono specificare il numero di soluzioni che desiderano restituire al sistema.

Gli utenti possono presentare problemi al computer quantistico D-Wave in diversi modi:

1. Utilizzo di un programma in C, C ++, Python o MATLAB per creare ed eseguire QMI

2. Utilizzando uno strumento D-Wave come:

   • QSage , un traduttore progettato per problemi di ottimizzazione

   • ToQ , un traduttore di lingua di alto livello utilizzato per problemi di soddisfazione dei vincoli e progettato per consentire agli utenti di "parlare" nella lingua del loro dominio problematico

   • qbsolv , un risolutore di ottimizzazione del partizionamento ibrido open source per problemi più grandi di quelli che si adattano nativamente alla QPU. Qbsolv può
     essere scaricato qui .

   • dw , che esegue QMI creati tramite un editor di testo

3. Programmando direttamente il sistema tramite QMI

Scarica questo white paper per ulteriori informazioni sul modello di programmazione di un sistema D-Wave

Gli input per la D-Wave sono un elenco di interazioni e più recentemente il tempo di ricottura dei qubit.

$J_{ij} = 1$

Raccomando le appendici di questo documento per una descrizione sintetica del funzionamento dell'hardware D-Wave. (Informativa completa: sono un coautore.)