گزارش جامع پروژه تحلیل داده‌های مسابقات فوتبال

  Division   MatchDate    HomeTeam    AwayTeam  HomeElo  AwayElo  FTHome  FTAway FTResult
0       F1  2000-07-28   Marseille      Troyes  1686.34  1586.57     2.0     1.0        H
1       F1  2000-07-28    Paris SG  Strasbourg  1714.89  1642.51     3.0     1.0        H
2       F2  2000-07-28   Wasquehal       Nancy  1465.08  1633.80     1.0     2.0        A
3       F1  2000-07-29     Auxerre       Sedan  1635.58  1624.22     0.0     0.0        D
4       F1  2000-07-29    Bordeaux        Metz  1734.34  1673.11     2.0     0.0        H
                

import kagglehub

# دانلود آخرین نسخه دیتاست
path = kagglehub.dataset_download("adamgbor/club-football-match-data-2000-2025")

print("Path to dataset files:", path)
                

Warning: Looks like you're using an outdated `kagglehub` version (installed: 0.3.13)
Downloading from https://www.kaggle.com/api/v1/datasets/download/...
100%|██████████| 14.4M/14.4M [00:00<00:00, 51.5MB/s]
Extracting files...
Path to dataset files: /root/.cache/kagglehub/datasets/adamgbor/club-football-match-data-2000-2025/versions/3
                

import shutil
import os

# تعریف پوشه مقصد
target_dir = "/content/ST"
os.makedirs(target_dir, exist_ok=True)

# انتقال تمام فایل‌ها
for file_name in os.listdir(path):
    full_file_name = os.path.join(path, file_name)
    if os.path.isfile(full_file_name):
        shutil.move(full_file_name, target_dir)

print("Files moved to:", target_dir)
                

import pandas as pd

# خواندن فایل CSV
match_data = pd.read_csv("/content/ST/Matches.csv")

# نمایش ۵ رکورد اول
match_data.head()
                

match_data.info()
                

'pandas.core.frame.DataFrame'>
RangeIndex: 230557 entries, 0 to 230556
Data columns (total 48 columns):
 #   Column       Non-Null Count   Dtype
---  ------       --------------   -----
 0   Division     230557 non-null  object
 1   MatchDate    230557 non-null  object
 2   MatchTime    99072 non-null   object
 3   HomeTeam     230557 non-null  object
 4   AwayTeam     230557 non-null  object
 5   HomeElo      141597 non-null  float64
 6   AwayElo      141528 non-null  float64
 7   Form3Home    229057 non-null  float64
 8   Form5Home    229057 non-null  float64
 9   Form3Away    229057 non-null  float64
 10  Form5Away    229057 non-null  float64
 11  FTHome       230554 non-null  float64
 12  FTAway       230554 non-null  float64
 13  FTResult     230554 non-null  object
 14  HTHome       175977 non-null  float64
 15  HTAway       175977 non-null  float64
 16  HTResult     175977 non-null  object
 17  HomeShots    114735 non-null  float64
 18  AwayShots    114738 non-null  float64
 19  HomeTarget   113929 non-null  float64
 20  AwayTarget   113932 non-null  float64
 21  HomeFouls    113973 non-null  float64
 22  AwayFouls    113973 non-null  float64
 23  HomeCorners  114363 non-null  float64
 24  AwayCorners  114363 non-null  float64
 25  HomeYellow   119298 non-null  float64
 26  AwayYellow   119299 non-null  float64
 27  HomeRed      119299 non-null  float64
 28  AwayRed      119297 non-null  float64
 29  OddHome      227527 non-null  float64
 30  OddDraw      227527 non-null  float64
 31  OddAway      227527 non-null  float64
 32  MaxHome      202922 non-null  float64
 33  MaxDraw      202922 non-null  float64
 34  MaxAway      202922 non-null  float64
 35  Over25       148398 non-null  float64
 36  Under25      148397 non-null  float64
 37  MaxOver25    148398 non-null  float64
 38  MaxUnder25   148397 non-null  float64
 39  HandiSize    156733 non-null  float64
 40  HandiHome    156475 non-null  float64
 41  HandiAway    156451 non-null  float64
 42  C_LTH        112602 non-null  float64
 43  C_LTA        112602 non-null  float64
 44  C_VHD        112602 non-null  float64
 45  C_VAD        112602 non-null  float64
 46  C_HTB        112602 non-null  float64
 47  C_PHB        112602 non-null  float64
dtypes: float64(41), object(7)
memory usage: 84.4+ MB
                

match_data.isnull().sum()
                

match_data.shape
                

(230557, 48)
                

match_data.columns
                

Index(['Division', 'MatchDate', 'MatchTime', 'HomeTeam', 'AwayTeam', 'HomeElo',
       'AwayElo', 'Form3Home', 'Form5Home', 'Form3Away', 'Form5Away', 'FTHome',
       'FTAway', 'FTResult', 'HTHome', 'HTAway', 'HTResult', 'HomeShots',
       'AwayShots', 'HomeTarget', 'AwayTarget', 'HomeFouls', 'AwayFouls',
       'HomeCorners', 'AwayCorners', 'HomeYellow', 'AwayYellow', 'HomeRed',
       'AwayRed', 'OddHome', 'OddDraw', 'OddAway', 'MaxHome', 'MaxDraw',
       'MaxAway', 'Over25', 'Under25', 'MaxOver25', 'MaxUnder25', 'HandiSize',
       'HandiHome', 'HandiAway', 'C_LTH', 'C_LTA', 'C_VHD', 'C_VAD', 'C_HTB',
       'C_PHB'],
      dtype='object')
                

match_data.describe()
                

match_data.drop([
    'HTHome', 'HTAway', 'HTResult',      # نتایج نیمه اول
    'HomeShots', 'AwayShots',            # شوت‌ها
    'HomeTarget', 'AwayTarget',          # شوت به چارچوب
    'HomeFouls', 'AwayFouls',            # خطاها
    'HomeCorners', 'AwayCorners',        # کرنرها
    'HomeYellow', 'AwayYellow',          # کارت زرد
    'HomeRed', 'AwayRed',                # کارت قرمز
    'OddHome', 'OddDraw', 'OddAway',     # ضرایب متوسط
    'MaxHome', 'MaxDraw', 'MaxAway',     # بیشترین ضرایب
    'Over25', 'Under25',                 # ضرایب تعداد گل
    'MaxOver25', 'MaxUnder25',           # بیشترین ضرایب گل
    'HandiSize', 'HandiHome', 'HandiAway' # هندیکپ
], axis=1, inplace=True)
                

match_data.columns
                

Index(['Division', 'MatchDate', 'MatchTime', 'HomeTeam', 'AwayTeam', 'HomeElo',
       'AwayElo', 'Form3Home', 'Form5Home', 'Form3Away', 'Form5Away', 'FTHome',
       'FTAway', 'FTResult', 'C_LTH', 'C_LTA', 'C_VHD', 'C_VAD', 'C_HTB', 'C_PHB'],
      dtype='object')
                

# ساخت ویژگی EloDiff
match_data['EloDiff'] = match_data['HomeElo'] - match_data['AwayElo']
                

match_data.drop(['HomeElo', 'AwayElo'], axis=1, inplace=True)
                

# بررسی وجود داده‌های گمشده در Form5Home
print(match_data['Form5Home'].isna().sum())  # خروجی: 1500

# ساخت ویژگی Form5Diff
match_data['Form5Diff'] = match_data['Form5Home'] - match_data['Form5Away']
                

# ساخت ویژگی Form3Diff
match_data['Form3Diff'] = match_data['Form3Home'] - match_data['Form3Away']
                

match_data.columns
                

Index(['Division', 'MatchDate', 'MatchTime', 'HomeTeam', 'AwayTeam',
       'Form3Home', 'Form5Home', 'Form3Away', 'Form5Away', 'FTHome',
       'FTAway', 'FTResult', 'C_LTH', 'C_LTA', 'C_VHD', 'C_VAD', 'C_HTB',
       'C_PHB', 'EloDiff', 'Form5Diff', 'Form3Diff'],
      dtype='object')
                

match_data.drop(columns=['Form3Home', 'Form5Home', 'Form3Away', 'Form5Away'])
                

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler
import matplotlib.pyplot as plt
import seaborn as sns
import warnings
warnings.filterwarnings('ignore')
                

# کپی دیتاست
df = match_data.copy()

print(f"\nRows: {df.shape[0]}, Columns: {df.shape[1]}")

# تعریف ویژگی‌های مورد استفاده
feature_cols = ['Form3Home', 'Form5Home', 'Form3Away', 'Form5Away',
                'C_LTH', 'C_LTA', 'C_VHD', 'C_VAD', 'C_HTB', 'C_PHB',
                'EloDiff', 'Form5Diff', 'Form3Diff']
                

# حذف رکوردهای بدون برچسب
df_clean = df.dropna(subset=['FTResult'])

# حذف رکوردهای بدون ویژگی‌های ضروری
df_clean = df_clean.dropna(subset=feature_cols)

print(f"After cleaning: {df_clean.shape[0]} rows")
                

# ویژگی‌ها (X) و برچسب‌ها (y)
X = df_clean[feature_cols].copy()
y = df_clean['FTResult'].copy()

print(f"\nFeatures: {len(feature_cols)}")
                

# رمزگذاری برچسب‌ها
le = LabelEncoder()
y_encoded = le.fit_transform(y)

print(f"\nTarget classes: {le.classes_}")
# خروجی: ['A' 'D' 'H']
                

# تقسیم 80% آموزش، 20% تست
X_train, X_test, y_train, y_test = train_test_split(
    X, y_encoded,
    test_size=0.2,      # 20% برای تست
    random_state=42,    # برای تکرارپذیری
    stratify=y_encoded  # حفظ نسبت کلاس‌ها
)

print(f"\nTrain: {X_train.shape[0]}, Test: {X_test.shape[0]}")
# خروجی: Train: 90081, Test: 22521
                

# نرمال‌سازی با StandardScaler
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
                

# ذخیره داده‌ها برای استفاده در مدل‌های بعدی
np.save('X_train_scaled.npy', X_train_scaled)
np.save('X_test_scaled.npy', X_test_scaled)
np.save('y_train.npy', y_train)
np.save('y_test.npy', y_test)

print("\n" + "="*60)
print("Data preprocessing complete!")
print("="*60)
                

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from sklearn.model_selection import cross_val_score
import warnings
warnings.filterwarnings('ignore')

print("="*60)
print("Random Forest Model")
print("="*60)

# بارگذاری داده‌ها
X_train = np.load('X_train_scaled.npy')
X_test = np.load('X_test_scaled.npy')
y_train = np.load('y_train.npy')
y_test = np.load('y_test.npy')

print("\nTraining Random Forest...")

# ساخت مدل با پارامترهای بهینه
rf_model = RandomForestClassifier(
    n_estimators=200,        # تعداد درخت‌ها
    max_depth=15,            # عمق هر درخت
    min_samples_split=10,    # حداقل نمونه برای split
    min_samples_leaf=4,      # حداقل نمونه در برگ
    random_state=42,
    n_jobs=-1                # استفاده از تمام هسته‌های CPU
)

# آموزش مدل
rf_model.fit(X_train, y_train)
                

# پیش‌بینی
y_pred = rf_model.predict(X_test)
y_train_pred = rf_model.predict(X_train)

# محاسبه دقت
train_acc = accuracy_score(y_train, y_train_pred)
test_acc = accuracy_score(y_test, y_pred)

print(f"\nTrain Accuracy: {train_acc:.4f} ({train_acc*100:.2f}%)")
print(f"Test Accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)")

# اعتبارسنجی متقابل 5-fold
cv_scores = cross_val_score(rf_model, X_train, y_train, cv=5)
print(f"\nCross Validation (5-fold):")
print(f"Mean: {cv_scores.mean():.4f}, Std: {cv_scores.std():.4f}")
                

print("\n" + "="*60)
print("Classification Report:")
print("="*60)
print(classification_report(y_test, y_pred))
                

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# ماتریس درهم‌ریختگی
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[0])
axes[0].set_title('Confusion Matrix - Random Forest')
axes[0].set_ylabel('Actual')
axes[0].set_xlabel('Predicted')

# اهمیت ویژگی‌ها
feature_names = ['Form3Home', 'Form5Home', 'Form3Away', 'Form5Away',
                 'C_LTH', 'C_LTA', 'C_VHD', 'C_VAD', 'C_HTB', 'C_PHB',
                 'EloDiff', 'Form5Diff', 'Form3Diff']

importances = rf_model.feature_importances_
indices = np.argsort(importances)[::-1]

axes[1].bar(range(len(importances)), importances[indices])
axes[1].set_title('Feature Importance - Random Forest')
axes[1].set_xticks(range(len(importances)))
axes[1].set_xticklabels([feature_names[i] for i in indices],
                        rotation=45, ha='right')

plt.tight_layout()
plt.savefig('rf_results.png', dpi=300, bbox_inches='tight')
plt.show()
                

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
from sklearn.model_selection import cross_val_score
import warnings
warnings.filterwarnings('ignore')

# نصب XGBoost در صورت نیاز
try:
    import xgboost as xgb
except:
    print("Installing XGBoost...")
    !pip install xgboost -q
    import xgboost as xgb

print("="*60)
print("XGBoost Model")
print("="*60)

# بارگذاری داده‌ها
X_train = np.load('X_train_scaled.npy')
X_test = np.load('X_test_scaled.npy')
y_train = np.load('y_train.npy')
y_test = np.load('y_test.npy')

print("\nTraining XGBoost...")

# ساخت مدل
xgb_model = xgb.XGBClassifier(
    n_estimators=200,         # تعداد boosting rounds
    max_depth=6,              # عمق درخت
    learning_rate=0.1,        # نرخ یادگیری
    subsample=0.8,            # نسبت نمونه‌برداری
    colsample_bytree=0.8,     # نسبت انتخاب ویژگی‌ها
    random_state=42,
    eval_metric='mlogloss',   # معیار ارزیابی
    use_label_encoder=False
)

# آموزش مدل
xgb_model.fit(X_train, y_train)
                

# پیش‌بینی
y_pred = xgb_model.predict(X_test)
y_train_pred = xgb_model.predict(X_train)

# محاسبه دقت
train_acc = accuracy_score(y_train, y_train_pred)
test_acc = accuracy_score(y_test, y_pred)

print(f"\nTrain Accuracy: {train_acc:.4f} ({train_acc*100:.2f}%)")
print(f"Test Accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)")

# اعتبارسنجی متقابل
cv_scores = cross_val_score(xgb_model, X_train, y_train, cv=5)
print(f"\nCross Validation (5-fold):")
print(f"Mean: {cv_scores.mean():.4f}, Std: {cv_scores.std():.4f}")

# گزارش طبقه‌بندی
print("\n" + "="*60)
print("Classification Report:")
print("="*60)
print(classification_report(y_test, y_pred))
                

fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# ماتریس درهم‌ریختگی
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Greens', ax=axes[0])
axes[0].set_title('Confusion Matrix - XGBoost')
axes[0].set_ylabel('Actual')
axes[0].set_xlabel('Predicted')

# اهمیت ویژگی‌ها
feature_names = ['Form3Home', 'Form5Home', 'Form3Away', 'Form5Away',
                 'C_LTH', 'C_LTA', 'C_VHD', 'C_VAD', 'C_HTB', 'C_PHB',
                 'EloDiff', 'Form5Diff', 'Form3Diff']

importances = xgb_model.feature_importances_
indices = np.argsort(importances)[::-1]

axes[1].bar(range(len(importances)), importances[indices],
           color='green', alpha=0.7)
axes[1].set_title('Feature Importance - XGBoost')
axes[1].set_xticks(range(len(importances)))
axes[1].set_xticklabels([feature_names[i] for i in indices],
                        rotation=45, ha='right')

plt.tight_layout()
plt.savefig('xgb_results.png', dpi=300, bbox_inches='tight')
plt.show()
                

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
import warnings
warnings.filterwarnings('ignore')

# نصب TensorFlow در صورت نیاز
try:
    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import layers
except:
    print("Installing TensorFlow...")
    !pip install tensorflow -q
    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import layers

print("="*60)
print("Neural Network Model")
print("="*60)

# بارگذاری داده‌ها
X_train = np.load('X_train_scaled.npy')
X_test = np.load('X_test_scaled.npy')
y_train = np.load('y_train.npy')
y_test = np.load('y_test.npy')

num_classes = len(np.unique(y_train))  # 3 کلاس
input_dim = X_train.shape[1]           # 13 ویژگی

print(f"\nFeatures: {input_dim}, Classes: {num_classes}")
                

print("\nBuilding Neural Network...")

# ساخت مدل Sequential
model = keras.Sequential([
    # لایه اول: 128 نورون + Dropout
    layers.Dense(128, activation='relu', input_shape=(input_dim,)),
    layers.Dropout(0.3),

    # لایه دوم: 64 نورون + Dropout
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.3),

    # لایه سوم: 32 نورون + Dropout
    layers.Dense(32, activation='relu'),
    layers.Dropout(0.2),

    # لایه خروجی: 3 نورون (یک برای هر کلاس)
    layers.Dense(num_classes, activation='softmax')
])
                

# تنظیمات آموزش
model.compile(
    optimizer='adam',                        # الگوریتم بهینه‌سازی
    loss='sparse_categorical_crossentropy',  # تابع خطا
    metrics=['accuracy']                     # معیار ارزیابی
)
                

print("\nTraining Neural Network...")

# آموزش با 100 epoch
history = model.fit(
    X_train, y_train,
    epochs=100,              # تعداد دور کامل آموزش
    batch_size=32,           # تعداد نمونه در هر batch
    validation_split=0.2,    # 20% از train برای اعتبارسنجی
    verbose=0                # عدم نمایش جزئیات
)
                

# پیش‌بینی
y_pred_proba = model.predict(X_test, verbose=0)
y_pred = np.argmax(y_pred_proba, axis=1)

y_train_pred_proba = model.predict(X_train, verbose=0)
y_train_pred = np.argmax(y_train_pred_proba, axis=1)

# محاسبه دقت
train_acc = accuracy_score(y_train, y_train_pred)
test_acc = accuracy_score(y_test, y_pred)

print(f"\nTrain Accuracy: {train_acc:.4f} ({train_acc*100:.2f}%)")
print(f"Test Accuracy: {test_acc:.4f} ({test_acc*100:.2f}%)")

# گزارش طبقه‌بندی
print("\n" + "="*60)
print("Classification Report:")
print("="*60)
print(classification_report(y_test, y_pred))
                

fig = plt.figure(figsize=(15, 5))

# ماتریس درهم‌ریختگی
ax1 = plt.subplot(1, 3, 1)
cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d', cmap='Purples', ax=ax1)
ax1.set_title('Confusion Matrix - Neural Network')
ax1.set_ylabel('Actual')
ax1.set_xlabel('Predicted')

# نمودار Loss
ax2 = plt.subplot(1, 3, 2)
ax2.plot(history.history['loss'], label='Train Loss', linewidth=2)
ax2.plot(history.history['val_loss'], label='Validation Loss', linewidth=2)
ax2.set_title('Model Loss')
ax2.set_xlabel('Epoch')
ax2.set_ylabel('Loss')
ax2.legend()
ax2.grid(True, alpha=0.3)

# نمودار Accuracy
ax3 = plt.subplot(1, 3, 3)
ax3.plot(history.history['accuracy'], label='Train Accuracy', linewidth=2)
ax3.plot(history.history['val_accuracy'], label='Validation Accuracy', linewidth=2)
ax3.set_title('Model Accuracy')
ax3.set_xlabel('Epoch')
ax3.set_ylabel('Accuracy')
ax3.legend()
ax3.grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('nn_results.png', dpi=300, bbox_inches='tight')
plt.show()
                

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score
import warnings
warnings.filterwarnings('ignore')

print("=" * 60)
print("Part 5: Model Comparison")
print("=" * 60)

# بارگذاری داده‌ها
X_train = np.load('X_train_scaled.npy')
X_test = np.load('X_test_scaled.npy')
y_train = np.load('y_train.npy')
y_test = np.load('y_test.npy')

num_classes = len(np.unique(y_train))

print("\nTraining all models...")
                

print("1. Random Forest...")
from sklearn.ensemble import RandomForestClassifier

rf_model = RandomForestClassifier(
    n_estimators=200,
    max_depth=15,
    random_state=42,
    n_jobs=-1
)
rf_model.fit(X_train, y_train)
rf_pred = rf_model.predict(X_test)
rf_train_pred = rf_model.predict(X_train)
                

print("2. XGBoost...")
try:
    import xgboost as xgb
except:
    !pip install xgboost -q
    import xgboost as xgb

xgb_model = xgb.XGBClassifier(
    n_estimators=200,
    max_depth=6,
    learning_rate=0.1,
    random_state=42,
    eval_metric='mlogloss',
    use_label_encoder=False
)
xgb_model.fit(X_train, y_train)
xgb_pred = xgb_model.predict(X_test)
xgb_train_pred = xgb_model.predict(X_train)
                

print("3. Neural Network...")
try:
    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import layers
except:
    !pip install tensorflow -q
    import tensorflow as tf
    from tensorflow import keras
    from tensorflow.keras import layers

nn_model = keras.Sequential([
    layers.Dense(128, activation='relu', input_shape=(X_train.shape[1],)),
    layers.Dropout(0.3),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.3),
    layers.Dense(32, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(num_classes, activation='softmax')
])

nn_model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)
nn_model.fit(X_train, y_train, epochs=100, batch_size=32,
            validation_split=0.2, verbose=0)

