27

मैं जानना चाहूंगा कि डी-वेव डिवाइस के लिए नौकरी कोड में कैसे लिखी जाती है और डिवाइस को सबमिट की जाती है।

जवाब में एक साधारण समस्या के लिए इसका एक विशिष्ट उदाहरण देखना सबसे अच्छा होगा। मुझे लगता है कि डी-वेव डिवाइस का "हैलो वर्ल्ड" एक साधारण 2 डी इस्सिंग मॉडल की जमीनी अवस्थाओं को खोजने जैसा होगा , क्योंकि इस तरह की समस्या सीधे हार्डवेयर द्वारा महसूस की जाती है। तो शायद यह देखने के लिए एक अच्छा उदाहरण होगा। लेकिन अगर विशेषज्ञता वाले लोग एक वैकल्पिक उदाहरण के लिए उपयुक्त होंगे, तो मुझे एक विकल्प देखकर खुशी होगी।

d-wave programming

— जेम्स वॉटन
स्रोत

24

डी-वेव दुनिया में 'हैलो वर्ल्ड' के समकक्ष 2 डी चेकरबोर्ड उदाहरण है। इस उदाहरण में, आपको 4 नोड्स के साथ निम्नलिखित वर्ग ग्राफ दिया गया है:

square_graph

चलो परिभाषित है कि हम रंग शिखर काला यदि और सफेद यदि । लक्ष्य ग्राफ में चार कोने के साथ एक चेकरबोर्ड पैटर्न बनाना है। इस परिणाम को प्राप्त करने के लिए और को परिभाषित करने के विभिन्न तरीके हैं । सबसे पहले, इस समस्या के दो संभावित समाधान हैं: $\sigma_{i}$ $\sigma_{i} = -1$ $\sigma_{i} = +1$ $h$ $J$

checkerboard_solutions

डी-वेव क्वांटम एनीलर आइसिंग हैमिल्टन को न्यूनतम करता है जिसे हम परिभाषित करते हैं और विभिन्न युग्मक सेटिंग्स के प्रभाव को समझना महत्वपूर्ण है। उदाहरण के लिए कपलर पर विचार करें : $J_{0,1}$

यदि हम इसे सेट करते हैं , तो हैमिल्टनियन को कम से कम किया जाता है यदि दोनों क्विबेट समान मान लेते हैं। हम कहते हैं कि नकारात्मक युग्मक सहसंबंधित हैं । जबकि अगर हम इसे सेट करते हैं तो दो क्विल्ट विपरीत मान लेने पर हैमिल्टनियन को कम से कम किया जाता है। इस प्रकार, सकारात्मक कप्लर्स सहसंबंधी होते हैं । $J_{0,1}=-1$ $J_{0,1}=+1$

चेकरबोर्ड के उदाहरण में, हम पड़ोसी जोड़ी के प्रत्येक जोड़े का सहसंबंधी बनाना चाहते हैं, जो निम्न हैम्पटनटन को जन्म देता है:

एच = σ_{0} σ_{1} + σ_{0} σ_{2} + σ_{1} σ_{3} + σ_{2} σ_{3}

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

प्रदर्शन की खातिर, हम qu qubit पर एक पूर्वाग्रह शब्द भी जोड़ते हैं, जैसे कि हम केवल # 1 समाधान प्राप्त करते हैं। यह समाधान की आवश्यकता है और इसलिए हम अपने पूर्वाग्रह सेट । अंतिम हैमिल्टन अब है: $0$ $\sigma_{0}=-1$ $h_{0}=1$

एच = σ_{0} + σ_{0} σ_{1} + σ_{0} σ_{2} + σ_{1} σ_{3} + σ_{2} σ_{3}

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

तो चलो इसे ऊपर कोड!

नोट: आप कुछ भी काम करने के लिए डी-वेव क्लाउड सेवा तक पहुँच की आवश्यकता नहीं है।

