docs/source/tutorials/sklearn_svc_cn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 结合SKLearn实现的支持向量分类\n",
    "\n",
    "[_Mark (Zixuan) Song_](https://marksong.tech) 撰写\n",
    "- - -\n",
    "\n",
    "本示例结合了`sklearn`库中的`SVC`类，实现了支持向量分类。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 概述\n",
    "\n",
    "本示例的目的是将量子机器学习（QML）转换器嵌入到SVC管道中并且介绍`tensorcircuit`与`scikit-learn`的一种连接方式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设置\n",
    "\n",
    "安装 `scikit-learn` 和 `requests`. 本模型测试数据为 [德国信用]The data that is going to be used is [German Credit Data by UCI](http://home.cse.ust.hk/~qyang/221/Assignments/German/GermanData.csv)\n",
    "\n",
    "```bash\n",
    "pip install scikit-learn requests\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorcircuit as tc\n",
    "import tensorflow as tf\n",
    "from sklearn.svm import SVC\n",
    "from sklearn import metrics\n",
    "from time import time\n",
    "import requests\n",
    "\n",
    "K = tc.set_backend(\"tensorflow\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数据处理\n",
    "\n",
    "数据集包含20个变量，每个变量都是整数值。为了使模型能够使用数据，我们需要将数据归一化为0到1之间。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_GCN_data():\n",
    "    link2gcn = \"http://home.cse.ust.hk/~qyang/221/Assignments/German/GermanData.csv\"\n",
    "    data = requests.get(link2gcn)\n",
    "    data = data.text\n",
    "    data = data.split(\"\\n\")[:-1]\n",
    "    x = None\n",
    "    y = None\n",
    "    def destring(string):\n",
    "        string = string.split(\",\")\n",
    "        return_array = []\n",
    "        for i, v in enumerate(string):\n",
    "            if v[0] == 'A':\n",
    "                return_array.append(int(v[1+len(str(i)):]))\n",
    "            else:\n",
    "                return_array.append(int(v))\n",
    "        return K.cast([return_array[:-1]], dtype=\"float32\"), K.cast([return_array[-1]-1], dtype=\"int32\")\n",
    "    for i in data:\n",
    "        if x is None:\n",
    "            temp_x, temp_y = destring(i)\n",
    "            x = K.cast(temp_x, dtype=\"float32\")\n",
    "            y = K.cast(temp_y, dtype=\"int32\")\n",
    "        else:\n",
    "            temp_x, temp_y = destring(i)\n",
    "            x = K.concat([x, temp_x], axis=0)\n",
    "            y = K.concat([y, temp_y], axis=0)\n",
    "    x = K.transpose(x)\n",
    "    nx = None\n",
    "    for i in x:\n",
    "        max_i = K.cast(K.max(i),dtype=\"float32\")\n",
    "        temp_nx = [K.divide(i, max_i)]\n",
    "        nx = K.concat([nx, temp_nx], axis=0) if nx is not None else temp_nx\n",
    "    x = K.transpose(nx)\n",
    "    return (x[:800],y[:800]),(x[800:],y[800:])\n",
    "    \n",
    "(x_train, y_train), (x_test, y_test) = load_GCN_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 量子模型\n",
    "\n",
    "这个量子模型是输入为1x20的矩阵，并输出为5个量子比特的状态。模型如下所示："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quantumTran(inputs):\n",
    "    c = tc.Circuit(5)\n",
    "    for i in range(4):\n",
    "        if i%2 == 0:\n",
    "            for j in range(5):\n",
    "                c.rx(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n",
    "        else:\n",
    "            for j in range(5):\n",
    "                c.rz(j, theta=(0 if i*5+j >= 20 else inputs[i*5+j]))\n",
    "            for j in range(4):\n",
    "                c.cnot(j, j+1)\n",
    "    return c.state()\n",
    "\n",
    "func_qt =  tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 将量子模型打包成SVC\n",
    "\n",
    "将量子模型打包成`SKLearn`能使用的SVC模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quantum_kernel(quantumTran, data_x, data_y):\n",
    "    def kernel(x,y):\n",
    "        x = K.convert_to_tensor(x)\n",
    "        y = K.convert_to_tensor(y)\n",
    "        x_qt = None\n",
    "        for i, x1 in enumerate(x):\n",
    "            if i == 0:\n",
    "                x_qt = K.convert_to_tensor([quantumTran(x1)])\n",
    "            else:\n",
    "                x_qt = K.concat([x_qt,[quantumTran(x1)]],0)\n",
    "        y_qt = None\n",
    "        for i, x1 in enumerate(y):\n",
    "            if i == 0:\n",
    "                y_qt = K.convert_to_tensor([quantumTran(x1)])\n",
    "            else:\n",
    "                y_qt = K.concat([y_qt,[quantumTran(x1)]],0)\n",
    "        data_ret = K.cast(K.power(K.abs(x_qt @ K.transpose(y_qt)), 2), \"float32\")\n",
    "        return data_ret\n",
    "    clf = SVC(kernel=kernel)\n",
    "    clf.fit(data_x, data_y)\n",
    "    return clf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 创建传统SVC模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def standard_kernel(data_x, data_y, method):\n",
    "    methods = ['linear', 'poly', 'rbf', 'sigmoid']\n",
    "    if method not in methods:\n",
    "        raise ValueError(\"method must be one of %r.\" % methods)\n",
    "    clf = SVC(kernel=method)\n",
    "    clf.fit(data_x, data_y)\n",
    "    return clf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 测试对比\n",
    "\n",
    "测试量子SVC模型并于传统SVC模型进行对比。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy:(linear as kernel) 0.78\n",
      "time: 0.00810384750366211 seconds\n",
      "\n",
      "Accuracy:(poly as kernel) 0.75\n",
      "time: 0.024804115295410156 seconds\n",
      "\n",
      "Accuracy:(rbf as kernel) 0.765\n",
      "time: 0.011444091796875 seconds\n",
      "\n",
      "Accuracy:(sigmoid as kernel) 0.695\n",
      "time: 0.010396003723144531 seconds\n",
      "\n",
      "Accuracy:(qml as kernel) 0.66\n",
      "time: 6.472219228744507 seconds\n"
     ]
    }
   ],
   "source": [
    "methods = ['linear', 'poly', 'rbf', 'sigmoid']\n",
    "\n",
    "for method in methods:\n",
    "    \n",
    "    print()\n",
    "    t = time()\n",
    "\n",
    "    k = standard_kernel(data_x=x_train, data_y=y_train, method=method)\n",
    "    y_pred = k.predict(x_test)\n",
    "    print(\"Accuracy:(%s as kernel)\" % method,metrics.accuracy_score(y_test, y_pred))\n",
    "\n",
    "    print(\"time:\",time()-t,'seconds')\n",
    "\n",
    "print()\n",
    "t = time()\n",
    "\n",
    "k = quantum_kernel(quantumTran=func_qt, data_x=x_train, data_y=y_train)\n",
    "y_pred = k.predict(x_test)\n",
    "print(\"Accuracy:(qml as kernel)\",metrics.accuracy_score(y_test, y_pred))\n",
    "\n",
    "print(\"time:\",time()-t,'seconds')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `SKLearn`的局限性\n",
    "\n",
    "因为`SKLearn`的局限性，`SKLearn`的`SVC`并不完全兼容量子机器学习（QML）。\n",
    "\n",
    "这是因为QML输出的为复数（布洛赫球上的坐标），而`SKLearn`只接受浮点数。这导致QML输出的结果必须在使用SVC之前转换为浮点数，从而可能导致精度损失。\n",
    "\n",
    "## 结论\n",
    "\n",
    "由于`SKLearn`的局限性，量子SVC在准确性和速度上都不如传统SVC。但是，如果这种局限性被消除，量子SVC可能会在准确性上都优于传统SVC。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "tc2",
   "language": "python",
   "name": "python3"
  },
  "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.10.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}