08_Evaluacion_Resultados_Modelo_Final.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/rodraxphysics/Master_VIU_Data_Science/blob/main/08_Evaluacion_Resultados_Modelo_Final.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ti5Wnz3cgkRD"
      },
      "source": [
        "## <center>  <center>\n",
        "## <center> Universidad Internacional de Valencia (VIU) <center>\n",
        "## <center> Trabajo Fin de Master (TFM) <center>\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "# <center> **Predicción de la magnitud de la banda prohibida (bandgap) en compuestos inorgánicos mediante técnicas de Machine Learning** <center>\n",
        "\n",
        "\n",
        "---\n",
        "\n",
        "\n",
        "\n",
        "**Titulación:** Máster en Big Data y Data Science\n",
        "\n",
        "**Alumno:** Rodrigo Eduardo Sandoval Brito\n",
        "\n",
        "**Director:** Jose Carlos González, PhD.\n",
        "\n",
        "\n",
        "\n",
        "---\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## <center> **Evaluacion de resultados de Modelo Final** <center>"
      ],
      "metadata": {
        "id": "nLbDeZac_mzc"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "523Qmp4r2Puq"
      },
      "source": [
        "Comenzamos importando los 3 datasets proporcionados por DataDriven"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "QcqAjsMIKluO"
      },
      "outputs": [],
      "source": [
        "# Imports generales\n",
        "import pandas as pd\n",
        "import io\n",
        "from google.colab import files\n",
        "import numpy as np\n",
        "import time\n",
        "\n",
        "def upload_files (index_fields=None):\n",
        "  uploaded = files.upload()\n",
        "  for fn in uploaded.keys():\n",
        "    print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "        name=fn, length=len(uploaded[fn])))\n",
        "    df = pd.read_csv(io.StringIO(uploaded[fn].decode('utf-8')), index_col = index_fields)\n",
        "\n",
        "  return df\n",
        "\n",
        "df = upload_files()"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Obtenemos una copia del dataset final ya que dataset utilizado por el algoritmo de regresion es distinto al dataset utilizado por el algoritmo de clasificacion, con la diferencia en que el bandgap es numerico en regresion y booleano en clasificacion**"
      ],
      "metadata": {
        "id": "DfYxmxKa_xfB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df1=df.copy()"
      ],
      "metadata": {
        "id": "B-J7_HN0MdYN"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Transformamos variable numerica del bandgap a booleana para aplicar los algoritmos de clasificacion**"
      ],
      "metadata": {
        "id": "N6tK42ye_ymJ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df['band_gap'] = df['band_gap'].apply(lambda x: 1 if x != 0 else 0)"
      ],
      "metadata": {
        "id": "pFKl-UQfDIMM"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Normalizacion de las caracteristicas y division de datos training y test en ratio 80/20**"
      ],
      "metadata": {
        "id": "nG57MDNu_4kx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "scaler = MinMaxScaler()\n",
        "\n",
        "selected_features = ['nsites', 'nelements', 'volume', 'density', 'density_atomic', 'crystal_symmetry', 'symmetry_number', 'sides_abc', 'angles_abc', 'uncorrected_energy_per_atom', 'energy_per_atom', 'formation_energy_per_atom', 'energy_above_hull', 'is_stable', 'efermi', 'is_magnetic', 'total_magnetization', 'num_magnetic_sites', 'molecular_weight', 'Ho_count', 'Ho_mass_ratio', 'Ti_count', 'Ti_mass_ratio', 'Lu_count', 'Lu_mass_ratio', 'Hf_count', 'Hf_mass_ratio', 'Cu_count', 'Cu_mass_ratio', 'Ga_count', 'Ga_mass_ratio', 'Ba_count', 'Ba_mass_ratio', 'Te_count', 'Te_mass_ratio', 'Au_count', 'Au_mass_ratio', 'Ce_count', 'Ce_mass_ratio', 'Pa_count', 'Pa_mass_ratio', 'Br_count', 'Br_mass_ratio', 'Gd_count', 'Gd_mass_ratio', 'Nb_count', 'Nb_mass_ratio', 'Dy_count', 'Dy_mass_ratio', 'Os_count', 'Os_mass_ratio', 'Nd_count', 'Nd_mass_ratio', 'Co_count', 'Co_mass_ratio', 'Zn_count', 'Zn_mass_ratio', 'Ni_count', 'Ni_mass_ratio', 'V_count', 'V_mass_ratio', 'Cd_count', 'Cd_mass_ratio', 'Hg_count', 'Hg_mass_ratio', 'La_count', 'La_mass_ratio', 'Cs_count', 'Cs_mass_ratio', 'B_count', 'B_mass_ratio', 'Ag_count', 'Ag_mass_ratio', 'Ru_count', 'Ru_mass_ratio', 'Ar_count', 'Ar_mass_ratio', 'Tb_count', 'Tb_mass_ratio', 'Y_count', 'Y_mass_ratio', 'Sn_count', 'Sn_mass_ratio', 'Fe_count', 'Fe_mass_ratio', 'Yb_count', 'Yb_mass_ratio', 'P_count', 'P_mass_ratio', 'Sb_count', 'Sb_mass_ratio', 'Er_count', 'Er_mass_ratio', 'Ir_count', 'Ir_mass_ratio', 'Th_count', 'Th_mass_ratio', 'Si_count', 'Si_mass_ratio', 'O_count', 'O_mass_ratio', 'F_count', 'F_mass_ratio', 'Na_count', 'Na_mass_ratio', 'Pr_count', 'Pr_mass_ratio', 'N_count', 'N_mass_ratio', 'Mo_count', 'Mo_mass_ratio', 'Se_count', 'Se_mass_ratio', 'Kr_count', 'Kr_mass_ratio', 'Tl_count', 'Tl_mass_ratio', 'Mg_count', 'Mg_mass_ratio', 'Rb_count', 'Rb_mass_ratio', 'Ne_count', 'Ne_mass_ratio', 'Li_count', 'Li_mass_ratio', 'W_count', 'W_mass_ratio', 'Eu_count', 'Eu_mass_ratio', 'Al_count', 'Al_mass_ratio', 'Pm_count', 'Pm_mass_ratio', 'Sr_count', 'Sr_mass_ratio', 'Rh_count', 'Rh_mass_ratio', 'As_count', 'As_mass_ratio', 'Pt_count', 'Pt_mass_ratio', 'Cr_count', 'Cr_mass_ratio', 'Pd_count', 'Pd_mass_ratio', 'Tc_count', 'Tc_mass_ratio', 'I_count', 'I_mass_ratio', 'Sm_count', 'Sm_mass_ratio', 'Re_count', 'Re_mass_ratio', 'Ge_count', 'Ge_mass_ratio', 'Cl_count', 'Cl_mass_ratio', 'S_count', 'S_mass_ratio', 'U_count', 'U_mass_ratio', 'H_count', 'H_mass_ratio', 'Tm_count', 'Tm_mass_ratio', 'In_count', 'In_mass_ratio', 'K_count', 'K_mass_ratio', 'Bi_count', 'Bi_mass_ratio', 'Mn_count', 'Mn_mass_ratio', 'Ca_count', 'Ca_mass_ratio', 'Sc_count', 'Sc_mass_ratio', 'Pu_count', 'Pu_mass_ratio', 'Ac_count', 'Ac_mass_ratio', 'Be_count', 'Be_mass_ratio', 'Xe_count', 'Xe_mass_ratio', 'C_count', 'C_mass_ratio', 'He_count', 'He_mass_ratio', 'Zr_count', 'Zr_mass_ratio', 'Np_count', 'Np_mass_ratio', 'Ta_count', 'Ta_mass_ratio', 'Pb_count', 'Pb_mass_ratio']\n",
        "\n",
        "X=df[selected_features]\n",
        "y=df[\"band_gap\"]\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "X_train = scaler.fit_transform(X_train)\n",
        "X_test = scaler.transform(X_test)\n",
        "\n",
        "print(X_test.shape)\n",
        "print(X_train.shape)\n",
        "print(y_train.shape)\n",
        "print(y_test.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zpMry2MWCz2U",
        "outputId": "2ad0a658-f7a4-45b3-c84c-8ef3ea198384"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(5845, 197)\n",
            "(23377, 197)\n",
            "(23377,)\n",
            "(5845,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Aplicamos el algoritmo de Clasificacion RFC con hiperparametros ya optimizados**"
      ],
      "metadata": {
        "id": "kfRd4RdgLtY-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import RandomForestClassifier\n",
        "from sklearn.metrics import accuracy_score, confusion_matrix, classification_report\n",
        "from sklearn.metrics import roc_auc_score\n",
        "\n",
        "# Inicializar el clasificador de Random Forest\n",
        "best_params={'n_estimators': 681, 'min_samples_split': 4, 'min_samples_leaf': 1, 'max_features': 'log2', 'max_depth': 37, 'bootstrap': False}\n",
        "rf = RandomForestClassifier(**best_params,random_state=42)\n",
        "\n",
        "# Entrenar el modelo con el conjunto de entrenamiento\n",
        "rf.fit(X_train, y_train)\n",
        "\n",
        "# Realizar predicciones en el conjunto de prueba\n",
        "y_pred = rf.predict(X_test)\n",
        "\n",
        "# Calcular y mostrar la precisión del modelo\n",
        "accuracy = accuracy_score(y_test, y_pred)\n",
        "roc_auc = roc_auc_score(y_test, y_pred)\n",
        "\n",
        "print(\"Precisión del modelo en el conjunto de prueba:\", accuracy)\n",
        "\n",
        "# Mostrar la matriz de confusión\n",
        "print(\"Matriz de confusión:\\n\", confusion_matrix(y_test, y_pred))\n",
        "\n",
        "# Mostrar el informe de clasificación\n",
        "print(\"Informe de clasificación:\\n\", classification_report(y_test, y_pred))\n",
        "\n",
        "print(\"ROC-AUC:\", roc_auc)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sm2AotbuM0fa",
        "outputId": "4d9c75d4-48f2-4245-f55a-fefd9477a428"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Precisión del modelo en el conjunto de prueba: 0.9271171941830625\n",
            "Matriz de confusión:\n",
            " [[3056  236]\n",
            " [ 190 2363]]\n",
            "Informe de clasificación:\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "           0       0.94      0.93      0.93      3292\n",
            "           1       0.91      0.93      0.92      2553\n",
            "\n",
            "    accuracy                           0.93      5845\n",
            "   macro avg       0.93      0.93      0.93      5845\n",
            "weighted avg       0.93      0.93      0.93      5845\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Separamos los valores de bandgap de cero para evaluarlos con RFC y los valores distintos de cero para evaluarlos con GBR**"
      ],
      "metadata": {
        "id": "Z5TtSsVHIche"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Predecir con el clasificador\n",
        "y_pred_class = rf.predict(X_test)\n",
        "\n",
        "# Dividir X_test en dos partes\n",
        "X_test_zero = X_test[y_pred_class == 0]\n",
        "X_test_nonzero = X_test[y_pred_class != 0]\n",
        "\n",
        "# Para los valores cero, ya sabemos que el valor predicho es cero, entonces:\n",
        "y_pred_zero = np.zeros(X_test_zero.shape[0])"
      ],
      "metadata": {
        "id": "n-bqgDevId4L"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Aplicamos el algoritmo de Regresion GBR con hiperparametros ya optimizados**"
      ],
      "metadata": {
        "id": "YwVuxVDmM4Tx"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "df=df1.copy()"
      ],
      "metadata": {
        "id": "H88z9GLpM5th"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "scaler = MinMaxScaler()\n",
        "\n",
        "selected_features = ['nsites', 'nelements', 'volume', 'density', 'density_atomic', 'crystal_symmetry', 'symmetry_number', 'sides_abc', 'angles_abc', 'uncorrected_energy_per_atom', 'energy_per_atom', 'formation_energy_per_atom', 'energy_above_hull', 'is_stable', 'efermi', 'is_magnetic', 'total_magnetization', 'num_magnetic_sites', 'molecular_weight', 'Ho_count', 'Ho_mass_ratio', 'Ti_count', 'Ti_mass_ratio', 'Lu_count', 'Lu_mass_ratio', 'Hf_count', 'Hf_mass_ratio', 'Cu_count', 'Cu_mass_ratio', 'Ga_count', 'Ga_mass_ratio', 'Ba_count', 'Ba_mass_ratio', 'Te_count', 'Te_mass_ratio', 'Au_count', 'Au_mass_ratio', 'Ce_count', 'Ce_mass_ratio', 'Pa_count', 'Pa_mass_ratio', 'Br_count', 'Br_mass_ratio', 'Gd_count', 'Gd_mass_ratio', 'Nb_count', 'Nb_mass_ratio', 'Dy_count', 'Dy_mass_ratio', 'Os_count', 'Os_mass_ratio', 'Nd_count', 'Nd_mass_ratio', 'Co_count', 'Co_mass_ratio', 'Zn_count', 'Zn_mass_ratio', 'Ni_count', 'Ni_mass_ratio', 'V_count', 'V_mass_ratio', 'Cd_count', 'Cd_mass_ratio', 'Hg_count', 'Hg_mass_ratio', 'La_count', 'La_mass_ratio', 'Cs_count', 'Cs_mass_ratio', 'B_count', 'B_mass_ratio', 'Ag_count', 'Ag_mass_ratio', 'Ru_count', 'Ru_mass_ratio', 'Ar_count', 'Ar_mass_ratio', 'Tb_count', 'Tb_mass_ratio', 'Y_count', 'Y_mass_ratio', 'Sn_count', 'Sn_mass_ratio', 'Fe_count', 'Fe_mass_ratio', 'Yb_count', 'Yb_mass_ratio', 'P_count', 'P_mass_ratio', 'Sb_count', 'Sb_mass_ratio', 'Er_count', 'Er_mass_ratio', 'Ir_count', 'Ir_mass_ratio', 'Th_count', 'Th_mass_ratio', 'Si_count', 'Si_mass_ratio', 'O_count', 'O_mass_ratio', 'F_count', 'F_mass_ratio', 'Na_count', 'Na_mass_ratio', 'Pr_count', 'Pr_mass_ratio', 'N_count', 'N_mass_ratio', 'Mo_count', 'Mo_mass_ratio', 'Se_count', 'Se_mass_ratio', 'Kr_count', 'Kr_mass_ratio', 'Tl_count', 'Tl_mass_ratio', 'Mg_count', 'Mg_mass_ratio', 'Rb_count', 'Rb_mass_ratio', 'Ne_count', 'Ne_mass_ratio', 'Li_count', 'Li_mass_ratio', 'W_count', 'W_mass_ratio', 'Eu_count', 'Eu_mass_ratio', 'Al_count', 'Al_mass_ratio', 'Pm_count', 'Pm_mass_ratio', 'Sr_count', 'Sr_mass_ratio', 'Rh_count', 'Rh_mass_ratio', 'As_count', 'As_mass_ratio', 'Pt_count', 'Pt_mass_ratio', 'Cr_count', 'Cr_mass_ratio', 'Pd_count', 'Pd_mass_ratio', 'Tc_count', 'Tc_mass_ratio', 'I_count', 'I_mass_ratio', 'Sm_count', 'Sm_mass_ratio', 'Re_count', 'Re_mass_ratio', 'Ge_count', 'Ge_mass_ratio', 'Cl_count', 'Cl_mass_ratio', 'S_count', 'S_mass_ratio', 'U_count', 'U_mass_ratio', 'H_count', 'H_mass_ratio', 'Tm_count', 'Tm_mass_ratio', 'In_count', 'In_mass_ratio', 'K_count', 'K_mass_ratio', 'Bi_count', 'Bi_mass_ratio', 'Mn_count', 'Mn_mass_ratio', 'Ca_count', 'Ca_mass_ratio', 'Sc_count', 'Sc_mass_ratio', 'Pu_count', 'Pu_mass_ratio', 'Ac_count', 'Ac_mass_ratio', 'Be_count', 'Be_mass_ratio', 'Xe_count', 'Xe_mass_ratio', 'C_count', 'C_mass_ratio', 'He_count', 'He_mass_ratio', 'Zr_count', 'Zr_mass_ratio', 'Np_count', 'Np_mass_ratio', 'Ta_count', 'Ta_mass_ratio', 'Pb_count', 'Pb_mass_ratio']\n",
        "\n",
        "X=df[selected_features]\n",
        "y=df[\"band_gap\"]\n",
        "\n",
        "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
        "\n",
        "X_train = scaler.fit_transform(X_train)\n",
        "X_test = scaler.transform(X_test)\n",
        "\n",
        "print(X_test.shape)\n",
        "print(X_train.shape)\n",
        "print(y_train.shape)\n",
        "print(y_test.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NrQKK_zoNyBS",
        "outputId": "ea725cd0-1793-48eb-d831-b190fce732e7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(5845, 197)\n",
            "(23377, 197)\n",
            "(23377,)\n",
            "(5845,)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.ensemble import GradientBoostingRegressor\n",
        "from sklearn.model_selection import train_test_split\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "from sklearn.metrics import r2_score\n",
        "from sklearn.metrics import mean_absolute_error\n",
        "import numpy as np\n",
        "\n",
        "# Modelos con hiperparámetros específicos\n",
        "gb_parameters ={'learning_rate': 0.05, 'max_depth': 10, 'max_features': 'sqrt', 'min_samples_leaf': 4, 'min_samples_split': 10, 'n_estimators': 620, 'subsample': 0.99}\n",
        "gb_model = GradientBoostingRegressor(**gb_parameters, random_state=42)\n",
        "\n",
        "# Entrenamiento\n",
        "gb_model.fit(X_train, y_train)\n",
        "\n",
        "# Predicciones individuales\n",
        "y_pred_gb = gb_model.predict(X_test)\n",
        "\n",
        "# Evaluación individual\n",
        "r2_gb = r2_score(y_test, y_pred_gb)\n",
        "\n",
        "# Evaluación del ensemble\n",
        "mae_gb= mean_absolute_error(y_test, y_pred_gb)\n",
        "\n",
        "# Mostrar las métricas\n",
        "print(\"R² Gradient Boosting:\", r2_gb)\n",
        "print(\"MAE Gradient Boosting:\", mae_gb)\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "qcMFASIx1oEf",
        "outputId": "1ed1500a-cb15-4341-bdf7-dda5c473ffa8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "R² Gradient Boosting: 0.8892974667211315\n",
            "MAE Gradient Boosting: 0.30202681798443304\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Combinamos las predicciones de ambos modelos, cuando bandgap es igual a cero utilizamos RFC y cuando es distinto de cero usamos GBR**"
      ],
      "metadata": {
        "id": "dQWPJ4jgAUIv"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#Predecir los valores no cero con el modelo de regresión\n",
        "y_pred_nonzero = gb_model.predict(X_test_nonzero)\n",
        "\n",
        "# Primero, crea un array vacío para almacenar las predicciones finales\n",
        "y_pred_final = np.empty(X_test.shape[0])\n",
        "\n",
        "# Rellena el array con las predicciones de cero\n",
        "y_pred_final[y_pred_class == 0] = y_pred_zero\n",
        "\n",
        "# Rellena el resto con las predicciones de no cero\n",
        "y_pred_final[y_pred_class != 0] = y_pred_nonzero"
      ],
      "metadata": {
        "id": "kcIXxkvPQLMn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Evaluamos las predicciones en dataset de test y observamos que modelo final presenta coeficiente de determinacion de 0.89 y MAE de 0.25**"
      ],
      "metadata": {
        "id": "BV9mq9L2AhP6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from sklearn.metrics import mean_squared_error\n",
        "\n",
        "r2_ensemble = r2_score(y_test, y_pred_final)\n",
        "mae_ensamble= mean_absolute_error(y_test, y_pred_final)\n",
        "rmse_ensemble = np.sqrt(mean_squared_error(y_test, y_pred_final))\n",
        "\n",
        "# Mostrar las métricas\n",
        "print(\"R² Ensemble (Random Forest + Gradient Boosting):\", r2_ensemble)\n",
        "print(\"MAE Ensemble (Random Forest + Gradient Boosting):\", mae_ensamble)\n",
        "print(\"RMSE Ensemble (Random Forest + Gradient Boosting):\", rmse_ensemble)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MMj7B1guNKMH",
        "outputId": "0fba7f28-4a82-4920-95d8-881bddd10f9b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "R² Ensemble (Random Forest + Gradient Boosting): 0.8913345029112099\n",
            "MAE Ensemble (Random Forest + Gradient Boosting): 0.25904640278456564\n",
            "RMSE Ensemble (Random Forest + Gradient Boosting): 0.5278919244707677\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**R² de modelo final**: 0.8913345029112099\n",
        "\n",
        "**MAE de modelo final:**  0.25904640278456564"
      ],
      "metadata": {
        "id": "Fa3DIrIEAojl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Evaluamos las predicciones del modelo final**"
      ],
      "metadata": {
        "id": "BNwOrFyWAze6"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "formatted_predictions = [max(round(prediction, 4), 0) for prediction in y_pred_final]\n",
        "\n",
        "df_visualization = pd.DataFrame({\n",
        "    'y_real': y_test[100:130].values,\n",
        "    'y_pred': formatted_predictions[100:130]\n",
        "})\n",
        "\n",
        "print(df_visualization)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zJVErdspweRU",
        "outputId": "d05a1be5-4e79-42fc-b8c5-f76589c6134e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "    y_real  y_pred\n",
            "0   8.0448  7.4473\n",
            "1   0.0000  0.0000\n",
            "2   0.0000  0.0000\n",
            "3   4.2353  3.6754\n",
            "4   0.0000  0.2133\n",
            "5   2.9492  1.8457\n",
            "6   0.0000  0.0000\n",
            "7   0.0000  0.0000\n",
            "8   2.8210  1.9941\n",
            "9   3.8866  3.0316\n",
            "10  1.5858  0.9219\n",
            "11  0.1950  0.4538\n",
            "12  0.0000  0.0000\n",
            "13  3.3844  2.4757\n",
            "14  0.0000  0.0000\n",
            "15  2.3958  1.6782\n",
            "16  1.1346  0.7680\n",
            "17  5.3288  4.1602\n",
            "18  0.0000  0.0000\n",
            "19  0.0000  0.0000\n",
            "20  0.0000  0.0000\n",
            "21  0.0000  0.0000\n",
            "22  0.0000  0.0000\n",
            "23  0.0000  0.0000\n",
            "24  3.2641  3.0055\n",
            "25  0.0000  0.0000\n",
            "26  1.6437  0.8718\n",
            "27  4.0182  3.7860\n",
            "28  3.3909  2.7840\n",
            "29  0.0000  0.0000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Generamos grafico de comparacion de valores reales y predichos por modelo final para 30 predicciones del dataset de testing**"
      ],
      "metadata": {
        "id": "FLzfxHneBXo8"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "# Crear un gráfico de líneas\n",
        "plt.plot(df_visualization['y_real'], label='y_real', marker='o')\n",
        "plt.plot(df_visualization['y_pred'], label='y_pred', marker='o')\n",
        "\n",
        "# Agregar etiquetas y título\n",
        "plt.ylabel('Band Gap (eV)')\n",
        "plt.title('Primeras 30 predicciones del modelo ensamble (RFC+GBR)')\n",
        "#plt.ylim(0, 7)\n",
        "# Agregar leyenda\n",
        "plt.legend()\n",
        "\n",
        "# Mostrar el recuadro con las etiquetas \"y_real\" y \"y_pred\"\n",
        "plt.legend(loc='upper right', bbox_to_anchor=(1,1))\n",
        "\n",
        "# Mostrar el gráfico\n",
        "\n",
        "plt.savefig('predicciones_modelo_final.svg', format='svg', bbox_inches='tight')\n",
        "\n",
        "plt.show()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 452
        },
        "id": "UyT5AEbrKaB6",
        "outputId": "c2a3a712-c37a-4732-9ec2-834a55fa5b00"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "pip install cairosvg"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dByPKRrKi7xg",
        "outputId": "6450c916-4d4b-4053-afe8-b0a77bd432d0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Collecting cairosvg\n",
            "  Downloading CairoSVG-2.7.1-py3-none-any.whl (43 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m43.2/43.2 kB\u001b[0m \u001b[31m523.2 kB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting cairocffi (from cairosvg)\n",
            "  Downloading cairocffi-1.6.1-py3-none-any.whl (75 kB)\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m75.1/75.1 kB\u001b[0m \u001b[31m1.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25hCollecting cssselect2 (from cairosvg)\n",
            "  Downloading cssselect2-0.7.0-py3-none-any.whl (15 kB)\n",
            "Requirement already satisfied: defusedxml in /usr/local/lib/python3.10/dist-packages (from cairosvg) (0.7.1)\n",
            "Requirement already satisfied: pillow in /usr/local/lib/python3.10/dist-packages (from cairosvg) (9.4.0)\n",
            "Requirement already satisfied: tinycss2 in /usr/local/lib/python3.10/dist-packages (from cairosvg) (1.2.1)\n",
            "Requirement already satisfied: cffi>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from cairocffi->cairosvg) (1.16.0)\n",
            "Requirement already satisfied: webencodings in /usr/local/lib/python3.10/dist-packages (from cssselect2->cairosvg) (0.5.1)\n",
            "Requirement already satisfied: pycparser in /usr/local/lib/python3.10/dist-packages (from cffi>=1.1.0->cairocffi->cairosvg) (2.21)\n",
            "Installing collected packages: cssselect2, cairocffi, cairosvg\n",
            "Successfully installed cairocffi-1.6.1 cairosvg-2.7.1 cssselect2-0.7.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import cairosvg\n",
        "# Convert SVG to PDF with adjustable DPI\n",
        "svg_file = 'predicciones_modelo_final.svg'\n",
        "pdf_file = 'predicciones_modelo_final.pdf'\n",
        "dpi = 300  # Adjust DPI as needed\n",
        "\n",
        "# Convert SVG to PDF with specified DPI\n",
        "cairosvg.svg2pdf(url=svg_file, write_to=pdf_file, dpi=dpi)\n",
        "\n",
        "print(f\"Archivo PDF '{pdf_file}' creado con éxito.\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MJAMvD1vi7Ta",
        "outputId": "b9ede761-e543-4d2f-bb52-050e003cb8e4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Archivo PDF 'predicciones_modelo_final.pdf' creado con éxito.\n"
          ]
        }
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}