regresion15.10.2021.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "regresionYaiza.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "mount_file_id": "1NjF9cLr8zCv5U-FHJM5K3WEaySpCHEKQ",
      "authorship_tag": "ABX9TyM136tCljh/K3fqvOKn6/xc",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/angelminsua/python/blob/main/regresion15.10.2021.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "CopIR19-XqJE",
        "outputId": "acbc7f8d-0a90-4cb8-acf2-39d7eace90a8"
      },
      "source": [
        "\n",
        "from keras.models import Sequential\n",
        "from keras import layers\n",
        "import pathlib\n",
        "import matplotlib.pyplot as plt\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "import tensorflow as tf\n",
        "from tensorflow import keras\n",
        "from tensorflow.keras import layers\n",
        "import numpy as np\n",
        "\n",
        "#Multilayer Perceptron (MLP): https://www.pyimagesearch.com/2019/01/21/regression-with-keras/\n",
        "def create_mlp(dim, regress=True):\n",
        "\t# define our MLP network\n",
        "\tmodel = Sequential()\n",
        "\tmodel.add(layers.Dense(12, input_dim=dim, activation=\"relu\"))\n",
        "\t#model.add(layers.Dense(100, activation=\"relu\"))\n",
        "\tmodel.add(layers.Dense(18, activation=\"relu\"))\n",
        "\t# check to see if the regression node should be added\n",
        "\tif regress:\n",
        "\t  model.add(layers.Dense(1, activation=\"linear\"))\n",
        "\t\n",
        "\toptimizer_rms = tf.keras.optimizers.RMSprop(0.05) #parametro que se puede cambiar para mejorar \n",
        "\t#from tf.keras.optimizers import SGD #from keras.optimizers import SGD\n",
        "\t#optimizer_sgd = SGD(learning_rate=0.01)\n",
        "\tmodel.compile(loss='mse', optimizer=optimizer_rms, metrics=['mae', 'mse'])\n",
        "\treturn model\n",
        "\n",
        "#alternativa al metodo anterior\n",
        "\"\"\"\n",
        "def build_model():\n",
        "  model = Sequential([layers.Dense(99, activation='relu', input_shape=[len(train_dataset.keys())]),layers.Dense(64, activation='relu'),layers.Dense(1)])\n",
        "\n",
        "  optimizer = tf.keras.optimizers.RMSprop(0.001)\n",
        "\n",
        "  model.compile(loss='mse',\n",
        "                optimizer=optimizer,\n",
        "                metrics=['mae', 'mse'])\n",
        "  return model\n",
        "\"\"\"\n",
        "\n",
        "print(tf.__version__)\n",
        "!pwd\n",
        "\n",
        "dataset = pd.read_excel('df_datos_regresion_googleColab.xlsx', sheet_name='Sheet1')\n",
        "print(\"dataset sin normalizar=\", dataset.head(3))\n",
        "\n",
        "# dividimos el set de datos en un set de entrenamiento y otro de pruebas. Usaremos el set de pruebas en la evaluacion final de nuestro modelo.\n",
        "\n",
        "x_df = dataset.drop('BusTime', axis=1)\n",
        "y_df= dataset['BusTime']\n",
        "print(\"x_df=\", x_df)\n",
        "print(\"y_df=\", y_df)\n",
        "\n",
        "\n",
        "#normalizar dataset\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "scaler= MinMaxScaler()\n",
        "scaler = scaler.fit(x_df)\n",
        "x= scaler.transform(x_df)\n",
        "print(\"x_df=\", (x_df))\n",
        "y = y_df.to_numpy()\n",
        "\n",
        "from sklearn.model_selection import train_test_split\n",
        "train_dataset, test_data, train_labels, test_labels = train_test_split(x, y, test_size=0.2, random_state = 3) #train_dataset es X_train, test_data es X_test, train_labels es y_train, test_labels es y_test. parameter \"random_state\": If we want the splits to be reproducible.Otherwise, each time we run train_test_split, different indices will be splitted into training and test set.\n",
        "print(\"train_dataset.shape[1]==========================================\", train_dataset.shape[1])\n",
        "\n",
        "model = create_mlp(train_dataset.shape[1],True) #build_model()\n",
        "model.summary()\n",
        "\n",
        "\n",
        "#Entrenar a la modelo\n",
        "#Entrene el modelo durante 1000 épocas y registre la precisión de entrenamiento y validación en el objeto history.\n",
        "\n",
        "# Display training progress by printing a single dot for each completed epoch\n",
        "class PrintDot(keras.callbacks.Callback):\n",
        "  def on_epoch_end(self, epoch, logs):\n",
        "    if epoch % 100 == 0: print('')\n",
        "    print('.', end='')\n",
        "\n",
        "EPOCHS = 2\n",
        "history = model.fit(train_dataset, train_labels, epochs=EPOCHS, validation_split = 0.3, verbose=0, callbacks=[PrintDot()]) #entrenamos la red neuronal\n",
        "print(\"history.params=\", history.params)\n",
        "print(\"history.history.keys()=\", history.history.keys()) # dict_keys=(['loss', 'mae', 'mse', 'val_loss', 'val_mae', 'val_mse'])\n",
        "print(\"history.history=\", history.history)\n",
        "\n",
        "loss, mae, mse = model.evaluate(test_data, test_labels, verbose=2) #ahora q tenemos un modelo (red neuronal con pesos específicos) lo evaluamos con los datos de test para ver el error\n",
        "print(\"Errores (MAE y MSE) obtenidos con los datos de Test:\")\n",
        "print(\"Mean Abs Error (MAE): {:5.2f} MPG\".format(mae))\n",
        "print(\"MSE: {:5.2f} MPG\".format(mse))\n",
        "\n",
        "#Visualizar el progreso de entrenamiento del modelo usando las estadísticas almacenadas en el objeto history.\n",
        "hist = pd.DataFrame(history.history)\n",
        "hist['epoch'] = history.epoch\n",
        "hist.tail()\n",
        "\n",
        "\n",
        "hist = pd.DataFrame(history.history)\n",
        "hist['epoch'] = history.epoch\n",
        "#https://www.tensorflow.org/tutorials/keras/regression?hl=es-419\n",
        "plt.figure() \n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Mean Abs Error(MAE) [MPG]')\n",
        "plt.plot(hist['epoch'], hist['mae'],label='Train Error')\n",
        "plt.plot(hist['epoch'], hist['val_mae'],label = 'Val Error')\n",
        "plt.ylim([0,100])\n",
        "plt.legend()\n",
        "\n",
        "plt.figure()\n",
        "plt.xlabel('Epoch')\n",
        "plt.ylabel('Mean Square Error(MSE) [$MPG^2$]')\n",
        "plt.plot(hist['epoch'], hist['mse'],label='Train Error')\n",
        "plt.plot(hist['epoch'], hist['val_mse'],label = 'Val Error')\n",
        "plt.ylim([0,8000])\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "\n",
        "#plot the training and validation accuracy and loss at each epoch\n",
        "loss = history.history['loss'] #training loss\n",
        "val_loss = history.history['val_loss'] #validation loss\n",
        "epochs = range(1, len(loss) + 1)\n",
        "plt.plot(epochs, loss, 'y', label='Training loss')\n",
        "plt.plot(epochs, val_loss, 'r', label='Validation loss')\n",
        "plt.title('Training and validation loss')\n",
        "plt.xlabel('Epochs')\n",
        "plt.ylabel('Loss')\n",
        "plt.legend()\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "test_predictions = model.predict(test_data).flatten()\n",
        "#dibujamos las predicciones (cada punto debería dar a la misma altura en el eje x y en el y)\n",
        "plt.subplot(1, 2, 1)\n",
        "plt.scatter(test_labels, test_predictions)\n",
        "plt.xlabel('True Values [MPG]')\n",
        "plt.ylabel('Predictions [MPG]')\n",
        "plt.axis('equal')\n",
        "plt.axis('square')\n",
        "plt.xlim([0,plt.xlim()[1]])\n",
        "plt.ylim([0,plt.ylim()[1]])\n",
        "_ = plt.plot([-100, 100], [-100, 100])\n",
        "plt.show()\n",
        " \n",
        "#Echemos un vistazo a la distribución de errores. Debería seguir una normal\n",
        "error = test_predictions - test_labels\n",
        "plt.subplot(1, 2, 2)\n",
        "plt.hist(error, bins = 25)\n",
        "plt.xlabel(\"Prediction Error [MPG]\")\n",
        "_ = plt.ylabel(\"Count\")\n",
        "plt.show()\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#from sklearn.metrics import r2_score\n",
        "from sklearn import metrics\n",
        "MAE = metrics.mean_absolute_error(test_labels, test_predictions)\n",
        "MSE = metrics.mean_squared_error(test_labels, test_predictions)\n",
        "RMSE = np.sqrt(metrics.mean_squared_error(test_labels, test_predictions))\n",
        "r_square = r2_score(test_labels, test_predictions) #coeficiente de determinacion\n",
        "print('Mean Absolute Error (MAE):', MAE) #test_labels es y_test (la variable dependiente pero solo el trozo del test, no el del train)\n",
        "print('Mean Squared Error (MSE):', MSE) #test_predictions es y_pred (la prediccion de \"y\" (variable dependiente) que nos dio el modelo al llamar a  model.predict(test_data))\n",
        "print('Root Mean Squared Error (RMSE):', RMSE) #es la raiz cuadrada del MSE\n",
        "print(\"r_square (coeficiente de determinacion) =\", r_square )\n",
        "\n",
        "\n",
        "\n",
        "\"\"\"\n",
        "Guardando el modelo\n",
        "Puede guardar un modelo creado con la API funcional en un solo archivo. Posteriormente, puede volver a crear el mismo modelo a partir de este archivo, incluso si ya no tiene acceso al codigo que creo el modelo.\n",
        "Este archivo incluye:\n",
        "-Los modelos de arquitectura\n",
        "-Los valores de peso del modelo (que se aprendieron durante el entrenamiento)\n",
        "-La configuración de entrenamiento del modelo (lo que pasó a 'compilar'), si corresponde\n",
        "-El optimizador y su estado, si corresponde (esto le permite reiniciar el entrenamiento donde lo dejó)\n",
        "\"\"\"\n",
        "# Guardar el Modelo\n",
        "saved_model_path = \"./my_model.h5\"\n",
        "model.save(saved_model_path)\n",
        "# Recrea exactamente el mismo modelo solo desde el archivo\n",
        "new_model = keras.models.load_model(saved_model_path)\n",
        "# Tenga en cuenta que el estado del optimizador también se conserva. Puede reanudar el entrenamiento donde lo dejó.\n",
        "\n",
        "\n",
        "\n",
        "\n",
        "#print(\"model.score======\", model.score(test_labels, test_predictions))\n",
        "\n",
        "\"\"\"\n",
        "from sklearn.model_selection import KFold, cross_validate, cross_val_score #cross_validate: evaluate metric(s) by cross-validation and also record fit/score times.   cross_val_score: Evaluate a score by cross-validation\n",
        "cv_results = cross_validate(model, x_df, y_df, cv=3,  scoring=('r2', 'neg_mean_squared_error'), return_train_score=True)\n",
        "print(\"cv_results=\",cv_results)\n",
        "# cross_validate also allows to specify metrics which you want to see\n",
        "for i, score in enumerate(cross_validate(model, test_data, test_labels, cv=3)[\"test_score\"]):\n",
        "    print(f\"Accuracy for the fold no. {i} on the test set: {score}\")\n",
        "\"\"\""
      ],
      "execution_count": 33,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.6.0\n",
            "/content\n",
            "dataset sin normalizar=    StreamPatronage  TrafficFlowRate  ...  PreviousPatronage  BusTime\n",
            "0                1       118.333333  ...                  6      504\n",
            "1               11       168.000000  ...                 11      743\n",
            "2               10       216.222222  ...                  9      632\n",
            "\n",
            "[3 rows x 7 columns]\n",
            "x_df=        StreamPatronage  TrafficFlowRate  ...  AccumulatedRainfall  PreviousPatronage\n",
            "0                    1       118.333333  ...                  0.0                  6\n",
            "1                   11       168.000000  ...                  0.0                 11\n",
            "2                   10       216.222222  ...                  0.0                  9\n",
            "3                   26       330.952381  ...                  0.0                 12\n",
            "4                   13       413.111111  ...                  0.0                 19\n",
            "...                ...              ...  ...                  ...                ...\n",
            "21586               20       467.222222  ...                  0.0                 24\n",
            "21587               20       390.000000  ...                  0.0                 22\n",
            "21588                1       408.000000  ...                  0.0                  9\n",
            "21589               11       383.555556  ...                  0.0                 19\n",
            "21590                1       265.833333  ...                  0.0                  8\n",
            "\n",
            "[21591 rows x 6 columns]\n",
            "y_df= 0        504\n",
            "1        743\n",
            "2        632\n",
            "3        785\n",
            "4        599\n",
            "        ... \n",
            "21586    622\n",
            "21587    694\n",
            "21588    480\n",
            "21589    659\n",
            "21590    476\n",
            "Name: BusTime, Length: 21591, dtype: int64\n",
            "x_df=        StreamPatronage  TrafficFlowRate  ...  AccumulatedRainfall  PreviousPatronage\n",
            "0                    1       118.333333  ...                  0.0                  6\n",
            "1                   11       168.000000  ...                  0.0                 11\n",
            "2                   10       216.222222  ...                  0.0                  9\n",
            "3                   26       330.952381  ...                  0.0                 12\n",
            "4                   13       413.111111  ...                  0.0                 19\n",
            "...                ...              ...  ...                  ...                ...\n",
            "21586               20       467.222222  ...                  0.0                 24\n",
            "21587               20       390.000000  ...                  0.0                 22\n",
            "21588                1       408.000000  ...                  0.0                  9\n",
            "21589               11       383.555556  ...                  0.0                 19\n",
            "21590                1       265.833333  ...                  0.0                  8\n",
            "\n",
            "[21591 rows x 6 columns]\n",
            "train_dataset.shape[1]========================================== 6\n",
            "Model: \"sequential_28\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "dense_63 (Dense)             (None, 12)                84        \n",
            "_________________________________________________________________\n",
            "dense_64 (Dense)             (None, 18)                234       \n",
            "_________________________________________________________________\n",
            "dense_65 (Dense)             (None, 1)                 19        \n",
            "=================================================================\n",
            "Total params: 337\n",
            "Trainable params: 337\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n",
            "\n",
            "..history.params= {'verbose': 0, 'epochs': 2, 'steps': 378}\n",
            "history.history.keys()= dict_keys(['loss', 'mae', 'mse', 'val_loss', 'val_mae', 'val_mse'])\n",
            "history.history= {'loss': [29492.88671875, 8105.50927734375], 'mae': [101.67842102050781, 70.89384460449219], 'mse': [29492.88671875, 8105.50927734375], 'val_loss': [9530.837890625, 8481.9287109375], 'val_mae': [78.53298950195312, 73.68411254882812], 'val_mse': [9530.837890625, 8481.9287109375]}\n",
            "135/135 - 0s - loss: 8612.0615 - mae: 74.3842 - mse: 8612.0615\n",
            "Errores (MAE y MSE) obtenidos con los datos de Test:\n",
            "Mean Abs Error (MAE): 74.38 MPG\n",
            "MSE: 8612.06 MPG\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mean Absolute Error (MAE): 74.38416674844257\n",
            "Mean Squared Error (MSE): 8612.060681670839\n",
            "Root Mean Squared Error (RMSE): 92.8011890100059\n",
            "r_square (coeficiente de determinacion) = 0.5863418299390536\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-33-26322494a801>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m    190\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    191\u001b[0m \u001b[0;31m# Exportar el modelo a 'SavedModel'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 192\u001b[0;31m \u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexport_saved_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'path_to_saved_model'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m    193\u001b[0m \u001b[0;31m# Recrea exactamente el mismo modelo\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    194\u001b[0m \u001b[0mnew_model\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mkeras\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mexperimental\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mload_from_saved_model\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'path_to_saved_model'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
            "\u001b[0;31mAttributeError\u001b[0m: module 'keras.api._v2.keras.experimental' has no attribute 'export_saved_model'"
          ]
        }
      ]
    }
  ]
}