Untitled-1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LinearRegression\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import tensorflow as tf\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       Date Date.1  Time  Case  Rainfall  Temperature  Humidity  Wind\n",
      "0  01-01-20      J     1     3       0.0         21.6      67.5   1.0\n",
      "1  02-01-20      J     2    17       2.0         21.8      73.5   1.5\n",
      "2  03-01-20      J     3    20      18.0         19.8      90.5   5.0\n",
      "3  04-01-20      J     4    39       0.0         20.5      82.0   0.5\n",
      "4  05-01-20      J     5    45       0.3         19.6      73.5   2.0\n"
     ]
    }
   ],
   "source": [
    "data = pd.read_csv(r'C:\\Users\\sneha\\Documents\\project\\dengue\\Dengue Data.csv')\n",
    "print(data.head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Date           0\n",
       "Date.1         0\n",
       "Time           0\n",
       "Case           0\n",
       "Rainfall       0\n",
       "Temperature    0\n",
       "Humidity       0\n",
       "Wind           0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   Case  outbreak_prone\n",
      "0     3               0\n",
      "1    17               0\n",
      "2    20               0\n",
      "3    39               0\n",
      "4    45               0\n"
     ]
    }
   ],
   "source": [
    "# Calculate the threshold (mean number of cases)\n",
    "threshold = data['Case'].mean()\n",
    "# Create the 'outbreak_prone' column\n",
    "data['outbreak_prone'] = data['Case'].apply(lambda x: 1 if x > threshold else 0)\n",
    "# Verify the new column\n",
    "print(data[['Case', 'outbreak_prone']].head())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Select features\n",
    "X = data[['Temperature', 'Humidity', 'Rainfall', 'Wind']]\n",
    "# Select target\n",
    "y = data['outbreak_prone']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape: (584, 4)\n",
      "X_test shape: (147, 4)\n",
      "y_train shape: (584,)\n",
      "y_test shape: (147,)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "# Split the data (80% training, 20% testing)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "# Verify the shapes\n",
    "print(f\"X_train shape: {X_train.shape}\")\n",
    "print(f\"X_test shape: {X_test.shape}\")\n",
    "print(f\"y_train shape: {y_train.shape}\")\n",
    "print(f\"y_test shape: {y_test.shape}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['Date', 'Date.1', 'Time', 'Case', 'Rainfall', 'Temperature', 'Humidity',\n",
      "       'Wind', 'outbreak_prone'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(data.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.75\n",
      "Precision: 0.71\n",
      "Recall: 0.60\n",
      "Confusion Matrix:\n",
      "[[75 14]\n",
      " [23 35]]\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.77      0.84      0.80        89\n",
      "           1       0.71      0.60      0.65        58\n",
      "\n",
      "    accuracy                           0.75       147\n",
      "   macro avg       0.74      0.72      0.73       147\n",
      "weighted avg       0.75      0.75      0.74       147\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix, classification_report\n",
    "# Initialize the model\n",
    "rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)\n",
    "# Train the model\n",
    "rf_classifier.fit(X_train, y_train)\n",
    "# Make predictions\n",
    "y_pred = rf_classifier.predict(X_test)\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "precision = precision_score(y_test, y_pred)\n",
    "recall = recall_score(y_test, y_pred)\n",
    "conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "class_report = classification_report(y_test, y_pred)\n",
    "print(f\"Accuracy: {accuracy:.2f}\")\n",
    "print(f\"Precision: {precision:.2f}\")\n",
    "print(f\"Recall: {recall:.2f}\")\n",
    "print(\"Confusion Matrix:\")\n",
    "print(conf_matrix)\n",
    "print(\"Classification Report:\")\n",
    "print(class_report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X_train shape: (584, 4)\n",
      "X_test shape: (147, 4)\n",
      "y_train shape: (584,)\n",
      "y_test shape: (147,)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "# Split the data (80% training, 20% testing)\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "# Verify the shapes\n",
    "print(f\"X_train shape: {X_train.shape}\")\n",
    "print(f\"X_test shape: {X_test.shape}\")\n",
    "print(f\"y_train shape: {y_train.shape}\")\n",
    "print(f\"y_test shape: {y_test.shape}\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.75\n",
      "Precision: 0.71\n",
      "Recall: 0.60\n",
      "Confusion Matrix:\n",
      "[[75 14]\n",
      " [23 35]]\n",
      "Classification Report:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.77      0.84      0.80        89\n",
      "           1       0.71      0.60      0.65        58\n",
      "\n",
      "    accuracy                           0.75       147\n",
      "   macro avg       0.74      0.72      0.73       147\n",
      "weighted avg       0.75      0.75      0.74       147\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix, classification_report\n",
    "# Initialize the model\n",
    "rf_classifier = RandomForestClassifier(n_estimators=100, random_state=42)\n",
    "# Train the model\n",
    "rf_classifier.fit(X_train, y_train)\n",
    "# Make predictions\n",
    "y_pred = rf_classifier.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "precision = precision_score(y_test, y_pred)\n",
    "recall = recall_score(y_test, y_pred)\n",
    "conf_matrix = confusion_matrix(y_test, y_pred)\n",
    "class_report = classification_report(y_test, y_pred)\n",
    "\n",
    "print(f\"Accuracy: {accuracy:.2f}\")\n",
    "print(f\"Precision: {precision:.2f}\")\n",
    "print(f\"Recall: {recall:.2f}\")\n",
    "print(\"Confusion Matrix:\")\n",
    "print(conf_matrix)\n",
    "print(\"Classification Report:\")\n",
    "print(class_report)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Get feature importances\n",
    "importances = rf_classifier.feature_importances_\n",
    "feature_names = X.columns\n",
    "feature_importances = pd.Series(importances, index=feature_names).sort_values(ascending=False)\n",
    "\n",
    "# Plot feature importances\n",
    "plt.figure(figsize=(8,6))\n",
    "sns.barplot(x=feature_importances, y=feature_importances.index)\n",
    "plt.title('Feature Importances')\n",
    "plt.xlabel('Importance Score')\n",
    "plt.ylabel('Features')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 5 folds for each of 108 candidates, totalling 540 fits\n",
      "{'max_depth': 10, 'min_samples_leaf': 2, 'min_samples_split': 2, 'n_estimators': 100}\n",
      "Accuracy: 0.77\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.78      0.85      0.82        89\n",
      "           1       0.74      0.64      0.69        58\n",
      "\n",
      "    accuracy                           0.77       147\n",
      "   macro avg       0.76      0.75      0.75       147\n",
      "weighted avg       0.77      0.77      0.77       147\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "# Define parameter grid\n",
    "param_grid = {\n",
    "    'n_estimators': [100, 200, 300],\n",
    "    'max_depth': [None, 10, 20, 30],\n",
    "    'min_samples_split': [2, 5, 10],\n",
    "    'min_samples_leaf': [1, 2, 4]\n",
    "}\n",
    "# Initialize GridSearchCV\n",
    "grid_search = GridSearchCV(estimator=rf_classifier, param_grid=param_grid, cv=5, n_jobs=-1, verbose=2)\n",
    "# Fit GridSearchCV\n",
    "grid_search.fit(X_train, y_train)\n",
    "# Get best parameters\n",
    "print(grid_search.best_params_)\n",
    "# Use the best estimator\n",
    "best_rf = grid_search.best_estimator_\n",
    "# Make predictions with the best model\n",
    "y_pred_best = best_rf.predict(X_test)\n",
    "# Evaluate the best model\n",
    "print(f\"Accuracy: {accuracy_score(y_test, y_pred_best):.2f}\")\n",
    "print(classification_report(y_test, y_pred_best))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Confusion matrix\n",
    "y_pred = best_rf.predict(X_test)\n",
    "cm = confusion_matrix(y_test, y_pred)\n",
    "sns.heatmap(cm, annot=True)\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "# Initialize the model\n",
    "model = RandomForestClassifier()\n",
    "\n",
    "# Train the model\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Now, you can use the model to predict or save it\n",
    "y_pred = model.predict(X_test)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['dengue_model.pkl']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import joblib\n",
    "\n",
    "# Save the model\n",
    "joblib.dump(model, 'dengue_model.pkl')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " * Serving Flask app '__main__'\n",
      " * Debug mode: on\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.\n",
      " * Running on http://127.0.0.1:5000\n",
      "Press CTRL+C to quit\n",
      " * Restarting with stat\n"
     ]
    },
    {
     "ename": "SystemExit",
     "evalue": "1",
     "output_type": "error",
     "traceback": [
      "An exception has occurred, use %tb to see the full traceback.\n",
      "\u001b[1;31mSystemExit\u001b[0m\u001b[1;31m:\u001b[0m 1\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\sneha\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.12_qbz5n2kfra8p0\\LocalCache\\local-packages\\Python312\\site-packages\\IPython\\core\\interactiveshell.py:3585: UserWarning: To exit: use 'exit', 'quit', or Ctrl-D.\n",
      "  warn(\"To exit: use 'exit', 'quit', or Ctrl-D.\", stacklevel=1)\n"
     ]
    }
   ],
   "source": [
    "from flask import Flask, request, render_template\n",
    "import joblib\n",
    "\n",
    "app = Flask(__name__)\n",
    "\n",
    "# Load your saved model\n",
    "model = joblib.load('dengue_model.pkl')\n",
    "\n",
    "@app.route('/')\n",
    "def home():\n",
    "    return render_template('index.html')\n",
    "\n",
    "@app.route('/predict', methods=['POST'])\n",
    "def predict():\n",
    "    temperature = float(request.form['Temperature'])\n",
    "    humidity = float(request.form['Humidity'])\n",
    "    rainfall = float(request.form['Rainfall'])\n",
    "    \n",
    "    # Make a prediction\n",
    "    prediction = model.predict([[temperature, humidity, rainfall]])\n",
    "    \n",
    "    result = 'Prone to Dengue' if prediction[0] == 1 else 'Not Prone to Dengue'\n",
    "    return render_template('index.html', prediction_text=result)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    app.run(debug=True)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}