آموزش کامل اموزش ساخت رگرسیون خطی و ساخت الگوریتم از در پایتون — از صفر تا حرفه‌ای | + تحلیل متدها و پارامترها

اموزش کامل ساخت رگرسیون خطی و ساخت الگوریتم از صفر تا صد در پایتون همه سطوح
parsakarimidev.ir

آموزش کامل اموزش ساخت رگرسیون خطی و ساخت الگوریتم از در پایتون — از صفر تا حرفه‌ای | + تحلیل متدها و پارامترها

اموزش کامل ساخت رگرسیون خطی و ساخت الگوریتم از صفر تا صد در پایتونمفهوم سطح: همه سطوح 1405/08/21

آموزش کامل ساخت رگرسیون خطی و ساخت الگوریتم از صفر تا صد در پایتون


⚡ خلاصه سریع — اصل کاری‌ها

این‌ها مهم‌ترین چیزهایی هستن که اگه هیچی ندونی، فقط اینا رو بدونی کافیه:

  • نکته ۱: رگرسیون خطی یعنی کشیدن بهترین خط از بین نقاط داده‌ها؛ فرمولش y = w·x + b است که w وزن (شیب) و b بایاس (عرض از مبدأ) نام دارد.
  • نکته ۲: هدف آموزش، کمینه‌سازی تابع هزینه (MSE) است؛ یعنی میانگین مربعات خطا بین پیش‌بینی و مقدار واقعی.
  • نکته ۳: دو راه اصلی برای یادگیری پارامترها وجود دارد: معادله نرمال (مستقیم و تحلیلی) و گرادیان کاهشی (تکرارشونده و تدریجی).
  • نکته ۴: در گرادیان کاهشی، نرخ یادگیری (learning_rate) حیاتی است؛ خیلی بزرگ ⇒ واگرایی، خیلی کوچک ⇒ آموزش کُند.
  • نکته ۵: همیشه قبل از آموزش، داده‌ها را استانداردسازی (Scale) کن و بعد از آموزش با R² و MSE و نه فقط خطای خام، مدل را ارزیابی کن.

۳ اشتباه رایج:

  1. استفاده از نرخ یادگیری نامناسب (مثلاً ۰٫۱ برای داده‌های استاندارد نشده) که باعث واگرایی یا گیر کردن در نقطه‌اشتباه می‌شود.
  2. مقیاس‌ندادن فیچرها، مخصوصاً وقتی محدوده متغیرها خیلی متفاوت است (مثلاً مساحت خانه به فوت vs تعداد اتاق)؛ گرادیان کاهشی به شدت آسیب می‌بیند.
  3. ارزیابی روی داده آموزش و فریب خوردن از نمره بالا؛ باید با train_test_split داده‌ها را جدا کنی و روی داده تست امتحان کنی.

اگر فقط ۵ دقیقه وقت داری:

  1. کلاس LinearRegressionScratch بخش ۵ را کپی کن و با داده‌های ساده y = 3x + 2 تستش کن.
  2. مفهوم MSE و گرادیان کاهشی را از بخش ۴.۳ و ۴.۴ بخوان.
  3. کد واقعی بخش ۶ (پیش‌بینی قیمت مسکن) را اجرا کن و خروجی R² را ببینی.

۱. مقدمه

۱.۱ رگرسیون خطی چیست؟

فرض کن نقشه‌ای از قیمت خانه‌های یک محله داری؛ محور افقی متراژ خانه و محور عمودی قیمت است. قطرهای از نقاط روی کاغذ پخش شده. رگرسیون خطی سعی می‌کند یک خط مستقیم از بین این نقاط بکشد که «بهترین» نشان‌دهنده روند کلی باشد. بعداً با داشتن متراژ هر خانه‌ی جدید، می‌توانی قیمت تقریبی‌اش را از روی خط پیدا کنی.

به زبان ریاضی، مدل این است:

\(\hat{y} = w_1 x_1 + w_2 x_2 + \dots + w_n x_n + b\)

  • \(\hat{y}\): مقدار پیش‌بینی‌شده
  • \(x_i\): ویژگی‌های ورودی (فیچرها)
  • \(w_i\): وزن هر ویژگی (اهمیت آن فیچر)
  • \(b\): بایاس یا نقطه شروع

۱.۲ کجا کاربرد دارد؟

کاربرد توضیح
پیش‌بینی قیمت ملک بر اساس مساحت، محله، سال ساخت
پیش‌بینی فروش بر اساس بودجه تبلیغات، فصل، قیمت
تحلیل ریسک بیمه بر اساس سن، سابقه تصادف
اقتصاد پیش‌بینی تورم از نرخ ارز و عرضه پول
پزشکی پیش‌بینی فشار خون از وزن و سن

۱.۳ چرا «از صفر» بسازیمش؟

شاید بپرسی: «کتابخانه scikit-learn با یک خط کد همین کار را نمی‌کند؟» بله، اما:

  1. درک عمیق: وقتی خودت fit را بنویسی، می‌فهمی پشت صحنه چه می‌گذرد.
  2. توانایی تنظیم: مهندس واقعی باید بداند چرا مدلش ضعیف است، نه فقط اینکه ضعیف است.
  3. مصاحبه‌ها: در مصاحبه‌های دانشمند داده، «پیاده‌سازی گرادیان کاهشی از صفر» یک سؤال کلاسیک است.
  4. کنترل کامل: می‌توانی تغییرات سفارشی انجام دهی (مانند وزن‌دهی نمونه‌ها، هزینه سفارشی).

۲. پیش‌نیازها

۲.۱ دانشی که باید داشته باشی

موضوع سطح لازم مثال
پایتون پایه متوسط تابع، کلاس، لیست، dict
NumPy مبتدی-متوسط آرایه، عملیات برداری، reshape
جبر خطی مبتدی ضرب ماتریسی، ترانهاده
حسابان مبتدی مشتق جزئی (برای گرادیان)
آمار مبتدی میانگین، واریانس

۲.۲ اگر جبر خطی‌ات ضعیف است — ۳ دقیقه خلاصه

یک بردار لیستی از اعداد است: [1, 2, 3]. یک ماتریس، جدولی از اعداد. ضرب ماتریس در بردار یعنی ترکیب خطی ستون‌ها. تمام کار ما این است:

\(X \cdot w = \hat{y}\)

که X ماتریس نمونه‌ها، w بردار وزن‌ها و hat y بردار پیش‌بینی‌هاست. همین!


۳. نصب و راه‌اندازی

۳.۱ نصب پیش‌نیازها

