{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Yapay Zeka Uygulamaları — 6. Hafta\n",
    "## Karar Ağaçları ve Topluluk Yöntemleri · Titanic\n",
    "\n",
    "Bu notebook, 6. hafta ders notunun 12. ve 13. bölümlerinin tamamını içerir.\n",
    "\n",
    "**Başlamadan:**\n",
    "1. `kaggle.com/c/titanic` → **Join Competition**\n",
    "2. **Code → New Notebook** (yarışma sayfasından basarsanız veri otomatik eklenir)\n",
    "3. Hızlandırıcı gerekmiyor; bütün notebook CPU'da 1 dakikadan az sürer.\n",
    "\n",
    "Soldaki hücreleri sırayla çalıştırın. Sondaki hücre `submission.csv` üretir.\n",
    "\n",
    "> Ders notundaki çıktı değerleri örnektir; sizdeki son ondalıklar kütüphane sürümüne göre\n",
    "> küçük farklar gösterebilir. Bakılacak şey tek bir sayı değil, **sıralama ve eğilim**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 · Veriyi oku ve taban çizgisini yaz\n",
    "\n",
    "5. haftanın kuralı: **taban çizgisi olmadan sayı yoktur.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "\n",
    "train = pd.read_csv(\"/kaggle/input/titanic/train.csv\")\n",
    "test  = pd.read_csv(\"/kaggle/input/titanic/test.csv\")\n",
    "\n",
    "print(\"Egitim:\", train.shape, \" Test:\", test.shape)\n",
    "print(\"Hayatta kalma orani:\", round(train[\"Survived\"].mean(), 4))\n",
    "print(\"TABAN CIZGISI (hep 'olmedi' de):\", round((train[\"Survived\"] == 0).mean(), 4))\n",
    "print(\"\\nEksik veri:\")\n",
    "print(train.isna().sum()[lambda s: s > 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 · Ağacın anlayacağı hâle getir — ama ölçekleme yok\n",
    "\n",
    "Ağaç sayı ister, o kadar. Normalizasyon/standartlaştırma ağaç için **boşa emektir**:\n",
    "`maas <= 18000` sorusu, maaş 0–1 arasına sıkıştırılsa da aynı sıralamayı verir.\n",
    "\n",
    "Doldurma değerleri **yalnızca eğitim verisinden** hesaplanır — testin medyanını kullanmak\n",
    "2. haftanın *veri sızıntısı* hatasıdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "YAS_ORTA   = train[\"Age\"].median()\n",
    "UCRET_ORTA = train[\"Fare\"].median()\n",
    "\n",
    "SUTUNLAR = [\"Pclass\", \"Kadin\", \"Age\", \"Fare\", \"SibSp\", \"Parch\",\n",
    "            \"Aile\", \"Yalniz\", \"Lman_C\", \"Lman_Q\", \"Lman_S\"]\n",
    "\n",
    "def hazirla(df):\n",
    "    d = df.copy()\n",
    "    d[\"Kadin\"]  = (d[\"Sex\"] == \"female\").astype(int)      # metin -> 0/1\n",
    "    d[\"Age\"]    = d[\"Age\"].fillna(YAS_ORTA)\n",
    "    d[\"Fare\"]   = d[\"Fare\"].fillna(UCRET_ORTA)\n",
    "    d[\"Aile\"]   = d[\"SibSp\"] + d[\"Parch\"] + 1             # kendisi dahil aile buyuklugu\n",
    "    d[\"Yalniz\"] = (d[\"Aile\"] == 1).astype(int)\n",
    "    liman = pd.get_dummies(d[\"Embarked\"].fillna(\"S\"), prefix=\"Lman\", dtype=int)\n",
    "    d = pd.concat([d, liman], axis=1)\n",
    "    # reindex: testte olmayan bir liman sutunu 0 ile doldurulur, fazlasi atilir\n",
    "    return d.reindex(columns=SUTUNLAR, fill_value=0)\n",
    "\n",
    "X      = hazirla(train)\n",
    "y      = train[\"Survived\"]\n",
    "X_test = hazirla(test)\n",
    "\n",
    "print(X.shape, X_test.shape)\n",
    "X.head(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 · İlk ağacı kur ve **oku**\n",
    "\n",
    "Bu haftanın ayırt edici anı: modeli yazdırıp sesli okumak. Hiçbir başka modelde bunu\n",
    "yapamazsınız."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.tree import DecisionTreeClassifier, export_text\n",
    "\n",
    "X_eg, X_dog, y_eg, y_dog = train_test_split(\n",
    "    X, y, test_size=0.25, stratify=y, random_state=42)\n",
    "\n",
    "agac = DecisionTreeClassifier(max_depth=3, min_samples_leaf=10, random_state=42)\n",
    "agac.fit(X_eg, y_eg)\n",
    "\n",
    "print(\"Egitim    :\", round(agac.score(X_eg,  y_eg),  4))\n",
    "print(\"Dogrulama :\", round(agac.score(X_dog, y_dog), 4))\n",
    "print()\n",
    "print(export_text(agac, feature_names=list(X.columns), decimals=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### İstersen ağacı çizdir\n",
    "\n",
    "`plot_tree` aynı ağacı görsel olarak verir. Derinlik 3'ün üstünde okunmaz hâle gelir —\n",
    "bu da okunabilirliğin pratik sınırını gösterir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "from sklearn.tree import plot_tree\n",
    "\n",
    "plt.figure(figsize=(16, 7))\n",
    "plot_tree(agac, feature_names=list(X.columns),\n",
    "          class_names=[\"olmedi\", \"kurtuldu\"], filled=True, rounded=True, fontsize=9)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 · Derinliği tara: aşırı öğrenmeyi sayıyla yakala\n",
    "\n",
    "İki sütunu **birlikte** okuyun: biri hangi noktada yükselmeye devam ediyor, diğeri\n",
    "hangi noktada dönüyor?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f\"{'derinlik':>9} | {'egitim':>7} | {'dogrulama':>9} | ucurum\")\n",
    "for d in [1, 2, 3, 4, 5, 6, 8, 10, 12, None]:\n",
    "    m = DecisionTreeClassifier(max_depth=d, random_state=42).fit(X_eg, y_eg)\n",
    "    e, v = m.score(X_eg, y_eg), m.score(X_dog, y_dog)\n",
    "    print(f\"{str(d):>9} | {e:>7.4f} | {v:>9.4f} | {e-v:+.4f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5 · Çapraz doğrulama: tek bölünmeye güvenme\n",
    "\n",
    "223 satırlık bir doğrulama kümesinde ±2 puan gürültü normaldir. İki modeli 1 puan farkla\n",
    "karşılaştırmak **ölçüm hatasının içinde kalır**.\n",
    "\n",
    "`±` işaretinden sonraki sayı raporun en önemli parçasıdır."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import cross_val_score, StratifiedKFold\n",
    "\n",
    "# StratifiedKFold: her katta hayatta kalma orani korunur (5. hafta: dengesiz veri)\n",
    "kat = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)\n",
    "\n",
    "def olc(ad, model):\n",
    "    s = cross_val_score(model, X, y, cv=kat, scoring=\"accuracy\", n_jobs=-1)\n",
    "    print(f\"{ad:<36} {s.mean():.4f} +- {s.std():.4f}   {np.round(s, 4)}\")\n",
    "    return s\n",
    "\n",
    "olc(\"Agac, derinlik 4, yaprak 10\", DecisionTreeClassifier(max_depth=4, min_samples_leaf=10, random_state=42))\n",
    "olc(\"Agac, sinirsiz (ezberleyen)\",  DecisionTreeClassifier(random_state=42));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6 · Random Forest + bedava OOB skoru\n",
    "\n",
    "`max_features=\"sqrt\"` **ormanı orman yapan ayardır**. `None` yazarsanız düz torbalama\n",
    "yapmış olursunuz — aşağıda ikisini karşılaştırıyoruz.\n",
    "\n",
    "Her bootstrap örneklemi verinin ortalama %37'sini içermez; OOB skoru o örnekler üzerinde\n",
    "ölçülür. Yani **ayrı bir test seti ayırmadan** dürüst bir sayı."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "\n",
    "orman = RandomForestClassifier(\n",
    "    n_estimators=400,        # agac sayisi: ayar degil, butce\n",
    "    max_features=\"sqrt\",     # ORMANI ORMAN YAPAN AYAR\n",
    "    min_samples_leaf=2,\n",
    "    random_state=42,\n",
    "    n_jobs=-1,\n",
    "    oob_score=True\n",
    ")\n",
    "orman.fit(X, y)\n",
    "print(\"OOB skoru (bedava):\", round(orman.oob_score_, 4))\n",
    "\n",
    "olc(\"Random Forest (400 agac)\", RandomForestClassifier(\n",
    "    n_estimators=400, max_features=\"sqrt\", min_samples_leaf=2,\n",
    "    random_state=42, n_jobs=-1))\n",
    "\n",
    "olc(\"Duz torbalama (max_features=None)\", RandomForestClassifier(\n",
    "    n_estimators=400, max_features=None, min_samples_leaf=2,\n",
    "    random_state=42, n_jobs=-1));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7 · Boosting\n",
    "\n",
    "Üç ayarı birlikte okuyun: **düşük hız, çok tur, erken durdurma.** Üçü birbirine bağlı.\n",
    "\n",
    "Son ölçüm haftanın en önemlisi: aynı model, tek fark ağaç sayısının zorla 500'de tutulması.\n",
    "**Ormanda ağaç eklemek zarar vermez; boosting'te bir noktadan sonra verir.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.ensemble import HistGradientBoostingClassifier\n",
    "\n",
    "hgb = HistGradientBoostingClassifier(\n",
    "    learning_rate=0.06,        # yavas ogren\n",
    "    max_iter=500,              # cok adim at\n",
    "    max_leaf_nodes=15,         # agaclar SIG olsun\n",
    "    min_samples_leaf=15,\n",
    "    early_stopping=True,       # dogrulama skoru iyilesmeyi birakinca dur\n",
    "    validation_fraction=0.15,\n",
    "    n_iter_no_change=30,\n",
    "    random_state=42\n",
    ")\n",
    "hgb.fit(X, y)\n",
    "print(\"Erken durdurma kac agacta durdu:\", hgb.n_iter_)\n",
    "\n",
    "olc(\"HistGradientBoosting\", HistGradientBoostingClassifier(\n",
    "    learning_rate=0.06, max_iter=500, max_leaf_nodes=15, min_samples_leaf=15,\n",
    "    early_stopping=True, validation_fraction=0.15, n_iter_no_change=30,\n",
    "    random_state=42))\n",
    "\n",
    "olc(\"HGB, 500 agac, erken durdurma yok\", HistGradientBoostingClassifier(\n",
    "    learning_rate=0.06, max_iter=500, max_leaf_nodes=15, min_samples_leaf=15,\n",
    "    early_stopping=False, random_state=42));"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 8 · Dördünü tek tabloya yaz\n",
    "\n",
    "Raporunuzun kalbi bu tablo: dört model, aynı veri, aynı katlar, aynı metrik — ve en üstte\n",
    "taban çizgisi.\n",
    "\n",
    "**Okuma kuralı:** iki modelin ortalamaları arasındaki fark yayılımlarından küçükse, o fark\n",
    "yoktur."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.dummy import DummyClassifier\n",
    "\n",
    "modeller = {\n",
    "    \"0 - Taban cizgisi (hep cogunluk)\": DummyClassifier(strategy=\"most_frequent\"),\n",
    "    \"1 - Karar agaci (d=4, yaprak=10)\": DecisionTreeClassifier(max_depth=4, min_samples_leaf=10, random_state=42),\n",
    "    \"2 - Karar agaci (sinirsiz)\":       DecisionTreeClassifier(random_state=42),\n",
    "    \"3 - Random Forest (400)\":          RandomForestClassifier(n_estimators=400, max_features=\"sqrt\",\n",
    "                                                               min_samples_leaf=2, random_state=42, n_jobs=-1),\n",
    "    \"4 - HistGradientBoosting\":         HistGradientBoostingClassifier(\n",
    "                                            learning_rate=0.06, max_iter=500, max_leaf_nodes=15,\n",
    "                                            min_samples_leaf=15, early_stopping=True,\n",
    "                                            validation_fraction=0.15, n_iter_no_change=30, random_state=42),\n",
    "}\n",
    "\n",
    "satirlar = []\n",
    "for ad, m in modeller.items():\n",
    "    s = cross_val_score(m, X, y, cv=kat, scoring=\"accuracy\", n_jobs=-1)\n",
    "    satirlar.append({\"model\": ad, \"ortalama\": round(s.mean(), 4),\n",
    "                     \"yayilim\": round(s.std(), 4), \"en_kotu_kat\": round(s.min(), 4)})\n",
    "\n",
    "tablo = pd.DataFrame(satirlar).sort_values(\"ortalama\", ascending=False)\n",
    "print(tablo.to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 9 · Öznitelik önemi ve `PassengerId` tuzağı\n",
    "\n",
    "Titanic'te hazır bir \"kayıt numarası\" var: `PassengerId`. Hayatta kalmakla ilgisi tanımı\n",
    "gereği sıfır. Bakalım budanmamış ağaç ne diyecek."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_tuzak = X.copy()\n",
    "X_tuzak[\"PassengerId\"] = train[\"PassengerId\"]      # BILGI TASIMAYAN SUTUN\n",
    "\n",
    "derin = DecisionTreeClassifier(random_state=42).fit(X_tuzak, y)\n",
    "print(\"Budanmamis agac - Gini onemi:\")\n",
    "print(pd.Series(derin.feature_importances_, index=X_tuzak.columns)\n",
    "        .sort_values(ascending=False).round(4).head(6).to_string())\n",
    "\n",
    "budali = DecisionTreeClassifier(max_depth=4, min_samples_leaf=10,\n",
    "                                random_state=42).fit(X_tuzak, y)\n",
    "print(\"\\nBudanmis agac - Gini onemi:\")\n",
    "print(pd.Series(budali.feature_importances_, index=X_tuzak.columns)\n",
    "        .sort_values(ascending=False).head(6).round(4).to_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10 · Permütasyon önemi: daha güvenilir ikinci görüş\n",
    "\n",
    "Gini önemi eğitim verisine bakar, ezberden etkilenir. Permütasyon önemi başka bir soru\n",
    "sorar: **bu sütunu bozarsam, görmediği veride skor ne kadar düşer?**\n",
    "\n",
    "Bir sütunu silip silmeme kararını **bu listeye** bakarak verin."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.inspection import permutation_importance\n",
    "\n",
    "orman_t = RandomForestClassifier(n_estimators=400, max_features=\"sqrt\",\n",
    "                                 min_samples_leaf=2, random_state=42, n_jobs=-1)\n",
    "X_eg2, X_dog2, y_eg2, y_dog2 = train_test_split(\n",
    "    X_tuzak, y, test_size=0.25, stratify=y, random_state=42)\n",
    "orman_t.fit(X_eg2, y_eg2)\n",
    "\n",
    "p = permutation_importance(orman_t, X_dog2, y_dog2,\n",
    "                           n_repeats=30, random_state=42, n_jobs=-1)\n",
    "\n",
    "print(\"Permutasyon onemi (gormedigi veride skor dususu):\")\n",
    "print(pd.Series(p.importances_mean, index=X_tuzak.columns)\n",
    "        .sort_values(ascending=False).round(4).to_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11 · 5. haftanın gözüyle: matris, kesinlik, duyarlılık\n",
    "\n",
    "Doğruluk tek başına yalan söyler. Rapora yazılacak cümle tek sayı değildir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "en_iyi = HistGradientBoostingClassifier(\n",
    "    learning_rate=0.06, max_iter=500, max_leaf_nodes=15, min_samples_leaf=15,\n",
    "    early_stopping=True, validation_fraction=0.15, n_iter_no_change=30, random_state=42)\n",
    "en_iyi.fit(X_eg, y_eg)\n",
    "tahmin = en_iyi.predict(X_dog)\n",
    "\n",
    "km = confusion_matrix(y_dog, tahmin)\n",
    "print(\"Karmasiklik matrisi (ham sayi):\")\n",
    "print(pd.DataFrame(km,\n",
    "      index=[\"gercek: olmedi\", \"gercek: kurtuldu\"],\n",
    "      columns=[\"tahmin: olmedi\", \"tahmin: kurtuldu\"]).to_string())\n",
    "print()\n",
    "print(classification_report(y_dog, tahmin, target_names=[\"olmedi\", \"kurtuldu\"], digits=3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12 · Izgara aramasıyla ayar seç\n",
    "\n",
    "`return_train_score=True` yazmayı alışkanlık yapın: hangi ayarın **neden** kaybettiğini\n",
    "ancak o sütunla görürsünüz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import GridSearchCV\n",
    "\n",
    "izgara = {\n",
    "    \"max_depth\":        [3, 4, 5, 6, 8, None],\n",
    "    \"min_samples_leaf\": [1, 5, 10, 20],\n",
    "}\n",
    "ara = GridSearchCV(\n",
    "    DecisionTreeClassifier(random_state=42),\n",
    "    izgara, cv=kat, scoring=\"accuracy\", n_jobs=-1, return_train_score=True\n",
    ")\n",
    "ara.fit(X, y)\n",
    "\n",
    "print(\"En iyi ayar :\", ara.best_params_)\n",
    "print(\"En iyi skor :\", round(ara.best_score_, 4))\n",
    "\n",
    "sonuc = pd.DataFrame(ara.cv_results_)[\n",
    "    [\"param_max_depth\", \"param_min_samples_leaf\",\n",
    "     \"mean_train_score\", \"mean_test_score\", \"std_test_score\"]\n",
    "].sort_values(\"mean_test_score\", ascending=False)\n",
    "print(sonuc.head(8).round(4).to_string(index=False))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13 · Sızıntı testi: etiketleri karıştır\n",
    "\n",
    "İki satır ve hayat kurtarır. Etiketler rastgele dağıtıldığında skor taban çizgisine inmeli.\n",
    "İnmiyorsa model cevabı bir yerden **görüyor** demektir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import shuffle\n",
    "\n",
    "y_karisik = shuffle(y.values, random_state=0)\n",
    "\n",
    "s_gercek  = cross_val_score(ara.best_estimator_, X, y,         cv=kat, n_jobs=-1)\n",
    "s_karisik = cross_val_score(ara.best_estimator_, X, y_karisik, cv=kat, n_jobs=-1)\n",
    "\n",
    "print(\"Gercek etiketlerle :\", round(s_gercek.mean(), 4))\n",
    "print(\"Karisik etiketlerle:\", round(s_karisik.mean(), 4))\n",
    "print(\"Taban cizgisi      :\", round((y == 0).mean(), 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 14 · `submission.csv`\n",
    "\n",
    "Ayarlar seçildi; artık doğrulama ayrımına gerek yok — **891 satırın tamamıyla** eğitiyoruz.\n",
    "\n",
    "Teslim etmeden iki kontrol: satır sayısı 418 mi, tahmin dağılımı makul mü?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "en_iyi.fit(X, y)\n",
    "tahmin_test = en_iyi.predict(X_test)\n",
    "\n",
    "teslim = pd.DataFrame({\n",
    "    \"PassengerId\": test[\"PassengerId\"],\n",
    "    \"Survived\": tahmin_test.astype(int)\n",
    "})\n",
    "teslim.to_csv(\"/kaggle/working/submission.csv\", index=False)\n",
    "\n",
    "print(teslim.shape)                       # (418, 2) olmali\n",
    "print(teslim[\"Survived\"].value_counts())\n",
    "print(\"Tahmin edilen hayatta kalma orani:\", round(teslim[\"Survived\"].mean(), 4),\n",
    "      \"| egitimdeki oran:\", round(train[\"Survived\"].mean(), 4))\n",
    "teslim.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## Ödev için buradan devam\n",
    "\n",
    "1. En az bir **yeni öznitelik** türetin (`Cabin` boş mu, `Name` içindeki unvan: Mr/Mrs/Miss/Master)\n",
    "   ve 8. hücredeki tabloyu **o öznitelikle ve onsuz** yeniden üretin.\n",
    "2. Yerel çapraz doğrulama skorunuzla Kaggle'ın verdiği **public skoru** karşılaştırın ve\n",
    "   farkın nedenini bir paragrafta açıklayın.\n",
    "3. Son paragraf: *bu veride kazandıran şey model değişikliği mi, ayar değişikliği mi,\n",
    "   öznitelik türetmek mi oldu?*"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}