docs/source/tutorials/sklearn_svc.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Support Vector Classification with SKLearn\n",
    "\n",
    "Authored by [_Mark (Zixuan) Song_](https://marksong.tech)\n",
    "- - -\n",
    "\n",
    "We use the `SKLearn` library to implement `SVC` in the following tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Overview\n",
    "\n",
    "The aim of this tutorial is to implant a quantum machine learning (QML) transformer into SVC pipeline. And this is a general introduction to connect `tensorcircuit` with `scikit-learn`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup\n",
    "\n",
    "Install `scikit-learn` and `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": 7,
   "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": [
    "## Data Preprocessing\n",
    "\n",
    "The data has 20 variables and each is a integer value. In order for the model to use the data, we need to normalize the data to between 0 and 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "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",
    "\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(\n",
    "            [return_array[-1] - 1], dtype=\"int32\"\n",
    "        )\n",
    "\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",
    "\n",
    "(x_train, y_train), (x_test, y_test) = load_GCN_data()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Quantum Model\n",
    "\n",
    "This quantum model takes in 1x20 matrices as input and output the state of 5 qbits. The model is shown below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "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",
    "\n",
    "func_qt = tc.interfaces.tensorflow_interface(quantumTran, ydtype=tf.complex64, jit=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Wrapping Quantum Model into a SVC\n",
    "\n",
    "Convert quantum model into svc that can be trained."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "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",
    "\n",
    "    clf = SVC(kernel=kernel)\n",
    "    clf.fit(data_x, data_y)\n",
    "    return clf"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Traditional SVC"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "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": [
    "## Test\n",
    "\n",
    "Test the accuracy of the quantum model SVC with the test data and compare it with traditional SVC."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Accuracy:(linear as kernel) 0.78\n",
      "time: 0.007764101028442383 seconds\n",
      "\n",
      "Accuracy:(poly as kernel) 0.75\n",
      "time: 0.024492979049682617 seconds\n",
      "\n",
      "Accuracy:(rbf as kernel) 0.765\n",
      "time: 0.011505126953125 seconds\n",
      "\n",
      "Accuracy:(sigmoid as kernel) 0.695\n",
      "time: 0.010205984115600586 seconds\n",
      "\n",
      "Accuracy:(qml as kernel) 0.66\n",
      "time: 3.0243749618530273 seconds\n"
     ]
    }
   ],
   "source": [
    "methods = [\"linear\", \"poly\", \"rbf\", \"sigmoid\"]\n",
    "\n",
    "for method in methods:\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": [
    "## Issue with `SKLearn`\n",
    "\n",
    "Due to the limitation of `SKLearn`, `SKLearn`'s `SVC` is not fully compatible with quantum machine model (QML). \n",
    "\n",
    "This is because QML outputs a result as complex number (coordinate on the bloch sphere) whereas SKLearn only accept float. This is causing the result output by QML must be converted into float before it can be used in SVC, leading to a potential loss of accuracy.\n",
    "\n",
    "## Conclusion\n",
    "\n",
    "Due to the present limitation of SKLearn, quantum SVC is worse than traditional SVC in both accuracy and speed. However, if the limitation is removed, quantum SVC might be able to outperform traditional SVC in both accuracy."
   ]
  }
 ],
 "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
}