From a05adf85a67f67e9efbf66df00cc33be0a46e962 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 04:54:22 +0530 Subject: [PATCH 01/13] Add files via upload --- app (3).py | 22 ++++++++++++++++++++++ chat (1).py | 26 ++++++++++++++++++++++++++ config (1).py | 2 ++ 3 files changed, 50 insertions(+) create mode 100644 app (3).py create mode 100644 chat (1).py create mode 100644 config (1).py diff --git a/app (3).py b/app (3).py new file mode 100644 index 000000000..5cefc3787 --- /dev/null +++ b/app (3).py @@ -0,0 +1,22 @@ +from flask import Flask, render_template, request, jsonify +from chat import chatbot + +app = Flask(__name__) + + +@app.route("/") +def hello(): + return render_template('chat.html') + +@app.route("/ask", methods=['POST']) +def ask(): + + message = str(request.form['messageText']) + + bot_response = chatbot(message) + + return jsonify({'status':'OK','answer':bot_response}) + + +if __name__ == "__main__": + app.run() diff --git a/chat (1).py b/chat (1).py new file mode 100644 index 000000000..72e4ec82c --- /dev/null +++ b/chat (1).py @@ -0,0 +1,26 @@ +from peft import AutoPeftModelForCausalLM +from transformers import GenerationConfig +from transformers import AutoTokenizer +import torch +tokenizer = AutoTokenizer.from_pretrained("Vasanth/mistral-finetuned-alpaca") + +model = AutoPeftModelForCausalLM.from_pretrained( + "Vasanth/mistral-finetuned-alpaca", + low_cpu_mem_usage=True, + return_dict=True, + torch_dtype=torch.float16, + device_map="cuda") + +generation_config = GenerationConfig( + do_sample=True, + top_k=1, + temperature=0.1, + max_new_tokens=100, + pad_token_id=tokenizer.eos_token_id +) + +def chatbot(message): + input_str = "###Human: " + message + " ###Assistant: " + inputs = tokenizer(input_str, return_tensors="pt").to("cuda") + outputs = model.generate(**inputs, generation_config=generation_config) + return tokenizer.decode(outputs[0], skip_special_tokens=True).replace(input_str, '') \ No newline at end of file diff --git a/config (1).py b/config (1).py new file mode 100644 index 000000000..9a835b3b5 --- /dev/null +++ b/config (1).py @@ -0,0 +1,2 @@ +##OPEN API STUFF +OPENAI_API_KEY = "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" From f317cdb05544bdcb21dd47f260fb28c7f2fea239 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:04:13 +0530 Subject: [PATCH 02/13] Create Model pred --- Quantum Circuit Model Probability Prediction/Model pred | 1 + 1 file changed, 1 insertion(+) create mode 100644 Quantum Circuit Model Probability Prediction/Model pred diff --git a/Quantum Circuit Model Probability Prediction/Model pred b/Quantum Circuit Model Probability Prediction/Model pred new file mode 100644 index 000000000..8b1378917 --- /dev/null +++ b/Quantum Circuit Model Probability Prediction/Model pred @@ -0,0 +1 @@ + From 912ba086219222da18b1b4ef8dc9b685c2d10003 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:05:13 +0530 Subject: [PATCH 03/13] Add files via upload --- .../Quantum_model (2).ipynb | 568 ++++++++++++++++++ .../README (29).md | 36 ++ .../requirements (3).py | 3 + 3 files changed, 607 insertions(+) create mode 100644 Quantum Circuit Model Probability Prediction/Quantum_model (2).ipynb create mode 100644 Quantum Circuit Model Probability Prediction/README (29).md create mode 100644 Quantum Circuit Model Probability Prediction/requirements (3).py diff --git a/Quantum Circuit Model Probability Prediction/Quantum_model (2).ipynb b/Quantum Circuit Model Probability Prediction/Quantum_model (2).ipynb new file mode 100644 index 000000000..d51bcdd5e --- /dev/null +++ b/Quantum Circuit Model Probability Prediction/Quantum_model (2).ipynb @@ -0,0 +1,568 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "gpuType": "T4" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU" + }, + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WnPzT96j3A6n", + "outputId": "c3e90033-9e67-4b24-a9cd-3d3a73cb6e6f" + }, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting qiskit\n", + " Downloading qiskit-1.2.2-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.4.1+cu121)\n", + "Collecting rustworkx>=0.15.0 (from qiskit)\n", + " Downloading rustworkx-0.15.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (9.9 kB)\n", + "Requirement already satisfied: numpy<3,>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.3)\n", + "Collecting dill>=0.3 (from qiskit)\n", + " Downloading dill-0.3.8-py3-none-any.whl.metadata (10 kB)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (2.8.2)\n", + "Collecting stevedore>=3.0.0 (from qiskit)\n", + " Downloading stevedore-5.3.0-py3-none-any.whl.metadata (2.3 kB)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit) (4.12.2)\n", + "Collecting symengine>=0.11 (from qiskit)\n", + " Downloading symengine-0.11.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl.metadata (1.2 kB)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.16.1)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.3)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2024.6.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit) (1.16.0)\n", + "Collecting pbr>=2.0.0 (from stevedore>=3.0.0->qiskit)\n", + " Downloading pbr-6.1.0-py2.py3-none-any.whl.metadata (3.4 kB)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.5)\n", + "Downloading qiskit-1.2.2-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.7 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.7/4.7 MB\u001b[0m \u001b[31m24.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading dill-0.3.8-py3-none-any.whl (116 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m8.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading rustworkx-0.15.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.0 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m44.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading stevedore-5.3.0-py3-none-any.whl (49 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.7/49.7 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading symengine-0.11.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (39.4 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m39.4/39.4 MB\u001b[0m \u001b[31m15.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hDownloading pbr-6.1.0-py2.py3-none-any.whl (108 kB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m108.5/108.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: symengine, rustworkx, pbr, dill, stevedore, qiskit\n", + "Successfully installed dill-0.3.8 pbr-6.1.0 qiskit-1.2.2 rustworkx-0.15.1 stevedore-5.3.0 symengine-0.11.0\n" + ] + } + ], + "source": [ + "pip install qiskit torch\n" + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install qiskit-aer\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fVgB83wJ3qDr", + "outputId": "5391ebd1-8762-4786-9a7b-b7be87216d0b" + }, + "execution_count": 2, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting qiskit-aer\n", + " Downloading qiskit_aer-0.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (8.0 kB)\n", + "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", + "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", + "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", + "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", + "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", + "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", + "Downloading qiskit_aer-0.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.3 MB)\n", + "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.3/12.3 MB\u001b[0m \u001b[31m56.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", + "\u001b[?25hInstalling collected packages: qiskit-aer\n", + "Successfully installed qiskit-aer-0.15.1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install qiskit-aer --upgrade\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Vwm0l2kh30KJ", + "outputId": "724a3018-a685-40c7-d8a9-a403a3597da3" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", + "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", + "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", + "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", + "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", + "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", + "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install qiskit-aer\n", + "from qiskit_aer import Aer\n", + "\n", + "print(Aer.backends())" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "73JAx3rU4MbQ", + "outputId": "f9e5bd62-0b06-4346-adcd-198bcee614e0" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", + "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", + "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", + "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", + "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", + "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", + "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", + "[AerSimulator('aer_simulator'), AerSimulator('aer_simulator_statevector'), AerSimulator('aer_simulator_density_matrix'), AerSimulator('aer_simulator_stabilizer'), AerSimulator('aer_simulator_matrix_product_state'), AerSimulator('aer_simulator_extended_stabilizer'), AerSimulator('aer_simulator_unitary'), AerSimulator('aer_simulator_superop'), QasmSimulator('qasm_simulator'), StatevectorSimulator('statevector_simulator'), UnitarySimulator('unitary_simulator')]\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!pip install qiskit torch\n", + "!pip install qiskit-aer\n", + "!pip install qiskit-aer --upgrade\n", + "\n", + "from qiskit import QuantumCircuit, transpile\n", + "from qiskit.primitives import StatevectorSampler\n", + "from qiskit_aer import AerSimulator\n", + "import numpy as np\n", + "\n", + "# Quantum Circuit Simulation\n", + "def create_quantum_circuit(theta):\n", + " \"\"\"\n", + " Create a simple quantum circuit with a rotation.\n", + " :param theta: Rotation angle for the qubit.\n", + " \"\"\"\n", + " qc = QuantumCircuit(1, 1) # 1 qubit, 1 classical bit\n", + " qc.rx(theta, 0) # Applying rotation around the X-axis with angle theta\n", + " qc.measure(0, 0) # Measuring the qubit into the classical bit\n", + " return qc\n", + "\n", + "def simulate_quantum_circuit(theta):\n", + " \"\"\"\n", + " Simulate the quantum circuit with the given rotation.\n", + " :param theta: Rotation angle for the qubit.\n", + " :return: Measurement result probability (0 or 1).\n", + " \"\"\"\n", + " qc = create_quantum_circuit(theta)\n", + "\n", + "\n", + " simulator = AerSimulator()\n", + " compiled_circuit = transpile(qc, simulator)\n", + " job = simulator.run(compiled_circuit, shots=1000)\n", + " result = job.result()\n", + " counts = result.get_counts(qc)\n", + "\n", + "\n", + " total_shots = sum(counts.values())\n", + " probability_of_1 = counts.get('1', 0) / total_shots if total_shots else 0\n", + " return probability_of_1\n", + "\n", + "# Testing the quantum simulation\n", + "theta = np.pi / 4 # Example rotation angle\n", + "probability = simulate_quantum_circuit(theta)\n", + "print(f\"Probability of measuring |1⟩: {probability}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VISWpDez3Nl-", + "outputId": "a49f45b8-d8ec-4802-dbfc-2fc24a80fa5a" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: qiskit in /usr/local/lib/python3.10/dist-packages (1.2.2)\n", + "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.4.1+cu121)\n", + "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.15.1)\n", + "Requirement already satisfied: numpy<3,>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.3)\n", + "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.3.8)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (2.8.2)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (5.3.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit) (4.12.2)\n", + "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.11.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.16.1)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.3)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2024.6.1)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit) (1.16.0)\n", + "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit) (6.1.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit) (1.3.0)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.5)\n", + "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", + "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", + "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", + "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", + "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", + "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", + "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", + "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", + "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", + "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", + "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", + "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", + "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", + "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", + "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", + "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", + "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", + "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", + "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", + "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", + "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", + "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", + "Probability of measuring |1⟩: 0.144\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "\n", + "\n", + "class QuantumCircuitPredictor(nn.Module):\n", + " def __init__(self):\n", + " super(QuantumCircuitPredictor, self).__init__()\n", + " self.fc1 = nn.Linear(1, 16) # Input layer with 1 feature (theta)\n", + " self.fc2 = nn.Linear(16, 16) # Hidden layer\n", + " self.fc3 = nn.Linear(16, 1) # Output layer (predicted probability)\n", + "\n", + " def forward(self, x):\n", + " x = torch.relu(self.fc1(x))\n", + " x = torch.relu(self.fc2(x))\n", + " x = torch.sigmoid(self.fc3(x)) # Output between 0 and 1 (probability)\n", + " return x\n", + "\n", + "\n", + "model = QuantumCircuitPredictor()\n", + "criterion = nn.MSELoss()\n", + "optimizer = optim.Adam(model.parameters(), lr=0.01)\n", + "\n", + "# Training the model to match quantum simulation outputs\n", + "def train_model(model, target_probability, theta_values, epochs=100):\n", + " \"\"\"\n", + " Train the model to predict the probability from quantum circuit simulation.\n", + " :param model: Neural network model.\n", + " :param target_probability: Target probability we want the quantum circuit to achieve.\n", + " :param theta_values: Range of theta angles to train the model on.\n", + " :param epochs: Number of training epochs.\n", + " \"\"\"\n", + " for epoch in range(epochs):\n", + " total_loss = 0\n", + " for theta in theta_values:\n", + " optimizer.zero_grad()\n", + " theta_tensor = torch.tensor([[theta]], dtype=torch.float32) # Input angle\n", + " predicted_prob = model(theta_tensor) # Model's prediction\n", + "\n", + " # Simulate quantum circuit output for the current theta\n", + " true_prob = torch.tensor([[simulate_quantum_circuit(theta)]], dtype=torch.float32)\n", + "\n", + " # Compute loss between true and predicted probability\n", + " loss = criterion(predicted_prob, true_prob)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " total_loss += loss.item()\n", + "\n", + " if epoch % 10 == 0:\n", + " print(f\"Epoch {epoch}/{epochs}, Loss: {total_loss:.4f}\")\n", + "\n", + "# Generating a range of theta values for training\n", + "theta_values = np.linspace(0, 2 * np.pi, 100)\n", + "\n", + "# Training the model\n", + "train_model(model, target_probability=0.5, theta_values=theta_values)\n", + "\n", + "# Testing the model with new input\n", + "test_theta = torch.tensor([[np.pi / 2]], dtype=torch.float32)\n", + "predicted_probability = model(test_theta).item()\n", + "print(f\"Predicted Probability for θ = π/2: {predicted_probability}\")\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "MyWXEp0a3Nie", + "outputId": "392cecf5-6b2a-4ef0-907c-bc0fb48ec773" + }, + "execution_count": 6, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Epoch 0/100, Loss: 23.5006\n", + "Epoch 10/100, Loss: 19.3669\n", + "Epoch 20/100, Loss: 1.2515\n", + "Epoch 30/100, Loss: 0.1003\n", + "Epoch 40/100, Loss: 0.0617\n", + "Epoch 50/100, Loss: 0.0635\n", + "Epoch 60/100, Loss: 0.0458\n", + "Epoch 70/100, Loss: 0.0915\n", + "Epoch 80/100, Loss: 0.0966\n", + "Epoch 90/100, Loss: 0.2163\n", + "Predicted Probability for θ = π/2: 0.4365631341934204\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from qiskit import QuantumCircuit\n", + "from qiskit.quantum_info import Statevector\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def create_quantum_circuit(theta):\n", + " qc = QuantumCircuit(1) # 1 qubit, no classical bit required for statevector simulation\n", + " qc.rx(theta, 0) # Apply rotation around the X-axis with angle theta\n", + " return qc\n", + "\n", + "# Simulating the quantum circuit and retrieve the probability of measuring |1⟩\n", + "def simulate_quantum_circuit(theta):\n", + " qc = create_quantum_circuit(theta)\n", + "\n", + " # Simulating the quantum circuit using the Statevector class\n", + " statevector = Statevector.from_instruction(qc) # Get the statevector from the circuit\n", + "\n", + " # Probability of measuring |1⟩ is the square of the amplitude of the second state\n", + " probability_of_1 = np.abs(statevector.data[1]) ** 2 # statevector.data gives the amplitudes\n", + " return probability_of_1\n", + "\n", + "theta_values = np.linspace(0, 2 * np.pi, 100)\n", + "probabilities = []\n", + "\n", + "\n", + "for theta in theta_values:\n", + " probability = simulate_quantum_circuit(theta)\n", + " probabilities.append(probability)\n", + "\n", + "# results\n", + "plt.figure(figsize=(10, 5))\n", + "plt.plot(theta_values, probabilities, label='Probability of |1⟩', color='blue')\n", + "plt.title('Probability of Measuring |1⟩ as a Function of Rotation Angle θ')\n", + "plt.xlabel('Rotation Angle θ (radians)')\n", + "plt.ylabel('Probability of Measuring |1⟩')\n", + "plt.axhline(0.5, color='red', linestyle='--', label='P(|1⟩) = 0.5')\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.xticks(np.arange(0, 2 * np.pi + 0.1, np.pi/2),\n", + " ['0', r'$\\frac{\\pi}{2}$', r'$\\pi$', r'$\\frac{3\\pi}{2}$', r'$2\\pi$'])\n", + "plt.show()\n" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 497 + }, + "id": "jpZPpi92SiYz", + "outputId": "5a275027-8199-4c39-a0c4-faf240526009" + }, + "execution_count": 49, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + }, + { + "cell_type": "code", + "source": [ + "from qiskit import QuantumCircuit, transpile, assemble\n", + "from qiskit_aer import AerSimulator\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "\n", + "def create_quantum_circuit(theta):\n", + " qc = QuantumCircuit(1, 1)\n", + " qc.rx(theta, 0)\n", + " qc.measure(0, 0)\n", + " return qc\n", + "\n", + "\n", + "def simulate_quantum_circuit(theta):\n", + " qc = create_quantum_circuit(theta)\n", + "\n", + "\n", + " backend = AerSimulator()\n", + " transpiled_circuit = transpile(qc, backend)\n", + "\n", + " job = backend.run(transpiled_circuit, shots=1024)\n", + " result = job.result()\n", + " counts = result.get_counts(qc)\n", + " probability_of_1 = counts.get('1', 0) / 1024 # Probability of measuring |1⟩\n", + " probability_of_0 = counts.get('0', 0) / 1024 # Probability of measuring |0⟩\n", + "\n", + " return probability_of_1, probability_of_0\n", + "\n", + "\n", + "theta_values = np.linspace(0, 2 * np.pi, 100) # From 0 to 2π\n", + "probabilities_1 = []\n", + "probabilities_0 = []\n", + "\n", + "\n", + "for theta in theta_values:\n", + " prob_1, prob_0 = simulate_quantum_circuit(theta)\n", + " probabilities_1.append(prob_1)\n", + " probabilities_0.append(prob_0)\n", + "\n", + "# results\n", + "plt.figure(figsize=(15, 5))\n", + "\n", + "# Probability of measuring |1⟩\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(theta_values, probabilities_1, label='P(|1⟩)', color='blue')\n", + "plt.title('Probability of Measuring |1⟩ as a Function of Rotation Angle θ')\n", + "plt.xlabel('Rotation Angle θ (radians)')\n", + "plt.ylabel('Probability of |1⟩')\n", + "plt.axhline(0.5, color='red', linestyle='--', label='P(|1⟩) = 0.5')\n", + "plt.legend()\n", + "plt.grid()\n", + "\n", + "# Probability of measuring |0⟩\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(theta_values, probabilities_0, label='P(|0⟩)', color='orange')\n", + "plt.title('Probability of Measuring |0⟩ as a Function of Rotation Angle θ')\n", + "plt.xlabel('Rotation Angle θ (radians)')\n", + "plt.ylabel('Probability of |0⟩')\n", + "plt.axhline(0.5, color='green', linestyle='--', label='P(|0⟩) = 0.5')\n", + "plt.legend()\n", + "plt.grid()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 299 + }, + "id": "HcQXnyDcick0", + "outputId": "67c5fe2b-8416-4729-830c-afbeef8f96b8" + }, + "execution_count": 70, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "
" + ], + "image/png": "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\n" + }, + "metadata": {} + } + ] + } + ] +} \ No newline at end of file diff --git a/Quantum Circuit Model Probability Prediction/README (29).md b/Quantum Circuit Model Probability Prediction/README (29).md new file mode 100644 index 000000000..9abeafd0e --- /dev/null +++ b/Quantum Circuit Model Probability Prediction/README (29).md @@ -0,0 +1,36 @@ +# Quantum-Circuit-Probability-Prediction-using-ML + +The Quantum Circuit Probability Predictor is a machine learning-based application designed to predict the probability of measuring a specific quantum state after applying a series of quantum gates to a qubit. Leveraging the principles of quantum mechanics and classical machine learning, this project aims to create a robust model that accurately estimates the probabilities associated with different quantum states resulting from varied input parameters. + +The core functionalities include: + +Quantum Circuit Simulation: +----------------------------- +Utilizing Qiskit's advanced quantum simulation capabilities, the project creates quantum circuits that implement rotations around the X-axis based on user-defined angles. + +State Probability Calculation: +------------------------------- +The application computes the probabilities of measuring the |0⟩ and |1⟩ states for various angles, using statevector sampling to retrieve the state vector of the quantum circuit after the operations are performed. + +Model Training: +---------------- +A machine learning model is trained on the computed probabilities to predict outcomes for angles not seen during training, enabling the model to generalize well to new inputs. + +Interactive Visualization: +-------------------------- +The project features an intuitive interface that allows users to input angles and visualize the resulting probabilities and model predictions, enhancing the understanding of quantum state dynamics. + +Educational Tool: +----------------- +This project serves as an educational resource for students and enthusiasts interested in quantum computing and machine learning, demonstrating the intersection of these fields through hands-on experience. + +Technologies Used: +------------------ +Quantum Computing Framework: Qiskit +Machine Learning: Python, NumPy, and relevant ML libraries (e.g., scikit-learn, TensorFlow, or PyTorch) +Data Visualization: Matplotlib or similar libraries for plotting probabilities and predictions +User Interface: Streamlit or Flask for creating a web application interface (to be deployed soon after making model more optimized) + +Sample Output of predicted probability +![1000034342](https://github.com/user-attachments/assets/bc3fc538-ef41-47bb-a685-a2ff63d942cc) +![1000034344](https://github.com/user-attachments/assets/dc0d666e-8417-4c9c-88eb-2ae33b85ccc0) diff --git a/Quantum Circuit Model Probability Prediction/requirements (3).py b/Quantum Circuit Model Probability Prediction/requirements (3).py new file mode 100644 index 000000000..7668218d3 --- /dev/null +++ b/Quantum Circuit Model Probability Prediction/requirements (3).py @@ -0,0 +1,3 @@ +qiskit==0.43.1 +numpy==1.24.3 +matplotlib==3.7.1 From 2b120e51219f963232db032ce58302b00a12fb02 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:05:42 +0530 Subject: [PATCH 04/13] Delete Quantum Circuit Model Probability Prediction/Model pred --- Quantum Circuit Model Probability Prediction/Model pred | 1 - 1 file changed, 1 deletion(-) delete mode 100644 Quantum Circuit Model Probability Prediction/Model pred diff --git a/Quantum Circuit Model Probability Prediction/Model pred b/Quantum Circuit Model Probability Prediction/Model pred deleted file mode 100644 index 8b1378917..000000000 --- a/Quantum Circuit Model Probability Prediction/Model pred +++ /dev/null @@ -1 +0,0 @@ - From 4ca5de331c799e9a603f1f268da05f9f0a2f91f3 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:06:07 +0530 Subject: [PATCH 05/13] Rename Quantum_model (2).ipynb to Quantum_model.ipynb --- .../{Quantum_model (2).ipynb => Quantum_model.ipynb} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename Quantum Circuit Model Probability Prediction/{Quantum_model (2).ipynb => Quantum_model.ipynb} (99%) diff --git a/Quantum Circuit Model Probability Prediction/Quantum_model (2).ipynb b/Quantum Circuit Model Probability Prediction/Quantum_model.ipynb similarity index 99% rename from Quantum Circuit Model Probability Prediction/Quantum_model (2).ipynb rename to Quantum Circuit Model Probability Prediction/Quantum_model.ipynb index d51bcdd5e..d2120d9a6 100644 --- a/Quantum Circuit Model Probability Prediction/Quantum_model (2).ipynb +++ b/Quantum Circuit Model Probability Prediction/Quantum_model.ipynb @@ -565,4 +565,4 @@ ] } ] -} \ No newline at end of file +} From 956641f306129440851d421cbf89b28e67b51b38 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:06:24 +0530 Subject: [PATCH 06/13] Rename README (29).md to README.md --- .../{README (29).md => README.md} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Quantum Circuit Model Probability Prediction/{README (29).md => README.md} (100%) diff --git a/Quantum Circuit Model Probability Prediction/README (29).md b/Quantum Circuit Model Probability Prediction/README.md similarity index 100% rename from Quantum Circuit Model Probability Prediction/README (29).md rename to Quantum Circuit Model Probability Prediction/README.md From 84f4de7a9bc10b4738363c32574bda89487dcbdd Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:06:46 +0530 Subject: [PATCH 07/13] Rename requirements (3).py to requirements.py --- .../{requirements (3).py => requirements.py} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Quantum Circuit Model Probability Prediction/{requirements (3).py => requirements.py} (100%) diff --git a/Quantum Circuit Model Probability Prediction/requirements (3).py b/Quantum Circuit Model Probability Prediction/requirements.py similarity index 100% rename from Quantum Circuit Model Probability Prediction/requirements (3).py rename to Quantum Circuit Model Probability Prediction/requirements.py From 5bc7b5f367e8678959b8c8485baeb09e5b59b09d Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:07:18 +0530 Subject: [PATCH 08/13] Add files via upload --- .../gitignore (7).txt | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) create mode 100644 Quantum Circuit Model Probability Prediction/gitignore (7).txt diff --git a/Quantum Circuit Model Probability Prediction/gitignore (7).txt b/Quantum Circuit Model Probability Prediction/gitignore (7).txt new file mode 100644 index 000000000..319e0656f --- /dev/null +++ b/Quantum Circuit Model Probability Prediction/gitignore (7).txt @@ -0,0 +1,22 @@ +__pycache__/ +*.py[cod] +*$py.class +env/ +venv/ +.venv/ +.Python +env.bak/ +.ipynb_checkpoints +.DS_Store +Thumbs.db +ehthumbs.db +*.swp +*.swo +*.swn +*.bak +*.log +*.tmp +.vscode/ +.pytest_cache/ +*.cfg +*.config From e5d03830cc4bed3b1ed7f6049431a3f1d0f04d5a Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 05:07:57 +0530 Subject: [PATCH 09/13] Rename gitignore (7).txt to gitignore.txt --- .../{gitignore (7).txt => gitignore.txt} | 0 1 file changed, 0 insertions(+), 0 deletions(-) rename Quantum Circuit Model Probability Prediction/{gitignore (7).txt => gitignore.txt} (100%) diff --git a/Quantum Circuit Model Probability Prediction/gitignore (7).txt b/Quantum Circuit Model Probability Prediction/gitignore.txt similarity index 100% rename from Quantum Circuit Model Probability Prediction/gitignore (7).txt rename to Quantum Circuit Model Probability Prediction/gitignore.txt From a4889e7c79e7325b68c0e9a836525cae4c620cc9 Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 19:02:30 +0530 Subject: [PATCH 10/13] Delete Quantum Circuit Model Probability Prediction/Quantum_model.ipynb --- .../Quantum_model.ipynb | 568 ------------------ 1 file changed, 568 deletions(-) delete mode 100644 Quantum Circuit Model Probability Prediction/Quantum_model.ipynb diff --git a/Quantum Circuit Model Probability Prediction/Quantum_model.ipynb b/Quantum Circuit Model Probability Prediction/Quantum_model.ipynb deleted file mode 100644 index d2120d9a6..000000000 --- a/Quantum Circuit Model Probability Prediction/Quantum_model.ipynb +++ /dev/null @@ -1,568 +0,0 @@ -{ - "nbformat": 4, - "nbformat_minor": 0, - "metadata": { - "colab": { - "provenance": [], - "gpuType": "T4" - }, - "kernelspec": { - "name": "python3", - "display_name": "Python 3" - }, - "language_info": { - "name": "python" - }, - "accelerator": "GPU" - }, - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "WnPzT96j3A6n", - "outputId": "c3e90033-9e67-4b24-a9cd-3d3a73cb6e6f" - }, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting qiskit\n", - " Downloading qiskit-1.2.2-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (12 kB)\n", - "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.4.1+cu121)\n", - "Collecting rustworkx>=0.15.0 (from qiskit)\n", - " Downloading rustworkx-0.15.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (9.9 kB)\n", - "Requirement already satisfied: numpy<3,>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.26.4)\n", - "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.1)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.3)\n", - "Collecting dill>=0.3 (from qiskit)\n", - " Downloading dill-0.3.8-py3-none-any.whl.metadata (10 kB)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (2.8.2)\n", - "Collecting stevedore>=3.0.0 (from qiskit)\n", - " Downloading stevedore-5.3.0-py3-none-any.whl.metadata (2.3 kB)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit) (4.12.2)\n", - "Collecting symengine>=0.11 (from qiskit)\n", - " Downloading symengine-0.11.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl.metadata (1.2 kB)\n", - "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.16.1)\n", - "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.3)\n", - "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n", - "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2024.6.1)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit) (1.16.0)\n", - "Collecting pbr>=2.0.0 (from stevedore>=3.0.0->qiskit)\n", - " Downloading pbr-6.1.0-py2.py3-none-any.whl.metadata (3.4 kB)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit) (1.3.0)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.5)\n", - "Downloading qiskit-1.2.2-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.7 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m4.7/4.7 MB\u001b[0m \u001b[31m24.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading dill-0.3.8-py3-none-any.whl (116 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m116.3/116.3 kB\u001b[0m \u001b[31m8.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading rustworkx-0.15.1-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (2.0 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m2.0/2.0 MB\u001b[0m \u001b[31m44.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading stevedore-5.3.0-py3-none-any.whl (49 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m49.7/49.7 kB\u001b[0m \u001b[31m2.9 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading symengine-0.11.0-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (39.4 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m39.4/39.4 MB\u001b[0m \u001b[31m15.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hDownloading pbr-6.1.0-py2.py3-none-any.whl (108 kB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m108.5/108.5 kB\u001b[0m \u001b[31m5.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hInstalling collected packages: symengine, rustworkx, pbr, dill, stevedore, qiskit\n", - "Successfully installed dill-0.3.8 pbr-6.1.0 qiskit-1.2.2 rustworkx-0.15.1 stevedore-5.3.0 symengine-0.11.0\n" - ] - } - ], - "source": [ - "pip install qiskit torch\n" - ] - }, - { - "cell_type": "code", - "source": [ - "!pip install qiskit-aer\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "fVgB83wJ3qDr", - "outputId": "5391ebd1-8762-4786-9a7b-b7be87216d0b" - }, - "execution_count": 2, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Collecting qiskit-aer\n", - " Downloading qiskit_aer-0.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl.metadata (8.0 kB)\n", - "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", - "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", - "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", - "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", - "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", - "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", - "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", - "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", - "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", - "Downloading qiskit_aer-0.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (12.3 MB)\n", - "\u001b[2K \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m12.3/12.3 MB\u001b[0m \u001b[31m56.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n", - "\u001b[?25hInstalling collected packages: qiskit-aer\n", - "Successfully installed qiskit-aer-0.15.1\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "!pip install qiskit-aer --upgrade\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "Vwm0l2kh30KJ", - "outputId": "724a3018-a685-40c7-d8a9-a403a3597da3" - }, - "execution_count": 3, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", - "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", - "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", - "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", - "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", - "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", - "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", - "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", - "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", - "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "!pip install qiskit-aer\n", - "from qiskit_aer import Aer\n", - "\n", - "print(Aer.backends())" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "73JAx3rU4MbQ", - "outputId": "f9e5bd62-0b06-4346-adcd-198bcee614e0" - }, - "execution_count": 4, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", - "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", - "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", - "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", - "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", - "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", - "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", - "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", - "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", - "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", - "[AerSimulator('aer_simulator'), AerSimulator('aer_simulator_statevector'), AerSimulator('aer_simulator_density_matrix'), AerSimulator('aer_simulator_stabilizer'), AerSimulator('aer_simulator_matrix_product_state'), AerSimulator('aer_simulator_extended_stabilizer'), AerSimulator('aer_simulator_unitary'), AerSimulator('aer_simulator_superop'), QasmSimulator('qasm_simulator'), StatevectorSimulator('statevector_simulator'), UnitarySimulator('unitary_simulator')]\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "!pip install qiskit torch\n", - "!pip install qiskit-aer\n", - "!pip install qiskit-aer --upgrade\n", - "\n", - "from qiskit import QuantumCircuit, transpile\n", - "from qiskit.primitives import StatevectorSampler\n", - "from qiskit_aer import AerSimulator\n", - "import numpy as np\n", - "\n", - "# Quantum Circuit Simulation\n", - "def create_quantum_circuit(theta):\n", - " \"\"\"\n", - " Create a simple quantum circuit with a rotation.\n", - " :param theta: Rotation angle for the qubit.\n", - " \"\"\"\n", - " qc = QuantumCircuit(1, 1) # 1 qubit, 1 classical bit\n", - " qc.rx(theta, 0) # Applying rotation around the X-axis with angle theta\n", - " qc.measure(0, 0) # Measuring the qubit into the classical bit\n", - " return qc\n", - "\n", - "def simulate_quantum_circuit(theta):\n", - " \"\"\"\n", - " Simulate the quantum circuit with the given rotation.\n", - " :param theta: Rotation angle for the qubit.\n", - " :return: Measurement result probability (0 or 1).\n", - " \"\"\"\n", - " qc = create_quantum_circuit(theta)\n", - "\n", - "\n", - " simulator = AerSimulator()\n", - " compiled_circuit = transpile(qc, simulator)\n", - " job = simulator.run(compiled_circuit, shots=1000)\n", - " result = job.result()\n", - " counts = result.get_counts(qc)\n", - "\n", - "\n", - " total_shots = sum(counts.values())\n", - " probability_of_1 = counts.get('1', 0) / total_shots if total_shots else 0\n", - " return probability_of_1\n", - "\n", - "# Testing the quantum simulation\n", - "theta = np.pi / 4 # Example rotation angle\n", - "probability = simulate_quantum_circuit(theta)\n", - "print(f\"Probability of measuring |1⟩: {probability}\")" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "VISWpDez3Nl-", - "outputId": "a49f45b8-d8ec-4802-dbfc-2fc24a80fa5a" - }, - "execution_count": 5, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Requirement already satisfied: qiskit in /usr/local/lib/python3.10/dist-packages (1.2.2)\n", - "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (2.4.1+cu121)\n", - "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.15.1)\n", - "Requirement already satisfied: numpy<3,>=1.17 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.26.4)\n", - "Requirement already satisfied: scipy>=1.5 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.1)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit) (1.13.3)\n", - "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.3.8)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (2.8.2)\n", - "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit) (5.3.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit) (4.12.2)\n", - "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit) (0.11.0)\n", - "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch) (3.16.1)\n", - "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch) (3.3)\n", - "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch) (3.1.4)\n", - "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch) (2024.6.1)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit) (1.16.0)\n", - "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit) (6.1.0)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit) (1.3.0)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch) (2.1.5)\n", - "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", - "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", - "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", - "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", - "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", - "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", - "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", - "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", - "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", - "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", - "Requirement already satisfied: qiskit-aer in /usr/local/lib/python3.10/dist-packages (0.15.1)\n", - "Requirement already satisfied: qiskit>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.2.2)\n", - "Requirement already satisfied: numpy>=1.16.3 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.26.4)\n", - "Requirement already satisfied: scipy>=1.0 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (1.13.1)\n", - "Requirement already satisfied: psutil>=5 in /usr/local/lib/python3.10/dist-packages (from qiskit-aer) (5.9.5)\n", - "Requirement already satisfied: rustworkx>=0.15.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.15.1)\n", - "Requirement already satisfied: sympy>=1.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (1.13.3)\n", - "Requirement already satisfied: dill>=0.3 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.3.8)\n", - "Requirement already satisfied: python-dateutil>=2.8.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (2.8.2)\n", - "Requirement already satisfied: stevedore>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (5.3.0)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (4.12.2)\n", - "Requirement already satisfied: symengine>=0.11 in /usr/local/lib/python3.10/dist-packages (from qiskit>=1.1.0->qiskit-aer) (0.11.0)\n", - "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.0->qiskit>=1.1.0->qiskit-aer) (1.16.0)\n", - "Requirement already satisfied: pbr>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from stevedore>=3.0.0->qiskit>=1.1.0->qiskit-aer) (6.1.0)\n", - "Requirement already satisfied: mpmath<1.4,>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from sympy>=1.3->qiskit>=1.1.0->qiskit-aer) (1.3.0)\n", - "Probability of measuring |1⟩: 0.144\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "\n", - "\n", - "class QuantumCircuitPredictor(nn.Module):\n", - " def __init__(self):\n", - " super(QuantumCircuitPredictor, self).__init__()\n", - " self.fc1 = nn.Linear(1, 16) # Input layer with 1 feature (theta)\n", - " self.fc2 = nn.Linear(16, 16) # Hidden layer\n", - " self.fc3 = nn.Linear(16, 1) # Output layer (predicted probability)\n", - "\n", - " def forward(self, x):\n", - " x = torch.relu(self.fc1(x))\n", - " x = torch.relu(self.fc2(x))\n", - " x = torch.sigmoid(self.fc3(x)) # Output between 0 and 1 (probability)\n", - " return x\n", - "\n", - "\n", - "model = QuantumCircuitPredictor()\n", - "criterion = nn.MSELoss()\n", - "optimizer = optim.Adam(model.parameters(), lr=0.01)\n", - "\n", - "# Training the model to match quantum simulation outputs\n", - "def train_model(model, target_probability, theta_values, epochs=100):\n", - " \"\"\"\n", - " Train the model to predict the probability from quantum circuit simulation.\n", - " :param model: Neural network model.\n", - " :param target_probability: Target probability we want the quantum circuit to achieve.\n", - " :param theta_values: Range of theta angles to train the model on.\n", - " :param epochs: Number of training epochs.\n", - " \"\"\"\n", - " for epoch in range(epochs):\n", - " total_loss = 0\n", - " for theta in theta_values:\n", - " optimizer.zero_grad()\n", - " theta_tensor = torch.tensor([[theta]], dtype=torch.float32) # Input angle\n", - " predicted_prob = model(theta_tensor) # Model's prediction\n", - "\n", - " # Simulate quantum circuit output for the current theta\n", - " true_prob = torch.tensor([[simulate_quantum_circuit(theta)]], dtype=torch.float32)\n", - "\n", - " # Compute loss between true and predicted probability\n", - " loss = criterion(predicted_prob, true_prob)\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " total_loss += loss.item()\n", - "\n", - " if epoch % 10 == 0:\n", - " print(f\"Epoch {epoch}/{epochs}, Loss: {total_loss:.4f}\")\n", - "\n", - "# Generating a range of theta values for training\n", - "theta_values = np.linspace(0, 2 * np.pi, 100)\n", - "\n", - "# Training the model\n", - "train_model(model, target_probability=0.5, theta_values=theta_values)\n", - "\n", - "# Testing the model with new input\n", - "test_theta = torch.tensor([[np.pi / 2]], dtype=torch.float32)\n", - "predicted_probability = model(test_theta).item()\n", - "print(f\"Predicted Probability for θ = π/2: {predicted_probability}\")\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "MyWXEp0a3Nie", - "outputId": "392cecf5-6b2a-4ef0-907c-bc0fb48ec773" - }, - "execution_count": 6, - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Epoch 0/100, Loss: 23.5006\n", - "Epoch 10/100, Loss: 19.3669\n", - "Epoch 20/100, Loss: 1.2515\n", - "Epoch 30/100, Loss: 0.1003\n", - "Epoch 40/100, Loss: 0.0617\n", - "Epoch 50/100, Loss: 0.0635\n", - "Epoch 60/100, Loss: 0.0458\n", - "Epoch 70/100, Loss: 0.0915\n", - "Epoch 80/100, Loss: 0.0966\n", - "Epoch 90/100, Loss: 0.2163\n", - "Predicted Probability for θ = π/2: 0.4365631341934204\n" - ] - } - ] - }, - { - "cell_type": "code", - "source": [ - "from qiskit import QuantumCircuit\n", - "from qiskit.quantum_info import Statevector\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "def create_quantum_circuit(theta):\n", - " qc = QuantumCircuit(1) # 1 qubit, no classical bit required for statevector simulation\n", - " qc.rx(theta, 0) # Apply rotation around the X-axis with angle theta\n", - " return qc\n", - "\n", - "# Simulating the quantum circuit and retrieve the probability of measuring |1⟩\n", - "def simulate_quantum_circuit(theta):\n", - " qc = create_quantum_circuit(theta)\n", - "\n", - " # Simulating the quantum circuit using the Statevector class\n", - " statevector = Statevector.from_instruction(qc) # Get the statevector from the circuit\n", - "\n", - " # Probability of measuring |1⟩ is the square of the amplitude of the second state\n", - " probability_of_1 = np.abs(statevector.data[1]) ** 2 # statevector.data gives the amplitudes\n", - " return probability_of_1\n", - "\n", - "theta_values = np.linspace(0, 2 * np.pi, 100)\n", - "probabilities = []\n", - "\n", - "\n", - "for theta in theta_values:\n", - " probability = simulate_quantum_circuit(theta)\n", - " probabilities.append(probability)\n", - "\n", - "# results\n", - "plt.figure(figsize=(10, 5))\n", - "plt.plot(theta_values, probabilities, label='Probability of |1⟩', color='blue')\n", - "plt.title('Probability of Measuring |1⟩ as a Function of Rotation Angle θ')\n", - "plt.xlabel('Rotation Angle θ (radians)')\n", - "plt.ylabel('Probability of Measuring |1⟩')\n", - "plt.axhline(0.5, color='red', linestyle='--', label='P(|1⟩) = 0.5')\n", - "plt.legend()\n", - "plt.grid()\n", - "plt.xticks(np.arange(0, 2 * np.pi + 0.1, np.pi/2),\n", - " ['0', r'$\\frac{\\pi}{2}$', r'$\\pi$', r'$\\frac{3\\pi}{2}$', r'$2\\pi$'])\n", - "plt.show()\n" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 497 - }, - "id": "jpZPpi92SiYz", - "outputId": "5a275027-8199-4c39-a0c4-faf240526009" - }, - "execution_count": 49, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - }, - { - "cell_type": "code", - "source": [ - "from qiskit import QuantumCircuit, transpile, assemble\n", - "from qiskit_aer import AerSimulator\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "\n", - "\n", - "def create_quantum_circuit(theta):\n", - " qc = QuantumCircuit(1, 1)\n", - " qc.rx(theta, 0)\n", - " qc.measure(0, 0)\n", - " return qc\n", - "\n", - "\n", - "def simulate_quantum_circuit(theta):\n", - " qc = create_quantum_circuit(theta)\n", - "\n", - "\n", - " backend = AerSimulator()\n", - " transpiled_circuit = transpile(qc, backend)\n", - "\n", - " job = backend.run(transpiled_circuit, shots=1024)\n", - " result = job.result()\n", - " counts = result.get_counts(qc)\n", - " probability_of_1 = counts.get('1', 0) / 1024 # Probability of measuring |1⟩\n", - " probability_of_0 = counts.get('0', 0) / 1024 # Probability of measuring |0⟩\n", - "\n", - " return probability_of_1, probability_of_0\n", - "\n", - "\n", - "theta_values = np.linspace(0, 2 * np.pi, 100) # From 0 to 2π\n", - "probabilities_1 = []\n", - "probabilities_0 = []\n", - "\n", - "\n", - "for theta in theta_values:\n", - " prob_1, prob_0 = simulate_quantum_circuit(theta)\n", - " probabilities_1.append(prob_1)\n", - " probabilities_0.append(prob_0)\n", - "\n", - "# results\n", - "plt.figure(figsize=(15, 5))\n", - "\n", - "# Probability of measuring |1⟩\n", - "plt.subplot(1, 2, 1)\n", - "plt.plot(theta_values, probabilities_1, label='P(|1⟩)', color='blue')\n", - "plt.title('Probability of Measuring |1⟩ as a Function of Rotation Angle θ')\n", - "plt.xlabel('Rotation Angle θ (radians)')\n", - "plt.ylabel('Probability of |1⟩')\n", - "plt.axhline(0.5, color='red', linestyle='--', label='P(|1⟩) = 0.5')\n", - "plt.legend()\n", - "plt.grid()\n", - "\n", - "# Probability of measuring |0⟩\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(theta_values, probabilities_0, label='P(|0⟩)', color='orange')\n", - "plt.title('Probability of Measuring |0⟩ as a Function of Rotation Angle θ')\n", - "plt.xlabel('Rotation Angle θ (radians)')\n", - "plt.ylabel('Probability of |0⟩')\n", - "plt.axhline(0.5, color='green', linestyle='--', label='P(|0⟩) = 0.5')\n", - "plt.legend()\n", - "plt.grid()\n", - "\n", - "plt.tight_layout()\n", - "plt.show()" - ], - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/", - "height": 299 - }, - "id": "HcQXnyDcick0", - "outputId": "67c5fe2b-8416-4729-830c-afbeef8f96b8" - }, - "execution_count": 70, - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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\n" - }, - "metadata": {} - } - ] - } - ] -} From 04f824c8f13b2aa8ef9cf4033d8797dfafb30b9d Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 19:02:39 +0530 Subject: [PATCH 11/13] Delete Quantum Circuit Model Probability Prediction/README.md --- .../README.md | 36 ------------------- 1 file changed, 36 deletions(-) delete mode 100644 Quantum Circuit Model Probability Prediction/README.md diff --git a/Quantum Circuit Model Probability Prediction/README.md b/Quantum Circuit Model Probability Prediction/README.md deleted file mode 100644 index 9abeafd0e..000000000 --- a/Quantum Circuit Model Probability Prediction/README.md +++ /dev/null @@ -1,36 +0,0 @@ -# Quantum-Circuit-Probability-Prediction-using-ML - -The Quantum Circuit Probability Predictor is a machine learning-based application designed to predict the probability of measuring a specific quantum state after applying a series of quantum gates to a qubit. Leveraging the principles of quantum mechanics and classical machine learning, this project aims to create a robust model that accurately estimates the probabilities associated with different quantum states resulting from varied input parameters. - -The core functionalities include: - -Quantum Circuit Simulation: ------------------------------ -Utilizing Qiskit's advanced quantum simulation capabilities, the project creates quantum circuits that implement rotations around the X-axis based on user-defined angles. - -State Probability Calculation: -------------------------------- -The application computes the probabilities of measuring the |0⟩ and |1⟩ states for various angles, using statevector sampling to retrieve the state vector of the quantum circuit after the operations are performed. - -Model Training: ----------------- -A machine learning model is trained on the computed probabilities to predict outcomes for angles not seen during training, enabling the model to generalize well to new inputs. - -Interactive Visualization: --------------------------- -The project features an intuitive interface that allows users to input angles and visualize the resulting probabilities and model predictions, enhancing the understanding of quantum state dynamics. - -Educational Tool: ------------------ -This project serves as an educational resource for students and enthusiasts interested in quantum computing and machine learning, demonstrating the intersection of these fields through hands-on experience. - -Technologies Used: ------------------- -Quantum Computing Framework: Qiskit -Machine Learning: Python, NumPy, and relevant ML libraries (e.g., scikit-learn, TensorFlow, or PyTorch) -Data Visualization: Matplotlib or similar libraries for plotting probabilities and predictions -User Interface: Streamlit or Flask for creating a web application interface (to be deployed soon after making model more optimized) - -Sample Output of predicted probability -![1000034342](https://github.com/user-attachments/assets/bc3fc538-ef41-47bb-a685-a2ff63d942cc) -![1000034344](https://github.com/user-attachments/assets/dc0d666e-8417-4c9c-88eb-2ae33b85ccc0) From 4482874016fa89d174cf8f23296b91f6114926ad Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 19:02:47 +0530 Subject: [PATCH 12/13] Delete Quantum Circuit Model Probability Prediction/requirements.py --- Quantum Circuit Model Probability Prediction/requirements.py | 3 --- 1 file changed, 3 deletions(-) delete mode 100644 Quantum Circuit Model Probability Prediction/requirements.py diff --git a/Quantum Circuit Model Probability Prediction/requirements.py b/Quantum Circuit Model Probability Prediction/requirements.py deleted file mode 100644 index 7668218d3..000000000 --- a/Quantum Circuit Model Probability Prediction/requirements.py +++ /dev/null @@ -1,3 +0,0 @@ -qiskit==0.43.1 -numpy==1.24.3 -matplotlib==3.7.1 From 15f4c0e91c9e6564a0810e143caa0ba959a25f3d Mon Sep 17 00:00:00 2001 From: Panchadip Date: Sun, 10 Nov 2024 19:02:57 +0530 Subject: [PATCH 13/13] Delete Quantum Circuit Model Probability Prediction/gitignore.txt --- .../gitignore.txt | 22 ------------------- 1 file changed, 22 deletions(-) delete mode 100644 Quantum Circuit Model Probability Prediction/gitignore.txt diff --git a/Quantum Circuit Model Probability Prediction/gitignore.txt b/Quantum Circuit Model Probability Prediction/gitignore.txt deleted file mode 100644 index 319e0656f..000000000 --- a/Quantum Circuit Model Probability Prediction/gitignore.txt +++ /dev/null @@ -1,22 +0,0 @@ -__pycache__/ -*.py[cod] -*$py.class -env/ -venv/ -.venv/ -.Python -env.bak/ -.ipynb_checkpoints -.DS_Store -Thumbs.db -ehthumbs.db -*.swp -*.swo -*.swn -*.bak -*.log -*.tmp -.vscode/ -.pytest_cache/ -*.cfg -*.config