Vector Approximation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "1f29d30c",
   "metadata": {},
   "source": [
    "# Vector Approximation\n",
    "\n",
    "In this notebook, I'm going to show how to use `qubo` to approximate a single vector.\n",
    "\n",
    "\n",
    "\\begin{equation}\n",
    "\\arg\\min_b\n",
    "\\Vert X - \n",
    "\\begin{bmatrix}\n",
    "    b_{11} & b_{12} & b_{13} & \\dots  & b_{1n} \\\\\n",
    "    b_{21} & b_{22} & b_{23} & \\dots  & b_{2n} \\\\\n",
    "    \\vdots & \\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "    b_{d1} & b_{d2} & b_{d3} & \\dots  & b_{dn}\n",
    "\\end{bmatrix}\n",
    "\\cdot\n",
    "\\begin{bmatrix}\n",
    "    2^s \\\\\n",
    "    2^{s-1} \\\\\n",
    "    \\vdots \\\\\n",
    "    2^{s-p}\n",
    "\\end{bmatrix}\n",
    "\\Vert\n",
    "\\end{equation}\n",
    "\n",
    "The variables with $b$ prefix variables in above matrix will be $\\{0, 1\\}$. The equation takes matrix norm as a hamiltonian and encoded into `qubo` by using **pyqubo** module. The solver used to solve this equation is **Digital Annealing Unit** provided by Fujitsu Limited."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "855e7d48",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pyqubo import Array, Binary, Model\n",
    "import numpy as np\n",
    "import scipy as sp\n",
    "import requests\n",
    "import json\n",
    "import re\n",
    "import time\n",
    "import yaml\n",
    "from lib.util import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "18891d8e",
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_random_vector(n):\n",
    "    vector = np.random.rand(n)\n",
    "    return vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e993f73",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "fd1a1e79",
   "metadata": {},
   "outputs": [],
   "source": [
    "precision = 21\n",
    "mat = create_binary_variable_matrix('vectorA', (20, precision))\n",
    "binary_code_mat = np.matrix(create_binary_representated_vector(precision, 1)).transpose()\n",
    "\n",
    "approximated_vector = mat * binary_code_mat\n",
    "\n",
    "X = np.matrix(generate_random_vector(20)).transpose()\n",
    "\n",
    "hamiltonian = np.trace(np.inner((X - (mat * binary_code_mat)), (X - (mat * binary_code_mat))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "770991de",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed time:  0.04717206954956055  seconds\n"
     ]
    }
   ],
   "source": [
    "start_time = time.time()\n",
    "\n",
    "model = hamiltonian.compile()\n",
    "qubo, offset = model.to_qubo()\n",
    "matrix_term = get_matrix_term(qubo, model.variables)\n",
    "\n",
    "end_time = time.time()\n",
    "elapsed_time = end_time - start_time\n",
    "print(\"Elapsed time: \", elapsed_time, \" seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "34d05b87",
   "metadata": {},
   "outputs": [],
   "source": [
    "problem_body = {}\n",
    "DA_Solver = {}\n",
    "DA_Solver[\"time_limit_sec\"]= 100\n",
    "DA_Solver[\"penalty_coef\"]=10000\n",
    "DA_Solver[\"num_run\"] = 16\n",
    "DA_Solver[\"num_group\"] = 16\n",
    "DA_Solver['gs_level'] = 50\n",
    "DA_Solver['gs_cutoff'] = 80000\n",
    "problem_body[\"fujitsuDA3\"]=DA_Solver\n",
    "problem_body[\"binary_polynomial\"] = {'terms' : matrix_term}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "99ebc5ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'message': 'success'}\n"
     ]
    }
   ],
   "source": [
    "response = post_solve(problem_body)\n",
    "job_id = response.json()['job_id']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "dab7f432",
   "metadata": {},
   "outputs": [],
   "source": [
    "solution = get_solution(job_id)\n",
    "configuration = solution['qubo_solution']['solutions'][0]['configuration']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "060ffb9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "binary_matrix = np.zeros((20, precision))\n",
    "for key, value in configuration.items():\n",
    "    vector_element = model.variables[int(key)]\n",
    "    \n",
    "    # exctract indices\n",
    "    \n",
    "    indices = re.findall(r'\\[(\\d+)\\]', vector_element)\n",
    "    indices = [int(_) for _ in indices]\n",
    "    if value == True:\n",
    "        val = 1\n",
    "    else:\n",
    "        val = 0\n",
    "    binary_matrix[indices[0]][indices[1]] = val\n",
    "binary_matrix = np.matrix(binary_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "1ea779dd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.287746517787633e-12"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(np.inner((X - binary_matrix * binary_code_mat), (X - binary_matrix * binary_code_mat)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c04a6fad",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}