{ "cells": [ { "cell_type": "code", "execution_count": 3, "id": "39621e4d-6b0c-4193-9a90-d423e3c7b0f5", "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "df = pd.read_csv('C:\\\\Users\\\\mus3a\\\\OneDrive - Solutions by stc\\\\Desktop\\\\kidney_disease_clean_final.csv')\n" ] }, { "cell_type": "code", "execution_count": 5, "id": "f5e03b78-2732-4b81-af39-1f9d2e80c9cf", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " age bp sg al su pc pcc ba bgr bu ... hemo pcv \\\n", "0 48.0 80.0 1.020 1.0 0.0 1 0 0 121.000000 36.0 ... 15.4 32 \n", "1 7.0 50.0 1.020 4.0 0.0 1 0 0 147.943503 18.0 ... 11.3 26 \n", "2 62.0 80.0 1.010 2.0 3.0 1 0 0 423.000000 53.0 ... 9.6 19 \n", "3 48.0 70.0 1.005 4.0 0.0 0 1 0 117.000000 56.0 ... 11.2 20 \n", "4 51.0 80.0 1.010 2.0 0.0 1 0 0 106.000000 26.0 ... 11.6 23 \n", "\n", " wc htn dm cad appet pe ane classification \n", "0 72 1 4 1 0 0 0 0 \n", "1 56 0 3 1 0 0 0 0 \n", "2 70 0 4 1 1 0 1 0 \n", "3 62 1 3 1 1 1 1 0 \n", "4 68 0 3 1 0 0 0 0 \n", "\n", "[5 rows x 23 columns]\n", "\n", "RangeIndex: 398 entries, 0 to 397\n", "Data columns (total 23 columns):\n", " # Column Non-Null Count Dtype \n", "--- ------ -------------- ----- \n", " 0 age 398 non-null float64\n", " 1 bp 398 non-null float64\n", " 2 sg 398 non-null float64\n", " 3 al 398 non-null float64\n", " 4 su 398 non-null float64\n", " 5 pc 398 non-null int64 \n", " 6 pcc 398 non-null int64 \n", " 7 ba 398 non-null int64 \n", " 8 bgr 398 non-null float64\n", " 9 bu 398 non-null float64\n", " 10 sc 398 non-null float64\n", " 11 sod 398 non-null float64\n", " 12 pot 398 non-null float64\n", " 13 hemo 398 non-null float64\n", " 14 pcv 398 non-null int64 \n", " 15 wc 398 non-null int64 \n", " 16 htn 398 non-null int64 \n", " 17 dm 398 non-null int64 \n", " 18 cad 398 non-null int64 \n", " 19 appet 398 non-null int64 \n", " 20 pe 398 non-null int64 \n", " 21 ane 398 non-null int64 \n", " 22 classification 398 non-null int64 \n", "dtypes: float64(11), int64(12)\n", "memory usage: 71.6 KB\n", "None\n", "age 0\n", "bp 0\n", "sg 0\n", "al 0\n", "su 0\n", "pc 0\n", "pcc 0\n", "ba 0\n", "bgr 0\n", "bu 0\n", "sc 0\n", "sod 0\n", "pot 0\n", "hemo 0\n", "pcv 0\n", "wc 0\n", "htn 0\n", "dm 0\n", "cad 0\n", "appet 0\n", "pe 0\n", "ane 0\n", "classification 0\n", "dtype: int64\n" ] } ], "source": [ "import pandas as pd\n", "\n", "df = pd.read_csv(r'C:\\Users\\mus3a\\OneDrive - Solutions by stc\\Desktop\\kidney_disease_clean_final.csv')\n", "\n", "print(df.head())\n", "\n", "print(df.info())\n", "\n", "print(df.isnull().sum())\n" ] }, { "cell_type": "code", "execution_count": 6, "id": "de4364e7-3781-4dd4-a6cc-5a38e853e119", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "حجم بيانات التدريب: (318, 22)\n", "حجم بيانات الاختبار: (80, 22)\n" ] } ], "source": [ "from sklearn.model_selection import train_test_split\n", "\n", "X = df.drop('classification', axis=1)\n", "y = df['classification']\n", "\n", "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)\n", "\n", "print(f\"حجم بيانات التدريب: {X_train.shape}\")\n", "print(f\"حجم بيانات الاختبار: {X_test.shape}\")\n" ] }, { "cell_type": "code", "execution_count": 8, "id": "0935787f-d810-4e42-8640-7b0ca841fd0f", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "أفضل معاملات: {'max_depth': 4, 'min_samples_leaf': 1, 'min_samples_split': 2, 'n_estimators': 50}\n", "دقة النموذج: 0.9875\n", "تقرير التصنيف:\n", " precision recall f1-score support\n", "\n", " 0 1.00 0.98 0.99 52\n", " 1 0.97 1.00 0.98 28\n", "\n", " accuracy 0.99 80\n", " macro avg 0.98 0.99 0.99 80\n", "weighted avg 0.99 0.99 0.99 80\n", "\n" ] } ], "source": [ "from sklearn.ensemble import RandomForestClassifier\n", "from sklearn.model_selection import GridSearchCV\n", "from sklearn.metrics import classification_report, accuracy_score\n", "\n", "rf = RandomForestClassifier(random_state=42)\n", "\n", "param_grid = {\n", " 'n_estimators': [50, 100, 200], \n", " 'max_depth': [4, 6, 8, None], \n", " 'min_samples_split': [2, 5, 10], \n", " 'min_samples_leaf': [1, 2, 4] \n", "}\n", "\n", "grid_search = GridSearchCV(estimator=rf, param_grid=param_grid, cv=5, scoring='accuracy', n_jobs=-1)\n", "\n", "grid_search.fit(X_train, y_train)\n", "\n", "print(\"أفضل معاملات:\", grid_search.best_params_)\n", "\n", "y_pred = grid_search.predict(X_test)\n", "\n", "print(\"دقة النموذج:\", accuracy_score(y_test, y_pred))\n", "print(\"تقرير التصنيف:\\n\", classification_report(y_test, y_pred))\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "2f2f61e4-15da-4328-ae65-e86fcc0daf2a", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "أهمية الخصائص:\n", "hemo: 0.2641\n", "sg: 0.2142\n", "sc: 0.0967\n", "al: 0.0827\n", "bgr: 0.0654\n", "sod: 0.0495\n", "htn: 0.0471\n", "pcv: 0.0460\n", "wc: 0.0281\n", "bu: 0.0253\n", "dm: 0.0187\n", "su: 0.0152\n", "bp: 0.0120\n", "pe: 0.0096\n", "pc: 0.0059\n", "appet: 0.0052\n", "pot: 0.0052\n", "age: 0.0040\n", "ane: 0.0027\n", "cad: 0.0009\n", "ba: 0.0007\n", "pcc: 0.0005\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import numpy as np\n", "\n", "best_rf = grid_search.best_estimator_\n", "\n", "importances = best_rf.feature_importances_\n", "\n", "feature_names = X.columns\n", "\n", "indices = np.argsort(importances)[::-1]\n", "\n", "print(\"أهمية الخصائص:\")\n", "for i in indices:\n", " print(f\"{feature_names[i]}: {importances[i]:.4f}\")\n", "\n", "plt.figure(figsize=(10,6))\n", "sns.barplot(x=importances[indices][:10], y=feature_names[indices][:10])\n", "plt.title(\"Top 10 Features of Random Forests\")\n", "plt.show()\n" ] }, { "cell_type": "code", "execution_count": 11, "id": "e7a8b54f-a389-402a-bd86-6da2d799983b", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Properties selected using RFE:\n", "['sg', 'al', 'bgr', 'bu', 'sc', 'sod', 'hemo', 'pcv', 'wc', 'htn']\n" ] } ], "source": [ "from sklearn.feature_selection import RFE\n", "\n", "rf_basic = RandomForestClassifier(random_state=42)\n", "\n", "selector = RFE(rf_basic, n_features_to_select=10)\n", "\n", "selector = selector.fit(X_train, y_train)\n", "\n", "selected_features = X.columns[selector.support_]\n", "\n", "print(\"Properties selected using RFE:\")\n", "print(selected_features.tolist())\n" ] }, { "cell_type": "code", "execution_count": 12, "id": "0cfe0cce-8905-44e9-842b-3efe83f46106", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Model accuracy using selected properties: 0.9875\n", "Classification Report:\n", " precision recall f1-score support\n", "\n", " 0 1.00 0.98 0.99 52\n", " 1 0.97 1.00 0.98 28\n", "\n", " accuracy 0.99 80\n", " macro avg 0.98 0.99 0.99 80\n", "weighted avg 0.99 0.99 0.99 80\n", "\n" ] } ], "source": [ "X_train_selected = X_train[selected_features]\n", "X_test_selected = X_test[selected_features]\n", "\n", "rf_selected = RandomForestClassifier(random_state=42)\n", "rf_selected.fit(X_train_selected, y_train)\n", "\n", "y_pred_selected = rf_selected.predict(X_test_selected)\n", "\n", "print(\"Model accuracy using selected properties:\", accuracy_score(y_test, y_pred_selected))\n", "print(\"Classification Report:\\n\", classification_report(y_test, y_pred_selected))\n" ] }, { "cell_type": "code", "execution_count": null, "id": "22a61f1d-30b8-43b8-bd25-09644143db72", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python [conda env:base] *", "language": "python", "name": "conda-base-py" }, "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.13.5" } }, "nbformat": 4, "nbformat_minor": 5 }