सबसे पहले, सुनिश्चित करें कि आपके पास dwave_sapi2( https://cloud.dwavesys.com/qubist/downloads/ ) पायथन पैकेज स्थापित है। सब कुछ अजगर 2.7 होने जा रहा है क्योंकि डी-वेव वर्तमान में किसी भी उच्च पायथन संस्करण का समर्थन नहीं करता है। कहा जा रहा है, चलो आवश्यक आयात करते हैं:

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

डी-वेव सॉल्वर एपीआई से कनेक्ट करने के लिए आपको उनके एसएपीआई सॉल्वर, एसएपीआई यूआरएल के लिए वैध एपीआई टोकन की आवश्यकता होगी और आपको यह तय करना होगा कि आप किस क्वांटम प्रोसेसर का उपयोग करना चाहते हैं:

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

मैं डी-वेव 2000Q वर्चुअल फुल यील्ड चिमेरा (VFYC) का उपयोग करने की सलाह देता हूं, जो कि बिना किसी भी तरह की पूरी तरह से कार्यात्मक चिप है! यहाँ है चीमरा चिप लेआउट:

dwave_chimera

इस बिंदु पर मैं ट्यूटोरियल को दो अलग-अलग टुकड़ों में विभाजित कर रहा हूं। पहले खंड में, हम मैन्युअल रूप से समस्या को चिमेरा हार्डवेयर ग्राफ पर एम्बेड कर रहे हैं और दूसरे खंड में हम एक हार्डवेयर एम्बेडिंग खोजने के लिए डी-वेव की एम्बेडिंग हेयुरेटिक्स का उपयोग कर रहे हैं।

मैनुअल एम्बेडिंग

डी-वेव 2000Q चिप लेआउट के शीर्ष बाएं कोने में स्थित इकाई कक्ष इस तरह दिखता है:

physical_qubits

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

अब, हम रीडआउट की संख्या को परिभाषित कर सकते हैं और answer_mode"हिस्टोग्राम" चुन सकते हैं जो पहले से ही हमारे लिए होने वाली घटनाओं की संख्या से परिणामों को क्रमबद्ध करता है। अब हम डी-वेव क्वांटम एनीलर के साथ ईज़िंग उदाहरण को हल करने के लिए तैयार हैं:

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

आपको निम्न परिणाम प्राप्त करना चाहिए:

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

हेयुरिस्टिक एम्बेडिंग

$J$ $h$

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

हम फिर से रिमोट कनेक्शन स्थापित करते हैं और डी-वेव 2000Q VFYC सॉल्वर उदाहरण प्राप्त करते हैं:

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

हमारी समस्या का एक एम्बेडिंग खोजने के लिए, हमें सबसे पहले वर्तमान हार्डवेयर ग्राफ के आसन्न मैट्रिक्स को प्राप्त करने की आवश्यकता है:

adjacency = get_hardware_adjacency(solver)

आइए अब अपनी समस्या के बारे में जानने की कोशिश करें:

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

यदि आप बड़े ईज़िंग उदाहरणों के साथ काम कर रहे हैं, तो आप कई थ्रेड्स (कई सीपीयू पर समानांतर) में एम्बेडिंग के लिए खोज करना चाहते हैं और फिर सबसे छोटी श्रृंखला लंबाई के साथ एम्बेडिंग का चयन कर सकते हैं! एक चेन तब होती है जब कनेक्टिविटी की डिग्री बढ़ाने के लिए कई क्विट्स को एक सिंगल क्वेट के रूप में कार्य करने के लिए मजबूर किया जाता है। हालांकि, श्रृंखला जितनी अधिक बार यह टूटने की संभावना है। और टूटी हुई जंजीरें बुरा परिणाम देती हैं!

अब हम अपनी समस्या को ग्राफ पर एम्बेड करने के लिए तैयार हैं:

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

j0jc $J$

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

अब, हम एम्बेडेड समस्या को हल करने के लिए तैयार हैं:

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

raw_resultsजब तक हम इस समस्या unembed हमें कोई मतलब नहीं होगा। मामले में, कुछ जंजीरों को तोड़ दिया हम उन्हें वैकल्पिक मत द्वारा परिभाषित बहुमत वोट के माध्यम से ठीक कर रहे हैं broken_chains:

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

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

यदि आप इसे चलाते हैं, तो आपको सभी रीडआउट में सही परिणाम प्राप्त करना चाहिए:

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

मैं इस अपने प्रश्न का उत्तर और मैं अत्यधिक सभी अतिरिक्त पैरामीटर बाहर की जाँच है कि आप करने के लिए पारित कर सकते हैं की सिफारिश आशा solve_isingजैसे समारोह अपने समाधान की गुणवत्ता में सुधार करने के लिए num_spin_reversal_transformsया postprocess।

— फ़िंगरहुथ
स्रोत

9

शीर्षक और प्रश्न निकाय दो अलग-अलग प्रश्न पूछते हैं। शीर्षक में आप पूछते हैं कि "आप डी-वेव डिवाइस के लिए एक सरल प्रोग्राम कैसे लिखते हैं?", जबकि प्रश्न बॉडी में आप पूछते हैं कि डी-वेव के अंतर्निहित हार्डवेयर का उपयोग करके एक साधारण 2 डी इस्सिंग मॉडल के जमीनी राज्यों को कैसे खोजना है। डिवाइस, और संबंधित कोड क्या होगा (जो एक अधिक विशिष्ट प्रश्न है)।

मैं पूर्व का उत्तर दूंगा, क्योंकि यह अधिक सामान्य प्रश्न है।

के अनुसार डी-वेव सॉफ्टवेयर पेज :

डी-वेव 2000 क्यू सिस्टम सी / सी ++, पायथन और MATLAB के लिए उपलब्ध क्लाइंट लाइब्रेरी के साथ एक मानक इंटरनेट एपीआई (रेस्टफुल सेवाओं के आधार पर) प्रदान करता है। यह इंटरफ़ेस उपयोगकर्ताओं को नेटवर्क पर क्लाउड संसाधन के रूप में सिस्टम तक पहुंचने की अनुमति देता है, या उनके उच्च-प्रदर्शन कंप्यूटिंग (एचपीसी) वातावरण और डेटा केंद्रों में एकीकृत करता है। एक्सेस डी-वेव की होस्टेड क्लाउड सेवा के माध्यम से भी उपलब्ध है। डी-वेव के विकास उपकरण और क्लाइंट पुस्तकालयों का उपयोग करके, डेवलपर्स उद्योग-मानक टूल का उपयोग करके अपने मौजूदा वातावरण के भीतर एल्गोरिदम और एप्लिकेशन बना सकते हैं।

जबकि उपयोगकर्ता कई अलग-अलग तरीकों से सिस्टम को समस्याएं प्रस्तुत कर सकते हैं, अंततः एक समस्या मूल्यों के एक समूह का प्रतिनिधित्व करती है जो कि तंतुओं के वजन और युग्मकों की ताकत के अनुरूप है। सिस्टम अन्य उपयोगकर्ता-निर्दिष्ट मापदंडों के साथ इन मूल्यों को लेता है और QPU को एक एकल क्वांटम मशीन निर्देश (QMI) भेजता है। समस्या समाधान पाई गई कक्षाओं के इष्टतम विन्यास के अनुरूप हैं; यानी ऊर्जा परिदृश्य में सबसे कम अंक। ये मान नेटवर्क पर उपयोगकर्ता प्रोग्राम को वापस कर दिए जाते हैं।

क्योंकि क्वांटम कंप्यूटर नियतात्मक के बजाय संभाव्य होते हैं, कई मानों को लौटाया जा सकता है, जिससे न केवल सबसे अच्छा समाधान मिल जाता है, बल्कि अन्य बहुत अच्छे विकल्प भी मिलते हैं जिनमें से चयन करना है। उपयोगकर्ता उन समाधानों की संख्या निर्दिष्ट कर सकते हैं जो वे चाहते हैं कि प्रणाली वापस आ जाए।

उपयोगकर्ता डी-वेव क्वांटम कंप्यूटर में कई तरह से समस्याएं प्रस्तुत कर सकते हैं:

क्यूएमआई बनाने और निष्पादित करने के लिए सी, सी ++, पायथन या MATLAB में एक कार्यक्रम का उपयोग करना

डी-वेव टूल का उपयोग करना जैसे:

QSage , अनुकूलन समस्याओं के लिए डिज़ाइन किया गया अनुवादक

ToQ , एक उच्च स्तरीय भाषा अनुवादक जो कि संतुष्टि संतुष्टि की समस्याओं के लिए उपयोग किया जाता है और उपयोगकर्ताओं को उनकी समस्या डोमेन की भाषा में "बोलने" के लिए डिज़ाइन किया गया है

QbsU पर फिट होने वाली समस्याओं के लिए एक खुला-स्रोत, हाइब्रिड पार्टीशन ऑप्टिमाइज़ेशन सॉल्वर qbsolv। Qbsolv को यहाँ
डाउनलोड किया जा सकता है ।

dw , जो एक पाठ संपादक के माध्यम से बनाई गई QMI को निष्पादित करता है

सीधे QMI के माध्यम से सिस्टम को प्रोग्रामिंग करके

डी-वेव प्रणाली के लिए प्रोग्रामिंग मॉडल के बारे में अधिक जानने के लिए इस श्वेत पत्र को डाउनलोड करें

— संचेतन दत्ता
स्रोत

5

डी-वेव के इनपुट्स परस्पर क्रियाओं की एक सूची है और हाल ही में क्वेट का समय है।

जैसा कि आपने उल्लेख किया है कि ईज़िंग समस्या सबसे आसान है $J_{ij} = 1$ समस्या में हैमिल्टनियन हालांकि यह बहुत दिलचस्प नहीं है।

मैं इस पत्र में डी-वेव हार्डवेयर के संचालन के संक्षिप्त विवरण के लिए परिशिष्टों की सिफारिश करता हूं । (पूर्ण प्रकटीकरण: मैं एक कौथोर हूं।)

— एंड्रयू ओ
स्रोत

2

यह और भी बेहतर हो सकता है अगर आप लिंक के बजाय यहाँ उत्तर का एक बड़ा हिस्सा शामिल करें? कागज में एक कोओथोर होने के नाते, आप शायद एक अच्छा सारांश बनाने के लिए सबसे उपयुक्त हैं।

— अगस्तैरोिनो