AI: التعلم تحت الإشراف

# Linear vs Decision Tree on simple rental data
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor

area = np.array([30, 50, 70, 80, 100, 120, 150, 180, 200, 250]).reshape(-1, 1)
rent = np.array([1800, 3000, 4200, 5000, 6000, 6800, 7500, 7900, 8100, 8300])

lr = LinearRegression().fit(area, rent)
dt = DecisionTreeRegressor(max_depth=3, random_state=42).fit(area, rent)

print("Area | Actual | LinearPred | TreePred")
for i in range(len(area)):
    a = area[i, 0]
    print(f"{a:5.0f} | {rent[i]:6.0f} | {lr.predict([[a]])[0]:10.0f} | {dt.predict([[a]])[0]:8.0f}")

Area | Actual | LinearPred | TreePred
   30 |   1800 |       2187 |     1800
   50 |   3000 |       2780 |     3000
   70 |   4200 |       3374 |     4200
   80 |   5000 |       3670 |     5000
  100 |   6000 |       4264 |     6000
  120 |   6800 |       4857 |     6800
  150 |   7500 |       5748 |     7500
  180 |   7900 |       6639 |     7900
  200 |   8100 |       7233 |     8100
  250 |   8300 |       8716 |     8300

y = w₁x₁ + w₂x₂ + ... + wₙxₙ + b

حيث:
  w = الأوزان (الميل لكل سمة)
  b = الانحياز (الثابت)
  
الهدف: إيجاد w و b اللتين تصغران Σ(yᵢ - ŷᵢ)²
      أي، تصغير مجموع مربعات الأخطاء

# انحدار خطي للتنبؤ بسعر المنزل
from sklearn.linear_model import LinearRegression
import numpy as np

# السمة: المساحة (متر مربع)، التسمية: السعر (دولار أمريكي)
X = np.array([[50], [60], [80], [100], [120], [150]])
y = np.array([150000, 180000, 240000, 300000, 360000, 450000])

model = LinearRegression()
model.fit(X, y)

print(f"الوزن (w): {model.coef_[0]:.2f} دولار/م²")
print(f"الانحياز (b):   {model.intercept_:.2f} دولار")
print(f"\nالصيغة: السعر = {model.coef_[0]:.2f} * المساحة + {model.intercept_:.2f}")

# التنبؤ
new_area = np.array([[90]])
predicted = model.predict(new_area)
print(f"\nالسعر المتوقع لمساحة 90 م²: ${predicted[0]:,.0f}")

الوزن (w): 3000.00 دولار/م²
الانحياز (b):   0.00 دولار

الصيغة: السعر = 3000.00 * المساحة + 0.00

السعر المتوقع لمساحة 90 م²: $270,000

y = w₁ * x + w₂ * x² + b   ← لا يزال انحدارًا خطيًا!
                                 (خطي في الأوزان w، ليس في السمة x)

# رسم خط الانحدار ونقاط الانتشار
import numpy as np
from sklearn.linear_model import LinearRegression
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt

X = np.array([[30], [50], [70], [90], [110], [130], [150], [170]])
y = np.array([90000, 150000, 210000, 270000, 330000, 390000, 450000, 510000])

model = LinearRegression()
model.fit(X, y)

x_line = np.linspace(20, 180, 100).reshape(-1, 1)
y_line = model.predict(x_line)

plt.figure(figsize=(8, 5))
plt.scatter(X, y, color='steelblue', s=60, label='بيانات حقيقية')
plt.plot(x_line, y_line, color='orangered', linewidth=2, label='خط الانحدار')
plt.xlabel('المساحة (م²)')
plt.ylabel('السعر (دولار أمريكي)')
plt.title('انحدار خطي: سعر المنزل مقابل المساحة')
plt.legend()
plt.tight_layout()
plt.savefig('regression_line.png', dpi=100)
print("تم حفظ الرسم في regression_line.png")

