ANN_supervised_regression_train-apply.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <big><big><big><font color='#5D6D7E'>**ENTRENAMIENTO DE UNA RED NEURONAL PARA EMULACION DE UNA CURVA UTILIZANDO KERAS**</font></big><big><big>\n",
    "https://www.tensorflow.org/tutorials/load_data/pandas_dataframe<br>\n",
    "    \n",
    "En este archivo trataremos de emular 1 curva a partir de algunas otras presentes en el mismo archivo.<br>\n",
    "    \n",
    "Los pasos son los siguientes:\n",
    "    \n",
    "    \n",
    "1. [POZOS DE TRABAJO](#counter_curvas)\n",
    "    - 1.1 [Revisamos todos los archivos .LAS en la carpeta de trabajo](#counter_curvas_1)\n",
    "    - 1.2 [Elegimos los archivos .LAS de trabajo](#counter_curvas_2)\n",
    "    - 1.3 [Exportamos los archivos .LAS con lasio y pasamos cada .LAS a 1 DF pandas](#counter_curvas_3)\n",
    "    - 1.4 [Chequeamos cantidad de pozos y cantidad de veces que aparece cada curva en todos los pozos](#counter_curvas_4)<br><br><br>\n",
    "2. [POZO ENTRENADOR](#PozoEntrenador)\n",
    "    - 2.1 [Carga y QC de datos del pozo entrenador](#PozoEntrenador_LoadQc)\n",
    "        - 2.1.1 [Cargamos con lasio el archivo .LAS con los datos del pozo entrenador y creamos un nuevo DF pandas](#PozoEntrenador_LasioPandas)\n",
    "        - 2.1.2 [PLOT QC](#PozoEntrenador_PlotQc)\n",
    "        - 2.1.3 [Declaración de variables (para plot combinado y para entenamiento de la red)](#PozoEntrenador_Declaracion)\n",
    "        - 2.1.4 [PLOT COMBINADO](#PozoEntrenador_Combo)<br><br>\n",
    "    - 2.2 [Entrenamiento de la red](#PozoEntrenador_Modelo)\n",
    "        - 2.2.1 [Creacion df con las curvas que utilizaremos como features y la curva target, ambas en el tramo del pozo conveniente](#PozoEntrenador_Modelo_decl)\n",
    "        - 2.2.2 [Creación de funciones para graficar el modelo](#PozoEntrenador_Modelo_defs)\n",
    "        - 2.2.3 [Keras: Entrenamiento del modelo (fit)](#PozoEntrenador_Modelo_fit)\n",
    "        - 2.2.4 [Keras: Aplicación del modelo - obtención de la curva emulada (predict)](#PozoEntrenador_Modelo_predict)\n",
    "        - 2.2.5 [ Plot para comparar curva target vs. curva emulada](#PozoEntrenador_Modelo_predict_plot)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import lasio\n",
    "\n",
    "from collections import Counter\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import mplcursors\n",
    "%matplotlib inline\n",
    "%matplotlib notebook\n",
    "from matplotlib.ticker import MaxNLocator\n",
    "from matplotlib.ticker import StrMethodFormatter\n",
    "\n",
    "# import tensorflow as tf\n",
    "# import datetime\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Dropout\n",
    "from keras.callbacks import EarlyStopping\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "# from sklearn.preprocessing import MinMaxScaler\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "import fnmatch\n",
    "import glob, os\n",
    "from IPython.display import clear_output\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='counter_curvas'></a>\n",
    "# <big><big><font color='#8E44AD'>1. POZOS DE TRABAJO</font></big></big>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='counter_curvas_1'></a>\n",
    "# <font color='#1F618D'>1.1 Revisamos todos los archivos .LAS en la carpeta de trabajo</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "path=input(\"Escriba el PATH completo de la carpeta que contiene los .CSV y presione INTRO.(Ejemplo: D:\\Pablo\\Python\\working_files\\pozos)\")\n",
    "\n",
    "clear_output(wait=True)\n",
    "# D:\\Pablo\\Python\\working_files\\pozos\n",
    "for file in os.listdir(path):\n",
    "    if file.endswith(\".las\"):\n",
    "        print(os.path.join(file))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='counter_curvas_2'></a>\n",
    "# <font color='#1F618D'>1.2 Elegimos los archivos .LAS de trabajo</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if 'las_file_list' in locals():\n",
    "    del las_file_list\n",
    "else:\n",
    "    las_file_list = []\n",
    "\n",
    "las_file_list = []   \n",
    "las_file = []\n",
    "\n",
    "\n",
    "pozo_nomb_comienzo=input(\"Escriba las primeras letras/numeros de los Pozos con los que va a trabajar y presione INTRO. Si va a utilizar todos los .LAS de la carpeta, solo presione INTRO\")\n",
    "\n",
    "clear_output(wait=True)\n",
    "\n",
    "for file in os.listdir(path):\n",
    "    if file.endswith('.las') and file.startswith((pozo_nomb_comienzo.lower(),pozo_nomb_comienzo.upper(),pozo_nomb_comienzo.capitalize())):\n",
    "        las_file_list.append(path+\"\\\\\"+file)\n",
    "        las_file.append(file)\n",
    "las_file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='counter_curvas_3'></a>\n",
    "# <font color='#1F618D'>1.3 Exportamos los archivos .LAS con lasio y pasamos cada .LAS a 1 DF pandas (Cada DataFrame hereda el nombre del archivo, sin caracteres especiales)</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "las_list = []\n",
    "\n",
    "for i in range(0,len(las_file)):\n",
    "         \n",
    "    string = las_file[i][:-3]                 \n",
    "    string = ''.join(e for e in string if e.isalnum()) \n",
    "    \n",
    "    locals()[string] = lasio.read(las_file_list[i]).df()   \n",
    "    \n",
    "    las_list.append(string)\n",
    "\n",
    "for elem in range(len(las_list)):\n",
    "    locals()[las_list[elem]]['DEPTH'] = locals()[las_list[elem]].index\n",
    "\n",
    "\n",
    "print ('\\033[1m'+f'TOTAL DE DATAFRAMES: {len(las_list)}')\n",
    "for elem in las_list:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='counter_curvas_4'></a>\n",
    "# <font color='#1F618D'>1.4 <font color='#1F618D'>Chequeamos cantidad de pozos y cantidad de veces que aparece cada curva en todos los pozos</font></font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'NUMERO DE POZOS:{len(las_list)}')\n",
    "print(*las_list,sep=', ')\n",
    "\n",
    "print('\\n')\n",
    "print('NOMBRE DE LA CURVA,','CANTIDAD DE POZOS DONDE APARECE:')\n",
    "\n",
    "curves_list = []\n",
    "\n",
    "# hago un merge de todas las curvas en una sola LIST\n",
    "for i in range(len(las_list)):\n",
    "    curves_list = curves_list + (list(locals()[las_list[(i)]].columns))\n",
    "    \n",
    "# ordeno alfabeticamente la LIST de curvas y luego encuentro las curvas más comunes en la LIST\n",
    "curves_list.sort()\n",
    "dict_curves = dict(Counter(curves_list).most_common())\n",
    "Counter(curves_list).most_common()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador'></a>\n",
    "# <big><big><font color='#8E44AD'>2. POZO ENTRENADOR</font></big></big>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_LoadQc'></a>\n",
    "# <font color='#1F618D'>2.1 Carga y QC de datos del pozo entrenador</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_LasioPandas'></a>\n",
    "# <font color='#BA4A00'>2.1.1 Cargamos con lasio el archivo .LAS con los datos del pozo entrenador y creamos un nuevo DF pandas </font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "las = lasio.read(r\"D:\\Pablo\\Python\\working_files\\Pozos\\well_13.las\")\n",
    "\n",
    "well = las.df()\n",
    "well['DEPTH'] = well.index\n",
    "\n",
    "# Ordenar alfabeticamente\n",
    "well = well.reindex(sorted(well.columns), axis=1)\n",
    "\n",
    "# Nombre del pozo \n",
    "for count, curve in enumerate(well):\n",
    "    (count)\n",
    "print ('\\033[1m' + f\"POZO: {las.well.WELL.value}\",\"\\n\" + f\"Total de curvas:{count+1}\")\n",
    "pd.set_option('display.max_columns', None)          # Muestra todas las columnas \n",
    "well"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "### DATOS DE CURVAS DEL ARCHIVO LASIO ORDENADAS ALFBETICAMENTE ###\n",
    "\n",
    "lasio_file = las\n",
    "\n",
    "\n",
    "print (f\"POZO: {lasio_file.well.WELL.value}\",\"\\t\",f\"YACIMIENTO: {lasio_file.well.FLD.value}\"\"\\n\"\n",
    "       f\"TOP: {lasio_file.well.STRT.value:.2f} {lasio_file.well.STRT.unit}\",\"\\t\"\n",
    "       f\"BOTTOM: {lasio_file.well.STOP['value']:.2f} {lasio_file.well.STOP['unit']}\")\n",
    "\n",
    "print(f\"TOTAL DE CURVAS: {count+1}\",\"(ORDENADAS ALFABETICAMENTE)\",\"\\n\")\n",
    "\n",
    "## Curvas       \n",
    "for count, i in enumerate(range(len(lasio_file.curves))):\n",
    "                          print(count+1,\n",
    "                                lasio_file.curves[sorted(lasio_file.curves.keys())[i]].mnemonic,\n",
    "                                \", Unit:\", lasio_file.curves[sorted(lasio_file.curves.keys())[i]].unit,\n",
    "                                \", Description:\", lasio_file.curves[sorted(lasio_file.curves.keys())[i]].descr)    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_PlotQc'></a>\n",
    "# <font color='#BA4A00'>2.1.2 PLOT QC</font>\n",
    "\n",
    "Este PLOT está enfocado en la cantidad de pozos donde se registró cada curva, y en la búsqueda de gaps"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "################## DATOS DE ENTRADA ##################\n",
    "\n",
    "df = well            # Nombre del dataframe pandas que creamos\n",
    "lasio_file = las      # Nombre del archivo lasio que creamos al principio   \n",
    "  \n",
    "top_plot_qc = lasio_file.well.STRT.value   # Top plot\n",
    "bot_plot_qc = lasio_file.well.STOP.value   # Bottom plot\n",
    "\n",
    "data_color = '#BD1E0E'     # color de relleno de los datos\n",
    "data_alpha = 0.8           # transparencia del color (0: transparente 1:opaco)\n",
    "\n",
    "####################### CODIGO #######################\n",
    "\n",
    "if 'dict_curves' in locals():\n",
    "    pass\n",
    "else:\n",
    "    dict_curves = {}\n",
    "\n",
    "df_nan = df.notnull() * 1\n",
    "\n",
    "fig = plt.subplots(figsize=((len(well.columns)*.8),(len(well.columns)*.7))) #Set up the plot axes\n",
    " \n",
    "for i in range(len(well.columns)):\n",
    "    ax = plt.subplot2grid((1,len(well.columns)), (0,i), rowspan=1, colspan = 1)\n",
    "    ax.plot(df_nan.iloc[:,i], df_nan.index, lw=0)\n",
    "    ax.set_ylim(bot_plot_qc, top_plot_qc)\n",
    "    ax.set_xlim(0, 1)\n",
    "    \n",
    "    if dict_curves.get(df_nan.columns[i]) == None:\n",
    "        ax.set_title(df_nan.columns[i][:4], rotation=0)         # titulo columnas: [:4] solo muetras primeras 4 letras\n",
    "                                                            # titulo columnas: rotation=0 horizontal, rotation=90 vertical\n",
    "    else:\n",
    "        ax.set_title(label=f'{df_nan.columns[i][:4]}\\n{dict_curves.get(df_nan.columns[i])}', rotation=0)\n",
    "        \n",
    "    ax.set_facecolor('#F2F4F4')\n",
    "    ax.fill_betweenx(df_nan.index, 0, df_nan.iloc[:,i], facecolor= data_color, alpha= data_alpha)       \n",
    "    plt.setp(ax.get_xticklabels(), visible = False)\n",
    "    if i > 0:\n",
    "        plt.setp(ax.get_yticklabels(), visible = False)\n",
    "    else:    # Sets the label for the leftmost subplot\n",
    "        ax.set_ylabel('DEPTH', fontsize=22,family='cursive')\n",
    "\n",
    "\n",
    "\n",
    "plt.subplots_adjust(wspace=0)\n",
    "plt.suptitle(t=f'\\nPOZO ENTRENADOR: {lasio_file.well.WELL.value}\\nCANTIDAD TOTAL DE POZOS: {len(las_list)}',\n",
    "             size=25,ha=\"left\", x=0.125, y=1.01, weight=900,family='cursive')\n",
    "\n",
    "                                            ## The font.weight property has effectively 13 values: normal, bold,\n",
    "                                            ## bolder, lighter, 100, 200, 300, ..., 1000.  Normal=400, bold=700\n",
    "        \n",
    " \n",
    "mplcursors.cursor(hover=True)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Declaracion'></a>\n",
    "# <font color='#BA4A00'>2.1.3 Declaración de variables para plot combinado</font>\n",
    "https://stackoverflow.com/questions/16327055/how-to-add-an-empty-column-to-a-dataframe\n",
    "\n",
    "- Si nos equivocamos en el nombre de alguna de las curvas de la DECLARACION DE VARIABLES PARA PLOT COMBINADO, y se crean curvas con valores **Nan**, o algo similar, podemos borrarlas y volver a crearlas con el nombre correcto corriendo de nuevo la celda de DECLARACION DE VARIABLES PARA PLOT COMBINADO."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Ver curvas del dataframe si vemos que el PLOT no graficó las curvas correctamente. \n",
    "# well.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Borrar columnas si es necesario, corregir el nombre de las curvas en la celda de abajo (DECLARACION DE VARIABLES\n",
    "# PARA PLOT COMBINADO), y volverla a correr. Luego correr la celda del PLOT COMBINADO para verificar las correcciones.\n",
    "\n",
    "# well.drop('MDEP', inplace=True, axis=1)                           # Borrar 1 sola columna\n",
    "# well.drop(['MDEP','MPHS','DCON','BIT'], inplace=True, axis=1)     # Borrar muliples columnas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "##################################################\n",
    "#                                                #\n",
    "#  DECLARACION DE VARIABLES PARA PLOT COMBINADO  #\n",
    "#                                                #\n",
    "##################################################\n",
    "\n",
    "\n",
    "bitsize = 12.25\n",
    "\n",
    "## ax1\n",
    "crv_cal = 'CALI'             # CALIPER\n",
    "crv_bit = 'BIT'             # BIT SIZE\n",
    "crv_gr = 'GR'               # GAMMA RAY\n",
    "crv_sp = 'SP'              # SPONTANEOUS POTENTIAL\n",
    "\n",
    "# ax2\n",
    "crv_dp_res = 'RDEP'         # DEEP RESISTIVITY\n",
    "crv_sh_res = 'RMED'         # SHALLOW RESISTIVITY\n",
    "\n",
    "#ax3\n",
    "crv_neu_por = 'NPHI'        # NEUTRON POROSITY\n",
    "crv_den_bulk = 'RHOB'       # BULK DENSITY\n",
    "crv_nmr_por = 'EMPTYPOR'        # OTHER POROSITY\n",
    "\n",
    "#ax4\n",
    "crv_con = 'DCON'            # CONDUCTIVITY\n",
    "\n",
    "\n",
    "##############################################################\n",
    "if crv_cal in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_cal]=np.nan\n",
    "\n",
    "##############    \n",
    "\n",
    "if crv_bit in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_bit]=bitsize\n",
    "\n",
    "##############    \n",
    "\n",
    "if crv_gr in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_gr]=np.nan\n",
    "    \n",
    "##############  \n",
    "\n",
    "if crv_sp in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_sp]=np.nan\n",
    "    \n",
    "##############  \n",
    "\n",
    "if crv_dp_res in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_dp_res]=np.nan\n",
    "    \n",
    "##############  \n",
    "\n",
    "if crv_sh_res in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_sh_res]=np.nan\n",
    "    \n",
    "############## \n",
    "\n",
    "if crv_neu_por in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_neu_por]=np.nan\n",
    "\n",
    "############## \n",
    "\n",
    "if crv_nmr_por in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_nmr_por]=np.nan\n",
    "\n",
    "############## \n",
    "\n",
    "if crv_den_bulk in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_den_bulk]=np.nan\n",
    "    \n",
    "##############      \n",
    "    \n",
    "if crv_con in well.columns:\n",
    "    pass\n",
    "else:\n",
    "    well[crv_con]=1000/well[crv_dp_res]    \n",
    "        \n",
    "################"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Combo'></a>\n",
    "# <font color='#BA4A00'>2.1.4 PLOT COMBINADO</font>\n",
    "https://engineeringfordatascience.com/posts/matplotlib_subplots/"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "top_plot= las.well.STRT.value\n",
    "bot_plot= las.well.STOP.value\n",
    "\n",
    "## numero de lineas verticales del track que va a depender de la escala de la curva\n",
    "ax1_ticks = 6         # Convencionales\n",
    "ax2_ticks = 6         # Resistividades\n",
    "ax3_ticks = 7         # Porosidades\n",
    "ax4_ticks = 6         # Conductividad\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20,20))#Set up the plot axes\n",
    "   \n",
    "ax1 = plt.subplot2grid((1,6), (0,0), rowspan=1, colspan = 1) \n",
    "ax11 = ax1.twiny()\n",
    "ax12 = ax1.twiny()\n",
    "\n",
    "ax2 = plt.subplot2grid((1,6), (0,1), rowspan=1, colspan = 1, sharey = ax1)\n",
    "ax21 = ax2.twiny()\n",
    "\n",
    "ax3 = plt.subplot2grid((1,6), (0,2), rowspan=1, colspan = 1, sharey = ax1) #\n",
    "ax31 = ax3.twiny() \n",
    "ax32 = ax3.twiny() \n",
    "\n",
    "ax4 = plt.subplot2grid((1,6), (0,3), rowspan=1, colspan = 1, sharey = ax1) #\n",
    "\n",
    "################################################################################\n",
    "\n",
    "### CAL ###\n",
    "cal_izq = 10     # min=izq \n",
    "cal_der = 20     # max=der\n",
    "\n",
    "ax1.plot(well[crv_cal], well.index, color = \"black\", linewidth = 0.5)\n",
    "ax1.set_ylabel(\"Depth (m)\")\n",
    "\n",
    "if abs(top_plot-bot_plot) > 500:\n",
    "    ax1.yaxis.set_major_locator(MaxNLocator(round(abs(top_plot-bot_plot)/99)))\n",
    "    \n",
    "elif abs(top_plot-bot_plot) <= 500 and abs(top_plot-bot_plot) > 200:\n",
    "    ax1.yaxis.set_major_locator(MaxNLocator(round(abs(top_plot-bot_plot)/49)))\n",
    "else:\n",
    "    ax1.yaxis.set_major_locator(MaxNLocator(round(abs(top_plot-bot_plot)/24)))\n",
    "    \n",
    "ax1.set_xlabel(f\"Caliper {well[crv_cal].name}\")\n",
    "ax1.set_xlim(cal_izq, cal_der)\n",
    "ax1.xaxis.label.set_color(\"black\")\n",
    "ax1.tick_params(axis='x', colors=\"black\")\n",
    "ax1.spines[\"top\"].set_edgecolor(\"black\")\n",
    "ax1.set_xticks(np.arange(cal_izq, cal_der+1, ((cal_der-cal_izq)/(ax1_ticks-1))))\n",
    "ax1.xaxis.set_major_formatter(StrMethodFormatter('{x:.0f}'))\n",
    "\n",
    "ax1.fill_betweenx(well.index, well[crv_bit], well[crv_cal],\n",
    "                  where=well[crv_bit]>=well[crv_cal], interpolate=True, color='brown')\n",
    "ax1.fill_betweenx(well.index, well[crv_bit], well[crv_cal],\n",
    "                  where=well[crv_bit]<=well[crv_cal], interpolate=True, color='#a6ecfa')\n",
    "################################################################################\n",
    "\n",
    "### GR ###\n",
    "gr_izq=0        \n",
    "gr_der=200      \n",
    "\n",
    "ax11.plot(well[crv_gr], well.index, color = \"green\", linewidth = 1.5)\n",
    "ax11.set_xlabel(f\"Gamma Ray ({well[crv_gr].name})\")\n",
    "ax11.xaxis.label.set_color(\"green\")\n",
    "ax11.set_xlim(gr_izq, gr_der)\n",
    "ax11.tick_params(axis='x', colors=\"green\")\n",
    "ax11.spines[\"top\"].set_position((\"axes\", 1.12))\n",
    "ax11.spines[\"top\"].set_visible(True)\n",
    "ax11.spines[\"top\"].set_edgecolor(\"green\")\n",
    "ax11.title.set_color('green')\n",
    "ax11.set_xticks(np.arange(gr_izq, gr_der+1, ((gr_der-gr_izq)/(ax1_ticks-1))))\n",
    "ax11.xaxis.set_major_formatter(StrMethodFormatter('{x:.0f}'))\n",
    "################################################################################\n",
    "\n",
    "### SP ###\n",
    "sp_izq=-80   \n",
    "sp_der=20     \n",
    "\n",
    "ax12.plot(well[crv_sp], well.index, color = \"red\", linewidth = 1.5)\n",
    "ax12.set_xlabel(f\"SP ({well[crv_sp].name})\")\n",
    "ax12.xaxis.label.set_color(\"red\")\n",
    "ax12.set_xlim(sp_izq,sp_der)\n",
    "ax12.tick_params(axis='x', colors=\"r\")\n",
    "ax12.spines[\"top\"].set_position((\"axes\", 1.07))\n",
    "ax12.spines[\"top\"].set_visible(True)\n",
    "ax12.spines[\"top\"].set_edgecolor(\"r\")\n",
    "ax12.title.set_color('r')\n",
    "ax12.set_xticks(np.arange(sp_izq, sp_der+1, ((sp_der-sp_izq)/(ax1_ticks-1))))\n",
    "ax12.xaxis.set_major_formatter(StrMethodFormatter('{x:.0f}'))\n",
    "################################################################################\n",
    "\n",
    "### RESD ###\n",
    "res_izq=0.1     \n",
    "res_der=100     \n",
    "\n",
    "ax2.plot(well[crv_dp_res], well.index, color = \"blue\", linewidth = 2)\n",
    "ax2.set_xlabel(f\"Deep Resistivity ({well[crv_dp_res].name})\")\n",
    "ax2.set_xlim(res_izq, res_der)\n",
    "ax2.xaxis.label.set_color(\"blue\")\n",
    "ax2.tick_params(axis='x', colors=\"blue\")\n",
    "ax2.spines[\"top\"].set_edgecolor(\"blue\")\n",
    "ax2.set_xticks(np.arange(res_izq, res_der+.1, (res_der/(ax2_ticks-1))))\n",
    "ax2.set_xscale(\"log\")\n",
    "ax2.grid(True, which=\"both\", axis='x')\n",
    "ax2.xaxis.set_major_formatter(StrMethodFormatter('{x:.1f}'))\n",
    "################################################################################\n",
    "\n",
    "### RESS ###\n",
    "\n",
    "\n",
    "ax21.plot(well[crv_sh_res], well.index, color = \"r\", linewidth = 0.5)\n",
    "ax21.set_xlabel(f\"Shallow Resistivity ({well[crv_sh_res].name})\")\n",
    "ax21.set_xlim(res_izq, res_der)\n",
    "ax21.xaxis.label.set_color(\"r\")\n",
    "ax21.spines[\"top\"].set_position((\"axes\", 1.07))\n",
    "ax21.spines[\"top\"].set_visible(True)\n",
    "ax21.tick_params(axis='x', colors=\"r\")\n",
    "ax21.spines[\"top\"].set_edgecolor(\"r\")\n",
    "ax21.set_xticks(np.arange(res_izq, res_der+.1, ((res_der-res_izq)/(ax2_ticks-1))))\n",
    "ax21.set_xscale(\"log\")\n",
    "ax21.xaxis.set_major_formatter(StrMethodFormatter('{x:.1f}'))\n",
    "################################################################################\n",
    "\n",
    "### DEN BULK ###\n",
    "denbulk_izq = 1.65      \n",
    "denbulk_der = 2.65      \n",
    "\n",
    "\n",
    "ax3.plot(well[crv_den_bulk], well.index, color = \"red\", linewidth = 1.0)\n",
    "ax3.set_xlabel(f\"Density Bulk ({well[crv_den_bulk].name})\")\n",
    "ax3.set_xlim(denbulk_izq,denbulk_der)\n",
    "ax3.xaxis.label.set_color(\"red\")\n",
    "ax3.tick_params(axis='x', colors=\"r\")\n",
    "ax3.spines[\"top\"].set_edgecolor(\"r\")\n",
    "ax3.set_xticks(np.arange(denbulk_der, denbulk_izq+.01, ((denbulk_izq-denbulk_der)/(ax3_ticks-1))))\n",
    "ax3.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "################################################################################\n",
    "\n",
    "### NEU POR ###\n",
    "neupor_izq = .6     \n",
    "neupor_der = 0      \n",
    "\n",
    "ax31.plot(well[crv_neu_por], well.index, color = \"blue\", linewidth = 1.0)\n",
    "ax31.set_xlabel(f\"Neutron Porosity ({well[crv_neu_por].name})\")\n",
    "ax31.xaxis.label.set_color(\"b\")\n",
    "ax31.set_xlim(neupor_izq,neupor_der)\n",
    "ax31.tick_params(axis='x', colors=\"blue\")\n",
    "ax31.spines[\"top\"].set_position((\"axes\", 1.07))\n",
    "ax31.spines[\"top\"].set_visible(True)\n",
    "ax31.spines[\"top\"].set_edgecolor(\"blue\")\n",
    "ax31.set_xticks(np.arange(neupor_der, neupor_izq+.01, (abs(neupor_der-neupor_izq)/(ax3_ticks-1))))\n",
    "ax31.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "################################################################################\n",
    "\n",
    "### AUX POR ###\n",
    "auxpor_izq = .6    \n",
    "auxpor_der = 0     \n",
    "auxpor_desc = 'Empty Porosity'\n",
    "\n",
    "ax32.plot(well[crv_nmr_por], well.index, color = \"black\", linewidth = 1.0)\n",
    "ax32.set_xlabel(f\"{auxpor_desc} ({well[crv_nmr_por].name})\")\n",
    "ax32.xaxis.label.set_color(\"black\")\n",
    "ax32.set_xlim(auxpor_izq,auxpor_der)\n",
    "ax32.tick_params(axis='x', colors=\"black\")\n",
    "ax32.spines[\"top\"].set_position((\"axes\", 1.12))\n",
    "ax32.spines[\"top\"].set_visible(True)\n",
    "ax32.spines[\"top\"].set_edgecolor(\"black\")\n",
    "ax32.set_xticks(np.arange(auxpor_der, auxpor_izq+.01, (abs(auxpor_der-auxpor_izq)/(ax3_ticks-1))))\n",
    "ax32.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "################################################################################\n",
    "\n",
    "\n",
    "### CONDUCTIVITY ###\n",
    "cond_izq = 2000     \n",
    "cond_der = 0        \n",
    "\n",
    "ax4.plot(well[crv_con], well.index, color = \"black\", linewidth = 1.5)\n",
    "ax4.set_xlabel(f\"Conductivity ({well[crv_con].name})\")\n",
    "ax4.set_xlim(cond_izq,cond_der)\n",
    "ax4.xaxis.label.set_color(\"black\")\n",
    "ax4.tick_params(axis='x', colors=\"black\")\n",
    "ax4.spines[\"top\"].set_edgecolor(\"black\")\n",
    "ax4.set_xticks(np.arange(cond_der, cond_izq+1, (abs(cond_der-cond_izq)/(ax4_ticks-1))))\n",
    "ax4.xaxis.set_major_formatter(StrMethodFormatter('{x:.0f}'))\n",
    "################################################################################\n",
    "\n",
    "\n",
    "fig.suptitle(las.well.WELL.value+\"\\n\"+\"YACIMIENTO: \"+las.well.FLD.value+\"\\n\"+\"COMPAÑIA: \"+las.well.COMP.value,size=26,\n",
    "             x=0.36,y=1)\n",
    "\n",
    "# Common functions for setting up the plot can be extracted into\n",
    "# a for loop. This saves repeating code.\n",
    "\n",
    "for ax in [ax1, ax2, ax3, ax4]:\n",
    "    ax.set_ylim(bot_plot, top_plot)\n",
    "    ax.grid(which='major', color='lightgrey', linestyle='-')\n",
    "    ax.xaxis.set_ticks_position(\"top\")\n",
    "    ax.xaxis.set_label_position(\"top\")\n",
    "    ax.spines[\"top\"].set_position((\"axes\", 1.02))\n",
    " \n",
    "    \n",
    "for ax in [ax2, ax3, ax4]:\n",
    "    plt.setp(ax.get_yticklabels(), visible = False)\n",
    "  \n",
    "\n",
    "fig.subplots_adjust(wspace = 0.2)\n",
    "\n",
    "mplcursors.cursor(hover=True)\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Modelo'></a>\n",
    "# <font color='#1F618D'>2.2 Entrenamiento de la red</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Modelo_decl'></a>\n",
    "# <font color='#BA4A00'>2.2.1 Creacion df con las curvas que utilizaremos como features y la curva target, ambas en el tramo del pozo conveniente</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# DECLARACION DE CURVAS FEATURES y TARGET\n",
    "\n",
    "##############################################################\n",
    "# TRAMO A PROCESAR\n",
    "\n",
    "well_top = 1140\n",
    "well_bot = 2990\n",
    "\n",
    "\n",
    "#######################################\n",
    "# CURVAS PARA ENTRENAMIENTO CON KERAS\n",
    "\n",
    "crv_target = 'NPHI'\n",
    "\n",
    "crv_feature1 = 'CALI'\n",
    "crv_feature2 = 'GR'\n",
    "crv_feature3 = 'DTC'\n",
    "crv_feature4 = 'PEF'\n",
    "crv_feature5 = 'RHOB'\n",
    "crv_feature6 = 'RDEP'\n",
    "crv_feature7 = 'RMED'\n",
    "crv_feature8 = 'SP'\n",
    "crv_feature9 = 'NADA'\n",
    "crv_feature10 = 'NADA'\n",
    "\n",
    "\n",
    "##############################################################\n",
    "\n",
    "well_train = well[(well.DEPTH >= well_top) & (well.DEPTH <= well_bot)]\n",
    "\n",
    "well_train['target'] = well_train[crv_target]\n",
    "\n",
    "if 'features_list' in locals():\n",
    "    del features_list\n",
    "else:\n",
    "    features_list = []\n",
    "\n",
    "features_list = []    \n",
    "\n",
    "### \n",
    "\n",
    "if crv_feature1 in well_train.columns:\n",
    "    features_list.append(crv_feature1)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature2 in well_train.columns:\n",
    "    features_list.append(crv_feature2)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature3 in well_train.columns:\n",
    "    features_list.append(crv_feature3)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature4 in well_train.columns:\n",
    "    features_list.append(crv_feature4)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature5 in well_train.columns:\n",
    "    features_list.append(crv_feature5)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature6 in well_train.columns:\n",
    "    features_list.append(crv_feature6)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature7 in well_train.columns:\n",
    "    features_list.append(crv_feature7)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature8 in well_train.columns:\n",
    "    features_list.append(crv_feature8)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature9 in well_train.columns:\n",
    "    features_list.append(crv_feature9)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "if crv_feature10 in well_train.columns:\n",
    "    features_list.append(crv_feature10)\n",
    "else:\n",
    "    pass\n",
    "\n",
    "well_train_features = well_train[features_list]\n",
    "well_train_features"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# <big><big><big><font color='#y67E22'>**KERAS**</font></big></big></big>\n",
    "**input_dim:** https://github.com/christianversloot/machine-learning-articles/blob/main/how-to-find-the-value-for-keras-input_shape-input_dim.md<br>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Modelo_defs'></a>\n",
    "# <big><font color='#D35400'>2.2.2 Creación de funciones para graficar el modelo</font></big>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_plot_no_val(historia):\n",
    "        \n",
    "    plt.rcParams[\"figure.figsize\"] = (14,3.5)\n",
    "    plt.subplots_adjust(wspace=0.5)\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.plot(historia.history[f'{list(historia.history.keys())[0]}'])\n",
    "    #plt.plot(historia.history[f'{list(historia.history.keys())[2]}'])\n",
    "    plt.ylabel(f'Pérdida ({list(historia.history.keys())[0]})')\n",
    "    plt.xlabel('Iteración')\n",
    " #   plt.legend(['Entrenamiento','Validación'])\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.plot(historia.history[f'{list(historia.history.keys())[1]}'])\n",
    "   # plt.plot(historia.history[f'{list(historia.history.keys())[3]}'])\n",
    "    plt.ylabel(f'Métrica ({list(historia.history.keys())[1]})')\n",
    "    plt.xlabel('Iteración')\n",
    "#    plt.legend(['Entrenamiento','Validación'])\n",
    "\n",
    "    ax = plt.gca()\n",
    "    ax.yaxis.set_label_position(\"right\")\n",
    "    ax.yaxis.tick_right()\n",
    "    \n",
    "    plt.show()\n",
    "    \n",
    "##############################    \n",
    "    \n",
    "def get_plot_val(historia):\n",
    "    \n",
    "    \n",
    "    plt.rcParams[\"figure.figsize\"] = (14,3.5)\n",
    "    plt.subplots_adjust(wspace=0.5)\n",
    "    plt.subplot(1,2,1)\n",
    "    plt.plot(historia.history[f'{list(historia.history.keys())[0]}'])\n",
    "    plt.plot(historia.history[f'{list(historia.history.keys())[2]}'])\n",
    "    plt.ylabel(f'Pérdida ({list(historia.history.keys())[0]})')\n",
    "    plt.xlabel('Iteración')\n",
    "    plt.legend(['Entrenamiento','Validación'])\n",
    "\n",
    "    plt.subplot(1,2,2)\n",
    "    plt.plot(historia.history[f'{list(historia.history.keys())[1]}'])\n",
    "    plt.plot(historia.history[f'{list(historia.history.keys())[3]}'])\n",
    "    plt.ylabel(f'Métrica ({list(historia.history.keys())[1]})')\n",
    "    plt.xlabel('Iteración')\n",
    "    plt.legend(['Entrenamiento','Validación'])\n",
    "\n",
    "    ax = plt.gca()\n",
    "    ax.yaxis.set_label_position(\"right\")\n",
    "    ax.yaxis.tick_right()\n",
    "    \n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Modelo_fit'></a>\n",
    "# <big><font color='#D35400'>2.2.3 Keras: Entrenamiento del modelo (fit)</font></big>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = well_train_features\n",
    "Y = well_train['target']\n",
    "\n",
    "scaler = StandardScaler()\n",
    "scaler.fit(X)\n",
    "X = scaler.transform(X)\n",
    "\n",
    "x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2, random_state=True)\n",
    "\n",
    "\n",
    "model = Sequential()\n",
    "#model.add(Dense(1000, input_dim=len(well_train_features.columns), activation='relu'))\n",
    "model.add(Dense(1000, activation='relu'))\n",
    "# model.add(Dropout(0.9))\n",
    "model.add(Dense(250, activation='relu'))\n",
    "# model.add(Dropout(0.8))\n",
    "model.add(Dense(1, activation='sigmoid'))\n",
    "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['MeanSquaredError'])\n",
    "\n",
    "# log_dir = \"logs/fit/\" + datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n",
    "# tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=log_dir, histogram_freq=1, update_freq='batch')\n",
    "\n",
    "historia = model.fit(x_train, y_train, batch_size=10, epochs=10, validation_data=(x_test,y_test))\n",
    "\n",
    "clear_output()\n",
    "\n",
    "get_plot_val(historia) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Modelo_predict'></a>\n",
    "# <big><font color='#D35400'>2.2.4 Keras: Aplicación del modelo - obtención de la curva emulada (predict)</font></big>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crv_emulated = 'NPHI_emulada'\n",
    "well_train[crv_emulated]=model.predict(\n",
    "    X,\n",
    "    batch_size=10,\n",
    "    verbose=0,\n",
    "    steps=None,\n",
    "    callbacks=None,\n",
    "    max_queue_size=10,\n",
    "    workers=1,\n",
    "    use_multiprocessing=False)\n",
    "\n",
    "well_train"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='PozoEntrenador_Modelo_predict_plot'></a>\n",
    "# <big><font color='#D35400'>2.2.5 Plot para comparar curva target vs. curva emulada</font></big>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "top_plot= well_top\n",
    "bot_plot= well_bot\n",
    "\n",
    "crv_target = 'NPHI'\n",
    "crv_emulated = 'NPHI_emulada'\n",
    "\n",
    "# Escalas curvas\n",
    "target_izq = .6       \n",
    "target_der = 0    \n",
    "\n",
    "\n",
    "\n",
    "# numero de lineas verticales del track que va a depender de la escala de la curva\n",
    "ax1_ticks = 6         # Convencionales\n",
    "ax2_ticks = 6         # Resistividades\n",
    "ax3_ticks = 7         # Porosidades\n",
    "ax4_ticks = 7         # Target & Emulated\n",
    "\n",
    "\n",
    "\n",
    "##################### CODIGO ###################################################\n",
    "\n",
    "fig, ax = plt.subplots(figsize=(20,20))#Set up the plot axes\n",
    "   \n",
    "ax1 = plt.subplot2grid((1,6), (0,0), rowspan=1, colspan = 1) \n",
    "ax11 = ax1.twiny()\n",
    "ax12 = ax1.twiny()\n",
    "\n",
    "ax2 = plt.subplot2grid((1,6), (0,1), rowspan=1, colspan = 1, sharey = ax1)\n",
    "ax21 = ax2.twiny()\n",
    "\n",
    "ax3 = plt.subplot2grid((1,6), (0,2), rowspan=1, colspan = 1, sharey = ax1) #\n",
    "ax31 = ax3.twiny() \n",
    "ax32 = ax3.twiny() \n",
    "\n",
    "ax4 = plt.subplot2grid((1,6), (0,3), rowspan=1, colspan = 1, sharey = ax1) #\n",
    "ax41 = ax4.twiny() \n",
    "################################################################################\n",
    "\n",
    "### CAL ###\n",
    "cal_izq = 10     # min=izq \n",
    "cal_der = 20     # max=der\n",
    "\n",
    "ax1.plot(well_train[crv_cal], well_train.index, color = \"black\", linewidth = 0.5)\n",
    "ax1.set_ylabel(\"Depth (m)\")\n",
    "\n",
    "if abs(top_plot-bot_plot) > 500:\n",
    "    ax1.yaxis.set_major_locator(MaxNLocator(round(abs(top_plot-bot_plot)/99)))\n",
    "    \n",
    "elif abs(top_plot-bot_plot) <= 500 and abs(top_plot-bot_plot) > 200:\n",
    "    ax1.yaxis.set_major_locator(MaxNLocator(round(abs(top_plot-bot_plot)/49)))\n",
    "else:\n",
    "    ax1.yaxis.set_major_locator(MaxNLocator(round(abs(top_plot-bot_plot)/24)))\n",
    "    \n",
    "ax1.set_xlabel(f\"Caliper {well_train[crv_cal].name}\")\n",
    "ax1.set_xlim(cal_izq, cal_der)\n",
    "ax1.xaxis.label.set_color(\"black\")\n",
    "ax1.tick_params(axis='x', colors=\"black\")\n",
    "ax1.spines[\"top\"].set_edgecolor(\"black\")\n",
    "ax1.set_xticks(np.arange(cal_izq, cal_der+1, ((cal_der-cal_izq)/(ax1_ticks-1))))\n",
    "ax1.xaxis.set_major_formatter(StrMethodFormatter('{x:.0f}'))\n",
    "\n",
    "ax1.fill_betweenx(well_train.index, well_train[crv_bit], well_train[crv_cal],\n",
    "                  where=well_train[crv_bit]>=well_train[crv_cal], interpolate=True, color='brown')\n",
    "ax1.fill_betweenx(well_train.index, well_train[crv_bit], well_train[crv_cal],\n",
    "                  where=well_train[crv_bit]<=well_train[crv_cal], interpolate=True, color='#a6ecfa')\n",
    "################################################################################\n",
    "\n",
    "### GR ###\n",
    "gr_izq=0        \n",
    "gr_der=200      \n",
    "\n",
    "ax11.plot(well_train[crv_gr], well_train.index, color = \"green\", linewidth = 1.5)\n",
    "ax11.set_xlabel(f\"Gamma Ray ({well_train[crv_gr].name})\")\n",
    "ax11.xaxis.label.set_color(\"green\")\n",
    "ax11.set_xlim(gr_izq, gr_der)\n",
    "ax11.tick_params(axis='x', colors=\"green\")\n",
    "ax11.spines[\"top\"].set_position((\"axes\", 1.1))\n",
    "ax11.spines[\"top\"].set_visible(True)\n",
    "ax11.spines[\"top\"].set_edgecolor(\"green\")\n",
    "ax11.title.set_color('green')\n",
    "ax11.set_xticks(np.arange(gr_izq, gr_der+1, ((gr_der-gr_izq)/(ax1_ticks-1))))\n",
    "ax11.xaxis.set_major_formatter(StrMethodFormatter('{x:.0f}'))\n",
    "################################################################################\n",
    "\n",
    "### SP ###\n",
    "sp_izq=-80   \n",
    "sp_der=20     \n",
    "\n",
    "ax12.plot(well_train[crv_sp], well_train.index, color = \"red\", linewidth = 1.5)\n",
    "ax12.set_xlabel(f\"SP ({well_train[crv_sp].name})\")\n",
    "ax12.xaxis.label.set_color(\"red\")\n",
    "ax12.set_xlim(sp_izq,sp_der)\n",
    "ax12.tick_params(axis='x', colors=\"r\")\n",
    "ax12.spines[\"top\"].set_position((\"axes\", 1.06))\n",
    "ax12.spines[\"top\"].set_visible(True)\n",
    "ax12.spines[\"top\"].set_edgecolor(\"r\")\n",
    "ax12.title.set_color('r')\n",
    "ax12.set_xticks(np.arange(sp_izq, sp_der+1, ((sp_der-sp_izq)/(ax1_ticks-1))))\n",
    "ax12.xaxis.set_major_formatter(StrMethodFormatter('{x:.0f}'))\n",
    "################################################################################\n",
    "\n",
    "### RESD ###\n",
    "res_izq=0.1     \n",
    "res_der=100     \n",
    "\n",
    "ax2.plot(well_train[crv_dp_res], well_train.index, color = \"blue\", linewidth = 2)\n",
    "ax2.set_xlabel(f\"Deep Resistivity ({well_train[crv_dp_res].name})\")\n",
    "ax2.set_xlim(res_izq, res_der)\n",
    "ax2.xaxis.label.set_color(\"blue\")\n",
    "ax2.tick_params(axis='x', colors=\"blue\")\n",
    "ax2.spines[\"top\"].set_edgecolor(\"blue\")\n",
    "ax2.set_xticks(np.arange(res_izq, res_der+.1, (res_der/(ax2_ticks-1))))\n",
    "ax2.set_xscale(\"log\")\n",
    "ax2.grid(True, which=\"both\", axis='x')\n",
    "ax2.xaxis.set_major_formatter(StrMethodFormatter('{x:.1f}'))\n",
    "################################################################################\n",
    "\n",
    "### RESS ###\n",
    "\n",
    "\n",
    "ax21.plot(well_train[crv_sh_res], well_train.index, color = \"r\", linewidth = 0.5)\n",
    "ax21.set_xlabel(f\"Shallow Resistivity ({well_train[crv_sh_res].name})\")\n",
    "ax21.set_xlim(res_izq, res_der)\n",
    "ax21.xaxis.label.set_color(\"r\")\n",
    "ax21.spines[\"top\"].set_position((\"axes\", 1.06))\n",
    "ax21.spines[\"top\"].set_visible(True)\n",
    "ax21.tick_params(axis='x', colors=\"r\")\n",
    "ax21.spines[\"top\"].set_edgecolor(\"r\")\n",
    "ax21.set_xticks(np.arange(res_izq, res_der+.1, ((res_der-res_izq)/(ax2_ticks-1))))\n",
    "ax21.set_xscale(\"log\")\n",
    "ax21.xaxis.set_major_formatter(StrMethodFormatter('{x:.1f}'))\n",
    "################################################################################\n",
    "\n",
    "### DEN BULK ###\n",
    "denbulk_izq = 1.65      \n",
    "denbulk_der = 2.65      \n",
    "\n",
    "\n",
    "ax3.plot(well_train[crv_den_bulk], well_train.index, color = \"red\", linewidth = 1.0)\n",
    "ax3.set_xlabel(f\"Density Bulk ({well_train[crv_den_bulk].name})\")\n",
    "ax3.set_xlim(denbulk_izq,denbulk_der)\n",
    "ax3.xaxis.label.set_color(\"red\")\n",
    "ax3.tick_params(axis='x', colors=\"r\")\n",
    "ax3.spines[\"top\"].set_edgecolor(\"r\")\n",
    "ax3.set_xticks(np.arange(denbulk_der, denbulk_izq+.01, ((denbulk_izq-denbulk_der)/(ax3_ticks-1))))\n",
    "ax3.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "################################################################################\n",
    "\n",
    "### NEU POR ###\n",
    "neupor_izq = .6     \n",
    "neupor_der = 0      \n",
    "\n",
    "ax31.plot(well_train[crv_neu_por], well_train.index, color = \"blue\", linewidth = 1.0)\n",
    "ax31.set_xlabel(f\"Neutron Porosity ({well_train[crv_neu_por].name})\")\n",
    "ax31.xaxis.label.set_color(\"b\")\n",
    "ax31.set_xlim(neupor_izq,neupor_der)\n",
    "ax31.tick_params(axis='x', colors=\"blue\")\n",
    "ax31.spines[\"top\"].set_position((\"axes\", 1.06))\n",
    "ax31.spines[\"top\"].set_visible(True)\n",
    "ax31.spines[\"top\"].set_edgecolor(\"blue\")\n",
    "ax31.set_xticks(np.arange(neupor_der, neupor_izq+.01, (abs(neupor_der-neupor_izq)/(ax3_ticks-1))))\n",
    "ax31.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "################################################################################\n",
    "\n",
    "### AUX POR ###\n",
    "auxpor_izq = .6    \n",
    "auxpor_der = 0     \n",
    "auxpor_desc = 'Empty Porosity'\n",
    "\n",
    "ax32.plot(well_train[crv_nmr_por], well_train.index, color = \"black\", linewidth = 1.0)\n",
    "ax32.set_xlabel(f\"{auxpor_desc} ({well_train[crv_nmr_por].name})\")\n",
    "ax32.xaxis.label.set_color(\"black\")\n",
    "ax32.set_xlim(auxpor_izq,auxpor_der)\n",
    "ax32.tick_params(axis='x', colors=\"black\")\n",
    "ax32.spines[\"top\"].set_position((\"axes\", 1.1))\n",
    "ax32.spines[\"top\"].set_visible(True)\n",
    "ax32.spines[\"top\"].set_edgecolor(\"black\")\n",
    "ax32.set_xticks(np.arange(auxpor_der, auxpor_izq+.01, (abs(auxpor_der-auxpor_izq)/(ax3_ticks-1))))\n",
    "ax32.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "################################################################################\n",
    "### TARGET & EMULATED ###\n",
    "\n",
    "ax4.plot(well_train[crv_target], well_train.index, color = \"black\", linewidth = 1.5)\n",
    "ax4.set_xlabel(f\"Target ({well_train[crv_target].name})\")\n",
    "ax4.set_xlim(target_izq,target_der)\n",
    "ax4.xaxis.label.set_color(\"black\")\n",
    "ax4.tick_params(axis='x', colors=\"black\")\n",
    "ax4.spines[\"top\"].set_edgecolor(\"black\")\n",
    "ax4.set_xticks(np.arange(neupor_der, neupor_izq+.01, (abs(neupor_der-neupor_izq)/(ax4_ticks-1))))\n",
    "ax4.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "\n",
    "\n",
    "ax41.plot(well_train[crv_emulated], well_train.index, color = \"red\", linewidth = 0.5)\n",
    "ax41.set_xlabel(f\"Emulated ({well_train[crv_emulated].name})\")\n",
    "ax41.xaxis.label.set_color(\"r\")\n",
    "ax41.set_xlim(target_izq,target_der)\n",
    "ax41.tick_params(axis='x', colors=\"red\")\n",
    "ax41.spines[\"top\"].set_position((\"axes\", 1.06))\n",
    "ax41.spines[\"top\"].set_visible(True)\n",
    "ax41.spines[\"top\"].set_edgecolor(\"red\")\n",
    "ax41.set_xticks(np.arange(neupor_der, neupor_izq+.01, (abs(neupor_der-neupor_izq)/(ax4_ticks-1))))\n",
    "ax41.xaxis.set_major_formatter(StrMethodFormatter('{x:.2f}'))\n",
    "\n",
    "\n",
    "\n",
    "################################################################################\n",
    "\n",
    "\n",
    "fig.suptitle(\"CURVA TARGET vs. CURVA EMULADA\"+\"\\n\"+\"POZO: \"+las.well.well.value,size=26,\n",
    "             x=0.035,y=1,ha=\"left\")\n",
    "\n",
    "# Common functions for setting up the plot can be extracted into\n",
    "# a for loop. This saves repeating code.\n",
    "\n",
    "for ax in [ax1, ax2, ax3, ax4]:\n",
    "    ax.set_ylim(bot_plot, top_plot)\n",
    "    ax.grid(which='major', color='lightgrey', linestyle='-')\n",
    "    ax.xaxis.set_ticks_position(\"top\")\n",
    "    ax.xaxis.set_label_position(\"top\")\n",
    "    ax.spines[\"top\"].set_position((\"axes\", 1.02))\n",
    " \n",
    "    \n",
    "for ax in [ax2, ax3, ax4]:\n",
    "    plt.setp(ax.get_yticklabels(), visible = False)\n",
    "  \n",
    "\n",
    "fig.subplots_adjust(wspace = 0.2)\n",
    "\n",
    "mplcursors.cursor(hover=True)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "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.9.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}