5qubits_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# QML for VBS - v2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Imports"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "t_start = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit import *\n",
    "from qiskit import IBMQ, Aer\n",
    "\n",
    "from qiskit.circuit import ParameterVector\n",
    "from qiskit.visualization.bloch import Bloch\n",
    "from qiskit.aqua.components.optimizers import SPSA\n",
    "#from qiskit.algorithms.optimizers import SPSA\n",
    "from qiskit.tools.monitor import job_monitor\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "import numpy as np\n",
    "import math\n",
    "import pickle\n",
    "import random \n",
    "from random import randrange\n",
    "from sklearn.utils import shuffle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'qiskit-terra': '0.17.4', 'qiskit-aer': '0.8.2', 'qiskit-ignis': '0.6.0', 'qiskit-ibmq-provider': '0.13.1', 'qiskit-aqua': '0.9.1', 'qiskit': '0.26.2', 'qiskit-nature': None, 'qiskit-finance': None, 'qiskit-optimization': None, 'qiskit-machine-learning': None}"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "qiskit.__qiskit_version__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Script parameters\n",
    "* quantum_hw: set to '0' to use simulator or to '1' to use a real quantum computer;\n",
    "* bknd: quantum computer used;\n",
    "* Shots: number of attempts for each measuration to get a statistical result;\n",
    "* max_circuits_supported: maximum number of circuits supported on Quantum Experience (use an number multiple of number_classes);\n",
    "* layout: configuration of the qubits chosen from the quantum computer. It links each qubit of the algorithm to the corresponding qubits of the real hardware;\n",
    "* number_training: number of events of each type used during the training phase;\n",
    "* number_testing: number of events of each type used during the testing phase;\n",
    "* SPSA_steps: number of steps for SPSA algorithm;\n",
    "* number_var: total number of variables used to classify each event;\n",
    "* number_classes: number of classes for which classification is performed;\n",
    "* ii,jj,kk,ll,mm : numbers associated to the variables used for the classification of each event (their order is relevant);\n",
    "* nn: index associated to the weights column;\n",
    "* c_e_ii,c_e_jj,c_e_kk,c_e_ll,c_e_mm: crossentropy functions associated to the variables distributions;\n",
    "* L1: Number of repetitions of the Mapping Circuit;\n",
    "* L2: Number of repetitions of the Variational part of the Quantum Circuit;\n",
    "* print_loss_func: 1-> prints the loss function evaluations, 0-> doesn't;\n",
    "* plot_AUC_image: 1-> prints the AUC graph, 0-> doesn't;\n",
    "* plot_data: 1-> prints the data images, 0-> doesn't;\n",
    "* sound: 1-> acustic signal at the end of the execution, 0 -> no signal;\n",
    "* save_results: 1 -> save result on an externjal file, 0 -> doesn't;\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "quantum_hw = 0\n",
    "bknd = 'ibmq_manila'\n",
    "Shots = 8192                        \n",
    "max_circuits_supported = 7400        \n",
    "layout = [0,1,2,3,4]\n",
    "\n",
    "number_training = 100             \n",
    "number_testing = 1000\n",
    "SPSA_steps = 50          \n",
    "number_var = 5                      \n",
    "number_classes = 2                  \n",
    "ratio = 1\n",
    "\n",
    "ii = 35 \n",
    "jj = 40\n",
    "kk = 45\n",
    "ll = 18\n",
    "mm = 54\n",
    "nn = 59 #weight_norm column index\n",
    "\n",
    "c_e_ii = 8.703944283\n",
    "c_e_jj = 8.312086411\n",
    "c_e_kk = 8.270524837\n",
    "c_e_ll = 8.157018642\n",
    "c_e_mm = 7.354027826\n",
    "\n",
    "ri=2\n",
    "rj=2\n",
    "rk=2\n",
    "rl=0\n",
    "rm=2\n",
    "\n",
    "L1 = 1                 \n",
    "L2 = 2                 \n",
    "\n",
    "\n",
    "print_loss_func = 1     \n",
    "plot_AUC_image = 1      \n",
    "plot_data = 1 \n",
    "sound = 0\n",
    "save_results = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Auxiliary functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definitions of useful functions\n",
    "The following are useful to reshape the variables distributions before the mapping phase"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Cheb(x):\n",
    "    return np.cos((x+1)*np.pi/2)\n",
    "\n",
    "def InvCheb(x):\n",
    "    return 2*np.arccos((x+1)/2)/np.pi-1\n",
    "\n",
    "def Sqrt(x):\n",
    "    x = np.clip(x,-1,1)\n",
    "    return np.sqrt((x+1)/2)*2 -1\n",
    "\n",
    "def InvSqrt(x):\n",
    "    return ((x+1)**2 -1)/2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Labelling function\n",
    "It labels the input events into the classes (implemented only for 2 classes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f_label(i):\n",
    "    if i%2==0:\n",
    "        result = [1,0]\n",
    "    else:\n",
    "        result = [0,1]\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Normalization function (softmax function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "def softmax_function(x):\n",
    "    F = [math.exp(x[0]),math.exp(x[1]),math.exp(x[2]),math.exp(x[3])]\n",
    "    for i in range(0,2):\n",
    "        F[i] = F[i]/sum([math.exp(x[0]),math.exp(x[1])])\n",
    "    for i in range(2,4):\n",
    "        F[i] = F[i]/sum([math.exp(x[2]),math.exp(x[3])])\n",
    "    return F"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Measuration  function\n",
    "The following determines how measuration values obtained from the quantum circuit are treated in order to obtain a single result for each event"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f_measuration(count):\n",
    "    Z_m = np.zeros(4)\n",
    "    for i in range(0,2**(number_bits)):\n",
    "        for k in range(0,4):\n",
    "            if eig[i][1-k] == '0' and eig[i] in count:\n",
    "                Z_m[k] += count[eig[i]]  \n",
    "\n",
    "    Z_m = (2*np.array(Z_m)-Shots)/Shots\n",
    "    y = softmax_function(Z_m)\n",
    "    return y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Mapping function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Phi_function(x,y,z,a,b):\n",
    "    return [np.arcsin(y),np.arccos(y**2),np.arcsin(x),np.arccos(x**2),np.arcsin(z),np.arccos(z**2),np.arcsin(a),np.arccos(a**2),np.arcsin(b),np.arccos(b**2)] \n",
    "    #the length of the array has to be equal to the number of qubits"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Parameters introduction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "def training_set(par,circuit,theta,Phi_f):\n",
    "    #the following lines are destineted to the creation of the input for bind.parameters()\n",
    "    pre_input = [[theta.params[k], par[k]] for k in range(0, number_parameters)]\n",
    "    input_p2 = []\n",
    "    for i in range(0,len(pre_input)):\n",
    "        input_p2 = input_p2  + [pre_input[i][0]] + [pre_input[i][1]]\n",
    "    the_input = [{Phi:Phi_f[i]} for i in range(0,len(X))]\n",
    "    for i in range(0,len(X)):\n",
    "        for j in range(0,len(pre_input)):\n",
    "            the_input[i][pre_input[j][0]] = pre_input[j][1]\n",
    "\n",
    "    #evaluation of the circuit with the parameters setted by the input, for all possible values in X\n",
    "    Counts = []\n",
    "    for j in range(0,N):\n",
    "        circuits_dataset = [circuit.bind_parameters(the_input[i+j*max_circuits_supported]) for i in range(0,max_circuits_supported)]\n",
    "        if quantum_hw == 1:\n",
    "            provider = IBMQ.get_provider('ibm-q')\n",
    "            qcomp = provider.get_backend(bknd)\n",
    "        else:\n",
    "            qcomp = Aer.get_backend('qasm_simulator')\n",
    "        job = execute(circuits_dataset, backend = qcomp, optimization_level = 0, shots=Shots, initial_layout = layout)\n",
    "        job_monitor(job)\n",
    "        result = job.result()\n",
    "        counts = result.get_counts()\n",
    "        Counts = Counts + counts\n",
    "\n",
    "    circuits_dataset = [circuit.bind_parameters(the_input[i+max_circuits_supported*N]) for i in range(0,remainder)]\n",
    "    if quantum_hw == 1:\n",
    "        provider = IBMQ.get_provider('ibm-q')\n",
    "        qcomp = provider.get_backend(bknd)\n",
    "    else:\n",
    "        qcomp = Aer.get_backend('qasm_simulator')\n",
    "    job = execute(circuits_dataset, backend = qcomp, optimization_level = 0, shots=Shots, initial_layout = layout)\n",
    "    job_monitor(job)\n",
    "    result = job.result()\n",
    "    counts = result.get_counts()\n",
    "\n",
    "    Counts = Counts + counts\n",
    "    counts = Counts\n",
    "    \n",
    "#    ### Just to check that the circuits look right...\n",
    "#    print(circuits_dataset[0].decompose())\n",
    "    \n",
    "    return counts"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading data for training\n",
    "definition of functions to load data variable-per-variable properly deformed and rescaled in the interval [-1,1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [],
   "source": [
    "#calculate the number of events for each background in the sample considered\n",
    "def number_of_events(X1):\n",
    "    i=0\n",
    "    top=0\n",
    "    DY=0\n",
    "    Wjets_HT=0\n",
    "    VV=0\n",
    "    VVV=0\n",
    "    Vg=0\n",
    "    VgS=0\n",
    "    VBF_V=0\n",
    "    Fake=0\n",
    "    for i in range(len(X1)):\n",
    "        if X1[i]=='top':\n",
    "            top+=1\n",
    "            continue\n",
    "        if X1[i]=='DY':\n",
    "            DY+=1\n",
    "            continue\n",
    "        if X1[i]=='Wjets_HT':\n",
    "            Wjets_HT+=1\n",
    "            continue\n",
    "        if X1[i]=='VV':\n",
    "            VV+=1\n",
    "            continue\n",
    "        if X1[i]=='VBF-V':\n",
    "            VBF_V+=1\n",
    "            continue\n",
    "        if X1[i]=='VVV':\n",
    "            VVV+=1\n",
    "            continue\n",
    "        if X1[i]=='Vg':\n",
    "            Vg+=1\n",
    "            continue\n",
    "        if X1[i]=='VgS':\n",
    "            VgS+=1\n",
    "            continue\n",
    "        if X1[i]=='Fake':\n",
    "            Fake+=1\n",
    "            continue\n",
    "    return top, DY, Wjets_HT,VV,VBF_V,VVV,Vg,VgS,Fake\n",
    "\n",
    "def load_training(aa):\n",
    "    X1 = np.array(data1[Ind[aa]])\n",
    "    X2 = np.array(data2[Ind[aa]])\n",
    "\n",
    "    X = []\n",
    "    num_events=number_training//9\n",
    "    for i in range(0,number_training):\n",
    "        X.append(X1[i])\n",
    "        if i < num_events:\n",
    "            X.append(X2[i])\n",
    "        if num_events <= i < 2*num_events:\n",
    "            X.append(X2[top+i-num_events])\n",
    "        if 2*num_events <= i < 3*num_events:\n",
    "            X.append(X2[top+DY+i-2*num_events])\n",
    "        if 3*num_events<= i < 4*num_events:\n",
    "            X.append(X2[top+DY+Wjets_HT+i-3*num_events])\n",
    "        if 4*num_events<= i <5*num_events:\n",
    "            X.append(X2[top+DY+Wjets_HT+VV+i-4*num_events])\n",
    "        if 5*num_events<= i <6*num_events:\n",
    "            X.append(X2[top+DY+Wjets_HT+VV+VBF_V+i-5*num_events])\n",
    "        if 6*num_events<= i <7*num_events:\n",
    "            X.append(X2[top+DY+Wjets_HT+VV+VBF_V+VVV+i-6*num_events])\n",
    "        if 7*num_events<= i <8*num_events:\n",
    "            X.append(X2[top+DY+Wjets_HT+VV+VBF_V+VVV+Vg+i-7*num_events])\n",
    "        if 8*num_events<= i <9*num_events:\n",
    "            X.append(X2[top+DY+Wjets_HT+VV+VBF_V+VVV+Vg+VgS+i-8*num_events])\n",
    "        if 9*num_events<= i:\n",
    "            X.append(X2[top+DY+i-8*num_events])\n",
    "    return X\n",
    "\n",
    "def load_testing(aa):\n",
    "    X1 = np.array(data1[Ind[aa]])\n",
    "    X2 = np.array(data2[Ind[aa]])\n",
    "    \n",
    "    X = []\n",
    "    for i in range(number_training,number_training + number_testing):\n",
    "        X.append(X1[i])\n",
    "        X.append(X2[i])\n",
    "    return X\n",
    "\n",
    "def rescaling(X,reshape):\n",
    "    Xmax = max(X)\n",
    "    Xmin = min(X)\n",
    "\n",
    "    #X are normalizated over [-1,1]\n",
    "    if Xmax-Xmin != 0:\n",
    "        X = (np.array(X)- Xmin)*2/(Xmax-Xmin)\n",
    "    X = np.array(X) -1\n",
    "    if reshape==0:\n",
    "        X = Cheb(X)\n",
    "    if reshape==1:\n",
    "        X = InvCheb(X)\n",
    "    if reshape==2:\n",
    "        X = Sqrt(X)\n",
    "    if reshape==3:\n",
    "        X = InvSqrt(X)\n",
    "    X = np.clip(X,-1,1)\n",
    "    \n",
    "    X1 = []\n",
    "    X2 = []\n",
    "    for i in range(0,len(X)):\n",
    "        if i % 2 == 0:\n",
    "            X1.append(X[i])\n",
    "        else:\n",
    "            X2.append(X[i])\n",
    "    return X,X1,X2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "top = 24619 DY = 61371 Wjets_HT = 257503 VV = 70934 VBF-V = 743 VVV = 653 Vg = 215 VgS = 212 Fake = 13184\n",
      "top = 11 DY = 11 Wjets_HT = 12 VV = 11 VBF-V = 11 VVV = 11 Vg = 11 VgS = 11 Fake = 11\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#DATA CAPTURE\n",
    "#Here data are normalized in [-1,1] and, eventually, \"stretched\" or \"squized\" by using the functions just defined.\n",
    "#Odd and even elements of the following vectors will appartain to different classes (by choice)\n",
    "\n",
    "data1 = pickle.load(open(\"signal_balanced.pkl\",\"rb\"))\n",
    "data2 = pickle.load(open(\"background_balanced.pkl\",\"rb\")) \n",
    "Ind = data1.columns\n",
    "\n",
    "#total number of events of each background\n",
    "S=np.array(data2[Ind[57]])\n",
    "top, DY, Wjets_HT,VV,VBF_V,VVV,Vg,VgS,Fake=number_of_events(S)\n",
    "print('top =',top,'DY =', DY,'Wjets_HT =', Wjets_HT,'VV =', VV,'VBF-V =',VBF_V,'VVV =',VVV,'Vg =', Vg,'VgS =',VgS,'Fake =', Fake)\n",
    "#print(len(S), top+DY+Wjets_HT+VV+VBF_V+VVV+Vg+VgS+Fake)\n",
    "\n",
    "X=load_training(ii)\n",
    "Y=load_training(jj)\n",
    "Z=load_training(kk)\n",
    "A=load_training(ll)\n",
    "B=load_training(mm)\n",
    "X,X1,X2=rescaling(X,ri)\n",
    "Y,Y1,Y2=rescaling(Y,rj)\n",
    "Z,Z1,Z2=rescaling(Z,rk)\n",
    "A,A1,A2=rescaling(A,rl)\n",
    "B,B1,B2=rescaling(B,rm)\n",
    "W=load_training(nn)\n",
    "\n",
    "#balancing signal and background weights\n",
    "W1 = []\n",
    "W2 = []\n",
    "sum1=0\n",
    "sum2=0\n",
    "for i in range(0,len(X)):\n",
    "        if i % 2 == 0:\n",
    "            W1.append(W[i])\n",
    "            sum1 += W[i]\n",
    "        else:\n",
    "            W2.append(W[i])\n",
    "            sum2 += W[i]\n",
    "\n",
    "balance=sum2/sum1\n",
    "W2=W2/balance\n",
    "\n",
    "#sum2=0\n",
    "#for i in range(0,len(W2)):\n",
    "#        sum2 += W2[i]\n",
    "#print(sum1,sum2)\n",
    "\n",
    "#number of events of each background for the training\n",
    "S=load_training(57)\n",
    "top, DY, Wjets_HT,VV,VBF_V,VVV,Vg,VgS,Fake=number_of_events(S)\n",
    "print('top =',top,'DY =', DY,'Wjets_HT =', Wjets_HT,'VV =', VV,'VBF-V =',VBF_V,'VVV =',VVV,'Vg =', Vg,'VgS =',VgS,'Fake =', Fake)\n",
    "\n",
    "############################################################\n",
    "\n",
    "#TRAINING SET VISUALIZATION\n",
    "if plot_data == 1:\n",
    "    %matplotlib inline\n",
    "    fig5 = plt.figure(figsize = (10,10)) \n",
    "    ax = plt.axes(projection='3d')\n",
    "    ax.plot3D(X1,Y1,Z1,'ro',markersize = 1)\n",
    "    ax.plot3D(X2,Y2,Z2,'bo',markersize = 1)\n",
    "    ax.set_xlabel('x')   \n",
    "    ax.set_ylabel('y')   \n",
    "    ax.set_zlabel('z') "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing for the training\n",
    "division of the initial vector in smaller vectors in order to fit \"max_circuits_supported\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [],
   "source": [
    "#this part of the program is needed in the case where there exists a maximal number of trainable circuits per-time\n",
    "N = int(len(X)/max_circuits_supported)\n",
    "\n",
    "v = np.zeros((N, max_circuits_supported))\n",
    "for i in range(0,N):\n",
    "    for j in range(0,max_circuits_supported):\n",
    "        v[i][j] = X[j+i*max_circuits_supported]\n",
    "        \n",
    "remainder = len(X)%max_circuits_supported     \n",
    "v_last = np.zeros(remainder)\n",
    "for j in range(0,remainder):\n",
    "    v_last[j] = X[j+N*max_circuits_supported]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "training set mapping function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_qubits = 1 #for EACH variable\n",
    "number_bits = number_classes*2\n",
    "\n",
    "#evaluation of phi\n",
    "Phi_f = np.zeros((len(X), 2*number_var))\n",
    "for i in range(0,len(X)):\n",
    "    for j in range(0, 2*number_var):\n",
    "        Phi_f[i][j] = Phi_function(X[i],Y[i],Z[i],A[i],B[i])[j]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "training set mapping function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "#defining the label function for the trainingset, remember that odd and even events correspond to different classes\n",
    "\n",
    "f_l = []\n",
    "for i in range(0,len(X)):\n",
    "    f_l.append(f_label(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Build the variational circuit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_parameters = 4*number_qubits*number_var\n",
    "\n",
    "Phi = ParameterVector('Φ', 2*number_var) #int(number_qubits*(number_qubits+1)/2)\n",
    "theta = ParameterVector('θ',number_parameters)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Circuit construction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1591.6x806.68 with 1 Axes>"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1591.6x806.68 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "circuit = QuantumCircuit(number_var*number_qubits, number_bits)\n",
    "\n",
    "for i in range(0,L1):\n",
    "\n",
    "    for j in range(0,number_var):\n",
    "        for k in range(0,number_qubits):\n",
    "            circuit.rx(2*Phi[j*2],j+(number_var)*k)  \n",
    "            circuit.rz(2*Phi[j*2+1],j+(number_var)*k) \n",
    "circuit.barrier()\n",
    "\n",
    "#rotations\n",
    "s = 0\n",
    "for i in range(0,number_qubits*number_var):\n",
    "    variational_circuit = QuantumCircuit(1)\n",
    "    variational_circuit.rx(theta[s],0)\n",
    "    s += 1\n",
    "    variational_circuit.rz(theta[s],0)\n",
    "    s += 1\n",
    "    var_inst = variational_circuit.to_instruction()\n",
    "\n",
    "    circuit.append(var_inst,[i])\n",
    "circuit.barrier()\n",
    "S = s\n",
    "\n",
    "for k in range(0,L2):    \n",
    "    #entanglement  \n",
    "\n",
    "    circuit.cx(0,1)\n",
    "    circuit.cx(2,3)\n",
    "    circuit.h(3)\n",
    "    circuit.cx(2,3)\n",
    "    circuit.cx(3,4)\n",
    "    circuit.cx(2,3)\n",
    "\n",
    "    \n",
    "    circuit.barrier()\n",
    "    \n",
    "    #rotations\n",
    "    s = S\n",
    "    for i in range(0,number_qubits*number_var):\n",
    "        variational_circuit = QuantumCircuit(1)\n",
    "        variational_circuit.rx(theta[s],0)\n",
    "        s += 1\n",
    "        variational_circuit.rz(theta[s],0)\n",
    "        s += 1\n",
    "        var_inst = variational_circuit.to_instruction()\n",
    "\n",
    "        circuit.append(var_inst,[i])\n",
    "    circuit.barrier()\n",
    "\n",
    "    \n",
    "# circuit.measure(range(0,2),range(0,2))\n",
    "circuit.measure(range(0,4),range(0,4))\n",
    "\n",
    "%matplotlib inline \n",
    "circuit.decompose().draw('mpl')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cost function production and plot\n",
    "The cost function is chosen to be the kullback-Leibler divergence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/javascript": [
       "/* Put everything inside the global mpl namespace */\n",
       "/* global mpl */\n",
       "window.mpl = {};\n",
       "\n",
       "mpl.get_websocket_type = function () {\n",
       "    if (typeof WebSocket !== 'undefined') {\n",
       "        return WebSocket;\n",
       "    } else if (typeof MozWebSocket !== 'undefined') {\n",
       "        return MozWebSocket;\n",
       "    } else {\n",
       "        alert(\n",
       "            'Your browser does not have WebSocket support. ' +\n",
       "                'Please try Chrome, Safari or Firefox ≥ 6. ' +\n",
       "                'Firefox 4 and 5 are also supported but you ' +\n",
       "                'have to enable WebSockets in about:config.'\n",
       "        );\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n",
       "    this.id = figure_id;\n",
       "\n",
       "    this.ws = websocket;\n",
       "\n",
       "    this.supports_binary = this.ws.binaryType !== undefined;\n",
       "\n",
       "    if (!this.supports_binary) {\n",
       "        var warnings = document.getElementById('mpl-warnings');\n",
       "        if (warnings) {\n",
       "            warnings.style.display = 'block';\n",
       "            warnings.textContent =\n",
       "                'This browser does not support binary websocket messages. ' +\n",
       "                'Performance may be slow.';\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.imageObj = new Image();\n",
       "\n",
       "    this.context = undefined;\n",
       "    this.message = undefined;\n",
       "    this.canvas = undefined;\n",
       "    this.rubberband_canvas = undefined;\n",
       "    this.rubberband_context = undefined;\n",
       "    this.format_dropdown = undefined;\n",
       "\n",
       "    this.image_mode = 'full';\n",
       "\n",
       "    this.root = document.createElement('div');\n",
       "    this.root.setAttribute('style', 'display: inline-block');\n",
       "    this._root_extra_style(this.root);\n",
       "\n",
       "    parent_element.appendChild(this.root);\n",
       "\n",
       "    this._init_header(this);\n",
       "    this._init_canvas(this);\n",
       "    this._init_toolbar(this);\n",
       "\n",
       "    var fig = this;\n",
       "\n",
       "    this.waiting = false;\n",
       "\n",
       "    this.ws.onopen = function () {\n",
       "        fig.send_message('supports_binary', { value: fig.supports_binary });\n",
       "        fig.send_message('send_image_mode', {});\n",
       "        if (fig.ratio !== 1) {\n",
       "            fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n",
       "        }\n",
       "        fig.send_message('refresh', {});\n",
       "    };\n",
       "\n",
       "    this.imageObj.onload = function () {\n",
       "        if (fig.image_mode === 'full') {\n",
       "            // Full images could contain transparency (where diff images\n",
       "            // almost always do), so we need to clear the canvas so that\n",
       "            // there is no ghosting.\n",
       "            fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n",
       "        }\n",
       "        fig.context.drawImage(fig.imageObj, 0, 0);\n",
       "    };\n",
       "\n",
       "    this.imageObj.onunload = function () {\n",
       "        fig.ws.close();\n",
       "    };\n",
       "\n",
       "    this.ws.onmessage = this._make_on_message_function(this);\n",
       "\n",
       "    this.ondownload = ondownload;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_header = function () {\n",
       "    var titlebar = document.createElement('div');\n",
       "    titlebar.classList =\n",
       "        'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n",
       "    var titletext = document.createElement('div');\n",
       "    titletext.classList = 'ui-dialog-title';\n",
       "    titletext.setAttribute(\n",
       "        'style',\n",
       "        'width: 100%; text-align: center; padding: 3px;'\n",
       "    );\n",
       "    titlebar.appendChild(titletext);\n",
       "    this.root.appendChild(titlebar);\n",
       "    this.header = titletext;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n",
       "\n",
       "mpl.figure.prototype._init_canvas = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var canvas_div = (this.canvas_div = document.createElement('div'));\n",
       "    canvas_div.setAttribute(\n",
       "        'style',\n",
       "        'border: 1px solid #ddd;' +\n",
       "            'box-sizing: content-box;' +\n",
       "            'clear: both;' +\n",
       "            'min-height: 1px;' +\n",
       "            'min-width: 1px;' +\n",
       "            'outline: 0;' +\n",
       "            'overflow: hidden;' +\n",
       "            'position: relative;' +\n",
       "            'resize: both;'\n",
       "    );\n",
       "\n",
       "    function on_keyboard_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.key_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    canvas_div.addEventListener(\n",
       "        'keydown',\n",
       "        on_keyboard_event_closure('key_press')\n",
       "    );\n",
       "    canvas_div.addEventListener(\n",
       "        'keyup',\n",
       "        on_keyboard_event_closure('key_release')\n",
       "    );\n",
       "\n",
       "    this._canvas_extra_style(canvas_div);\n",
       "    this.root.appendChild(canvas_div);\n",
       "\n",
       "    var canvas = (this.canvas = document.createElement('canvas'));\n",
       "    canvas.classList.add('mpl-canvas');\n",
       "    canvas.setAttribute('style', 'box-sizing: content-box;');\n",
       "\n",
       "    this.context = canvas.getContext('2d');\n",
       "\n",
       "    var backingStore =\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        this.context.webkitBackingStorePixelRatio ||\n",
       "        this.context.mozBackingStorePixelRatio ||\n",
       "        this.context.msBackingStorePixelRatio ||\n",
       "        this.context.oBackingStorePixelRatio ||\n",
       "        this.context.backingStorePixelRatio ||\n",
       "        1;\n",
       "\n",
       "    this.ratio = (window.devicePixelRatio || 1) / backingStore;\n",
       "\n",
       "    var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n",
       "        'canvas'\n",
       "    ));\n",
       "    rubberband_canvas.setAttribute(\n",
       "        'style',\n",
       "        'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n",
       "    );\n",
       "\n",
       "    // Apply a ponyfill if ResizeObserver is not implemented by browser.\n",
       "    if (this.ResizeObserver === undefined) {\n",
       "        if (window.ResizeObserver !== undefined) {\n",
       "            this.ResizeObserver = window.ResizeObserver;\n",
       "        } else {\n",
       "            var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n",
       "            this.ResizeObserver = obs.ResizeObserver;\n",
       "        }\n",
       "    }\n",
       "\n",
       "    this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n",
       "        var nentries = entries.length;\n",
       "        for (var i = 0; i < nentries; i++) {\n",
       "            var entry = entries[i];\n",
       "            var width, height;\n",
       "            if (entry.contentBoxSize) {\n",
       "                if (entry.contentBoxSize instanceof Array) {\n",
       "                    // Chrome 84 implements new version of spec.\n",
       "                    width = entry.contentBoxSize[0].inlineSize;\n",
       "                    height = entry.contentBoxSize[0].blockSize;\n",
       "                } else {\n",
       "                    // Firefox implements old version of spec.\n",
       "                    width = entry.contentBoxSize.inlineSize;\n",
       "                    height = entry.contentBoxSize.blockSize;\n",
       "                }\n",
       "            } else {\n",
       "                // Chrome <84 implements even older version of spec.\n",
       "                width = entry.contentRect.width;\n",
       "                height = entry.contentRect.height;\n",
       "            }\n",
       "\n",
       "            // Keep the size of the canvas and rubber band canvas in sync with\n",
       "            // the canvas container.\n",
       "            if (entry.devicePixelContentBoxSize) {\n",
       "                // Chrome 84 implements new version of spec.\n",
       "                canvas.setAttribute(\n",
       "                    'width',\n",
       "                    entry.devicePixelContentBoxSize[0].inlineSize\n",
       "                );\n",
       "                canvas.setAttribute(\n",
       "                    'height',\n",
       "                    entry.devicePixelContentBoxSize[0].blockSize\n",
       "                );\n",
       "            } else {\n",
       "                canvas.setAttribute('width', width * fig.ratio);\n",
       "                canvas.setAttribute('height', height * fig.ratio);\n",
       "            }\n",
       "            canvas.setAttribute(\n",
       "                'style',\n",
       "                'width: ' + width + 'px; height: ' + height + 'px;'\n",
       "            );\n",
       "\n",
       "            rubberband_canvas.setAttribute('width', width);\n",
       "            rubberband_canvas.setAttribute('height', height);\n",
       "\n",
       "            // And update the size in Python. We ignore the initial 0/0 size\n",
       "            // that occurs as the element is placed into the DOM, which should\n",
       "            // otherwise not happen due to the minimum size styling.\n",
       "            if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n",
       "                fig.request_resize(width, height);\n",
       "            }\n",
       "        }\n",
       "    });\n",
       "    this.resizeObserverInstance.observe(canvas_div);\n",
       "\n",
       "    function on_mouse_event_closure(name) {\n",
       "        return function (event) {\n",
       "            return fig.mouse_event(event, name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousedown',\n",
       "        on_mouse_event_closure('button_press')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseup',\n",
       "        on_mouse_event_closure('button_release')\n",
       "    );\n",
       "    // Throttle sequential mouse events to 1 every 20ms.\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mousemove',\n",
       "        on_mouse_event_closure('motion_notify')\n",
       "    );\n",
       "\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseenter',\n",
       "        on_mouse_event_closure('figure_enter')\n",
       "    );\n",
       "    rubberband_canvas.addEventListener(\n",
       "        'mouseleave',\n",
       "        on_mouse_event_closure('figure_leave')\n",
       "    );\n",
       "\n",
       "    canvas_div.addEventListener('wheel', function (event) {\n",
       "        if (event.deltaY < 0) {\n",
       "            event.step = 1;\n",
       "        } else {\n",
       "            event.step = -1;\n",
       "        }\n",
       "        on_mouse_event_closure('scroll')(event);\n",
       "    });\n",
       "\n",
       "    canvas_div.appendChild(canvas);\n",
       "    canvas_div.appendChild(rubberband_canvas);\n",
       "\n",
       "    this.rubberband_context = rubberband_canvas.getContext('2d');\n",
       "    this.rubberband_context.strokeStyle = '#000000';\n",
       "\n",
       "    this._resize_canvas = function (width, height, forward) {\n",
       "        if (forward) {\n",
       "            canvas_div.style.width = width + 'px';\n",
       "            canvas_div.style.height = height + 'px';\n",
       "        }\n",
       "    };\n",
       "\n",
       "    // Disable right mouse context menu.\n",
       "    this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n",
       "        event.preventDefault();\n",
       "        return false;\n",
       "    });\n",
       "\n",
       "    function set_focus() {\n",
       "        canvas.focus();\n",
       "        canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    window.setTimeout(set_focus, 100);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'mpl-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'mpl-button-group';\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'mpl-button-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        var button = (fig.buttons[name] = document.createElement('button'));\n",
       "        button.classList = 'mpl-widget';\n",
       "        button.setAttribute('role', 'button');\n",
       "        button.setAttribute('aria-disabled', 'false');\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "\n",
       "        var icon_img = document.createElement('img');\n",
       "        icon_img.src = '_images/' + image + '.png';\n",
       "        icon_img.srcset = '_images/' + image + '_large.png 2x';\n",
       "        icon_img.alt = tooltip;\n",
       "        button.appendChild(icon_img);\n",
       "\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    var fmt_picker = document.createElement('select');\n",
       "    fmt_picker.classList = 'mpl-widget';\n",
       "    toolbar.appendChild(fmt_picker);\n",
       "    this.format_dropdown = fmt_picker;\n",
       "\n",
       "    for (var ind in mpl.extensions) {\n",
       "        var fmt = mpl.extensions[ind];\n",
       "        var option = document.createElement('option');\n",
       "        option.selected = fmt === mpl.default_extension;\n",
       "        option.innerHTML = fmt;\n",
       "        fmt_picker.appendChild(option);\n",
       "    }\n",
       "\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n",
       "    // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n",
       "    // which will in turn request a refresh of the image.\n",
       "    this.send_message('resize', { width: x_pixels, height: y_pixels });\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_message = function (type, properties) {\n",
       "    properties['type'] = type;\n",
       "    properties['figure_id'] = this.id;\n",
       "    this.ws.send(JSON.stringify(properties));\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.send_draw_message = function () {\n",
       "    if (!this.waiting) {\n",
       "        this.waiting = true;\n",
       "        this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    var format_dropdown = fig.format_dropdown;\n",
       "    var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n",
       "    fig.ondownload(fig, format);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_resize = function (fig, msg) {\n",
       "    var size = msg['size'];\n",
       "    if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n",
       "        fig._resize_canvas(size[0], size[1], msg['forward']);\n",
       "        fig.send_message('refresh', {});\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n",
       "    var x0 = msg['x0'] / fig.ratio;\n",
       "    var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n",
       "    var x1 = msg['x1'] / fig.ratio;\n",
       "    var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n",
       "    x0 = Math.floor(x0) + 0.5;\n",
       "    y0 = Math.floor(y0) + 0.5;\n",
       "    x1 = Math.floor(x1) + 0.5;\n",
       "    y1 = Math.floor(y1) + 0.5;\n",
       "    var min_x = Math.min(x0, x1);\n",
       "    var min_y = Math.min(y0, y1);\n",
       "    var width = Math.abs(x1 - x0);\n",
       "    var height = Math.abs(y1 - y0);\n",
       "\n",
       "    fig.rubberband_context.clearRect(\n",
       "        0,\n",
       "        0,\n",
       "        fig.canvas.width / fig.ratio,\n",
       "        fig.canvas.height / fig.ratio\n",
       "    );\n",
       "\n",
       "    fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n",
       "    // Updates the figure title.\n",
       "    fig.header.textContent = msg['label'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n",
       "    var cursor = msg['cursor'];\n",
       "    switch (cursor) {\n",
       "        case 0:\n",
       "            cursor = 'pointer';\n",
       "            break;\n",
       "        case 1:\n",
       "            cursor = 'default';\n",
       "            break;\n",
       "        case 2:\n",
       "            cursor = 'crosshair';\n",
       "            break;\n",
       "        case 3:\n",
       "            cursor = 'move';\n",
       "            break;\n",
       "    }\n",
       "    fig.rubberband_canvas.style.cursor = cursor;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_message = function (fig, msg) {\n",
       "    fig.message.textContent = msg['message'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n",
       "    // Request the server to send over a new figure.\n",
       "    fig.send_draw_message();\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n",
       "    fig.image_mode = msg['mode'];\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n",
       "    for (var key in msg) {\n",
       "        if (!(key in fig.buttons)) {\n",
       "            continue;\n",
       "        }\n",
       "        fig.buttons[key].disabled = !msg[key];\n",
       "        fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n",
       "    if (msg['mode'] === 'PAN') {\n",
       "        fig.buttons['Pan'].classList.add('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    } else if (msg['mode'] === 'ZOOM') {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.add('active');\n",
       "    } else {\n",
       "        fig.buttons['Pan'].classList.remove('active');\n",
       "        fig.buttons['Zoom'].classList.remove('active');\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Called whenever the canvas gets updated.\n",
       "    this.send_message('ack', {});\n",
       "};\n",
       "\n",
       "// A function to construct a web socket function for onmessage handling.\n",
       "// Called in the figure constructor.\n",
       "mpl.figure.prototype._make_on_message_function = function (fig) {\n",
       "    return function socket_on_message(evt) {\n",
       "        if (evt.data instanceof Blob) {\n",
       "            /* FIXME: We get \"Resource interpreted as Image but\n",
       "             * transferred with MIME type text/plain:\" errors on\n",
       "             * Chrome.  But how to set the MIME type?  It doesn't seem\n",
       "             * to be part of the websocket stream */\n",
       "            evt.data.type = 'image/png';\n",
       "\n",
       "            /* Free the memory for the previous frames */\n",
       "            if (fig.imageObj.src) {\n",
       "                (window.URL || window.webkitURL).revokeObjectURL(\n",
       "                    fig.imageObj.src\n",
       "                );\n",
       "            }\n",
       "\n",
       "            fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n",
       "                evt.data\n",
       "            );\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        } else if (\n",
       "            typeof evt.data === 'string' &&\n",
       "            evt.data.slice(0, 21) === 'data:image/png;base64'\n",
       "        ) {\n",
       "            fig.imageObj.src = evt.data;\n",
       "            fig.updated_canvas_event();\n",
       "            fig.waiting = false;\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        var msg = JSON.parse(evt.data);\n",
       "        var msg_type = msg['type'];\n",
       "\n",
       "        // Call the  \"handle_{type}\" callback, which takes\n",
       "        // the figure and JSON message as its only arguments.\n",
       "        try {\n",
       "            var callback = fig['handle_' + msg_type];\n",
       "        } catch (e) {\n",
       "            console.log(\n",
       "                \"No handler for the '\" + msg_type + \"' message type: \",\n",
       "                msg\n",
       "            );\n",
       "            return;\n",
       "        }\n",
       "\n",
       "        if (callback) {\n",
       "            try {\n",
       "                // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n",
       "                callback(fig, msg);\n",
       "            } catch (e) {\n",
       "                console.log(\n",
       "                    \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n",
       "                    e,\n",
       "                    e.stack,\n",
       "                    msg\n",
       "                );\n",
       "            }\n",
       "        }\n",
       "    };\n",
       "};\n",
       "\n",
       "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n",
       "mpl.findpos = function (e) {\n",
       "    //this section is from http://www.quirksmode.org/js/events_properties.html\n",
       "    var targ;\n",
       "    if (!e) {\n",
       "        e = window.event;\n",
       "    }\n",
       "    if (e.target) {\n",
       "        targ = e.target;\n",
       "    } else if (e.srcElement) {\n",
       "        targ = e.srcElement;\n",
       "    }\n",
       "    if (targ.nodeType === 3) {\n",
       "        // defeat Safari bug\n",
       "        targ = targ.parentNode;\n",
       "    }\n",
       "\n",
       "    // pageX,Y are the mouse positions relative to the document\n",
       "    var boundingRect = targ.getBoundingClientRect();\n",
       "    var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n",
       "    var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n",
       "\n",
       "    return { x: x, y: y };\n",
       "};\n",
       "\n",
       "/*\n",
       " * return a copy of an object with only non-object keys\n",
       " * we need this to avoid circular references\n",
       " * http://stackoverflow.com/a/24161582/3208463\n",
       " */\n",
       "function simpleKeys(original) {\n",
       "    return Object.keys(original).reduce(function (obj, key) {\n",
       "        if (typeof original[key] !== 'object') {\n",
       "            obj[key] = original[key];\n",
       "        }\n",
       "        return obj;\n",
       "    }, {});\n",
       "}\n",
       "\n",
       "mpl.figure.prototype.mouse_event = function (event, name) {\n",
       "    var canvas_pos = mpl.findpos(event);\n",
       "\n",
       "    if (name === 'button_press') {\n",
       "        this.canvas.focus();\n",
       "        this.canvas_div.focus();\n",
       "    }\n",
       "\n",
       "    var x = canvas_pos.x * this.ratio;\n",
       "    var y = canvas_pos.y * this.ratio;\n",
       "\n",
       "    this.send_message(name, {\n",
       "        x: x,\n",
       "        y: y,\n",
       "        button: event.button,\n",
       "        step: event.step,\n",
       "        guiEvent: simpleKeys(event),\n",
       "    });\n",
       "\n",
       "    /* This prevents the web browser from automatically changing to\n",
       "     * the text insertion cursor when the button is pressed.  We want\n",
       "     * to control all of the cursor setting manually through the\n",
       "     * 'cursor' event from matplotlib */\n",
       "    event.preventDefault();\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n",
       "    // Handle any extra behaviour associated with a key event\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.key_event = function (event, name) {\n",
       "    // Prevent repeat events\n",
       "    if (name === 'key_press') {\n",
       "        if (event.which === this._key) {\n",
       "            return;\n",
       "        } else {\n",
       "            this._key = event.which;\n",
       "        }\n",
       "    }\n",
       "    if (name === 'key_release') {\n",
       "        this._key = null;\n",
       "    }\n",
       "\n",
       "    var value = '';\n",
       "    if (event.ctrlKey && event.which !== 17) {\n",
       "        value += 'ctrl+';\n",
       "    }\n",
       "    if (event.altKey && event.which !== 18) {\n",
       "        value += 'alt+';\n",
       "    }\n",
       "    if (event.shiftKey && event.which !== 16) {\n",
       "        value += 'shift+';\n",
       "    }\n",
       "\n",
       "    value += 'k';\n",
       "    value += event.which.toString();\n",
       "\n",
       "    this._key_event_extra(event, name);\n",
       "\n",
       "    this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n",
       "    return false;\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n",
       "    if (name === 'download') {\n",
       "        this.handle_save(this, null);\n",
       "    } else {\n",
       "        this.send_message('toolbar_button', { name: name });\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n",
       "    this.message.textContent = tooltip;\n",
       "};\n",
       "\n",
       "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n",
       "// prettier-ignore\n",
       "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n",
       "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n",
       "\n",
       "mpl.extensions = [\"eps\", \"jpeg\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n",
       "\n",
       "mpl.default_extension = \"png\";/* global mpl */\n",
       "\n",
       "var comm_websocket_adapter = function (comm) {\n",
       "    // Create a \"websocket\"-like object which calls the given IPython comm\n",
       "    // object with the appropriate methods. Currently this is a non binary\n",
       "    // socket, so there is still some room for performance tuning.\n",
       "    var ws = {};\n",
       "\n",
       "    ws.close = function () {\n",
       "        comm.close();\n",
       "    };\n",
       "    ws.send = function (m) {\n",
       "        //console.log('sending', m);\n",
       "        comm.send(m);\n",
       "    };\n",
       "    // Register the callback with on_msg.\n",
       "    comm.on_msg(function (msg) {\n",
       "        //console.log('receiving', msg['content']['data'], msg);\n",
       "        // Pass the mpl event to the overridden (by mpl) onmessage function.\n",
       "        ws.onmessage(msg['content']['data']);\n",
       "    });\n",
       "    return ws;\n",
       "};\n",
       "\n",
       "mpl.mpl_figure_comm = function (comm, msg) {\n",
       "    // This is the function which gets called when the mpl process\n",
       "    // starts-up an IPython Comm through the \"matplotlib\" channel.\n",
       "\n",
       "    var id = msg.content.data.id;\n",
       "    // Get hold of the div created by the display call when the Comm\n",
       "    // socket was opened in Python.\n",
       "    var element = document.getElementById(id);\n",
       "    var ws_proxy = comm_websocket_adapter(comm);\n",
       "\n",
       "    function ondownload(figure, _format) {\n",
       "        window.open(figure.canvas.toDataURL());\n",
       "    }\n",
       "\n",
       "    var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n",
       "\n",
       "    // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n",
       "    // web socket which is closed, not our websocket->open comm proxy.\n",
       "    ws_proxy.onopen();\n",
       "\n",
       "    fig.parent_element = element;\n",
       "    fig.cell_info = mpl.find_output_cell(\"<div id='\" + id + \"'></div>\");\n",
       "    if (!fig.cell_info) {\n",
       "        console.error('Failed to find cell for figure', id, fig);\n",
       "        return;\n",
       "    }\n",
       "    fig.cell_info[0].output_area.element.on(\n",
       "        'cleared',\n",
       "        { fig: fig },\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_close = function (fig, msg) {\n",
       "    var width = fig.canvas.width / fig.ratio;\n",
       "    fig.cell_info[0].output_area.element.off(\n",
       "        'cleared',\n",
       "        fig._remove_fig_handler\n",
       "    );\n",
       "    fig.resizeObserverInstance.unobserve(fig.canvas_div);\n",
       "\n",
       "    // Update the output cell to use the data from the current canvas.\n",
       "    fig.push_to_output();\n",
       "    var dataURL = fig.canvas.toDataURL();\n",
       "    // Re-enable the keyboard manager in IPython - without this line, in FF,\n",
       "    // the notebook keyboard shortcuts fail.\n",
       "    IPython.keyboard_manager.enable();\n",
       "    fig.parent_element.innerHTML =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "    fig.close_ws(fig, msg);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.close_ws = function (fig, msg) {\n",
       "    fig.send_message('closing', msg);\n",
       "    // fig.ws.close()\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n",
       "    // Turn the data on the canvas into data in the output cell.\n",
       "    var width = this.canvas.width / this.ratio;\n",
       "    var dataURL = this.canvas.toDataURL();\n",
       "    this.cell_info[1]['text/html'] =\n",
       "        '<img src=\"' + dataURL + '\" width=\"' + width + '\">';\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.updated_canvas_event = function () {\n",
       "    // Tell IPython that the notebook contents must change.\n",
       "    IPython.notebook.set_dirty(true);\n",
       "    this.send_message('ack', {});\n",
       "    var fig = this;\n",
       "    // Wait a second, then push the new image to the DOM so\n",
       "    // that it is saved nicely (might be nice to debounce this).\n",
       "    setTimeout(function () {\n",
       "        fig.push_to_output();\n",
       "    }, 1000);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._init_toolbar = function () {\n",
       "    var fig = this;\n",
       "\n",
       "    var toolbar = document.createElement('div');\n",
       "    toolbar.classList = 'btn-toolbar';\n",
       "    this.root.appendChild(toolbar);\n",
       "\n",
       "    function on_click_closure(name) {\n",
       "        return function (_event) {\n",
       "            return fig.toolbar_button_onclick(name);\n",
       "        };\n",
       "    }\n",
       "\n",
       "    function on_mouseover_closure(tooltip) {\n",
       "        return function (event) {\n",
       "            if (!event.currentTarget.disabled) {\n",
       "                return fig.toolbar_button_onmouseover(tooltip);\n",
       "            }\n",
       "        };\n",
       "    }\n",
       "\n",
       "    fig.buttons = {};\n",
       "    var buttonGroup = document.createElement('div');\n",
       "    buttonGroup.classList = 'btn-group';\n",
       "    var button;\n",
       "    for (var toolbar_ind in mpl.toolbar_items) {\n",
       "        var name = mpl.toolbar_items[toolbar_ind][0];\n",
       "        var tooltip = mpl.toolbar_items[toolbar_ind][1];\n",
       "        var image = mpl.toolbar_items[toolbar_ind][2];\n",
       "        var method_name = mpl.toolbar_items[toolbar_ind][3];\n",
       "\n",
       "        if (!name) {\n",
       "            /* Instead of a spacer, we start a new button group. */\n",
       "            if (buttonGroup.hasChildNodes()) {\n",
       "                toolbar.appendChild(buttonGroup);\n",
       "            }\n",
       "            buttonGroup = document.createElement('div');\n",
       "            buttonGroup.classList = 'btn-group';\n",
       "            continue;\n",
       "        }\n",
       "\n",
       "        button = fig.buttons[name] = document.createElement('button');\n",
       "        button.classList = 'btn btn-default';\n",
       "        button.href = '#';\n",
       "        button.title = name;\n",
       "        button.innerHTML = '<i class=\"fa ' + image + ' fa-lg\"></i>';\n",
       "        button.addEventListener('click', on_click_closure(method_name));\n",
       "        button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n",
       "        buttonGroup.appendChild(button);\n",
       "    }\n",
       "\n",
       "    if (buttonGroup.hasChildNodes()) {\n",
       "        toolbar.appendChild(buttonGroup);\n",
       "    }\n",
       "\n",
       "    // Add the status bar.\n",
       "    var status_bar = document.createElement('span');\n",
       "    status_bar.classList = 'mpl-message pull-right';\n",
       "    toolbar.appendChild(status_bar);\n",
       "    this.message = status_bar;\n",
       "\n",
       "    // Add the close button to the window.\n",
       "    var buttongrp = document.createElement('div');\n",
       "    buttongrp.classList = 'btn-group inline pull-right';\n",
       "    button = document.createElement('button');\n",
       "    button.classList = 'btn btn-mini btn-primary';\n",
       "    button.href = '#';\n",
       "    button.title = 'Stop Interaction';\n",
       "    button.innerHTML = '<i class=\"fa fa-power-off icon-remove icon-large\"></i>';\n",
       "    button.addEventListener('click', function (_evt) {\n",
       "        fig.handle_close(fig, {});\n",
       "    });\n",
       "    button.addEventListener(\n",
       "        'mouseover',\n",
       "        on_mouseover_closure('Stop Interaction')\n",
       "    );\n",
       "    buttongrp.appendChild(button);\n",
       "    var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n",
       "    titlebar.insertBefore(buttongrp, titlebar.firstChild);\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._remove_fig_handler = function (event) {\n",
       "    var fig = event.data.fig;\n",
       "    if (event.target !== this) {\n",
       "        // Ignore bubbled events from children.\n",
       "        return;\n",
       "    }\n",
       "    fig.close_ws(fig, {});\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._root_extra_style = function (el) {\n",
       "    el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._canvas_extra_style = function (el) {\n",
       "    // this is important to make the div 'focusable\n",
       "    el.setAttribute('tabindex', 0);\n",
       "    // reach out to IPython and tell the keyboard manager to turn it's self\n",
       "    // off when our div gets focus\n",
       "\n",
       "    // location in version 3\n",
       "    if (IPython.notebook.keyboard_manager) {\n",
       "        IPython.notebook.keyboard_manager.register_events(el);\n",
       "    } else {\n",
       "        // location in version 2\n",
       "        IPython.keyboard_manager.register_events(el);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype._key_event_extra = function (event, _name) {\n",
       "    var manager = IPython.notebook.keyboard_manager;\n",
       "    if (!manager) {\n",
       "        manager = IPython.keyboard_manager;\n",
       "    }\n",
       "\n",
       "    // Check for shift+enter\n",
       "    if (event.shiftKey && event.which === 13) {\n",
       "        this.canvas_div.blur();\n",
       "        // select the cell after this one\n",
       "        var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n",
       "        IPython.notebook.select(index + 1);\n",
       "    }\n",
       "};\n",
       "\n",
       "mpl.figure.prototype.handle_save = function (fig, _msg) {\n",
       "    fig.ondownload(fig, null);\n",
       "};\n",
       "\n",
       "mpl.find_output_cell = function (html_output) {\n",
       "    // Return the cell and output element which can be found *uniquely* in the notebook.\n",
       "    // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n",
       "    // IPython event is triggered only after the cells have been serialised, which for\n",
       "    // our purposes (turning an active figure into a static one), is too late.\n",
       "    var cells = IPython.notebook.get_cells();\n",
       "    var ncells = cells.length;\n",
       "    for (var i = 0; i < ncells; i++) {\n",
       "        var cell = cells[i];\n",
       "        if (cell.cell_type === 'code') {\n",
       "            for (var j = 0; j < cell.output_area.outputs.length; j++) {\n",
       "                var data = cell.output_area.outputs[j];\n",
       "                if (data.data) {\n",
       "                    // IPython >= 3 moved mimebundle to data attribute of output\n",
       "                    data = data.data;\n",
       "                }\n",
       "                if (data['text/html'] === html_output) {\n",
       "                    return [cell, data, j];\n",
       "                }\n",
       "            }\n",
       "        }\n",
       "    }\n",
       "};\n",
       "\n",
       "// Register the function which deals with the matplotlib target/channel.\n",
       "// The kernel may be null if the page has been refreshed.\n",
       "if (IPython.notebook.kernel !== null) {\n",
       "    IPython.notebook.kernel.comm_manager.register_target(\n",
       "        'matplotlib',\n",
       "        mpl.mpl_figure_comm\n",
       "    );\n",
       "}\n"
      ],
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/html": [
       "<img src=\"data:image/png;base64,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\" width=\"432\">"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib notebook\n",
    "\n",
    "X_plot = []\n",
    "Y_plot = []\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.add_subplot()\n",
    "plt.ion()\n",
    "\n",
    "fig.show()\n",
    "fig.canvas.draw()\n",
    "iter_count = 0\n",
    "\n",
    "def plot_cost_fun(y):\n",
    "    global iter_count\n",
    "    global X_plot\n",
    "    global Y_plot\n",
    "    X_plot.append(iter_count)\n",
    "    Y_plot.append(y)\n",
    "    ax.clear()\n",
    "    ax.plot(X_plot,Y_plot)\n",
    "    fig.canvas.draw()\n",
    "    iter_count += 1   \n",
    "\n",
    "def cost_function(par,*args): #par will contain the parameters at each step of the optimization\n",
    "\n",
    "    circuit = args[0]\n",
    "    theta = args[1]\n",
    "    Phi_f = args[2]\n",
    "    W = args[3]\n",
    "    \n",
    "    counts = training_set(par,circuit,theta,Phi_f)\n",
    "\n",
    "    L = 0\n",
    "    print(\"\\n current value of parameters: \" , par )\n",
    "      \n",
    "    #estimated label \n",
    "    for i in range(0,len(X)):\n",
    "        for k in range(0,2):\n",
    "            yi = f_measuration(counts[i])\n",
    "            Yi = ((c_e_ii+c_e_jj)*yi[k] + (c_e_kk+c_e_ll)*yi[2+k])/(c_e_ii+c_e_jj+c_e_kk+c_e_ll)  \n",
    "            L += (-f_l[i][k]*math.log(Yi))*(((i+1)%2)*ratio + i%2)*W[i]\n",
    "            \n",
    "    if print_loss_func == 1:\n",
    "        plot_cost_fun(L)\n",
    "    \n",
    "    print(\"current value for loss function: \" , L , \"\\n\\n\" )\n",
    "    return L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "factor = 100\n",
    "\n",
    "#creation of the eigenstates list, i.e: ['000', '001',... ]\n",
    "eig = []\n",
    "for i in range(0,2**(number_bits)):\n",
    "    eig.append('')\n",
    "\n",
    "for j in range(0,number_bits):\n",
    "    for i in range(0,2**j): \n",
    "        for k in range(0,(2**(number_bits-j))):            \n",
    "            if (k % 2) == 0:\n",
    "                eig[i+k*2**j] = '0' + eig[i+k*2**j] \n",
    "            else:\n",
    "                eig[i+k*2**j] = '1' + eig[i+k*2**j]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [ 1.65685041  4.97913386  0.77295146  5.23748043  1.90642202  1.56940164\n",
      " -0.01039288  4.74406781  5.8162106   3.66874056  1.98092531  4.61458505\n",
      "  4.41582149  4.67276973  2.99726133  3.23888652  2.33819787  3.98928789\n",
      "  4.61063517  0.04558055]\n",
      "current value for loss function:  81.492815626882 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [2.25685041 5.57913386 1.37295146 5.83748043 2.50642202 2.16940164\n",
      " 0.58960712 5.34406781 6.4162106  3.06874056 2.58092531 5.21458505\n",
      " 5.01582149 5.27276973 2.39726133 2.63888652 2.93819787 4.58928789\n",
      " 5.21063517 0.64558055]\n",
      "current value for loss function:  81.50995199329867 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.76932269 5.09160614 1.25476706 5.34995271 2.01889429 2.05121724\n",
      " 0.47142272 4.85654008 6.2980262  3.18692496 2.09339758 5.09640065\n",
      " 4.89763709 5.15458533 2.88478905 3.12641424 2.82001347 4.4711035\n",
      " 4.72310745 0.52739615]\n",
      "current value for loss function:  79.92998515819816 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [2.13866601 5.46094946 0.88542374 5.71929603 2.38823762 1.68187392\n",
      " 0.10207939 5.22588341 5.92868288 3.55626829 2.46274091 4.72705733\n",
      " 4.52829377 4.785242   2.51544573 2.75707092 2.45067015 4.10176017\n",
      " 5.09245077 0.15805283]\n",
      "current value for loss function:  82.77219671498139 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.70826774 4.75247336 1.59389984 5.28889776 1.95783935 2.39035002\n",
      " 0.8105555  4.5174073  6.35908115 3.12587002 1.7542648  5.1574556\n",
      " 4.95869204 5.21564027 2.945844   3.18746919 2.88106842 4.81023627\n",
      " 4.6620525  0.5884511 ]\n",
      "current value for loss function:  79.91128517429846 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.43018991 5.03055119 1.31582201 5.01081993 1.67976151 2.11227219\n",
      " 0.53247766 4.79548514 6.63715898 2.84779218 2.03234264 5.43553343\n",
      " 5.23676987 5.49371811 3.22392183 3.46554702 3.15914625 4.53215844\n",
      " 4.38397467 0.86652893]\n",
      "current value for loss function:  78.08341694624018 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.23644258 5.22429853 1.12207468 4.8170726  1.48601418 2.14588234\n",
      " 0.33873033 4.76187498 6.60354883 2.88140234 1.99873248 5.40192328\n",
      " 5.4305172  5.46010796 3.19031168 3.43193687 3.1255361  4.56576859\n",
      " 4.41758482 1.06027626]\n",
      "current value for loss function:  77.70427324477323 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.46380006 4.99694104 1.34943216 5.04443008 1.71337167 1.91852486\n",
      " 0.56608781 4.98923247 6.83090631 2.65404485 2.22608997 5.62928076\n",
      " 5.20315972 5.68746544 3.41766916 3.65929435 3.35289359 4.33841111\n",
      " 4.19022734 0.83291878]\n",
      "current value for loss function:  77.68217856957662 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.44979022 5.20542967 1.14094353 4.83594145 1.69936183 1.93253469\n",
      " 0.55207798 4.97522263 6.62241768 2.66805469 2.21208013 5.42079213\n",
      " 5.41164835 5.6734556  3.20918053 3.64528452 3.33888375 4.35242095\n",
      " 4.20423718 0.84692862]\n",
      "current value for loss function:  77.01730125005986 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.25531143 5.01095088 1.33542232 5.03042024 1.50488304 2.12701349\n",
      " 0.35759918 4.78074384 6.81689648 2.86253348 2.01760134 5.61527092\n",
      " 5.21716956 5.47897681 3.40365932 3.45080572 3.14440496 4.54689974\n",
      " 4.39871597 1.04140741]\n",
      "current value for loss function:  78.30723945928418 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.57079525 5.32643469 1.01993851 4.88611342 1.82036685 1.98270666\n",
      " 0.50190601 4.92505067 6.50141266 2.71822665 2.16190817 5.29978711\n",
      " 5.36147639 5.79446063 3.2593525  3.76628954 3.28871178 4.23141592\n",
      " 4.25440914 0.72592359]\n",
      "current value for loss function:  76.90629608211066 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.39961826 5.15525771 1.19111549 4.71493643 1.64918986 1.81152967\n",
      " 0.673083   5.09622765 6.67258965 2.54704967 2.33308515 5.4709641\n",
      " 5.53265337 5.62328364 3.08817551 3.59511255 3.45988877 4.40259291\n",
      " 4.08323215 0.89710058]\n",
      "current value for loss function:  76.65465094449068 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.38387144 5.13951089 1.20686231 4.85285732 1.78711076 1.94945056\n",
      " 0.68882982 5.11197447 6.68833647 2.68497056 2.34883197 5.3330432\n",
      " 5.54840019 5.76120453 3.2260964  3.73303344 3.47563559 4.26467202\n",
      " 4.06748533 0.9128474 ]\n",
      "current value for loss function:  76.11146019312449 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.53753915 5.2931786  1.0531946  4.69918961 1.63344304 1.79578285\n",
      " 0.53516211 4.95830676 6.53466876 2.53130285 2.19516426 5.48671092\n",
      " 5.39473248 5.60753682 3.07242869 3.57936573 3.32196788 4.41833973\n",
      " 4.22115304 0.75917969]\n",
      "current value for loss function:  77.17137914600606 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.29219249 5.18778688 1.15858632 4.80458132 1.87878971 1.90117457\n",
      " 0.78050877 5.06369848 6.78001542 2.63669456 2.30055598 5.24136425\n",
      " 5.64007915 5.71292854 3.31777535 3.8247124  3.4273596  4.31294801\n",
      " 3.97580638 0.8645714 ]\n",
      "current value for loss function:  76.26985229150851 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.43214743 5.04783193 1.29854127 4.94453627 1.73883476 2.04112952\n",
      " 0.64055382 5.20365343 6.64006047 2.77664951 2.44051093 5.3813192\n",
      " 5.5001242  5.85288348 3.17782041 3.68475745 3.56731454 4.17299307\n",
      " 4.11576133 1.00452635]\n",
      "current value for loss function:  75.93633444755343 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.32751852 5.15246085 1.32279116 4.96878617 1.84346367 1.9365006\n",
      " 0.61630393 5.22790332 6.61581058 2.8008994  2.33588202 5.40556909\n",
      " 5.60475311 5.74825457 3.15357051 3.78938636 3.46268563 4.14874317\n",
      " 4.14001122 1.02877624]\n",
      "current value for loss function:  75.85078666575072 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.45639733 5.02358204 1.19391236 4.83990736 1.71458487 2.06537941\n",
      " 0.74518273 5.09902452 6.74468938 2.6720206  2.46476082 5.27669029\n",
      " 5.4758743  5.87713338 3.28244932 3.66050756 3.59156444 4.27762198\n",
      " 4.01113242 0.89989744]\n",
      "current value for loss function:  76.13613818264653 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.30749886 5.05276477 1.34281082 4.86909009 1.74376759 1.91648094\n",
      " 0.71600001 5.24792298 6.59579092 2.70120333 2.43557809 5.42558875\n",
      " 5.50505703 5.72823491 3.13355085 3.68969028 3.56238171 4.24843925\n",
      " 4.04031514 0.92908017]\n",
      "current value for loss function:  76.09152196342163 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.4272146  5.17248051 1.22309508 4.98880583 1.86348333 2.03619668\n",
      " 0.59628427 5.12820724 6.71550666 2.82091906 2.31586235 5.30587301\n",
      " 5.62477277 5.84795065 3.25326659 3.80940602 3.44266597 4.12872351\n",
      " 4.16003088 1.04879591]\n",
      "current value for loss function:  75.93792609497886 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.32419215 5.06945806 1.32611753 4.99777264 1.87245014 1.93317423\n",
      " 0.69930672 5.11924043 6.61248421 2.82988587 2.30689555 5.29690621\n",
      " 5.52175032 5.85691746 3.2622334  3.81837283 3.43369916 4.1197567\n",
      " 4.05700843 0.94577345]\n",
      "current value for loss function:  75.94953943621057 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.43618141 5.18144732 1.21412827 4.88578338 1.76046088 2.04516349\n",
      " 0.58731746 5.23122969 6.72447346 2.71789661 2.41888481 5.40889547\n",
      " 5.63373958 5.7449282  3.15024414 3.70638357 3.54568842 4.23174596\n",
      " 4.16899769 1.05776271]\n",
      "current value for loss function:  75.87040389814852 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.43929663 5.07919074 1.31638485 4.88266815 1.75734566 1.94290692\n",
      " 0.68957403 5.12897312 6.72758869 2.71478139 2.31662823 5.30663889\n",
      " 5.6368548  5.74181298 3.14712892 3.70326835 3.44343185 4.12948939\n",
      " 4.17211291 1.06087794]\n",
      "current value for loss function:  76.29134255491296 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33392484 5.18456254 1.21101305 4.98803995 1.86271745 2.04827871\n",
      " 0.58420224 5.23434492 6.62221689 2.82015318 2.42200003 5.41201069\n",
      " 5.53148301 5.84718477 3.25250071 3.80864014 3.54880364 4.23486119\n",
      " 4.06674112 0.95550614]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current value for loss function:  75.66980604019788 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.38727158 5.1312158  1.26435979 4.93469321 1.90900089 2.09456215\n",
      " 0.63754898 5.18099817 6.57593346 2.76680644 2.36865329 5.45829412\n",
      " 5.58482975 5.89346821 3.19915397 3.7552934  3.4954569  4.28114462\n",
      " 4.12008786 1.00885288]\n",
      "current value for loss function:  75.87589462305712 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.2876414  5.23084597 1.16472962 5.03432338 1.80937071 1.99493197\n",
      " 0.5379188  5.28062835 6.67556364 2.86643662 2.46828346 5.35866395\n",
      " 5.48519957 5.79383803 3.29878415 3.85492358 3.59508708 4.18151444\n",
      " 4.02045768 0.90922271]\n",
      "current value for loss function:  75.67003691899806 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.27426572 5.24422166 1.15135393 5.04769907 1.79599503 1.98155629\n",
      " 0.61913669 5.19941046 6.68893932 2.87981231 2.38706558 5.34528826\n",
      " 5.56641746 5.87505592 3.21756626 3.86829926 3.51386919 4.26273233\n",
      " 4.007082   0.89584702]\n",
      "current value for loss function:  75.62080095182166 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36885929 5.14962809 1.2459475  4.9531055  1.8905886  2.07614986\n",
      " 0.52454312 5.29400404 6.59434575 2.78521873 2.48165915 5.43988183\n",
      " 5.47182389 5.78046234 3.31215983 3.77370569 3.60846277 4.16813876\n",
      " 4.10167557 0.99044059]\n",
      "current value for loss function:  75.860069604282 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.34856195 5.26005916 1.13551643 4.97340283 1.87029126 2.05585252\n",
      " 0.54484046 5.2737067  6.70477682 2.89564981 2.46136181 5.4195845\n",
      " 5.58225496 5.89089342 3.29186249 3.79400303 3.49803169 4.27856983\n",
      " 4.08137823 0.88000952]\n",
      "current value for loss function:  75.53047788041326 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.25842821 5.16992543 1.22565016 5.06353657 1.78015753 1.96571878\n",
      " 0.63497419 5.18357296 6.61464309 2.80551607 2.37122808 5.32945076\n",
      " 5.49212122 5.80075968 3.20172876 3.88413676 3.58816543 4.1884361\n",
      " 3.9912445  0.97014325]\n",
      "current value for loss function:  75.93568511264014 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.29038971 5.20188692 1.10753629 4.9454227  1.81211902 2.08383266\n",
      " 0.51686032 5.21553446 6.64660458 2.92362994 2.40318957 5.36141226\n",
      " 5.6102351  5.83272118 3.23369025 3.76602289 3.55620393 4.22039759\n",
      " 4.02320599 0.93818176]\n",
      "current value for loss function:  75.46805293636152 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37654209 5.2880393  1.19368867 5.03157508 1.8982714  1.99768028\n",
      " 0.6030127  5.30168683 6.73275696 2.83747757 2.48934195 5.44756463\n",
      " 5.52408272 5.91887355 3.31984263 3.85217527 3.47005156 4.30654997\n",
      " 4.10935837 0.85202938]\n",
      "current value for loss function:  75.68356437162487 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.27654503 5.27061504 1.17626441 4.93157802 1.79827434 2.09767733\n",
      " 0.50301564 5.20168978 6.7153327  2.85490182 2.47191769 5.34756758\n",
      " 5.62407977 5.8188765  3.21984558 3.75217822 3.57004861 4.20655291\n",
      " 4.09193411 0.86945364]\n",
      "current value for loss function:  75.59530708476268 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.35911783 5.18804224 1.09369162 5.01415082 1.88084714 2.01510454\n",
      " 0.58558844 5.28426258 6.6327599  2.93747462 2.38934489 5.43014038\n",
      " 5.54150697 5.9014493  3.30241837 3.83475101 3.48747581 4.28912571\n",
      " 4.00936131 0.95202644]\n",
      "current value for loss function:  75.44021753197212 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.28921266 5.25794742 1.16359679 4.94424565 1.89027618 2.0056755\n",
      " 0.59501748 5.2143574  6.62333087 2.94690366 2.37991586 5.3602352\n",
      " 5.61141215 5.91087833 3.31184741 3.76484584 3.55738099 4.29855475\n",
      " 4.07926649 0.88212126]\n",
      "current value for loss function:  75.55508955610601 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36854686 5.17861321 1.08426258 5.02357985 1.81094197 2.08500971\n",
      " 0.51568327 5.29369161 6.70266508 2.86756945 2.45925007 5.43956941\n",
      " 5.53207794 5.83154412 3.2325132  3.84418005 3.47804678 4.21922054\n",
      " 3.99993228 0.96145547]\n",
      "current value for loss function:  75.60965552436284 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36325253 5.18390754 1.16594467 5.01828552 1.89262405 2.00332763\n",
      " 0.5209776  5.21200953 6.62098299 2.87286378 2.45395573 5.43427508\n",
      " 5.61376002 5.91322621 3.31419528 3.76249796 3.48334111 4.22451487\n",
      " 4.00522661 0.87977339]\n",
      "current value for loss function:  75.55977549810885 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.28686478 5.26029529 1.08955691 4.94189777 1.8162363  2.07971538\n",
      " 0.59736535 5.28839728 6.69737075 2.94925153 2.37756798 5.35788733\n",
      " 5.53737227 5.83683846 3.23780753 3.83888572 3.55972886 4.30090262\n",
      " 4.08161436 0.95616114]\n",
      "current value for loss function:  75.44508527721969 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.35400328 5.26685048 1.15669541 5.00903627 1.80968112 2.08627056\n",
      " 0.60392054 5.29495246 6.70392593 2.88211303 2.44470648 5.35133214\n",
      " 5.60451077 5.90397695 3.30494603 3.77174722 3.49259036 4.30745781\n",
      " 4.08816955 0.88902264]\n",
      "current value for loss function:  75.52394261735525 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.2803096  5.1931568  1.08300173 4.93534259 1.8833748  2.01257688\n",
      " 0.53022685 5.22125878 6.63023225 2.95580671 2.3710128  5.42502582\n",
      " 5.53081709 5.83028327 3.23125235 3.8454409  3.56628404 4.23376413\n",
      " 4.01447587 0.96271632]\n",
      "current value for loss function:  75.58158481256243 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.28545772 5.26952422 1.08814985 4.94049071 1.80700737 2.08894431\n",
      " 0.53537497 5.2264069  6.63538037 2.9506586  2.37616092 5.3486584\n",
      " 5.53596521 5.83543139 3.30761977 3.76907347 3.56113593 4.31013155\n",
      " 4.09084329 0.9575682 ]\n",
      "current value for loss function:  75.741341685913 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.35667702 5.19830491 1.15936916 5.01171001 1.87822668 2.017725\n",
      " 0.60659428 5.29762621 6.70659967 2.87943929 2.44738022 5.4198777\n",
      " 5.60718451 5.9066507  3.23640047 3.84029278 3.48991662 4.23891224\n",
      " 4.01962398 0.8863489 ]\n",
      "current value for loss function:  75.38205713428769 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37955879 5.24436062 1.11331345 5.03459178 1.83217097 1.99484323\n",
      " 0.62947605 5.32050798 6.66054397 2.925495   2.40132452 5.44275947\n",
      " 5.56112881 5.92953247 3.2135187  3.86317455 3.46703485 4.21603048\n",
      " 4.06567969 0.93240461]\n",
      "current value for loss function:  75.40538536652915 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.31062131 5.17542315 1.18225092 4.9656543  1.90110845 2.06378071\n",
      " 0.56053857 5.2515705  6.72948144 2.85655752 2.47026199 5.373822\n",
      " 5.63006628 5.86059499 3.28245618 3.79423707 3.53597233 4.28496795\n",
      " 3.99674222 0.86346713]\n",
      "current value for loss function:  75.63666443978724 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.32692693 5.25855419 1.16594531 4.98195992 1.8179774  1.98064966\n",
      " 0.64366962 5.26787612 6.64635039 2.87286314 2.45395637 5.39012761\n",
      " 5.54693523 5.87690061 3.26615056 3.87736812 3.51966671 4.20183691\n",
      " 4.01304783 0.87977275]\n",
      "current value for loss function:  75.58058126588497 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.39375236 5.19172876 1.09911988 5.04878535 1.88480283 2.04747509\n",
      " 0.57684419 5.33470155 6.71317582 2.93968857 2.38713094 5.45695304\n",
      " 5.61376067 5.94372604 3.19932513 3.81054269 3.45284128 4.26866234\n",
      " 4.07987327 0.94659818]\n",
      "current value for loss function:  75.2056010497 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.3523048  5.16831237 1.14056743 5.07220174 1.90821922 2.07089148\n",
      " 0.5534278  5.29325399 6.73659221 2.96310496 2.4285785  5.41550548\n",
      " 5.63717705 5.96714243 3.17590874 3.7871263  3.49428884 4.22721478\n",
      " 4.10328965 0.90515062]\n",
      "current value for loss function:  75.1105679897894 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.41716875 5.23317632 1.07570349 5.00733779 1.84335527 2.00602753\n",
      " 0.61829175 5.35811794 6.67172827 2.89824101 2.36371455 5.48036943\n",
      " 5.57231311 5.90227848 3.24077269 3.85199025 3.42942489 4.29207873\n",
      " 4.03842571 0.97001457]\n",
      "current value for loss function:  75.42751010317983 \n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.39589569 5.21190327 1.09697654 5.02861085 1.92766499 2.09033726\n",
      " 0.59701869 5.27380821 6.75603799 2.91951407 2.44802428 5.39605971\n",
      " 5.59358616 5.92355154 3.15646296 3.76768052 3.51373461 4.27080567\n",
      " 4.05969876 0.88570484]\n",
      "current value for loss function:  75.41743074009224 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33285903 5.1488666  1.16001321 5.09164752 1.86462833 2.02730059\n",
      " 0.53398202 5.33684488 6.69300132 2.98255073 2.38498761 5.45909638\n",
      " 5.65662283 5.9865882  3.21949963 3.83071719 3.45069795 4.207769\n",
      " 4.12273543 0.94874151]\n",
      "current value for loss function:  75.29882817580521 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.3875162  5.14219421 1.10535603 5.03699034 1.9192855  2.08195777\n",
      " 0.5886392  5.34351727 6.68632893 2.98922313 2.37831522 5.46576877\n",
      " 5.60196565 5.93193103 3.22617202 3.83738958 3.44402556 4.20109661\n",
      " 4.12940782 0.89408433]\n",
      "current value for loss function:  75.19864259488747 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.32618663 5.20352377 1.1666856  5.09831991 1.85795594 2.0206282\n",
      " 0.52730963 5.2821877  6.7476585  2.92789356 2.43964479 5.4044392\n",
      " 5.66329522 5.99326059 3.16484245 3.77606001 3.50535512 4.26242618\n",
      " 4.06807825 0.9554139 ]\n",
      "current value for loss function:  75.45851406399998 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.34328343 5.18642698 1.14958881 5.02149255 1.87505273 2.03772499\n",
      " 0.60413699 5.35901506 6.67083114 3.00472091 2.36281743 5.42153599\n",
      " 5.58646787 5.9761638  3.24166981 3.7931568  3.42852777 4.24532939\n",
      " 4.08517504 0.87858655]\n",
      "current value for loss function:  75.27467081965163 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.40301399 5.12669642 1.08985825 5.08122312 1.93478329 2.09745555\n",
      " 0.54440642 5.29928449 6.73056171 2.94499035 2.422548   5.48126655\n",
      " 5.64619843 5.91643324 3.18193924 3.85288737 3.48825833 4.18559882\n",
      " 4.14490561 0.93831711]\n",
      "current value for loss function:  75.21622232253179 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.34765833 5.18205208 1.14521391 5.08409663 1.87942763 2.04209989\n",
      " 0.59976208 5.29641098 6.73343522 2.94211684 2.42542151 5.48414007\n",
      " 5.59084277 5.91355973 3.23729491 3.79753171 3.49113185 4.24095449\n",
      " 4.08954995 0.94119062]\n",
      "current value for loss function:  75.46784038829678 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.4058875  5.12382291 1.08698474 5.02586746 1.9376568  2.10032906\n",
      " 0.54153291 5.35464016 6.67520605 3.00034601 2.36719234 5.42591089\n",
      " 5.64907194 5.9717889  3.17906573 3.85576088 3.43290267 4.18272531\n",
      " 4.14777912 0.88296145]\n",
      "current value for loss function:  75.2218822301198 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36345038 5.10944377 1.12942185 5.06830457 1.89521968 2.05789195\n",
      " 0.58397003 5.3690193  6.6608269  2.95790889 2.35281319 5.41153175\n",
      " 5.60663483 5.98616805 3.22150285 3.81332376 3.47533979 4.16834617\n",
      " 4.105342   0.86858231]\n",
      "current value for loss function:  75.29541013259711 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.42026664 5.16626003 1.07260559 5.01148831 1.95203594 2.11470821\n",
      " 0.52715377 5.31220304 6.71764316 3.01472515 2.40962945 5.46834801\n",
      " 5.66345109 5.92935178 3.16468659 3.87014002 3.41852353 4.22516243\n",
      " 4.16215826 0.92539857]\n",
      "current value for loss function:  75.23373145878483 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36785999 5.16933719 1.06952843 5.06389497 1.95511311 2.11778537\n",
      " 0.5240766  5.3646097  6.72072033 2.9623185  2.41270662 5.47142517\n",
      " 5.66652825 5.98175844 3.16160943 3.81773337 3.41544636 4.17275577\n",
      " 4.16523543 0.87299191]\n",
      "current value for loss function:  75.23747556271765 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.42334381 5.11385337 1.12501225 5.00841115 1.89962929 2.06230155\n",
      " 0.57956042 5.30912587 6.66523651 3.01780232 2.3572228  5.41594135\n",
      " 5.61104443 5.92627462 3.21709325 3.87321719 3.47093019 4.2282396\n",
      " 4.10975161 0.92847573]\n",
      "current value for loss function:  75.33016342699435 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36292103 5.12005134 1.11881428 5.01460911 1.90582725 2.06849951\n",
      " 0.57336246 5.31532384 6.72565929 2.95737954 2.36342076 5.42213932\n",
      " 5.6172424  5.9866974  3.15667047 3.86701922 3.41050741 4.16781682\n",
      " 4.11594957 0.92227777]\n",
      "current value for loss function:  75.13384279472189 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.41714584 5.17427615 1.06458947 5.06883393 1.96005207 2.12272433\n",
      " 0.51913764 5.36954865 6.67143447 3.01160435 2.41764558 5.47636413\n",
      " 5.67146721 5.93247259 3.21089528 3.81279441 3.46473222 4.22204163\n",
      " 4.17017439 0.86805295]\n",
      "current value for loss function:  75.23621344417182 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.35742695 5.11455726 1.12430836 5.06214805 1.90033318 2.11603845\n",
      " 0.52582352 5.30982976 6.73115336 3.00491847 2.4109597  5.41664524\n",
      " 5.61174832 5.93915847 3.2042094  3.8725133  3.45804634 4.21535575\n",
      " 4.1104555  0.92777184]\n",
      "current value for loss function:  75.29963234665297 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.41045996 5.16759027 1.07127535 5.00911504 1.95336619 2.06300544\n",
      " 0.57885653 5.36286277 6.67812035 2.95188546 2.35792669 5.46967825\n",
      " 5.66478133 5.99219147 3.15117639 3.81948029 3.40501333 4.16232274\n",
      " 4.16348851 0.87473883]\n",
      "current value for loss function:  75.15680097020952 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36640844 5.17544163 1.06342399 5.05316657 1.96121754 2.10705697\n",
      " 0.53480501 5.37071413 6.670269   2.94403411 2.35007533 5.42562672\n",
      " 5.6207298  6.00004283 3.14332504 3.86353182 3.39716197 4.20637427\n",
      " 4.11943698 0.91879036]\n",
      "current value for loss function:  75.2500607722271 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.41831132 5.12353874 1.11532688 5.00126368 1.90931466 2.05515408\n",
      " 0.58670789 5.31881125 6.72217188 2.99593699 2.40197821 5.47752961\n",
      " 5.67263269 5.94813995 3.19522792 3.81162893 3.44906486 4.15447138\n",
      " 4.17133986 0.86688747]\n",
      "current value for loss function:  75.2103685770883 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36926251 5.12175803 1.11710759 4.99948297 1.95836347 2.10420289\n",
      " 0.53765908 5.36786005 6.72395259 2.94688818 2.40375892 5.4284808\n",
      " 5.62358388 5.94635924 3.19700863 3.80984822 3.45084557 4.20352019\n",
      " 4.12229105 0.86510676]\n",
      "current value for loss function:  75.15935939596831 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.42009203 5.17258755 1.06627807 5.05031249 1.90753395 2.05337337\n",
      " 0.5884886  5.31703053 6.67312307 2.9977177  2.3529294  5.47931032\n",
      " 5.6744134  5.99718876 3.14617911 3.86067774 3.40001605 4.15269067\n",
      " 4.17312057 0.91593628]\n",
      "current value for loss function:  75.37295481800746 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.35741362 5.10990914 1.12895648 4.98763408 1.97021236 2.06624326\n",
      " 0.57561871 5.32990043 6.68599296 2.98484781 2.36579929 5.46644043\n",
      " 5.66154351 5.98431887 3.20885752 3.79799933 3.46269446 4.21536908\n",
      " 4.16025068 0.85325788]\n",
      "current value for loss function:  75.1662994671966 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.40722214 5.15971766 1.07914796 5.0374426  1.92040384 2.11605178\n",
      " 0.52581019 5.37970894 6.73580148 2.93503929 2.41560781 5.41663191\n",
      " 5.61173499 5.93451035 3.159049   3.84780785 3.41288594 4.16556056\n",
      " 4.11044217 0.90306639]\n",
      "current value for loss function:  75.17983604828247 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.40595936 5.15845488 1.12924668 5.03617982 1.97050256 2.06595306\n",
      " 0.57590891 5.32961022 6.73453869 2.93630208 2.41434503 5.46673063\n",
      " 5.61299777 5.98460907 3.20914772 3.79770913 3.46298466 4.16682335\n",
      " 4.11170495 0.85296767]\n",
      "current value for loss function:  75.40022974232937 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.35712342 5.10961894 1.08041074 4.98734388 1.92166662 2.114789\n",
      " 0.52707298 5.37844616 6.68570276 2.98513801 2.36550909 5.4178947\n",
      " 5.66183371 5.93577313 3.16031179 3.84654507 3.41414872 4.21565928\n",
      " 4.16054088 0.90180361]\n",
      "current value for loss function:  75.20178023233107 \n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.39420773 5.14670325 1.11749505 5.02442819 1.91084271 2.12561291\n",
      " 0.56415729 5.38927007 6.72278707 2.9480537  2.35468518 5.40707079\n",
      " 5.6247494  5.97285744 3.14948788 3.80946075 3.45123303 4.17857497\n",
      " 4.12345657 0.8647193 ]\n",
      "current value for loss function:  75.21255151548019 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.34629951 5.09879503 1.06958683 4.97651997 1.95875093 2.07770468\n",
      " 0.51624907 5.34136185 6.67487885 2.99596192 2.4025934  5.45497901\n",
      " 5.67265762 5.92494922 3.1973961  3.85736898 3.40332481 4.22648319\n",
      " 4.17136479 0.91262752]\n",
      "current value for loss function:  75.21140962427326 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.39370029 5.09917363 1.11698761 5.02392075 1.91135015 2.07808329\n",
      " 0.51662767 5.34174045 6.67525745 2.94856114 2.4022148  5.40757823\n",
      " 5.62525684 5.97235    3.14999532 3.85699037 3.40370342 4.17908241\n",
      " 4.17098619 0.86522674]\n",
      "current value for loss function:  75.21808111661544 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.34667811 5.14619581 1.06996544 4.97689857 1.95837233 2.12510546\n",
      " 0.56364985 5.38876263 6.72227963 2.99558332 2.35519262 5.4546004\n",
      " 5.67227901 5.92532783 3.19701749 3.8099682  3.45072559 4.22610459\n",
      " 4.12396401 0.91224892]\n",
      "current value for loss function:  75.0067698211833 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.3814507  5.15759814 1.05856311 5.01167116 1.92359975 2.09033288\n",
      " 0.52887727 5.35399005 6.68750705 2.96081074 2.38996521 5.41982782\n",
      " 5.68368134 5.9139255  3.20841982 3.79856587 3.46212792 4.23750691\n",
      " 4.11256169 0.92365124]\n",
      "current value for loss function:  75.18474169903389 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33527579 5.11142323 1.10473802 4.96549625 1.96977466 2.13650779\n",
      " 0.57505217 5.40016495 6.73368195 3.00698564 2.3437903  5.46600273\n",
      " 5.63750643 5.96010041 3.16224491 3.84474078 3.41595301 4.19133201\n",
      " 4.1587366  0.87747633]\n",
      "current value for loss function:  75.1659370112084 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.38000091 5.11078456 1.10537669 4.96485758 1.92504954 2.13714645\n",
      " 0.53032706 5.35543984 6.68895684 2.96226053 2.38851542 5.46664139\n",
      " 5.68223155 5.91537529 3.16160624 3.80001566 3.46067813 4.23605712\n",
      " 4.15937526 0.92220145]\n",
      "current value for loss function:  75.17315215596518 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33463712 5.15614835 1.0600129  5.01022137 1.97041332 2.09178267\n",
      " 0.57569084 5.40080362 6.73432062 3.00762431 2.34315163 5.42127761\n",
      " 5.63686777 5.96073907 3.20697003 3.84537944 3.41531434 4.19069334\n",
      " 4.11401148 0.87683767]\n",
      "current value for loss function:  75.12340565604482 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37687069 5.15850119 1.10224647 5.01257421 1.97276617 2.08942982\n",
      " 0.53345727 5.40315647 6.73667347 2.96539074 2.34079879 5.41892476\n",
      " 5.67910133 5.96309192 3.20932287 3.80314588 3.45754791 4.18834049\n",
      " 4.15624505 0.91907123]\n",
      "current value for loss function:  75.15805092988315 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33228428 5.11391478 1.05766005 4.9679878  1.92817976 2.13401624\n",
      " 0.57804369 5.35857005 6.69208705 3.00997716 2.3853852  5.46351118\n",
      " 5.63451492 5.91850551 3.16473646 3.84773229 3.4129615  4.23292691\n",
      " 4.11165863 0.87448482]\n",
      "current value for loss function:  75.09287239559026 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37293231 5.11072219 1.05446747 4.96479521 1.92498717 2.0933682\n",
      " 0.53739565 5.35537746 6.68889447 2.96932912 2.38857779 5.46670377\n",
      " 5.67516296 5.95915355 3.2053845  3.85092488 3.45360954 4.23611949\n",
      " 4.15230667 0.87129223]\n",
      "current value for loss function:  75.10609544963975 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.32909169 5.15456282 1.09830809 5.00863584 1.96882779 2.13720883\n",
      " 0.58123627 5.39921809 6.73273509 3.01316974 2.34473716 5.42286314\n",
      " 5.63132233 5.91531292 3.16154387 3.80708425 3.40976891 4.19227887\n",
      " 4.10846605 0.91513286]\n",
      "current value for loss function:  75.18315972139344 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37675952 5.15001941 1.05064026 5.00409243 1.92115996 2.089541\n",
      " 0.57669287 5.39467469 6.68506726 2.96550191 2.34928057 5.42740654\n",
      " 5.67899016 5.96298075 3.16608728 3.85475208 3.45743674 4.2399467\n",
      " 4.11300945 0.91058945]\n",
      "current value for loss function:  75.22447423949112 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33363509 5.10689499 1.09376469 4.96096801 1.96428439 2.13266542\n",
      " 0.53356844 5.35155026 6.72819169 3.00862634 2.39240499 5.47053097\n",
      " 5.63586574 5.91985632 3.2092117  3.81162766 3.41431231 4.19682227\n",
      " 4.15613388 0.86746503]\n",
      "current value for loss function:  75.1732577529002 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37365334 5.10447724 1.09618244 4.95855026 1.92426614 2.09264718\n",
      " 0.57358669 5.39156851 6.68817344 3.01104409 2.39482274 5.43051272\n",
      " 5.67588398 5.91743858 3.16919346 3.80920991 3.45433056 4.19440452\n",
      " 4.11611563 0.90748327]\n",
      "current value for loss function:  75.1109615969585 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33121735 5.14691323 1.05374644 5.00098625 1.96670214 2.13508317\n",
      " 0.53115069 5.34913251 6.73060944 2.96860809 2.35238675 5.47294872\n",
      " 5.63344799 5.95987457 3.21162945 3.8516459  3.41189457 4.23684052\n",
      " 4.15855162 0.86504728]\n",
      "current value for loss function:  75.21396788904462 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37883884 5.09929174 1.10136793 4.95336476 1.91908065 2.12923534\n",
      " 0.57877219 5.396754   6.7247616  3.01622958 2.35823458 5.46710088\n",
      " 5.68106948 5.95402674 3.20578162 3.80402441 3.4177424  4.18921903\n",
      " 4.15270379 0.91266877]\n",
      "current value for loss function:  75.1731412483857 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33706518 5.1410654  1.05959428 4.99513842 1.9608543  2.08746168\n",
      " 0.53699853 5.35498035 6.68298795 2.97445593 2.40000824 5.42532723\n",
      " 5.63929582 5.91225308 3.16400796 3.84579807 3.45951606 4.23099268\n",
      " 4.11093013 0.87089512]\n",
      "current value for loss function:  75.16767457481703 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33709326 5.09990144 1.05962236 4.95397446 1.96082622 2.08748976\n",
      " 0.57816249 5.35500843 6.68301603 2.97448401 2.39998016 5.42535531\n",
      " 5.6393239  5.95341704 3.20517192 3.84576999 3.4183521  4.18982873\n",
      " 4.15209409 0.91205907]\n",
      "current value for loss function:  75.09345216645428 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37822914 5.14103732 1.10075824 4.99511034 1.91969034 2.12862564\n",
      " 0.53702661 5.39614431 6.7241519  3.01561989 2.35884428 5.46649118\n",
      " 5.68045978 5.91228116 3.16403604 3.80463411 3.45948798 4.2309646\n",
      " 4.11095821 0.8709232 ]\n",
      "current value for loss function:  75.27617178459018 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.32774437 5.09055255 1.05027347 4.94462557 1.97017511 2.11866211\n",
      " 0.58751138 5.34565954 6.67366714 2.96513512 2.40932905 5.45652766\n",
      " 5.67049626 5.92224469 3.17399956 3.81459764 3.40900321 4.18047984\n",
      " 4.16144298 0.88088672]\n",
      "current value for loss function:  75.23163360044583 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36826561 5.13107379 1.09079471 4.98514681 1.92965387 2.07814087\n",
      " 0.54699013 5.38618078 6.71418838 3.00565636 2.3688078  5.41600642\n",
      " 5.62997501 5.96276593 3.21452081 3.85511888 3.44952445 4.22100108\n",
      " 4.12092174 0.92140796]\n",
      "current value for loss function:  75.17880363945697 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.33081473 5.09362291 1.09327227 4.98762437 1.96710476 2.11559176\n",
      " 0.58444102 5.38865834 6.67673749 2.96820547 2.36633025 5.41352886\n",
      " 5.62749746 5.96524348 3.17706992 3.81766799 3.45200201 4.18355019\n",
      " 4.15837262 0.88395708]\n",
      "current value for loss function:  75.07723188669954 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.37074317 5.13355135 1.05334382 4.94769593 1.92717631 2.07566331\n",
      " 0.54451258 5.34872989 6.71666594 3.00813392 2.40625869 5.4534573\n",
      " 5.6674259  5.92531504 3.21699836 3.85759644 3.41207357 4.22347864\n",
      " 4.11844418 0.92388552]\n",
      "current value for loss function:  75.21269761242932 \n",
      "\n",
      "\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36338894 5.12619712 1.06069806 4.95505016 1.93453055 2.12237382\n",
      " 0.59122309 5.3954404  6.66995542 2.96142341 2.39890446 5.40674679\n",
      " 5.62071539 5.97202555 3.20964413 3.81088592 3.4194278  4.2161244\n",
      " 4.12579841 0.91653129]\n",
      "current value for loss function:  75.06565966328391 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.32403266 5.08684084 1.10005434 4.99440644 1.97388682 2.08301755\n",
      " 0.55186681 5.35608413 6.7093117  3.00077968 2.35954818 5.44610307\n",
      " 5.66007166 5.93266928 3.17028785 3.8502422  3.45878408 4.17676812\n",
      " 4.16515469 0.87717501]\n",
      "current value for loss function:  75.12138650297017 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.36600232 5.1288105  1.05808468 4.9912404  1.93191716 2.12498721\n",
      " 0.59383647 5.35925017 6.66734204 2.95881003 2.36271422 5.40413341\n",
      " 5.65690563 5.97463893 3.21225751 3.80827254 3.41681442 4.17993416\n",
      " 4.16198865 0.91914467]\n",
      "current value for loss function:  75.06046689330827 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.3271987  5.09000688 1.0968883  4.95243678 1.97072078 2.08618358\n",
      " 0.55503285 5.39805379 6.70614566 2.99761365 2.40151784 5.44293703\n",
      " 5.61810201 5.93583531 3.17345389 3.84707616 3.45561804 4.21873778\n",
      " 4.12318503 0.88034105]\n",
      "current value for loss function:  75.0201040157725 \n",
      "\n",
      "\n",
      "Job Status: job has successfully run\n",
      "\n",
      " current value of parameters:  [1.34494382 5.107752   1.07914318 4.97210837 1.95297567 2.1039287\n",
      " 0.57277797 5.3783822  6.68840054 2.97986853 2.38184625 5.42519191\n",
      " 5.6377736  5.95358043 3.19119901 3.82933104 3.43787292 4.19906619\n",
      " 4.14285662 0.89808617]\n",
      "current value for loss function:  75.04586861688092 \n",
      "\n",
      "\n",
      "75.04586861688092 [1.34494382 5.107752   1.07914318 4.97210837 1.95297567 2.1039287\n",
      " 0.57277797 5.3783822  6.68840054 2.97986853 2.38184625 5.42519191\n",
      " 5.6377736  5.95358043 3.19119901 3.82933104 3.43787292 4.19906619\n",
      " 4.14285662 0.89808617]\n",
      "1718.912086725235\n"
     ]
    }
   ],
   "source": [
    "#initial values for parameters are chosen randomly\n",
    "theta_0 = []\n",
    "\n",
    "for i in range(0, number_parameters):\n",
    "    theta_0.append(random.uniform(0, 2*np.pi))\n",
    "theta_0 = np.array(theta_0)\n",
    "\n",
    "#In the following c0 is the firt step \"a\", c1 is the initial \"c\", c2 is the \"alpha\" parameter, c3 the \"gamma\" parameter\n",
    "#and finally c4 another parameter to control \"a\" (as like as \"alpha\" does)\n",
    "t = time.time()\n",
    "\n",
    "Optimizer = SPSA(maxiter = 1e3, save_steps = 1, last_avg = 1, c0 = 10/(number_training), c1 = 0.3, c2 = 1, c3 = 0.7, c4 = 0, \n",
    "                 skip_calibration = False)\n",
    "\n",
    "# cost_final, theta_best, cost_plus_save, cost_minus_save, theta_plus_save, theta_minus_save =  (\n",
    "#     Optimizer._optimization(cost_function,theta_0, SPSA_steps, save_steps = 1, last_avg = 3))\n",
    "\n",
    "fw = Optimizer.wrap_function(cost_function,(circuit,theta,Phi_f,W))\n",
    "\n",
    "cost_final, theta_best, cost_plus_save, cost_minus_save, theta_plus_save, theta_minus_save =  (\n",
    "    Optimizer._optimization(fw,theta_0, SPSA_steps, save_steps = 1, last_avg = 3) )\n",
    "\n",
    "print(cost_final,theta_best)\n",
    "\n",
    "elapsed = time.time() - t\n",
    "print(elapsed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load data for testing\n",
    "data loading variable-per-variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "top = 55 DY = 160 Wjets_HT = 614 VV = 142 VBF-V = 2 VVV = 4 Vg = 0 VgS = 0 Fake = 23\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#data shuffling\n",
    "data1 = shuffle(data1, random_state=1)\n",
    "data2 = shuffle(data2, random_state=1)\n",
    "\n",
    "#number of events of each background for the test\n",
    "S=load_testing(57)\n",
    "top, DY, Wjets_HT,VV,VBF_V,VVV,Vg,VgS,Fake=number_of_events(S)\n",
    "print('top =',top,'DY =', DY,'Wjets_HT =', Wjets_HT,'VV =', VV,'VBF-V =',VBF_V,'VVV =',VVV,'Vg =', Vg,'VgS =',VgS,'Fake =', Fake)\n",
    "\n",
    "#load, normalize and rescale variables\n",
    "X=load_testing(ii)\n",
    "Y=load_testing(jj)\n",
    "Z=load_testing(kk)\n",
    "A=load_testing(ll)\n",
    "B=load_testing(mm)\n",
    "\n",
    "X,X1,X2=rescaling(X,ri)\n",
    "Y,Y1,Y2=rescaling(Y,rj)\n",
    "Z,Z1,Z2=rescaling(Z,rk)\n",
    "A,A1,A2=rescaling(A,rl)\n",
    "B,B1,B2=rescaling(B,rm)\n",
    "\n",
    "\n",
    "#TESTING SET VISUALIZATION\n",
    "if plot_data == 1:\n",
    "    %matplotlib inline\n",
    "    fig4 = plt.figure(figsize = (10,10)) \n",
    "    ax = plt.axes(projection='3d')\n",
    "    ax.plot3D(X1,Y1,Z1,'ro',markersize = 0.5)\n",
    "    ax.plot3D(X2,Y2,Z2,'bo',markersize = 0.5)\n",
    "    ax.set_xlabel('x')   \n",
    "    ax.set_ylabel('y')   \n",
    "    ax.set_zlabel('z')  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing for testing\n",
    "division of the initial vector in smaller vectors in order to fit \"max_circuits_supported\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = int(len(X)/max_circuits_supported)\n",
    "\n",
    "v = np.zeros((N, max_circuits_supported))\n",
    "for i in range(0,N):\n",
    "    for j in range(0,max_circuits_supported):\n",
    "        v[i][j] = X[j+i*max_circuits_supported]\n",
    "        \n",
    "remainder = len(X)%max_circuits_supported     \n",
    "v_last = np.zeros(remainder)\n",
    "for j in range(0,remainder):\n",
    "    v_last[j] = X[j+N*max_circuits_supported]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "testing set mapping function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "Phi_f = np.zeros((len(X), 2*number_var))\n",
    "for i in range(0,len(X)):\n",
    "    for j in range(0, 2*number_var):\n",
    "        Phi_f[i][j] = Phi_function(X[i],Y[i],Z[i],A[i],B[i])[j]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "traing set labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "f_l = []\n",
    "for i in range(0,len(X)):\n",
    "    f_l.append(f_label(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing & AUC"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ROC production"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Job Status: job has successfully run\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline  \n",
    "if plot_AUC_image == 1:\n",
    "    fig2 = plt.figure(figsize = (10,10)) \n",
    "    plt.ylim((0,1))\n",
    "    plt.xlim((0,1))\n",
    "\n",
    "counts = training_set(theta_best,circuit,theta,Phi_f)\n",
    "\n",
    "index_sorted = []\n",
    "classification = []\n",
    "for i in range(0,len(X)):\n",
    "    classification.append(((c_e_ii+c_e_jj)*f_measuration(counts[i])[0]+(c_e_kk+c_e_ll)*f_measuration(counts[i])[2])/(c_e_ii+c_e_jj+c_e_kk+c_e_ll)) \n",
    "\n",
    "sort_index = np.argsort(classification)\n",
    "\n",
    "Classification = []\n",
    "Labelling = []\n",
    "for i in range(0,len(X)):\n",
    "    Classification.append(((c_e_ii+c_e_jj)*f_measuration(counts[sort_index[i]])[0]+(c_e_kk+c_e_ll)*f_measuration(counts[sort_index[i]])[2])/(c_e_ii+c_e_jj+c_e_kk+c_e_ll))  \n",
    "    Labelling.append((sort_index[i]+1)%2)\n",
    "\n",
    "treshold = np.linspace(0,1,2000)\n",
    "False_positive_rate = []\n",
    "True_positive_rate = []\n",
    "\n",
    "for k in range(0,len(treshold)):\n",
    "    C = Classification > treshold[k]\n",
    "    false_negatives = sum((Labelling - C) == np.int_(np.ones(len(X))))\n",
    "    false_positives = sum(np.array(Labelling - C) ==np.int_(-np.ones(len(X)))) \n",
    "    true_positives = sum(Labelling) - false_negatives \n",
    "    true_negatives = sum((Labelling) == np.int_(np.zeros(len(X)))) - false_positives\n",
    "\n",
    "    False_positive_rate.append(false_positives/(false_positives+true_negatives+0.000001))\n",
    "    True_positive_rate.append(true_positives/(true_positives+false_negatives+0.000001))\n",
    "    if plot_AUC_image == 1:\n",
    "        plt.plot(False_positive_rate[k],True_positive_rate[k],'ro',label = \"ROC\", markersize=3)\n",
    "        \n",
    "if plot_AUC_image == 1:    \n",
    "    plt.plot(treshold,treshold,'b', markersize=3)    \n",
    "    plt.xlabel('FPR')\n",
    "    plt.ylabel('TPR')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### AUC evaluation\n",
    "(should be improved with Simpson rule)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6538054986923891\n"
     ]
    }
   ],
   "source": [
    "def sorter(x,y):\n",
    "    index = np.zeros(len(x))\n",
    "    for k in range(0,len(x)):\n",
    "        min = x[k]\n",
    "        index[k] = k\n",
    "        for i in range(k,len(x)):\n",
    "            if x[i] < min:\n",
    "                index[k] = i\n",
    "        buffer = x[k] \n",
    "        x[k] = x[int(index[k])]\n",
    "        x[int(index[k])] = buffer\n",
    "        buffer = y[k] \n",
    "        y[k] = y[int(index[k])]\n",
    "        y[int(index[k])] = buffer\n",
    "    return x,y\n",
    "    \n",
    "False_positive_rate, True_positive_rate = sorter(False_positive_rate, True_positive_rate)\n",
    "\n",
    "AUC = 0\n",
    "for k in range(0,len(False_positive_rate)-1):\n",
    "    AUC += (True_positive_rate[k]+True_positive_rate[k+1])*(False_positive_rate[k+1]-False_positive_rate[k])/2\n",
    "\n",
    "print(AUC)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Simpson rule"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6537763320257811\n"
     ]
    }
   ],
   "source": [
    "AUC2 = 0\n",
    "for k in range(0,len(True_positive_rate)-2,2):\n",
    "    AUC2+=0.5*(False_positive_rate[k+2]-False_positive_rate[k])/3*(True_positive_rate[k]+4*True_positive_rate[k+1]+True_positive_rate[k+2])\n",
    "print(AUC2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Resulting visualzation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x720 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline  \n",
    "fig3 = plt.figure(figsize = (10,10)) \n",
    "ax = plt.axes(projection='3d')\n",
    "\n",
    "classificator = []\n",
    "f_m = []\n",
    "for i in range(0,len(X)):\n",
    "    f_m.append(((c_e_ii+c_e_jj)*f_measuration(counts[i])[0]+(c_e_kk+c_e_ll)*f_measuration(counts[i])[2])/(c_e_ii+c_e_jj+c_e_kk+c_e_ll))\n",
    "\n",
    "Min = min(f_m)\n",
    "Max = max(f_m)\n",
    "delta = Max - Min\n",
    "    \n",
    "for i in range(0,len(X)):\n",
    "    x = [X[i]]\n",
    "    y = [Y[i]]\n",
    "    z = [Z[i]]\n",
    "    ax.plot3D(x,y,z,'o',color = [np.clip((((c_e_ii+c_e_jj)*f_measuration(counts[i])[0]+(c_e_kk+c_e_ll)*f_measuration(counts[sort_index[i]])[2])/(c_e_ii+c_e_jj+c_e_kk+c_e_ll)-Min)/delta,0,1), 0, np.clip(1-(((c_e_ii+c_e_jj)*f_measuration(counts[i])[0]+(c_e_kk+c_e_ll)*f_measuration(counts[sort_index[i]])[2])/(c_e_ii+c_e_jj+c_e_kk+c_e_ll)-Min)/delta,0,1)] ,markersize = 0.5)\n",
    "\n",
    "if sound == 1:\n",
    "    import winsound\n",
    "    frequency = 1000  # Set Frequency To 2500 Hertz\n",
    "    duration = 1000 # Set Duration To 1000 ms == 1 second\n",
    "    winsound.Beep(frequency, duration)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Saving results on file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "tot_time = time.time() - t_start\n",
    "\n",
    "def sec_to_hour(seconds: float):\n",
    "    hour = seconds/3600\n",
    "    min = (hour - int(hour))*60\n",
    "    sec = (min -int(min))*60\n",
    "    hour = int(hour)\n",
    "    min = int(min)\n",
    "    time = (\"{} h, {} min and {:.0f} sec\".format(hour,min,sec))\n",
    "    return time\n",
    "\n",
    "if save_results == 1:  \n",
    "    ora=time.localtime()\n",
    "    ora=str(ora.tm_year)+'_'+str(ora.tm_mon)+'_'+str(ora.tm_mday)+'_'+str(ora.tm_hour)+'_'+str(ora.tm_min)+'_'+str(ora.tm_sec)\n",
    "    if quantum_hw==0:\n",
    "        nome_file='simulator_record_'+ora+'.txt'\n",
    "    else:\n",
    "        nome_file='real_device_'+bknd+'_record_'+ora+'.txt'\n",
    "    file1 = open(nome_file,\"a\")\n",
    "    FP = str(False_positive_rate).strip('[]')\n",
    "    TP = str(True_positive_rate).strip('[]')\n",
    "    FM = str(f_m).strip('[]')\n",
    "    TB = str(theta_best).strip('[]')\n",
    "\n",
    "    file1.write(\"BEGIN ATTEMPT \\n\\n\")\n",
    "    file1.write(\"number_training = %d \\n\" %number_training)\n",
    "    file1.write(\"number_testing  = %d \\n\" %number_testing)\n",
    "    file1.write(\"SPSA_steps      = %d \\n\" %SPSA_steps)\n",
    "    file1.write(\"number_var      = %d \\n\" %number_var)\n",
    "    file1.write(\"variables       = %d, %d, %d, %d, %d\\n\" % (ii, jj, kk, ll, mm))\n",
    "    file1.write(\"AUC             = %f \\n\" %AUC)\n",
    "    file1.write(\"Training time(s)= %d \\n\" %elapsed) \n",
    "    file1.write(\"Total time (s)  = %d \" %tot_time + \"(\" + sec_to_hour(tot_time) + \")\\n\")\n",
    "    file1.write(\"Loss value      = %f \\n\" %cost_final)\n",
    "    file1.write(\"\\nParameters: \\n\"+TB+\"\\n\")\n",
    "    file1.write(\"\\nFalse Positives: \\n\\n\"+FP+ \"\\n\\n\"+\"True Positives: \\n\\n\"+TP+ \"\\n\\n\"+\"f_measuration: \\n\\n\"+FM + \"\\n\\n\\n\\n\\n\")\n",
    "    file1.close() \n",
    "    \n",
    "    fig2.savefig('AUC_'+ora+'.png')\n",
    "    fig.savefig('Loss_'+ora+'.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}