{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# 6-Machine Learning (QBoost) with Quantum Annealing" ] }, { "cell_type": "markdown", "metadata": { "colab_type": "text", "id": "view-in-github" }, "source": [ "[![Open in Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/OpenJij/OpenJijTutorial/blob/master/source/en/006-Machine_Learning_by_QA.ipynb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this section, we describe machine lerning (ML) as an example of an application of quantum annealing (QA) optimization.\n", "\n", "In the first, we show clustering using PyQUBO and OpenJij. \n", "In the seconde, we execute an ensamble study called QBoost with PyQUBO and D-Wave sampler." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Clustering\n", "\n", "Clustering is the task of deviding given set of data into $n$ clusters ($n$ is our input). For the sake of simplicity, let us consider the number of cluster is 2 in this time.\n", "\n", "### Importing the required libraries\n", "\n", "We import scikit-learn library for ML." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# import libraries\n", "import numpy as np\n", "from matplotlib import pyplot as plt\n", "from sklearn import cluster\n", "import pandas as pd\n", "from scipy.spatial import distance_matrix \n", "from pyqubo import Array, Constraint, Placeholder, solve_qubo\n", "import openjij as oj\n", "from sklearn.model_selection import train_test_split" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Make artificial data\n", "\n", "In this case, let us generate linearly separable data in a two-dimensional plane artificially." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "data = []\n", "label = []\n", "for i in range(100):\n", " # generate 0 to 1 random number\n", " p = np.random.uniform(0, 1)\n", " # set class 1 when certain condition are met, and -1 when it are not met\n", " cls =1 if p>0.5 else -1\n", " # create random numbers following a normal distribution\n", " data.append(np.random.normal(0, 0.5, 2) + np.array([cls, cls]))\n", " label.append(cls)\n", "# formatted as a DataFrame\n", "df1 = pd.DataFrame(data, columns=[\"x\", \"y\"], index=range(len(data)))\n", "df1[\"label\"] = label" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# visualize dataset\n", "df1.plot(kind='scatter', x=\"x\", y=\"y\")\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We demonstrate clustering by minimizing the following Hamiltonians.\n", "\n", "$$\n", "H = - \\sum_{i, j} \\frac{1}{2}d_{i,j} (1 - \\sigma _i \\sigma_j)\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Where $i, j$ is sample No., $d_{i, j}$ is a distance between $i$ and $j$, $\\sigma_i=\\{-1,1\\}$ is spin variable that indicates whether $i$ belong to one of the two clusters.\n", "\n", "Each term of this Hamiltonian sum behaves as follows.\n", "\n", "- 0 for $\\sigma_i = \\sigma_j $\n", "- $d_{i,j}$ for $\\sigma_i \\neq \\sigma_j $ \n", "\n", "Note that minus of R.H.S., Hamiltonian means the problem is \"Choosing pairs of $\\{\\sigma _1, \\sigma _2 \\ldots \\}$ that maximizes the distance between the samples of different classes\"." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Clustering with PyQUBO\n", "\n", "At first, we formulate the Hamiltonian in PyQUBO. Second, we execute simulated annealing (SA) with `solve_qubo`." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "def clustering_pyqubo(df):\n", " # set distance matrix\n", " d_ij = distance_matrix(df, df)\n", " # set spin variables\n", " spin = Array.create(\"spin\", shape= len(df), vartype=\"SPIN\")\n", " # set the total Hamiltonian\n", " H = - 0.5* sum(\n", " [d_ij[i,j]* (1 - spin[i]* spin[j]) for i in range(len(df)) for j in range(len(df))]\n", " )\n", " # compile\n", " model = H.compile()\n", " # convert to QUBO\n", " qubo, offset = model.to_qubo()\n", " # solve with SA\n", " raw_solution = solve_qubo(qubo, num_reads=10)\n", " # decode for easier analysis\n", " decoded_samples = model.decode_sample(raw_solution, vartype=\"SPIN\")\n", " # extract label\n", " labels = [decoded_samples.array(\"spin\", idx) for idx in range(len(df))]\n", " return labels" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We execute and check a solution." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "label [1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0]\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ ":15: DeprecationWarning: Call to deprecated function (or staticmethod) solve_qubo. (You should use simulated annealing sampler of dwave-neal directly.) -- Deprecated since version 0.4.0.\n", " raw_solution = solve_qubo(qubo, num_reads=10)\n" ] } ], "source": [ "labels =clustering_pyqubo(df1[[\"x\", \"y\"]])\n", "print(\"label\", labels)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us visualize the result." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "for idx, label in enumerate(labels):\n", " if label:\n", " plt.scatter(df1.loc[idx][\"x\"], df1.loc[idx][\"y\"], color=\"b\") \n", " else:\n", " plt.scatter(df1.loc[idx][\"x\"], df1.loc[idx][\"y\"], color=\"r\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Clustering with OpenJij solver\n", "\n", "Next, we introduce clustering with OpenJij solver and use PyQUBO to formulate QUBO." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "def clustering_openjij(df):\n", " # set distance matrix\n", " d_ij = distance_matrix(df, df)\n", " # set spin variables\n", " spin = Array.create(\"spin\", shape= len(df), vartype=\"SPIN\")\n", " # set total Hamiltonian\n", " H = - 0.5* sum(\n", " [d_ij[i,j]* (1 - spin[i]* spin[j]) for i in range(len(df)) for j in range(len(df))]\n", " )\n", " # compile\n", " model = H.compile()\n", " # convert to QUBO\n", " qubo, offset = model.to_qubo()\n", " # set OpenJij SA sampler\n", " sampler = oj.SASampler(num_reads=10, num_sweeps=100)\n", " # solve with above sampler\n", " response = sampler.sample_qubo(qubo)\n", " # extract raw data\n", " raw_solution = dict(zip(response.indices, response.states[np.argmin(response.energies)]))\n", " # decode for easier analysis\n", " decoded_samples= model.decode_sample(raw_solution, vartype=\"SPIN\")\n", " # extract labels\n", " labels = [int(decoded_samples.array(\"spin\", idx) ) for idx in range(len(df))]\n", " return labels, sum(response.energies)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We execute and check a solution." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "label [1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0]\n", "energy -139358.74510750096\n" ] } ], "source": [ "labels, energy =clustering_openjij(df1[[\"x\", \"y\"]])\n", "print(\"label\", labels)\n", "print(\"energy\", energy)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And also we visualize the result." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "for idx, label in enumerate(labels):\n", " if label:\n", " plt.scatter(df1.loc[idx][\"x\"], df1.loc[idx][\"y\"], color=\"b\") \n", " else:\n", " plt.scatter(df1.loc[idx][\"x\"], df1.loc[idx][\"y\"], color=\"r\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can get a same figure as using PyQUBO SA." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## QBoost\n", "\n", "QBoost is a one of the ensamble learning using QA. Ensamble learning involves preparing a number of weak predictors and combining the results of each of these predictors to obtain the final prediction result.\n", "\n", "QBoost uses QA to optimize the best combination of learners for a given training data. We handle classification problem in this time.\n", "\n", "We define that the set of $D$ training data are $\\{\\vec x^{(d)}\\}(d=1, ..., D)$, corresponding label are $\\{y^{(d)}\\}(d=1, ..., D), y^{(d)}\\in \\{-1, 1\\}$ and the (function) set of $N$ weak learner is $\\{C_i\\}(i=1, ..., N)$. For some data $\\vec x^{(d)}$, $C_i(\\vec x^{(d)})\\in \\{-1, 1\\}$. \n", "\n", "Based on the definitions above, the classification labels are as follows.\n", "\n", "$${\\rm sgn}\\left( \\sum_{i=1}^{N} w_i C_i({\\vec x}^{(d)})\\right)$$\n", "\n", "Where $w_i\\in\\{0, 1\\} (i=1, ..., N)$, is a weight of each predictor (bool value to adopt or not adopt the predictor for the final prediction).QBoost optimizes the combination of $w_i$ so that prediction matches the training data while erasing the number of weak learners.\n", "\n", "Hamiltonian in this problem is as follows.\n", "\n", "$$H(\\vec w) = \\sum_{d=1}^{D} \\left( \\frac{1}{N}\\sum_{i=1}^{N} w_i C_i(\\vec x^{(d)})-y^{(d)} \\right)^2 + \\lambda \\sum _i^N w_i$$\n", "\n", "The first term represents the difference between weak classifier and the correct label. The second term represents a degree of the number of weak classifier to be employed in the final classifier. $\\lambda$ is the regularization parameter that adjust how much the number of weak classifiers affects the total Hamiltonian.\n", "\n", "We optimize this Hamiltonian by recognizing the first term as a cost (objective function) and the second term as a constraint.Minimizing with QA allows us to obtain a combination of weak classifiers that best fits the training data." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Scripts\n", "\n", "Let us try QBoost. We use the cancer identification dataset from scikit-learn for training data. For simplicity, we will only use two character types for training: \"0\" and \"1\"." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# import libraries\n", "import pandas as pd \n", "from scipy import stats \n", "from sklearn import datasets\n", "from sklearn import metrics" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# load data\n", "cancerdata = datasets.load_breast_cancer()\n", "# set the number of training data & test data\n", "num_train = 450" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "In this time, we consider that feature of noise exists." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(569, 60)\n" ] } ], "source": [ "data_noisy = np.concatenate((cancerdata.data, np.random.rand(cancerdata.data.shape[0], 30)), axis=1)\n", "print(data_noisy.shape)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# convert from label {0, 1} to {-1, 1}\n", "labels = (cancerdata.target-0.5) * 2" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# divide dataset to training and test\n", "X_train = data_noisy[:num_train, :]\n", "X_test = data_noisy[num_train:, :]\n", "y_train = labels[:num_train]\n", "y_test = labels[num_train:]" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "# from the result of weak learnor\n", "def aggre_mean(Y_list):\n", " return ((np.mean(Y_list, axis=0)>0)-0.5) * 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Set of Weak Learner\n", "\n", "We make weak learner with scikit-learn. In this time, we choose decision stump. Desision stump is a single-layer decision tree. As it will be used as a weak classifier, the features to be used for segmentation are selected randomly (it's a good understanding that we execute single-layer of random forest)." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "# import required libraries\n", "from sklearn.tree import DecisionTreeClassifier as DTC\n", "\n", "# set the number of weak classifier\n", "num_clf = 32\n", "# set the number of ensembles to be taken out for one sample in bootstrap sampling\n", "sample_train = 40\n", "# set model\n", "models = [DTC(splitter=\"random\",max_depth=1) for i in range(num_clf)]\n", "for model in models:\n", " # extract randomly\n", " train_idx = np.random.choice(np.arange(X_train.shape[0]), sample_train)\n", " # make decision tree with variables\n", " model.fit(X=X_train[train_idx], y=y_train[train_idx])\n", "y_pred_list_train = []\n", "for model in models:\n", " # execute prediction with model\n", " y_pred_list_train.append(model.predict(X_train))\n", "y_pred_list_train = np.asanyarray(y_pred_list_train)\n", "y_pred_train =np.sign(y_pred_list_train)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We look accuracy of all weak learner as the final classifier. Henceforth, we refer to this combination as baseline." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.9663865546218487\n" ] } ], "source": [ "y_pred_list_test = []\n", "for model in models:\n", " # execute with test data\n", " y_pred_list_test.append(model.predict(X_test))\n", " \n", "y_pred_list_test = np.array(y_pred_list_test)\n", "y_pred_test = np.sign(np.sum(y_pred_list_test,axis=0))\n", "# compute score of prediction accuracy\n", "acc_test_base = metrics.accuracy_score(y_true=y_test, y_pred=y_pred_test)\n", "print(acc_test_base)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# set class of QBoost\n", "class QBoost():\n", " def __init__(self, y_train, ys_pred):\n", " self.num_clf = ys_pred.shape[0]\n", " # set binary variables\n", " self.Ws = Array.create(\"weight\", shape = self.num_clf, vartype=\"BINARY\")\n", " # set hyperparameter with PyQUBO Placeholder\n", " self.param_lamda = Placeholder(\"norm\")\n", " # set combination of weak classifier Hamiltonian\n", " self.H_clf = sum( [ (1/self.num_clf * sum([W*C for W, C in zip(self.Ws, y_clf)])- y_true)**2 for y_true, y_clf in zip(y_train, ys_pred.T)\n", " ])\n", " # set normalization term as a constraint\n", " self.H_norm = Constraint(sum([W for W in self.Ws]), \"norm\")\n", " # set total Hamiltonian\n", " self.H = self.H_clf + self.H_norm * self.param_lamda\n", " # compile\n", " self.model = self.H.compile()\n", " # set function for converting to QUBO\n", " def to_qubo(self, norm_param=1):\n", " # set value of hyperparameter\n", " self.feed_dict = {'norm': norm_param}\n", " return self.model.to_qubo(feed_dict=self.feed_dict)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [], "source": [ "qboost = QBoost(y_train=y_train, ys_pred=y_pred_list_train)\n", "# make QUBO with lambda=3\n", "qubo = qboost.to_qubo(3)[0]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Execute QBoost with D-Wave Sampler" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "# import required libraries\n", "from dwave.system.samplers import DWaveSampler\n", "from dwave.system.composites import EmbeddingComposite" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "ename": "SolverAuthenticationError", "evalue": "Token not accepted for that action.", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mSolverAuthenticationError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m dw = DWaveSampler(endpoint='https://cloud.dwavesys.com/sapi/', \n\u001b[1;32m 2\u001b[0m \u001b[0mtoken\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'xxxx'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m solver='DW_2000Q_VFYC_6')\n\u001b[0m\u001b[1;32m 4\u001b[0m \u001b[0msampler\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mEmbeddingComposite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdw\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.local/share/virtualenvs/OpenJijTutorial-bCQ9CWHW/lib/python3.7/site-packages/dwave/system/samplers/dwave_sampler.py\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, failover, retry_interval, **config)\u001b[0m\n\u001b[1;32m 163\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 164\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclient\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mClient\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfrom_config\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mconfig\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 165\u001b[0;31m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msolver\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mclient\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_solver\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 166\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 167\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfailover\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfailover\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.local/share/virtualenvs/OpenJijTutorial-bCQ9CWHW/lib/python3.7/site-packages/dwave/cloud/client.py\u001b[0m in \u001b[0;36mget_solver\u001b[0;34m(self, name, refresh, **filters)\u001b[0m\n\u001b[1;32m 1077\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1078\u001b[0m \u001b[0mlogger\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdebug\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Fetching solvers according to filters=%r\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfilters\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 1079\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_solvers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrefresh\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mrefresh\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mfilters\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 1080\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mIndexError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 1081\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0mSolverNotFoundError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Solver with the requested features not available\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.local/share/virtualenvs/OpenJijTutorial-bCQ9CWHW/lib/python3.7/site-packages/dwave/cloud/client.py\u001b[0m in \u001b[0;36mget_solvers\u001b[0;34m(self, refresh, order_by, **filters)\u001b[0m\n\u001b[1;32m 990\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 991\u001b[0m \u001b[0;31m# filter\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 992\u001b[0;31m \u001b[0msolvers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_fetch_solvers\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0mquery\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 993\u001b[0m \u001b[0msolvers\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0ms\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0ms\u001b[0m \u001b[0;32min\u001b[0m \u001b[0msolvers\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mall\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mp\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mp\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mpredicates\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 994\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.local/share/virtualenvs/OpenJijTutorial-bCQ9CWHW/lib/python3.7/site-packages/dwave/cloud/utils.py\u001b[0m in \u001b[0;36mwrapper\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 404\u001b[0m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'val'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 405\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 406\u001b[0;31m \u001b[0mval\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mfn\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 407\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcache\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mdict\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mexpires\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mnow\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmaxage\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mval\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mval\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 408\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;32m~/.local/share/virtualenvs/OpenJijTutorial-bCQ9CWHW/lib/python3.7/site-packages/dwave/cloud/client.py\u001b[0m in \u001b[0;36m_fetch_solvers\u001b[0;34m(self, name)\u001b[0m\n\u001b[1;32m 622\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 623\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus_code\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m401\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 624\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0mSolverAuthenticationError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 625\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 626\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mname\u001b[0m \u001b[0;32mis\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0mresponse\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstatus_code\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m404\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mSolverAuthenticationError\u001b[0m: Token not accepted for that action." ] } ], "source": [ "# set DwaveSampler with token yourself\n", "dw = DWaveSampler(endpoint='https://cloud.dwavesys.com/sapi/', \n", " token='xxxx', \n", " solver='DW_2000Q_VFYC_6')\n", "# embed on chimeragraph\n", "sampler = EmbeddingComposite(dw)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'sampler' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# D-Waveサンプラーで計算\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0msampleset\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msampler\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msample_qubo\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mqubo\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnum_reads\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'sampler' is not defined" ] } ], "source": [ "# compute DWaveSampler\n", "sampleset = sampler.sample_qubo(qubo, num_reads=100)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'sampleset' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# 結果の確認\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msampleset\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'sampleset' is not defined" ] } ], "source": [ "# check the result\n", "print(sampleset)" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'sampleset' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0menergies\u001b[0m \u001b[0;34m=\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mdecoded_sol\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mqboost\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdecode_dimod_response\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msampleset\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfeed_dict\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mqboost\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mfeed_dict\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0md_sol\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mbroken\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0menergy\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdecoded_sol\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mdecoded_solutions\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0md_sol\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", "\u001b[0;31mNameError\u001b[0m: name 'sampleset' is not defined" ] } ], "source": [ "# decode each computation result with PyQUBO\n", "decoded_solutions = []\n", "brokens = []\n", "energies =[]\n", "\n", "decoded_sol = qboost.model.decode_dimod_response(sampleset, feed_dict=qboost.feed_dict)\n", "for d_sol, broken, energy in decoded_sol:\n", " decoded_solutions.append(d_sol)\n", " brokens.append(broken)\n", " energies.append(energy)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let us check the accuracy in the training/validation data when using a combination of weak classifiers obtained by D-Wave." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "accs_train_Dwaves = []\n", "accs_test_Dwaves = []\n", "for decoded_solution in decoded_solutions:\n", " idx_clf_DWave=[]\n", " for key, val in decoded_solution[\"weight\"].items():\n", " if val == 1:\n", " idx_clf_DWave.append(int(key))\n", " y_pred_train_DWave = np.sign(np.sum(y_pred_list_train[idx_clf_DWave, :], axis=0))\n", " y_pred_test_DWave = np.sign(np.sum(y_pred_list_test[idx_clf_DWave, :], axis=0))\n", " acc_train_DWave = metrics.accuracy_score(y_true=y_train, y_pred=y_pred_train_DWave)\n", " acc_test_DWave= metrics.accuracy_score(y_true=y_test, y_pred=y_pred_test_DWave)\n", " accs_train_Dwaves.append(acc_train_DWave)\n", " accs_test_Dwaves.append(acc_test_DWave)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We make a graph with energy on the horizontal axis and accuracy on the vertical axis." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "image/svg+xml": [ "\r\n", "\r\n", "\r\n", "\r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", " \r\n", "\r\n" ], "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.figure(figsize=(12, 8))\n", "plt.scatter(energies, accs_train_Dwaves, label=\"train\" )\n", "plt.scatter(energies, accs_test_Dwaves, label=\"test\")\n", "plt.xlabel(\"energy: D-wave\")\n", "plt.ylabel(\"accuracy\")\n", "plt.title(\"relationship between energy and accuracy\")\n", "plt.grid()\n", "plt.legend()\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "base accuracy is 0.9411764705882353\n", "max accuracy of QBoost is 0.957983193277311\n", "average accuracy of QBoost is 0.9398183515830576\n" ] } ], "source": [ "print(\"base accuracy is {}\".format(acc_test_base))\n", "print(\"max accuracy of QBoost is {}\".format(max(accs_test_Dwaves)))\n", "print(\"average accuracy of QBoost is {}\".format(np.mean(np.asarray(accs_test_Dwaves))))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "D-Wave samplig can perform hundreds or more sampling in a short period. It is possible to create a more accurate classifier than a baseling if you use the results that maximiza accuracy." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.9.3" } }, "nbformat": 4, "nbformat_minor": 2 }