Adult Dataset_3_ML_algorithms.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f6715916",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.metrics import classification_report\n",
    "import tensorflow as tf\n",
    "from tensorflow import keras\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import accuracy_score, precision_score, recall_score\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Dense, Conv2D, MaxPooling2D, Flatten, AveragePooling2D\n",
    "from keras.optimizers import RMSprop, SGD"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cc41621-5b5a-4766-a5f6-d079ca3803cc",
   "metadata": {},
   "source": [
    "##### \"Adult\" dataset has 15 columns. We will make a prediction to determine whether a person makes over $50k a year. Here is the link I downloaded: https://archive.ics.uci.edu/dataset/2/adult"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "8b02b400",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Import \"adult\" dataset from the UCI website\n",
    "url = '/Users/esraydogan/Downloads/adult/adult.data'\n",
    "column_names = names=[\"age\", \"workclass\", \"fnlwgt\", \"education\", \"education-num\", \"marital-status\", \"occupation\", \"relationship\", \"race\", \"sex\", \"capital-gain\", \"capital-loss\", \"hours-per-week\", \"native-country\", \"income\"]\n",
    "data = pd.read_csv(url, names=column_names, na_values='?')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0fe05d9d-4295-4da0-9d9d-87ac8b0e1539",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_dataset(url):\n",
    "    column_names = [\"age\", \"workclass\", \"fnlwgt\", \"education\", \"education-num\", \"marital-status\", \"occupation\", \"relationship\", \"race\", \"sex\", \"capital-gain\", \"capital-loss\", \"hours-per-week\", \"native-country\", \"income\"]\n",
    "\n",
    "    return pd.read_csv(\n",
    "        url,\n",
    "        names=column_names,\n",
    "        skipinitialspace=True,  # Skip spaces after delimiter\n",
    "        na_values={\n",
    "            'workclass': '?',\n",
    "            'native-country': '?',\n",
    "            'occupation': '?',\n",
    "        }\n",
    "    )\n",
    "\n",
    "url = '/Users/esraydogan/Downloads/adult/adult.data'\n",
    "data = read_dataset(url)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "acd3f433",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "   age         workclass  fnlwgt  education  education-num  \\\n",
      "0   39         State-gov   77516  Bachelors             13   \n",
      "1   50  Self-emp-not-inc   83311  Bachelors             13   \n",
      "2   38           Private  215646    HS-grad              9   \n",
      "3   53           Private  234721       11th              7   \n",
      "4   28           Private  338409  Bachelors             13   \n",
      "\n",
      "       marital-status         occupation   relationship   race     sex  \\\n",
      "0       Never-married       Adm-clerical  Not-in-family  White    Male   \n",
      "1  Married-civ-spouse    Exec-managerial        Husband  White    Male   \n",
      "2            Divorced  Handlers-cleaners  Not-in-family  White    Male   \n",
      "3  Married-civ-spouse  Handlers-cleaners        Husband  Black    Male   \n",
      "4  Married-civ-spouse     Prof-specialty           Wife  Black  Female   \n",
      "\n",
      "   capital-gain  capital-loss  hours-per-week native-country income  \n",
      "0          2174             0              40  United-States  <=50K  \n",
      "1             0             0              13  United-States  <=50K  \n",
      "2             0             0              40  United-States  <=50K  \n",
      "3             0             0              40  United-States  <=50K  \n",
      "4             0             0              40           Cuba  <=50K  \n",
      "<class 'pandas.core.frame.DataFrame'>\n",
      "RangeIndex: 32561 entries, 0 to 32560\n",
      "Data columns (total 15 columns):\n",
      " #   Column          Non-Null Count  Dtype \n",
      "---  ------          --------------  ----- \n",
      " 0   age             32561 non-null  int64 \n",
      " 1   workclass       30725 non-null  object\n",
      " 2   fnlwgt          32561 non-null  int64 \n",
      " 3   education       32561 non-null  object\n",
      " 4   education-num   32561 non-null  int64 \n",
      " 5   marital-status  32561 non-null  object\n",
      " 6   occupation      30718 non-null  object\n",
      " 7   relationship    32561 non-null  object\n",
      " 8   race            32561 non-null  object\n",
      " 9   sex             32561 non-null  object\n",
      " 10  capital-gain    32561 non-null  int64 \n",
      " 11  capital-loss    32561 non-null  int64 \n",
      " 12  hours-per-week  32561 non-null  int64 \n",
      " 13  native-country  31978 non-null  object\n",
      " 14  income          32561 non-null  object\n",
      "dtypes: int64(6), object(9)\n",
      "memory usage: 3.7+ MB\n",
      "None\n",
      "                age        fnlwgt  education-num  capital-gain  capital-loss  \\\n",
      "count  32561.000000  3.256100e+04   32561.000000  32561.000000  32561.000000   \n",
      "mean      38.581647  1.897784e+05      10.080679   1077.648844     87.303830   \n",
      "std       13.640433  1.055500e+05       2.572720   7385.292085    402.960219   \n",
      "min       17.000000  1.228500e+04       1.000000      0.000000      0.000000   \n",
      "25%       28.000000  1.178270e+05       9.000000      0.000000      0.000000   \n",
      "50%       37.000000  1.783560e+05      10.000000      0.000000      0.000000   \n",
      "75%       48.000000  2.370510e+05      12.000000      0.000000      0.000000   \n",
      "max       90.000000  1.484705e+06      16.000000  99999.000000   4356.000000   \n",
      "\n",
      "       hours-per-week  \n",
      "count    32561.000000  \n",
      "mean        40.437456  \n",
      "std         12.347429  \n",
      "min          1.000000  \n",
      "25%         40.000000  \n",
      "50%         40.000000  \n",
      "75%         45.000000  \n",
      "max         99.000000  \n"
     ]
    }
   ],
   "source": [
    "print(data.head()) #Display first 5 rows of the dataset\n",
    "print(data.info()) #get the basic info about the dataset\n",
    "print(data.describe()) #Summary statistics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "20513bea",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Column :  age , Missing Values: 0\n",
      "Column :  workclass , Missing Values: 0\n",
      "Column :  fnlwgt , Missing Values: 0\n",
      "Column :  education , Missing Values: 0\n",
      "Column :  education-num , Missing Values: 0\n",
      "Column :  marital-status , Missing Values: 0\n",
      "Column :  occupation , Missing Values: 0\n",
      "Column :  relationship , Missing Values: 0\n",
      "Column :  race , Missing Values: 0\n",
      "Column :  sex , Missing Values: 0\n",
      "Column :  capital-gain , Missing Values: 0\n",
      "Column :  capital-loss , Missing Values: 0\n",
      "Column :  hours-per-week , Missing Values: 0\n",
      "Column :  native-country , Missing Values: 0\n",
      "Column :  income , Missing Values: 0\n"
     ]
    }
   ],
   "source": [
    "for i in data.columns:\n",
    "    print(\"Column : \", i, \", Missing Values:\", data.loc[data[i] == \"?\",i].size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "994d6b29",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Scaling numerical features using Min-Max scaling or Z-score normalization\n",
    "\n",
    "# from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "# scaler = MinMaxScaler()\n",
    "# data_pre[[\"age\", \"fnlwgt\", \"education-num\", \"capital-gain\", \"capital-loss\", \"hours-per-week\"]] = scaler.fit_transform(data[[\"age\", \"fnlwgt\", \"education-num\", \"capital-gain\", \"capital-loss\", \"hours-per-week\"]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "69a0f1ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Organize data\n",
    "\n",
    "# X = data.drop(\"income\", axis=1)\n",
    "# y = data[\"income\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "1aa22a6b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#data splitting\n",
    "\n",
    "# from sklearn.model_selection import train_test_split\n",
    "\n",
    "# X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "f00afb21",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "                age        fnlwgt  education-num  capital-gain  capital-loss  \\\n",
      "count  32561.000000  3.256100e+04   32561.000000  32561.000000  32561.000000   \n",
      "mean      38.581647  1.897784e+05      10.080679   1077.648844     87.303830   \n",
      "std       13.640433  1.055500e+05       2.572720   7385.292085    402.960219   \n",
      "min       17.000000  1.228500e+04       1.000000      0.000000      0.000000   \n",
      "25%       28.000000  1.178270e+05       9.000000      0.000000      0.000000   \n",
      "50%       37.000000  1.783560e+05      10.000000      0.000000      0.000000   \n",
      "75%       48.000000  2.370510e+05      12.000000      0.000000      0.000000   \n",
      "max       90.000000  1.484705e+06      16.000000  99999.000000   4356.000000   \n",
      "\n",
      "       hours-per-week  \n",
      "count    32561.000000  \n",
      "mean        40.437456  \n",
      "std         12.347429  \n",
      "min          1.000000  \n",
      "25%         40.000000  \n",
      "50%         40.000000  \n",
      "75%         45.000000  \n",
      "max         99.000000  \n",
      "<bound method DataFrame.info of        age         workclass  fnlwgt   education  education-num  \\\n",
      "0       39         State-gov   77516   Bachelors             13   \n",
      "1       50  Self-emp-not-inc   83311   Bachelors             13   \n",
      "2       38           Private  215646     HS-grad              9   \n",
      "3       53           Private  234721        11th              7   \n",
      "4       28           Private  338409   Bachelors             13   \n",
      "...    ...               ...     ...         ...            ...   \n",
      "32556   27           Private  257302  Assoc-acdm             12   \n",
      "32557   40           Private  154374     HS-grad              9   \n",
      "32558   58           Private  151910     HS-grad              9   \n",
      "32559   22           Private  201490     HS-grad              9   \n",
      "32560   52      Self-emp-inc  287927     HS-grad              9   \n",
      "\n",
      "           marital-status         occupation   relationship   race     sex  \\\n",
      "0           Never-married       Adm-clerical  Not-in-family  White    Male   \n",
      "1      Married-civ-spouse    Exec-managerial        Husband  White    Male   \n",
      "2                Divorced  Handlers-cleaners  Not-in-family  White    Male   \n",
      "3      Married-civ-spouse  Handlers-cleaners        Husband  Black    Male   \n",
      "4      Married-civ-spouse     Prof-specialty           Wife  Black  Female   \n",
      "...                   ...                ...            ...    ...     ...   \n",
      "32556  Married-civ-spouse       Tech-support           Wife  White  Female   \n",
      "32557  Married-civ-spouse  Machine-op-inspct        Husband  White    Male   \n",
      "32558             Widowed       Adm-clerical      Unmarried  White  Female   \n",
      "32559       Never-married       Adm-clerical      Own-child  White    Male   \n",
      "32560  Married-civ-spouse    Exec-managerial           Wife  White  Female   \n",
      "\n",
      "       capital-gain  capital-loss  hours-per-week native-country income  \n",
      "0              2174             0              40  United-States  <=50K  \n",
      "1                 0             0              13  United-States  <=50K  \n",
      "2                 0             0              40  United-States  <=50K  \n",
      "3                 0             0              40  United-States  <=50K  \n",
      "4                 0             0              40           Cuba  <=50K  \n",
      "...             ...           ...             ...            ...    ...  \n",
      "32556             0             0              38  United-States  <=50K  \n",
      "32557             0             0              40  United-States   >50K  \n",
      "32558             0             0              40  United-States  <=50K  \n",
      "32559             0             0              20  United-States  <=50K  \n",
      "32560         15024             0              40  United-States   >50K  \n",
      "\n",
      "[32561 rows x 15 columns]>\n"
     ]
    }
   ],
   "source": [
    "summary_stats = data.describe()\n",
    "print(summary_stats)\n",
    "print(data.info)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "e68f7529",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "income\n",
      "<=50K    24720\n",
      ">50K      7841\n",
      "Name: count, dtype: int64\n"
     ]
    }
   ],
   "source": [
    "class_distribution = data['income'].value_counts()\n",
    "print(class_distribution)\n",
    "# it shows us how many variables bigger or smaller than 50k income."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d7e8f950",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Index(['age', 'workclass', 'fnlwgt', 'education', 'education-num',\n",
      "       'marital-status', 'occupation', 'relationship', 'race', 'sex',\n",
      "       'capital-gain', 'capital-loss', 'hours-per-week', 'native-country',\n",
      "       'income'],\n",
      "      dtype='object')\n"
     ]
    }
   ],
   "source": [
    "print(data.columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "8c881d05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[39 50 38 53 28 37 49 52 31 42 30 23 32 40 34 25 43 54 35 59 56 19 20 45\n",
      " 22 48 21 24 57 44 41 29 18 47 46 36 79 27 67 33 76 17 55 61 70 64 71 68\n",
      " 66 51 58 26 60 90 75 65 77 62 63 80 72 74 69 73 81 78 88 82 83 84 85 86\n",
      " 87]\n",
      "['State-gov' 'Self-emp-not-inc' 'Private' 'Federal-gov' 'Local-gov' nan\n",
      " 'Self-emp-inc' 'Without-pay' 'Never-worked']\n",
      "[ 77516  83311 215646 ...  34066  84661 257302]\n",
      "['Bachelors' 'HS-grad' '11th' 'Masters' '9th' 'Some-college' 'Assoc-acdm'\n",
      " 'Assoc-voc' '7th-8th' 'Doctorate' 'Prof-school' '5th-6th' '10th'\n",
      " '1st-4th' 'Preschool' '12th']\n",
      "[13  9  7 14  5 10 12 11  4 16 15  3  6  2  1  8]\n",
      "['Never-married' 'Married-civ-spouse' 'Divorced' 'Married-spouse-absent'\n",
      " 'Separated' 'Married-AF-spouse' 'Widowed']\n",
      "['Adm-clerical' 'Exec-managerial' 'Handlers-cleaners' 'Prof-specialty'\n",
      " 'Other-service' 'Sales' 'Craft-repair' 'Transport-moving'\n",
      " 'Farming-fishing' 'Machine-op-inspct' 'Tech-support' nan\n",
      " 'Protective-serv' 'Armed-Forces' 'Priv-house-serv']\n",
      "['Not-in-family' 'Husband' 'Wife' 'Own-child' 'Unmarried' 'Other-relative']\n",
      "['White' 'Black' 'Asian-Pac-Islander' 'Amer-Indian-Eskimo' 'Other']\n",
      "['Male' 'Female']\n",
      "[ 2174     0 14084  5178  5013  2407 14344 15024  7688 34095  4064  4386\n",
      "  7298  1409  3674  1055  3464  2050  2176   594 20051  6849  4101  1111\n",
      "  8614  3411  2597 25236  4650  9386  2463  3103 10605  2964  3325  2580\n",
      "  3471  4865 99999  6514  1471  2329  2105  2885 25124 10520  2202  2961\n",
      " 27828  6767  2228  1506 13550  2635  5556  4787  3781  3137  3818  3942\n",
      "   914   401  2829  2977  4934  2062  2354  5455 15020  1424  3273 22040\n",
      "  4416  3908 10566   991  4931  1086  7430  6497   114  7896  2346  3418\n",
      "  3432  2907  1151  2414  2290 15831 41310  4508  2538  3456  6418  1848\n",
      "  3887  5721  9562  1455  2036  1831 11678  2936  2993  7443  6360  1797\n",
      "  1173  4687  6723  2009  6097  2653  1639 18481  7978  2387  5060]\n",
      "[   0 2042 1408 1902 1573 1887 1719 1762 1564 2179 1816 1980 1977 1876\n",
      " 1340 2206 1741 1485 2339 2415 1380 1721 2051 2377 1669 2352 1672  653\n",
      " 2392 1504 2001 1590 1651 1628 1848 1740 2002 1579 2258 1602  419 2547\n",
      " 2174 2205 1726 2444 1138 2238  625  213 1539  880 1668 1092 1594 3004\n",
      " 2231 1844  810 2824 2559 2057 1974  974 2149 1825 1735 1258 2129 2603\n",
      " 2282  323 4356 2246 1617 1648 2489 3770 1755 3683 2267 2080 2457  155\n",
      " 3900 2201 1944 2467 2163 2754 2472 1411]\n",
      "[40 13 16 45 50 80 30 35 60 20 52 44 15 25 38 43 55 48 58 32 70  2 22 56\n",
      " 41 28 36 24 46 42 12 65  1 10 34 75 98 33 54  8  6 64 19 18 72  5  9 47\n",
      " 37 21 26 14  4 59  7 99 53 39 62 57 78 90 66 11 49 84  3 17 68 27 85 31\n",
      " 51 77 63 23 87 88 73 89 97 94 29 96 67 82 86 91 81 76 92 61 74 95]\n",
      "['United-States' 'Cuba' 'Jamaica' 'India' nan 'Mexico' 'South'\n",
      " 'Puerto-Rico' 'Honduras' 'England' 'Canada' 'Germany' 'Iran'\n",
      " 'Philippines' 'Italy' 'Poland' 'Columbia' 'Cambodia' 'Thailand' 'Ecuador'\n",
      " 'Laos' 'Taiwan' 'Haiti' 'Portugal' 'Dominican-Republic' 'El-Salvador'\n",
      " 'France' 'Guatemala' 'China' 'Japan' 'Yugoslavia' 'Peru'\n",
      " 'Outlying-US(Guam-USVI-etc)' 'Scotland' 'Trinadad&Tobago' 'Greece'\n",
      " 'Nicaragua' 'Vietnam' 'Hong' 'Ireland' 'Hungary' 'Holand-Netherlands']\n",
      "['<=50K' '>50K']\n"
     ]
    }
   ],
   "source": [
    "for col in data:\n",
    "  print(data[col].unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "4e993eac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "       age  workclass  fnlwgt  education  education-num  marital-status  \\\n",
      "0       39          0   77516          0             13               0   \n",
      "1       50          1   83311          0             13               1   \n",
      "2       38          2  215646          1              9               2   \n",
      "3       53          2  234721          2              7               1   \n",
      "4       28          2  338409          0             13               1   \n",
      "...    ...        ...     ...        ...            ...             ...   \n",
      "32556   27          2  257302          6             12               1   \n",
      "32557   40          2  154374          1              9               1   \n",
      "32558   58          2  151910          1              9               6   \n",
      "32559   22          2  201490          1              9               0   \n",
      "32560   52          5  287927          1              9               1   \n",
      "\n",
      "       occupation  relationship  race  sex  capital-gain  capital-loss  \\\n",
      "0               0             0     0    0          2174             0   \n",
      "1               1             1     0    0             0             0   \n",
      "2               2             0     0    0             0             0   \n",
      "3               2             1     1    0             0             0   \n",
      "4               3             2     1    1             0             0   \n",
      "...           ...           ...   ...  ...           ...           ...   \n",
      "32556          10             2     0    1             0             0   \n",
      "32557           9             1     0    0             0             0   \n",
      "32558           0             4     0    1             0             0   \n",
      "32559           0             3     0    0             0             0   \n",
      "32560           1             2     0    1         15024             0   \n",
      "\n",
      "       hours-per-week  native-country  income  \n",
      "0                  40               0       0  \n",
      "1                  13               0       0  \n",
      "2                  40               0       0  \n",
      "3                  40               0       0  \n",
      "4                  40               1       0  \n",
      "...               ...             ...     ...  \n",
      "32556              38               0       0  \n",
      "32557              40               0       1  \n",
      "32558              40               0       0  \n",
      "32559              20               0       0  \n",
      "32560              40               0       1  \n",
      "\n",
      "[32561 rows x 15 columns]\n"
     ]
    }
   ],
   "source": [
    "# Identify categorical columns\n",
    "categorical_columns = data.select_dtypes(include=['object']).columns\n",
    "\n",
    "# Apply label encoding to categorical columns\n",
    "for column in categorical_columns:\n",
    "    data[column] = pd.factorize(data[column])[0]\n",
    "\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "f3bd9a2e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[39 50 38 53 28 37 49 52 31 42 30 23 32 40 34 25 43 54 35 59 56 19 20 45\n",
      " 22 48 21 24 57 44 41 29 18 47 46 36 79 27 67 33 76 17 55 61 70 64 71 68\n",
      " 66 51 58 26 60 90 75 65 77 62 63 80 72 74 69 73 81 78 88 82 83 84 85 86\n",
      " 87]\n",
      "[ 0  1  2  3  4 -1  5  6  7]\n",
      "[ 77516  83311 215646 ...  34066  84661 257302]\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15]\n",
      "[13  9  7 14  5 10 12 11  4 16 15  3  6  2  1  8]\n",
      "[0 1 2 3 4 5 6]\n",
      "[ 0  1  2  3  4  5  6  7  8  9 10 -1 11 12 13]\n",
      "[0 1 2 3 4 5]\n",
      "[0 1 2 3 4]\n",
      "[0 1]\n",
      "[ 2174     0 14084  5178  5013  2407 14344 15024  7688 34095  4064  4386\n",
      "  7298  1409  3674  1055  3464  2050  2176   594 20051  6849  4101  1111\n",
      "  8614  3411  2597 25236  4650  9386  2463  3103 10605  2964  3325  2580\n",
      "  3471  4865 99999  6514  1471  2329  2105  2885 25124 10520  2202  2961\n",
      " 27828  6767  2228  1506 13550  2635  5556  4787  3781  3137  3818  3942\n",
      "   914   401  2829  2977  4934  2062  2354  5455 15020  1424  3273 22040\n",
      "  4416  3908 10566   991  4931  1086  7430  6497   114  7896  2346  3418\n",
      "  3432  2907  1151  2414  2290 15831 41310  4508  2538  3456  6418  1848\n",
      "  3887  5721  9562  1455  2036  1831 11678  2936  2993  7443  6360  1797\n",
      "  1173  4687  6723  2009  6097  2653  1639 18481  7978  2387  5060]\n",
      "[   0 2042 1408 1902 1573 1887 1719 1762 1564 2179 1816 1980 1977 1876\n",
      " 1340 2206 1741 1485 2339 2415 1380 1721 2051 2377 1669 2352 1672  653\n",
      " 2392 1504 2001 1590 1651 1628 1848 1740 2002 1579 2258 1602  419 2547\n",
      " 2174 2205 1726 2444 1138 2238  625  213 1539  880 1668 1092 1594 3004\n",
      " 2231 1844  810 2824 2559 2057 1974  974 2149 1825 1735 1258 2129 2603\n",
      " 2282  323 4356 2246 1617 1648 2489 3770 1755 3683 2267 2080 2457  155\n",
      " 3900 2201 1944 2467 2163 2754 2472 1411]\n",
      "[40 13 16 45 50 80 30 35 60 20 52 44 15 25 38 43 55 48 58 32 70  2 22 56\n",
      " 41 28 36 24 46 42 12 65  1 10 34 75 98 33 54  8  6 64 19 18 72  5  9 47\n",
      " 37 21 26 14  4 59  7 99 53 39 62 57 78 90 66 11 49 84  3 17 68 27 85 31\n",
      " 51 77 63 23 87 88 73 89 97 94 29 96 67 82 86 91 81 76 92 61 74 95]\n",
      "[ 0  1  2  3 -1  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22\n",
      " 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40]\n",
      "[0 1]\n"
     ]
    }
   ],
   "source": [
    "for col in data:\n",
    "  print(data[col].unique())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "33f62a37",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "\n",
    "\n",
    "# Example: Box plot of income vs. age\n",
    "plt.figure(figsize=(8, 6))\n",
    "sns.boxplot(data=data, x='income', y='age')\n",
    "plt.title('Income vs. Age')\n",
    "plt.xlabel('Income')\n",
    "plt.ylabel('Age')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cae22a68",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/var/folders/6c/5rvrj7z16fnfwp96d6vlng4c0000gn/T/ipykernel_94206/3789358721.py:4: UserWarning: \n",
      "\n",
      "`distplot` is a deprecated function and will be removed in seaborn v0.14.0.\n",
      "\n",
      "Please adapt your code to use either `displot` (a figure-level function with\n",
      "similar flexibility) or `histplot` (an axes-level function for histograms).\n",
      "\n",
      "For a guide to updating your code to use the new functions, please see\n",
      "https://gist.github.com/mwaskom/de44147ed2974457ad6372750bbe5751\n",
      "\n",
      "  sns.distplot(data['hours-per-week'], hist=True, kde=True,\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
      "  with pd.option_context('mode.use_inf_as_na', True):\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Histogram and density\n",
    "\n",
    "\n",
    "sns.distplot(data['hours-per-week'], hist=True, kde=True, \n",
    "             bins=int(180/5), color = 'darkblue', \n",
    "             hist_kws={'edgecolor':'black'},\n",
    "             kde_kws={'linewidth': 4});"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1913c9df",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Compute the correlation matrix\n",
    "correlation_matrix = data.corr()\n",
    "\n",
    "# Plot a heatmap of the correlation matrix\n",
    "plt.figure(figsize=(10, 8))\n",
    "sns.heatmap(correlation_matrix, annot=True, cmap='RdBu', fmt=\".2f\")\n",
    "plt.title('Correlation Heatmap')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2df11f9d",
   "metadata": {},
   "source": [
    "#### In this dataset, target variable is \"income\" column. It is binary and it indicates that if income is above or below 50k. Therefore, my ML task in this dataset is classification."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8abaa65e",
   "metadata": {},
   "source": [
    "#### I will initially include all variables as feature variables, but my primary focus will be on identifying and utilizing those with the highest correlations, as indicated by the heatmap."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aa55f31-84a2-41f2-b235-289eb57c1150",
   "metadata": {},
   "source": [
    "##### Applications of three machine learning algorithms : XGBoost, Deep Neural Network and Random Forest"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a1be611",
   "metadata": {},
   "source": [
    "## XGBoost Algorithm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "2caad3ca",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting xgboost\n",
      "  Downloading xgboost-1.7.6-py3-none-macosx_10_15_x86_64.macosx_11_0_x86_64.macosx_12_0_x86_64.whl (1.8 MB)\n",
      "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m1.8/1.8 MB\u001b[0m \u001b[31m1.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m00:01\u001b[0m00:01\u001b[0m0m\n",
      "\u001b[?25hRequirement already satisfied: numpy in ./opt/anaconda3/lib/python3.9/site-packages (from xgboost) (1.21.5)\n",
      "Requirement already satisfied: scipy in ./opt/anaconda3/lib/python3.9/site-packages (from xgboost) (1.9.1)\n",
      "Installing collected packages: xgboost\n",
      "Successfully installed xgboost-1.7.6\n"
     ]
    }
   ],
   "source": [
    "# !pip install xgboost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "bcd5d94b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "XGBoost accuracy: 0.8685665151701265\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n"
     ]
    }
   ],
   "source": [
    "import xgboost as xgb\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.metrics import accuracy_score, classification_report\n",
    "\n",
    "\n",
    "\n",
    "# Split the data into train and test sets\n",
    "X_train, X_test, y_train, y_test = train_test_split(data.drop(\"income\", axis=1), data[\"income\"], test_size=0.25)\n",
    "\n",
    "# Create an XGBoost classifier\n",
    "clf = xgb.XGBClassifier()\n",
    "\n",
    "# Train the classifier\n",
    "clf.fit(X_train, y_train)\n",
    "\n",
    "# Make predictions on the test set\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"XGBoost accuracy:\", accuracy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "bae8b6ba",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:440: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(data):\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R2 of the best regressor after CV is 0.28\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.90      0.94      0.92      6212\n",
      "           1       0.77      0.65      0.70      1929\n",
      "\n",
      "    accuracy                           0.87      8141\n",
      "   macro avg       0.83      0.79      0.81      8141\n",
      "weighted avg       0.87      0.87      0.87      8141\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:312: FutureWarning: is_sparse is deprecated and will be removed in a future version. Check `isinstance(dtype, pd.SparseDtype)` instead.\n",
      "  if is_sparse(dtype):\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:314: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  elif is_categorical_dtype(dtype) and enable_categorical:\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:345: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if is_categorical_dtype(dtype)\n",
      "/Users/esraydogan/miniforge3/envs/tfn/lib/python3.9/site-packages/xgboost/data.py:336: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  return is_int or is_bool or is_float or is_categorical_dtype(dtype)\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "# Define the XGBoost Classifier\n",
    "xgb_classifier = xgb.XGBClassifier(random_state=42)\n",
    "\n",
    "# Define hyperparameters to search through\n",
    "param_grid = {\n",
    "    'n_estimators': [100, 200, 300],\n",
    "    'max_depth': [3, 4, 5],\n",
    "    'learning_rate': [0.1, 0.01, 0.001]\n",
    "}\n",
    "\n",
    "# Perform hyperparameter tuning using GridSearchCV\n",
    "grid_search = GridSearchCV(xgb_classifier, param_grid, cv=5, scoring='accuracy', n_jobs=-1)\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# Get the best hyperparameters\n",
    "best_params = grid_search.best_params_\n",
    "\n",
    "# Train the model with the best hyperparameters\n",
    "best_xgb_classifier = xgb.XGBClassifier(random_state=42, **best_params)\n",
    "best_xgb_classifier.fit(X_train, y_train)\n",
    "\n",
    "# Evaluate the model on the test data\n",
    "y_pred = best_xgb_classifier.predict(X_test)\n",
    "r2score = r2_score(y_test,y_pred)\n",
    "print('R2 of the best regressor after CV is %.2f' % (r2score))\n",
    "\n",
    "# Print classification report\n",
    "print(classification_report(y_test, y_pred))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "687bc917-aaec-4dbf-b211-f9935dd00600",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(24420, 14)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0c1a0c1f-132b-4059-814d-293181ac45c8",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>age</th>\n",
       "      <th>workclass</th>\n",
       "      <th>fnlwgt</th>\n",
       "      <th>education</th>\n",
       "      <th>education-num</th>\n",
       "      <th>marital-status</th>\n",
       "      <th>occupation</th>\n",
       "      <th>relationship</th>\n",
       "      <th>race</th>\n",
       "      <th>sex</th>\n",
       "      <th>capital-gain</th>\n",
       "      <th>capital-loss</th>\n",
       "      <th>hours-per-week</th>\n",
       "      <th>native-country</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1023</th>\n",
       "      <td>34</td>\n",
       "      <td>2</td>\n",
       "      <td>33117</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>304</th>\n",
       "      <td>24</td>\n",
       "      <td>2</td>\n",
       "      <td>303296</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2657</th>\n",
       "      <td>31</td>\n",
       "      <td>2</td>\n",
       "      <td>163516</td>\n",
       "      <td>5</td>\n",
       "      <td>10</td>\n",
       "      <td>6</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11443</th>\n",
       "      <td>32</td>\n",
       "      <td>2</td>\n",
       "      <td>34437</td>\n",
       "      <td>1</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>7</td>\n",
       "      <td>3</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>26616</th>\n",
       "      <td>44</td>\n",
       "      <td>2</td>\n",
       "      <td>261497</td>\n",
       "      <td>1</td>\n",
       "      <td>9</td>\n",
       "      <td>1</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>-1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23414</th>\n",
       "      <td>36</td>\n",
       "      <td>2</td>\n",
       "      <td>334366</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>32</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20525</th>\n",
       "      <td>38</td>\n",
       "      <td>3</td>\n",
       "      <td>47707</td>\n",
       "      <td>1</td>\n",
       "      <td>9</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>20161</th>\n",
       "      <td>20</td>\n",
       "      <td>-1</td>\n",
       "      <td>304076</td>\n",
       "      <td>2</td>\n",
       "      <td>7</td>\n",
       "      <td>0</td>\n",
       "      <td>-1</td>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>20</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>23622</th>\n",
       "      <td>40</td>\n",
       "      <td>2</td>\n",
       "      <td>200496</td>\n",
       "      <td>0</td>\n",
       "      <td>13</td>\n",
       "      <td>4</td>\n",
       "      <td>5</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>40</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13762</th>\n",
       "      <td>58</td>\n",
       "      <td>2</td>\n",
       "      <td>123436</td>\n",
       "      <td>0</td>\n",
       "      <td>13</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "      <td>0</td>\n",
       "      <td>0</td>\n",
       "      <td>7688</td>\n",
       "      <td>0</td>\n",
       "      <td>50</td>\n",
       "      <td>0</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>24420 rows × 14 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "       age  workclass  fnlwgt  education  education-num  marital-status  \\\n",
       "1023    34          2   33117          5             10               1   \n",
       "304     24          2  303296          5             10               1   \n",
       "2657    31          2  163516          5             10               6   \n",
       "11443   32          2   34437          1              9               0   \n",
       "26616   44          2  261497          1              9               1   \n",
       "...    ...        ...     ...        ...            ...             ...   \n",
       "23414   36          2  334366          2              7               4   \n",
       "20525   38          3   47707          1              9               0   \n",
       "20161   20         -1  304076          2              7               0   \n",
       "23622   40          2  200496          0             13               4   \n",
       "13762   58          2  123436          0             13               1   \n",
       "\n",
       "       occupation  relationship  race  sex  capital-gain  capital-loss  \\\n",
       "1023            4             1     0    0             0             0   \n",
       "304             0             2     2    1             0             0   \n",
       "2657            0             4     0    1             0             0   \n",
       "11443           7             3     0    0             0             0   \n",
       "26616           2             1     1    0             0             0   \n",
       "...           ...           ...   ...  ...           ...           ...   \n",
       "23414           1             0     0    1             0             0   \n",
       "20525           0             3     1    1             0             0   \n",
       "20161          -1             3     1    1             0             0   \n",
       "23622           5             0     0    0             0             0   \n",
       "13762           1             1     0    0          7688             0   \n",
       "\n",
       "       hours-per-week  native-country  \n",
       "1023               40               0  \n",
       "304                40              19  \n",
       "2657               40               0  \n",
       "11443              40               0  \n",
       "26616              40              -1  \n",
       "...               ...             ...  \n",
       "23414              32               0  \n",
       "20525              40               0  \n",
       "20161              20               0  \n",
       "23622              40               0  \n",
       "13762              50               0  \n",
       "\n",
       "[24420 rows x 14 columns]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_train[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "187d6d83-314a-4348-a902-90bfd0d36b9d",
   "metadata": {},
   "source": [
    "### Deep Neural Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "cb49a6a0-c10b-4b63-a0b1-c83686a9012c",
   "metadata": {},
   "outputs": [],
   "source": [
    "def df_to_dataset(data, shuffle=True, batch_size=32):\n",
    "  dataframe = data.copy()\n",
    "  labels = data.pop('income')\n",
    "  ds = tf.data.Dataset.from_tensor_slices((dict(data), labels))\n",
    "  if shuffle:\n",
    "    ds = ds.shuffle(buffer_size=len(data))\n",
    "  ds = ds.batch(batch_size)\n",
    "  return ds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "bdfc403d-3566-4b55-be03-4a0eb34c9a3f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20757 train examples\n",
      "3663 validation examples\n",
      "8141 test examples\n"
     ]
    }
   ],
   "source": [
    "train, test = train_test_split(data, test_size=0.25)\n",
    "train, val = train_test_split(train, test_size=0.15)\n",
    "print(len(train), 'train examples')\n",
    "print(len(val), 'validation examples')\n",
    "print(len(test), 'test examples')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "18380753-2ffc-40b7-bb83-9484834a639a",
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 32\n",
    "train_ds = df_to_dataset(train, batch_size=batch_size)\n",
    "val_ds = df_to_dataset(val, shuffle=False, batch_size=batch_size)\n",
    "test_ds = df_to_dataset(test, shuffle=False, batch_size=batch_size)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "dbda30c7-378d-4ad4-b460-586c5d5f6da2",
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow import feature_column\n",
    "\n",
    "feature_columns = []\n",
    "\n",
    "# Define feature columns for numeric features\n",
    "numeric_features = ['age', 'fnlwgt', 'education-num', 'capital-gain', 'capital-loss', 'hours-per-week']\n",
    "for feature_name in numeric_features:\n",
    "    feature_columns.append(tf.feature_column.numeric_column(feature_name, dtype=tf.float32))\n",
    "\n",
    "# Define feature columns for categorical features\n",
    "categorical_features = ['workclass', 'education', 'marital-status', 'occupation', 'relationship', 'race', 'sex', 'native-country']\n",
    "for feature_name in categorical_features:\n",
    "    categorical_column = tf.feature_column.categorical_column_with_vocabulary_list(\n",
    "        feature_name, data[feature_name].unique())\n",
    "    indicator_column = tf.feature_column.indicator_column(categorical_column)\n",
    "    feature_columns.append(indicator_column)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "0d873178-a32d-4ab8-8d91-10bccd8be7c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "feature_layer = tf.keras.layers.DenseFeatures(feature_columns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "b9ff98d7-c65f-4fd0-9ac1-956c20f5dd0e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n",
      "WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'age': <tf.Tensor 'IteratorGetNext:0' shape=(None,) dtype=int64>, 'workclass': <tf.Tensor 'IteratorGetNext:13' shape=(None,) dtype=int64>, 'fnlwgt': <tf.Tensor 'IteratorGetNext:5' shape=(None,) dtype=int64>, 'education': <tf.Tensor 'IteratorGetNext:3' shape=(None,) dtype=int64>, 'education-num': <tf.Tensor 'IteratorGetNext:4' shape=(None,) dtype=int64>, 'marital-status': <tf.Tensor 'IteratorGetNext:7' shape=(None,) dtype=int64>, 'occupation': <tf.Tensor 'IteratorGetNext:9' shape=(None,) dtype=int64>, 'relationship': <tf.Tensor 'IteratorGetNext:11' shape=(None,) dtype=int64>, 'race': <tf.Tensor 'IteratorGetNext:10' shape=(None,) dtype=int64>, 'sex': <tf.Tensor 'IteratorGetNext:12' shape=(None,) dtype=int64>, 'capital-gain': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>, 'capital-loss': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=int64>, 'hours-per-week': <tf.Tensor 'IteratorGetNext:6' shape=(None,) dtype=int64>, 'native-country': <tf.Tensor 'IteratorGetNext:8' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.\n",
      "WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'age': <tf.Tensor 'IteratorGetNext:0' shape=(None,) dtype=int64>, 'workclass': <tf.Tensor 'IteratorGetNext:13' shape=(None,) dtype=int64>, 'fnlwgt': <tf.Tensor 'IteratorGetNext:5' shape=(None,) dtype=int64>, 'education': <tf.Tensor 'IteratorGetNext:3' shape=(None,) dtype=int64>, 'education-num': <tf.Tensor 'IteratorGetNext:4' shape=(None,) dtype=int64>, 'marital-status': <tf.Tensor 'IteratorGetNext:7' shape=(None,) dtype=int64>, 'occupation': <tf.Tensor 'IteratorGetNext:9' shape=(None,) dtype=int64>, 'relationship': <tf.Tensor 'IteratorGetNext:11' shape=(None,) dtype=int64>, 'race': <tf.Tensor 'IteratorGetNext:10' shape=(None,) dtype=int64>, 'sex': <tf.Tensor 'IteratorGetNext:12' shape=(None,) dtype=int64>, 'capital-gain': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>, 'capital-loss': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=int64>, 'hours-per-week': <tf.Tensor 'IteratorGetNext:6' shape=(None,) dtype=int64>, 'native-country': <tf.Tensor 'IteratorGetNext:8' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-09-14 23:34:52.592066: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "649/649 [==============================] - ETA: 0s - loss: 253.2332 - accuracy: 0.6796WARNING:tensorflow:Layers in a Sequential model should only have a single input tensor. Received: inputs={'age': <tf.Tensor 'IteratorGetNext:0' shape=(None,) dtype=int64>, 'workclass': <tf.Tensor 'IteratorGetNext:13' shape=(None,) dtype=int64>, 'fnlwgt': <tf.Tensor 'IteratorGetNext:5' shape=(None,) dtype=int64>, 'education': <tf.Tensor 'IteratorGetNext:3' shape=(None,) dtype=int64>, 'education-num': <tf.Tensor 'IteratorGetNext:4' shape=(None,) dtype=int64>, 'marital-status': <tf.Tensor 'IteratorGetNext:7' shape=(None,) dtype=int64>, 'occupation': <tf.Tensor 'IteratorGetNext:9' shape=(None,) dtype=int64>, 'relationship': <tf.Tensor 'IteratorGetNext:11' shape=(None,) dtype=int64>, 'race': <tf.Tensor 'IteratorGetNext:10' shape=(None,) dtype=int64>, 'sex': <tf.Tensor 'IteratorGetNext:12' shape=(None,) dtype=int64>, 'capital-gain': <tf.Tensor 'IteratorGetNext:1' shape=(None,) dtype=int64>, 'capital-loss': <tf.Tensor 'IteratorGetNext:2' shape=(None,) dtype=int64>, 'hours-per-week': <tf.Tensor 'IteratorGetNext:6' shape=(None,) dtype=int64>, 'native-country': <tf.Tensor 'IteratorGetNext:8' shape=(None,) dtype=int64>}. Consider rewriting this model with the Functional API.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-09-14 23:35:09.750586: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "649/649 [==============================] - 20s 31ms/step - loss: 253.2332 - accuracy: 0.6796 - val_loss: 62.8760 - val_accuracy: 0.7942\n",
      "Epoch 2/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 168.2677 - accuracy: 0.6839 - val_loss: 152.0026 - val_accuracy: 0.7887\n",
      "Epoch 3/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 95.1354 - accuracy: 0.6864 - val_loss: 78.0364 - val_accuracy: 0.2473\n",
      "Epoch 4/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 77.6875 - accuracy: 0.6883 - val_loss: 71.4449 - val_accuracy: 0.7876\n",
      "Epoch 5/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 60.3015 - accuracy: 0.6866 - val_loss: 7.8078 - val_accuracy: 0.7603\n",
      "Epoch 6/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 49.8762 - accuracy: 0.6873 - val_loss: 24.2810 - val_accuracy: 0.7958\n",
      "Epoch 7/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 33.2750 - accuracy: 0.6901 - val_loss: 36.7765 - val_accuracy: 0.7819\n",
      "Epoch 8/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 27.0944 - accuracy: 0.6874 - val_loss: 18.3386 - val_accuracy: 0.2473\n",
      "Epoch 9/25\n",
      "649/649 [==============================] - 21s 33ms/step - loss: 24.4932 - accuracy: 0.6907 - val_loss: 4.6036 - val_accuracy: 0.7723\n",
      "Epoch 10/25\n",
      "649/649 [==============================] - 21s 33ms/step - loss: 15.6634 - accuracy: 0.6917 - val_loss: 11.4830 - val_accuracy: 0.7696\n",
      "Epoch 11/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 12.5565 - accuracy: 0.6982 - val_loss: 6.3728 - val_accuracy: 0.7993\n",
      "Epoch 12/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 9.0750 - accuracy: 0.7038 - val_loss: 1.4351 - val_accuracy: 0.7868\n",
      "Epoch 13/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 6.3280 - accuracy: 0.7065 - val_loss: 1.0253 - val_accuracy: 0.7895\n",
      "Epoch 14/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 3.7237 - accuracy: 0.7150 - val_loss: 2.9023 - val_accuracy: 0.7958\n",
      "Epoch 15/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 2.7037 - accuracy: 0.7239 - val_loss: 0.7523 - val_accuracy: 0.7289\n",
      "Epoch 16/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 1.6853 - accuracy: 0.7362 - val_loss: 0.9234 - val_accuracy: 0.8103\n",
      "Epoch 17/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 0.9592 - accuracy: 0.7581 - val_loss: 0.4870 - val_accuracy: 0.8021\n",
      "Epoch 18/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 0.6286 - accuracy: 0.7798 - val_loss: 0.4334 - val_accuracy: 0.8100\n",
      "Epoch 19/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 0.5711 - accuracy: 0.7868 - val_loss: 0.4782 - val_accuracy: 0.7835\n",
      "Epoch 20/25\n",
      "649/649 [==============================] - 21s 33ms/step - loss: 0.5606 - accuracy: 0.7888 - val_loss: 0.5041 - val_accuracy: 0.7936\n",
      "Epoch 21/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 0.4940 - accuracy: 0.7989 - val_loss: 0.4890 - val_accuracy: 0.7955\n",
      "Epoch 22/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 0.4979 - accuracy: 0.7973 - val_loss: 0.4806 - val_accuracy: 0.8034\n",
      "Epoch 23/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 0.4967 - accuracy: 0.7977 - val_loss: 0.4903 - val_accuracy: 0.7928\n",
      "Epoch 24/25\n",
      "649/649 [==============================] - 21s 32ms/step - loss: 0.4993 - accuracy: 0.7959 - val_loss: 0.4837 - val_accuracy: 0.8018\n",
      "Epoch 25/25\n",
      "649/649 [==============================] - 20s 31ms/step - loss: 0.5057 - accuracy: 0.7948 - val_loss: 0.4895 - val_accuracy: 0.8032\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<keras.callbacks.History at 0x308769670>"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from tensorflow.keras import layers\n",
    "model = tf.keras.Sequential([\n",
    "  feature_layer,\n",
    "  layers.Dense(128, activation='relu'),\n",
    "  layers.Dropout(0.2),\n",
    "  layers.Dense(128, activation='relu'),\n",
    "  layers.Dense(1)\n",
    "])\n",
    "\n",
    "model.compile(optimizer='adam',\n",
    "              loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),\n",
    "              metrics=['accuracy'])\n",
    "\n",
    "model.fit(train_ds,\n",
    "          validation_data=val_ds,\n",
    "          epochs=25)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93cee270-e1d3-4f68-b70e-b9999c570596",
   "metadata": {},
   "source": [
    "## Random Forest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "e0f2f7b1-872d-4417-b1b8-7ac646ce4150",
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "8fed5427-5130-4917-a017-200687b96ff3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>RandomForestClassifier(random_state=42)</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">RandomForestClassifier</label><div class=\"sk-toggleable__content\"><pre>RandomForestClassifier(random_state=42)</pre></div></div></div></div></div>"
      ],
      "text/plain": [
       "RandomForestClassifier(random_state=42)"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create the classifier\n",
    "clf = RandomForestClassifier(n_estimators=100, random_state=42)\n",
    "\n",
    "# Train the classifier\n",
    "clf.fit(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b43de175-9c6e-4875-9ca4-6d3087089ded",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy: 0.8577570323056135\n",
      "Confusion Matrix:\n",
      " [[5758  454]\n",
      " [ 704 1225]]\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       0.89      0.93      0.91      6212\n",
      "           1       0.73      0.64      0.68      1929\n",
      "\n",
      "    accuracy                           0.86      8141\n",
      "   macro avg       0.81      0.78      0.79      8141\n",
      "weighted avg       0.85      0.86      0.85      8141\n",
      "\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, classification_report, confusion_matrix\n",
    "\n",
    "# Make predictions\n",
    "y_pred = clf.predict(X_test)\n",
    "\n",
    "# Evaluate the model\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "confusion = confusion_matrix(y_test, y_pred)\n",
    "classification_report_str = classification_report(y_test, y_pred)\n",
    "\n",
    "print(\"Accuracy:\", accuracy)\n",
    "print(\"Confusion Matrix:\\n\", confusion)\n",
    "print(\"Classification Report:\\n\", classification_report_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "0b425e39-44d3-4ab1-a743-84d4089d3a0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Best Hyperparameters: {'n_estimators': 200}\n",
      "Test Accuracy with Best Hyperparameters: 0.8616612927990174\n"
     ]
    }
   ],
   "source": [
    "# Split the data into a training set and a testing set\n",
    "X = data.drop('income', axis=1)  # Features\n",
    "y = data['income']  # Target variable\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n",
    "\n",
    "# Define hyperparameters to tune (e.g., number of trees, max depth, etc.)\n",
    "# For example, let's vary the number of trees (n_estimators) in the random forest.\n",
    "param_grid = {'n_estimators': [100, 200, 300, 400]}\n",
    "\n",
    "# Create the random forest classifier\n",
    "clf = RandomForestClassifier(random_state=42)\n",
    "\n",
    "# Perform cross-validation to find the best hyperparameters\n",
    "# You can use GridSearchCV or RandomizedSearchCV for hyperparameter search\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "grid_search = GridSearchCV(estimator=clf, param_grid=param_grid, cv=5, scoring='accuracy')\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# Print the best hyperparameters\n",
    "best_params = grid_search.best_params_\n",
    "print(\"Best Hyperparameters:\", best_params)\n",
    "\n",
    "# Fit the model with the best hyperparameters to the entire training set\n",
    "best_clf = RandomForestClassifier(n_estimators=best_params['n_estimators'], random_state=42)\n",
    "best_clf.fit(X_train, y_train)\n",
    "\n",
    "# Evaluate the model on the test set\n",
    "y_pred = best_clf.predict(X_test)\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(\"Test Accuracy with Best Hyperparameters:\", accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db66137b-88b7-4a83-8e5d-5a068b2a2377",
   "metadata": {},
   "source": [
    "#### In all three algortihms, the best one is Random Forest with tuning, XGBoost with tuning and without tuning. The result is almost similar each other like rougly 0.86. The Deep Neural Network is worse one. Because my dataset, adult dataset, is tabular data. It does not have homogeneous and generic data format like images dataset. Moreover, it tends to overfitting. We can explain this like that because deep learning models have a high number of parameters to be learned, it requires huge datasets to avoid overfitting. Thus, it would not be a good option for small tabular datasets when it is difficult to acquire more data. To sum up, machine learning algorithms such as ensemble methods are better than deep learning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3302e65-10a8-41e6-8ee6-34ad1da1e1c8",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}