Qiskit முன்னுரை¶

Qiskit பயன்படுத்தும் போது ஒரு பயனர் பணிப்பாய்வு பெயரளவில் நான்கு உயர் மட்ட படிகளைப் பின்பற்றுகிறது:

கட்டு: நீங்கள் கருத்தில் கொள்ளும் சிக்கலைக் குறிக்கும் குவாண்டம் சர்க்யூட்(கள்) வடிவமைக்கவும்.
Compile: ஒரு குறிப்பிட்ட குவாண்டம் சேவைக்கான சர்க்யூட்களைத் தொகுக்கவும், எ.கா. குவாண்டம் அமைப்பு அல்லது கிளாசிக்கல் சிமுலேட்டர்.
Run: குறிப்பிட்ட குவாண்டம் சேவையில்(களில்) compile செய்த சர்க்யூட்களை இயக்கவும். இந்த சேவைகள் மேகக்கணி சார்ந்தவை அல்லது உள்ளூர்.
Analyze: சுருக்கமான புள்ளிவிவரங்களைக் கணக்கிட்டு, பரிசோதனைகளின் முடிவுகளைக் காட்சிப்படுத்துங்கள்.

ஒவ்வொரு அடியும் அடுத்தடுத்த பிரிவுகளில் விரிவாக விளக்கப்பட்டுள்ள நிலையில், முழு பணிப்பாய்வின் ஒரு உதாரணம் இங்கே:

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram

# Use Aer's qasm_simulator
simulator = QasmSimulator()

# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)

# Add a H gate on qubit 0
circuit.h(0)

# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)

# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])

# compile the circuit down to low-level QASM instructions
# supported by the backend (not needed for simple circuits)
compiled_circuit = transpile(circuit, simulator)

# Execute the circuit on the qasm simulator
job = simulator.run(compiled_circuit, shots=1000)

# Grab results from the job
result = job.result()

# Returns counts
counts = result.get_counts(compiled_circuit)
print("\nTotal count for 00 and 11 are:",counts)

# Draw the circuit
circuit.draw()


Total count for 00 and 11 are: {'00': 519, '11': 481}

     ┌───┐     ┌─┐   
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1

# Plot a histogram
plot_histogram(counts)

பணிப்பாய்வு படி படியாக¶

மேலே உள்ள நிரலை ஆறு படிகளாக உடைக்கலாம்:

இறக்குமதி பேக்கேஜ்கள்
மாறிகளை துவக்கவும்
கேட்களைச் சேர்க்கவும்
சர்க்யூட் யை காட்சிப்படுத்தவும்
பரிசோதனையை உருவகப்படுத்தவும்
முடிவுகளை காட்சிப்படுத்து

படி 1: பேக்கேஜ்களை இறக்குமதி செய்க¶

உங்கள் திட்டத்திற்கு தேவையான அடிப்படை உறுப்புகளை பின்வருமாறு இறக்குமதி செய்யப்படுகின்றன:

import numpy as np
from qiskit import QuantumCircuit
from qiskit.providers.aer import QasmSimulator
from qiskit.visualization import plot_histogram

இன்னும் விரிவாக, இறக்குமதிகள்

QuantumCircuit: குவாண்டம் அமைப்பின் வழிமுறைகளாக கருதலாம். இது உங்கள் அனைத்து குவாண்டம் செயல்பாடுகளையும் கொண்டுள்ளது.
QasmSimulator: Aer உயர் செயல்திறன் சர்க்யூட் சிமுலேட்டர்.
plot_histogram: ஹிஸ்டோகிராம்களை உருவாக்குகிறது.

படி 2: மாறிகளை துவக்கவும்¶

Codeயின் அடுத்த வரியைக் கவனியுங்கள்

circuit = QuantumCircuit(2, 2)

