WeatherPredictionEnsembleClassifiers.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "gpuType": "T4"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "source": [
        "!pip install scikit-learn numpy pandas scipy matplotlib joblib"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "huwsobR5HlN7",
        "outputId": "2d71e3bf-50af-48c8-890d-88f4b386821c",
        "collapsed": true
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Requirement already satisfied: scikit-learn in /usr/local/lib/python3.10/dist-packages (1.2.2)\n",
            "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (1.25.2)\n",
            "Requirement already satisfied: pandas in /usr/local/lib/python3.10/dist-packages (2.0.3)\n",
            "Requirement already satisfied: scipy in /usr/local/lib/python3.10/dist-packages (1.11.4)\n",
            "Requirement already satisfied: matplotlib in /usr/local/lib/python3.10/dist-packages (3.7.1)\n",
            "Requirement already satisfied: joblib in /usr/local/lib/python3.10/dist-packages (1.4.2)\n",
            "Requirement already satisfied: threadpoolctl>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from scikit-learn) (3.5.0)\n",
            "Requirement already satisfied: python-dateutil>=2.8.2 in /usr/local/lib/python3.10/dist-packages (from pandas) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2020.1 in /usr/local/lib/python3.10/dist-packages (from pandas) (2023.4)\n",
            "Requirement already satisfied: tzdata>=2022.1 in /usr/local/lib/python3.10/dist-packages (from pandas) (2024.1)\n",
            "Requirement already satisfied: contourpy>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.2.1)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (0.12.1)\n",
            "Requirement already satisfied: fonttools>=4.22.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (4.53.0)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (1.4.5)\n",
            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (24.1)\n",
            "Requirement already satisfied: pillow>=6.2.0 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (9.4.0)\n",
            "Requirement already satisfied: pyparsing>=2.3.1 in /usr/local/lib/python3.10/dist-packages (from matplotlib) (3.1.2)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.10/dist-packages (from python-dateutil>=2.8.2->pandas) (1.16.0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import pandas as pd\n",
        "import numpy as np\n",
        "from sklearn.model_selection import train_test_split, GridSearchCV, cross_val_score, learning_curve, validation_curve\n",
        "from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, VotingClassifier\n",
        "from sklearn.svm import SVC\n",
        "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
        "from sklearn.preprocessing import LabelEncoder\n",
        "from scipy import stats\n",
        "import matplotlib.pyplot as plt\n",
        "import joblib\n"
      ],
      "metadata": {
        "collapsed": true,
        "id": "y_fmqqfzQFrr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class WeatherModel:\n",
        "    def __init__(self, file_path):\n",
        "        self.file_path = file_path\n",
        "        self.model = None\n",
        "        self.X_train = None\n",
        "        self.X_test = None\n",
        "        self.y_train = None\n",
        "        self.y_test = None\n",
        "        self.label_encoders = {}\n",
        "        self.best_params = None\n",
        "        self.best_score = None\n",
        "        self.cv_results = None\n",
        "\n",
        "    def load_and_preprocess_data(self):\n",
        "        df = pd.read_csv(self.file_path)\n",
        "        df = df.dropna()\n",
        "\n",
        "        for column in df.select_dtypes(include=['object']).columns:\n",
        "            self.label_encoders[column] = LabelEncoder()\n",
        "            df.loc[:, column] = self.label_encoders[column].fit_transform(df[column])\n",
        "\n",
        "        X = df.drop('RainTomorrow', axis=1)\n",
        "        y = df['RainTomorrow'].astype(int)\n",
        "\n",
        "        #Hold-out com 30% para teste e 70% para treino\n",
        "        self.X_train, self.X_test, self.y_train, self.y_test = train_test_split(X, y, test_size=0.3, random_state=1, shuffle = True, stratify = y)\n",
        "\n",
        "    def train_model(self):\n",
        "        rfc = RandomForestClassifier()\n",
        "        gbc = GradientBoostingClassifier()\n",
        "\n",
        "        #Classificador ensemble com os 2 modelos\n",
        "        ensemble_clf = VotingClassifier(estimators=[\n",
        "            ('rfc', rfc),\n",
        "            ('gbc', gbc),\n",
        "        ], voting='soft')\n",
        "\n",
        "        #Lista de parametros do gridsearch, RandomForest e Gradient boosting classifier\n",
        "        param_grid = {\n",
        "            'rfc__n_estimators': [100,200,300],\n",
        "            'gbc__n_estimators': [100,200,300],\n",
        "            'gbc__learning_rate': [0.5,0.1,0.01],\n",
        "        }\n",
        "\n",
        "        #GridSearch com 10 fold\n",
        "        grid_search = GridSearchCV(estimator=ensemble_clf, param_grid=param_grid, cv=10, n_jobs=-1, verbose=2, error_score='raise')\n",
        "        grid_search.fit(self.X_train, self.y_train)\n",
        "        #Mostrando os resultados da busca\n",
        "        print(grid_search.cv_results_)\n",
        "        #Selecionando o Melhor modelo do gridsearch\n",
        "        self.model = grid_search.best_estimator_\n",
        "\n",
        "        # Coletar os melhores parâmetros e a melhor pontuação\n",
        "        self.best_params = grid_search.best_params_\n",
        "        self.best_score = grid_search.best_score_\n",
        "        self.cv_results = grid_search.cv_results_\n",
        "\n",
        "    def save_model(self, filename='best_ensemble_model.pkl'):\n",
        "        joblib.dump(self.model, filename)\n",
        "\n",
        "    def load_model(self, filename='best_ensemble_model.pkl'):\n",
        "        self.model = joblib.load(filename)\n",
        "\n",
        "    def evaluate_model(self):\n",
        "        # Acurácia no conjunto de treino\n",
        "        y_train_pred = self.model.predict(self.X_train)\n",
        "        train_accuracy = accuracy_score(self.y_train, y_train_pred)\n",
        "        print(f\"Train Accuracy: {train_accuracy:.4f}\")\n",
        "\n",
        "        # Acurácia no conjunto de teste\n",
        "        y_test_pred = self.model.predict(self.X_test)\n",
        "        test_accuracy = accuracy_score(self.y_test, y_test_pred)\n",
        "        print(f\"Test Accuracy: {test_accuracy:.4f}\")\n",
        "\n",
        "        print(\"Classification Report (Test Set):\\n\", classification_report(self.y_test, y_test_pred))\n",
        "        print(\"Confusion Matrix (Test Set):\\n\", confusion_matrix(self.y_test, y_test_pred))\n",
        "\n",
        "        print(\"Classification Report (Train Set):\\n\", classification_report(self.y_train, y_train_pred))\n",
        "        print(\"Confusion Matrix (Train Set):\\n\", confusion_matrix(self.y_train, y_train_pred))\n",
        "\n",
        "        # Avaliação de overfitting usando validação cruzada no conjunto de treino e teste\n",
        "        train_scores = cross_val_score(self.model, self.X_train, self.y_train, cv=10)\n",
        "        test_scores = cross_val_score(self.model, self.X_test, self.y_test, cv=10)\n",
        "\n",
        "        train_mean = np.mean(train_scores)\n",
        "        test_mean = np.mean(test_scores)\n",
        "        conf_interval = stats.norm.interval(0.95, loc=test_mean, scale=stats.sem(test_scores))\n",
        "\n",
        "        print(f\"Train Scores Mean: {train_mean:.4f}\")\n",
        "        print(f\"Test Scores Mean: {test_mean:.4f}\")\n",
        "        print(f\"95% Confidence Interval for Test Scores: ({conf_interval[0]:.4f}, {conf_interval[1]:.4f})\")\n",
        "\n",
        "    def get_best_params_and_results(self):\n",
        "        print(f\"Best Parameters: {self.best_params}\")\n",
        "        print(f\"Best Cross-Validation Score: {self.best_score:.4f}\")\n",
        "        print(\"CV Results:\")\n",
        "        for mean_score, params in zip(self.cv_results['mean_test_score'], self.cv_results['params']):\n",
        "            print(f\"{mean_score:.4f} with: {params}\")\n",
        "\n",
        "    def plot_learning_curve(self):\n",
        "        def plot_learning_curve(estimator, title, X, y, cv=10, n_jobs=-1, train_sizes=np.linspace(0.1, 1.0, 5)):\n",
        "            plt.figure()\n",
        "            plt.title(title)\n",
        "            plt.xlabel(\"Training examples\")\n",
        "            plt.ylabel(\"Score\")\n",
        "\n",
        "            train_sizes, train_scores, test_scores = learning_curve(\n",
        "                estimator, X, y, cv=cv, n_jobs=n_jobs, train_sizes=train_sizes, scoring='accuracy')\n",
        "\n",
        "            train_scores_mean = np.mean(train_scores, axis=1)\n",
        "            train_scores_std = np.std(train_scores, axis=1)\n",
        "            test_scores_mean = np.mean(test_scores, axis=1)\n",
        "            test_scores_std = np.std(test_scores, axis=1)\n",
        "\n",
        "            plt.grid()\n",
        "\n",
        "            plt.fill_between(train_sizes, train_scores_mean - train_scores_std,\n",
        "                             train_scores_mean + train_scores_std, alpha=0.1,\n",
        "                             color=\"r\")\n",
        "            plt.fill_between(train_sizes, test_scores_mean - test_scores_std,\n",
        "                             test_scores_mean + test_scores_std, alpha=0.1, color=\"g\")\n",
        "            plt.plot(train_sizes, train_scores_mean, 'o-', color=\"r\",\n",
        "                     label=\"Training score\")\n",
        "            plt.plot(train_sizes, test_scores_mean, 'o-', color=\"g\",\n",
        "                     label=\"Cross-validation score\")\n",
        "\n",
        "            plt.legend(loc=\"best\")\n",
        "            return plt\n",
        "\n",
        "        plot_learning_curve(self.model, \"Learning Curve (Best Model)\", self.X_train, self.y_train, cv=10)\n",
        "        plt.show()\n",
        "\n",
        "    def plot_validation_curves(self):\n",
        "        def plot_validation_curve(estimator, title, X, y, param_name, param_range, cv=10, n_jobs=-1):\n",
        "            train_scores, test_scores = validation_curve(\n",
        "                estimator, X, y, param_name=param_name, param_range=param_range,\n",
        "                cv=cv, scoring='accuracy', n_jobs=n_jobs)\n",
        "\n",
        "            train_scores_mean = np.mean(train_scores, axis=1)\n",
        "            train_scores_std = np.std(train_scores, axis=1)\n",
        "            test_scores_mean = np.mean(test_scores, axis=1)\n",
        "            test_scores_std = np.std(test_scores, axis=1)\n",
        "\n",
        "            plt.figure()\n",
        "            plt.title(title)\n",
        "            plt.xlabel(param_name)\n",
        "            plt.ylabel(\"Score\")\n",
        "            plt.ylim(0.0, 1.1)\n",
        "            plt.grid()\n",
        "\n",
        "            plt.fill_between(param_range, train_scores_mean - train_scores_std,\n",
        "                             train_scores_mean + train_scores_std, alpha=0.1,\n",
        "                             color=\"r\")\n",
        "            plt.fill_between(param_range, test_scores_mean - test_scores_std,\n",
        "                             test_scores_mean + test_scores_std, alpha=0.1, color=\"g\")\n",
        "            plt.plot(param_range, train_scores_mean, 'o-', color=\"r\",\n",
        "                     label=\"Training score\")\n",
        "            plt.plot(param_range, test_scores_mean, 'o-', color=\"g\",\n",
        "                     label=\"Cross-validation score\")\n",
        "\n",
        "            plt.legend(loc=\"best\")\n",
        "            return plt\n",
        "\n",
        "        plot_validation_curve(self.model.named_estimators_['rfc'], \"Validation Curve (RandomForestClassifier, n_estimators)\",\n",
        "                              self.X_train, self.y_train, param_name='n_estimators', param_range=[100, 200, 300], cv=10)\n",
        "        plt.show()\n",
        "\n",
        "        plot_validation_curve(self.model.named_estimators_['gbc'], \"Validation Curve (GradientBoostingClassifier, n_estimators)\",\n",
        "                              self.X_train, self.y_train, param_name='n_estimators', param_range=[100, 200, 300], cv=10)\n",
        "        plt.show()\n",
        "\n",
        "        plot_validation_curve(self.model.named_estimators_['gbc'], \"Validation Curve (GradientBoostingClassifier, learning_rate)\",\n",
        "                              self.X_train, self.y_train, param_name='learning_rate', param_range=[0.01, 0.1, 0.5], cv=10)\n",
        "        plt.show()"
      ],
      "metadata": {
        "id": "HlzUiayg6ZFI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "weather_model = WeatherModel(file_path='/content/drive/MyDrive/2024_01/Aprendizado de Máquina/dataset/weatherAUS.csv' )\n",
        "weather_model.load_and_preprocess_data()\n",
        "weather_model.train_model()\n",
        "weather_model.save_model()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3piYu9_B6ae3",
        "outputId": "7c2402eb-a146-4605-dd4a-c0769d7f7614",
        "collapsed": true
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Fitting 10 folds for each of 27 candidates, totalling 270 fits\n",
            "{'mean_fit_time': array([28.33199315, 40.03051333, 51.73886271, 43.44426312, 55.03225992,\n",
            "       67.04761541, 58.58266101, 70.81263561, 82.67007422, 27.60023921,\n",
            "       39.65007265, 52.03485465, 43.24018118, 54.65998216, 66.80807798,\n",
            "       58.00937846, 69.71452363, 82.46174126, 27.85086067, 39.56347017,\n",
            "       51.22923689, 43.21443002, 54.9607959 , 66.48505409, 58.25856574,\n",
            "       70.20742424, 82.20450377]), 'std_fit_time': array([0.40446119, 0.78020064, 0.87190889, 0.73057648, 1.03979962,\n",
            "       1.26754922, 0.85438295, 1.28208662, 0.83216576, 0.93942455,\n",
            "       0.76944814, 1.02898608, 0.88375355, 1.28734028, 1.01161715,\n",
            "       0.47785238, 1.43554155, 1.10890313, 0.86938022, 1.13337354,\n",
            "       0.52352288, 0.76689039, 0.92054163, 0.74500801, 0.61187194,\n",
            "       1.16849254, 0.80195962]), 'mean_score_time': array([0.18597732, 0.32020071, 0.49679451, 0.17070823, 0.3288321 ,\n",
            "       0.43900235, 0.18635473, 0.29602256, 0.54672987, 0.16427963,\n",
            "       0.31494102, 0.43808141, 0.16805089, 0.28766499, 0.41446862,\n",
            "       0.1835851 , 0.27592952, 0.45117843, 0.16990478, 0.34767029,\n",
            "       0.44700851, 0.17931077, 0.29264925, 0.46271639, 0.18237448,\n",
            "       0.30736127, 0.45900044]), 'std_score_time': array([0.0479825 , 0.07595938, 0.15965984, 0.04367697, 0.07946186,\n",
            "       0.11551047, 0.0530704 , 0.06920119, 0.17403146, 0.03652499,\n",
            "       0.08497349, 0.10579203, 0.03089807, 0.05224561, 0.09891166,\n",
            "       0.05999361, 0.01083041, 0.09947387, 0.04064034, 0.08816006,\n",
            "       0.13079561, 0.04985086, 0.0670437 , 0.10851853, 0.05212054,\n",
            "       0.06487404, 0.10762291]), 'param_gbc__learning_rate': masked_array(data=[0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.5, 0.1, 0.1,\n",
            "                   0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.01, 0.01, 0.01,\n",
            "                   0.01, 0.01, 0.01, 0.01, 0.01, 0.01],\n",
            "             mask=[False, False, False, False, False, False, False, False,\n",
            "                   False, False, False, False, False, False, False, False,\n",
            "                   False, False, False, False, False, False, False, False,\n",
            "                   False, False, False],\n",
            "       fill_value='?',\n",
            "            dtype=object), 'param_gbc__n_estimators': masked_array(data=[100, 100, 100, 200, 200, 200, 300, 300, 300, 100, 100,\n",
            "                   100, 200, 200, 200, 300, 300, 300, 100, 100, 100, 200,\n",
            "                   200, 200, 300, 300, 300],\n",
            "             mask=[False, False, False, False, False, False, False, False,\n",
            "                   False, False, False, False, False, False, False, False,\n",
            "                   False, False, False, False, False, False, False, False,\n",
            "                   False, False, False],\n",
            "       fill_value='?',\n",
            "            dtype=object), 'param_rfc__n_estimators': masked_array(data=[100, 200, 300, 100, 200, 300, 100, 200, 300, 100, 200,\n",
            "                   300, 100, 200, 300, 100, 200, 300, 100, 200, 300, 100,\n",
            "                   200, 300, 100, 200, 300],\n",
            "             mask=[False, False, False, False, False, False, False, False,\n",
            "                   False, False, False, False, False, False, False, False,\n",
            "                   False, False, False, False, False, False, False, False,\n",
            "                   False, False, False],\n",
            "       fill_value='?',\n",
            "            dtype=object), 'params': [{'gbc__learning_rate': 0.5, 'gbc__n_estimators': 100, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 100, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 100, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 200, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 200, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 200, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 300, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 300, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.5, 'gbc__n_estimators': 300, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 100, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 100, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 100, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 200, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 200, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 200, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 300, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 300, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.1, 'gbc__n_estimators': 300, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 100, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 100, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 100, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 200, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 200, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 200, 'rfc__n_estimators': 300}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 300, 'rfc__n_estimators': 100}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 300, 'rfc__n_estimators': 200}, {'gbc__learning_rate': 0.01, 'gbc__n_estimators': 300, 'rfc__n_estimators': 300}], 'split0_test_score': array([0.8643038 , 0.86253165, 0.86202532, 0.86151899, 0.86405063,\n",
            "       0.8643038 , 0.86151899, 0.86253165, 0.86151899, 0.85974684,\n",
            "       0.85848101, 0.85721519, 0.86202532, 0.86075949, 0.86050633,\n",
            "       0.86075949, 0.85924051, 0.86126582, 0.84936709, 0.85037975,\n",
            "       0.84987342, 0.85341772, 0.85392405, 0.85468354, 0.85443038,\n",
            "       0.85468354, 0.85392405]), 'split1_test_score': array([0.87139241, 0.87139241, 0.87139241, 0.87113924, 0.87417722,\n",
            "       0.87316456, 0.87443038, 0.87265823, 0.87341772, 0.86759494,\n",
            "       0.86936709, 0.87012658, 0.86962025, 0.87189873, 0.86987342,\n",
            "       0.87088608, 0.87012658, 0.87113924, 0.85873418, 0.85898734,\n",
            "       0.85721519, 0.86481013, 0.86227848, 0.86405063, 0.86481013,\n",
            "       0.86481013, 0.86303797]), 'split2_test_score': array([0.8635443 , 0.86278481, 0.86379747, 0.86202532, 0.86405063,\n",
            "       0.86227848, 0.86405063, 0.86151899, 0.86075949, 0.86025316,\n",
            "       0.85949367, 0.86025316, 0.85974684, 0.86      , 0.85873418,\n",
            "       0.86151899, 0.86278481, 0.86227848, 0.85417722, 0.85392405,\n",
            "       0.85367089, 0.85848101, 0.85822785, 0.85772152, 0.85974684,\n",
            "       0.85949367, 0.85949367]), 'split3_test_score': array([0.86151899, 0.86151899, 0.85949367, 0.85746835, 0.86101266,\n",
            "       0.86050633, 0.86      , 0.86025316, 0.86151899, 0.85696203,\n",
            "       0.85417722, 0.85696203, 0.85721519, 0.85746835, 0.85544304,\n",
            "       0.85949367, 0.86      , 0.85974684, 0.84962025, 0.8478481 ,\n",
            "       0.84860759, 0.85037975, 0.85367089, 0.85468354, 0.84886076,\n",
            "       0.85367089, 0.85189873]), 'split4_test_score': array([0.87313244, 0.87034692, 0.86958724, 0.87060015, 0.87490504,\n",
            "       0.87110661, 0.87034692, 0.87262598, 0.87135984, 0.86756141,\n",
            "       0.86933401, 0.86781464, 0.87009369, 0.87034692, 0.87085338,\n",
            "       0.87034692, 0.87060015, 0.87085338, 0.85743226, 0.85895163,\n",
            "       0.85945809, 0.86452266, 0.86477589, 0.86553558, 0.86832109,\n",
            "       0.86654849, 0.86705495]), 'split5_test_score': array([0.86680172, 0.86578881, 0.86654849, 0.86604204, 0.86426944,\n",
            "       0.86705495, 0.86376298, 0.86502912, 0.86705495, 0.85641935,\n",
            "       0.85971132, 0.85819195, 0.86021778, 0.86097746, 0.86224361,\n",
            "       0.86300329, 0.86224361, 0.86275006, 0.85008863, 0.85186123,\n",
            "       0.85186123, 0.85363383, 0.85489997, 0.85489997, 0.85565966,\n",
            "       0.85439352, 0.8551532 ]), 'split6_test_score': array([0.86275006, 0.86376298, 0.86477589, 0.86528235, 0.86604204,\n",
            "       0.86553558, 0.86376298, 0.86553558, 0.86705495, 0.86275006,\n",
            "       0.86300329, 0.86123069, 0.86452266, 0.86452266, 0.86528235,\n",
            "       0.86275006, 0.86730818, 0.86477589, 0.85186123, 0.84755634,\n",
            "       0.84907572, 0.85287415, 0.85641935, 0.8551532 , 0.85591289,\n",
            "       0.85591289, 0.8569258 ]), 'split7_test_score': array([0.85616612, 0.85540643, 0.85540643, 0.8569258 , 0.85819195,\n",
            "       0.85819195, 0.85363383, 0.85743226, 0.85616612, 0.851608  ,\n",
            "       0.8533806 , 0.85084832, 0.85439352, 0.85363383, 0.85489997,\n",
            "       0.85464675, 0.85540643, 0.85464675, 0.84704989, 0.84755634,\n",
            "       0.84578374, 0.84704989, 0.84958217, 0.85034186, 0.84958217,\n",
            "       0.84932894, 0.84958217]), 'split8_test_score': array([0.87085338, 0.86908078, 0.87161307, 0.86882755, 0.86958724,\n",
            "       0.87085338, 0.86958724, 0.87034692, 0.87034692, 0.86680172,\n",
            "       0.86376298, 0.86604204, 0.86629526, 0.86984047, 0.86908078,\n",
            "       0.86882755, 0.87034692, 0.86958724, 0.85667258, 0.85945809,\n",
            "       0.85743226, 0.86072423, 0.86148392, 0.86123069, 0.86123069,\n",
            "       0.86401621, 0.86350975]), 'split9_test_score': array([0.87009369, 0.87110661, 0.87060015, 0.87211952, 0.87161307,\n",
            "       0.87211952, 0.87211952, 0.87237275, 0.87237275, 0.86199038,\n",
            "       0.86224361, 0.86325652, 0.86629526, 0.86654849, 0.86730818,\n",
            "       0.86680172, 0.86604204, 0.86806787, 0.85388706, 0.85414029,\n",
            "       0.8551532 , 0.85743226, 0.86047101, 0.86097746, 0.86047101,\n",
            "       0.85996455, 0.86148392]), 'mean_test_score': array([0.86605569, 0.86537204, 0.86552401, 0.86519493, 0.86678999,\n",
            "       0.86651152, 0.86532135, 0.86603046, 0.86615707, 0.86116879,\n",
            "       0.86129548, 0.86119411, 0.86304258, 0.86359964, 0.86342252,\n",
            "       0.86390345, 0.86440992, 0.86451116, 0.85288904, 0.85306632,\n",
            "       0.85281313, 0.85633256, 0.85757336, 0.8579278 , 0.85790256,\n",
            "       0.85828228, 0.85820642]), 'std_test_score': array([0.00507079, 0.00489201, 0.00518992, 0.00527314, 0.00529846,\n",
            "       0.00494972, 0.00598739, 0.00536128, 0.00556385, 0.00501587,\n",
            "       0.00516396, 0.00549594, 0.0049495 , 0.00572456, 0.0056177 ,\n",
            "       0.00495748, 0.00501874, 0.00511142, 0.00371296, 0.00457229,\n",
            "       0.00426259, 0.00559824, 0.00446113, 0.00459437, 0.0059107 ,\n",
            "       0.00532196, 0.00534444]), 'rank_test_score': array([ 4,  7,  6,  9,  1,  2,  8,  5,  3, 18, 16, 17, 15, 13, 14, 12, 11,\n",
            "       10, 26, 25, 27, 24, 23, 21, 22, 19, 20], dtype=int32)}\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#validação do modelo\n",
        "weather_model.evaluate_model()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZLgmjsAfA02n",
        "outputId": "76e8a30e-e73f-4536-ae5c-05ff616ed145"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Train Accuracy: 0.9566\n",
            "Test Accuracy: 0.8652\n",
            "Classification Report (Test Set):\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "           0       0.89      0.95      0.92     13198\n",
            "           1       0.75      0.58      0.65      3728\n",
            "\n",
            "    accuracy                           0.87     16926\n",
            "   macro avg       0.82      0.76      0.78     16926\n",
            "weighted avg       0.86      0.87      0.86     16926\n",
            "\n",
            "Confusion Matrix (Test Set):\n",
            " [[12501   697]\n",
            " [ 1584  2144]]\n",
            "Classification Report (Train Set):\n",
            "               precision    recall  f1-score   support\n",
            "\n",
            "           0       0.95      0.99      0.97     30795\n",
            "           1       0.97      0.83      0.89      8699\n",
            "\n",
            "    accuracy                           0.96     39494\n",
            "   macro avg       0.96      0.91      0.93     39494\n",
            "weighted avg       0.96      0.96      0.96     39494\n",
            "\n",
            "Confusion Matrix (Train Set):\n",
            " [[30549   246]\n",
            " [ 1469  7230]]\n",
            "Train Scores Mean: 0.8660\n",
            "Test Scores Mean: 0.8566\n",
            "95% Confidence Interval for Test Scores: (0.8516, 0.8615)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "weather_model.plot_learning_curve()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 472
        },
        "id": "DrWEO2KST4pH",
        "outputId": "400040d3-3cc6-4ba3-897f-c859997fecc7"
      },
      "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": [
        "weather_model.plot_validation_curves()"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 1000
        },
        "id": "MaVautNQWWgZ",
        "outputId": "9caeb51a-4e0f-428b-fd7e-fa5319d0a25a"
      },
      "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": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    }
  ]
}