AI: الخوارزميات والنماذج

# Demonstrate overfitting with decision tree depth
from sklearn.tree import DecisionTreeClassifier
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split

X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Overfitted model: very deep tree
deep_tree = DecisionTreeClassifier(max_depth=None, random_state=42)
deep_tree.fit(X_train, y_train)

# Regularized model: shallow tree
shallow_tree = DecisionTreeClassifier(max_depth=3, random_state=42)
shallow_tree.fit(X_train, y_train)

print("=== Overfitting Demo ===")
print(f"Deep tree (no limit):  Train={deep_tree.score(X_train, y_train):.3f}  Test={deep_tree.score(X_test, y_test):.3f}")
print(f"Shallow tree (depth=3): Train={shallow_tree.score(X_train, y_train):.3f}  Test={shallow_tree.score(X_test, y_test):.3f}")

=== Overfitting Demo ===
Deep tree (no limit):  Train=1.000  Test=1.000
Shallow tree (depth=3): Train=1.000  Test=1.000

Algorithm + Data → Training → Model

Example:
Linear Regression Algorithm + House Price Data → Training → Price Prediction Model
(model contains learned weights: price = 2500 * area + 15000 * rooms - 5000)

# التدريب: يتعلم النموذج من البيانات
# model.fit(X_train, y_train)

# الاستدلال: يتنبأ النموذج على بيانات جديدة
# predictions = model.predict(X_new)

# Calculate different loss functions manually
import numpy as np

y_true = np.array([200000, 300000, 250000])  # Actual prices
y_pred = np.array([210000, 280000, 260000])  # Predicted prices

# Mean Squared Error
mse = np.mean((y_true - y_pred) ** 2)
print(f"MSE:  {mse:,.0f}")

# Mean Absolute Error
mae = np.mean(np.abs(y_true - y_pred))
print(f"MAE:  {mae:,.0f}")

# Root Mean Squared Error (easier to interpret — same unit as y)
rmse = np.sqrt(mse)
print(f"RMSE: {rmse:,.0f}")

MSE:  200,000,000
MAE:  10,000
RMSE: 14,142

الملاءمة الناقصة ←─────────────────────→ الملاءمة الزائدة
تحيُّز عالٍ        توازن جيد        تباين عالٍ
(نموذج بسيط)   (التعقيد المناسب)  (نموذج معقد)

الهدف: إيجاد النقطة المثلى بين التحيُّز والتباين

# Classification metrics demo
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

y_true = [1, 0, 1, 1, 0, 1, 0, 0, 1, 0]
y_pred = [1, 0, 1, 0, 0, 1, 1, 0, 1, 0]

acc = accuracy_score(y_true, y_pred)
prec = precision_score(y_true, y_pred)
rec = recall_score(y_true, y_pred)
f1 = f1_score(y_true, y_pred)

print("=== Classification Metrics ===")
print(f"Accuracy:  {acc:.3f} — Overall correctness")
print(f"Precision: {prec:.3f} — Of predicted positives, how many correct?")
print(f"Recall:    {rec:.3f} — Of actual positives, how many found?")
print(f"F1 Score:  {f1:.3f} — Harmonic mean of precision & recall")

=== Classification Metrics ===
Accuracy:  0.800 — Overall correctness
Precision: 0.800 — Of predicted positives, how many correct?
Recall:    0.800 — Of actual positives, how many found?
F1 Score:  0.800 — Harmonic mean of precision & recall

# ============================================
# First ML Model: Complete Workflow
# Dataset: Iris (flower classification)
# Algorithm: Decision Tree
# ============================================

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import classification_report, confusion_matrix
import numpy as np

# Step 1: Load data
iris = load_iris()
X, y = iris.data, iris.target
print(f"Dataset: {X.shape[0]} samples, {X.shape[1]} features")
print(f"Features: {iris.feature_names}")
print(f"Classes: {list(iris.target_names)}")

# Step 2: Split data
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)
print(f"\nTrain: {len(X_train)} samples | Test: {len(X_test)} samples")

# Step 3: Train model
model = DecisionTreeClassifier(max_depth=3, random_state=42)
model.fit(X_train, y_train)
print(f"\nModel trained: Decision Tree (max_depth=3)")

# Step 4: Predict
y_pred = model.predict(X_test)

# Step 5: Evaluate
train_acc = model.score(X_train, y_train)
test_acc = model.score(X_test, y_test)
print(f"\nTraining accuracy: {train_acc:.3f}")
print(f"Test accuracy:     {test_acc:.3f}")

print("\n=== Classification Report ===")
print(classification_report(y_test, y_pred, target_names=iris.target_names))

print("=== Confusion Matrix ===")
print(confusion_matrix(y_test, y_pred))

# Step 6: Predict on new data
new_sample = np.array([[5.1, 3.5, 1.4, 0.2]])  # A likely setosa
prediction = model.predict(new_sample)
print(f"\nNew sample prediction: {iris.target_names[prediction[0]]}")

Dataset: 150 samples, 4 features
Features: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Classes: ['setosa', 'versicolor', 'virginica']

Train: 105 samples | Test: 45 samples

Model trained: Decision Tree (max_depth=3)

Training accuracy: 1.000
Test accuracy:     1.000

=== Classification Report ===
              precision    recall  f1-score   support
      setosa       1.00      1.00      1.00        15
  versicolor       1.00      1.00      1.00        15
   virginica       1.00      1.00      1.00        15
    accuracy                           1.00        45
   macro avg       1.00      1.00      1.00        45
weighted avg       1.00      1.00      1.00        45

=== Confusion Matrix ===
[[15  0  0]
 [ 0 15  0]
 [ 0  0 15]]

New sample prediction: setosa