இங்கே, நீங்கள் பூஜ்ஜிய நிலையில் 2 குபிட்களுடன் துவக்குகிறீர்கள்; 2 கிளாசிக்கல் பிட்கள் பூஜ்ஜியமாக அமைக்கப்பட்டுள்ளது; மற்றும் சர்க்யூட் என்பது குவாண்டம் சர்க்யூட்கள் ஆகும்.

சொற்றொடரியல்:

QuantumCircuit(int, int)

படி 3 : கேட்களை சேர்¶

உங்கள் சர்க்யூட் பதிவேடுகளை கையாள கேட்ஸ்களை (செயல்பாடுகள்) சேர்க்கலாம்.

பின்வரும் மூன்று code வரிகளைக் கவனியுங்கள்:

circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0,1], [0,1])

பெல் நிலையை உருவாக்குவதற்கு கேட்கள் ஒவ்வொன்றாக சர்க்யூட்க்கு சேர்க்கப்படுகின்றன

\[|\psi\rangle = \left(|00\rangle+|11\rangle\right)/\sqrt{2}.\]

மேலே உள்ள code பின்வரும் கேட்களை பயன்படுத்துகிறது:

QuantumCircuit.h(0):குவிட் 0 இல் ஒரு ஹடமார்ட் கேட் \(H\), இது ஒரு சூப்பர்பொசிஷன் நிலைக்கு வைக்கிறது.
QuantumCircuit.cx(0, 1): கட்டுப்பாட்டு க்யூபிட் 0 மற்றும் இலக்கு க்யூபிட் 1 இல் ஒரு கட்டுப்பாடு-இல்லை செயல்பாடு (\(CNOT\)) ஒரு entangled நிலை இல் குபிட்களை வைக்கிறது.
QuantumCircuit.measure([0,1], [0,1]): நீங்கள் முழு குவாண்டம் மற்றும் கிளாசிக்கல் பதிவேடுகளை அளவிடு க்கு அனுப்பினால், ith க்யூபிட்டின் அளவீட்டு முடிவு ith கிளாசிக்கல் பிட்டில் சேமிக்கப்படும்.

படி 4: சர்க்யூட்-ஐ காட்சிப்படுத்துங்கள்¶

நீங்கள் பயன்படுத்த முடியும் qiskit.circuit.QuantumCircuit.draw() நீங்கள் பல பாடப்புத்தகங்கள் மற்றும் ஆராய்ச்சி கட்டுரைகள் பயன்படுத்தப்படும் பல்வேறு வடிவங்களில் வடிவமைக்கப்பட்டுள்ளது என்று சர்க்யூட் பார்க்க.

circuit.draw()

     ┌───┐     ┌─┐   
q_0: ┤ H ├──■──┤M├───
     └───┘┌─┴─┐└╥┘┌─┐
q_1: ─────┤ X ├─╫─┤M├
          └───┘ ║ └╥┘
c: 2/═══════════╩══╩═
                0  1

இச்சர்க்யூடில், க்யூபிட்கள் மேலே க்யூபிட் பூஜ்ஜியத்துடனும், கீழே உள்ள ஒன்றை க்யூபிட் செய்யவும் உத்தரவிடப்படுகின்றன. சர்க்யூட் இடது-க்கு-வலது படிக்கப்படுகிறது, அதாவது சர்க்யூடில் முன்பு பயன்படுத்தப்படும் கேட்ஸ் இடது புறம் இன்னும் அதிகமாகக் காட்டுகின்றன.

QuantumCircuit.draw() அல்லது qiskit.visualization.circuit_drawer() க்கான முன்னிருப்பு பின்முனை உரை பின்முனையாகும். இருப்பினும், உங்கள் உள்ளூர் சூழலைப் பொறுத்து, இந்த முன்னிருப்புகளை உங்கள் பயன்பாட்டு வழக்குக்கு மிகவும் பொருத்தமானதாக மாற்ற விரும்பலாம். இது பயனர் உள்வடிவமைப்பு கோப்புடன் செய்யப்படுகிறது. முன்னிருப்பாக பயனர் வடிவமைப்பு கோப்பு ~/.qiskit/settings.conf இல் இருக்க வேண்டும் மற்றும் .ini கோப்பாக இருக்க வேண்டும்.