# ساخت محیط مجازی (اختیاری ولی توصیه‌شده)
python -m venv ml_env
source ml_env/bin/activate  # لینوکس/مک
# ml_env\Scripts\activate   # ویندوز

# نصب کتابخانه‌ها
pip install numpy pandas matplotlib scikit-learn

۳.۲ بررسی نصب

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import sklearn

print("NumPy:", np.__version__)
print("Pandas:", pd.__version__)
print("Scikit-Learn:", sklearn.__version__)

۳.۳ تنظیمات اولیه برای نمونه‌های قابل تکرار

import numpy as np
np.random.seed(42)  # تا هر بار اجرا، نتایج یکسان باشد

۴. مفاهیم پایه

۴.۱ معادله خط

خط راست در دو بعد با فرمول y = mx + c (یا y = wx + b) مشخص می‌شود:

  • w (وزن/شیب): به ازای یک واحد افزایش در x، y چند واحد افزایش می‌یابد.
  • b (بایاس): مقدار y وقتی x = 0 است؛ یعنی نقطه برخورد خط با محور عمودی.

تمرین ذهنی: اگه خط y = 3x + 2 را داشته باشیم و x = 5 باشد، y = 17 می‌شود. همین!

۴.۲ تابع هزینه — MSE (Mean Squared Error)

وقتی مدل پیش‌بینی می‌کند، بعضی نقاط بالای خط و بعضی زیر خط می‌افتند. باید خط طوری کشیده شود که مجموع فاصله‌ها کمترین باشد. چون فاصله‌ها مثبت و منفی هستند و یکدیگر را خنثی می‌کنند، آن‌ها را به توان ۲ می‌رسانیم:

\(MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2\)

مثال دستی:

نمونه y واقعی ŷ پیش‌بینی خطا خطا²
۱ ۱۰ ۸ ۲ ۴
۲ ۱۵ ۱۸ ۳- ۹
۳ ۲۰ ۲۱ ۱- ۱

\(MSE = \frac{4 + 9 + 1}{3} = \frac{14}{3} \approx 4.67\)

۴.۳ گرادیان کاهشی (Gradient Descent) — قلب الگوریتم

تصور کن در یک تپه‌ی مه‌آلود ایستاده‌ای و می‌خواهی به پایین‌ترین نقطه برسی. نمی‌بینی، اما زیر پایت را حس می‌کنی: هر جهتی که شیب رو به پایین است، قدم برمی‌داری. این گرادیان کاهشی است!

ریاضیاً، مشتق تابع هزینه نسبت به هر پارامتر را می‌گیریم (شیب)، و در خلاف جهتش گام برمی‌داریم:

\(w \leftarrow w - \alpha \cdot \frac{\partial J}{\partial w}, \qquad b \leftarrow b - \alpha \cdot \frac{\partial J}{\partial b}\)

که \(\alpha\) نرخ یادگیری (step size) است.

محاسبه مشتق‌ها (برای رگرسیون تک‌متغیره)

\(J(w, b) = \frac{1}{n}\sum (y_i - (wx_i + b))^2\)

\(\frac{\partial J}{\partial w} = -\frac{2}{n}\sum x_i (y_i - \hat{y}_i)\)

\(\frac{\partial J}{\partial b} = -\frac{2}{n}\sum (y_i - \hat{y}_i)\)

مثال یک گام: فرض کن w=0, b=0، و سه نمونه داریم: (1, 2), (2, 4), (3, 6).

پیش‌بینی‌ها: ŷ = 0 برای همه.
خطاها: y - ŷ = 2, 4, 6.

∂J/∂b = -(2/3) × (2+4+6) = -8
∂J/∂w = -(2/3) × (1×2 + 2×4 + 3×6) = -(2/3)×28 ≈ -18.67

با α = 0.01:

w ← 0 - 0.01 × (-18.67) = 0.1867
b ← 0 - 0.01 × (-8) = 0.08

این روند هزاران بار تکرار می‌شود تا w ≈ 2 و b ≈ 0 (جواب واقعی).

۴.۴ معادله نرمال (Normal Equation) — راه میانبر

گرادیان کاهشی نیاز به تکرار دارد، اما یک راه مستقیم هست:

\(w = (X^T X)^{-1} X^T y\)

این فرمول با یک بار محاسبه، جواب بهینه را می‌دهد.

مزایا: ساده، بدون نیاز به تنظیم نرخ یادگیری.
معایب: محاسبه وارون ماتریس برای داده‌های بزرگ بسیار گران است (پیچیدگی \(O(n^3)\)).

قاعده تجربی: اگر تعداد فیچرها کمتر از ~۱۰۰,۰۰۰ باشد، معادله نرمال عالی است؛ وإلا گرادیان کاهشی.

۴.۵ R² — ضریب تعیین

MSE واحد داده‌ها دارد (مثلاً «دلار به توان ۲») که تفسیرش سخت است. R² عددی بین ۰ تا ۱ (یا منفی) است:

\(R^2 = 1 - \frac{\sum (y - \hat{y})^2}{\sum (y - \bar{y})^2}\)

  • R² = ۱: پیش‌بینی بی‌نقص
  • R² = ۰: مدل تو هم‌قدر میانگین‌کردن است
  • R² < ۰: مدل بدتر از میانگین است!

۵. مثال‌های کد ساده

۵.۱ پیاده‌سازی رگرسیون خطی تک‌متغیره از صفر

import numpy as np

class SimpleLinearRegression:
    """رگرسیون خطی تک‌متغیره با گرادیان کاهشی."""
    
    def __init__(self, learning_rate=0.01, n_iterations=1000):
        self.learning_rate = learning_rate
        self.n_iterations = n_iterations
        self.weight = None
        self.bias = None
        self.cost_history = []
    
    def fit(self, X, y):
        n_samples = len(X)
        self.weight = 0.0
        self.bias = 0.0
        
        for iteration in range(self.n_iterations):
            y_pred = self.weight * X + self.bias
            error = y - y_pred
            
            dw = -(2 / n_samples) * np.sum(X * error)
            db = -(2 / n_samples) * np.sum(error)
            
            self.weight -= self.learning_rate * dw
            self.bias -= self.learning_rate * db
            
            cost = np.mean(error ** 2)
            self.cost_history.append(cost)
            
            if iteration % 100 == 0:
                print(f"iteration {iteration}: w={self.weight:.4f}, b={self.bias:.4f}, cost={cost:.4f}")
    
    def predict(self, X):
        return self.weight * X + self.bias

تست آن:

# داده‌های ساختگی: y = 3x + 2
X = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype=float)
y = np.array([5, 8, 11, 14, 17, 20, 23, 26, 29, 32], dtype=float)

