{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 量子启发式算法NPU后端使用教程\n", "\n", "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindquantum/zh_cn/case_library/mindspore_qaia_npu_tutorial.ipynb) \n", "[![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/master/mindquantum/zh_cn/case_library/mindspore_qaia_npu_tutorial.py) \n", "[![在Gitee上查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/master/resource/_static/logo_source.svg)](https://gitee.com/mindspore/docs/blob/master/docs/mindquantum/docs/source_zh_cn/case_library/qaia_npu_tutorial.ipynb)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "本篇教程基于MindQuantum介绍量子启发式算法的NPU后端的参数细节和使用方法，并提供实战教程，带领开发者手把手入门。\n", "\n", "本文将从下面六点进行展开说明：\n", "\n", "- 昇腾平台介绍，NPU芯片的特点性能。\n", "- 系统环境配置，检查硬件并安装软件。\n", "- 介绍MindQuantum和量子启发式算法。\n", "- 介绍量子启发式算法NPU后端支持的精度类型，提供矩阵运算样例代码。\n", "- 使用量子启发式算法NPU后端求解最大割问题。\n", "- 对比量子启发式算法在CPU和NPU后端上的性能优势。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 昇腾平台介绍\n", "\n", "- 达芬奇NPU核心‌：专为矩阵运算优化的3D Cube架构，昇腾芯片提供256TOPS INT8算力。\n", "- 混合精度计算‌：支持FP32/FP16/INT8混合精度，满足深度学习、大模型训练推理和量子计算不同阶段计算需求。\n", "- 超高能效比‌：相比传统GPU能效提升2-3倍，降低运营成本。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 系统环境配置\n", "\n", "### 硬件配置\n", "\n", "- 支持昇腾NPU\n", "- 支持算子版本：CANN-7/CANN-8\n" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:07.744914Z", "iopub.status.busy": "2025-09-04T12:11:07.744142Z", "iopub.status.idle": "2025-09-04T12:11:08.242121Z", "shell.execute_reply": "2025-09-04T12:11:08.240563Z" } }, "outputs": [], "source": [ "# 配置环境变量\n", "!source /usr/local/Ascend/ascend-toolkit/set_env.sh" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:08.246651Z", "iopub.status.busy": "2025-09-04T12:11:08.246030Z", "iopub.status.idle": "2025-09-04T12:11:08.253025Z", "shell.execute_reply": "2025-09-04T12:11:08.251969Z" } }, "outputs": [], "source": [ "import os\n", "\n", "os.environ[\"LD_LIBRARY_PATH\"] = \":\".join(\n", " [\n", " \"/usr/local/Ascend/driver/lib64:\",\n", " \"/usr/local/Ascend/driver/lib64/common:\",\n", " \"/usr/local/Ascend/ascend-toolkit/latest/aarch64-linux/lib64:\",\n", " \"/usr/local/Ascend/driver/lib64/driver:\",\n", " os.environ.get(\"LD_LIBRARY_PATH\", \"\"),\n", " ]\n", ")" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:08.256710Z", "iopub.status.busy": "2025-09-04T12:11:08.255912Z", "iopub.status.idle": "2025-09-04T12:11:09.249350Z", "shell.execute_reply": "2025-09-04T12:11:09.247952Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "+------------------------------------------------------------------------------------------------+\r\n", "| npu-smi 23.0.3 Version: 23.0.3 |\r\n", "+---------------------------+---------------+----------------------------------------------------+\r\n", "| NPU Name | Health | Power(W) Temp(C) Hugepages-Usage(page)|\r\n", "| Chip | Bus-Id | AICore(%) Memory-Usage(MB) HBM-Usage(MB) |\r\n", "+===========================+===============+====================================================+\r\n", "| 0 910 | OK | 93.8 40 0 / 0 |\r\n", "| 0 | 0000:C1:00.0 | 0 0 / 0 3326 / 65536 |\r\n", "+===========================+===============+====================================================+\r\n", "+---------------------------+---------------+----------------------------------------------------+\r\n", "| NPU Chip | Process id | Process name | Process memory(MB) |\r\n", "+===========================+===============+====================================================+\r\n", "| No running processes found in NPU 0 |\r\n", "+===========================+===============+====================================================+\r\n" ] } ], "source": [ "# 输出系统NPU型号、数量、驱动版本\n", "!npu-smi info" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 软件安装" ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:09.254120Z", "iopub.status.busy": "2025-09-04T12:11:09.253501Z", "iopub.status.idle": "2025-09-04T12:11:09.259194Z", "shell.execute_reply": "2025-09-04T12:11:09.258158Z" }, "tags": [], "vscode": { "languageId": "shellscript" } }, "outputs": [], "source": [ "# 可选，已安装软件则不需要执行此步\n", "# !pip install torch_npu\n", "# !pip install mindquantum" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 验证NPU是否正常可用" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:09.263074Z", "iopub.status.busy": "2025-09-04T12:11:09.262301Z", "iopub.status.idle": "2025-09-04T12:11:13.989847Z", "shell.execute_reply": "2025-09-04T12:11:13.988680Z" } }, "outputs": [ { "data": { "text/plain": [ "True" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 检查NPU是否可用\n", "import torch_npu\n", "\n", "torch_npu.npu.is_available()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## MindQuantum介绍\n", "\n", "**MindQuantum**是基于昇思MindSpore开源深度学习平台开发的新一代通用量子计算框架，聚焦于NISQ阶段的算法实现与落地。结合HiQ高性能量子计算模拟器和昇思MindSpore并行自动微分能力，提供极简的开发模式和极致的性能体验。\n", "\n", "MindQuantum已经[集成量子启发式算法模块](https://www.mindspore.cn/mindquantum/docs/zh-CN/r0.11/algorithm/mindquantum.algorithm.qaia.html)，并提供**CPU、GPU、NUP/昇腾**版本，适配多种硬件设备，并提供极致性能。\n", "\n", "量子启发式算法是一类基于**量子力学原理**的计算方法衍生或启发的经典力学方法，旨在利用量子力学的独特性质（叠加态、量子纠缠和量子并行性）来改进传统算法的性能。\n", "\n", "常见的**量子启发式算法**包括：\n", "\n", "- ASB（Adiabatic Simulated bifurcation/绝热模拟分叉算法）\n", "- BSB（Ballistic Simulated bifurcation/弹道模拟分叉算法）\n", "- DSB（Discrete Simulated bifurcation/离散模拟分叉算法）\n", "- SimCIM（Simulated Coherent Ising Machine/模拟相干伊辛机算法）\n", "- LQA（Local Quantum Annealing/局部量子退火算法）\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 量子启发式算法NPU后端\n", "\n", "量子启发式算法[支持后端](https://www.mindspore.cn/mindquantum/docs/zh-CN/r0.11/algorithm/qaia/mindquantum.algorithm.qaia.QAIA.html#mindquantum.algorithm.qaia.QAIA)：\n", "\n", "- backend (str) - 计算后端和精度：'cpu-float32'、'gpu-float32'、'gpu-float16'、'gpu-int8' 或 'npu-float32'，默认值： 'cpu-float32'。\n", "- NPU后端现支持的数据精度：float32" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 矩阵运算样例" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:13.994416Z", "iopub.status.busy": "2025-09-04T12:11:13.993766Z", "iopub.status.idle": "2025-09-04T12:11:22.711875Z", "shell.execute_reply": "2025-09-04T12:11:22.710333Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Warning: Device do not support double dtype now, dtype cast repalce with float.\n", "Cut: tensor([0., 1., 1., 1., 1., 1., 0., 1., 1., 0.], device='npu:0')\n", "Energy: tensor([ 1., -1., -1., -1., -1., -1., 1., -1., -1., 1.], device='npu:0')\n" ] } ], "source": [ "from scipy.sparse import coo_matrix\n", "from mindquantum.algorithm.qaia import DSB\n", "\n", "# 矩阵[[0,-1],[-1,0]]\n", "J = coo_matrix(([-1, -1], ([0, 1], [1, 0])), shape=(2, 2))\n", "solver = DSB(J, batch_size=10, backend=\"npu-float32\")\n", "solver.update()\n", "cut = solver.calc_cut()\n", "energy = solver.calc_energy()\n", "\n", "print(f\"Cut: {cut}\\nEnergy: {energy}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 实战案例-使用量子启发式算法求解最大割问题" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:22.716944Z", "iopub.status.busy": "2025-09-04T12:11:22.716176Z", "iopub.status.idle": "2025-09-04T12:11:23.271479Z", "shell.execute_reply": "2025-09-04T12:11:23.270330Z" } }, "outputs": [], "source": [ "# 导入需要的Python模块\n", "from mindquantum.algorithm.qaia import DSB\n", "import numpy as np\n", "import pandas as pd\n", "from scipy.sparse import coo_matrix\n", "import time" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:23.276470Z", "iopub.status.busy": "2025-09-04T12:11:23.275801Z", "iopub.status.idle": "2025-09-04T12:11:40.768826Z", "shell.execute_reply": "2025-09-04T12:11:40.767736Z" } }, "outputs": [ { "data": { "text/plain": [ "217828" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 数据准备\n", "# 下载数据，无向图数据集来源于GSet\n", "import requests\n", "\n", "graph_file = \"https://web.stanford.edu/~yyye/yyye/Gset/G22\"\n", "\n", "# 使用requests库中的get方法发送HTTP请求，将url的响应结果存入变量，再以二进制写入模式打开文件写入本地\n", "response = requests.get(graph_file)\n", "open(\"G22\", \"wb\").write(response.content)\n", "\n", "\n", "# 如果上述-下载图集的代码执行，报错TimeoutError，说明是网络问题\n", "# 可以手动点击网址 https://web.stanford.edu/~yyye/yyye/Gset/G22，下载数据，保存在本地，与该教程同级目录" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:40.772886Z", "iopub.status.busy": "2025-09-04T12:11:40.772355Z", "iopub.status.idle": "2025-09-04T12:11:40.794205Z", "shell.execute_reply": "2025-09-04T12:11:40.793173Z" } }, "outputs": [], "source": [ "# 数据处理\n", "def read_gset(filename, negate=True):\n", " # 读取图表\n", " graph = pd.read_csv(filename, sep=\" \")\n", " # 节点的数量\n", " n_v = int(graph.columns[0])\n", " # 边的数量\n", " n_e = int(graph.columns[1])\n", "\n", " # 如果节点和边不匹配，会抛出错误\n", " assert n_e == graph.shape[0], \"The number of edges is not matched\"\n", "\n", " # 将读取的数据转换为一个COO矩阵（Coordinate List Format），并返回一个稀疏矩阵\n", " G = coo_matrix(\n", " (\n", " np.concatenate([graph.iloc[:, -1], graph.iloc[:, -1]]),\n", " (\n", " np.concatenate([graph.iloc[:, 0] - 1, graph.iloc[:, 1] - 1]),\n", " np.concatenate([graph.iloc[:, 1] - 1, graph.iloc[:, 0] - 1]),\n", " ),\n", " ),\n", " shape=(n_v, n_v),\n", " )\n", " if negate:\n", " G = -G\n", "\n", " return G\n", "\n", "\n", "G = read_gset(\"./G22\")" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:40.797951Z", "iopub.status.busy": "2025-09-04T12:11:40.797357Z", "iopub.status.idle": "2025-09-04T12:11:41.344832Z", "shell.execute_reply": "2025-09-04T12:11:41.343535Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "G22 MAXCut is : 13353.0\n", "use time:0.5273990631103516\n" ] } ], "source": [ "start_time = time.time()\n", "solver = DSB(G, batch_size=100, n_iter=1000, backend=\"npu-float32\")\n", "solver.update()\n", "cut = solver.calc_cut()\n", "end_time = time.time()\n", "\n", "\n", "print(f\"G22 MAXCut is : {max(cut)}\\nuse time:{end_time-start_time}\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 性能对比\n", "\n", "对比BSB算法在CPU和NPU后端上求解最大割问题的性能优势" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:41.348865Z", "iopub.status.busy": "2025-09-04T12:11:41.348364Z", "iopub.status.idle": "2025-09-04T12:11:56.060680Z", "shell.execute_reply": "2025-09-04T12:11:56.057674Z" } }, "outputs": [], "source": [ "import time\n", "\n", "start_time = time.time()\n", "solver = DSB(G, batch_size=100, n_iter=1000, backend=\"cpu-float32\")\n", "solver.update()\n", "cut = solver.calc_cut()\n", "cpu_fp32_time = time.time() - start_time\n", "\n", "start_time = time.time()\n", "solver = DSB(G, batch_size=100, n_iter=1000, backend=\"npu-float32\")\n", "solver.update()\n", "cut = solver.calc_cut()\n", "npu_fp32_time = time.time() - start_time" ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:56.067627Z", "iopub.status.busy": "2025-09-04T12:11:56.066851Z", "iopub.status.idle": "2025-09-04T12:11:56.444379Z", "shell.execute_reply": "2025-09-04T12:11:56.443260Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", "# 计算加速比\n", "cpu_speedup = cpu_fp32_time / cpu_fp32_time\n", "npu_speedup = cpu_fp32_time / npu_fp32_time\n", "\n", "\n", "devices = [\"CPU-Float32\", \"NPU-Float32\"]\n", "times = [cpu_fp32_time, npu_fp32_time]\n", "speedups = [cpu_speedup, npu_speedup]\n", "colors = [\"#4C72B0\", \"#DD8452\"]\n", "\n", "\n", "plt.figure(figsize=(10, 6), dpi=100)\n", "\n", "# 绘制横向条形图, 表示不同后端的计算时间\n", "bars = plt.barh(devices, times, color=colors, height=0.6)\n", "\n", "# 添加数据标签和加速比\n", "for i, (time, speedup) in enumerate(zip(times, speedups)):\n", " plt.text(\n", " time + 0.05,\n", " i,\n", " f\"{time:.2f}s ({speedup:.1f}x)\",\n", " va=\"center\",\n", " fontsize=12,\n", " )\n", "\n", "plt.title(\n", " \"QAIA Performance Comparison On Different Hardware In G22\", fontsize=14, pad=20\n", ")\n", "plt.xlabel(\"Time(seconds)\", fontsize=12)\n", "plt.xlim(0, max(times) * 1.3)\n", "plt.grid(axis=\"x\", linestyle=\"--\", alpha=0.7)\n", "plt.tight_layout()\n", "\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2025-09-04T12:11:56.448006Z", "iopub.status.busy": "2025-09-04T12:11:56.447447Z", "iopub.status.idle": "2025-09-04T12:11:56.468011Z", "shell.execute_reply": "2025-09-04T12:11:56.467012Z" }, "tags": [] }, "outputs": [ { "data": { "text/html": [ "\n", "\n", " \n", " \n", " \n", " \n", "\n", "\n", "\n", "\n", " \n", " \n", "\n", "\n", "
SoftwareVersion
mindquantum0.11.0
scipy1.11.3
numpy1.26.1
SystemInfo
Python3.9.18
OSLinux aarch64
Memory1622.53 GB
CPU Max Thread192
DateThu Sep 4 20:11:56 2025
\n" ], "text/plain": [ "" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from mindquantum.utils.show_info import InfoTable\n", "\n", "InfoTable(\"mindquantum\", \"scipy\", \"numpy\")" ] } ], "metadata": { "kernelspec": { "display_name": "MindSpore", "language": "python", "name": "mindspore" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.9.18" } }, "nbformat": 4, "nbformat_minor": 4 }