AI: مقدمة في تعلّم الآلة

IF age > 30 AND browse_count > 3 THEN buy = yes
IF age < 25 AND cart_count > 0 THEN buy = maybe
IF region = "east" AND discount > 20% THEN buy = yes
... (300 قاعدة إضافية لاحقًا) ...

# Rule-based approach: you write the logic
def will_buy_rules(user):
    """Predict purchase using hand-written rules"""
    if user['age'] > 30 and user['browse_count'] > 3:
        return True
    if user['cart_count'] > 0 and user['discount_pct'] > 20:
        return True
    return False

# ML approach: algorithm learns from data
# from sklearn.neighbors import KNeighborsClassifier
# model = KNeighborsClassifier(n_neighbors=5)
# model.fit(X_train, y_train)  # Learns patterns from 100K records
# prediction = model.predict(new_user_data)

# Load the Iris dataset and inspect its structure
from sklearn.datasets import load_iris

iris = load_iris()
print(f"Feature names: {iris.feature_names}")
print(f"Target names:  {list(iris.target_names)}")
print(f"Samples:       {iris.data.shape[0]}")
print(f"Features:      {iris.data.shape[1]}")
print(f"\nFirst 5 samples:")
for i in range(5):
    print(f"  {iris.data[i]} → {iris.target_names[iris.target[i]]}")

Feature names: ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']
Target names:  ['setosa', 'versicolor', 'virginica']
Samples:       150
Features:      4

First 5 samples:
  [5.1 3.5 1.4 0.2] → setosa
  [4.9 3.0 1.4 0.2] → setosa
  [4.7 3.2 1.3 0.2] → setosa
  [4.6 3.1 1.5 0.2] → setosa
  [5.0 3.6 1.4 0.2] → setosa

بيانات أولية ← هندسة الميزات ← ميزات
"ذكر من بكين يبلغ من العمر 25 عامًا" ← [25, 1, 39] (العمر، رمز_الجنس، رمز_المدينة)

model = SomeClassifier(params)    # 1. إنشاء النموذج
model.fit(X_train, y_train)      # 2. تدريب النموذج
model.predict(X_new)             # 3. التنبؤ
model.score(X_test, y_test)      # 4. التقييم

# مصنف KNN: التدريب والتنبؤ
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

# تحميل البيانات وتقسيمها
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, stratify=y
)

# إنشاء النموذج وتدريبه
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)

# التنبؤ
y_pred = knn.predict(X_test)

# التقييم
train_acc = knn.score(X_train, y_train)
test_acc = knn.score(X_test, y_test)
print(f"دقة التدريب: {train_acc:.3f}")
print(f"دقة الاختبار: {test_acc:.3f}")

# التنبؤ بعينة جديدة
import numpy as np
new_sample = np.array([[5.0, 3.4, 1.5, 0.2]])
pred = knn.predict(new_sample)
print(f"الفئة المتوقعة للعينة الجديدة: {load_iris().target_names[pred[0]]}")

Train accuracy: 0.971
Test accuracy:  0.978
New sample predicted class: setosa

# Compare KNN with different k values
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier

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, stratify=y
)

print("=== KNN: Effect of k value ===")
for k in [1, 3, 5, 7, 9, 15, 30]:
    knn = KNeighborsClassifier(n_neighbors=k)
    knn.fit(X_train, y_train)
    train_acc = knn.score(X_train, y_train)
    test_acc = knn.score(X_test, y_test)
    print(f"k={k:2d} | Train: {train_acc:.3f} | Test: {test_acc:.3f}")

=== KNN: Effect of k value ===
k= 1 | Train: 1.000 | Test: 0.956
k= 3 | Train: 0.971 | Test: 0.978
k= 5 | Train: 0.971 | Test: 0.978
k= 7 | Train: 0.971 | Test: 0.978
k= 9 | Train: 0.971 | Test: 0.978
k=15 | Train: 0.971 | Test: 0.978
k=30 | Train: 0.952 | Test: 0.956

# Detailed classification report
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import classification_report

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, stratify=y
)

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train, y_train)
y_pred = knn.predict(X_test)

