آموزش کامل ساخت رگرسیون خطی و ساخت الگوریتم از صفر تا صد در پایتون
⚡ خلاصه سریع — اصل کاریها
اینها مهمترین چیزهایی هستن که اگه هیچی ندونی، فقط اینا رو بدونی کافیه:
- نکته ۱: رگرسیون خطی یعنی کشیدن بهترین خط از بین نقاط دادهها؛ فرمولش
y = w·x + bاست کهwوزن (شیب) وbبایاس (عرض از مبدأ) نام دارد. - نکته ۲: هدف آموزش، کمینهسازی تابع هزینه (MSE) است؛ یعنی میانگین مربعات خطا بین پیشبینی و مقدار واقعی.
- نکته ۳: دو راه اصلی برای یادگیری پارامترها وجود دارد: معادله نرمال (مستقیم و تحلیلی) و گرادیان کاهشی (تکرارشونده و تدریجی).
- نکته ۴: در گرادیان کاهشی، نرخ یادگیری (
learning_rate) حیاتی است؛ خیلی بزرگ ⇒ واگرایی، خیلی کوچک ⇒ آموزش کُند. - نکته ۵: همیشه قبل از آموزش، دادهها را استانداردسازی (Scale) کن و بعد از آموزش با R² و MSE و نه فقط خطای خام، مدل را ارزیابی کن.
۳ اشتباه رایج:
- استفاده از نرخ یادگیری نامناسب (مثلاً ۰٫۱ برای دادههای استاندارد نشده) که باعث واگرایی یا گیر کردن در نقطهاشتباه میشود.
- مقیاسندادن فیچرها، مخصوصاً وقتی محدوده متغیرها خیلی متفاوت است (مثلاً مساحت خانه به فوت vs تعداد اتاق)؛ گرادیان کاهشی به شدت آسیب میبیند.
- ارزیابی روی داده آموزش و فریب خوردن از نمره بالا؛ باید با
train_test_splitدادهها را جدا کنی و روی داده تست امتحان کنی.
اگر فقط ۵ دقیقه وقت داری:
- کلاس
LinearRegressionScratchبخش ۵ را کپی کن و با دادههای سادهy = 3x + 2تستش کن. - مفهوم MSE و گرادیان کاهشی را از بخش ۴.۳ و ۴.۴ بخوان.
- کد واقعی بخش ۶ (پیشبینی قیمت مسکن) را اجرا کن و خروجی 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 با یک خط کد همین کار را نمیکند؟» بله، اما:
- درک عمیق: وقتی خودت
fitرا بنویسی، میفهمی پشت صحنه چه میگذرد. - توانایی تنظیم: مهندس واقعی باید بداند چرا مدلش ضعیف است، نه فقط اینکه ضعیف است.
- مصاحبهها: در مصاحبههای دانشمند داده، «پیادهسازی گرادیان کاهشی از صفر» یک سؤال کلاسیک است.
- کنترل کامل: میتوانی تغییرات سفارشی انجام دهی (مانند وزندهی نمونهها، هزینه سفارشی).
۲. پیشنیازها
۲.۱ دانشی که باید داشته باشی
| موضوع | سطح لازم | مثال |
|---|---|---|
| پایتون پایه | متوسط | تابع، کلاس، لیست، 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\) ناپایدار میشود. راهها:
- حذف یکی از فیچرها
- استفاده از Ridge (طبیعتاً این مشکل را حل میکند)
- محاسبه 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)
۹.۱ چکلیست طلایی
- ✅ دادهها را کاوش کن (EDA) قبل از مدلسازی
- ✅ نقاط پرت را شناسایی و مدیریت کن
- ✅
train_test_splitقبل از هر پردازش - ✅ استانداردسازی برای گرادیان کاهشی
- ✅ Cross-Validation برای تنظیم پارامترها
- ✅ گزارش R² و RMSE و MAE (نه فقط یکی)
- ✅ بررسی فرضیات با نمودار باقیمانده (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)
۱۰.۴ تمرینهای پیشنهادی
- رگرسیون را روی Boston Housing (یا California) با ۵ مدل مختلف اجرا کن و نمودار R² بکش.
- کلاسی بنویس که Early Stopping داشته باشد.
SGDRegressorسفارشی بنویس (یک نمونه در هر بار).- تابع هزینه Huber (مقاوم در برابر پرتها) پیادهسازی کن.
- پارامتر α برای Ridge را با 手Manual Grid Search (نه GridSearchCV) پیدا کن.
۱۰.۵ وبسایتها
- Kaggle Learn — Intro to Machine Learning
- scikit-learn LinearRegression docs
- Seeing Theory — با تصویر گرادیان کاهشی را حس کن
۱۱. مرجع کامل توابع و متدها (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 (شئ کلاس را با پارامترهای تنظیمشده پدید میآورد).
رفتار گامبهگام
- پارامترها روی
selfذخیره میشوند. self.weights = Noneوself.bias = None(قبل ازfitتعریف نشدهاند).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)).
رفتار گامبهگام
- تبدیل
Xوyبهnp.ndarrayباdtype=np.float64(برای دقت بیشتر). - خواندن
n_samples, n_features = X.shape. - مقداردهی اولیه:
weights = zeros(n_features),bias = 0. - اگر
method == 'normal':- ستون بایاس به
Xاضافه میشود:np.c_[np.ones((n, 1)), X]. - حلقه کمترین مربعات:
np.linalg.lstsq(X_b, y)(پایدارتر از وارون). params[0]به bias وparams[1:]به weights اختصاص مییابد.
- ستون بایاس به
- در غیر این صورت (گرادیان کاهشی):
- هر تکرار:
y_pred = X @ weights + bias error = y_pred - ydw = (2/n) X.T @ error,db = (2/n) sum(error)weights -= lr * dw,bias -= lr * db- ضبط 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] — مقادیر پیشبینیشده.
رفتار گامبهگام
- تبدیل به
np.float64. - محاسبه
X @ weights + bias. - برگرداندن آرایه.
مثال ۱
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² (معمولا بین ۰ و ۱).
رفتار گامبهگام
y_pred = self.predict(X)ss_res = sum((y - y_pred)^2)(پراکندهی باقیمانده)ss_tot = sum((y - mean(y))^2)(پراکندهی کل)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)
پایان. حالا تو نهتنها میتوانی رگرسیون خطی بسازی، بلکه میفهمی چطور کار میکند. موفق باشی! 🚀