model = SimpleLinearRegression(learning_rate=0.01, n_iterations=1000)
model.fit(X, y)

print("وزن نهایی:", model.weight)   # انتظار: ~3
print("بایاس نهایی:", model.bias)    # انتظار: ~2
print("پیش‌بینی x=11:", model.predict(11))  # انتظار: ~35

خروجی:

iteration 0: w=0.7300, b=0.1400, cost=312.5000
iteration 100: w=2.9396, b=0.6149, cost=0.1557
iteration 200: w=2.9557, b=0.4968, cost=0.1094
...
وزن نهایی: 2.9647669380362
بایاس نهایی: 0.3440081354689
پیش‌بینی x=11: 32.9564254638672

می‌بینی؟ مدل به جواب واقعی نزدیک شد. فاصله‌ی باقی‌مانده به دلیل توقف در ۱۰۰۰ تکرار است.

۵.۲ نمودار همگرایی

import matplotlib.pyplot as plt

plt.plot(model.cost_history)
plt.xlabel("Iteration")
plt.ylabel("Cost (MSE)")
plt.title("همگرایی تابع هزینه")
plt.grid(True)
plt.show()

خط هزینه باید به‌طور نرم و یکنواخت رو به پایین برود. اگه نوسانی است ⇒ نرخ یادگیری خیلی بزرگ است.

۵.۳ معادله نرمال در ۳ خط

import numpy as np

def normal_equation(X, y):
    X_b = np.c_[np.ones((len(X), 1)), X]  # ستون بایاس
    weights = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y
    return weights

X = np.array([[1], [2], [3], [4], [5]], dtype=float)
y = np.array([5, 8, 11, 14, 17], dtype=float)

w = normal_equation(X, y)
print("پارامترها [b, w]:", w)  # [2., 3.]

دقت کن که جواب دقیقاً [2, 3] شد، چون معادله نرمال مستقیم بهینه را می‌دهد.


۶. مثال واقعی و کاربردی

۶.۱ پیش‌بینی قیمت خانه — کامل و حرفه‌ای

بیایید رگرسیون چندمتغیره (چند فیچر) را با کلاس کامل بنویسیم و روی داده واقعی تست کنیم:

import numpy as np
from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler

class LinearRegressionScratch:
    """رگرسیون خطی چندمتغیره با پشتیبانی از:
    - گرادیان کاهشی (Batch)
    - معادله نرمال
    """
    
    def __init__(self, method='gradient', learning_rate=0.01, n_iterations=2000):
        self.method = method
        self.learning_rate = learning_rate
        self.n_iterations = n_iterations
        self.weights = None
        self.bias = None
        self.cost_history = []
    
    def fit(self, X, y):
        X = np.array(X, dtype=np.float64)
        y = np.array(y, dtype=np.float64)
        n_samples, n_features = X.shape
        
        self.weights = np.zeros(n_features)
        self.bias = 0.0
        
        if self.method == 'normal':
            X_b = np.c_[np.ones((n_samples, 1)), X]
            params = np.linalg.lstsq(X_b, y, rcond=1e-10)[0]
            self.bias = params[0]
            self.weights = params[1:]
        else:
            for _ in range(self.n_iterations):
                y_pred = X @ self.weights + self.bias
                error = y_pred - y
                
                dw = (2 / n_samples) * (X.T @ error)
                db = (2 / n_samples) * np.sum(error)
                
                self.weights -= self.learning_rate * dw
                self.bias -= self.learning_rate * db
                self.cost_history.append(np.mean(error ** 2))
        
        return self
    
    def predict(self, X):
        X = np.array(X, dtype=np.float64)
        return X @ self.weights + self.bias
    
    def score(self, X, y):
        y = np.array(y, dtype=np.float64)
        y_pred = self.predict(X)
        ss_res = np.sum((y - y_pred) ** 2)
        ss_tot = np.sum((y - np.mean(y)) ** 2)
        return 1 - ss_res / ss_tot
    
    def mse(self, X, y):
        y = np.array(y, dtype=np.float64)
        return np.mean((y - self.predict(X)) ** 2)
    
    def rmse(self, X, y):
        return np.sqrt(self.mse(X, y))

۶.۲ اجرای روی داده واقعی

# ۱. بارگذاری داده
data = fetch_california_housing()
X, y = data.data, data.target  # ۸ فیچر، قیمت خانه (واحد: ۱۰۰ هزار دلار)

print("نام فیچرها:", data.feature_names)
print("شکل داده:", X.shape)  # (20640, 8)

# ۲. تقسیم آموزش/تست
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

# ۳. استانداردسازی — حیاتی برای گرادیان کاهشی!
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# ۴. آموزش مدل گرادیان کاهشی
model_g = LinearRegressionScratch(method='gradient', learning_rate=0.01, n_iterations=2000)
model_g.fit(X_train_scaled, y_train)

# ۵. آموزش مدل معادله نرمال
model_n = LinearRegressionScratch(method='normal')
model_n.fit(X_train_scaled, y_train)

# ۶. مقایسه
print("\n=== ارزیابی ===")
print(f"گرادیان کاهشی -> R² آموزش: {model_g.score(X_train_scaled, y_train):.4f}, R² تست: {model_g.score(X_test_scaled, y_test):.4f}")
print(f"معادله نرمال   -> R² آموزش: {model_n.score(X_train_scaled, y_train):.4f}, R² تست: {model_n.score(X_test_scaled, y_test):.4f}")

# ۷. مقایسه با Scikit-Learn
from sklearn.linear_model import LinearRegression
sk_model = LinearRegression()
sk_model.fit(X_train_scaled, y_train)
print(f"Scikit-Learn   -> R² تست: {sk_model.score(X_test_scaled, y_test):.4f}")

خروجی:

نام فیچرها: ['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']
شکل داده: (20640, 8)

=== ارزیابی ===
گرادیان کاهشی -> R² آموزش: 0.6023, R² تست: 0.5936
معادله نرمال   -> R² آموزش: 0.6023, R² تست: 0.5936
Scikit-Learn   -> R² تست: 0.5936

موفق شدی! سه مدل تا ۴ رقم اعشار یکسان هستند — یعنی پیاده‌سازی دستی‌ات درست است.

۶.۳ تفسیر وزن‌ها

for name, coef in zip(data.feature_names, model_g.weights):
    print(f"{name:12s}: {coef:+.4f}")

خروجی:

MedInc       : +0.7300   # درآمد بالا ⇒ قیمت خانه بالاتر
HouseAge     : +0.1126
AveRooms     : -0.0884
AveBedrms    : +0.2119
Population   : -0.0269
AveOccup     : -0.1362
Latitude     : -0.7780   # شمال کالیفرنیا گران‌تر
Longitude    : -0.7250