print("=== Classification Report ===")
print(classification_report(y_test, y_pred, target_names=load_iris().target_names))

=== Classification Report ===
              precision    recall  f1-score   support

      setosa       1.00      1.00      1.00        15
  versicolor       1.00      0.93      0.97        15
   virginica       0.94      1.00      0.97        15

    accuracy                           0.98        45
   macro avg       0.98      0.98      0.98        45
weighted avg       0.98      0.98      0.98        45

# Visualize KNN decision boundaries on Iris (2 features)
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.neighbors import KNeighborsClassifier

iris = load_iris()
X = iris.data[:, :2]  # Use only first 2 features for 2D plot
y = iris.target

knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X, y)

# Create mesh grid for decision boundary
h = 0.02
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))
Z = knn.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)

# Plot
plt.figure(figsize=(8, 6))
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Set1)
scatter = plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.Set1, edgecolors='black')
plt.xlabel('Sepal length (cm)')
plt.ylabel('Sepal width (cm)')
plt.title('KNN (k=5) Decision Boundary on Iris')
plt.legend(handles=scatter.legend_elements()[0], labels=list(iris.target_names))
plt.savefig('knn_decision_boundary.png', dpi=150, bbox_inches='tight')
plt.show()
print("Decision boundary plot saved.")

# ============================================
# Complete ML Workflow: KNN on Iris Dataset
# Step 1-6: Full pipeline with evaluation
# ============================================

import numpy as np
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import (accuracy_score, classification_report,
                             confusion_matrix)

# Step 1: Load data
iris = load_iris()
X, y = iris.data, iris.target
print(f"Step 1 - Data loaded: {X.shape[0]} samples, {X.shape[1]} features")
print(f"  Classes: {list(iris.target_names)}")
print(f"  Class distribution: {np.bincount(y)}")

# Step 2: Split data (70% train, 30% test)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)
print(f"\nStep 2 - Data split: Train={len(X_train)}, Test={len(X_test)}")

# Step 3: Feature scaling (important for KNN!)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
print(f"\nStep 3 - Features scaled (mean≈0, std≈1)")
print(f"  Before scaling - mean: {X_train.mean(axis=0).round(2)}")
print(f"  After scaling  - mean: {X_train_scaled.mean(axis=0).round(2)}")

# Step 4: Train model
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(X_train_scaled, y_train)
print(f"\nStep 4 - Model trained: KNN (k=5)")

# Step 5: Evaluate
y_pred = knn.predict(X_test_scaled)
test_acc = accuracy_score(y_test, y_pred)
print(f"\nStep 5 - Evaluation:")
print(f"  Test accuracy: {test_acc:.3f}")
print(f"\n{classification_report(y_test, y_pred, target_names=iris.target_names)}")
print("Confusion Matrix:")
print(confusion_matrix(y_test, y_pred))

# Step 6: Predict new samples
new_data = np.array([
    [5.1, 3.5, 1.4, 0.2],   # Likely setosa
    [6.7, 3.0, 5.2, 2.3],   # Likely virginica
    [5.9, 3.0, 4.2, 1.5],   # Likely versicolor
])
new_data_scaled = scaler.transform(new_data)
predictions = knn.predict(new_data_scaled)
print("\nStep 6 - New predictions:")
for i, pred in enumerate(predictions):
    print(f"  Sample {i+1} → {iris.target_names[pred]}")

Step 1 - Data loaded: 150 samples, 4 features
  Classes: ['setosa', 'versicolor', 'virginica']
  Class distribution: [50 50 50]

Step 2 - Data split: Train=105, Test=45

Step 3 - Features scaled (mean≈0, std≈1)
  Before scaling - mean: [5.86 3.06 3.78 1.2 ]
  After scaling  - mean: [ 0. -0.  0. -0.]

Step 4 - Model trained: KNN (k=5)

Step 5 - Evaluation:
  Test accuracy: 1.000

              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]]

Step 6 - New predictions:
  Sample 1 → setosa
  Sample 2 → virginica
  Sample 3 → versicolor