retrain_less.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/lzmoraes/anaconda3/lib/python3.6/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n",
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import shutil\n",
    "import os\n",
    "import time\n",
    "from PIL import Image\n",
    "from numba import jit\n",
    "import pickle\n",
    "from pathlib import Path\n",
    "import skimage.measure\n",
    "%matplotlib inline\n",
    "\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Activation, Dense, Dropout\n",
    "from keras.layers.core import Flatten, Dense\n",
    "from keras.layers import Conv2D, MaxPooling2D\n",
    "from keras.metrics import categorical_crossentropy\n",
    "from keras.optimizers import Adam\n",
    "from keras.preprocessing.image import ImageDataGenerator\n",
    "from keras.layers.normalization import BatchNormalization\n",
    "from keras.layers.convolutional import *\n",
    "from keras.models import load_model\n",
    "\n",
    "import keras\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import pandas as pd\n",
    "import shutil\n",
    "import os\n",
    "import random\n",
    "\n",
    "from PIL import Image\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import metrics\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn import datasets\n",
    "\n",
    "\n",
    "from keras.optimizers import Adam\n",
    "\n",
    "from keras.models import load_model\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check the nth ('n') of an integer 'num'\n",
    "def check_nth_bit(num, n):\n",
    "    return (num>>n)&1\n",
    "\n",
    "# flip the bit of the integer 'int' at a position 'p'  (staring at 0)\n",
    "def bitflip(int,p):\n",
    "    mask = 1 << p\n",
    "    return (int^ mask)\n",
    "\n",
    "# count the numbers of 1 on a binarie representetion of an interger n\n",
    "def CountBits(n):\n",
    "    n = (n & 0x5555555555555555) + ((n & 0xAAAAAAAAAAAAAAAA) >> 1)\n",
    "    n = (n & 0x3333333333333333) + ((n & 0xCCCCCCCCCCCCCCCC) >> 2)\n",
    "    n = (n & 0x0F0F0F0F0F0F0F0F) + ((n & 0xF0F0F0F0F0F0F0F0) >> 4)\n",
    "    n = (n & 0x00FF00FF00FF00FF) + ((n & 0xFF00FF00FF00FF00) >> 8)\n",
    "    n = (n & 0x0000FFFF0000FFFF) + ((n & 0xFFFF0000FFFF0000) >> 16)\n",
    "    n = (n & 0x00000000FFFFFFFF) + ((n & 0xFFFFFFFF00000000) >> 32) \n",
    "    return n\n",
    "\n",
    "# defining n!\n",
    "@jit\n",
    "def factorial(n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)\n",
    "\n",
    "# finding the states that have the maginetization \"z\"\n",
    "@jit\n",
    "def statep(y,z):\n",
    "    a = 0\n",
    "    for x in range(0,2**l):\n",
    "        if (2* CountBits(x)-l) == z:\n",
    "            y[a] = x\n",
    "            a += 1\n",
    "    return (y)\n",
    "\n",
    "# numbers of states with magnatization x\n",
    "def num_mag(x):\n",
    "    y = p = int(factorial(l)//((factorial((x+l)/2))*(factorial(l -((x+l)/2)))))\n",
    "    return y\n",
    "            \n",
    "# find the position in the list of states \"s\" that are iqual to \"b\"\n",
    "@jit\n",
    "def find_state(s,b):\n",
    "    for z in range(0,p+1):\n",
    "        if s[z] == b:\n",
    "            return(z)\n",
    "\n",
    "# power method\n",
    "@jit\n",
    "def power_iteration(A):\n",
    "    # Choose a random vector\n",
    "    y_0 = np.random.rand(A.shape[0])\n",
    "    #erro precision\n",
    "    e= 0.000000001\n",
    "    #convergence constant\n",
    "    er= 1.0\n",
    "    it = 0\n",
    "    while (er >= e):\n",
    "        # calculate the matrix-by-vector product Ab\n",
    "        z_1 = np.dot(A, y_0)\n",
    "        # calculate the norm\n",
    "        z_1_norm = np.linalg.norm(z_1)\n",
    "        # renormalize the vector\n",
    "        y_1 = z_1 / z_1_norm\n",
    "        z_2 = np.dot(A, y_1)\n",
    "        z_2_norm = np.linalg.norm(z_2)\n",
    "        lamb_1 = np.dot(z_2,y_1)/np.dot(y_1,y_1)\n",
    "        y_2 = z_2/z_2_norm\n",
    "        z_3 = np.dot(A, y_2)\n",
    "        z_3_norm = np.linalg.norm(z_3)\n",
    "        lamb_2 = np.dot(z_3,y_2)/np.dot(y_2,y_2)\n",
    "        er = abs(lamb_1 - lamb_2)/abs(lamb_2)\n",
    "        y_0 = z_3/z_3_norm\n",
    "        it += 1\n",
    "        #if( it%10 == 0):print('# of interations:',it,';','Precision:', er)\n",
    "    return (y_0, lamb_2)\n",
    "\n",
    "@jit\n",
    "def POWER_METHOD(A,dim):\n",
    "    for x in range(0,dim):\n",
    "        A[x,x] -= 2*l\n",
    "        \n",
    "    C = np.asarray(power_iteration(A))\n",
    "    C[1] += 2*l\n",
    "    return (C)\n",
    "\n",
    "def chart_regression(pred,y,sort=True):\n",
    "    t = pd.DataFrame({'pred' : pred, 'y' : y.flatten()})\n",
    "    if sort:\n",
    "        t.sort_values(by=['y'],inplace=True)\n",
    "    a = plt.plot(t['y'].tolist(),label='expected')\n",
    "    b = plt.plot(t['pred'].tolist(),label='prediction')\n",
    "    plt.ylabel('output')\n",
    "    plt.legend()\n",
    "    plt.title('RMSE ='+ str(np.round(100000*score)/100000))\n",
    "    plt.savefig('predct_pool.png')\n",
    "    plt.show()\n",
    "    \n",
    "#plt.switch_backend('agg')\n",
    "\n",
    "def plot_history(history):\n",
    "    loss_list = [s for s in history.history.keys() if 'loss' in s and 'val' not in s]\n",
    "    val_loss_list = [s for s in history.history.keys() if 'loss' in s and 'val' in s]\n",
    "    acc_list = [s for s in history.history.keys() if 'mean_squared_error' in s and 'val' not in s]\n",
    "    val_acc_list = [s for s in history.history.keys() if 'val_mean_squared_error' in s and 'val' in s]\n",
    "\n",
    "    if len(loss_list) == 0:\n",
    "        print('Loss is missing in history')\n",
    "        return\n",
    "\n",
    "    ## As loss always exists\n",
    "    epochs = range(1,len(history.history[loss_list[0]]) + 1)\n",
    "\n",
    "    ## Loss\n",
    "    plt.figure(1)\n",
    "    for l in loss_list:\n",
    "        plt.plot(epochs, history.history[l], 'b', label='Training loss (' + str(str(format(history.history[l][-1],'.5f'))+')'))\n",
    "    for l in val_loss_list:\n",
    "        plt.plot(epochs, history.history[l], 'g', label='Validation loss (' + str(str(format(history.history[l][-1],'.5f'))+')'))\n",
    "\n",
    "    plt.title('Loss')\n",
    "    plt.xlabel('Epochs')\n",
    "    plt.ylabel('Loss')\n",
    "    plt.legend()\n",
    "    plt.grid()\n",
    "    plt.savefig('loss_retrain_pool.png')\n",
    "    plt.show()\n",
    "    \n",
    "\n",
    "    ## Accuracy\n",
    "    #plt.figure(2)\n",
    "    #for l in acc_list:\n",
    "        #plt.plot(epochs, history.history[l], 'b', label='Training Mean Square Error (' + str(format(history.history[l][-1],'.5f'))+')')\n",
    "    #for l in val_acc_list:\n",
    "        #plt.plot(epochs, history.history[l], 'g', label='Validation Mean Square Error (' + str(format(history.history[l][-1],'.5f'))+')')\n",
    "\n",
    "    #plt.title('Mean Square Error')\n",
    "    #plt.xlabel('Epochs')\n",
    "    #plt.ylabel('Mean Square Error')\n",
    "    #plt.legend()\n",
    "    \n",
    "    \n",
    "# ------------------------------------------------------    \n",
    "# ------------------PLOT CLECIO-------------------------\n",
    "# ------------------------------------------------------\n",
    "\n",
    "def plot_regression_results(\n",
    "        results,results_residuals,\n",
    "        truth_values,individual_truth_values,\n",
    "        individual_medians,plot_std=True,\n",
    "        bin_edges=10,real_data=None,\n",
    "        plot_dropout_err=True, plot_name='regression.png',\n",
    "        xlabel='$\\\\theta_{E}$',ylabel='$\\\\theta_{E}$',\n",
    "        xmin=None, xmax=None,\n",
    "        ymin=None, ymax=None,\n",
    "        color_std='blue', color_err='green',\n",
    "        color_pop='magenta',plot_label=None,\n",
    "        fill_label_std=None, fill_label_err=None,\n",
    "        figsize=(6, 8),alpha_hist=0.4, \n",
    "        pop_error=None,pop_error_residuals=None,\n",
    "        plot_real_residuals=False):\n",
    "    \"\"\" \n",
    "    Funtion to create Plots of true values vs predicted values.\n",
    "    It also plots residuals and the histogram of true and \n",
    "    predicted.\n",
    "    INPUT:\n",
    "        results: <list> - a list with the format [bin centers, \n",
    "        bin medians, bin standard deviations,bin 1 sigma \n",
    "        intervals, i.e., [low,high] limit ,bin 2 sigma intervals \n",
    "        ,bin 3 sigma intervals].\n",
    "        results_residuals: <list> - a list with the format [bin \n",
    "        centers, bin median residuals, bin standard deviation\n",
    "        residuals,bin 1 sigma interval of residuals,bin 2 sigma \n",
    "        intervals of residuals, bin 3 sigma intervals of \n",
    "        residuals].\n",
    "        truth_values: <array> - same as np.unique\n",
    "        (individual_truth_values).\n",
    "        individual_truth_value: <array> - The non bined truth \n",
    "        values for histogram.\n",
    "        individual_medians: <array> - The non bined predicted \n",
    "        medians for histogram.\n",
    "        plot_std <bool> - If True will plot a standard deviation\n",
    "        in results and results_residuals\n",
    "        bin_edges: <array> - Bin edges, used to define a scale \n",
    "        only, optional.\n",
    "        real_data: data points, instead of binned curves to add\n",
    "        in the plot. if plot_real_residuals=True it must follow \n",
    "        the format [true_valules,median,lowlim,highlim,\n",
    "        median_residual,lowlim_residual,highlim_residual] if \n",
    "        plot_real_residuals=False the format is [true_valules,\n",
    "        median,lowlim,highlim]\n",
    "        plot_dropout_err: <bool> -  if True will plot the \n",
    "        1-sigma, 2-sigma and 3-sigma error in results_catalog \n",
    "        and results_residuals.\n",
    " \n",
    "        plot_name: <str> : output plot name.\n",
    "    OUTPUT:\n",
    "       Saves a plot with a a path defined in the input plot_name.\n",
    "    \"\"\"\n",
    "\n",
    "    pop_err=pop_error\n",
    "    pop_err_r=pop_error_residuals\n",
    "    x_bin,y_bin,y_bin_std,y_bin_percentile1sig,y_bin_percentile2sig,y_bin_percentile3sig=results\n",
    "    x_bin,yr_bin,yr_bin_std,yr_bin_percentile1sig,yr_bin_percentile2sig,yr_bin_percentile3sig=results_residuals\n",
    "\n",
    "\n",
    "    if type(xmin)==type(None):\n",
    "        if type(bin_edges)!=type(10):\n",
    "            xmin=min(bin_edges)\n",
    "            xmax=max(bin_edges)\n",
    "        else:\n",
    "            xmin=min(x_bin)\n",
    "            xmax=max(x_bin)\n",
    "\n",
    "\n",
    "\n",
    "    imed=individual_medians\n",
    "    itruth=individual_truth_values \n",
    "\n",
    "    ty_bin_percentile1sig=np.transpose(y_bin_percentile1sig)\n",
    "    ty_bin_percentile2sig=np.transpose(y_bin_percentile2sig)\n",
    "    ty_bin_percentile3sig=np.transpose(y_bin_percentile3sig)\n",
    "\n",
    "    tyr_bin_percentile1sig=np.transpose(yr_bin_percentile1sig)\n",
    "    tyr_bin_percentile2sig=np.transpose(yr_bin_percentile2sig)\n",
    "    tyr_bin_percentile3sig=np.transpose(yr_bin_percentile3sig)\n",
    "    \n",
    "    # ================================\n",
    "    # Initialize figure canvas\n",
    "    # ================================\n",
    "    ymax = xmax\n",
    "    ymin = xmin\n",
    "    # set up figure\n",
    "    fig = plt.figure(figsize=figsize)         \n",
    "    \n",
    "    # set up grid of panels in figure\n",
    "    grid = plt.GridSpec(3, 2, hspace=0.0, wspace=0.0, \n",
    "                        left=0.1, right=1.0, bottom=0.1, top=1.0,\n",
    "                        height_ratios=[1, 4, 1], width_ratios=[4,1])\n",
    "         \n",
    "    # main axis: predicted statistic vs. true statistic\n",
    "    ax_main = fig.add_subplot(grid[1,0])\n",
    "    \n",
    "    # hist axis [x]: histogram of data on x axis on top\n",
    "    ax_hist_x = fig.add_subplot(grid[0, 0], sharex=ax_main)\n",
    "    \n",
    "    # hist axis [y]: histogram of data on y axis on right\n",
    "    ax_hist_y = fig.add_subplot(grid[1, 1], sharey=ax_main)\n",
    "    \n",
    "    # res axis: residual of statistic vs. true stratistic\n",
    "    ax_diff = fig.add_subplot(grid[2,0], sharex=ax_main)\n",
    "    \n",
    "\n",
    " \n",
    "    \n",
    "    # calculate upper and lower bounds [for systematic error bars]\n",
    "    if plot_std==True:\n",
    "        lo_err, up_err = measure_uplow_std_limits(y_bin, y_bin_std, nsigma=1)#(ys_bin, ys_err_bin)\n",
    "\n",
    "    # calculate upper and lower bounds on diff [for systematic error bars]\n",
    "    if plot_std==True:\n",
    "        lo_err_diff, up_err_diff = measure_uplow_std_limits(yr_bin, yr_bin_std, nsigma=1)\n",
    "        \n",
    "\n",
    "    # ================================\n",
    "    # Plot data [sim]\n",
    "    # ================================\n",
    "    # plot: dropout medians [main axis]\n",
    "    ax_main.plot(x_bin,y_bin, color=color_err, alpha=0.9, label=plot_label)\n",
    "    \n",
    "    # plot: dropouts percentile errors [main axis]\n",
    "    if plot_dropout_err==True:\n",
    "        ax_main.fill_between(x_bin, ty_bin_percentile1sig[0], ty_bin_percentile1sig[1], color=color_err, alpha=0.5, label=fill_label_err)\n",
    "        ax_main.fill_between(x_bin, ty_bin_percentile2sig[0], ty_bin_percentile2sig[1], color=color_err, alpha=0.4)\n",
    "        ax_main.fill_between(x_bin, ty_bin_percentile3sig[0], ty_bin_percentile3sig[1], color=color_err, alpha=0.3)\n",
    "    \n",
    "    # plot: one-to-one line [main axis]\n",
    "    ax_main.plot([xmin, xmax], [ymin, ymax], color='black', ls='dashed', alpha=0.9)\n",
    "    \n",
    "    # plot: errors from standard deviation [main axis]\n",
    "    if plot_std==True:\n",
    "        ax_main.fill_between(x_bin, lo_err, up_err, color=color_std, alpha=0.4, label=fill_label_std)\n",
    "    \n",
    "    # plot: deltas [diff axis]\n",
    "    ax_diff.plot(x_bin,yr_bin, color=color_err, alpha=0.9)\n",
    "    \n",
    "    # plot: statistical errors [diff axis]\n",
    "    if plot_dropout_err==True:\n",
    "        ax_diff.fill_between(x_bin, tyr_bin_percentile1sig[0], tyr_bin_percentile1sig[1], color=color_err, alpha=0.5, label=fill_label_err)\n",
    "        ax_diff.fill_between(x_bin, tyr_bin_percentile2sig[0], tyr_bin_percentile2sig[1], color=color_err, alpha=0.4)\n",
    "        ax_diff.fill_between(x_bin, tyr_bin_percentile3sig[0], tyr_bin_percentile3sig[1], color=color_err, alpha=0.3)\n",
    "    \n",
    "    # plot: systematic errors [main axis]\n",
    "    if plot_std==True:\n",
    "        ax_diff.fill_between(x_bin, lo_err_diff, up_err_diff, color=color_err, alpha=0.9, label=fill_label_std)\n",
    "    \n",
    "    # plot: errors from medians\n",
    "    if pop_error!=None:\n",
    "        xp_bin,yp_bin,yp_bin_std,yp_bin_percentile1sig,yp_bin_percentile2sig,yp_bin_percentile3sig=pop_err\n",
    "        xp_bin,ypr_bin,ypr_bin_std,ypr_bin_percentile1sig,ypr_bin_percentile2sig,ypr_bin_percentile3sig=results_residuals=pop_err_r\n",
    "        typ_bin_percentile1sig=np.transpose(yp_bin_percentile1sig)\n",
    "        typr_bin_percentile1sig=np.transpose(ypr_bin_percentile1sig)\n",
    "        ax_main.fill_between(xp_bin, typ_bin_percentile1sig[0], typ_bin_percentile1sig[1], color=color_pop, alpha=0.4)\n",
    "        ax_diff.fill_between(xp_bin, typr_bin_percentile1sig[0], typr_bin_percentile1sig[1], color=color_pop, alpha=0.4)\n",
    "    # plot: zero line [res axis]\n",
    "    xmin_line, xmax_line = ax_diff.get_xlim()\n",
    "    ax_diff.axhline(y=0.2, ls='dashed', color='magenta', lw=0.5)\n",
    "    ax_diff.axhline(y=0.1, ls='dashed', color='red', lw=0.5)\n",
    "    ax_diff.axhline(y=0, ls='dashed', color='black', lw=0.5)\n",
    "    ax_diff.axhline(y=-0.1, ls='dashed', color='red', lw=0.5)\n",
    "    ax_diff.axhline(y=-0.2, ls='dashed', color='magenta', lw=0.5)\n",
    "\n",
    "    #ax_diff.plot([xmin, xmax], np.zeros(2), color='black', ls='dashed', alpha=0.4) \n",
    "\n",
    "    \n",
    "    # ================================\n",
    "    # Plot data [simulation]\n",
    "    # ================================\n",
    "    # plot: histogram on upper x axis\n",
    "    ax_hist_x.hist(itruth, bin_edges, \n",
    "                   color=color_err, alpha=alpha_hist, \n",
    "                   histtype='stepfilled')\n",
    "    \n",
    "    # plot: histogram on right y axis\n",
    "    blank = ax_hist_y.hist(imed, bin_edges, \n",
    "                   color=color_err, alpha=alpha_hist,\n",
    "                   histtype='stepfilled',\n",
    "                   orientation='horizontal')\n",
    "        \n",
    "    # plot: sky data main_axis\n",
    "    if type(real_data)!=type(None):\n",
    "        print('real data')\n",
    "        print(np.array(real_data).shape)\n",
    "        if plot_real_residuals==False:\n",
    "            real_tr,real_me,real_lo,real_hi=np.transpose(real_data)\n",
    "        else:\n",
    "            real_tr,real_me,real_lo,real_hi,realr_me,realr_lo,realr_hi=np.transpose(real_data)\n",
    "        yerr_lo=real_me - real_lo\n",
    "        yerr_hi= real_hi - real_me\n",
    "\n",
    "        yerr_lor=realr_me - realr_lo\n",
    "        yerr_hir= realr_hi - realr_me\n",
    "\n",
    "        #res_me=np.divide(real_me-real_tr,real_tr)\n",
    "        ax_main.errorbar(real_tr, real_me, yerr=[yerr_lo,yerr_hi], fmt='ko', markersize=5,label='DES')\n",
    "        ax_diff.errorbar(real_tr, realr_me, yerr=[yerr_lor,yerr_hir], fmt='ko', markersize=5,label='DES')\n",
    "\n",
    "\n",
    "    #if xr is not None and yr is not None:\n",
    "    #    if yr_err is not None:\n",
    "    #        ax_main.errorbar(xr, yr, yerr=yr_err, color='black', fmt='o', label='DES')\n",
    "    #    if yr_diff is not None:\n",
    "    #        ax_diff.scatter(xr, yr_diff, color='black')\n",
    "    #    if yr_diff is not None and yr_err is not None:\n",
    "    #        ax_diff.errorbar(xr, yr_diff, yerr=yr_err, color='black', fmt='o')\n",
    "\n",
    "    # ================================\n",
    "    # Set plot options\n",
    "    # ================================\n",
    "    # set plot options [main axis]\n",
    "    plt.setp(ax_main.get_xticklabels(), visible=False)\n",
    "    plt.setp(ax_main.get_yticklabels(), visible=True)\n",
    "    plt.setp(ax_diff.get_yticklabels(), visible=False)\n",
    "    plt.setp(ax_hist_x.get_xticklabels(), visible=False)\n",
    "    plt.setp(ax_hist_x.get_yticklabels(), visible=False)\n",
    "    plt.setp(ax_hist_y.get_yticklabels(), visible=False)\n",
    "    plt.setp(ax_hist_y.get_xticklabels(), visible=False)\n",
    "    ax_main.set_ylabel(ylabel)\n",
    "    #ax_main.autoscale(enable=True,axis='both')\n",
    "    ax_main.axis('equal')\n",
    "    ax_main.set_xlim((xmin, xmax))   \n",
    "    ax_main.set_ylim((xmin, xmax))\n",
    "    ax_main.set_ylabel(ylabel)   \n",
    "    ax_main.grid(True, alpha=0.2) \n",
    "    ax_hist_x.grid(True,alpha=0.2)\n",
    "    ax_hist_y.grid(True,alpha=0.2)\n",
    "    ax_main.legend()\n",
    "    #ax_main.set_aspect('equal')\n",
    "    \n",
    "    # set plot options [residual axis]\n",
    "    ax_diff.set_ylim((-0.8,0.8))\n",
    "    ax_diff.set_xlabel(xlabel)\n",
    "    ylabel_plain=ylabel.replace('$','')\n",
    "    ax_diff.set_ylabel('$\\\\frac{\\\\delta '+ylabel_plain+'}{'+ylabel_plain+'}$')\n",
    "    ax_diff.grid(True, alpha=0.2)\n",
    "\n",
    "\n",
    "    plt.savefig(plot_name)\n",
    "    \n",
    "    \n",
    "def make_bin(col1_dat,col2_dat,bin_edges,return_vals=False,method=\"mean\"):\n",
    "    \"\"\"\n",
    "    col1= array like of the x values\n",
    "    col2= array like of the y values\n",
    "    Funtion that bins in x of a sample of (x,y) pairs.\n",
    "    USe the return_vals if you want a list of y values in each bin\n",
    "    \"\"\"\n",
    "    print (type(col2_dat))\n",
    "    print (np.array(col2_dat).shape)\n",
    "    #col1_dat=fits_catalog_col(cat,col1)\n",
    "    #col2_dat=fits_catalog_col(cat,col2)\n",
    "    #xy=zip(col1_dat,col2_dat)\n",
    "    bin_vals = [[] for x in range(0,len(bin_edges)-1)]\n",
    "    bin_valsx = [[] for x in range(0,len(bin_edges)-1)]\n",
    "    bin_median=np.zeros(len(bin_edges)-1)\n",
    "    bin_mean=np.zeros(len(bin_edges)-1)\n",
    "    bin_std=np.zeros(len(bin_edges)-1)\n",
    "    bin_center=np.zeros(len(bin_edges)-1)\n",
    "\n",
    "    bin_percentile1sig=[[] for x in range(0,len(bin_edges)-1)]\n",
    "    bin_percentile2sig=[[] for x in range(0,len(bin_edges)-1)]\n",
    "    bin_percentile3sig=[[] for x in range(0,len(bin_edges)-1)]\n",
    "\n",
    "    for i in range(0,len(col1_dat)):\n",
    "        for j in range(0,len(bin_edges)-1):\n",
    "            if bin_edges[j] <= col1_dat[i] <= bin_edges[j+1]:\n",
    "                #print \"data size\"\n",
    "                #try:\n",
    "                #    print col1_dat.size\n",
    "                #    print col2_dat.size\n",
    "                #except:\n",
    "                #    print len(col1_dat)\n",
    "                #    print len(col2_dat)\n",
    "                bin_vals[j].append(col2_dat[i])\n",
    "                bin_valsx[j].append(col1_dat[i])            \n",
    "\n",
    "    for i in range(0,len(bin_edges)-1):\n",
    "        try:\n",
    "            bin_mean[i]=np.mean(bin_vals[i])\n",
    "        except:\n",
    "            print(type(bin_vals[i]))\n",
    "            print(\"Error!\")\n",
    "        bin_median[i]=np.median(bin_vals[i])\n",
    "        bin_std[i]=np.std(bin_vals[i])\n",
    "        if method==\"percentile\":\n",
    "            if len(bin_vals[i])!=0:\n",
    "                #median=np.percentile(measurements,50.0)\n",
    "                lowlim=np.percentile(bin_vals[i],15.87)\n",
    "                highlim=np.percentile(bin_vals[i],84.13)\n",
    "                lowlim2sig=np.percentile(bin_vals[i],2.25)\n",
    "                highlim2sig=np.percentile(bin_vals[i],97.6)\n",
    "                lowlim3sig=np.percentile(bin_vals[i],0.15)\n",
    "                highlim3sig=np.percentile(bin_vals[i],99.7)\n",
    "            else:\n",
    "                lowlim=0\n",
    "                highlim=0\n",
    "                lowlim2sig=0\n",
    "                highlim2sig=0\n",
    "                lowlim3sig=0\n",
    "                highlim3sig=0\n",
    "            bin_percentile1sig[i]=[lowlim,highlim]\n",
    "            bin_percentile2sig[i]=[lowlim2sig,highlim2sig]\n",
    "            bin_percentile3sig[i]=[lowlim3sig,highlim3sig]\n",
    "            \n",
    "        if bin_std[i]<0.001:\n",
    "            print(\"zero bin std data:\")\n",
    "            print(bin_vals[i])\n",
    "        bin_center[i]= (bin_edges[i]+bin_edges[i+1])/2\n",
    "\n",
    "    if return_vals==False:\n",
    "        if method=='median':\n",
    "            return bin_center,bin_median,bin_std\n",
    "        elif method=='percentile':\n",
    "            return bin_center,bin_median,bin_std,bin_percentile1sig,bin_percentile2sig,bin_percentile3sig,       \n",
    "        else:\n",
    "            return bin_center,bin_mean,bin_std\n",
    "    else:\n",
    "        # if you want the a list of values inside each bin,\n",
    "        # so you can perform your own bin metrics.\n",
    "        return bin_center,bin_valsx,bin_vals"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pool dimansion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv('pool.csv')\n",
    "path_folder = 'matrix_pool/'\n",
    "\n",
    "#writing the columns of the csv in an list\n",
    "X_1 = dataset.iloc[:,1].values\n",
    "Y_1 = dataset.iloc[:,3].values\n",
    "\n",
    "W = np.random.permutation(np.c_[X_1.reshape(len(X_1), -1), Y_1.reshape(len(Y_1), -1)])\n",
    "\n",
    "X = W[:, :X_1.size//len(X_1)].reshape(X_1.shape)\n",
    "Y = W[:, X_1.size//len(X_1):].reshape(Y_1.shape)\n",
    "\n",
    "x_train = np.array([X[i] for i in range((len(X)//10),len(X))])\n",
    "y_train = np.array([Y[i] for i in range((len(Y)//10),len(Y))])\n",
    "\n",
    "x_test = np.array([X[i] for i in range((len(X)//10))])\n",
    "y_test = np.array([Y[i] for i in range((len(Y)//10))])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1441,)\n"
     ]
    }
   ],
   "source": [
    "print(x_train.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = []\n",
    "\n",
    "load_train_data = []\n",
    "for file in x_train[0:500]:\n",
    "        path = os.path.abspath(path_folder+ file)\n",
    "        H = np.load(path)\n",
    "        load_train_data.append(H)\n",
    "load_train_data = np.array(load_train_data)\n",
    "train_data = load_train_data[:,:,:,np.newaxis]\n",
    "train_data -= np.mean(train_data)\n",
    "train_data /= np.std(train_data)\n",
    "\n",
    "train_label = []\n",
    "for file in y_train[0:500]:\n",
    "    train_label.append(file)\n",
    "train_label = np.array(train_label)\n",
    "\n",
    "test_data = []\n",
    "\n",
    "load_test_data = []\n",
    "for file in x_test[0:50]:\n",
    "        path = os.path.abspath(path_folder+ file)\n",
    "        H = np.load(path)\n",
    "        load_test_data.append(H)\n",
    "load_test_data = np.array(load_test_data)\n",
    "test_data = load_test_data[:,:,:,np.newaxis]\n",
    "test_data -= np.mean(test_data)\n",
    "test_data /= np.std(test_data)\n",
    "\n",
    "test_label = []\n",
    "for file in y_test[0:50]:\n",
    "    test_label.append(file)\n",
    "test_label = np.array(test_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 450 samples, validate on 50 samples\n",
      "Epoch 1/15\n",
      "450/450 [==============================] - 168s 373ms/step - loss: 2.2680 - val_loss: 1.4635\n",
      "Epoch 2/15\n",
      "450/450 [==============================] - 215s 478ms/step - loss: 1.9688 - val_loss: 2.3185\n",
      "Epoch 3/15\n",
      "450/450 [==============================] - 191s 425ms/step - loss: 2.4662 - val_loss: 2.2284\n",
      "Epoch 4/15\n",
      "450/450 [==============================] - 166s 368ms/step - loss: 2.2243 - val_loss: 1.6947\n",
      "Epoch 5/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 1.4079 - val_loss: 0.4195\n",
      "Epoch 6/15\n",
      "450/450 [==============================] - 166s 368ms/step - loss: 0.5039 - val_loss: 0.5169\n",
      "Epoch 7/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 0.3671 - val_loss: 0.3638\n",
      "Epoch 8/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.4390 - val_loss: 0.3813\n",
      "Epoch 9/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.2946 - val_loss: 0.1662\n",
      "Epoch 10/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.2451 - val_loss: 0.1694\n",
      "Epoch 11/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 0.1747 - val_loss: 0.1690\n",
      "Epoch 12/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.1704 - val_loss: 0.1164\n",
      "Epoch 13/15\n",
      "450/450 [==============================] - 165s 366ms/step - loss: 0.1115 - val_loss: 0.0834\n",
      "Epoch 14/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.1016 - val_loss: 0.0703\n",
      "Epoch 15/15\n",
      "450/450 [==============================] - 165s 368ms/step - loss: 0.0854 - val_loss: 0.0533\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Score (RMSE): 0.21397142288771387\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = load_model('my_model.h5')\n",
    "\n",
    "model.compile(Adam(lr=.0001),loss='mean_squared_error')\n",
    "\n",
    "\n",
    "history = model.fit(train_data, train_label, epochs=15, batch_size=128, validation_split=0.1, verbose=1)\n",
    "\n",
    "model.save('retrain_less.h5')\n",
    "plot_history(history)\n",
    "\n",
    "\n",
    "\n",
    "pred = model.predict(test_data, batch_size=128)\n",
    "score = np.sqrt(metrics.mean_squared_error(pred,test_label))\n",
    "print(\"Score (RMSE): {}\".format(score))\n",
    "\n",
    "chart_regression(pred.flatten(),test_label)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Random MF"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = pd.read_csv('rand.csv')\n",
    "\n",
    "path_folder = 'matrix_del_rand/'\n",
    "\n",
    "#writing the columns of the csv in an list\n",
    "X_1 = dataset.iloc[:,1].values\n",
    "Y_1 = dataset.iloc[:,2].values\n",
    "\n",
    "W = np.random.permutation(np.c_[X_1.reshape(len(X_1), -1), Y_1.reshape(len(Y_1), -1)])\n",
    "\n",
    "X = W[:, :X_1.size//len(X_1)].reshape(X_1.shape)\n",
    "Y = W[:, X_1.size//len(X_1):].reshape(Y_1.shape)\n",
    "\n",
    "x_train = np.array([X[i] for i in range((len(X)//10),len(X))])\n",
    "y_train = np.array([Y[i] for i in range((len(Y)//10),len(Y))])\n",
    "\n",
    "x_test = np.array([X[i] for i in range((len(X)//10))])\n",
    "y_test = np.array([Y[i] for i in range((len(Y)//10))])\n",
    "\n",
    "train_data = []\n",
    "\n",
    "load_train_data = []\n",
    "for file in x_train[0:500]:\n",
    "        path = os.path.abspath(path_folder+ file)\n",
    "        H = np.load(path)\n",
    "        load_train_data.append(H)\n",
    "load_train_data = np.array(load_train_data)\n",
    "train_data = load_train_data[:,:,:,np.newaxis]\n",
    "train_data -= np.mean(train_data)\n",
    "train_data /= np.std(train_data)\n",
    "\n",
    "train_label = []\n",
    "for file in y_train[0:500]:\n",
    "    train_label.append(file)\n",
    "train_label = np.array(train_label)\n",
    "\n",
    "test_data = []\n",
    "\n",
    "load_test_data = []\n",
    "for file in x_test[0:50]:\n",
    "        path = os.path.abspath(path_folder+ file)\n",
    "        H = np.load(path)\n",
    "        load_test_data.append(H)\n",
    "load_test_data = np.array(load_test_data)\n",
    "test_data = load_test_data[:,:,:,np.newaxis]\n",
    "test_data -= np.mean(test_data)\n",
    "test_data /= np.std(test_data)\n",
    "\n",
    "test_label = []\n",
    "for file in y_test[0:50]:\n",
    "    test_label.append(file)\n",
    "test_label = np.array(test_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train on 450 samples, validate on 50 samples\n",
      "Epoch 1/15\n",
      "450/450 [==============================] - 169s 375ms/step - loss: 2.9273 - val_loss: 3.5996\n",
      "Epoch 2/15\n",
      "450/450 [==============================] - 167s 372ms/step - loss: 3.1367 - val_loss: 1.0695\n",
      "Epoch 3/15\n",
      "450/450 [==============================] - 165s 368ms/step - loss: 0.9563 - val_loss: 0.4511\n",
      "Epoch 4/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.5107 - val_loss: 1.1715\n",
      "Epoch 5/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.7104 - val_loss: 0.2720\n",
      "Epoch 6/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 0.4797 - val_loss: 0.2691\n",
      "Epoch 7/15\n",
      "450/450 [==============================] - 166s 368ms/step - loss: 0.3417 - val_loss: 0.6417\n",
      "Epoch 8/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 0.3369 - val_loss: 0.2688\n",
      "Epoch 9/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 0.3497 - val_loss: 0.3206\n",
      "Epoch 10/15\n",
      "450/450 [==============================] - 166s 370ms/step - loss: 0.3262 - val_loss: 0.3786\n",
      "Epoch 11/15\n",
      "450/450 [==============================] - 166s 368ms/step - loss: 0.2562 - val_loss: 0.2480\n",
      "Epoch 12/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 0.2591 - val_loss: 0.3655\n",
      "Epoch 13/15\n",
      "450/450 [==============================] - 165s 367ms/step - loss: 0.2463 - val_loss: 0.2318\n",
      "Epoch 14/15\n",
      "450/450 [==============================] - 166s 368ms/step - loss: 0.2226 - val_loss: 0.2502\n",
      "Epoch 15/15\n",
      "450/450 [==============================] - 166s 369ms/step - loss: 0.2182 - val_loss: 0.2758\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "50/50 [==============================] - 6s 121ms/step\n",
      "Score (RMSE): 0.5783888944162177\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = load_model('my_model.h5')\n",
    "\n",
    "model.compile(Adam(lr=.0001),loss='mean_squared_error')\n",
    "\n",
    "history = model.fit(train_data, train_label, epochs=15, batch_size=128, validation_split=0.1, verbose=1)\n",
    "\n",
    "model.save('retrain_less_big.h5')\n",
    "plot_history(history)\n",
    "\n",
    "pred = model.predict(test_data, verbose=1)\n",
    "score = np.sqrt(metrics.mean_squared_error(pred,test_label))\n",
    "print(\"Score (RMSE): {}\".format(score))\n",
    "\n",
    "chart_regression(pred.flatten(),test_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}