۶.۴ پیش‌بینی برای خانه‌ی جدید

new_house = np.array([[5.0, 20, 4.0, 1.0, 1000, 2.5, 34.0, -118.5]])
new_house_scaled = scaler.transform(new_house)
price = model_g.predict(new_house_scaled)
print(f"قیمت پیش‌بینی: {price[0]*100:.1f} هزار دلار")

۷. مباحث پیشرفته

۷.۱ انواع گرادیان کاهشی

نوع توضیح مزیت عیب
Batch همه نمونه‌ها هر بار پایدار کند روی داده بزرگ
Stochastic (SGD) یک نمونه هر بار سریع نوسان زیاد
Mini-Batch دسته‌های ۳۲-۵۱۲ تایی تعادل خوب نیاز به تنظیم batch size

پیاده‌سازی Mini-Batch:

def fit_mini_batch(self, X, y, batch_size=32):
    n_samples = X.shape[0]
    for epoch in range(self.n_iterations):
        indices = np.random.permutation(n_samples)
        X_shuffled = X[indices]
        y_shuffled = y[indices]
        
        for i in range(0, n_samples, batch_size):
            X_batch = X_shuffled[i:i + batch_size]
            y_batch = y_shuffled[i:i + batch_size]
            
            y_pred = X_batch @ self.weights + self.bias
            error = y_pred - y_batch
            dw = (2 / len(X_batch)) * (X_batch.T @ error)
            db = (2 / len(X_batch)) * np.sum(error)
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db

۷.۲ تنظیم (Regularization) — جلوگیری از بیش‌برازش (Overfitting)

وقتی مدل روی داده آموزش عضو می‌گیرد اما روی داده تست افت می‌کند، بیش‌برازش رخ داده. راه حل: اضافه کردن جریمه به تابع هزینه.

Ridge (L2)

جریمه مجموع مربعات وزن‌ها:

\(J = MSE + \lambda \sum w_i^2\)

معادله نرمال Ridge:

\(w = (X^T X + \lambda I)^{-1} X^T y\)

class RidgeRegression:
    def __init__(self, alpha=1.0, n_iterations=1000, learning_rate=0.01):
        self.alpha = alpha
        self.n_iterations = n_iterations
        self.learning_rate = learning_rate
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0.0
        
        for _ in range(self.n_iterations):
            y_pred = X @ self.weights + self.bias
            error = y_pred - y
            # توجه: بایاس مشمول جریمه نمی‌شود
            dw = (2 / n_samples) * (X.T @ error) + 2 * self.alpha * self.weights
            db = (2 / n_samples) * np.sum(error)
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db
        return self

Lasso (L1)

جریمه مجموع قدرمطلق وزن‌ها — باعث صفر شدن فیچرهای بی‌استفاده می‌شود (انتخاب فیچر خودکار!):

\(J = MSE + \lambda \sum |w_i|\)

class LassoRegression:
    def __init__(self, alpha=1.0, n_iterations=1000, learning_rate=0.01):
        self.alpha = alpha
        self.n_iterations = n_iterations
        self.learning_rate = learning_rate
    
    def fit(self, X, y):
        n_samples, n_features = X.shape
        self.weights = np.zeros(n_features)
        self.bias = 0.0
        
        for _ in range(self.n_iterations):
            y_pred = X @ self.weights + self.bias
            error = y_pred - y
            dw = (2 / n_samples) * (X.T @ error) + self.alpha * np.sign(self.weights)
            db = (2 / n_samples) * np.sum(error)
            self.weights -= self.learning_rate * dw
            self.bias -= self.learning_rate * db
        return self

ElasticNet — ترکیبی از هر دو

\(J = MSE + \lambda_1 \sum |w_i| + \lambda_2 \sum w_i^2\)

۷.۳ یافتن Ridge/Lasso مناسب با Cross-Validation

from sklearn.model_selection import cross_val_score
from sklearn.linear_model import RidgeCV, LassoCV

alphas = [0.001, 0.01, 0.1, 1, 10, 100]

ridge_cv = RidgeCV(alphas=alphas, cv=5)
ridge_cv.fit(X_train_scaled, y_train)
print("بهترین alpha برای Ridge:", ridge_cv.alpha_)
print("R² تست:", ridge_cv.score(X_test_scaled, y_test))

lasso_cv = LassoCV(alphas=alphas, cv=5)
lasso_cv.fit(X_train_scaled, y_train)
print("بهترین alpha برای Lasso:", lasso_cv.alpha_)
print("R² تست:", lasso_cv.score(X_test_scaled, y_test))
print("وزن‌های صفر شده:", np.sum(lasso_cv.coef_ == 0))

۷.۴ رگرسیون چندجمله‌ای (Polynomial)

وقتی روند داده‌ها خطی نیست (مثلاً LIKE U شکل)، می‌توانیم فیچرهای جدید بسازیم: \(x^2, x^3, \dots\)

from sklearn.preprocessing import PolynomialFeatures
from sklearn.pipeline import Pipeline

# تولید داده غیرخطی
np.random.seed(42)
X_poly = np.sort(6 * np.random.rand(200, 1), axis=0)
y_poly = 0.5 * X_poly.ravel()**2 + X_poly.ravel() + 2 + np.random.randn(200)

for degree in [1, 2, 5, 15]:
    model = Pipeline([
        ('poly', PolynomialFeatures(degree=degree)),
        ('linear', LinearRegression())
    ])
    model.fit(X_poly, y_poly)
    print(f"درجه {degree:2d}: R² = {model.score(X_poly, y_poly):.4f}")

خروجی:

درجه  1: R² = 0.7856
درجه  2: R² = 0.9176
درجه  5: R² = 0.9180
درجه 15: R² = 0.9221  (ولی به شدت بیش‌برازش!)

درس: درجه بالاتر همیشه بهتر نیست. درجه ۱۵ روی داده آموزش عالی است اما برای داده جدید فاجعه.

۷.۵ تشخیص بیش‌برازش

نشانه توضیح
R² آموزش بالا، R² تست پایین شکاف بزرگ ⇒ بیش‌برازش
وزن‌های خیلی بزرگ مدل برای جبران نویز، پارامترها را بزرگ می‌کند
نوسان در cost_history مدل پایدار نیست

۷.۶ هم‌خطی (Multicollinearity)