تم حفظ الرسم في regression_line.png

# Decision Tree classification on Iris dataset
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score, classification_report

iris = load_iris()
X, y = iris.data, iris.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

tree = DecisionTreeClassifier(max_depth=3, random_state=42)
tree.fit(X_train, y_train)

y_pred = tree.predict(X_test)

print(f"Training accuracy: {tree.score(X_train, y_train):.3f}")
print(f"Test accuracy:     {accuracy_score(y_test, y_pred):.3f}")
print(f"\nFeature importances:")
for name, imp in zip(iris.feature_names, tree.feature_importances_):
    print(f"  {name}: {imp:.3f}")

Training accuracy: 1.000
Test accuracy:     1.000

Feature importances:
  sepal length (cm): 0.000
  sepal width (cm): 0.000
  petal length (cm): 0.560
  petal width (cm): 0.440

# Confusion matrix and derived metrics
from sklearn.metrics import confusion_matrix, precision_score, recall_score, f1_score, accuracy_score
import numpy as np

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

cm = confusion_matrix(y_true, y_pred)
print("Confusion Matrix:")
print(f"              Predicted Neg  Predicted Pos")
print(f"Actual Neg      {cm[0][0]:3d} (TN)      {cm[0][1]:3d} (FP)")
print(f"Actual Pos      {cm[1][0]:3d} (FN)      {cm[1][1]:3d} (TP)")

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(f"\nAccuracy:  {acc:.3f} = (TP+TN) / Total = ({cm[1][1]}+{cm[0][0]}) / {len(y_true)}")
print(f"Precision: {prec:.3f} = TP / (TP+FP) = {cm[1][1]} / ({cm[1][1]}+{cm[0][1]})")
print(f"Recall:    {rec:.3f} = TP / (TP+FN) = {cm[1][1]} / ({cm[1][1]}+{cm[1][0]})")
print(f"F1 Score:  {f1:.3f} = 2*P*R / (P+R)")

Confusion Matrix:
              Predicted Neg  Predicted Pos
Actual Neg        5 (TN)        2 (FP)
Actual Pos        2 (FN)        6 (TP)

Accuracy:  0.733 = (TP+TN) / Total = (6+5) / 15
Precision: 0.750 = TP / (TP+FP) = 6 / (6+2)
Recall:    0.750 = TP / (TP+FN) = 6 / (6+2)
F1 Score:  0.750 = 2*P*R / (P+R)

# حساب مقاييس الانحدار
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

y_true = np.array([200000, 300000, 250000, 400000, 350000])
y_pred = np.array([210000, 290000, 260000, 380000, 340000])

mae = mean_absolute_error(y_true, y_pred)
mse = mean_squared_error(y_true, y_pred)
rmse = np.sqrt(mse)
r2 = r2_score(y_true, y_pred)

print("=== مقاييس الانحدار ===")
print(f"MAE:  ${mae:,.0f}  — متوسط الخطأ المطلق")
print(f"MSE:  ${mse:,.0f}  — متوسط مربع الخطأ")
print(f"RMSE: ${rmse:,.0f}  — جذر MSE (نفس وحدة السعر)")
print(f"R²:   {r2:.4f}  — نسبة التباين المُفسَّر")

=== مقاييس الانحدار ===
MAE:  $12,000  — متوسط الخطأ المطلق
MSE:  $170,000,000  — متوسط مربع الخطأ
RMSE: $13,038  — جذر MSE (نفس وحدة السعر)
RMSE: $13,038  — جذر MSE (نفس وحدة السعر)
R²:   0.9620  — نسبة التباين المُفسَّر

R² = 1  → تنبؤات مثالية
R² = 0  → لا أفضل من تخمين المتوسط
R² < 0  → أسوأ من تخمين المتوسط (جداً!)

# Feature scaling comparison
from sklearn.preprocessing import MinMaxScaler, StandardScaler
import numpy as np

