4_machine learning _ turtle bycatch_v1_SRB.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9815918b",
   "metadata": {},
   "source": [
    "# Predict Turtle bycatch mortality "
   ]
  },
  {
   "cell_type": "raw",
   "id": "66104156",
   "metadata": {},
   "source": [
    "['S.no', 'Recorder name/code', 'Respondent no', 'Date', 'Time_Start',\n",
    "       'Time_End', 'FishermanID', 'Village', 'District', 'Latitute',\n",
    "       'Longitude', 'FishermanID2', 'Father_Name', 'Age', 'Education_Level',\n",
    "       'Language', 'Occupation', 'duration with Fisheries association',\n",
    "       'Current role', 'Type of fisheries', 'Boat_Sizeft', 'Fishing_Time',\n",
    "       'Fishing_Oper_hh/day', 'Category_Gear', 'Gear_Type',\n",
    "       'Total Months in gear use', 'Gear_Setting', 'Colour ',\n",
    "       'Gear_Length_(km)', 'width (meters)', 'mesh size (millimeters/ungal)',\n",
    "       'Float_Type', 'Float_Used', 'Sinkers_Type', 'Sinkers_Used',\n",
    "       'Sinkers_Weight_kg', 'Duration_Fishing_Trip_Days', 'Total_Crew',\n",
    "       'Tech_Used', 'Navi_commu', 'Engine_Type', 'horse power',\n",
    "       'Total gear used', 'departure area', 'Arrival Area',\n",
    "       'Fish market/Landed area', 'Catch market', 'target gear',\n",
    "       'Fish species', 'Fish_Category', 'No. of turtles found',\n",
    "       'Turtle Local name', 'No. of dolphins', 'Dolphin Local name',\n",
    "       'Category', 'Bycatch_categories', 'Sighted/encountered',\n",
    "       'Total no/ year', 'Bycatch_Fishing_Area', 'Bycatch_Month',\n",
    "       'Total months', 'Damage net (Y/N)', 'Released', 'Discarded', 'Retained',\n",
    "       'Other ', 'Encountered', 'Shifted/change fishing techniques',\n",
    "       'If yes, Change Technique name', 'Awareness on conservation',\n",
    "       'Animals should no caught', 'If yes/Explain',\n",
    "       'Facilitate data collection and reporting', 'Interview_One_Year',\n",
    "       'Captain name', 'Boat name', 'Boat reg:', 'Contact', 'Recommended',\n",
    "       'Comments']"
   ]
  },
  {
   "cell_type": "raw",
   "id": "54c8e886",
   "metadata": {},
   "source": [
    "As a data scientist, I would identify the following variables for machine learning from the provided list:\n",
    "\n",
    "1. S.no: Serial number or identifier of the data point (may not be relevant for modeling)\n",
    "2. Respondent no: Identifier for each respondent (may not be relevant for modeling)\n",
    "3. Date: The date of data collection (can be useful for time-based analysis)\n",
    "4. Time_Start: The start time of data collection (can be useful for time-based analysis)\n",
    "5. Time_End: The end time of data collection (can be useful for time-based analysis)\n",
    "6. FishermanID: Identifier for each fisherman (may not be relevant for modeling if FishermanID2 is used)\n",
    "7. Village: The village where the fisherman resides (categorical variable)\n",
    "8. District: The district where the fisherman resides (categorical variable)\n",
    "9. Latitude: The latitude coordinate of the fishing location (numerical variable)\n",
    "10. Longitude: The longitude coordinate of the fishing location (numerical variable)\n",
    "11. Father_Name: The name of the fisherman's father (may not be relevant for modeling)\n",
    "12. Age: The age of the fisherman (numerical variable)\n",
    "13. Education_Level: The education level of the fisherman (categorical variable)\n",
    "14. Occupation: The occupation of the fisherman (categorical variable)\n",
    "15. duration with Fisheries association: The duration of the fisherman's association with the fisheries (numerical variable)\n",
    "16. Current role: The current role of the fisherman in the association (categorical variable)\n",
    "17. Type of fisheries: The type of fisheries the fisherman is engaged in (categorical variable)\n",
    "18. Boat_Sizeft: The size of the boat in feet (numerical variable)\n",
    "19. Fishing_Time: The duration of fishing activity (numerical variable)\n",
    "20. Fishing_Oper_hh/day: The number of fishing hours per day (numerical variable)\n",
    "21. Category_Gear: The category of gear used (categorical variable)\n",
    "22. Gear_Type: The type of gear used (categorical variable)\n",
    "23. Total Months in gear use: The total months the gear has been used (numerical variable)\n",
    "24. Gear_Setting: The setting of the gear (categorical variable)\n",
    "25. Colour: The color of the gear (categorical variable)\n",
    "26. Gear_Length_(km): The length of the gear in kilometers (numerical variable)\n",
    "27. Width (meters): The width of the gear in meters (numerical variable)\n",
    "28. Mesh size (millimeters/ungal): The mesh size of the gear in millimeters (numerical variable)\n",
    "29. Float_Type: The type of float used (categorical variable)\n",
    "30. Float_Used: Whether a float is used or not (categorical variable)\n",
    "31. Sinkers_Type: The type of sinkers used (categorical variable)\n",
    "32. Sinkers_Used: Whether sinkers are used or not (categorical variable)\n",
    "33. Sinkers_Weight_kg: The weight of the sinkers in kilograms (numerical variable)\n",
    "34. Duration_Fishing_Trip_Days: The duration of the fishing trip in days (numerical variable)\n",
    "35. Total_Crew: The total number of crew members (numerical variable)\n",
    "36. Tech_Used: The technology used during fishing (categorical variable)\n",
    "37. Navi_commu: The navigation and communication devices used (categorical variable)\n",
    "38. Engine_Type: The type of engine used in the boat (categorical variable)\n",
    "39. Horse power: The horsepower of the boat engine (numerical variable)\n",
    "40. Total gear used: The total number of gear used (numerical variable)\n",
    "41. Departure Area: The area where the fishing trip starts (categorical variable)\n",
    "42. Arrival Area: The area where the fishing trip ends (categorical variable)\n",
    "43. Fish market/Landed area: The area where the fish is sold or landed (categorical variable)\n",
    "44. Catch market: The market where the fish is sold (categorical variable)\n",
    "45. Target gear: The gear specifically targeted for fishing (categorical variable)\n",
    "46. Fish species: The species of fish caught (categorical variable)\n",
    "47. Fish_Category: The category of fish caught (categorical variable)\n",
    "48. No. of turtles found: The number of turtles found during fishing (numerical variable)\n",
    "49. Turtle Local name: The local name of the turtle (categorical variable)\n",
    "50. No. of dolphins: The number of dolphins found during fishing (numerical variable)\n",
    "51. Dolphin Local name: The local name of the dolphin (categorical variable)\n",
    "52. Category: The category of the data point (may not be relevant for modeling)\n",
    "53. Bycatch_categories: The categories of bycatch (categorical variable)\n",
    "54. Sighted/encountered: Whether certain animals were sighted or encountered (categorical variable)\n",
    "55. Total no/ year: The total number of sightings or encounters per year (numerical variable)\n",
    "56. Bycatch_Fishing_Area: The area where bycatch occurs (categorical variable)\n",
    "57. Bycatch_Month: The month when bycatch occurs (categorical variable)\n",
    "58. Total months: The total number of months considered for analysis (numerical variable)\n",
    "59. Damage net (Y/N): Whether the fishing net was damaged (categorical variable)\n",
    "60. Released: Whether the catch was released (categorical variable)\n",
    "61. Discarded: Whether the catch was discarded (categorical variable)\n",
    "62. Retained: Whether the catch was retained (categorical variable)\n",
    "63. Other: Other relevant variables not specified in the list (may need further clarification)\n",
    "64. Encountered: Whether certain events were encountered (categorical variable)\n",
    "65. Shifted/change fishing techniques: Whether fishing techniques were shifted or changed (categorical variable)\n",
    "66. If yes, Change Technique name: The name of the changed fishing technique (categorical variable)\n",
    "67. Awareness on conservation: Awareness level of the fisherman regarding conservation (categorical variable)\n",
    "68. Animals should not be caught: Whether certain animals should not be caught (categorical variable)\n",
    "69. If yes/Explain: Explanation or details regarding the previous variable (may need further clarification)\n",
    "70. Facilitate data collection and reporting: Whether data collection and reporting were facilitated (categorical variable)\n",
    "71. Interview_One_Year: Whether an interview was conducted within the past year (categorical variable)\n",
    "72. Captain name: The name of the captain (may not be relevant for modeling)\n",
    "73. Boat name: The name of the boat (may not be relevant for modeling)\n",
    "74. Boat reg: The registration number of the boat (may not be relevant for modeling)\n",
    "75. Contact: Contact information of the respondent (may not be relevant for modeling)\n",
    "76. Recommended: Whether the respondent was recommended by someone (categorical variable)\n",
    "77. Comments: Additional comments or notes (may not be relevant for modeling)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "281ef682",
   "metadata": {},
   "source": [
    "# predict turtles from column 'No. of turtles found'  and mortality form 'Sighted/encountered' based on the selected variables of 'Education_Level_1'  "
   ]
  },
  {
   "cell_type": "raw",
   "id": "5abbfec6",
   "metadata": {},
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Survey_F2F_Cetacean.csv\")\n",
    "\n",
    "# Select the features and target variables\n",
    "X = data[['Education_Level']]\n",
    "y_turtle = data['No. of turtles found']\n",
    "y_mortality = data['Sighted/encountered']\n",
    "\n",
    "# Handle missing values in y_turtle\n",
    "imputer = SimpleImputer(strategy='mean')\n",
    "y_turtle = imputer.fit_transform(y_turtle.values.reshape(-1, 1))\n",
    "\n",
    "# Encode the categorical variable y_mortality\n",
    "encoder = OneHotEncoder(sparse=False)\n",
    "y_mortality_encoded = encoder.fit_transform(y_mortality.values.reshape(-1, 1))\n",
    "\n",
    "# Handle missing values in y_mortality_encoded\n",
    "imputer = SimpleImputer(strategy='mean')\n",
    "y_mortality_encoded = imputer.fit_transform(y_mortality_encoded)\n",
    "\n",
    "# Encode the categorical variable X\n",
    "encoder = OneHotEncoder(sparse=False)\n",
    "X_encoded = encoder.fit_transform(X)\n",
    "\n",
    "# Resize X_encoded and y_mortality_encoded to match the number of samples\n",
    "min_samples = min(len(X_encoded), len(y_mortality_encoded))\n",
    "X_encoded = X_encoded[:min_samples]\n",
    "y_mortality_encoded = y_mortality_encoded[:min_samples]\n",
    "\n",
    "# Train a linear regression model for turtle prediction\n",
    "model_turtle = LinearRegression()\n",
    "model_turtle.fit(X_encoded, y_turtle.ravel())\n",
    "\n",
    "# Train a logistic regression model for mortality prediction\n",
    "model_mortality = LogisticRegression()\n",
    "model_mortality.fit(X_encoded, y_mortality_encoded.ravel())\n",
    "\n",
    "# Make predictions for turtles and mortality\n",
    "turtle_predictions = model_turtle.predict(X_encoded)\n",
    "mortality_predictions = model_mortality.predict(X_encoded)\n",
    "\n",
    "# Display the predictions\n",
    "print(\"Turtle Predictions:\", turtle_predictions)\n",
    "print(\"Mortality Predictions:\", mortality_predictions)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.scatter(X['Education_Level'], y_turtle, c=turtle_predictions)\n",
    "plt.xlabel('Education_Level')\n",
    "plt.ylabel('No. of Turtles Found')\n",
    "plt.title('Turtle Predictions')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.scatter(X['Education_Level'], y_mortality_encoded[:, 0], c=mortality_predictions)\n",
    "plt.xlabel('Education_Level')\n",
    "plt.ylabel('Sighted/Encountered')\n",
    "plt.title('Mortality Predictions')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2adbaa7c",
   "metadata": {},
   "source": [
    "# predict turtles and mortality based on the selected variable of 'Village' "
   ]
  },
  {
   "cell_type": "raw",
   "id": "e99f0a91",
   "metadata": {},
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Survey_F2F_Cetacean.csv\")\n",
    "\n",
    "# Select the features and target variables\n",
    "X = data[['Village']]\n",
    "y_turtle = data['No. of turtles found']\n",
    "y_mortality = data['Sighted/encountered']\n",
    "\n",
    "# Train a logistic regression model for turtle prediction\n",
    "model_turtle = LogisticRegression()\n",
    "model_turtle.fit(X, y_turtle)\n",
    "\n",
    "# Train a logistic regression model for mortality prediction\n",
    "model_mortality = LogisticRegression()\n",
    "model_mortality.fit(X, y_mortality)\n",
    "\n",
    "# Make predictions for turtles and mortality\n",
    "turtle_predictions = model_turtle.predict(X)\n",
    "mortality_predictions = model_mortality.predict(X)\n",
    "\n",
    "# Display the predictions\n",
    "print(\"Turtle Predictions:\", turtle_predictions)\n",
    "print(\"Mortality Predictions:\", mortality_predictions)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.scatter(data['Village'], data['No. of turtles found'], c=turtle_predictions)\n",
    "plt.xlabel('Village')\n",
    "plt.ylabel('No. of Turtles Found')\n",
    "plt.title('Turtle Predictions')\n",
    "plt.xticks(rotation=90)\n",
    "plt.colorbar()\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.scatter(data['Village'], data['Sighted/encountered'], c=mortality_predictions)\n",
    "plt.xlabel('Village')\n",
    "plt.ylabel('Sighted/Encountered')\n",
    "plt.title('Mortality Predictions')\n",
    "plt.xticks(rotation=90)\n",
    "plt.colorbar()\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56a693df",
   "metadata": {},
   "source": [
    "# predict turtles and mortality based on the selected variable of 'Type of fisheries' "
   ]
  },
  {
   "cell_type": "raw",
   "id": "25d18b1f",
   "metadata": {},
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.preprocessing import OneHotEncoder\n",
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Survey_F2F_Cetacean.csv\")\n",
    "\n",
    "# Select the features and target variable\n",
    "X = data[['Boat_Sizeft']]\n",
    "y_turtle = data['No. of turtles found']\n",
    "y_mortality = data['Sighted/encountered_1']\n",
    "\n",
    "# Handle missing values in X and y_turtle\n",
    "imputer = SimpleImputer(strategy='mean')\n",
    "X = imputer.fit_transform(X)\n",
    "y_turtle = imputer.fit_transform(y_turtle.values.reshape(-1, 1))\n",
    "\n",
    "# Convert continuous values to binary labels\n",
    "threshold = 0\n",
    "y_turtle_binary = (y_turtle > threshold).astype(int)\n",
    "\n",
    "# Encode the categorical variable y_mortality\n",
    "encoder = OneHotEncoder(sparse=False)\n",
    "y_mortality_encoded = encoder.fit_transform(y_mortality.values.reshape(-1, 1))\n",
    "\n",
    "# Train a logistic regression model for turtle prediction\n",
    "model_turtle = LogisticRegression()\n",
    "model_turtle.fit(X, y_turtle_binary)\n",
    "\n",
    "# Train a logistic regression model for mortality prediction\n",
    "model_mortality = LogisticRegression()\n",
    "model_mortality.fit(X, y_mortality_encoded)\n",
    "\n",
    "# Make predictions for turtles and mortality\n",
    "turtle_predictions = model_turtle.predict(X)\n",
    "mortality_predictions = model_mortality.predict(X)\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Boat_Sizeft': X.ravel(),\n",
    "                        'Turtle_Predictions': turtle_predictions,\n",
    "                        'Mortality_Predictions': mortality_predictions})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.scatter(X, y_turtle_binary, c=turtle_predictions)\n",
    "plt.xlabel('Boat_Sizeft')\n",
    "plt.ylabel('No. of Turtles Found')\n",
    "plt.title('Turtle Predictions')\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.scatter(X, y_mortality_encoded[:, 0], c=mortality_predictions)\n",
    "plt.xlabel('Boat_Sizeft')\n",
    "plt.ylabel('Sighted/Encountered')\n",
    "plt.title('Mortality Predictions')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5271b630",
   "metadata": {},
   "source": [
    "# predict turtles and mortality based on the selected variable 'Boat_Sizeft' "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3faa4386",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       0.00      0.00      0.00         4\n",
      "     Sighted       0.56      1.00      0.71         5\n",
      "\n",
      "    accuracy                           0.56         9\n",
      "   macro avg       0.28      0.50      0.36         9\n",
      "weighted avg       0.31      0.56      0.40         9\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\")\n",
    "\n",
    "# Preprocess the data\n",
    "#1. \n",
    "#X = data[['Turtle_No', 'Status', 'Boat_Sizeft']]  # Features\n",
    "#y = data['Mortality']  # Target variable\n",
    "\n",
    "#2. \n",
    "X = data[['Turtle_No', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status']  # Target variable\n",
    "\n",
    "\n",
    "\n",
    "# Handle categorical variables by creating dummy variables\n",
    "X = pd.get_dummies(X, drop_first=True)\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the logistic regression model\n",
    "model = LogisticRegression()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "dd1d7d99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       1.00      0.75      0.86         4\n",
      "     Sighted       0.83      1.00      0.91         5\n",
      "\n",
      "    accuracy                           0.89         9\n",
      "   macro avg       0.92      0.88      0.88         9\n",
      "weighted avg       0.91      0.89      0.89         9\n",
      "\n",
      "         Actual    Predicted\n",
      "25  Encountered      Sighted\n",
      "13  Encountered  Encountered\n",
      "8   Encountered  Encountered\n",
      "26      Sighted      Sighted\n",
      "4   Encountered  Encountered\n",
      "39      Sighted      Sighted\n",
      "19      Sighted      Sighted\n",
      "29      Sighted      Sighted\n",
      "30      Sighted      Sighted\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\")\n",
    "\n",
    "# Preprocess the data\n",
    "#1. \n",
    "X = data[['Turtle_No', 'Status', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status']  # Target variable\n",
    "\n",
    "\n",
    "# Handle categorical variables by creating dummy variables\n",
    "X = pd.get_dummies(X, drop_first=True)\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the logistic regression model\n",
    "model = LogisticRegression()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results['Actual'], results['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b188b312",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Random Forest Classifier:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       1.00      1.00      1.00         4\n",
      "     Sighted       1.00      1.00      1.00         5\n",
      "\n",
      "    accuracy                           1.00         9\n",
      "   macro avg       1.00      1.00      1.00         9\n",
      "weighted avg       1.00      1.00      1.00         9\n",
      "\n",
      "-----------------------------------------\n",
      "Support Vector Machine Classifier:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       0.00      0.00      0.00         4\n",
      "     Sighted       0.56      1.00      0.71         5\n",
      "\n",
      "    accuracy                           0.56         9\n",
      "   macro avg       0.28      0.50      0.36         9\n",
      "weighted avg       0.31      0.56      0.40         9\n",
      "\n",
      "-----------------------------------------\n",
      "Gradient Boosting Classifier:\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       1.00      1.00      1.00         4\n",
      "     Sighted       1.00      1.00      1.00         5\n",
      "\n",
      "    accuracy                           1.00         9\n",
      "   macro avg       1.00      1.00      1.00         9\n",
      "weighted avg       1.00      1.00      1.00         9\n",
      "\n",
      "Random Forest Classifier Results:\n",
      "         Actual    Predicted\n",
      "25  Encountered  Encountered\n",
      "13  Encountered  Encountered\n",
      "8   Encountered  Encountered\n",
      "26      Sighted      Sighted\n",
      "4   Encountered  Encountered\n",
      "39      Sighted      Sighted\n",
      "19      Sighted      Sighted\n",
      "29      Sighted      Sighted\n",
      "30      Sighted      Sighted\n",
      "-----------------------------------------\n",
      "Support Vector Machine Classifier Results:\n",
      "         Actual Predicted\n",
      "25  Encountered   Sighted\n",
      "13  Encountered   Sighted\n",
      "8   Encountered   Sighted\n",
      "26      Sighted   Sighted\n",
      "4   Encountered   Sighted\n",
      "39      Sighted   Sighted\n",
      "19      Sighted   Sighted\n",
      "29      Sighted   Sighted\n",
      "30      Sighted   Sighted\n",
      "-----------------------------------------\n",
      "Gradient Boosting Classifier Results:\n",
      "         Actual    Predicted\n",
      "25  Encountered  Encountered\n",
      "13  Encountered  Encountered\n",
      "8   Encountered  Encountered\n",
      "26      Sighted      Sighted\n",
      "4   Encountered  Encountered\n",
      "39      Sighted      Sighted\n",
      "19      Sighted      Sighted\n",
      "29      Sighted      Sighted\n",
      "30      Sighted      Sighted\n",
      "-----------------------------------------\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\")\n",
    "\n",
    "# Preprocess the data\n",
    "X = data[['Turtle_No', 'Status', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status']  # Target variable\n",
    "\n",
    "# Handle categorical variables by creating dummy variables\n",
    "X = pd.get_dummies(X, drop_first=True)\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the Random Forest model\n",
    "rf_model = RandomForestClassifier()\n",
    "rf_model.fit(X_train, y_train)\n",
    "\n",
    "# Train the Support Vector Machine (SVM) model\n",
    "svm_model = SVC()\n",
    "svm_model.fit(X_train, y_train)\n",
    "\n",
    "# Train the Gradient Boosting model\n",
    "gb_model = GradientBoostingClassifier()\n",
    "gb_model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set for each model\n",
    "y_pred_rf = rf_model.predict(X_test)\n",
    "y_pred_svm = svm_model.predict(X_test)\n",
    "y_pred_gb = gb_model.predict(X_test)\n",
    "\n",
    "# Evaluate the models\n",
    "print(\"Random Forest Classifier:\")\n",
    "print(classification_report(y_test, y_pred_rf))\n",
    "print(\"-----------------------------------------\")\n",
    "print(\"Support Vector Machine Classifier:\")\n",
    "print(classification_report(y_test, y_pred_svm))\n",
    "print(\"-----------------------------------------\")\n",
    "print(\"Gradient Boosting Classifier:\")\n",
    "print(classification_report(y_test, y_pred_gb))\n",
    "\n",
    "# Display the results for Random Forest Classifier\n",
    "results_rf = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred_rf})\n",
    "print(\"Random Forest Classifier Results:\")\n",
    "print(results_rf)\n",
    "print(\"-----------------------------------------\")\n",
    "\n",
    "# Display the results for Support Vector Machine Classifier\n",
    "results_svm = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred_svm})\n",
    "print(\"Support Vector Machine Classifier Results:\")\n",
    "print(results_svm)\n",
    "print(\"-----------------------------------------\")\n",
    "\n",
    "# Display the results for Gradient Boosting Classifier\n",
    "results_gb = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred_gb})\n",
    "print(\"Gradient Boosting Classifier Results:\")\n",
    "print(results_gb)\n",
    "print(\"-----------------------------------------\")\n",
    "\n",
    "# Plot the results for Random Forest Classifier\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results_rf['Actual'], results_rf['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Random Forest Classifier Confusion Matrix')\n",
    "plt.show()\n",
    "\n",
    "# Plot the results for Support Vector Machine Classifier\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results_svm['Actual'], results_svm['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Support Vector Machine Classifier Confusion Matrix')\n",
    "plt.show()\n",
    "\n",
    "# Plot the results for Gradient Boosting Classifier\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results_gb['Actual'], results_gb['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Gradient Boosting Classifier Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d08adb8",
   "metadata": {},
   "source": [
    "# machine learning - examples \n",
    "\n",
    "Based on the information provided, where you have a numerical feature (number of turtles caught) and a numerical feature (boat size), and you want to predict a categorical variable (status of turtles), you can use a classification model.\n",
    "\n",
    "Here are a few machine learning models that you can consider for predicting the status of turtles in this scenario:\n",
    "\n",
    "1. Logistic Regression: Logistic Regression is a commonly used classification algorithm that can handle binary or multi-class classification problems. It can provide probabilities for each class based on the input features.\n",
    "\n",
    "2. Random Forest: Random Forest is an ensemble learning method that combines multiple decision trees to make predictions. It is effective for handling complex relationships between features and can handle both numerical and categorical features.\n",
    "\n",
    "3. Gradient Boosting: Gradient Boosting is another ensemble learning method that builds an ensemble of weak learners (decision trees) in a sequential manner. It can provide accurate predictions and handle both numerical and categorical features.\n",
    "\n",
    "4. Support Vector Machines (SVM): SVM is a powerful algorithm that can handle both linear and non-linear classification problems. It finds the optimal hyperplane that maximally separates the different classes based on the input features.\n",
    "\n",
    "5. Neural Networks: Neural networks, specifically deep learning models, have shown great performance in various classification tasks. They can learn complex patterns and relationships in the data. However, they typically require a larger amount of data and computational resources.\n",
    "\n",
    "The choice of the model depends on various factors such as the size of the dataset, the complexity of the relationship between features, interpretability requirements, and computational resources available. It is recommended to try different models and compare their performance using suitable evaluation metrics to select the best model for your specific problem.\n",
    "\n",
    "Remember to preprocess your data, handle missing values, and normalize or scale your numerical features before training the models. Also, consider using techniques like cross-validation to better estimate the performance of your models and tune their hyperparameters."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "42c678ac",
   "metadata": {},
   "source": [
    "# 1. Logistic Regression: Logistic Regression is a commonly used classification algorithm that can handle binary or multi-class classification problems. It can provide probabilities for each class based on the input features."
   ]
  },
  {
   "cell_type": "raw",
   "id": "1d6a26ad",
   "metadata": {},
   "source": [
    "The code performs the following steps:\n",
    "\n",
    "Loads the dataset using pd.read_csv() function.\n",
    "Separates the features (X) and the target variable (y).\n",
    "Splits the data into training and testing sets using train_test_split() function from scikit-learn.\n",
    "Creates an instance of the LogisticRegression model.\n",
    "Trains the model using the training data with model.fit().\n",
    "Makes predictions on the test set using model.predict().\n",
    "Evaluates the model's performance using classification_report(), which prints precision, recall, F1-score, and support for each class."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a4db118a",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.56      1.00      0.71         5\n",
      "           1       0.00      0.00      0.00         4\n",
      "\n",
      "    accuracy                           0.56         9\n",
      "   macro avg       0.28      0.50      0.36         9\n",
      "weighted avg       0.31      0.56      0.40         9\n",
      "\n",
      "    Actual  Predicted\n",
      "25       1          0\n",
      "13       1          0\n",
      "8        1          0\n",
      "26       0          0\n",
      "4        1          0\n",
      "39       0          0\n",
      "19       0          0\n",
      "29       0          0\n",
      "30       0          0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\") \n",
    "\n",
    "# Preprocess the data\n",
    "\n",
    "# Preprocess the data\n",
    "X = data[['Turtle_No', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status_1']  # Target variable\n",
    "\n",
    "#X = data[['Turtle_No', 'Status_1', 'Boat_Sizeft']]  # Features\n",
    "#y = data['Status_1']  # Target variable\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the logistic regression model\n",
    "model = LogisticRegression()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results['Actual'], results['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Logistic Regression Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3ccb82fc",
   "metadata": {},
   "source": [
    "The provided result corresponds to the evaluation metrics and predicted values from a logistic regression model for the task of predicting the status of turtles. Let's go through the different components of the result:\n",
    "\n",
    "- Precision: Precision measures the accuracy of positive predictions. A precision of 0.83 for class 0 means that 83% of the predictions made for class 0 were correct. A precision of 1.00 for class 1 means that all the predictions made for class 1 were correct.\n",
    "\n",
    "- Recall: Recall, also known as sensitivity or true positive rate, measures the proportion of actual positives that were correctly identified. A recall of 1.00 for class 0 means that all the instances of class 0 were correctly identified. A recall of 0.75 for class 1 means that 75% of the instances of class 1 were correctly identified.\n",
    "\n",
    "- F1-score: The F1-score is the harmonic mean of precision and recall. It provides a balanced measure of the model's performance. The F1-score for class 0 is 0.91, and for class 1, it is 0.86.\n",
    "\n",
    "- Support: The support indicates the number of instances of each class in the test set. In this case, there are 5 instances of class 0 and 4 instances of class 1.\n",
    "\n",
    "- Accuracy: The accuracy is the overall performance of the model, which is the proportion of correct predictions out of the total number of predictions. In this case, the accuracy is 0.89, which means that 89% of the predictions were correct.\n",
    "\n",
    "The second part of the result shows the actual values and the corresponding predicted values for each instance in the test set. It indicates whether the model correctly predicted the status of the turtles for each instance.\n",
    "\n",
    "To summarize, the logistic regression model achieved good precision, recall, and F1-score for both classes, with an overall accuracy of 0.89. However, the performance may vary depending on the specific dataset and the class distribution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ea4fd87",
   "metadata": {},
   "source": [
    "# 2. Random Forest: Random Forest is an ensemble learning method that combines multiple decision trees to make predictions. It is effective for handling complex relationships between features and can handle both numerical and categorical features."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "e2cd8a85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.62      1.00      0.77         5\n",
      "           1       1.00      0.25      0.40         4\n",
      "\n",
      "    accuracy                           0.67         9\n",
      "   macro avg       0.81      0.62      0.58         9\n",
      "weighted avg       0.79      0.67      0.61         9\n",
      "\n",
      "    Actual  Predicted\n",
      "25       1          0\n",
      "13       1          0\n",
      "8        1          0\n",
      "26       0          0\n",
      "4        1          1\n",
      "39       0          0\n",
      "19       0          0\n",
      "29       0          0\n",
      "30       0          0\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\") \n",
    "\n",
    "# Preprocess the data\n",
    "#X = data[['Number_of_Turtles_Caught', 'Boat_Size']]  # Features\n",
    "#y = data['Status']  # Target variable\n",
    "\n",
    "# Preprocess the data\n",
    "#X = data[['Turtle_No', 'Status_1', 'Boat_Sizeft']]  # Features\n",
    "#y = data['Status_1']  # Target variable\n",
    "\n",
    "\n",
    "# Preprocess the data\n",
    "X = data[['Turtle_No', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status_1']  # Target variable\n",
    "\n",
    "\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the Random Forest model\n",
    "model = RandomForestClassifier()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results['Actual'], results['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Random Forest Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6df79139",
   "metadata": {},
   "source": [
    "The provided result corresponds to the evaluation metrics and predicted values from a Random Forest model for the task of predicting the status of turtles. Let's go through the different components of the result:\n",
    "\n",
    "- Precision: Precision measures the accuracy of positive predictions. A precision of 0.62 for class 0 means that 62% of the predictions made for class 0 were correct. A precision of 1.00 for class 1 means that all the predictions made for class 1 were correct.\n",
    "\n",
    "- Recall: Recall, also known as sensitivity or true positive rate, measures the proportion of actual positives that were correctly identified. A recall of 1.00 for class 0 means that all the instances of class 0 were correctly identified. A recall of 0.25 for class 1 means that only 25% of the instances of class 1 were correctly identified.\n",
    "\n",
    "- F1-score: The F1-score is the harmonic mean of precision and recall. It provides a balanced measure of the model's performance. The F1-score for class 0 is 0.77, and for class 1, it is 0.40.\n",
    "\n",
    "- Support: The support indicates the number of instances of each class in the test set. In this case, there are 5 instances of class 0 and 4 instances of class 1.\n",
    "\n",
    "- Accuracy: The accuracy is the overall performance of the model, which is the proportion of correct predictions out of the total number of predictions. In this case, the accuracy is 0.67, which means that 67% of the predictions were correct.\n",
    "\n",
    "The second part of the result shows the actual values and the corresponding predicted values for each instance in the test set. It indicates whether the model correctly predicted the status of the turtles for each instance.\n",
    "\n",
    "To summarize, the Random Forest model achieved moderate precision, recall, and F1-score for class 0, but lower performance for class 1, with an overall accuracy of 0.67. The model struggled to correctly identify instances of class 1, as indicated by the low recall and F1-score. This could be due to imbalanced class distribution or other factors. Further analysis and potential adjustments to the model or dataset may be needed for better performance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a23e44a",
   "metadata": {},
   "source": [
    "# 3. Gradient Boosting: Gradient Boosting is another ensemble learning method that builds an ensemble of weak learners (decision trees) in a sequential manner. It can provide accurate predictions and handle both numerical and categorical features.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "96664aa5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       1.00      0.25      0.40         4\n",
      "     Sighted       0.62      1.00      0.77         5\n",
      "\n",
      "    accuracy                           0.67         9\n",
      "   macro avg       0.81      0.62      0.58         9\n",
      "weighted avg       0.79      0.67      0.61         9\n",
      "\n",
      "         Actual    Predicted\n",
      "25  Encountered      Sighted\n",
      "13  Encountered      Sighted\n",
      "8   Encountered      Sighted\n",
      "26      Sighted      Sighted\n",
      "4   Encountered  Encountered\n",
      "39      Sighted      Sighted\n",
      "19      Sighted      Sighted\n",
      "29      Sighted      Sighted\n",
      "30      Sighted      Sighted\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\")\n",
    "\n",
    "# Preprocess the data\n",
    "X = data[['Turtle_No', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status']  # Target variable\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the Gradient Boosting model\n",
    "model = GradientBoostingClassifier()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results['Actual'], results['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Gradient Boosting Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "47eab575",
   "metadata": {},
   "source": [
    "The provided result corresponds to the evaluation metrics and predicted values from a Gradient Boosting model for the task of predicting the status of turtles. Let's go through the different components of the result:\n",
    "\n",
    "- Precision: Precision measures the accuracy of positive predictions. A precision of 1.00 for class Encountered means that all the predictions made for Encountered were correct. A precision of 0.62 for class Sighted means that 62% of the predictions made for Sighted were correct.\n",
    "\n",
    "- Recall: Recall, also known as sensitivity or true positive rate, measures the proportion of actual positives that were correctly identified. A recall of 0.25 for class Encountered means that only 25% of the instances of Encountered were correctly identified. A recall of 1.00 for class Sighted means that all the instances of Sighted were correctly identified.\n",
    "\n",
    "- F1-score: The F1-score is the harmonic mean of precision and recall. It provides a balanced measure of the model's performance. The F1-score for class Encountered is 0.40, and for class Sighted, it is 0.77.\n",
    "\n",
    "- Support: The support indicates the number of instances of each class in the test set. In this case, there are 4 instances of Encountered and 5 instances of Sighted.\n",
    "\n",
    "- Accuracy: The accuracy is the overall performance of the model, which is the proportion of correct predictions out of the total number of predictions. In this case, the accuracy is 0.67, which means that 67% of the predictions were correct.\n",
    "\n",
    "The second part of the result shows the actual values and the corresponding predicted values for each instance in the test set. It indicates whether the model correctly predicted the status of the turtles for each instance.\n",
    "\n",
    "To summarize, the Gradient Boosting model achieved higher precision, recall, and F1-score for class Sighted compared to class Encountered. The model correctly identified most instances of class Sighted, resulting in higher precision and recall for that class. However, the model struggled to identify instances of class Encountered, as indicated by the low precision and recall. This could be due to imbalanced class distribution or other factors. Further analysis and potential adjustments to the model or dataset may be needed for better performance."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "621a6e1d",
   "metadata": {},
   "source": [
    "4. Support Vector Machines (SVM): SVM is a powerful algorithm that can handle both linear and non-linear classification problems. It finds the optimal hyperplane that maximally separates the different classes based on the input features.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "7a681857",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       0.00      0.00      0.00         4\n",
      "     Sighted       0.56      1.00      0.71         5\n",
      "\n",
      "    accuracy                           0.56         9\n",
      "   macro avg       0.28      0.50      0.36         9\n",
      "weighted avg       0.31      0.56      0.40         9\n",
      "\n",
      "         Actual Predicted\n",
      "25  Encountered   Sighted\n",
      "13  Encountered   Sighted\n",
      "8   Encountered   Sighted\n",
      "26      Sighted   Sighted\n",
      "4   Encountered   Sighted\n",
      "39      Sighted   Sighted\n",
      "19      Sighted   Sighted\n",
      "29      Sighted   Sighted\n",
      "30      Sighted   Sighted\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoUAAAIjCAYAAAB1bGEnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAABGFElEQVR4nO3de3zP9f//8ftrs81sM2e2hTmUOR9SQkgmpw85FB9WDtEBZVJilTaJIYpPPg4hOhgin6VS+Cgh0sJQH0lOcxgizMh7vPf6/eHn/e3dhr3Z2+u97Xb9Xl6X797P9/P9fD3e7z7fz/fR43l4GaZpmgIAAECB5mV1AAAAALAeSSEAAABICgEAAEBSCAAAAJEUAgAAQCSFAAAAEEkhAAAARFIIAAAAkRQCAABAJIUALPDmm2+qcuXK8vb2Vr169XJ9/L59+yo8PDzXx82r1q5dK8MwtHbtWqtDAeDBSAqBXLRz50498sgjqlixogoXLqywsDC1bt1a77zzjiRp69atMgxDr7766jXH2LNnjwzD0LBhwyRJcXFxMgxDXl5eOnToUJb+aWlp8vf3l2EYevbZZ3MUp91u17x58/TAAw+oRIkS8vPzU3h4uPr166cff/zxJr55zq1atUovvfSSmjZtqnnz5mncuHFuvd/tdODAARmGIcMw9MYbb2TbJyoqSoZhKDAw8KbukZCQoClTptxClACQPZJCIJds3LhRDRs21Pbt2/Xkk09q2rRpGjBggLy8vDR16lRJUoMGDRQREaGFCxdec5yEhARJ0mOPPebU7ufnl+3nli1b5lKcf/75p/7xj3/oiSeekGmaevnllzVjxgz17t1bmzZt0r333qvDhw+7NKYrvv76a3l5eWnu3Lnq3bu32rdvn+v3mD17tnbv3p3r4+ZU4cKFs/1ndf78eX366acqXLjwTY99M0lh8+bN9eeff6p58+Y3fV8A+V8hqwMA8ouxY8cqODhYSUlJKlasmNN7J06ccPwdFRWlUaNG6fvvv9d9992XZZyFCxcqIiJCDRo0cGpv3769Fi5cqJdeesmpPSEhQR06dNAnn3ySoziHDx+ur776Sm+//baGDh3q9F5sbKzefvvtHI1zs06cOCF/f3/5+vq67R4+Pj5uGzsn2rdvr2XLlmn79u2qW7euo/3TTz9VRkaG2rZtq6+//trtcVy8eFG+vr7y8vK6pUQUQMFApRDIJXv37lXNmjWzJISSVKZMGcffUVFRkv6vIvhXW7Zs0e7dux19/qpXr15KTk7WL7/84mg7duyYvv76a/Xq1StHMR4+fFizZs1S69atsySEkuTt7a0XX3xRd9xxh6Nt27ZtateunYoWLarAwEC1atVK33//vdPn5s+fL8Mw9N1332nYsGEqXbq0AgIC1KVLF/3++++OfoZhaN68eTp//rxjmnX+/PmOadf58+dnickwDMXFxTlenzt3TkOHDlV4eLj8/PxUpkwZtW7dWlu3bnX0yW5N4fnz5/XCCy+ofPny8vPzU7Vq1TRp0iSZppnlfs8++6wSExNVq1Yt+fn5qWbNmvrqq69y8Atf0bhxY1WqVCnLP+MFCxaobdu2KlGiRJbPfPrpp+rQoYNCQ0Pl5+enKlWqaMyYMbLb7Y4+DzzwgL744gsdPHjQ8ftd/Z5X1w0uWrRIr776qsLCwlSkSBGlpaVlWVO4a9cu+fv7q3fv3k4xbNiwQd7e3hoxYkSOvyuA/IOkEMglFStW1JYtW/TTTz9dt1+lSpXUpEkTffzxx07/D1/6v0QxuySvefPmuuOOO5wSjcWLFyswMFAdOnTIUYxffvmlLl++rMcffzxH/X/++Wc1a9ZM27dv10svvaRRo0Zp//79euCBB7R58+Ys/Z977jlt375dsbGxGjhwoD777DOndY4ffvihmjVrJj8/P3344Yf68MMPXZ7SfOaZZzRjxgx169ZN06dP14svvih/f3/t2rXrmp8xTVOdOnXS22+/rbZt2+qtt95StWrVNHz4cMfazb/asGGDBg0apH/+85+aOHGiLl68qG7duunUqVM5jrNnz55atGiRI+k8efKkVq1adc0Efv78+QoMDNSwYcM0depU3X333Xrttdc0cuRIR59XXnlF9erVU6lSpRy/39+nkseMGaMvvvhCL774osaNG5dtRbZ69eoaM2aMPvzwQy1fvlzSlaS5b9++ioiI0Ouvv57j7wkgHzEB5IpVq1aZ3t7epre3t9m4cWPzpZdeMleuXGlmZGRk6fvvf//blGSuXLnS0Wa3282wsDCzcePGTn1jY2NNSebvv/9uvvjii2bVqlUd791zzz1mv379TNM0TUnm4MGDrxvj888/b0oyt23blqPv1LlzZ9PX19fcu3evo+3o0aNmUFCQ2bx5c0fbvHnzTElmZGSkmZmZ6XQ/b29v88yZM462Pn36mAEBAU732b9/vynJnDdvXpYYJJmxsbGO18HBwTf8nn369DErVqzoeJ2YmGhKMt944w2nfo888ohpGIb522+/Od3P19fXqW379u2mJPOdd9657n2vfo8333zT/Omnn0xJ5vr1603TvPLPPDAw0Dx//ny2v8GFCxeyjPf000+bRYoUMS9evOho69Chg9N3u+qbb74xJZmVK1fOMtbV97755htHm91uN++//36zbNmy5smTJ83BgwebhQoVMpOSkq77HQHkX1QKgVzSunVrbdq0SZ06ddL27ds1ceJEtWnTRmFhYY5qzFU9evSQj4+PU9Xv22+/1ZEjR7KdOr6qV69e+u2335SUlOT43zmdOpau7FSWpKCgoBv2tdvtWrVqlTp37qzKlSs72kNCQtSrVy9t2LDBMd5VTz31lAzDcLxu1qyZ7Ha7Dh48mOMYb6RYsWLavHmzjh49muPPrFixQt7e3hoyZIhT+wsvvCDTNPXll186tUdGRqpKlSqO13Xq1FHRokW1b9++HN+zZs2aqlOnjmPDSUJCgh5++GEVKVIk2/7+/v6Ov8+dO6eTJ0+qWbNmunDhgtOSgRvp06eP01jX4uXlpfnz5ys9PV3t2rXT9OnTFRMTo4YNG+b4XgDyF5JCIBfdc889WrZsmU6fPq0ffvhBMTExOnfunB555BH973//c/QrWbKk2rRpo//85z+6ePGipCtJQ6FChdS9e/drjl+/fn1FREQoISFBCxYsULly5fTggw/mOL6iRYtKupJ03Mjvv/+uCxcuqFq1alneq169ujIzM7MckVOhQgWn18WLF5cknT59Oscx3sjEiRP1008/qXz58rr33nsVFxd3w2Tt4MGDCg0NzZIMV69e3fH+X/39e0hXvour36NXr15asmSJfvvtN23cuPG6CfzPP/+sLl26KDg4WEWLFlXp0qUdO9DPnj2b43tWqlQpx32rVKmiuLg4JSUlqWbNmho1alSOPwsg/yEpBNzA19dX99xzj8aNG6cZM2bo0qVLWrJkiVOfxx57TGlpafr888+VkZGhTz75RA899JBKly593bF79eqlxYsXKyEhQT169JCXV87/zzgiIkLSlfMU3cHb2zvbdvNvmzn+7q/Vxb/6+5pLSerevbv27dund955R6GhoXrzzTdVs2bNLNW+W3Gz3+PvevbsqZMnT+rJJ59UyZIl9dBDD2Xb78yZM2rRooW2b9+u119/XZ999plWr16tCRMmSJIyMzNzfM+cVAn/atWqVZKko0ePurRmEkD+Q1IIuNnV6bjU1FSn9k6dOikoKEgJCQn68ssvdfr06etOHV/Vq1cvpaam6tdff3Vp6liS2rVrJ29vb3300Uc37Fu6dGkVKVIk2/P+fvnlF3l5eal8+fIu3f9arlYUz5w549R+rWnnkJAQDRo0SImJidq/f79KliypsWPHXnP8ihUr6ujRo1kqpFenZStWrHgL0V9bhQoV1LRpU61du1aPPvqoChXK/hSwtWvX6tSpU5o/f76io6P1j3/8Q5GRkY7f5a+ulUDfjJkzZ2r16tUaO3asMjIy9PTTT+fa2ADyHpJCIJd888032VaSVqxYIUlZpmH9/f3VpUsXrVixQjNmzFBAQIAefvjhG96nSpUqmjJliuLj43Xvvfe6FGP58uX15JNPatWqVY6nrPxVZmamJk+erMOHD8vb21sPPfSQPv30Ux04cMDR5/jx40pISND999/vmI6+VUWLFlWpUqW0bt06p/bp06c7vbbb7VmmUsuUKaPQ0FDZbLZrjt++fXvZ7XZNmzbNqf3tt9+WYRhq167dLX6Da3vjjTcUGxur55577pp9rlYm//qfn4yMjCzfX5ICAgJcmk6+lv3792v48OHq1q2bXn75ZU2aNEnLly/XBx98cMtjA8ibOLwayCXPPfecLly4oC5duigiIkIZGRnauHGjFi9e7HiE3N899thj+uCDD7Ry5UpFRUUpICAgR/eKjo6+6TgnT56svXv3asiQIVq2bJn+8Y9/qHjx4kpJSdGSJUv0yy+/6J///KekKwnN6tWrdf/992vQoEEqVKiQZs2aJZvNpokTJ950DNkZMGCAxo8frwEDBqhhw4Zat26dfv31V6c+586d0x133KFHHnlEdevWVWBgoP773/8qKSlJkydPvubYHTt2VMuWLfXKK6/owIEDqlu3rlatWqVPP/1UQ4cOddpUkttatGihFi1aXLdPkyZNVLx4cfXp00dDhgyRYRj68MMPs/2XjLvvvluLFy/WsGHDdM899ygwMFAdO3Z0KSbTNPXEE0/I399fM2bMkCQ9/fTT+uSTTxQdHa3IyEiFhoa6NCaAfMDCnc9AvvLll1+aTzzxhBkREWEGBgaavr6+ZtWqVc3nnnvOPH78eLafuXz5shkSEmJKMlesWJFtn78eSXM9ysGRNH+975w5c8xmzZqZwcHBpo+Pj1mxYkWzX79+WY6r2bp1q9mmTRszMDDQLFKkiNmyZUtz48aNTn2uHknz9+NMsjsKJbvjWEzzypEs/fv3N4ODg82goCCze/fu5okTJ5yOpLHZbObw4cPNunXrmkFBQWZAQIBZt25dc/r06U5j/f1IGtM0zXPnzpnPP/+8GRoaavr4+Jh33nmn+eabbzodoWOa1/4dK1asaPbp0yebX/P//PVImuvJ7jf47rvvzPvuu8/09/c3Q0NDHUca/f33S09PN3v16mUWK1bMlOT4nld/6yVLlmS539//OUydOtWUZH7yySdO/VJSUsyiRYua7du3v278APInwzRdXDkNAACAfIc1hQAAACApBAAAAEkhAAAARFIIAADgMeLi4mQYhtN19cED17JkyRJFRESocOHCql27tuMoNFeRFAIAAHiQmjVrKjU11XFt2LDhmn03btyonj17qn///tq2bZs6d+6szp0766effnL5vuw+BgAA8BBxcXFKTExUcnJyjvr36NFD58+f1+eff+5ou++++1SvXj3NnDnTpXtTKQQAAHAjm82mtLQ0p+t6T2Has2ePQkNDVblyZUVFRSklJeWafTdt2qTIyEintjZt2mjTpk0ux5kvn2hSyDfM6hAAAICLLmccsezel07uc9vY8dM+0OjRo53aYmNjFRcXl6Vvo0aNNH/+fFWrVk2pqakaPXq0mjVrpp9++klBQUFZ+h87dkxly5Z1aitbtqyOHTvmcpz5MikEAADwFDExMRo2bJhTm5+fX7Z9//os9jp16qhRo0aqWLGiPv74Y/Xv39+tcZIUAgAAZNrdNrSfn981k8AbKVasmO666y799ttv2b5frlw5HT9+3Knt+PHjKleunMv3Yk0hAACAmem+6xakp6dr7969CgkJyfb9xo0ba82aNU5tq1evVuPGjV2+F0khAACAh3jxxRf17bff6sCBA9q4caO6dOkib29v9ezZU5LUu3dvxcTEOPpHR0frq6++0uTJk/XLL78oLi5OP/74o5599lmX7830MQAAQOatVfRyy+HDh9WzZ0+dOnVKpUuX1v3336/vv/9epUuXliSlpKTIy+v/anpNmjRRQkKCXn31Vb388su68847lZiYqFq1arl873x5TiG7jwEAyHss3X2custtY/uEVHfb2LmJSiEAACjwzFtc+5cfsKYQAAAAVAoBAAA8ZU2hlagUAgAAgEohAADArZ4nmB+QFAIAALjxiSZ5BdPHAAAAoFIIAADA9DGVQgAAAIhKIQAAAEfSiEohAAAARKUQAACAx9yJSiEAAABEpRAAAIA1hSIpBAAA4EgaMX0MAAAAUSkEAADgMXeiUggAAABRKQQAAGBNoagUAgAAQFQKAQAAOJJGVAoBAAAgKoUAAACsKRRJIQAAANPHYvoYAAAAolIIAAAg0+TwaiqFAAAAoFIIAADARhMqhQAAABCVQgAAAHYfi0ohAAAARKUQAACANYUiKQQAAJAyOZKG6WMAAABQKQQAAGD6mEohAAAARKUQAACAI2lEpRAAAACiUggAAMCaQlEpBAAAgKgUAgAAsKZQJIUAAAAkhWL6GAAAAKJSCAAAINPkMXdUCgEAAEClEAAAgDWFVAoBAAAgKoUAAAAcXi0qhQAAABCVQgAAANYUiqQQAACA6WMxfQwAAABRKQQAAGD6WFQKAQAAICqFAAAArCkUlUIAAACISiEAAABrCkWlEAAAAKJSCAAAQKVQJIUAAABsNBHTxwAAABCVQgAAAKaPRaUQAAAAolIIAADAmkJRKQQAAICoFAIAALCmUFQKAQAAICqFAAAArCkUlUIAAADIwkph165dc9x32bJlbowEAAAUeKwptC4pDA4Odvxtmqb+85//KDg4WA0bNpQkbdmyRWfOnHEpeQQAALgpJIXWJYXz5s1z/D1ixAh1795dM2fOlLe3tyTJbrdr0KBBKlq0qFUhAgAAFBiGaZqm1UGULl1aGzZsULVq1Zzad+/erSZNmujUqVMujVfINyw3wwMAALfB5Ywjlt37z8Wj3Ta2f49Yt42dmzxio8nly5f1yy+/ZGn/5ZdflEk5FwAAwO084kiafv36qX///tq7d6/uvfdeSdLmzZs1fvx49evXz+LoAABAvkcRyjOSwkmTJqlcuXKaPHmyUlNTJUkhISEaPny4XnjhBYujAwAAyP88Yk3hX6WlpUnSLW0wYU0hAAB5j6VrCheMctvY/lFj3DZ2bvKINYXSlXWF//3vf7Vw4UIZhiFJOnr0qNLT0y2ODAAAIP/ziOnjgwcPqm3btkpJSZHNZlPr1q0VFBSkCRMmyGazaebMmVaHCAAA8jMec+cZlcLo6Gg1bNhQp0+flr+/v6O9S5cuWrNmjYWRAQCAAiEz031XHuERlcL169dr48aN8vX1dWoPDw/XkSPWrS8AAAAoKDyiUpiZmSm73Z6l/fDhwwoKCrIgIgAAUKCYpvuuWzB+/HgZhqGhQ4det9+UKVNUrVo1+fv7q3z58nr++ed18eJFl+7lEUnhQw89pClTpjheG4ah9PR0xcbGqn379tYFBgAAYJGkpCTNmjVLderUuW6/hIQEjRw5UrGxsdq1a5fmzp2rxYsX6+WXX3bpfh4xfTxp0iS1bdtWNWrU0MWLF9WrVy/t2bNHpUqV0sKFC60ODwAA5HcetvYvPT1dUVFRmj17tt54443r9t24caOaNm2qXr16Sbqy/K5nz57avHmzS/f0iEph+fLltX37dr3yyit6/vnnVb9+fY0fP17btm1TmTJlrA4PAADgptlsNqWlpTldNpvtup8ZPHiwOnTooMjIyBuO36RJE23ZskU//PCDJGnfvn1asWKFy7OtllcKL126pIiICH3++eeKiopSVFSU1SEBAICCxo2Vwvj4eI0ePdqpLTY2VnFxcdn2X7RokbZu3aqkpKQcjd+rVy+dPHlS999/v0zT1OXLl/XMM8+4PH1seaXQx8fH5YWQAAAAeUVMTIzOnj3rdMXExGTb99ChQ4qOjtaCBQtUuHDhHI2/du1ajRs3TtOnT9fWrVu1bNkyffHFFxozxrUnqXjEY+7GjRunX3/9VXPmzFGhQrdevOQxdwAA5D2WPuZuzjC3je0/4K0c901MTFSXLl3k7e3taLPb7TIMQ15eXrLZbE7vSVKzZs1033336c0333S0ffTRR3rqqaeUnp4uL6+c1QAtnz6WruyuWbNmjVatWqXatWsrICDA6f1ly5ZZFBkAACgIzEzLa2SSpFatWmnnzp1Obf369VNERIRGjBiRJSGUpAsXLmRJ/K72c6X25xFJYbFixdStWzerwwAAALBUUFCQatWq5dQWEBCgkiVLOtp79+6tsLAwxcfHS5I6duyot956S/Xr11ejRo3022+/adSoUerYsWO2SeS1eERSOG/ePKtDAAAABZmHHUlzPSkpKU6VwVdffVWGYejVV1/VkSNHVLp0aXXs2FFjx451aVyPWFMoSZcvX9batWu1d+9e9erVS0FBQTp69KiKFi2qwMBAl8ZiTSEAAHmPlWsKL8yMdtvYRZ6Z6raxc5NHVAoPHjyotm3bKiUlRTabTa1bt1ZQUJAmTJggm82mmTNnWh0iAADIz8y8Uyl0F8uPpJGk6OhoNWzYUKdPn5a/v7+jvUuXLlqzZo2FkQEAABQMHlEpXL9+vTZu3ChfX1+n9vDwcB05Yl0pGQAAFBAesvvYSh5RKczMzJTdbs/SfvjwYQUFBVkQEQAAQMHiEUnhQw89pClTpjheG4ah9PR0xcbGuvzcPgAAAJdlZrrvyiM8Yvp48uTJatOmjWrUqKGLFy+qV69e2rNnj0qVKqWFCxdaHR4AAMjv8lDy5i4ekRTecccd2r59uxYvXqzt27crPT1d/fv3V1RUlNPGEwAAALiHR5xTuG7dOjVp0iTLc48vX76sjRs3qnnz5i6NxzmFAADkPZaeUzjlabeNXWToLLeNnZs8Yk1hy5Yt9ccff2RpP3v2rFq2bGlBRAAAAAWLR0wfm6YpwzCytJ86dUoBAQEWRAQAAAoU1hRamxR27dpV0pXdxn379pWfn5/jPbvdrh07dqhJkyZWhQcAAFBgWDp9HBwcrODgYJmmqaCgIMfr4OBglStXTk899ZQ++ugjK0ME4IFeGj5YlzOOaPKk0VaHAiC/yDTdd+URllYK582bJ+nKk0tefPFFpooB3FDDu+vqyQGPafuO/1kdCgDkKx6x0SQ2NpaEEMANBQQU0QcfTNMzA1/SmdNnrA4HQH5iZrrvyiM8Iik8fvy4Hn/8cYWGhqpQoULy9vZ2ugBAkt751zh9uWKN1ny93upQAOQ3TB97xu7jvn37KiUlRaNGjVJISEi2O5GvxWazyWazObVdazczgLyre/dOql+/lu5r3MHqUAAgX/KIpHDDhg1av3696tWr5/Jn4+PjNXq082JzwytQhnfRXIoOgNXuuCNUb09+XW3b98zyL4EAkBtMjqTxjOnj8uXL62YfrBITE6OzZ886XYZXUC5HCMBKDRrUVtmypZW0+StdvHBQFy8cVIsWTfTcs0/o4oWD8vLyiP8qA4A8zSMqhVOmTNHIkSM1a9YshYeHu/RZPz8/p/MNJTF1DOQzX3+9QXXrP+jUNmf2W9q9e6/enPRvZfJv+ABuVR5a++cuHpEU9ujRQxcuXFCVKlVUpEgR+fj4OL2f3SPwABQc6enn9fPPu53aLpy/oFOnTmdpBwDcHI9ICqdMmWJ1CAAAoCDLQ0fHuItHJIV9+vSxOgQAeUyr1o9aHQIA5CsekRSmpKRc9/0KFSrcpkgAAECBxJpCz0gKw8PDr7s5xG6338ZoAABAgcOGNc9ICrdt2+b0+tKlS9q2bZveeustjR071qKoAAAACg6PSArr1q2bpa1hw4YKDQ3Vm2++qa5du1oQFQAAKDCYPvaMw6uvpVq1akpKSrI6DAAAgHzPIyqFaWlpTq9N01Rqaqri4uJ05513WhQVAAAoMDiSxjOSwmLFimXZaGKapsqXL69FixZZFBUAAEDB4RFJ4TfffOP02svLS6VLl1bVqlVVqJBHhAgAAPIz1hR6RlLYokULq0MAAAAo0DwiKZSkvXv3asqUKdq1a5ckqUaNGoqOjlaVKlUsjgwAAOR3JucUesbu45UrV6pGjRr64YcfVKdOHdWpU0ebN29WzZo1tXr1aqvDAwAA+V2m6b4rjzBM07Q82vr166tNmzYaP368U/vIkSO1atUqbd261aXxCvmG5WZ4AADgNricccSye6ePcN+ZyIETlrlt7NzkEZXCXbt2qX///lnan3jiCf3vf/+zICIAAFCgUCn0jKSwdOnSSk5OztKenJysMmXK3P6AAAAAChiP2Gjy5JNP6qmnntK+ffvUpEkTSdJ3332nCRMmaNiwYRZHBwAA8j0Or/aMpHDUqFEKCgrS5MmTFRMTI0kKDQ1VXFychgwZYnF0AAAA+Z9HbDT5q3PnzkmSgoKCbnoMNpoAAJD3WLrRZFgnt40d+NZyt42dmzyiUrh//35dvnxZd955p1MyuGfPHvn4+Cg8PNy64AAAAAoAj9ho0rdvX23cuDFL++bNm9W3b9/bHxAAAChQzEzTbVde4RFJ4bZt29S0adMs7ffdd1+2u5IBAAByFUfSeEZSaBiGYy3hX509e1Z2u92CiAAAAAoWj0gKmzdvrvj4eKcE0G63Kz4+Xvfff7+FkQEAgAIhM9N9Vx7hERtNJkyYoObNm6tatWpq1qyZJGn9+vVKS0vT119/bXF0AAAA+Z9HVApr1KihHTt2qHv37jpx4oTOnTun3r1765dfflGtWrWsDg8AAOR3rCn0jEqhdOWw6nHjxlkdBgAAQIHkMUnhmTNn9MMPP+jEiRPK/Nv8e+/evS2KCgAAFAh5qKLnLh6RFH722WeKiopSenq6ihYtKsMwHO8ZhkFSCAAA4GYesabwhRde0BNPPKH09HSdOXNGp0+fdlx//PGH1eEBAIB8zjRNt115hUckhUeOHNGQIUNUpEgRq0MBAAAokDwiKWzTpo1+/PFHq8MAAAAFFbuPPWNNYYcOHTR8+HD973//U+3ateXj4+P0fqdOnSyKDAAAFAh5KHlzF8P0gMluL69rFywNw3D5UXeFfMNuNSQAAHCbXc44Ytm90/q3dtvYReeudtvYuckjKoV/P4IGAADgdjKpFFq7prB9+/Y6e/as4/X48eN15swZx+tTp06pRo0aFkQGAABQsFiaFK5cuVI2m83xety4cU5H0Fy+fFm7d++2IjQAAFCQsNHE2qTw78sZPWB5IwAAQIHkEWsKAQAALMX2BmsrhYZhOD3S7mobAAAAbi9LK4Wmaapv377y8/OTJF28eFHPPPOMAgICJMlpvSEAAIC7sPvY4qSwT58+Tq8fe+yxLH169+59u8IBAAAFFUmhtUnhvHnzrLw9AAAA/j82mgAAALDRxNqNJgAAAPAMVAoBAECBx0YTKoUAAAAQlUIAAADWFIpKIQAAAESlEAAAgDWFIikEAABg+lhMHwMAAEBUCgEAAGRSKaRSCAAAACqFAAAArCkUlUIAAACISiEAAABrCkWlEAAAAKJSCAAAwJpCkRQCAAAwfSymjwEAACAqhQAAAFQKRaUQAADAY40fP16GYWjo0KHX7XfmzBkNHjxYISEh8vPz01133aUVK1a4dC8qhQAAoMDzxEphUlKSZs2apTp16ly3X0ZGhlq3bq0yZcpo6dKlCgsL08GDB1WsWDGX7kdSCAAA4GHS09MVFRWl2bNn64033rhu3/fee09//PGHNm7cKB8fH0lSeHi4y/dk+hgAAMA03HbZbDalpaU5XTab7brhDB48WB06dFBkZOQNQ1++fLkaN26swYMHq2zZsqpVq5bGjRsnu93u0k9AUggAAOBG8fHxCg4Odrri4+Ov2X/RokXaunXrdfv81b59+7R06VLZ7XatWLFCo0aN0uTJk29YYfw7wzRN06VP5AGFfMOsDgEAALjocsYRy+59rPkDbhu7+OqVWSqDfn5+8vPzy9L30KFDatiwoVavXu1YS/jAAw+oXr16mjJlSrbj33XXXbp48aL2798vb29vSdJbb72lN998U6mpqTmOkzWFAACgwDMzDbeNfa0EMDtbtmzRiRMn1KBBA0eb3W7XunXrNG3aNNlsNkfid1VISIh8fHyc2qtXr65jx44pIyNDvr6+Obo3SSEAAICHaNWqlXbu3OnU1q9fP0VERGjEiBFZEkJJatq0qRISEpSZmSkvrysrA3/99VeFhITkOCGUSAoBAAA85kiaoKAg1apVy6ktICBAJUuWdLT37t1bYWFhjjWHAwcO1LRp0xQdHa3nnntOe/bs0bhx4zRkyBCX7k1SCAAAkIekpKQ4KoKSVL58ea1cuVLPP/+86tSpo7CwMEVHR2vEiBEujctGEwAA4BGs3GhypPGDbhs7bNPXbhs7N3EkDQAAAJg+BgAA8JQ1hVaiUggAAAAqhQAAAO48pzCvICkEAAAFXv7bdus6po8BAABApRAAAIDpYyqFAAAAEJVCAAAAKoWiUggAAABRKQQAAGD3sagUAgAAQFQKAQAAWFMokkIAAACZJkkh08cAAACgUggAAGBmWh2B9agUAgAAgEohAABAJmsKqRQCAACASiEAAAC7j5XDpHD58uU5HrBTp043HQwAAACskaOksHPnzjkazDAM2e32W4kHAADgtuPw6hwmhZmZ7NMGAAD5F88+ZqMJAAAAdJMbTc6fP69vv/1WKSkpysjIcHpvyJAhuRIYAADA7cL08U0khdu2bVP79u114cIFnT9/XiVKlNDJkydVpEgRlSlThqQQAAAgD3J5+vj5559Xx44ddfr0afn7++v777/XwYMHdffdd2vSpEnuiBEAAMCtMk3DbVde4XJSmJycrBdeeEFeXl7y9vaWzWZT+fLlNXHiRL388svuiBEAAABu5nJS6OPjIy+vKx8rU6aMUlJSJEnBwcE6dOhQ7kYHAABwG5im4bYrr3B5TWH9+vWVlJSkO++8Uy1atNBrr72mkydP6sMPP1StWrXcESMAAADczOVK4bhx4xQSEiJJGjt2rIoXL66BAwfq999/17vvvpvrAQIAALibabrvyisM08xL4eZMId8wq0MAAAAuupxxxLJ77wjv6Lax6xz4zG1j56abOqcQAAAgP8lLu4TdxeWksFKlSjKMa/9w+/btu6WAAAAAbre8tCHEXVxOCocOHer0+tKlS9q2bZu++uorDR8+PLfiAgAAwG3kclIYHR2dbfu///1v/fjjj7ccEAAAwO2W/3ZYuM7l3cfX0q5dO33yySe5NRwAAABuo1zbaLJ06VKVKFEit4YDAAC4bdhocpOHV/91o4lpmjp27Jh+//13TZ8+PVeDAwAAwO3hclL48MMPOyWFXl5eKl26tB544AFFRETkanA368+j660OAQAA5CHsPr6JpDAuLs4NYQAAAMBKLm808fb21okTJ7K0nzp1St7e3rkSFAAAwO2UaRpuu/IKlyuF13oqns1mk6+v7y0HBAAAcLtxIo0LSeG//vUvSZJhGJozZ44CAwMd79ntdq1bt85j1hQCAADANTlOCt9++21JVyqFM2fOdJoq9vX1VXh4uGbOnJn7EQIAALhZXprmdZccJ4X79++XJLVs2VLLli1T8eLF3RYUAAAAbi+X1xR+88037ogDAADAMhxJcxO7j7t166YJEyZkaZ84caIeffTRXAkKAAAAt5fLSeG6devUvn37LO3t2rXTunXrciUoAACA2ynTjVde4XJSmJ6enu3RMz4+PkpLS8uVoAAAAHB7uZwU1q5dW4sXL87SvmjRItWoUSNXggIAALidTBluu/IKlzeajBo1Sl27dtXevXv14IMPSpLWrFmjhIQELV26NNcDBAAAcLdMTq92PSns2LGjEhMTNW7cOC1dulT+/v6qW7euvv76a5UoUcIdMQIAAMDNDPNaz63LobS0NC1cuFBz587Vli1bZLfbcyu2m3bp5D6rQwAAAC7yKVXZsnt/Xba728Z+8PjHbhs7N7m8pvCqdevWqU+fPgoNDdXkyZP14IMP6vvvv8/N2AAAAHCbuDR9fOzYMc2fP19z585VWlqaunfvLpvNpsTERDaZAACAPCsvbQhxlxxXCjt27Khq1appx44dmjJlio4ePap33nnHnbEBAADgNslxpfDLL7/UkCFDNHDgQN15553ujAkAAOC2ykuHTLtLjiuFGzZs0Llz53T33XerUaNGmjZtmk6ePOnO2AAAAHCb5DgpvO+++zR79mylpqbq6aef1qJFixQaGqrMzEytXr1a586dc2ecAAAAbsPh1bd4JM3u3bs1d+5cffjhhzpz5oxat26t5cuX52Z8N4UjaQAAyHusPJLmq7L/dNvYbY8vctvYuemmj6SRpGrVqmnixIk6fPiwFi5cmFsxAQAA4DZz+Ykm2fH29lbnzp3VuXPn3BgOAADgtmKjyS1WCgEAAJA/5EqlEAAAIC/LSxtC3IVKIQAAAKgUAgAAZFIopFIIAAAAKoUAAADKZE0hSSEAAMBNP8kjH2H6GAAAAFQKAQAAOLyaSiEAAABEpRAAAECZBhtNqBQCAACASiEAAAC7j6kUAgAAQFQKAQAA2H0skkIAAACefSymjwEAACAqhQAAADz7WFQKAQAAPNb48eNlGIaGDh2ao/6LFi2SYRjq3Lmzy/eiUggAAAo8TzySJikpSbNmzVKdOnVy1P/AgQN68cUX1axZs5u6H5VCAAAAD5Oenq6oqCjNnj1bxYsXv2F/u92uqKgojR49WpUrV76pe5IUAgCAAi/TcN9ls9mUlpbmdNlstuvGM3jwYHXo0EGRkZE5iv/1119XmTJl1L9//5v+DUgKAQAA3Cg+Pl7BwcFOV3x8/DX7L1q0SFu3br1un7/asGGD5s6dq9mzZ99SnKwpBAAABZ47D6+OiYnRsGHDnNr8/Pyy7Xvo0CFFR0dr9erVKly48A3HPnfunB5//HHNnj1bpUqVuqU4DdM0PXFt5S25dHKf1SEAAAAX+ZS6ubVwuWFe2GNuG7vfkY9y3DcxMVFdunSRt7e3o81ut8swDHl5eclmszm9l5ycrPr16zu1ZWZeSXG9vLy0e/duValSJUf3plIIAADgIVq1aqWdO3c6tfXr108REREaMWKEU/InSREREVn6v/rqqzp37pymTp2q8uXL5/jeJIUAAKDA85TH3AUFBalWrVpObQEBASpZsqSjvXfv3goLC1N8fLwKFy6cpX+xYsUkKUv7jZAUAgAA5CEpKSny8sr9vcKsKQQAAB7ByjWFs+9w35rCJw/nfE2hlTiSBgAAAEwfAwAAuPNImryCSiEAAACoFAIAAJgesvvYSiSFAACgwGP6mOljAAAAiEohAAAAlUJRKQQAAICoFAIAACjfPcnjJlApBAAAAJVCAACATI6koVIIAAAAKoUAAADsPhZJIQAAAEmhmD4GAACAqBQCAABwJI2oFAIAAEBUCgEAADiSRlQKAQAAICqFAAAA7D4WlUIAAACISiEAAAC7j0WlEAAAAKJSCAAAoExqhSSFAAAAbDRh+hgAAACiUggAAMDksagUAgAAQFQKAQAAWFMoKoUAAAAQlUIAAABlGlZHYD0qhQAAAKBSCAAAwOHVJIUAAACkhGL6GAAAAKJSCAAAwJE0olIIAAAAUSkEAABgo4moFAIAAEAWVQrr168vw8jZKZFbt251czQAAKCgo05oUVLYuXNnx98XL17U9OnTVaNGDTVu3FiS9P333+vnn3/WoEGDrAgPAACgwLEkKYyNjXX8PWDAAA0ZMkRjxozJ0ufQoUO3OzQAAFAAsfvYA9YULlmyRL17987S/thjj+mTTz6xICIAAFDQZMp025VXWJ4U+vv767vvvsvS/t1336lw4cIWRAQAAFDwWH4kzdChQzVw4EBt3bpV9957ryRp8+bNeu+99zRq1CiLowMAAAVB3qnnuY/lSeHIkSNVuXJlTZ06VR999JEkqXr16po3b566d+9ucXQAAAAFg+VJoSR1796dBBAAAFiGjSYesKZQks6cOaM5c+bo5Zdf1h9//CHpyvmER44csTgyAACAgsHySuGOHTsUGRmp4OBgHThwQAMGDFCJEiW0bNkypaSk6IMPPrA6RAAAkM+ZrCq0vlI4bNgw9e3bV3v27HHabdy+fXutW7fOwsgAAAAKDssrhUlJSZo1a1aW9rCwMB07dsyCiAAAQEHDmkIPSAr9/PyUlpaWpf3XX39V6dKlLYgIAAAUNHnpkGl3sXz6uFOnTnr99dd16dIlSZJhGEpJSdGIESPUrVs3i6MDAAAoGCxPCidPnqz09HSVKVNGf/75p1q0aKGqVasqKChIY8eOtTo8AABQAJhuvPIKy6ePg4ODtXr1an333Xfavn270tPT1aBBA0VGRlodGgAAQIFheVL4wQcfqEePHmratKmaNm3qaM/IyNCiRYvUu3dvC6MDAAAFAWsKPWD6uF+/fjp79myW9nPnzqlfv34WRAQAAFDwWF4pNE1ThmFkaT98+LCCg4MtiAiAp/n33I80470FTm2VKtyhzxbOtigiAPkNR9JYmBTWr19fhmHIMAy1atVKhQr9Xyh2u1379+9X27ZtrQoPgIepWqmi5kwd53jt7e1tYTQAkP9YlhR27txZkpScnKw2bdooMDDQ8Z6vr6/Cw8M5kgaAg7e3t0qVLGF1GADyKR5zZ2FSGBsbK0kKDw9Xjx49nB5xBwB/l3L4iFp2ipKfn6/q1ozQ0Gf6KaRcGavDApBPMH0sGaZpekRqnJGRoRMnTigz0/kfS4UKFa77OZvNJpvN5tTmde6I/Pz8cj1GANZYvylJF/68qPAKd+jkqT80/b0FOvH7KSV+OEMBAUWsDg9ALvEpVdmyez8R/ojbxn7vwFK3jZ2bLN99vGfPHjVr1kz+/v6qWLGiKlWqpEqVKik8PFyVKlW64efj4+MVHBzsdE2YOvM2RA7gdmnW+B61ebCZqlWtpKaN7taMSa/rXHq6vvp6vdWhAcgnTDf+T15h+e7jvn37qlChQvr8888VEhKS7U7k64mJidGwYcOc2rzOHcnNEAF4mKJBgapYPkwph49aHQoA5BuWJ4XJycnasmWLIiIiburzfn5+WaaKL2WczI3QAHioCxf+1KEjqerYtpXVoQDIJ1hT6AFJYY0aNXTyJEkcgGt7c9psPdC0kULLldWJk6f07zkfydvbS+0jW1gdGgDkG5YkhWlpaY6/J0yYoJdeeknjxo1T7dq15ePj49S3aNGitzs8AB7m+ImTeil2gs6kpalEsWDVr1NTC2a9rRLFi1kdGoB8ItMz9t1aypLdx15eXk5rB7N7qsnVNrvd7vL4l07uu+UYAQDA7WXl7uPHK3Z129gfHlzmtrFzkyWVwm+++caK2wIAAGSLOqFFSWGLFqwDAgAAniOTtND6jSY7duzItt0wDBUuXFgVKlTgIGoAAAA3szwprFev3nXPJvTx8VGPHj00a9YsHoUHAADcIi8dMu0ulj/R5D//+Y/uvPNOvfvuu0pOTlZycrLeffddVatWTQkJCZo7d66+/vprvfrqq1aHCgAAkG9ZXikcO3aspk6dqjZt2jjaateurTvuuEOjRo3SDz/8oICAAL3wwguaNGmShZECAID8isOrPaBSuHPnTlWsWDFLe8WKFbVz505JV6aYU1NTb3doAAAABYblSWFERITGjx+vjIwMR9ulS5c0fvx4x6Pvjhw5orJly1oVIgAAyOcyZbrtyissnz7+97//rU6dOumOO+5QnTp1JF2pHtrtdn3++eeSpH379mnQoEFWhgkAAJCvWfJEk787d+6cFixYoF9//VWSVK1aNfXq1UtBQUE3NR5PNAEAIO+x8okmj1Ts5Laxlx5c7raxc5PllUJJCgoK0jPPPGN1GAAAoIBio4lFSeHy5cvVrl07+fj4aPny62fPnTq5L3MHAADAFZYkhZ07d9axY8dUpkwZde7c+Zr9DMOQ3W6/fYEBAIACyQNW01nOkt3HmZmZKlOmjOPva10khAAAoCAbP368DMPQ0KFDr9ln9uzZatasmYoXL67ixYsrMjJSP/zwg8v3suxImk2bNjl2F1/1wQcfqFKlSipTpoyeeuop2Ww2i6IDAAAFiSceSZOUlKRZs2Y5Tme5lrVr16pnz5765ptvtGnTJpUvX14PPfSQjhw54tL9LEsKX3/9df3888+O1zt37lT//v0VGRmpkSNH6rPPPlN8fLxV4QEAAFgmPT1dUVFRmj17tooXL37dvgsWLNCgQYNUr149RUREaM6cOcrMzNSaNWtcuqdlSWFycrJatWrleL1o0SI1atRIs2fP1rBhw/Svf/1LH3/8sVXhAQCAAiTTjZfNZlNaWprTdaPZ0MGDB6tDhw6KjIx0+btcuHBBly5dUokSJVz6nGVJ4enTp52eUvLtt9+qXbt2jtf33HOPDh06ZEVoAAAAuSY+Pl7BwcFO1/VmQxctWqStW7fe9IzpiBEjFBoa6nJCadk5hWXLltX+/ftVvnx5ZWRkaOvWrRo9erTj/XPnzsnHx8eq8AAAQAFiuvFxdDExMRo2bJhTm5+fX7Z9Dx06pOjoaK1evVqFCxd2+V7jx4/XokWLtHbtWpc/b1lS2L59e40cOVITJkxQYmKiihQpombNmjne37Fjh6pUqWJVeAAAoABx5zOK/fz8rpkE/t2WLVt04sQJNWjQwNFmt9u1bt06TZs2TTabTd7e3tl+dtKkSRo/frz++9//3nBzSnYsSwrHjBmjrl27qkWLFgoMDNT7778vX19fx/vvvfeeHnroIavCAwAAuO1atWqlnTt3OrX169dPERERGjFixDUTwokTJ2rs2LFauXKlGjZseFP3tiwpLFWqlNatW6ezZ88qMDAwy5dcsmSJAgMDLYoOAAAUJJ5yeHVQUJBq1arl1BYQEKCSJUs62nv37q2wsDDHmsMJEybotddeU0JCgsLDw3Xs2DFJUmBgoEu5lGUbTa4KDg7ONustUaKEU+UQAAAAUkpKilJTUx2vZ8yYoYyMDD3yyCMKCQlxXJMmTXJpXMP0lNQ4F106uc/qEAAAgIt8SlW27N5tyre7caebtPLQl24bOzdZXikEAACA9SxbUwgAAOAp3HkkTV5BpRAAAABUCgEAANx5TmFeQaUQAAAAVAoBAADy4WEsLiMpBAAABR7Tx0wfAwAAQFQKAQAAOJJGVAoBAAAgKoUAAADKZKMJlUIAAABQKQQAAGBFoagUAgAAQFQKAQAAOKdQJIUAAAAkhWL6GAAAAKJSCAAAwLOPRaUQAAAAolIIAADAmkJRKQQAAICoFAIAAMikUkilEAAAAFQKAQAA2H0skkIAAAA2mojpYwAAAIhKIQAAANPHolIIAAAAUSkEAABgTaGoFAIAAEBUCgEAADi8WlQKAQAAICqFAAAAymT3MUkhAAAA08dMHwMAAEBUCgEAAJg+FpVCAAAAiEohAAAAawpFpRAAAACiUggAAMCaQlEpBAAAgKgUAgAAsKZQJIUAAABMH4vpYwAAAIhKIQAAANPHolIIAAAAUSkEAACQaWZaHYLlqBQCAACASiEAAEAmawqpFAIAAIBKIQAAgEzOKSQpBAAAYPqY6WMAAACISiEAAADTx6JSCAAAAFEpBAAAUCaVQiqFAAAAoFIIAAAgk93HVAoBAABApRAAAIDdxyIpBAAA4PBqMX0MAAAAUSkEAABg+lhUCgEAACAqhQAAABxeLSqFAAAAEJVCAAAA1hSKSiEAAABEpRAAAIBzCkVSCAAAwPSxmD4GAACAqBQCAABwJI2oFAIAAEBUCgEAAGSy0YRKIQAAAKgUAgAAsKZQVAoBAAAgKoUAAACcUygqhQAAABCVQgAAAHYfi6QQAACA6WMxfQwAAACRFAIAAMg0Tbddt2L8+PEyDENDhw69br8lS5YoIiJChQsXVu3atbVixQqX70VSCAAA4IGSkpI0a9Ys1alT57r9Nm7cqJ49e6p///7atm2bOnfurM6dO+unn35y6X4khQAAoMAz3XjdjPT0dEVFRWn27NkqXrz4dftOnTpVbdu21fDhw1W9enWNGTNGDRo00LRp01y6J0khAACAG9lsNqWlpTldNpvtup8ZPHiwOnTooMjIyBuOv2nTpiz92rRpo02bNrkUZ77cfexTqrLVIQBwA5vNpvj4eMXExMjPz8/qcADkI5czjrht7Li4OI0ePdqpLTY2VnFxcdn2X7RokbZu3aqkpKQcjX/s2DGVLVvWqa1s2bI6duyYS3FSKQSQZ9hsNo0ePfqG/4YNAJ4kJiZGZ8+edbpiYmKy7Xvo0CFFR0drwYIFKly48G2NM19WCgEAADyFn59fjmc3tmzZohMnTqhBgwaONrvdrnXr1mnatGmy2Wzy9vZ2+ky5cuV0/Phxp7bjx4+rXLlyLsVJpRAAAMBDtGrVSjt37lRycrLjatiwoaKiopScnJwlIZSkxo0ba82aNU5tq1evVuPGjV26N5VCAAAADxEUFKRatWo5tQUEBKhkyZKO9t69eyssLEzx8fGSpOjoaLVo0UKTJ09Whw4dtGjRIv3444969913Xbo3lUIAeYafn59iY2PZZAKgQEtJSVFqaqrjdZMmTZSQkKB3331XdevW1dKlS5WYmJglubwRw+RhfwAAAAUelUIAAACQFAIAAICkEAAAACIpBHCbGYahxMTEHPdfu3atDMPQmTNn3BbTX8XFxalevXq35V4A4ElICgHkqt9//10DBw5UhQoV5Ofnp3LlyqlNmzb67rvvJEmpqalq165drt6TRA4Abh3nFALIVd26dVNGRobef/99Va5cWcePH9eaNWt06tQpSXL5hH0AwO1BpRBArjlz5ozWr1+vCRMmqGXLlqpYsaLuvfdexcTEqFOnTpKyTh9v3LhR9erVU+HChdWwYUMlJibKMAwlJyc7jb1lyxY1bNhQRYoUUZMmTbR7925J0vz58zV69Ght375dhmHIMAzNnz/fEc+AAQNUunRpFS1aVA8++KC2b9/uNO748eNVtmxZBQUFqX///rp48aLbfh8A8GQkhQByTWBgoAIDA5WYmCibzXbD/mlpaerYsaNq166trVu3asyYMRoxYkS2fV955RVNnjxZP/74owoVKqQnnnhCktSjRw+98MILqlmzplJTU5WamqoePXpIkh599FGdOHFCX375pbZs2aIGDRqoVatW+uOPPyRJH3/8seLi4jRu3Dj9+OOPCgkJ0fTp03Pp1wCAvIWkEECuKVSokObPn6/3339fxYoVU9OmTfXyyy9rx44d2fZPSEiQYRiaPXu2atSooXbt2mn48OHZ9h07dqxatGihGjVqaOTIkdq4caMuXrwof39/BQYGqlChQipXrpzKlSsnf39/bdiwQT/88IOWLFmihg0b6s4779SkSZNUrFgxLV26VJI0ZcoU9e/fX/3791e1atX0xhtvqEaNGm77fQDAk5EUAshV3bp109GjR7V8+XK1bdtWa9euVYMGDRxTun+1e/du1alTR4ULF3a03XvvvdmOW6dOHcffISEhkqQTJ05cM47t27crPT1dJUuWdFQwAwMDtX//fu3du1eStGvXLjVq1Mjpc64+QB4A8gs2mgDIdYULF1br1q3VunVrjRo1SgMGDFBsbKz69u1702P6+Pg4/jYMQ5KUmZl5zf7p6ekKCQnR2rVrs7xXrFixm44DAPIrKoUA3K5GjRo6f/58lvZq1app586dTusPk5KSXB7f19dXdrvdqa1BgwY6duyYChUqpKpVqzpdpUqVkiRVr15dmzdvdvrc999/7/L9ASA/ICkEkGtOnTqlBx98UB999JF27Nih/fv3a8mSJZo4caIefvjhLP179eqlzMxMPfXUU9q1a5dWrlypSZMmSfq/amBOhIeHa//+/UpOTtbJkydls9kUGRmpxo0bq3Pnzlq1apUOHDigjRs36pVXXtGPP/4oSYqOjtZ7772nefPm6ddff1VsbKx+/vnn3PkxACCPISkEkGsCAwPVqFEjvf3222revLlq1aqlUaNG6cknn9S0adOy9C9atKg+++wzJScnq169enrllVf02muvSZLTOsMb6datm9q2bauWLVuqdOnSWrhwoQzD0IoVK9S8eXP169dPd911l/75z3/q4MGDKlu2rKQrO5dHjRqll156SXfffbcOHjyogQMH5s6PAQB5jGGapml1EABw1YIFC9SvXz+dPXtW/v7+VocDAAUGG00AWOqDDz5Q5cqVFRYWpu3bt2vEiBHq3r07CSEA3GYkhQAsdezYMb322ms6duyYQkJC9Oijj2rs2LFWhwUABQ7TxwAAAGCjCQAAAEgKAQAAIJJCAAAAiKQQAAAAIikEAACASAoBeLC+ffuqc+fOjtcPPPCAhg4detvjWLt2rQzD0JkzZ277vQHgdiEpBOCyvn37yjAMGYYhX19fVa1aVa+//rouX77s1vsuW7ZMY8aMyVFfEjkAcA2HVwO4KW3bttW8efNks9m0YsUKDR48WD4+PoqJiXHql5GRIV9f31y5Z4kSJXJlHABAVlQKAdwUPz8/lStXThUrVtTAgQMVGRmp5cuXO6Z8x44dq9DQUFWrVk2SdOjQIXXv3l3FihVTiRIl9PDDD+vAgQOO8ex2u4YNG6ZixYqpZMmSeumll/T3s/X/Pn1ss9k0YsQIlS9fXn5+fqpatarmzp2rAwcOqGXLlpKk4sWLyzAM9e3bV5KUmZmp+Ph4VapUSf7+/qpbt66WLl3qdJ8VK1borrvukr+/v1q2bOkUJwDkVySFAHKFv7+/MjIyJElr1qzR7t27tXr1an3++ee6dOmS2rRpo6CgIK1fv17fffedAgMD1bZtW8dnJk+erPnz5+u9997Thg0b9Mcff+g///nPde/Zu3dvLVy4UP/617+0a9cuzZo1S4GBgSpfvrw++eQTSdLu3buVmpqqqVOnSpLi4+P1wQcfaObMmfr555/1/PPP67HHHtO3334r6Ury2rVrV3Xs2FHJyckaMGCARo4c6a6fDQA8BtPHAG6JaZpas2aNVq5cqeeee06///67AgICNGfOHMe08UcffaTMzEzNmTNHhmFIkubNm6dixYpp7dq1euihhzRlyhTFxMSoa9eukqSZM2dq5cqV17zvr7/+qo8//lirV69WZGSkJKly5cqO969ONZcpU0bFihWTdKWyOG7cOP33v/9V48aNHZ/ZsGGDZs2apRYtWmjGjBmqUqWKJk+eLEmqVq2adu7cqQkTJuTirwYAnoekEMBN+fzzzxUYGKhLly4pMzNTvXr1UlxcnAYPHqzatWs7rSPcvn27fvvtNwUFBTmNcfHiRe3du1dnz55VamqqGjVq5HivUKFCatiwYZYp5KuSk5Pl7e2tFi1a5Djm3377TRcuXFDr1q2d2jMyMlS/fn1J0q5du5zikORIIAEgPyMpBHBTWrZsqRkzZsjX11ehoaEqVOj//uskICDAqW96erruvvtuLViwIMs4pUuXvqn7+/v7u/yZ9PR0SdIXX3yhsLAwp/f8/PxuKg4AyC9ICgHclICAAFWtWjVHfRs0aKDFixerTJkyKlq0aLZ9QkJCtHnzZjVv3lySdPnyZW3ZskUNGjTItn/t2rWVmZmpb7/91jF9/FdXK5V2u93RVqNGDfn5+SklJeWaFcbq1atr+fLlTm3ff//9jb8kAORxbDQB4HZRUVEqVaqUHn74Ya1fv1779+/X2rVrNWTIEB0+fFiSFB0drfHjxysxMVG//PKLBg0adN0zBsPDw9WnTx898cQTSkxMdIz58ccfS5IqVqwowzD0+eef6/fff1d6erqCgoL04osv6vnnn9f777+vvXv3auvWrXrnnXf0/vvvS5KeeeYZ7dmzR8OHD9fu3buVkJCg+fPnu/snAgDLkRQCcLsiRYpo3bp1qlChgrp27arq1aurf//+unjxoqNy+MILL+jxxx9Xnz591LhxYwUFBalLly7XHXfGjBl65JFHNGjQIEVEROjJJ5/U+fPnJUlhYWEaPXq0Ro4cqbJly+rZZ5+VJI0ZM0ajRo1SfHy8qlevrrZt2+qLL75QpUqVJEkVKlTQJ598osTERNWtW1czZ87UuHHj3PjrAIBnMMxrreIGAABAgUGlEAAAACSFAAAAICkEAACASAoBAAAgkkIAAACIpBAAAAAiKQQAAIBICgEAACCSQgAAAIikEAAAACIpBAAAgKT/B5WlzrpxhHASAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.svm import SVC\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\")\n",
    "\n",
    "# Preprocess the data\n",
    "X = data[['Turtle_No', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status']  # Target variable\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the SVM model\n",
    "model = SVC()\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results['Actual'], results['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('SVM Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "715ef845",
   "metadata": {},
   "source": [
    "The results correspond to the evaluation metrics and predicted values from a Support Vector Machines (SVM) model for the task of predicting the status of turtles. Let's go through the different components of the result:\n",
    "\n",
    "- Precision: Precision measures the accuracy of positive predictions. In this case, the precision for class Encountered is 0.00, indicating that there were no correct predictions for this class. The precision for class Sighted is 0.56, meaning that 56% of the predictions made for Sighted were correct.\n",
    "\n",
    "- Recall: Recall, also known as sensitivity or true positive rate, measures the proportion of actual positives that were correctly identified. The recall for class Encountered is 0.00, indicating that none of the instances of Encountered were correctly identified. The recall for class Sighted is 1.00, meaning that all instances of Sighted were correctly identified.\n",
    "\n",
    "- F1-score: The F1-score is the harmonic mean of precision and recall. The F1-score for class Encountered is 0.00, while for class Sighted, it is 0.71.\n",
    "\n",
    "- Support: The support indicates the number of instances of each class in the test set. In this case, there are 4 instances of Encountered and 5 instances of Sighted.\n",
    "\n",
    "- Accuracy: The accuracy is the overall performance of the model, which is the proportion of correct predictions out of the total number of predictions. In this case, the accuracy is 0.56, indicating that 56% of the predictions were correct.\n",
    "\n",
    "The second part of the result shows the actual values and the corresponding predicted values for each instance in the test set. It indicates whether the model correctly predicted the status of the turtles for each instance.\n",
    "\n",
    "To summarize, the SVM model achieved high recall for class Sighted, correctly identifying all instances of this class. However, the model struggled to predict instances of class Encountered, as indicated by the low precision and recall for this class. The overall accuracy of the model is relatively low, suggesting that the model might not be capturing the patterns in the data effectively. Further analysis and potential adjustments to the model or dataset may be necessary to improve the results."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb10cec7",
   "metadata": {},
   "source": [
    "5. Neural Networks: Neural networks, specifically deep learning models, have shown great performance in various classification tasks. They can learn complex patterns and relationships in the data. However, they typically require a larger amount of data and computational resources."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "f355cc5c",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n",
      "C:\\Users\\Shoaib\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\sklearn\\metrics\\_classification.py:1344: UndefinedMetricWarning: Precision and F-score are ill-defined and being set to 0.0 in labels with no predicted samples. Use `zero_division` parameter to control this behavior.\n",
      "  _warn_prf(average, modifier, msg_start, len(result))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       0.00      0.00      0.00         4\n",
      "     Sighted       0.56      1.00      0.71         5\n",
      "\n",
      "    accuracy                           0.56         9\n",
      "   macro avg       0.28      0.50      0.36         9\n",
      "weighted avg       0.31      0.56      0.40         9\n",
      "\n",
      "         Actual Predicted\n",
      "25  Encountered   Sighted\n",
      "13  Encountered   Sighted\n",
      "8   Encountered   Sighted\n",
      "26      Sighted   Sighted\n",
      "4   Encountered   Sighted\n",
      "39      Sighted   Sighted\n",
      "19      Sighted   Sighted\n",
      "29      Sighted   Sighted\n",
      "30      Sighted   Sighted\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.neural_network import MLPClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\")\n",
    "\n",
    "# Preprocess the data\n",
    "X = data[['Turtle_No', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status']  # Target variable\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Train the Neural Networks model\n",
    "model = MLPClassifier(hidden_layer_sizes=(10, 10), max_iter=1000)  # You can adjust the hidden layer sizes and max iterations\n",
    "model.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = model.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results['Actual'], results['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f95d540b",
   "metadata": {},
   "source": [
    "The results provided are the evaluation metrics for the predictions made by the Neural Networks model. Here's an explanation of each metric:\n",
    "\n",
    "- Precision: Precision measures the accuracy of the positive predictions. In this case, for the \"Encountered\" class, the precision is 0.00, which means that none of the predicted instances were correctly classified as \"Encountered\". For the \"Sighted\" class, the precision is 0.56, indicating that 56% of the predicted instances were correctly classified as \"Sighted\".\n",
    "\n",
    "- Recall: Recall measures the ability of the model to correctly identify the positive instances. The recall for the \"Encountered\" class is 0.00, indicating that none of the actual \"Encountered\" instances were correctly classified. The recall for the \"Sighted\" class is 1.00, meaning that all actual \"Sighted\" instances were correctly classified.\n",
    "\n",
    "- F1-score: The F1-score is the harmonic mean of precision and recall. It provides a balanced measure of the model's performance. The F1-score for the \"Encountered\" class is 0.00, and for the \"Sighted\" class, it is 0.71.\n",
    "\n",
    "- Support: Support represents the number of instances in each class in the test set. In this case, there are 4 instances of \"Encountered\" and 5 instances of \"Sighted\".\n",
    "\n",
    "- Accuracy: Accuracy is the overall performance of the model, calculated as the ratio of correctly predicted instances to the total number of instances. The accuracy for this model is 0.56, indicating that 56% of the instances in the test set were correctly classified.\n",
    "\n",
    "The second part of the results shows the actual values and predicted values for each instance in the test set. For example, instance 25 was actually \"Encountered\" but was predicted as \"Sighted\". Instance 26 was actually \"Sighted\" and was correctly predicted as \"Sighted\"."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d03f88fd",
   "metadata": {},
   "source": [
    "# using a VotingClassifier with Logistic Regression, Random Forest, and Gradient Boosting classifiers for predicting the status of turtles caught in boat sizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "8bac1154",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      " Encountered       1.00      0.25      0.40         4\n",
      "     Sighted       0.62      1.00      0.77         5\n",
      "\n",
      "    accuracy                           0.67         9\n",
      "   macro avg       0.81      0.62      0.58         9\n",
      "weighted avg       0.79      0.67      0.61         9\n",
      "\n",
      "         Actual    Predicted\n",
      "25  Encountered      Sighted\n",
      "13  Encountered      Sighted\n",
      "8   Encountered      Sighted\n",
      "26      Sighted      Sighted\n",
      "4   Encountered  Encountered\n",
      "39      Sighted      Sighted\n",
      "19      Sighted      Sighted\n",
      "29      Sighted      Sighted\n",
      "30      Sighted      Sighted\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 800x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.ensemble import VotingClassifier\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "from sklearn.ensemble import GradientBoostingClassifier\n",
    "from sklearn.metrics import classification_report\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "# Load the dataset\n",
    "data = pd.read_csv(\"Turtle_Bycatch.csv\")\n",
    "\n",
    "# Preprocess the data\n",
    "X = data[['Turtle_No', 'Boat_Sizeft']]  # Features\n",
    "y = data['Status']  # Target variable\n",
    "\n",
    "# Handle categorical variables by creating dummy variables\n",
    "X = pd.get_dummies(X, drop_first=True)\n",
    "\n",
    "# Split the data into training and testing sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Initialize the individual classifiers\n",
    "classifier1 = LogisticRegression()\n",
    "classifier2 = RandomForestClassifier()\n",
    "classifier3 = GradientBoostingClassifier()\n",
    "\n",
    "# Create the voting classifier\n",
    "voting_classifier = VotingClassifier(\n",
    "    estimators=[('lr', classifier1), ('rf', classifier2), ('gb', classifier3)],\n",
    "    voting='hard'  # Voting strategy can be 'hard' or 'soft'\n",
    ")\n",
    "\n",
    "# Train the voting classifier\n",
    "voting_classifier.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = voting_classifier.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "print(classification_report(y_test, y_pred))\n",
    "\n",
    "# Display the results\n",
    "results = pd.DataFrame({'Actual': y_test, 'Predicted': y_pred})\n",
    "print(results)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.heatmap(pd.crosstab(results['Actual'], results['Predicted']), annot=True, fmt='d')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66a26efd",
   "metadata": {},
   "source": [
    "code creates a VotingClassifier with Logistic Regression, Random Forest, and Gradient Boosting classifiers. The 'voting' parameter is set to 'hard', which means the majority vote among the classifiers will be used for predictions. The code then fits the voting classifier on the training data, makes predictions on the test set, and evaluates the model using the classification report. The results are displayed in a DataFrame and a confusion matrix is plotted using seaborn's heatmap."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "641c9480",
   "metadata": {},
   "source": [
    "The provided results show the evaluation metrics for a classification model. Let's go through each metric and what it represents:\n",
    "\n",
    "- Precision: Precision measures the proportion of true positive predictions (TP) out of the total predicted positives (TP + false positives, FP). In the results, the precision for the \"Encountered\" class is 1.00, indicating that when the model predicts \"Encountered,\" it is correct 100% of the time. For the \"Sighted\" class, the precision is 0.62, meaning that 62% of the predicted \"Sighted\" instances are true positives.\n",
    "\n",
    "- Recall: Recall, also known as sensitivity or true positive rate, measures the proportion of true positive predictions (TP) out of the total actual positives (TP + false negatives, FN). In the results, the recall for the \"Encountered\" class is 0.25, indicating that the model captures only 25% of the actual \"Encountered\" instances. On the other hand, the recall for the \"Sighted\" class is 1.00, meaning that the model correctly identifies all \"Sighted\" instances.\n",
    "\n",
    "- F1-score: The F1-score is the harmonic mean of precision and recall. It provides a balanced measure of the model's performance. In the results, the F1-score for the \"Encountered\" class is 0.40, and for the \"Sighted\" class, it is 0.77. These values indicate that the model achieves higher performance for the \"Sighted\" class compared to the \"Encountered\" class.\n",
    "\n",
    "- Support: Support represents the number of samples in each class. In the results, the \"Encountered\" class has a support of 4, and the \"Sighted\" class has a support of 5.\n",
    "\n",
    "- Accuracy: Accuracy is the overall correct predictions (TP + true negatives, TN) divided by the total number of samples. The accuracy in this case is 0.67, indicating that the model correctly predicts the status of turtles in approximately 67% of the cases.\n",
    "\n",
    "The second part of the results shows the actual and predicted values for each instance in the test set. It provides a direct comparison between the true labels and the predictions made by the model.\n",
    "\n",
    "Based on these results, we can see that the model performs well in predicting the \"Sighted\" class with high precision, recall, and F1-score. However, it struggles to correctly predict the \"Encountered\" class, resulting in lower precision, recall, and F1-score."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "b46128f2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "             precision  recall  f1-score  support\n",
      "Encountered       1.00    0.25      0.40        4\n",
      "Sighted           0.62    1.00      0.77        5\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 600x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "\n",
    "# Define the classification report results\n",
    "classification_report = {\n",
    "    'precision': [1.00, 0.62],\n",
    "    'recall': [0.25, 1.00],\n",
    "    'f1-score': [0.40, 0.77],\n",
    "    'support': [4, 5]\n",
    "}\n",
    "\n",
    "# Define the actual and predicted values\n",
    "actual_values = ['Encountered', 'Encountered', 'Encountered', 'Sighted', 'Encountered',\n",
    "                 'Sighted', 'Sighted', 'Sighted', 'Sighted']\n",
    "predicted_values = ['Sighted', 'Sighted', 'Sighted', 'Sighted', 'Encountered',\n",
    "                    'Sighted', 'Sighted', 'Sighted', 'Sighted']\n",
    "\n",
    "# Create a DataFrame from the classification report results\n",
    "results_df = pd.DataFrame(classification_report, index=['Encountered', 'Sighted'])\n",
    "\n",
    "# Print the classification report\n",
    "print(results_df)\n",
    "\n",
    "# Create a confusion matrix\n",
    "confusion_matrix = pd.crosstab(pd.Series(actual_values, name='Actual'), pd.Series(predicted_values, name='Predicted'))\n",
    "\n",
    "# Plot the confusion matrix as a heatmap\n",
    "plt.figure(figsize=(6, 4))\n",
    "sns.heatmap(confusion_matrix, annot=True, fmt='d', cmap='Blues')\n",
    "plt.xlabel('Predicted')\n",
    "plt.ylabel('Actual')\n",
    "plt.title('Confusion Matrix')\n",
    "plt.show()\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}