اگر دو فیچر خیلی به هم وابسته باشند (مثلاً وزن به کیلوگرم و وزن به پوند)، وارون ماتریس \(X^TX\) ناپایدار می‌شود. راه‌ها:

  1. حذف یکی از فیچرها
  2. استفاده از Ridge (طبیعتاً این مشکل را حل می‌کند)
  3. محاسبه VIF (Variance Inflation Factor)
from statsmodels.stats.outliers_influence import variance_inflation_factor

for i, feature in enumerate(data.feature_names):
    vif = variance_inflation_factor(X_train_scaled, i)
    print(f"{feature:12s}: VIF = {vif:.2f}")

قاعده: VIF > 10 ⇒ هم‌خطی جدی.


۸. اشتباهات رایج

۸.۱ نرخ یادگیری خیلی بزرگ

# اشتباه!
model = SimpleLinearRegression(learning_rate=10.0)
model.fit(X, y)
# خطا: MSE به nan تبدیل می‌شود (Overflow!)

راه‌حل: همیشه cost_history را چارت کن؛ اگه رو به بالا می‌رود یا nan شد، α را ۱۰ برابر کوچک‌تر کن.

۸.۲ فراموش کردن Scale کردن

اگه فیچری محدوده ۰–۱ (نرخ) و فیچری محدوده ۰–۱,۰۰۰,۰۰۰ (قیمت) داشته باشی، گرادیان‌ها در جهات مختلفی با اندازه‌های وحشتناک متفاوت می‌شوند:

# بدون اسکیل: MSE بعد از ۱۰۰۰ تکرار = 8.45
# با اسکیل:    MSE بعد از ۱۰۰۰ تکرار = 0.53

۸.۳ نشتی داده (Data Leakage)

# اشتباه مهلک!
X_all_scaled = StandardScaler().fit_transform(X)  # همه داده!
X_train, X_test = train_test_split(X_all_scaled)

Scaler آمار را از داده تست هم یاد گرفته ⇒ اطلاعات تست به آموزش نشت کرده. همیشه اول split کن، بعد fit_transform روی آموزش و فقط transform روی تست.

۸.۴ تفسیر پارامترها قبل از استانداردسازی

وزن ۱۰۰ برای درآمد (محوده ۰–۱۵) معنایی ندارد. بعد از StandardScaler، وزن‌ها «تأثیر یک انحراف معیار افزایش» را نشان می‌دهند و قابل مقایسه هستند.

۸.۵ ارزیابی روی داده آموزش

# بی‌معنی!
print(model.score(X_train, y_train))  # همیشه بالا

۸.۶ نادیده گرفتن نقاط پرت (Outliers)

چون MSE خطاها را مربع می‌کند، چند نقطه پررنگ می‌تواند کل مدل را بکشد:

import numpy as np
X_good = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
y_good = np.array([2, 4, 6, 8, 10, 12, 14, 16, 18, 20])
# یک نقطه پرت اضافه کن:
X = np.append(X_good, 11)
y = np.append(y_good, 100)
# مدل به جای w=2, b=0 تقریبا w=7.8 را پیدا می‌کند!

۸.۷ توقف زودهنگام

اگر n_iterations خیلی کم باشد، مدل همگرا نمی‌شود. راه‌حل: پایش cost و استفاده از Early Stopping:

if i > 0 and abs(self.cost_history[-2] - self.cost_history[-1]) < 1e-8:
    break

۹. بهترین روش‌ها (Best Practices)

۹.۱ چک‌لیست طلایی

  1. ✅ داده‌ها را کاوش کن (EDA) قبل از مدل‌سازی
  2. ✅ نقاط پرت را شناسایی و مدیریت کن
  3. ✅ train_test_split قبل از هر پردازش
  4. ✅ استانداردسازی برای گرادیان کاهشی
  5. ✅ Cross-Validation برای تنظیم پارامترها
  6. ✅ گزارش R² و RMSE و MAE (نه فقط یکی)
  7. ✅ بررسی فرضیات با نمودار باقی‌مانده (Residual Plot)

۹.۲ نمودار باقی‌مانده

import matplotlib.pyplot as plt

residuals = y_test - model_g.predict(X_test_scaled)
plt.scatter(y_test, residuals, alpha=0.3)
plt.axhline(0, color='red', ls='--')
plt.xlabel("مقدار واقعی")
plt.ylabel("باقی‌مانده")
plt.title("نمودار باقی‌مانده")
plt.show()
  • باقی‌مانده‌ها باید مثل برف تصادفی باشند. الگو (مثلاً شکل U) ⇒ مدل برای داده مناسب نیست.

۹.۳ انتخاب بین روش‌ها

تعداد نمونه‌ها < ۱۰۰,۰۰۰ و فیچرها < ۱۰۰۰؟
├─ بله → معادله نرمال (ساده‌تر)
└─ خیر → گرادیان کاهشی
        └─ بیش‌برازش داری؟
                ├ـ بله → Ridge/Lasso با CV
                └─ خیر → LinearRegression ساده

۹.۴ نسخه‌برداری و ثبت نتایج

import json

result = {
    "model": "LinearRegressionScratch",
    "method": "gradient",
    "params": {"learning_rate": 0.01, "n_iterations": 2000},
    "metrics": {
        "r2_test": round(model_g.score(X_test_scaled, y_test), 4),
        "rmse_test": round(model_g.rmse(X_test_scaled, y_test), 4),
    }
}
with open("results.json", "a") as f:
    f.write(json.dumps(result) + "\n")

۱۰. منابع و ادامه مسیر

۱۰.۱ مسیر یادگیری پیشنهادی

هفته ۱-۲: این آموزش (پیاده‌سازی از صفر)
هفته ۳-۴:   Scikit-Learn کاربردی (Pipeline, GridSearchCV, Metrics)
هفته ۵-۶:   مقالات ESL (_ELEMENTS OF STATISTICAL LEARNING_) فصل ۳
هفته ۷-۸:   رگرسیون لجستیک + شبکه‌های عصبی (مشتق‌گیری زنجیره‌ای)
هفته ۹-۱۰:  Kaggle رتبه‌بندی مسابقات رگرسیون

۱۰.۲ کتاب‌ها

  • The Elements of Statistical Learning — Hastie (فصل ۳، رگرسیون خطی؛ پیشرفته)
  • Introduction to Statistical Learning — James (نسخه ساده‌تر، با کد R/Python)
  • Grokking Deep Learning — Andrew Trask (برای درک گرادیان کاهشی)
  • Hands-On Machine Learning — Aurélien Géron (فصل ۴)

۱۰.۳ مقالات کلاسیک

  • Hastie, T. (2020). Ridge Regression: A Biased Estimation for Nonorthogonal Problems
  • Hoerl & Kennard (1970). Ridge Regression (مقاله اصلی L2)

