minimization_precision_multiplot.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "minimization_precision_multiplot.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "NUblw8y3ghWE",
        "Hl3zVIiYL5vj",
        "U5hzuNwShjue"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ogTwNBb9gWAZ",
        "colab_type": "text"
      },
      "source": [
        "# ***THIS NOTEBOOK PLOTS THE PRECISION OF THE MINIMIZATION WITH RESPECT TO THE CPU TIME***\n",
        "---\n",
        "---\n",
        "---\n",
        "---\n",
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NUblw8y3ghWE",
        "colab_type": "text"
      },
      "source": [
        "# IMPORTS AND GLOBAL VARIABLES"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kjdqqlGZgnjG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "f36de8ca-30e7-40d3-fe92-56cb7aa18369"
      },
      "source": [
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import math\n",
        "import keras\n",
        "from keras import layers, models, optimizers\n",
        "from keras.callbacks import History\n",
        "from scipy import integrate\n",
        "from scipy import interpolate\n",
        "from scipy.stats import norm\n",
        "import time\n",
        "\n",
        "hbar = 1\n",
        "omega = 1\n",
        "m = 1\n",
        "a = -5.\n",
        "b = 5."
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Using TensorFlow backend.\n"
          ],
          "name": "stderr"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hl3zVIiYL5vj",
        "colab_type": "text"
      },
      "source": [
        "# DATA GENERATION"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6g-q6clnL_2U",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 69
        },
        "outputId": "e566f852-a2c5-46f6-e6f9-3de1fdd29666"
      },
      "source": [
        "#################\n",
        "#SECTION : FUNCTION DEFINITION\n",
        "#################\n",
        "\n",
        "#W.F. stands for \"wave function\"\n",
        "\n",
        "def energy_compute (abscissa,psi):\n",
        "  #interpolations\n",
        "  tck_true = interpolate.splrep(abscissa, psi, k=3, s=0)                                         #W.F.\n",
        "  tck_true_carre = interpolate.splrep(abscissa, psi*psi, k=3, s=0)                               #W.F. squared\n",
        "  tck_true_x = interpolate.splrep(abscissa, abscissa*abscissa*psi*psi, k=3, s=0)                 #W.F. squared*x^2\n",
        "  der_true = interpolate.splev(abscissa, tck_true, der=1)                                        #W.F. derivative\n",
        "  tck_true_der = interpolate.splrep(abscissa,der_true*der_true, k=3,s=0)                         #W.F. derivative spline 1000\n",
        "  int_true_carre = interpolate.splint(a,b,tck_true_carre)                                        #integral of W.F. squared\n",
        "  int_true_x = interpolate.splint(a,b,tck_true_x)                                                #integral of W.F. squared*x^2 (<x^2>)\n",
        "  int_true_der = interpolate.splint(a,b,tck_true_der)                                            #integral of derivative squared\n",
        "  #energy\n",
        "  Energy = ((-pow(hbar,2)/(2*m))*(psi[-1]*der_true[-1]-psi[0]*der_true[0] - int_true_der) + 0.5*m*omega*int_true_x ) / int_true_carre\n",
        "  return Energy\n",
        "\n",
        "def normalization (abscissa,psi):\n",
        "  tck_true_carre = interpolate.splrep(abscissa, psi*psi, s=0)                       #W.F. squared\n",
        "  int_true_carre = interpolate.splint(a,b,tck_true_carre)                           #integral of W.F. squared\n",
        "  psi = psi*pow(1/int_true_carre,1/2)                                               #new normalized function\n",
        "  return psi\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#################\n",
        "#SECTION : OPENING FILES         (couche = layer, temps = time)\n",
        "#################\n",
        "file1 = open(\"energie_X_couche_500params.txt\", \"w\")\n",
        "file2 = open(\"temps_X_couche_500params.txt\", \"w\")\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#################\n",
        "#SECTION : MINIMIZATION - CONVERGENCE, LOSS, TIME, ITERATIONS STUDY\n",
        "#################\n",
        "\n",
        "pts = 100                                 #Number of points on X and Y axis\n",
        "linx = np.linspace(a,b,pts)               #X axis\n",
        "runs = 30                                 #how many runs we want to compute the mean values\n",
        "fits = 10000                              #how many iterations we want in each run\n",
        "\n",
        "arr_energy = np.zeros((runs,fits))       #energy array\n",
        "arr_time = np.zeros((runs,fits))         #time array\n",
        "\n",
        "#LOOP TO STUDY THE LOSS OVER THE NUMBER OF RUNS WE CHOSE\n",
        "#Début de la boucle de calcul/écriture\n",
        "for k in range(0,runs):\n",
        "  print('run n°',k+1)\n",
        "\n",
        "  #constant wave function (first target)\n",
        "  wave = np.ones_like(linx)\n",
        "  #normalized\n",
        "  wave = normalization (linx,wave)\n",
        "  #its energy\n",
        "  energy_wave = energy_compute(linx,wave)\n",
        "\n",
        "  #setup for measurement of time\n",
        "  time1 = time.clock()\n",
        "\n",
        "  #INITIALIZATION OF NEURAL NETWORK\n",
        "  model = models.Sequential([\n",
        "    layers.Dense(100, input_shape=(1,), activation='relu'),\n",
        "    layers.Dense(100, input_shape=(1,), activation='relu'),\n",
        "    layers.Dense(100, input_shape=(1,), activation='relu'),\n",
        "    layers.Dense(100, input_shape=(1,), activation='relu'),\n",
        "    layers.Dense(1), # no activation -> linear function of the input\n",
        "  ])\n",
        "  opt = optimizers.Adam(learning_rate=0.001)\n",
        "  model.compile(loss='mse',optimizer=opt)\n",
        "\n",
        "\n",
        "\n",
        "  #BEGINING OF MINIMIZATION\n",
        "  for i in range(0,fits):\n",
        "    \n",
        "    #one training\n",
        "    model.fit(linx,wave,epochs=1,batch_size=50,verbose=0)\n",
        "    #prediction after one training\n",
        "    predictions = model.predict(linx)\n",
        "\n",
        "    #prediction is made positive, symetric and normalized\n",
        "    preds = np.abs(predictions.reshape(-1))\n",
        "    for j in range(0,pts):\n",
        "      preds[j] = (preds[j]+preds[pts-1-j])/2\n",
        "      preds[pts-1-j] = preds[j]\n",
        "    preds = normalization(linx,preds)\n",
        "    #energy of prediction\n",
        "    energy_preds = energy_compute(linx,preds)\n",
        "\n",
        "    #we choose the function with the lowest energy\n",
        "    if (energy_preds < energy_wave):\n",
        "      wave = preds\n",
        "      energy_wave = energy_preds\n",
        "\n",
        "    #writing the energy of the current wave function\n",
        "    arr_energy[k,i] = energy_wave\n",
        "    #writing the time\n",
        "    arr_time[k,i] = time.clock() - time1\n",
        "\n",
        "\n",
        "  #clear of the network\n",
        "  keras.backend.clear_session()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#################\n",
        "#END OF DATA GENERATION\n",
        "#################\n",
        "\n",
        "#writing data in files\n",
        "np.savetxt(file1, arr_energy, fmt='%.18e', delimiter=' ', newline='\\n')\n",
        "np.savetxt(file2, arr_time, fmt='%.18e', delimiter=' ', newline='\\n')\n",
        "file1.close()\n",
        "file2.close()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "run n° 1\n",
            "run n° 2\n",
            "run n° 3\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "U5hzuNwShjue",
        "colab_type": "text"
      },
      "source": [
        "# DRAWING THE 8 PLOTS"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RcBFjf6vOFoG",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "outputId": "b4f2d7dd-a23f-40fd-d48c-bb576a7c26f9"
      },
      "source": [
        "#multiplot\n",
        "fig, axs = plt.subplots(4, 2,figsize=(7, 10))\n",
        "\n",
        "#number of runs\n",
        "runs = 30\n",
        "\n",
        "\n",
        "#PLOT 1 LAYER\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_1couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_1couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_1couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_1couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_1couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_1couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[0, 0].set_yscale('log')\n",
        "#DOTTED LINES\n",
        "axs[0, 0].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[0, 0].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[0, 0].errorbar(temps3_moy[0:5000:1],E3_moy[0:5000:1],c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS WITH ERROR BARS\n",
        "axs[0, 0].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[0, 0].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[0, 0].errorbar(temps3_moy[498:5000:1000],E3_moy[498:5000:1000], xerr=temps3_error[498:5000:1000], yerr = E3_error[498:5000:1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[0, 0].set_ylabel('Energy - 0.5')\n",
        "axs[0, 0].set_ylim(pow(10,-5), 0)\n",
        "axs[0, 0].set_xlim(0, 100)\n",
        "axs[0, 0].legend(loc='upper right',title = '1 layer')\n",
        "axs[0, 0].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#PLOT 2 LAYERZ\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_2couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_2couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_2couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_2couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_2couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_2couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[0, 1].set_yscale('log')\n",
        "#LINES\n",
        "axs[0, 1].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[0, 1].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[0, 1].errorbar(temps3_moy,E3_moy,c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS\n",
        "axs[0, 1].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[0, 1].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[0, 1].errorbar(temps3_moy[498::1000],E3_moy[498::1000], xerr=temps3_error[498::1000], yerr = E3_error[498::1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[0, 1].set_ylim(pow(10,-5), 0)\n",
        "axs[0, 1].set_xlim(0, 100)\n",
        "axs[0, 1].legend(title = '2 layers')\n",
        "axs[0, 1].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#PLOT 3 LAYERZ\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_3couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_3couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_3couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_3couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_3couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_3couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[1, 0].set_yscale('log')\n",
        "#LINES\n",
        "axs[1, 0].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[1, 0].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[1, 0].errorbar(temps3_moy,E3_moy,c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS\n",
        "axs[1, 0].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[1, 0].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[1, 0].errorbar(temps3_moy[498::1000],E3_moy[498::1000], xerr=temps3_error[498::1000], yerr = E3_error[498::1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[1, 0].set_ylabel('Energy - 0.5')\n",
        "axs[1, 0].set_ylim(pow(10,-5), 0)\n",
        "axs[1, 0].set_xlim(0, 100)\n",
        "axs[1, 0].legend(title = '3 layers')\n",
        "axs[1, 0].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#PLOT 4 LAYERS\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_4couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_4couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_4couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_4couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_4couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_4couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[1, 1].set_yscale('log')\n",
        "#LINES\n",
        "axs[1, 1].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[1, 1].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[1, 1].errorbar(temps3_moy,E3_moy,c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS\n",
        "axs[1, 1].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[1, 1].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[1, 1].errorbar(temps3_moy[498::1000],E3_moy[498::1000], xerr=temps3_error[498::1000], yerr = E3_error[498::1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[1, 1].set_ylim(pow(10,-5), 0)\n",
        "axs[1, 1].set_xlim(0, 100)\n",
        "axs[1, 1].legend(title = '4 layers')\n",
        "axs[1, 1].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#PLOT 5 LAYERS\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_5couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_5couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_5couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_5couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_5couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_5couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[2, 0].set_yscale('log')\n",
        "#LINES\n",
        "axs[2, 0].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[2, 0].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[2, 0].errorbar(temps3_moy,E3_moy,c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS\n",
        "axs[2, 0].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[2, 0].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[2, 0].errorbar(temps3_moy[498::1000],E3_moy[498::1000], xerr=temps3_error[498::1000], yerr = E3_error[498::1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[2, 0].set_ylabel('Energy - 0.5')\n",
        "axs[2, 0].set_ylim(pow(10,-5), 0)\n",
        "axs[2, 0].set_xlim(0, 100)\n",
        "axs[2, 0].legend(title = '5 layers',loc='upper right')\n",
        "axs[2, 0].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#PLOT 6 LAYERS\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_6couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_6couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_6couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_6couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_6couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_6couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[2, 1].set_yscale('log')\n",
        "#LINES\n",
        "axs[2, 1].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[2, 1].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[2, 1].errorbar(temps3_moy,E3_moy,c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS\n",
        "axs[2, 1].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[2, 1].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[2, 1].errorbar(temps3_moy[498::1000],E3_moy[498::1000], xerr=temps3_error[498::1000], yerr = E3_error[498::1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[2, 1].set_ylim(pow(10,-5), 0)\n",
        "axs[2, 1].set_xlim(0, 100)\n",
        "axs[2, 1].legend(title = '6 layers',loc='upper right')\n",
        "axs[2, 1].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#plot 7 couche\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_7couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_7couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_7couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "\n",
        "\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_7couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_7couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_7couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[3, 0].set_yscale('log')\n",
        "#LINES\n",
        "axs[3, 0].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[3, 0].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[3, 0].errorbar(temps3_moy,E3_moy,c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS\n",
        "axs[3, 0].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[3, 0].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[3, 0].errorbar(temps3_moy[498::1000],E3_moy[498::1000], xerr=temps3_error[498::1000], yerr = E3_error[498::1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[3, 0].set_ylabel('Energy - 0.5')\n",
        "axs[3, 0].set_xlabel('CPU time (s)')\n",
        "axs[3, 0].set_ylim(pow(10,-5), 0)\n",
        "axs[3, 0].set_xlim(0, 100)\n",
        "axs[3, 0].legend(title = '7 layers')\n",
        "axs[3, 0].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#plot 8 couche\n",
        "#opening energy files and computing mean and standard deviation\n",
        "energie1 = np.loadtxt(\"energie_8couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "energie2 = np.loadtxt(\"energie_8couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "energie3 = np.loadtxt(\"energie_8couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "E1_error = np.std(energie1-0.5,0)\n",
        "E1_moy = np.sum(energie1-0.5,axis=0)/runs\n",
        "E2_error = np.std(energie2-0.5,0)\n",
        "E2_moy = np.sum(energie2-0.5,axis=0)/runs\n",
        "E3_error = np.std(energie3-0.5,0)\n",
        "E3_moy = np.sum(energie3-0.5,axis=0)/runs\n",
        "#opening time files and computing mean and standard deviation\n",
        "temps1 = np.loadtxt(\"temps_8couche_500params.txt\", dtype=float, delimiter=' ')\n",
        "temps2 = np.loadtxt(\"temps_8couche_5000params.txt\", dtype=float, delimiter=' ')\n",
        "temps3 = np.loadtxt(\"temps_8couche_30600params.txt\", dtype=float, delimiter=' ')\n",
        "temps1_moy = np.sum(temps1,0)/runs\n",
        "temps1_error = np.std(temps1,axis=0)\n",
        "temps2_moy = np.sum(temps2,0)/runs\n",
        "temps2_error = np.std(temps2,axis=0)\n",
        "temps3_moy = np.sum(temps3,0)/runs\n",
        "temps3_error = np.std(temps3,axis=0)\n",
        "\n",
        "#plot scale\n",
        "axs[3, 1].set_yscale('log')\n",
        "#LINES\n",
        "axs[3, 1].errorbar(temps1_moy,E1_moy,c='darkorange',linestyle=\"dotted\")\n",
        "axs[3, 1].errorbar(temps2_moy,E2_moy,c='deepskyblue',linestyle=\"dotted\")\n",
        "axs[3, 1].errorbar(temps3_moy,E3_moy,c='fuchsia',linestyle=\"dotted\")\n",
        "#MARKERS\n",
        "axs[3, 1].errorbar(temps1_moy[0::1000],E1_moy[0::1000], xerr=temps1_error[0::1000], yerr = E1_error[0::1000],marker='.',c='darkorange',linestyle=\"None\",elinewidth=1)\n",
        "axs[3, 1].errorbar(temps2_moy[249::1000],E2_moy[249::1000], xerr=temps2_error[249::1000], yerr = E2_error[249::1000],marker='.',c='deepskyblue',linestyle=\"None\",elinewidth=1)\n",
        "axs[3, 1].errorbar(temps3_moy[498::1000],E3_moy[498::1000], xerr=temps3_error[498::1000], yerr = E3_error[498::1000],marker='.',c='fuchsia',linestyle=\"None\",elinewidth=1)\n",
        "axs[3, 1].set_xlabel('CPU time (s)')\n",
        "axs[3, 1].set_ylim(pow(10,-5), 0)\n",
        "axs[3, 1].set_xlim(0, 100)\n",
        "axs[3, 1].legend(title = '8 layers')\n",
        "axs[3, 1].grid(axis='both',alpha=0.2)\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#############\n",
        "# SHOWING AND SAVING PLOTS\n",
        "#############\n",
        "plt.tight_layout()\n",
        "plt.savefig('precision_time_multiplot.pdf')\n",
        "plt.show()\n",
        "plt.clf()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:41: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:89: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:137: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:185: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:234: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:283: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:343: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n",
            "/usr/local/lib/python3.6/dist-packages/ipykernel_launcher.py:389: UserWarning: Attempted to set non-positive top ylim on a log-scaled axis.\n",
            "Invalid limit will be ignored.\n",
            "No handles with labels found to put in legend.\n"
          ],
          "name": "stderr"
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 504x720 with 8 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    }
  ]
}