{"id":25644044,"url":"https://github.com/nirupamkhanal/quantum","last_synced_at":"2025-11-13T19:03:13.219Z","repository":{"id":242927887,"uuid":"810805841","full_name":"NirupamKhanal/Quantum","owner":"NirupamKhanal","description":"Quantum Computing with IBM's Qiskit toolkit","archived":false,"fork":false,"pushed_at":"2025-02-04T05:07:39.000Z","size":7531,"stargazers_count":1,"open_issues_count":0,"forks_count":0,"subscribers_count":1,"default_branch":"main","last_synced_at":"2025-02-04T05:18:50.582Z","etag":null,"topics":["qiskit","quantum-computing"],"latest_commit_sha":null,"homepage":"","language":"Jupyter Notebook","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"apache-2.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/NirupamKhanal.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE.txt","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null}},"created_at":"2024-06-05T11:42:21.000Z","updated_at":"2025-02-04T05:07:46.000Z","dependencies_parsed_at":"2024-06-05T19:52:52.978Z","dependency_job_id":"147bb158-e05a-4250-abd8-aa02e02b4823","html_url":"https://github.com/NirupamKhanal/Quantum","commit_stats":null,"previous_names":["nirupamkhanal/qiskit1","nirupamkhanal/quantum"],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NirupamKhanal%2FQuantum","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NirupamKhanal%2FQuantum/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NirupamKhanal%2FQuantum/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/NirupamKhanal%2FQuantum/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/NirupamKhanal","download_url":"https://codeload.github.com/NirupamKhanal/Quantum/tar.gz/refs/heads/main","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":240285473,"owners_count":19777296,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":["qiskit","quantum-computing"],"created_at":"2025-02-23T07:31:02.883Z","updated_at":"2025-11-13T19:03:08.175Z","avatar_url":"https://github.com/NirupamKhanal.png","language":"Jupyter Notebook","funding_links":[],"categories":[],"sub_categories":[],"readme":"# Quantum Programs with IBM's Qiskit\n\nThis repository contains various quantum programs implemented using IBM's Qiskit framework. The programs are organized into three main sections: **Hello-world**, **Quantum-Algorithms**, and **Quantum-ML**. Each notebook demonstrates different aspects of quantum computing, ranging from simple quantum circuits to more advanced algorithms and error correction techniques.\n\n## Table of Contents\n- [Overview](#overview)\n- [Hello-world Programs](#hello-world-programs)\n  - [QiskitHelloWorld.ipynb](#qiskithelloworldipynb)\n  - [QiskitPrimitives.ipynb](#qiskitprimitivesipynb)\n  - [CustomizedPrimitives.ipynb](#customizedprimitivesipynb)\n  - [QiskitDynamicCircuits.ipynb](#qiskitdynamiccircuitsipynb)\n- [Quantum Algorithms](#quantum-algorithms)\n  - [QuantumFourierCorrelation.ipynb](#quantumfouriercorrelationipynb)\n  - [GroversAlgorithm.ipynb](#groversalgorithmipynb)\n  - [VariationalQuantumEigensolver.ipynb](#variationalquantumeigensolveripynb)\n  - [DynamicQuantumErrorAnalysis.ipynb](#dynamicquantumerroranalysisipynb)\n  - [DynamicQuantumErrorCorrection.ipynb](#dynamicquantumerrorcorrectionipynb)\n  - [Quantum-Algorithms/QuantumApproximateOptimizationAlgorithm.ipynb](#quantumapproximateoptimizationalgorithm.ipynb)\n- [Quantum Machine Learning](#quantum-machine-learning)\n  - [QiskitPatterns.ipynb](#qiskitpatterns.ipynb)\n  - [QuantumNeuralNetworks.ipynb](#qiskitneuralnetworks.ipynb)\n  - [NeuralNetworkClassifierRegressor.ipynb](#neuralnetworkclassifierregressor.ipynb)\n  - [QuantumDataTraining.ipynb](#quantumdatatraining.ipynb)\n- [Getting Started with Qiskit](#getting-started-with-qiskit)\n- [License](#license)\n\n---\n\n## Overview\n\nThis repository contains notebooks that demonstrate quantum programming using IBM's Qiskit framework. Each notebook focuses on a different problem or technique, from basic quantum circuits to error correction algorithms. The common structure across all notebooks includes:\n1. **Mapping classical systems to quantum problem statements**: Explaining how classical problems are translated into quantum algorithms.\n2. **Optimization for quantum execution**: Adjusting circuit parameters, gate optimizations, and reducing depth for better quantum execution.\n3. **Quantum execution using IBM backends/simulators**: Running the quantum circuits on IBM's quantum devices or simulators.\n4. **Post-processing/getting back classical results**: Analyzing the measurement results, converting quantum data into useful classical information.\n---\n\n## Hello-world Programs\n\nThese are some of the programs that will help you get started with learning the basics of IBM's qiskit platform and its features. \n\n### 1. `QiskitHelloWorld.ipynb`\n- **2-qubits GHZ state example**\n- **n-qubits GHZ state example**\n\nThe **GHZ state** (Greenberger-Horne-Zeilinger) is a maximally entangled quantum state involving multiple qubits. It is commonly used to demonstrate quantum entanglement.\n\n**Example Code:**\n```python\nfrom qiskit import QuantumCircuit \n\n# Creating a quantum circuit with 2 qubits: \nqc = QuantumCircuit(2)\n\nqc.h(0)\nqc.cx(0, 1)\n\nqc.draw(output = 'mpl')\n``` \n**Example Output:**\n\n![Quantum Circuit](ImagesMD/qc.png)\n\n\n### 2. `QiskitPrimitives.ipynb`\n\n- **Transverse field ising model**: Demonstrates how to model transverse-field Ising chains using Qiskit primitives.\n- **Sampler** primitive for probabilistic measurement sampling.\n- **Estimator** primitive for evaluating quantum observables, such as energy expectation values of quantum states.\n\n**Pseudocode for Sampler Primitive:**\n1. Define quantum circuit.\n2. Use `Sampler/Estimator` to execute circuit on multiple backends.\n3. Gather measurement samples and analyze outcomes.\n\n**Example Code:**\n```python\nfrom qiskit.primitives import Estimator, Sampler\nfrom qiskit.circuit.library import IsingXX\nimport numpy as np\n```\n```python\n# Transverse Field Ising model\nmax_trotter_steps = 10\nnum_qubits = 100\nmeasured_qubits = [49, 50]\n\nqc_list = []\nfor trotter_step in range(max_trotter_steps):\n    qc = generate_1d_tfim_circuits(num_qubits, num_trotter_steps, rx_angle, num_cl_bits=len(measured_qubits), trotter_barriers = True, layer_barriers = True)\n    append_mirrored_1d_tfim_circuits(qc, num_qubits, num_trotter_steps, rx_angle, trotter_barriers = True, layer_barriers = True)\n    qc.measure(measured_qubits, list(range(len(measured_qubits))))\n    qc_list.append(qc)\n```\n**Executing on Sampler**\n```python\nsampler = Sampler()\nresult = sampler.run(circuits=ising_model).result()\ncounts = result.quasi_dists[0]\nprint(counts)\n```\n**Output:**\n\n![Sampler](ImagesMD/sampler.png)\n\n**Execution on Estimator**\n```python\nfrom qiskit.circuit import Parameter \nrx_angle = Parameter(\"rx_angle\")\ntrotter_steps = 2\nqc = generate_1d_tfim_circuits(num_qubits, trotter_steps, rx_angle)\n\nfrom qiskit.quantum_info import SparsePauliOp\n\nmiddle_index = num_qubits // 2\nobservable = SparsePauliOp(\"I\" * middle_index + \"Z\" + \"I\" * (middle_index-1))\n```\n**Output:**\n\n![Estimator](ImagesMD/Estimator.png)\n\n### 3. `CustomizedPrimitives.ipynb`\n\n- **Dynamical Decoupling**: An open-loop quantum control process for decoherence suppression using rapid, time-dependent control modulation. \n\nOptimizing quantum circuits dynamically using **Dynamical Decoupling** helps reduce noise and improve coherence times when executing circuits on real quantum devices.\n\n**Pseudocode for Customized Primitives:**\n1. Initialize quantum circuit.\n2. Apply dynamical decoupling techniques.\n3. Execute optimized circuit on a backend.\n4. Compare results with the non-optimized version.\n\n```python\n# Comparing different settings of transpilation for two-qubit circuits after mapping Grover's Algorithm to mark '111' state:\n\nqc.measure_all()\n\ntwoQ_gates = set(['ecr', 'cz', 'cx'])\nfor gate in backend.basis_gates:\n    if gate in twoQ_gates:\n        twoQ_gates = gate\n        \ncircuits = []\nfor optimization_level in [0, 3]:\n    pm = generate_preset_pass_manager(optimization_level, backend=backend, seed_transpiler=0)\n    t_qc = pm.run(qc)\n    print(f\"Two-qubit gates at (optimization level = {optimization_level}): \", t_qc.count_ops()[twoQ_gates])\n    circuits.append(t_qc)\n```\n**Output:**\n``Two-qubit gates at (optimization level = 0):  27``\n``Two-qubit gates at (optimization level = 3):  14``\n\n```python\n# Dynamic decoupling with Optimization_level = 3\n\nfrom qiskit.transpiler import PassManager\nfrom qiskit_ibm_runtime.transpiler.passes.scheduling import (ASAPScheduleAnalysis, PadDynamicalDecoupling,)\nfrom qiskit.circuit.library import XGate\n\ndurations = backend.target.durations() # operation time at each step\ndd_sequence = [XGate(), XGate()] # minimizing environmental degenaration of the system with dynamic decoupling\n\npm = PassManager([ASAPScheduleAnalysis(durations), PadDynamicalDecoupling(durations, dd_sequence)])\ncirc_dd = pm.run(circuits[1])\n\ncircuits.append(circ_dd)\n\ncirc_dd.draw(output=\"mpl\", style=\"iqp\", idle_wires=False)\n```\n**Output:**\n\n![Custom](ImagesMD/custom.png)\n\n### 4. `QiskitDynamicCircuits.ipynb`\n\nThis notebook demonstrates **dynamic circuits** in Qiskit by implementing **long-range CNOT gate teleportation**. This shows how feedback loops and classical control can be incorporated into quantum circuits.\n\n**Pseudocode for Dynamic Circuits:**\n1. Initialize qubits and define teleportation circuit.\n2. Introduce classical feedback for real-time control.\n3. Execute teleportation protocol using dynamic gates.\n\n**Example Code:**\n```python\n# Define get_dynamic_CNOT_circuit(num_qubits) such that the function returns a quantum circuit. \nqc = get_dynamic_CNOT_circuit(num_qubit = 7)\nqc.draw(output='mpl')\n```\n**Output:**\n\n![DD](ImagesMD/dynamic.png)\n\n---\n## Quantum Algorithms\n\n### 1. `QuantumFourierCorrelation.ipynb`\n\nThis notebook illustrates the **Quantum Fourier Transform (QFT)** to analyze correlations between qubits, producing a correlational histogram plot. The QFT is a crucial component in many quantum algorithms, such as Shor's algorithm.\n\n**Pseudocode to execute qunatum fourier transformations:**\n1. Initialize qubits in superposition.\n2. Apply Hadamard gates and controlled phase gates.\n3. Measure the qubits in the frequency domain.\n4. Analyze correlation histogram.\n\n**Example code:**\n```python\n#Define f and g:\nf = [1, -1, -1, -1]\ng = [1, 1, -1, -1]\ncirc = FourierChecking(f=f, g=g)\n```\n**Output:**\n\n![QFT](ImagesMD/QFT.png)\n\n### 2. `GroversAlgorithm.ipynb`\n\n- **Grover's Algorithm**: A quantum algorithm that provides a quadratic speedup for searching through unsorted databases.\n\n**Pseudocode for Grover's Algorithm:**\n1. Initialize qubits in a superposition state.\n2. Apply Grover's oracle to mark the target state.\n3. Apply Grover's diffusion operator.\n4. Measure qubits to retrieve the marked state.\n\n```python\n#define the Oracle circuit \ndef grover_oracle(marked_states): \n    if not isinstance(marked_states, list): \n        marked_states = [marked_states]\n    \n    num_qubits = len(marked_states[0])\n    \n    qc = QuantumCircuit(num_qubits)\n    \n    for target in marked_states: \n        rev_target = target[::-1]\n        zero_inds = [ind for ind in range(num_qubits) if rev_target.startswith('0', ind)]\n        qc.x(zero_inds)\n        qc.compose(MCMT(ZGate(), num_qubits - 1, 1), inplace = True)\n        qc.x(zero_inds)\n        \n    return qc\n\n# Instantiation \nmarked_states = ['001', '110']\n\noracle = grover_oracle(marked_states)\noracle.draw(output = \"mpl\")\n```\n**Output:**\n\n![Grover](ImagesMD/Grover.png)\n\n### 3. `VariationalQuantumEigensolver.ipynb`\n\n- **Variational Quantum Eigensolver (VQE)**: A hybrid quantum-classical algorithm used to find the minimum eigenvalue of a **Hamiltonian**, widely used in quantum chemistry for evaluating the energy states of molecules.\n\n**Pseudocode to find eigenvalues of a Hamiltonian with variational quantum execution:**\n1. Initialize a parameterized quantum circuit.\n2. Classically optimize the parameters to minimize the energy.\n3. Measure the final energy and optimize iteratively.\n\n**Example code:**\n```python\nfrom qiskit.circuit.library import RealAmplitudes\nfrom qiskit.algorithms import VQE\nfrom qiskit.opflow import X, Z\n\n# Define Hamiltonian (Pauli Operators)\nhamiltonian = Z ^ Z + X ^ X\nansatz = RealAmplitudes(2, reps=2)\n\n# Variational Quantum Eigensolver\nvqe = VQE(ansatz, optimizer='COBYLA')\nresult = vqe.compute_minimum_eigenvalue(operator=hamiltonian)\nprint(result.eigenvalue)\n```\n**Output:**\n\n![VQE](ImagesMD/VQE.png)\n\n### 4. `DynamicQuantumErrorAnalysis.ipynb`\n\nExplores **dynamic quantum error analysis**, where R_{X} gate errors are analyzed probabilistically, and errors are corrected dynamically using feedback mechanisms.\n\n**Pseudocode to implement dynamic error analysis:**\n1. Apply quantum gates with probabilistic errors.\n2. Detect errors and apply corrections.\n3. Reset qubits and repeat the process if errors occur.\n\n```python\n# Success := |0\u003e, P_success = 5/8; Failure := |1\u003e, P_failure = 3/8\n# reset_controls if failure == True\ndef reset_controls(circuit, controls, measures):\n    with circuit.if_test((measures[0], True)):\n        circuit.x(controls[0])\n    with circuit.if_test((measures[1], True)):\n        circuit.x(controls[1])\n```\n**Circuit diagram:**\n**Output:**\n```\nExpected success rate: 0.859\nActual success rate: 0.367\n```\n\n### 5. `DynamicQuantumErrorCorrection.ipynb`\n\nFocuses on **bit-flip error correction** for qubits, detecting errors using parity checks.\n\n**Pseudocode flipped-bits for parity checks:**\n1. Prepare qubit and set up error detection circuits.\n2. Apply error detection and correction.\n3. Measure corrected qubit state and repeat if necessary.\n\n**Example code:**\n```python\ndef apply_final_readout(circuit, qreg_data, creg_data):\n    circuit.barrier(qreg_data)\n    circuit.measure(qreg_data, creg_data)\n    return circuit\n```\n\n**Output:**\n```\nCompleted bit code experiment data measurement counts (no correction): {'001': 15, '101': 283, '111': 642, '110': 12, '100': 11, '011': 22, '010': 13, '000': 2}\nCompleted bit code experiment syndrome measurement counts (no correction): {'01': 285, '00': 686, '11': 13, '10': 16}\nBit-flip errors were detected/corrected on 314/1000 trials.\nA final parity error was detected on 356/1000 trials.\n\nCompleted bit code experiment data measurement counts (corrected): {'111': 840, '000': 11, '110': 22, '011': 86, '101': 33, '010': 2, '100': 3, '001': 3}\nCompleted bit code experiment syndrome measurement counts (corrected): {'01': 25, '00': 929, '10': 35, '11': 11}\nBit-flip errors were detected/corrected on 71/1000 trials.\nA final parity error was detected on 149/1000 trials.\n```\n\n### 6. `QuantumApproximateOptimizationAlgorithm.ipynb`\n\n**Optimization** algorithms executed using quantum computers, taking the **maximum-cut problem** from combinatorics as an example. \n\n**Pseudocode for QAOA:**\n1. Initialize qubits in a superposition state.\n2. Define the cost Hamiltonian.\n3. Define the mixer Hamiltonian.\n4. Apply alternating layers of cost and mixer Hamiltonians.\n5. Measure the qubits.\n6. Classical optimization loop. \n\n**Example sampling code:**\n\n```python\n# Extracting lowest-cost solution\n_PARITY = np.array([-1 if bin(i).count(\"1\") % 2 else 1 for i in range(256)], dtype=np.complex128)\n\ndef evaluate_sparse_pauli(state: int, observable: SparsePauliOp) -\u003e complex: \n    # Evaluation of the expectation value of a measured state\n    packed_uint8 = np.packbits(observable.paulis.z, axis=1, bitorder=\"little\")\n    state_bytes = np.frombuffer(state.to_bytes(packed_uint8.shape[1], \"little\"), dtype=np.uint8)\n    reduced = np.bitwise_xor.reduce(packed_uint8 \u0026 state_bytes, axis=1)\n    return np.sum(observable.coeffs * _PARITY[reduced])\n\ndef best_solution(samples, hamiltonian):\n    min_cost = 1000\n    min_sol = None\n    for bit_str in samples.keys():\n        candidate_sol = int(bit_str)\n        fval = evaluate_sparse_pauli(candidate_sol, hamiltonian).real\n        if fval \u003c= min_cost:\n            min_sol = candidate_sol\n            \n    return min_sol\n\nbest_sol_100 = best_solution(final_distribution_100_int, cost_hamiltonian_100)\nbest_sol_bitstring_100 = to_bitstring(int(best_sol_100), len(graph_100))\nbest_sol_bitstring_100.reverse()\n\nprint(\"Result bitstring:\", best_sol_bitstring_100)\n```\n\n**Output:**\n\n![graph](ImagesMD/graph.png)\n\n---\n## Quantum Machine Learning\n\n### 1. `QiskitPatterns.ipynb`\n\nThis notebook explores **quantum circuit patterns** and how they can be leveraged for machine learning tasks. The examples provided demonstrate how to apply different quantum gate patterns to qubit systems to build foundations for quantum machine learning algorithms like **Quantum Support Vector Machines (QSVM)** and **Quantum Neural Networks (QNN)**.\n\n**Pseudocode to build quantum machine learning circuits:**\n1. Initialize the quantum register and classical register.\n2. Apply variational forms using quantum gates (e.g., RX, RY).\n3. Create entangling layers between qubits.\n4. Measure qubits and analyze the results using classical machine learning models.\n\n**Example code:**\n```python\n# Feature map to compute overlap\nnum_features = np.shape(X_train)[1]\nnum_qubits = int(num_features/2)\nentangler_map = [[0,2],[3,4],[2,5],[1,4],[2,3],[4,6]]\nfm = QuantumCircuit(num_qubits)\ntraining_param = Parameter(\"θ\")\nfeature_params = ParameterVector(\"x\", num_qubits*2)\nfm.ry(training_param, fm.qubits)\n\nfor cz in entangler_map:\n    fm.cz(cz[0], cz[1])\nfor i in range(num_qubits):\n    fm.rz(-2 * feature_params[2*i+1], i)\n    fm.rx(-2 * feature_params[2*i], i)\n```\n\n**Output:**\n\n![patterns](ImagesMD/patterns.png)\n\n### 2. `QuantumNeuralNetworks.ipynb`\n\nIllustrations of `qiskit` libraries and features used in setting up **Quantum Neutral Networks (QNNs)**. \n\n- **Instantiation of EstimatorQNN and SamplerQNN**\n- **Forward pass with and without batched retrival**\n- **Backward pass with and without input gradients**\n- **EstimatorQNN with multiple observables**\n- **SamplerQNN with custom `interpret`**\n\n### 3. `NeuralNetworkClassifierRegressor.ipynb`\n\nComparison of perfomance of classical neural networks against quantum neural networks in tasks for classification and regression.\n\n**Pseudocode for classification and regression using variational quantum circuits (VQC):**\n1. Initialize the neural network, using standard dense layers with **activation function** for classical execution and **parameterized quantum circuits (PQC)** for quantum execution.\n2. Initialize the loss functions for classification and regression models.\n3. Train, evaluate and compare the results produced by each defined type of neural network. \n\n\n**Example code:**\n```python\n# constructing a feature map\nparam_x = Parameter(\"x\")\nfeature_map = QuantumCircuit(1, name=\"fm\")\nfeature_map.ry(param_x, 0)\n\n# constructing ansatz\nparam_y = Parameter(\"y\")\nansatz = QuantumCircuit(1, name=\"vf\")\nansatz.ry(param_y, 0)\n\n# constructing a circuit \nqc = QNNCircuit(feature_map=feature_map, ansatz=ansatz)\n\n# constructing QNN\nregression_estimator_qnn = EstimatorQNN(circuit=qc)\n# constructing the regressor \nregressor = NeuralNetworkRegressor(neural_network=regression_estimator_qnn, loss=\"squared_error\", optimizer=L_BFGS_B(maxiter=5), callback=callback_graph,)\n```\n\n**Output:**\n\n![nncr](ImagesMD/NNCR.png)\n\n### 4. `QuantumDataTraining.ipynb`\n\nExploratory **data analysis** and **principle components analysis (PCA)** using the Qiskit paradigm. \n\n**Pseudocode for training a Variational Quantum Classifier (VQC):**\n\n1. Initialize a neural network using classical dense layers for classical models and parameterized quantum circuits (PQC) for quantum models.\n2. Encode classical data into qubits using a feature map (e.g., ZZFeatureMap).\n3. Decompose the feature map into quantum gates for visualization and analysis.\n4. Create the ansatz (variational form) with trainable parameters (e.g., 16 parameters).\n5. Choose an optimizer (e.g., COBYLA) to minimize the objective function.\n6. Set the optimizer to have a defined number of iterations (e.g., maxiter=100).\n7. Define a quantum instance for training (e.g., Sampler for quantum simulation or a real quantum computer).\n8. Create a callback function to monitor and plot the value of the objective function during training.\n9. Construct the VQC using the feature map and ansatz to form the quantum neural network.\n10. Train the VQC on a quantum simulator or hardware, passing the defined quantum instance.\n11. Evaluate the model performance and accuracy after training.\n12. Tune hyperparameters such as the number of repetitions in the ansatz or change the optimizer to improve model performance.\n13. Repeat the process with different feature maps, ansatzes, or optimizers to optimize the model.\n\n**Example code:**\n```python\n# The objective function converges upon certain number of iterations, without necessarily reaching a better solution.\n\nfrom qiskit.circuit.library import EfficientSU2\n\nansatz = EfficientSU2(num_qubits=num_features, reps=3)\noptimizer = COBYLA(maxiter=40)\n\n# Constructing a QNN using VQC with the feature map and ansatz as parameters \n\nvqc = VQC(sampler=sampler, feature_map=feature_map, ansatz=ansatz, optimizer=optimizer, callback=callback_graph,)\n\nobjective_func_vals = [] # instantiation\n\nstart = time.time()\nvqc.fit(train_features, train_labels)\nelapsed = time.time() - start\n\nprint(f\"Training time: {round(elapsed)} seconds.\")\n```\n\n**Output:**\n```\nModel                           | Test Score | Train Score\nSVC, 4 features                 |       0.99 |       0.97\nVQC, 4 features, RealAmplitudes |       0.85 |       0.87\n----------------------------------------------------------\nSVC, 2 features                 |       0.97 |       0.90\nVQC, 2 features, RealAmplitudes |       0.58 |       0.63\nVQC, 2 features, EfficientSU2   |       0.71 |       0.67\n```\n\n---\n\n## Getting Started\n\n### Prerequisites\n\nTo run the notebooks in this repository, you will need to have the following software installed:\n\n1. **Qiskit:** IBM's quantum computing SDK.\n\n   You can install Qiskit using pip:\n\n   ```bash\n   pip install qiskit\n   ```\n   The code can be run using Jupyter Notebooks or a native python environment.\n\n  ```bash\n  pip install notebook\n  ```\n\n2. **Setting up the environment:**\n\n A python environment can be created and instantiated so as to not call the IBM Quantum API at each execution. A personal API can be generated at the [IBM Quantum](https://quantum.ibm.com/) website. \n\n```python\nimport qiskit\nprint(\"Qiskit version is: \", qiskit.version.VERSION)\nfrom qiskit_ibm_runtime import QiskitRuntimeService\n\nservice = QiskitRuntimeService(channel=\"ibm_quantum\", # ibm_cloud\n                              token = '') # Enter API \n\nQiskitRuntimeService.save_account(channel='ibm_quantum',\n                                 token = '',\n                                 overwrite = True) # Enter API\n```\n\n3. **Running the programs:** \n\n   ```bash\n   git clone https://github.com/your-username/qiskit-quantum-programs.git\n   ```\n   ```bash\n   cd qiskit-quantum-programs\n   ```\n\n  Launch jupyter notebooks:\n\n   ```bash\n   jupyter notebook\n   ```\n\n  Open any of the notebooks and run the cells to execute the quantum programs.\n\n   ```py\n  qiskithelloworld.ipybn\n  ```\n\n---\n\n## License\n\nThis repository is licensed under the Apache 2.0 License. See the `LICENSE.TXT` file for more information.\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnirupamkhanal%2Fquantum","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnirupamkhanal%2Fquantum","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnirupamkhanal%2Fquantum/lists"}