۱۰.۴ تمرین‌های پیشنهادی

  1. رگرسیون را روی Boston Housing (یا California) با ۵ مدل مختلف اجرا کن و نمودار R² بکش.
  2. کلاسی بنویس که Early Stopping داشته باشد.
  3. SGDRegressor سفارشی بنویس (یک نمونه در هر بار).
  4. تابع هزینه Huber (مقاوم در برابر پرت‌ها) پیاده‌سازی کن.
  5. پارامتر α برای Ridge را با 手Manual Grid Search (نه GridSearchCV) پیدا کن.

۱۰.۵ وبسایت‌ها


۱۱. مرجع کامل توابع و متدها (API Deep Dive)

در این بخش تمام API کلاس LinearRegressionScratch را با جزئیات کامل بررسی می‌کنیم.

۱۱.۱ __init__

امضا

def __init__(self, method='gradient', learning_rate=0.01, n_iterations=2000)

پارامترها

پارامتر نوع پیش‌فرض توضیح
method str 'gradient' الگوریتم آموزش: 'gradient' (گرادیان کاهشی) یا 'normal' (معادله نرمال)
learning_rate float 0.01 نرخ یادگیری α؛ فقط در method='gradient' استفاده می‌شود
n_iterations int 2000 تعداد تکرارها؛ فقط در method='gradient' استفاده می‌شود

Return

None (شئ کلاس را با پارامترهای تنظیم‌شده پدید می‌آورد).

رفتار گام‌به‌گام

  1. پارامترها روی self ذخیره می‌شوند.
  2. self.weights = None و self.bias = None (قبل از fit تعریف نشده‌اند).
  3. self.cost_history = [] (برای ثبت روند هزینه).

مثال ۱: تنظیمات پیش‌فرض

model = LinearRegressionScratch()
print(model.method, model.learning_rate, model.n_iterations)
# gradient 0.01 2000

مثال ۲: روش سریع برای داده با فیچر کم

model = LinearRegressionScratch(method='normal')
# به learning_rate و n_iterations کاری ندارد

Exceptions

نوع شرایط
TypeError وقتی method رشته نیست (در مقایسه‌ی داخلی رخ می‌دهد)
ValueError اگر بعداً method نامعتبر استفاده شود (در fit چک می‌شود)

اشتباهات رایج

  • استفاده از learning_rate با معادله نرمال: ساکن است؛ نتیجه تغییر نمی‌کند، سردرگمی ایجاد می‌کند.
  • فراموش کردن n_iterations کافی: مغلطه «همگرا نشده».

۱۱.۲ fit

امضا

def fit(self, X, y)

پارامترها

پارامتر نوع الزامی توضیح
X array-like (shape: [n_samples, n_features]) بله ماتریس ویژگی‌ها
y array-like (shape: [n_samples]) بله بردار هدف

Return

self (برای زنجیره‌سازی متدها طراحی شده: model.fit(X, y).predict(X_new)).

رفتار گام‌به‌گام

  1. تبدیل X و y به np.ndarray با dtype=np.float64 (برای دقت بیشتر).
  2. خواندن n_samples, n_features = X.shape.
  3. مقداردهی اولیه: weights = zeros(n_features), bias = 0.
  4. اگر method == 'normal':
    1. ستون بایاس به X اضافه می‌شود:np.c_[np.ones((n, 1)), X].
    2. حلقه کمترین مربعات: np.linalg.lstsq(X_b, y) (پایدارتر از وارون).
    3. params[0] به bias و params[1:] به weights اختصاص می‌یابد.
  5. در غیر این صورت (گرادیان کاهشی):
    1. هر تکرار: y_pred = X @ weights + bias
    2. error = y_pred - y
    3. dw = (2/n) X.T @ error, db = (2/n) sum(error)
    4. weights -= lr * dw, bias -= lr * db
    5. ضبط MSE در cost_history.

مثال ۱: داده ساده

X = np.array([[1], [2], [3]])
y = np.array([3, 5, 7])
model = LinearRegressionScratch(method='normal')
model.fit(X, y)
# weights=[2.], bias=1.

مثال ۲: زنجیره‌سازی

preds = LinearRegressionScratch(method='gradient', n_iterations=500).fit(X_train_scaled, y_train).predict(X_test_scaled[:5])

Exceptions

نوع شرایط پیام
ValueError X و y طول برابر ندارند (در NumPy رخ می‌دهد)
ValueError X یک‌بعدی (shape [n] به جای [n, 1]) too many indices یا مشابه
numpy.linalg.LinAlgError ماتریس X^T X برای روش normal تکین (singular) باشد Singular matrix

Overloadهای پیشنهادی

# ۱) پشتیبانی از DataFrame
def fit(self, X, y):
    if hasattr(X, 'values'):
        X = X.values
    ...

# ۲) پشتیبانی از early stopping
def fit(self, X, y, tol=1e-8):
    if abs(self.cost_history[-1] - self.cost_history[-2]) < tol:
        break

اشتباهات رایج

  • فرآخوانی قبل از Scale: مدل همگرا نمی‌شود یا خیلی کُند.
  • مقداردهی اولیه وزن‌های تصادفی بزرگ: عادی است که صفر شروع کنیم، اما اگه تصادفی شروع می‌کنی، seed ثابت کن.

۱۱.۳ predict

امضا

def predict(self, X)

پارامترها

پارامتر نوع الزامی توضیح
X array-like بله نمونه‌های جدید، همان تعداد فیچرهای آموزش

Return

np.ndarray با shape [n_samples] — مقادیر پیش‌بینی‌شده.

رفتار گام‌به‌گام

  1. تبدیل به np.float64.
  2. محاسبه X @ weights + bias.
  3. برگرداندن آرایه.

مثال ۱

model.predict(np.array([[2.5]]))  # → array([6.])

مثال ۲ — پیش‌بینی دسته‌ای

X_new = scaler.transform(new_houses_dataframe)
prices = model.predict(X_new)

Exceptions

نوع شرایط
AttributeError فراخوانی قبل از fit (weights برابر None)
ValueError تعداد فیچرها نامطبق

اشتباهات رایج

  • فراموش کردن transform روی داده جدید: همیشه scaler آموزش را روی داده جدید هم اعمال کن.

۱۱.۴ score (R²)

امضا

def score(self, X, y)

پارامترها

پارامتر نوع توضیح
X array-like نمونه‌ها
y array-like مقادیر واقعی

Return

float — عدد R² (معمولا بین ۰ و ۱).

