ml_algorithms/supervised/linear_regression.py - master - LeonBlue/ML_algos_from_scratch_python

ml_algorithms/supervised/linear_regression.py
106 строк4 KB
LeonBlue
Минимальный набор алгоритмов для начала работы
03 дек 2025, 18:50
03 дек 2025, 18:5028b87a5
"""
Линейная регрессия с нуля
"""

import numpy as np
from ..base.base_model import BaseModel


class LinearRegression(BaseModel):
    """
    Линейная регрессия с использованием метода наименьших квадратов
    или градиентного спуска
    """
    
    def __init__(self, method='normal_equation', learning_rate=0.01, 
                 max_iter=1000, tol=1e-6):
        """
        Parameters:
        -----------
        method : str, default='normal_equation'
            Метод обучения: 'normal_equation' или 'gradient_descent'
        learning_rate : float, default=0.01
            Скорость обучения (для gradient_descent)
        max_iter : int, default=1000
            Максимальное число итераций (для gradient_descent)
        tol : float, default=1e-6
            Точность сходимости (для gradient_descent)
        """
        super().__init__()
        self.method = method
        self.learning_rate = learning_rate
        self.max_iter = max_iter
        self.tol = tol
        self.coef_ = None
        self.intercept_ = None
    
    def fit(self, X, y):
        """
        Обучение модели линейной регрессии
        
        Parameters:
        -----------
        X : array-like, shape (n_samples, n_features)
            Обучающие данные
        y : array-like, shape (n_samples,)
            Целевые значения
        """
        X = self._validate_input(X)
        y = np.asarray(y)
        
        # Добавляем столбец единиц для intercept
        X_with_intercept = np.column_stack([np.ones(X.shape[0]), X])
        
        if self.method == 'normal_equation':
            # Метод нормальных уравнений (аналитическое решение)
            # theta = (X^T * X)^(-1) * X^T * y
            theta = np.linalg.pinv(X_with_intercept.T @ X_with_intercept) @ X_with_intercept.T @ y
        else:
            # Градиентный спуск
            theta = self._gradient_descent(X_with_intercept, y)
        
        self.intercept_ = theta[0]
        self.coef_ = theta[1:]
        self.is_fitted = True
        return self
    
    def _gradient_descent(self, X, y):
        """Градиентный спуск для оптимизации"""
        n_samples, n_features = X.shape
        theta = np.zeros(n_features)
        
        for i in range(self.max_iter):
            # Предсказания
            predictions = X @ theta
            # Ошибка
            error = predictions - y
            # Градиент
            gradient = (1 / n_samples) * X.T @ error
            # Обновление параметров
            theta_new = theta - self.learning_rate * gradient
            
            # Проверка сходимости
            if np.linalg.norm(theta_new - theta) < self.tol:
                break
            
            theta = theta_new
        
        return theta
    
    def predict(self, X):
        """
        Предсказание значений
        
        Parameters:
        -----------
        X : array-like, shape (n_samples, n_features)
            Данные для предсказания
        
        Returns:
        --------
        predictions : array-like, shape (n_samples,)
            Предсказанные значения
        """
        self._check_is_fitted()
        X = self._validate_input(X)
        return X @ self.coef_ + self.intercept_