data = np.array([[30, 1, 20000],
                 [80, 3, 60000],
                 [150, 5, 120000],
                 [250, 6, 200000]])

mm = MinMaxScaler()
ss = StandardScaler()

print("Min-Max scaled:\n", np.round(mm.fit_transform(data), 3))
print("\nStandard scaled:\n", np.round(ss.fit_transform(data), 3))

Min-Max scaled:
 [[0.     0.     0.    ]
 [0.235  0.4    0.222 ]
 [0.706  0.8    0.556 ]
 [1.     1.     1.    ]]

Standard scaled:
 [[-1.183 -1.183 -1.183]
 [-0.394 -0.394 -0.394]
 [ 0.789  0.394  0.394]
 [ 1.577  1.577  1.577]]

# ============================================
# Comprehensive: Linear Regression vs Decision Tree
# Dataset: California Housing
# ============================================
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
import numpy as np

# Step 1: Load data
housing = fetch_california_housing()
X, y = housing.data, housing.target
print(f"Dataset: {X.shape[0]} samples, {X.shape[1]} features")
print(f"Features: {list(housing.feature_names)}")
print(f"Target range: [{y.min():.2f}, {y.max():.2f}] (unit: $100,000)")

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

# Step 3: Feature scaling (for linear regression)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Step 4: Train both models
lr = LinearRegression()
lr.fit(X_train_scaled, y_train)

dt = DecisionTreeRegressor(max_depth=8, random_state=42)
dt.fit(X_train, y_train)  # Decision tree doesn't need scaling

# Step 5: Predict
y_pred_lr = lr.predict(X_test_scaled)
y_pred_dt = dt.predict(X_test)

# Step 6: Evaluate and compare
print("\n" + "=" * 50)
print(f"{'Metric':<12} {'Linear Reg':>12} {'Decision Tree':>14}")
print("=" * 50)

for name, pred in [("Linear Reg", y_pred_lr), ("Decision Tree", y_pred_dt)]:
    mae = mean_absolute_error(y_test, pred)
    rmse = np.sqrt(mean_squared_error(y_test, pred))
    r2 = r2_score(y_test, pred)

print(f"{'MAE':<12} {mean_absolute_error(y_test, y_pred_lr):>12.4f} {mean_absolute_error(y_test, y_pred_dt):>14.4f}")
print(f"{'RMSE':<12} {np.sqrt(mean_squared_error(y_test, y_pred_lr)):>12.4f} {np.sqrt(mean_squared_error(y_test, y_pred_dt)):>14.4f}")
print(f"{'R²':<12} {r2_score(y_test, y_pred_lr):>12.4f} {r2_score(y_test, y_pred_dt):>14.4f}")
print("=" * 50)

# Step 7: Feature importance (linear regression coefficients vs tree importances)
print("\nFeature Importance Comparison:")
print(f"{'Feature':<22} {'LR |Coef|':>10} {'DT Import':>10}")
for i, fname in enumerate(housing.feature_names):
    lr_imp = abs(lr.coef_[i])
    dt_imp = dt.feature_importances_[i]
    print(f"{fname:<22} {lr_imp:>10.4f} {dt_imp:>10.4f}")

Dataset: 20640 samples, 8 features
Features: ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']
Target range: [0.15, 5.00] (unit: $100,000)

Train: 16512 | Test: 4128

==================================================
Metric          Linear Reg   Decision Tree
==================================================
MAE                0.5252        0.4251
RMSE               0.7456        0.6052
R²                 0.5757        0.7210
==================================================

Feature Importance Comparison:
Feature                 LR |Coef|  DT Import
MedInc                     0.8269     0.5281
HouseAge                   0.1771     0.0521
AveRooms                   0.4283     0.0471
AveBedrms                  0.1447     0.0184
Population                 0.0021     0.0134
AveOccup                   0.0447     0.0481
Latitude                   0.8740     0.1434
Longitude                  0.8586     0.1494