உதாரணமாக, settings.conf மேட்ப்ளாட்லிப் வரைபடம் அமைப்பதற்கான கோப்பு:

[default]
circuit_drawer = mpl

இந்த கட்டமைப்பிற்கான மதிப்பாக நீங்கள் செல்லுபடியாகும் சர்க்யூட் டிராயர் backendல் எதையும் பயன்படுத்தலாம், இதில் உரை, எம்பிஎல், லேடெக்ஸ் மற்றும் லேடெக்ஸ்_சோர்ஸ் ஆகியவை அடங்கும்.

படி 5 : பரிசோதனையை உருவகப்படுத்தவும்¶

Qiskit Aer quantum circuitsகளுக்கான உயர் செயல்திறன் சிமுலேட்டர் கட்டமைப்பாகும். இது வெவ்வேறு உருவகப்படுத்துதல் இலக்குகளை அடைய several backends வழங்குகிறது.

Aer ஐ நிறுவுவதில் சிக்கல் இருந்தால், Aer ஐ Basic Aer உடன் மாற்றுவதன் மூலம் நீங்கள் அடிப்படை Aer வழங்குபவரைப் பயன்படுத்தலாம். Qiskit Terraவில் அடிப்படை Aer சேர்க்கப்பட்டுள்ளது.

import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.basicaer import QasmSimulatorPy
...

இந்த சர்க்யூட் உருவகப்படுத்த, நீங்கள் qasm_simulator பயன்படுத்த வேண்டும். இந்த சர்க்யூடின் ஒவ்வொரு ஓட்டமும் பிட் string 00 அல்லது 11 ஐ கொடுக்கும்.

simulator = QasmSimulator()
compiled_circuit = transpile(circuit, simulator)
job = simulator.run(compiled_circuit, shots=1000)
result = job.result()
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)


Total count for 00 and 11 are: {'11': 515, '00': 485}

எதிர்பார்த்தபடி, வெளியீடு பிட் string நேரம் சுமார் 50 சதவீதம் ஆகும். சர்க்யூட் எத்தனை முறை இயங்குகிறது என்பதை ஷாட்கள் என்ற execute முறையின் விவாதம் மூலம் குறிப்பிடலாம். உருவகப்படுத்துதல் ஷாட்களின் எண்ணிக்கை 1000 ஆக அமைக்கப்பட்டது (முன்னிருப்பு 1024).

நீங்கள் ஒரு result object இருந்தால், நீங்கள் முறை மூலம் எண்ணிக்கைகளை அணுக முடியும் get_counts(circuit). இது நீங்கள் நடத்திய பரிசோதனையின் ஒட்டுமொத்த விளைவுகளை உங்களுக்கு வழங்குகிறது.

படி 6 : முடிவுகளை காட்சிப்படுத்துங்கள்¶

Qiskit பல காட்சிப்படுத்தல்களை வழங்குகிறது,

உங்கள் முடிவுகளைக் காண, plot_histogram என்ற செயல்பாடு உட்பட.

plot_histogram(counts)

கவனிக்கப்பட்ட நிகழ்தகவுகள் \(Pr(00)\) மற்றும் \(Pr(11)\) ஆகியவை அந்தந்த எண்ணிக்கைகளை எடுத்து மொத்த ஷாட்களின் எண்ணிக்கையால் வகுக்கப்படுகின்றன.

Note

மதிப்பிடப்பட்ட நிகழ்தகவுகள் எவ்வாறு மாறுகின்றன என்பதைப் பார்க்க, run() முறையில் shots முக்கிய வார்த்தையை மாற்ற முயற்சிக்கவும்.

அடுத்த படிமுறைகள்¶

இப்போது நீங்கள் அடிப்படைகளை கற்றுக்கொண்டீர்கள், இந்த கற்றல் வளங்களை கருத்தில் கொள்ளுங்கள்: