import pandas as pd
import numpy as np

# تحميل البيانات من CSV
df = pd.read_csv('dataset.csv')

# التحميل من قاعدة بيانات SQL
from sqlalchemy import create_engine
engine = create_engine('postgresql://user:pass@host/db')
df = pd.read_sql('SELECT * FROM table', engine)

# نظرة عامة أساسية على البيانات
print(f"الشكل: {df.shape}")
print(f"الأعمدة: {df.columns.tolist()}")
print(f"أنواع البيانات:\n{df.dtypes}")
print(f"القيم المفقودة:\n{df.isnull().sum()}")

import matplotlib.pyplot as plt
import seaborn as sns

# الملخص الإحصائي
print(df.describe())

# توزيع الميزات الرقمية
df.hist(figsize=(15, 10), bins=30)
plt.suptitle('توزيعات الميزات')
plt.tight_layout()
plt.show()

# خريطة حرارة الارتباط
plt.figure(figsize=(12, 8))
sns.heatmap(df.corr(), annot=True, cmap='coolwarm', center=0)
plt.title('مصفوفة ارتباط الميزات')
plt.show()

# مخططات الصندوق لاكتشاف القيم الشاذة
fig, axes = plt.subplots(2, 3, figsize=(15, 10))
for idx, col in enumerate(df.select_dtypes(include=[np.number]).columns[:6]):
    ax = axes[idx // 3, idx % 3]
    df.boxplot(column=col, ax=ax)
    ax.set_title(f'مخطط الصندوق: {col}')
plt.tight_layout()
plt.show()

from sklearn.impute import SimpleImputer, KNNImputer
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

# فحص القيم المفقودة
print("القيم المفقودة:")
print(df.isnull().sum())
print(f"\nنسبة الفقدان:")
print((df.isnull().sum() / len(df) * 100).round(2))

# الطريقة 1: التعويض البسيط (المتوسط/الوسيط/المنوال)
mean_imputer = SimpleImputer(strategy='mean')
median_imputer = SimpleImputer(strategy='median')
mode_imputer = SimpleImputer(strategy='most_frequent')

# التطبيق على الأعمدة الرقمية
df_numeric = df.select_dtypes(include=[np.number])
df_numeric_imputed = pd.DataFrame(
    mean_imputer.fit_transform(df_numeric),
    columns=df_numeric.columns
)

# الطريقة 2: تعويض KNN
knn_imputer = KNNImputer(n_neighbors=5)
df_knn_imputed = pd.DataFrame(
    knn_imputer.fit_transform(df_numeric),
    columns=df_numeric.columns
)

# الطريقة 3: MICE (التعويض المتعدد بالمعادلات المتسلسلة)
mice_imputer = IterativeImputer(random_state=42, max_iter=10)
df_mice_imputed = pd.DataFrame(
    mice_imputer.fit_transform(df_numeric),
    columns=df_numeric.columns
)

print("اكتمل التعويض!")

from scipy import stats
from sklearn.ensemble import IsolationForest
from sklearn.neighbors import LocalOutlierFactor

# الطريقة 1: درجة Z
def detect_outliers_zscore(data, threshold=3):
    z_scores = np.abs(stats.zscore(data))
    return z_scores > threshold

# الطريقة 2: طريقة IQR
def detect_outliers_iqr(data):
    Q1 = data.quantile(0.25)
    Q3 = data.quantile(0.75)
    IQR = Q3 - Q1
    lower_bound = Q1 - 1.5 * IQR
    upper_bound = Q3 + 1.5 * IQR
    return (data < lower_bound) | (data > upper_bound)

# الطريقة 3: غابة العزل
isolation_forest = IsolationForest(contamination=0.1, random_state=42)
outliers_if = isolation_forest.fit_predict(df_numeric) == -1

# الطريقة 4: عامل الشذوذ المحلي
lof = LocalOutlierFactor(n_neighbors=20, contamination=0.1)
outliers_lof = lof.fit_predict(df_numeric) == -1

# معالجة القيم الشاذة
# الخيار 1: الإزالة
df_clean = df[~outliers_if]

# الخيار 2: التحديد (Winsorization)
for col in df_numeric.columns:
    Q1, Q3 = df[col].quantile([0.25, 0.75])
    IQR = Q3 - Q1
    df[col] = df[col].clip(Q1 - 1.5*IQR, Q3 + 1.5*IQR)

# الخيار 3: التحويل (اللوغاريتم، الجذر التربيعي)
df['log_feature'] = np.log1p(df['feature'])

from sklearn.preprocessing import (
    StandardScaler, MinMaxScaler, RobustScaler,
    MaxAbsScaler, PowerTransformer, QuantileTransformer
)

# التوحيد القياسي (تطبيع درجة Z)
standard_scaler = StandardScaler()
df_standardized = standard_scaler.fit_transform(df_numeric)

# قياس Min-Max
minmax_scaler = MinMaxScaler(feature_range=(0, 1))
df_minmax = minmax_scaler.fit_transform(df_numeric)

# القياس القوي (مقاوم للقيم الشاذة)
robust_scaler = RobustScaler()
df_robust = robust_scaler.fit_transform(df_numeric)

# تحويل القوة (Box-Cox أو Yeo-Johnson)
power_transformer = PowerTransformer(method='yeo-johnson')
df_power = power_transformer.fit_transform(df_numeric)

# تحويل الكميات (توزيع منتظم أو طبيعي)
quantile_transformer = QuantileTransformer(output_distribution='normal')
df_quantile = quantile_transformer.fit_transform(df_numeric)

from sklearn.preprocessing import LabelEncoder, OneHotEncoder, OrdinalEncoder
import category_encoders as ce

# بيانات فئوية نموذجية
df_cat = pd.DataFrame({
    'color': ['red', 'blue', 'green', 'red', 'blue'],
    'size': ['small', 'medium', 'large', 'medium', 'small'],
    'brand': ['A', 'B', 'C', 'A', 'D']
})

# 1. ترميز التسمية
label_encoder = LabelEncoder()
df_cat['color_encoded'] = label_encoder.fit_transform(df_cat['color'])

# 2. الترميز الأحادي الساخن
onehot_encoder = OneHotEncoder(sparse=False, drop='first')
color_onehot = onehot_encoder.fit_transform(df_cat[['color']])

# باستخدام pandas get_dummies (طريقة أبسط)
df_onehot = pd.get_dummies(df_cat, columns=['color'], drop_first=True)

# 3. الترميز الترتيبي (بترتيب مخصص)
size_order = ['small', 'medium', 'large']
ordinal_encoder = OrdinalEncoder(categories=[size_order])
df_cat['size_encoded'] = ordinal_encoder.fit_transform(df_cat[['size']])

# 4. ترميز الهدف
target_encoder = ce.TargetEncoder(cols=['brand'])
df_cat['brand_target'] = target_encoder.fit_transform(df_cat['brand'], y_target)

# 5. الترميز الثنائي
binary_encoder = ce.BinaryEncoder(cols=['brand'])
df_binary = binary_encoder.fit_transform(df_cat)

# 6. ترميز التكرار
freq_map = df_cat['color'].value_counts().to_dict()
df_cat['color_freq'] = df_cat['color'].map(freq_map)

from sklearn.preprocessing import PolynomialFeatures
from sklearn.feature_extraction.text import TfidfVectorizer

# 1. ميزات متعددة الحدود
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(df_numeric)

# 2. ميزات التاريخ/الوقت
df['datetime'] = pd.to_datetime(df['date'])
df['year'] = df['datetime'].dt.year
df['month'] = df['datetime'].dt.month
df['day'] = df['datetime'].dt.day
df['day_of_week'] = df['datetime'].dt.dayofweek
df['is_weekend'] = df['day_of_week'].isin([5, 6]).astype(int)
df['quarter'] = df['datetime'].dt.quarter

# الترميز الدوري للشهر (يلتقط استمرارية يناير-ديسمبر)
df['month_sin'] = np.sin(2 * np.pi * df['month'] / 12)
df['month_cos'] = np.cos(2 * np.pi * df['month'] / 12)

# 3. التجميع
df['age_group'] = pd.cut(df['age'], 
                         bins=[0, 18, 35, 50, 65, 100],
                         labels=['طفل', 'شاب', 'بالغ', 'متوسط العمر', 'كبير'])

# 4. ميزات النسب
df['price_per_sqft'] = df['price'] / df['square_feet']
df['income_to_debt_ratio'] = df['income'] / (df['debt'] + 1)

# 5. ميزات التجميع
df['avg_purchase_by_customer'] = df.groupby('customer_id')['amount'].transform('mean')
df['total_orders_by_customer'] = df.groupby('customer_id')['order_id'].transform('count')

# 6. ميزات النص
tfidf = TfidfVectorizer(max_features=100)
text_features = tfidf.fit_transform(df['text_column'])

from sklearn.feature_selection import (
    VarianceThreshold, SelectKBest, chi2, f_classif,
    RFE, SelectFromModel, mutual_info_classif
)
from sklearn.ensemble import RandomForestClassifier
from sklearn.decomposition import PCA
from sklearn.linear_model import LassoCV

# 1. عتبة التباين (إزالة الميزات منخفضة التباين)
variance_selector = VarianceThreshold(threshold=0.01)
X_high_variance = variance_selector.fit_transform(X)

# 2. الاختيار القائم على الارتباط
corr_matrix = df_numeric.corr().abs()
upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k=1).astype(bool))
to_drop = [column for column in upper.columns if any(upper[column] > 0.95)]
df_reduced = df_numeric.drop(to_drop, axis=1)

# 3. SelectKBest مع chi-squared
kbest_selector = SelectKBest(score_func=chi2, k=10)
X_kbest = kbest_selector.fit_transform(X, y)
selected_features = X.columns[kbest_selector.get_support()]

# 4. الإزالة التكرارية للميزات
rf = RandomForestClassifier(n_estimators=100, random_state=42)
rfe = RFE(estimator=rf, n_features_to_select=10)
X_rfe = rfe.fit_transform(X, y)
ranking = rfe.ranking_

# 5. أهمية الميزات القائمة على الأشجار
rf.fit(X, y)
importances = pd.DataFrame({
    'feature': X.columns,
    'importance': rf.feature_importances_
}).sort_values('importance', ascending=False)

# 6. LASSO لاختيار الميزات
lasso = LassoCV(cv=5, random_state=42)
lasso.fit(X, y)
selected_by_lasso = X.columns[lasso.coef_ != 0]

# 7. PCA لتقليل الأبعاد
pca = PCA(n_components=0.95)  # الحفاظ على 95% من التباين
X_pca = pca.fit_transform(X)
print(f"تم التقليل من {X.shape[1]} إلى {X_pca.shape[1]} مكون")

from imblearn.over_sampling import SMOTE, ADASYN, RandomOverSampler
from imblearn.under_sampling import RandomUnderSampler, TomekLinks
from imblearn.combine import SMOTEENN, SMOTETomek
from collections import Counter

# فحص توزيع الفئات
print(f"التوزيع الأصلي: {Counter(y)}")

# 1. الإفراط العشوائي في العينات
ros = RandomOverSampler(random_state=42)
X_ros, y_ros = ros.fit_resample(X, y)
print(f"بعد الإفراط العشوائي: {Counter(y_ros)}")

# 2. SMOTE
smote = SMOTE(random_state=42, k_neighbors=5)
X_smote, y_smote = smote.fit_resample(X, y)
print(f"بعد SMOTE: {Counter(y_smote)}")

# 3. ADASYN
adasyn = ADASYN(random_state=42)
X_adasyn, y_adasyn = adasyn.fit_resample(X, y)
print(f"بعد ADASYN: {Counter(y_adasyn)}")

# 4. نقص العينات العشوائي
rus = RandomUnderSampler(random_state=42)
X_rus, y_rus = rus.fit_resample(X, y)
print(f"بعد نقص العينات العشوائي: {Counter(y_rus)}")

# 5. SMOTEENN (التركيب)
smoteenn = SMOTEENN(random_state=42)
X_smoteenn, y_smoteenn = smoteenn.fit_resample(X, y)
print(f"بعد SMOTEENN: {Counter(y_smoteenn)}")

# 6. أوزان الفئات في النموذج
from sklearn.ensemble import RandomForestClassifier
rf_weighted = RandomForestClassifier(
    class_weight='balanced',  # يضبط الأوزان تلقائياً
    random_state=42
)
rf_weighted.fit(X, y)

from sklearn.model_selection import (
    train_test_split, KFold, StratifiedKFold,
    TimeSeriesSplit, GroupKFold, cross_val_score
)

# 1. تقسيم بسيط للتدريب/الاختبار
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 2. تقسيم ثلاثي (تدريب/تحقق/اختبار)
X_temp, X_test, y_temp, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)
X_train, X_val, y_train, y_val = train_test_split(
    X_temp, y_temp, test_size=0.25, random_state=42, stratify=y_temp
)  # 0.25 من 80% = 20% من الإجمالي

# 3. التحقق المتقاطع K-Fold
kfold = KFold(n_splits=5, shuffle=True, random_state=42)
for fold, (train_idx, val_idx) in enumerate(kfold.split(X)):
    X_train_fold = X.iloc[train_idx]
    X_val_fold = X.iloc[val_idx]
    print(f"الطية {fold+1}: حجم التدريب = {len(train_idx)}, حجم التحقق = {len(val_idx)}")

# 4. K-Fold الطبقي (يحافظ على توزيع الفئات)
strat_kfold = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scores = cross_val_score(model, X, y, cv=strat_kfold, scoring='accuracy')
print(f"درجات CV: {scores}")
print(f"المتوسط: {scores.mean():.4f} (+/- {scores.std()*2:.4f})")

# 5. تقسيم السلسلة الزمنية
tscv = TimeSeriesSplit(n_splits=5)
for fold, (train_idx, val_idx) in enumerate(tscv.split(X)):
    print(f"الطية {fold+1}: تدريب = {train_idx[0]}-{train_idx[-1]}, "
          f"تحقق = {val_idx[0]}-{val_idx[-1]}")

pip install pandas numpy scikit-learn imbalanced-learn category_encoders \
            matplotlib seaborn plotly missingno scipy feature-engine

from sklearn.pipeline import Pipeline
from sklearn.compose import ColumnTransformer
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.impute import SimpleImputer
from sklearn.feature_selection import SelectKBest, f_classif

# تحديد أنواع الأعمدة
numeric_features = ['age', 'income', 'balance']
categorical_features = ['gender', 'occupation', 'region']

# خط أنابيب المعالجة المسبقة الرقمية
numeric_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='median')),
    ('scaler', StandardScaler())
])

# خط أنابيب المعالجة المسبقة الفئوية
categorical_transformer = Pipeline(steps=[
    ('imputer', SimpleImputer(strategy='most_frequent')),
    ('encoder', OneHotEncoder(drop='first', handle_unknown='ignore'))
])

# دمج خطوات المعالجة المسبقة
preprocessor = ColumnTransformer(
    transformers=[
        ('num', numeric_transformer, numeric_features),
        ('cat', categorical_transformer, categorical_features)
    ],
    remainder='drop'
)

# خط الأنابيب الكامل مع النموذج
from sklearn.ensemble import RandomForestClassifier

full_pipeline = Pipeline(steps=[
    ('preprocessor', preprocessor),
    ('feature_selection', SelectKBest(f_classif, k=20)),
    ('classifier', RandomForestClassifier(n_estimators=100, random_state=42))
])

# التدريب والتنبؤ
full_pipeline.fit(X_train, y_train)
y_pred = full_pipeline.predict(X_test)

# التقييم
from sklearn.metrics import classification_report
print(classification_report(y_test, y_pred))