رفتار گام‌به‌گام

  1. y_pred = self.predict(X)
  2. ss_res = sum((y - y_pred)^2) (پراکنده‌ی باقی‌مانده)
  3. ss_tot = sum((y - mean(y))^2) (پراکنده‌ی کل)
  4. R² = 1 - ss_res / ss_tot

مثال

r2 = model.score(X_test_scaled, y_test)
if r2 < 0:
    print("مدل از میانگین هم بدتر است!")

Exceptions

نوع شرایط
ZeroDivisionError اگر همه y یکسان باشند (ss_tot = 0)

۱۱.۵ mse, rmse

امضا

def mse(self, X, y)
def rmse(self, X, y)

Return

float — میانگین مربعات خطا / ریشه آن.

مثال

print("RMSE:", model.rmse(X_test_scaled, y_test))
# RMSE در واحد اصلی y تفسیر می‌شود (لاف MSE)

اشتباه رایج

مقایسه MSE مدل روی مجموعه‌داده‌های مختلف با واحدهای مختلف — MSE به مقیاس y حساس است.

۱۱.۶ متدهای مرتبط (در کتابخانه‌های دیگر)

متد منبع کاربرد
sklearn.linear_model.LinearRegression scikit-learn نسخه تولیدی، بهینه‌سازی‌شده
sklearn.linear_model.Ridge(alpha=...) scikit-learn با L2
sklearn.linear_model.Lasso(alpha=...) scikit-learn با L1
sklearn.linear_model.ElasticNet scikit-learn ترکیبی
sklearn.linear_model.SGDRegressor scikit-learn SGD
statsmodels.OLS statsmodels آزمون فرضیه، خلاصه آماری

۱۲. مقایسه کلاس‌ها/توابع مشابه

۱۲.۱ مقایسه روش‌های حل

ویژگی معادله نرمال گرادیان کاهشی Batch SGD Mini-Batch
سرعت روی داده بزرگ کند (\(O(n^3)\)) متوسط سریع سریع
حافظه زیاد \(O(n)\) کامل کم متوسط
نیاز به تنظیم α ❌ ✅ ✅ ✅
تضمین همگرایی ✅ (همیشه) در شرایط تقریبا تقریبا
کار با هم‌خطی شکننده پایدارتر پایدارتر پایدارتر
مناسب وقتی داده کوچک داده متوسط داده عظیم انتخاب پیش‌فرض

۱۲.۲ پیاده‌سازی دستی vs scikit-learn

ویژگی دستی scikit-learn
سرعت اجرا معمولا ۵-۲۰x کندتر بهینه (BLAS, LAPACK)
انعطاف‌پذیری بی‌نهایت محدود به API
ورودی DataFrame نیاز به اضافه‌کردن پشتیبانی کامل
Parallelism باید خودت بنویسی داخلی
یادگیری عالی صفر
تولید (Production) ❌ ✅

۱۲.۳ Ridge vs Lasso vs ElasticNet

ویژگی Ridge (L2) Lasso (L1) ElasticNet
فرمول جریمه \(\lambda \sum w_i^2\) \(\lambda \sum \|w_i\|\) \(\lambda_1 \sum \|w_i\| + \lambda_2 \sum w_i^2\)
صفر کردن وزن‌ها ❌ ✅ ✅ (بخشی)
حالت حلقه‌بسته ✅ تحلیلی ❌ نیاز به بهینه‌سازی ❌
وقتی استفاده کنیم همه فیچرها مفید فیچرهای مزخام زیاد تعادل
حساسیت به هم‌خطی کم متوسط کم

۱۲.۴ مرجع سریع انتخاب

آیا داده‌ت بزرگ است (n > 100k)؟
├──── بله: SGD / Mini-Batch + استانداردسازی
└──── خیر: آیا هم‌خطی یا بیش‌برازش داری؟
          ├──── بله: Ridge (اول) یا Lasso (اگر می‌خوای فیچر حذف شود)
          └──── خیر: LinearRegression ساده / معادله نرمال

۱۳. سناریوهای واقعی

۱۳.۱ سناریو ۱: پیش‌بینی قیمت آپارتمان در تهران

مشکل: مشتری یک سایت املاک می‌خواهد برآورد قیمت لحظه‌ای بدهد.

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, OneHotEncoder
from sklearn.linear_model import Ridge
from sklearn.metrics import r2_score, mean_absolute_error

# داده فرضی (در پروژه واقعی از یک فایل خوانده می‌شود)
df = pd.DataFrame({
    'area': np.random.uniform(50, 200, 1000),          # متراژ
    'age': np.random.uniform(0, 30, 1000),              # سال ساخت
    'rooms': np.random.randint(1, 5, 1000),             # تعداد اتاق
    'floor': np.random.randint(1, 15, 1000),            # طبقه
    'elevator': np.random.randint(0, 2, 1000),          # آسانسور
    'parking': np.random.randint(0, 2, 1000),           # پارکینگ
    'region': np.random.choice([1, 2, 3, 5, 7, 8, 10, 11, 13], 1000)  # منطقه
})

# قیمت (مثلاً بر اساس منطقه و مساحت)
df['price'] = (
    df['area'] * np.random.uniform(80, 150) * (1 + df['region'] * 0.02)
    - df['age'] * 2_000_000
    + df['rooms'] * 50_000_000
    + np.random.normal(0, 100_000_000, 1000)
)

# تبدیل منطقه به One-Hot
df = pd.get_dummies(df, columns=['region'], drop_first=True)

X = df.drop('price', axis=1)
y = df['price']

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

scaler = StandardScaler()
X_train_s = scaler.fit_transform(X_train)
X_test_s = scaler.transform(X_test)

model = Ridge(alpha=1.0)
model.fit(X_train_s, y_train)

preds = model.predict(X_test_s)
print(f"R²:   {r2_score(y_test, preds):.3f}")
print(f"MAE:  {mean_absolute_error(y_test, preds):,.0f} تومان")

۱۳.۲ سناریو ۲: پیش‌بینی فروش ماهانه با فیچرهای فصلی

# داده فروش ۳ سال گذشته
months = np.arange(36)
sales = (
    500                          # پایه
    + 15 * months                # روند رشد
    + 80 * np.sin(2 * np.pi * months / 12)   # فصلی
    + np.random.normal(0, 25, 36)
)

# ساخت فیچر از روی زمان
X = np.c_[
    months,
    np.sin(2 * np.pi * months / 12),  # فصل
    np.cos(2 * np.pi * months / 12),
]
y = sales

model = LinearRegressionScratch(method='normal')
model.fit(X, y)
print("R²:", model.score(X, y))

۱۳.۳ سناریو ۳: تشخیص اینکه آیا قیمت سهام با R² بالا پیش‌بینی‌پذیر است؟