nn_pred = np.argmax(nn_model.predict(X_test, verbose=0), axis=1)
nn_train_pred = np.argmax(nn_model.predict(X_train, verbose=0), axis=1)
                

# تابع محاسبه معیارها
def calc_metrics(y_true, y_pred, name):
    return {
        'Model': name,
        'Accuracy': accuracy_score(y_true, y_pred),
        'Precision': precision_score(y_true, y_pred, average='weighted'),
        'Recall': recall_score(y_true, y_pred, average='weighted'),
        'F1-Score': f1_score(y_true, y_pred, average='weighted')
    }

# محاسبه برای داده تست
test_results = [
    calc_metrics(y_test, rf_pred, 'Random Forest'),
    calc_metrics(y_test, xgb_pred, 'XGBoost'),
    calc_metrics(y_test, nn_pred, 'Neural Network')
]

# محاسبه برای داده آموزش
train_results = [
    calc_metrics(y_train, rf_train_pred, 'Random Forest'),
    calc_metrics(y_train, xgb_train_pred, 'XGBoost'),
    calc_metrics(y_train, nn_train_pred, 'Neural Network')
]

test_df = pd.DataFrame(test_results)
train_df = pd.DataFrame(train_results)
                

print("\n" + "=" * 80)
print("Test Set Results:")
print("=" * 80)
print(test_df.to_string(index=False))

print("\n" + "=" * 80)
print("Train Set Results:")
print("=" * 80)
print(train_df.to_string(index=False))
                

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

metrics = ['Accuracy', 'Precision', 'Recall', 'F1-Score']

for idx, metric in enumerate(metrics):
    ax = axes[idx // 2, idx % 2]

    x = np.arange(len(test_df))
    width = 0.35

    train_vals = train_df[metric].values
    test_vals = test_df[metric].values

    # رسم نمودار میله‌ای
    ax.bar(x - width/2, train_vals, width, label='Train',
           alpha=0.8, color='skyblue')
    ax.bar(x + width/2, test_vals, width, label='Test',
           alpha=0.8, color='orange')

    ax.set_xlabel('Models')
    ax.set_ylabel(metric)
    ax.set_title(f'{metric} Comparison')
    ax.set_xticks(x)
    ax.set_xticklabels(test_df['Model'], rotation=15, ha='right')
    ax.legend()
    ax.grid(True, alpha=0.3, axis='y')

    # اضافه کردن مقادیر روی میله‌ها
    for i, v in enumerate(train_vals):
        ax.text(i - width/2, v + 0.01, f'{v:.3f}',
               ha='center', va='bottom', fontsize=8)
    for i, v in enumerate(test_vals):
        ax.text(i + width/2, v + 0.01, f'{v:.3f}',
               ha='center', va='bottom', fontsize=8)

plt.tight_layout()
plt.savefig('model_comparison.png', dpi=300, bbox_inches='tight')
plt.show()
                

best_idx = test_df['Accuracy'].idxmax()
best_model = test_df.loc[best_idx, 'Model']
best_acc = test_df.loc[best_idx, 'Accuracy']

print("\n" + "=" * 80)
print(f"Best Model: {best_model}")
print(f"Test Accuracy: {best_acc:.4f} ({best_acc * 100:.2f}%)")
print("=" * 80)
                

summary_data = {
    'Metric': ['Train Accuracy', 'Test Accuracy', 'Overfit Gap'],
    'Random Forest': [
        f"{train_df.loc[0, 'Accuracy']:.4f}",
        f"{test_df.loc[0, 'Accuracy']:.4f}",
        f"{(train_df.loc[0, 'Accuracy'] - test_df.loc[0, 'Accuracy']):.4f}"
    ],
    'XGBoost': [
        f"{train_df.loc[1, 'Accuracy']:.4f}",
        f"{test_df.loc[1, 'Accuracy']:.4f}",
        f"{(train_df.loc[1, 'Accuracy'] - test_df.loc[1, 'Accuracy']):.4f}"
    ],
    'Neural Network': [
        f"{train_df.loc[2, 'Accuracy']:.4f}",
        f"{test_df.loc[2, 'Accuracy']:.4f}",
        f"{(train_df.loc[2, 'Accuracy'] - test_df.loc[2, 'Accuracy']):.4f}"
    ]
}

summary_df = pd.DataFrame(summary_data)
print("\nSummary:")
print(summary_df.to_string(index=False))