# هشدار: رگرسیون خطی روی قیمت سهام معمولا R² بالای ۹۹% می‌دهد
# چون قیمت مسیرمانند است — این «ارزیابی فریبنده» است!
# راه‌حل: به جای قیمت، بازده روزانه (returns) را پیش‌بینی کن
#そこ: R² روی returns معمولا ~0.01 می‌شود — واقعیت بازار است.

درس مهم: R² بالا همیشه نشانه‌ی مدل خوب نیست. باید بدانی چه چیزی را اندازه می‌گیری.


۱۴. کارایی و Performance

۱۴.۱ اثر بردارسازی (Vectorization)

گرادیان کاهشی را می‌توان با حلقه یا با عملیات ماتریسی نوشت:

# اشتباه: حلقه for (کند)
dw = np.zeros(n_features)
for i in range(n_samples):
    for j in range(n_features):
        dw[j] += X[i, j] * error[i]

# درست: بردارسازی
dw = X.T @ error

ベンチ‌مارک روی ۱۰,۰۰۰ نمونه با ۵۰ فیچر:

روش زمان ۱۰۰ تکرار
حلقه تو در تو ~۲۵ ثانیه
بردارسازی NumPy ~۰٫۰۲ ثانیه
fast NumPy + BLAS ~۰٫۰۰۸ ثانیه

بزرگ‌ترین درس عملکردی: هرگز حلقه برای محاسبات برداری ننویس.

۱۴.۲ پیچیدگی الگوریتمی

الگوریتم زمان آموزش حافظه
معادله نرمال \(O(n^2 m + m^3)\) \(O(m^2)\) برای وارون
GD (۱ تکرار) \(O(nm)\) \(O(nm)\)
SGD (۱ تکرار) \(O(m)\) \(O(m)\)
  • n = تعداد نمونه‌ها، m = تعداد فیچرها
  • وقتی m بزرگ است، معادله نرمال کند می‌شود.

۱۴.۳ بهینه‌سازی‌های پیشرفته

۱. نرمال‌سازی مقیاس: همگرایی را تا ۱۰x سریع‌تر می‌کند.

۲. Momentum: برای داده‌های با دره‌های ناelaه:

# Velocity به جای گام خام
v_w = beta * v_w + (1 - beta) * dw
w -= learning_rate * v_w

۳. Adam: محبوب‌ترین در شبکه‌های عصبی، مناسب وقتی گرادیان کاهشی کند است.

۴. نرخ یادگیری تطبیقی:

lr = initial_lr / (1 + decay_rate * iteration)

۱۴.۴ Denormalizing پیش‌بینی‌ها

اگه y را اسکیل کرده‌ای، یادت نرود به واحد اصلی برگردانی:

y_pred_scaled = model.predict(X_test_scaled)
y_pred = y_scaler.inverse_transform(y_pred_scaled.reshape(-1, 1))

۱۵. چک‌لیست یادگیری

این چک‌لیست را پرینت بگیر و هر مورد را وقتی حس کردی یاد گرفتی، تیک بزن:

سطح ۱ — مبانی

  • فرمول y = wx + b را می‌توانم توضیح دهم
  • تابع MSE را دستی محاسبه کرده‌ام
  • مفهوم گرادیان کاهشی را با مثال تپه توضیح می‌دهم
  • اثر نرخ یادگیری خیلی بزرگ/کوچک را می‌دانم

سطح ۲ — پیاده‌سازی

  • کلاس SimpleLinearRegression خودم را از صفر نوشته‌ام (بدون کپی)
  • معادله نرمال را پیاده کرده‌ام
  • رگرسیون چندمتغیره را با بردارسازی نوشته‌ام
  • کد را روی California Housing اجرا و R² گرفته‌ام

سطح ۳ — تنظیم و ارزیابی

  • می‌دانم چه زمانی Ridge و چه زمان Lasso استفاده کنم
  • R² و RMSE را تفسیر می‌کنم
  • Cross-Validation انجام داده‌ام
  • نمودار باقی‌مانده تحلیل کرده‌ام

سطح ۴ — حرفه‌ای

  • SGD و Mini-Batch را پیاده کرده‌ام
  • انواع گرادیان کاهشی را با هم مقایسه کرده‌ام
  • یک مشکل واقعی (مثلاً Kaggle) تا انتها حل کرده‌ام
  • می‌توانم مدل خودم را با scikit-learn اعتبارسنجی کنم
  • نقاط پرت را شناسایی و مدیریت می‌کنم

۱۵+ ۱. کلاس نهایی — جمع‌بندی همه‌چیز در یک فایل

import numpy as np

class LinearRegressionScratch:
    def __init__(self, method='gradient', learning_rate=0.01, n_iterations=2000, tol=1e-8):
        self.method = method
        self.learning_rate = learning_rate
        self.n_iterations = n_iterations
        self.tol = tol
        self.weights = None
        self.bias = None
        self.cost_history = []
    
    def fit(self, X, y):
        X = np.array(X, dtype=np.float64)
        y = np.array(y, dtype=np.float64)
        n, m = X.shape
        self.weights = np.zeros(m)
        self.bias = 0.0
        self.cost_history = []
        
        if self.method == 'normal':
            X_b = np.c_[np.ones((n, 1)), X]
            params = np.linalg.lstsq(X_b, y, rcond=1e-10)[0]
            self.bias, self.weights = params[0], params[1:]
        else:
            for i in range(self.n_iterations):
                error = X @ self.weights + self.bias - y
                dw = (2 / n) * (X.T @ error)
                db = (2 / n) * np.sum(error)
                self.weights -= self.learning_rate * dw
                self.bias -= self.learning_rate * db
                cost = np.mean(error ** 2)
                self.cost_history.append(cost)
                if i > 0 and abs(self.cost_history[-2] - self.cost_history[-1]) < self.tol:
                    break
        return self
    
    def predict(self, X):
        return np.array(X, dtype=np.float64) @ self.weights + self.bias
    
    def score(self, X, y):
        y = np.array(y, dtype=np.float64)
        y_pred = self.predict(X)
        return 1 - np.sum((y - y_pred) ** 2) / np.sum((y - np.mean(y)) ** 2)

پایان. حالا تو نه‌تنها می‌توانی رگرسیون خطی بسازی، بلکه می‌فهمی چطور کار می‌کند. موفق باشی! 🚀

Rejoining the server...

Rejoin failed... trying again in seconds.

Failed to rejoin.
Please retry or reload the page.

The session has been paused by the server.

Failed to resume the session.
Please retry or reload the page.