data-blog-regression 0.1.0__tar.gz

data_blog_regression-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: data-blog-regression
+Version: 0.1.0
+Summary: From-scratch linear and multiple regression library for the Data Blog portfolio
+Author: Your Name
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+
+# Regression Library
+
+A lightweight, from-scratch linear and multiple regression library implemented in Python with NumPy. Perfect for educational demonstration, portfolios, and quick testing of regression mechanics.
+
+## Features
+
+- **Simple Linear Regression**: Supports Batch Gradient Descent with complete loss and coefficient history, and closed-form OLS estimation.
+- **Multiple Linear Regression**: Analytical Normal Equation solver for multidimensional datasets.
+- **Visualization & Animation**: Real-time animation of gradient descent fitting and static regression line plotting with Matplotlib.
+- **Dataset Loaders**: Pre-packaged synthetic generators and subsets of classic real datasets (Iris and Housing).
+
+## Quick Start
+
+### Installation
+
+Clone the repository and install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Running the Interactive Demo
+
+To explore interactive fits on various datasets and watch the live training animation:
+
+```bash
+python main.py
+```
+
+### Library Usage
+
+You can easily import and train models in your own scripts:
+
+```python
+from data_blog import LinearRegression, x, y
+
+# Instantiate and fit using Gradient Descent
+model = LinearRegression(learning_rate=0.01, epochs=1000)
+model.fit(x, y)
+
+print(f"Intercept: {model.b_0:.4f}")
+print(f"Slope: {model.b_1:.4f}")
+print(f"R-squared Score: {model.score(x, y):.4f}")
+```

data_blog_regression-0.1.0/README.md

@@ -0,0 +1,44 @@
+# Regression Library
+
+A lightweight, from-scratch linear and multiple regression library implemented in Python with NumPy. Perfect for educational demonstration, portfolios, and quick testing of regression mechanics.
+
+## Features
+
+- **Simple Linear Regression**: Supports Batch Gradient Descent with complete loss and coefficient history, and closed-form OLS estimation.
+- **Multiple Linear Regression**: Analytical Normal Equation solver for multidimensional datasets.
+- **Visualization & Animation**: Real-time animation of gradient descent fitting and static regression line plotting with Matplotlib.
+- **Dataset Loaders**: Pre-packaged synthetic generators and subsets of classic real datasets (Iris and Housing).
+
+## Quick Start
+
+### Installation
+
+Clone the repository and install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Running the Interactive Demo
+
+To explore interactive fits on various datasets and watch the live training animation:
+
+```bash
+python main.py
+```
+
+### Library Usage
+
+You can easily import and train models in your own scripts:
+
+```python
+from data_blog import LinearRegression, x, y
+
+# Instantiate and fit using Gradient Descent
+model = LinearRegression(learning_rate=0.01, epochs=1000)
+model.fit(x, y)
+
+print(f"Intercept: {model.b_0:.4f}")
+print(f"Slope: {model.b_1:.4f}")
+print(f"R-squared Score: {model.score(x, y):.4f}")
+```

data_blog_regression-0.1.0/data_blog/__init__.py

@@ -0,0 +1,41 @@
+"""
+From-Scratch Linear Regression Library.
+
+A educational, lightweight machine learning package implementing simple and multiple
+linear regression algorithms from scratch using NumPy.
+
+Features:
+- `LinearRegression`: Supports gradient descent fitting and analytical closed-form (OLS) fitting.
+- `MultipleLinearRegression`: Normal equation solver for multidimensional features.
+- `data_blog.animate`: Visualization utilities to animate gradient descent fitting and plot regression lines.
+- Synthetic and Classic dataset generators/loaders for testing and comparative benchmarking.
+"""
+
+from .data import (
+    x,
+    x_test,
+    y,
+    y_test,
+    x_multi_test,
+    y_multi_test,
+    make_simple_regression,
+    make_multiple_regression,
+    load_iris_regression,
+    load_housing_regression,
+)
+from .linear_regression import LinearRegression, MultipleLinearRegression
+
+__all__ = [
+    "LinearRegression",
+    "MultipleLinearRegression",
+    "x",
+    "y",
+    "x_test",
+    "y_test",
+    "x_multi_test",
+    "y_multi_test",
+    "make_simple_regression",
+    "make_multiple_regression",
+    "load_iris_regression",
+    "load_housing_regression",
+]

data_blog_regression-0.1.0/data_blog/animate/__init__.py

@@ -0,0 +1,3 @@
+from .track import plot_regression_line, animate_regression_fitting
+
+__all__ = ["plot_regression_line", "animate_regression_fitting"]

data_blog_regression-0.1.0/data_blog/animate/track.py

@@ -0,0 +1,160 @@
+"""
+Visualization and animation utilities for monitoring regression fitting.
+
+This module provides functions to plot fitted regression lines and create real-time
+animations of the gradient descent optimization process, tracking how loss decreases.
+"""
+
+import os
+from typing import Union, List, Optional
+import matplotlib
+
+# Headless environment detection: use Agg backend if no DISPLAY is present
+if "DISPLAY" not in os.environ and not os.environ.get("MPLBACKEND"):
+    matplotlib.use("Agg")
+
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+import numpy as np
+from data_blog import LinearRegression, x, y
+
+
+def plot_regression_line(
+    x: Union[List[float], np.ndarray],
+    y: Union[List[float], np.ndarray],
+    model: LinearRegression
+) -> None:
+    """
+    Plot a static 2D scatter plot of the data along with the fitted regression line.
+
+    Parameters
+    ----------
+    x : array-like of shape (n_samples,)
+        Input feature values.
+    y : array-like of shape (n_samples,)
+        True target values.
+    model : LinearRegression
+        A fitted simple linear regression model containing `b_0` and `b_1`.
+    """
+    x_arr = np.asarray(x, dtype=float)
+    y_arr = np.asarray(y, dtype=float)
+    plt.figure()
+    plt.scatter(x_arr, y_arr, color="blue", label="Data Points")
+
+    # Generate points along x for the line
+    x_line = np.linspace(min(x_arr), max(x_arr), 100)
+    y_line = model.b_1 * x_line + model.b_0
+
+    plt.plot(x_line, y_line, color="red", label="Regression Line")
+    plt.xlabel("x")
+    plt.ylabel("y")
+    plt.title("Linear Regression Fit")
+    plt.legend()
+    plt.show()
+
+
+def animate_regression_fitting(
+    x: Union[List[float], np.ndarray],
+    y: Union[List[float], np.ndarray],
+    model: LinearRegression,
+    save_path: Optional[str] = None
+) -> FuncAnimation:
+    """
+    Create an interactive animation showing the regression line and loss history over epochs.
+
+    Requires that the provided `model` has been fitted and contains `coeff_history`
+    and `loss_history`.
+
+    Parameters
+    ----------
+    x : array-like of shape (n_samples,)
+        Input feature values.
+    y : array-like of shape (n_samples,)
+        True target values.
+    model : LinearRegression
+        A fitted simple linear regression model with training history.
+    save_path : str or None, default=None
+        Optional file path (e.g., 'fitting.gif') to save the animation using Pillow.
+
+    Returns
+    -------
+    FuncAnimation
+        The matplotlib FuncAnimation object.
+    """
+    if not hasattr(model, "coeff_history") or not model.coeff_history:
+        raise ValueError(
+            "Model has not been fitted or does not have coefficient history."
+        )
+
+    x_arr = np.asarray(x, dtype=float)
+    y_arr = np.asarray(y, dtype=float)
+
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+
+    # Left subplot: Data Points and Regression Line
+    ax1.scatter(x_arr, y_arr, color="blue", label="Data Points")
+    (line,) = ax1.plot([], [], color="red", lw=2, label="Fitting Line")
+    ax1.set_xlim(min(x_arr) - 1, max(x_arr) + 1)
+    ax1.set_ylim(min(y_arr) - 2, max(y_arr) + 2)
+    ax1.set_xlabel("x")
+    ax1.set_ylabel("y")
+    ax1.set_title("Linear Regression Fit")
+    ax1.legend()
+
+    # Right subplot: Loss Curve
+    (loss_line,) = ax2.plot([], [], color="purple", lw=2, label="MSE Loss")
+    ax2.set_xlim(0, len(model.loss_history))
+    ax2.set_ylim(0, max(model.loss_history) * 1.1 if model.loss_history else 1.0)
+    ax2.set_xlabel("Epoch")
+    ax2.set_ylabel("Loss (MSE)")
+    ax2.set_title("Loss Curve History")
+    ax2.legend()
+
+    def init():
+        line.set_data([], [])
+        loss_line.set_data([], [])
+        return line, loss_line
+
+    # Downsample history to keep the animation fast and smooth (max 100 frames)
+    history_len = len(model.coeff_history)
+    max_frames = 100
+    if history_len > max_frames:
+        indices = np.linspace(0, history_len - 1, max_frames, dtype=int)
+    else:
+        indices = list(range(history_len))
+
+    def update(frame_idx):
+        idx = indices[frame_idx]
+        b_0, b_1 = model.coeff_history[idx]
+        y_pred = b_1 * x_arr + b_0
+        line.set_data(x_arr, y_pred)
+        loss_line.set_data(range(idx + 1), model.loss_history[: idx + 1])
+        return line, loss_line
+
+    anim = FuncAnimation(
+        fig,
+        update,
+        frames=len(indices),
+        init_func=init,
+        interval=50,
+        blit=True,
+    )
+
+    if save_path:
+        anim.save(save_path, writer="pillow")
+    else:
+        plt.tight_layout()
+        plt.show()
+
+    return anim
+
+
+if __name__ == "__main__":
+    # Test execution when run as a standalone script
+    print("Fitting model...")
+    model = LinearRegression(learning_rate=0.01, epochs=5)
+    model.fit(x, y)
+    print("Generating static plot...")
+    plot_regression_line(x, y, model)
+    print("Generating interactive animation...")
+    animate_regression_fitting(x, y, model)

data_blog_regression-0.1.0/data_blog/data.py

@@ -0,0 +1,222 @@
+"""
+Utility functions and datasets for training and testing regression models.
+
+This module provides original toy datasets, synthetic data generators for simple
+and multiple linear regression, and subsets of classic datasets (Iris and Housing).
+"""
+
+import numpy as np
+from typing import Tuple, List, Optional, Union
+
+# Toy dataset for simple linear regression demonstration (8 data points)
+x: List[float] = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0]
+y: List[float] = [2.1, 3.9, 6.2, 7.8, 10.3, 11.7, 13.9, 16.2]
+
+# Test dataset for simple linear regression validation
+x_test: List[float] = [7.0, 8.0]
+y_test: List[float] = [13.9, 16.2]
+
+# Sample multiple features data (5 samples, 2 features)
+x_multi_test: np.ndarray = np.array([[1.0, 4.0], [2.0, 1.0], [3.0, 0.0], [4.0, 2.0], [5.0, 5.0]])
+y_multi_test: np.ndarray = np.array([0.0, 9.0, 14.0, 13.0, 10.0])
+
+
+def make_simple_regression(
+    n_samples: int = 100,
+    slope: float = 2.0,
+    intercept: float = 1.0,
+    noise: float = 1.0,
+    random_seed: Optional[int] = 42
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generate synthetic data for simple linear regression.
+
+    Generates data according to: y = slope * x + intercept + gaussian_noise.
+
+    Parameters
+    ----------
+    n_samples : int, default=100
+        Number of data samples to generate.
+    slope : float, default=2.0
+        The true coefficient (slope) of the data.
+    intercept : float, default=1.0
+        The true intercept (y-intercept) of the data.
+    noise : float, default=1.0
+        Standard deviation of the gaussian noise added to the target.
+    random_seed : int or None, default=42
+        Seed for the random number generator to ensure reproducibility.
+
+    Returns
+    -------
+    x_arr : np.ndarray of shape (n_samples,)
+        Generated input features.
+    y_arr : np.ndarray of shape (n_samples,)
+        Generated target values.
+    """
+    if random_seed is not None:
+        np.random.seed(random_seed)
+
+    x_arr = np.random.uniform(-10.0, 10.0, n_samples)
+    noise_arr = np.random.normal(0.0, noise, n_samples)
+    y_arr = slope * x_arr + intercept + noise_arr
+
+    return x_arr, y_arr
+
+
+def make_multiple_regression(
+    n_samples: int = 100,
+    n_features: int = 3,
+    weights: Optional[Union[List[float], np.ndarray]] = None,
+    intercept: float = 1.0,
+    noise: float = 1.0,
+    random_seed: Optional[int] = 42
+) -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Generate synthetic data for multiple linear regression.
+
+    Generates data according to: y = X @ weights + intercept + gaussian_noise.
+
+    Parameters
+    ----------
+    n_samples : int, default=100
+        Number of data samples to generate.
+    n_features : int, default=3
+        Number of features to generate. Ignored if `weights` is specified.
+    weights : array-like of shape (n_features,) or None, default=None
+        True coefficients for each feature. If None, weights are generated randomly.
+    intercept : float, default=1.0
+        The true intercept of the data.
+    noise : float, default=1.0
+        Standard deviation of the gaussian noise added to the target.
+    random_seed : int or None, default=42
+        Seed for the random number generator.
+
+    Returns
+    -------
+    X : np.ndarray of shape (n_samples, n_features)
+        Generated input feature matrix.
+    y : np.ndarray of shape (n_samples,)
+        Generated target values.
+    """
+    if random_seed is not None:
+        np.random.seed(random_seed)
+
+    if weights is None:
+        actual_weights = np.random.uniform(1.0, 5.0, n_features)
+    else:
+        actual_weights = np.asarray(weights, dtype=float)
+        n_features = len(actual_weights)
+
+    X = np.random.uniform(-5.0, 5.0, size=(n_samples, n_features))
+    noise_arr = np.random.normal(0.0, noise, n_samples)
+    y = X @ actual_weights + intercept + noise_arr
+
+    return X, y
+
+
+def load_iris_regression() -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Load a small slice of the classic Iris dataset for simple linear regression.
+
+    Features (X) : Petal Width (cm)
+    Target (y)   : Petal Length (cm)
+
+    Returns
+    -------
+    X : np.ndarray of shape (40,)
+        Petal Width features.
+    y : np.ndarray of shape (40,)
+        Petal Length target values.
+    """
+    # 40 real samples from Setosa, Versicolor, and Virginica classes
+    iris_raw = [
+        [0.2, 1.4],
+        [0.2, 1.4],
+        [0.2, 1.3],
+        [0.2, 1.5],
+        [0.2, 1.4],
+        [0.4, 1.7],
+        [0.3, 1.4],
+        [0.2, 1.5],
+        [0.2, 1.4],
+        [0.1, 1.5],
+        [0.2, 1.5],
+        [0.2, 1.6],
+        [0.1, 1.4],
+        [0.1, 1.1],
+        [0.2, 1.2],
+        [0.4, 1.5],
+        [0.4, 1.3],
+        [0.3, 1.4],
+        [0.3, 1.7],
+        [0.3, 1.5],
+        [1.4, 4.7],
+        [1.5, 4.5],
+        [1.5, 4.9],
+        [1.3, 4.0],
+        [1.5, 4.6],
+        [1.3, 4.5],
+        [1.6, 4.7],
+        [1.0, 3.3],
+        [1.3, 4.6],
+        [1.4, 3.9],
+        [2.5, 6.0],
+        [1.9, 5.1],
+        [2.1, 5.9],
+        [1.8, 5.6],
+        [2.2, 5.8],
+        [2.1, 6.6],
+        [1.7, 4.5],
+        [1.8, 4.8],
+        [1.8, 5.4],
+        [2.5, 5.7],
+    ]
+    data = np.array(iris_raw)
+    X = data[:, 0]  # Petal Width
+    y = data[:, 1]  # Petal Length
+    return X, y
+
+
+def load_housing_regression() -> Tuple[np.ndarray, np.ndarray]:
+    """
+    Load a toy housing price dataset for multiple linear regression.
+
+    Features (X) : Matrix of shape (20, 3) representing:
+                   - Square Footage (in hundreds of sq ft)
+                   - Number of Bedrooms
+                   - Age of the property (in years)
+    Target (y)   : Array of shape (20,) representing house price (in thousands of dollars)
+
+    Returns
+    -------
+    X : np.ndarray of shape (20, 3)
+        Feature matrix.
+    y : np.ndarray of shape (20,)
+        Target values (House Prices).
+    """
+    housing_raw = [
+        [15.0, 3, 10, 350.0],
+        [20.0, 4, 5, 480.0],
+        [12.0, 2, 15, 270.0],
+        [18.0, 3, 8, 410.0],
+        [25.0, 4, 2, 590.0],
+        [14.0, 3, 20, 290.0],
+        [22.0, 4, 12, 450.0],
+        [16.0, 3, 14, 330.0],
+        [30.0, 5, 1, 720.0],
+        [10.0, 2, 30, 180.0],
+        [19.0, 3, 6, 435.0],
+        [21.0, 4, 4, 495.0],
+        [13.0, 2, 18, 285.0],
+        [17.0, 3, 11, 365.0],
+        [24.0, 4, 3, 560.0],
+        [11.0, 2, 25, 210.0],
+        [28.0, 5, 2, 680.0],
+        [15.5, 3, 9, 360.0],
+        [20.5, 4, 7, 470.0],
+        [23.0, 4, 5, 520.0],
+    ]
+    data = np.array(housing_raw)
+    X = data[:, :3]  # [Square Footage, Bedrooms, Age]
+    y = data[:, 3]  # Price
+    return X, y

data_blog_regression-0.1.0/data_blog/linear_regression.py

@@ -0,0 +1,244 @@
+"""
+From-scratch implementations of Linear Regression and Multiple Linear Regression.
+
+These classes are built using Python and NumPy, demonstrating both gradient descent
+and closed-form analytical solutions (Ordinary Least Squares/Normal Equation).
+"""
+
+import numpy as np
+from typing import Union, List, Tuple, Optional
+from .utils import func
+
+
+class LinearRegression:
+    """
+    Simple Linear Regression model supporting both Gradient Descent and
+    Ordinary Least Squares (OLS) closed-form estimation.
+
+    Parameters
+    ----------
+    learning_rate : float, default=0.001
+        The step size used for updating parameters during gradient descent.
+    epochs : int, default=1000
+        The number of training iterations for gradient descent.
+
+    Attributes
+    ----------
+    b_0 : float
+        The intercept of the regression line (bias). Default is 0.0.
+    b_1 : float
+        The slope of the regression line (weight). Default is 0.0.
+    loss_history : list of float
+        A list storing the Mean Squared Error (MSE) loss value at each epoch.
+    coeff_history : list of tuple of (float, float)
+        A history of (intercept, slope) tuples recorded at each epoch or step.
+    coeff : tuple of (float, float)
+        The final trained coefficients (b_0, b_1).
+    """
+
+    def __init__(self, learning_rate: float = 0.001, epochs: int = 1000) -> None:
+        self.learning_rate: float = learning_rate
+        self.epochs: int = epochs
+        self.b_0: float = 0.0
+        self.b_1: float = 0.0
+        self.loss_history: List[float] = []
+        self.coeff_history: List[Tuple[float, float]] = []
+        self.coeff: Tuple[float, float] = (0.0, 0.0)
+
+    def fit(self, x: Union[List[float], np.ndarray], y: Union[List[float], np.ndarray]) -> None:
+        """
+        Fit the model coefficients using Batch Gradient Descent.
+
+        Parameters
+        ----------
+        x : array-like of shape (n_samples,)
+            Training input features.
+        y : array-like of shape (n_samples,)
+            Target values.
+        """
+        x_arr = np.asarray(x, dtype=float)
+        y_arr = np.asarray(y, dtype=float)
+        n = len(x_arr)
+        
+        self.loss_history = []
+        self.coeff_history = []
+
+        for _ in range(self.epochs):
+            # Vectorized prediction
+            y_pred = self.b_1 * x_arr + self.b_0
+            errors = y_pred - y_arr
+
+            # Vectorized gradients
+            grad_b0 = (2.0 / n) * np.sum(errors)
+            grad_b1 = (2.0 / n) * np.sum(errors * x_arr)
+
+            # Update weights
+            self.b_0 -= self.learning_rate * grad_b0
+            self.b_1 -= self.learning_rate * grad_b1
+
+            self.loss_history.append(float(np.mean(errors ** 2)))
+            self.coeff_history.append((self.b_0, self.b_1))
+            
+        self.coeff = (self.b_0, self.b_1)
+
+    def fit_ols(self, x: Union[List[float], np.ndarray], y: Union[List[float], np.ndarray]) -> None:
+        """
+        Fit the model coefficients using Ordinary Least Squares (OLS) closed-form equations.
+
+        Parameters
+        ----------
+        x : array-like of shape (n_samples,)
+            Training input features.
+        y : array-like of shape (n_samples,)
+            Target values.
+        """
+        x_arr = np.asarray(x, dtype=float)
+        y_arr = np.asarray(y, dtype=float)
+
+        mean_x, mean_y = np.mean(x_arr), np.mean(y_arr)
+        numerator = np.sum((x_arr - mean_x) * (y_arr - mean_y))
+        denominator = np.sum((x_arr - mean_x) ** 2)
+
+        if denominator == 0.0:
+            self.b_1 = 0.0
+        else:
+            self.b_1 = float(numerator / denominator)
+            
+        self.b_0 = float(mean_y - self.b_1 * mean_x)
+        self.coeff = (self.b_0, self.b_1)
+        self.coeff_history = [(self.b_0, self.b_1)]
+
+    def predict(self, x: Union[float, List[float], np.ndarray]) -> Union[float, List[float]]:
+        """
+        Predict target values using the linear model: y = b_1 * x + b_0.
+
+        Parameters
+        ----------
+        x : float or array-like
+            Input features to predict.
+
+        Returns
+        -------
+        float or list of float
+            Predicted target values matching the type/shape of the input.
+        """
+        if isinstance(x, (list, tuple, np.ndarray)):
+            return [float(func(xi, b=self.b_0, m=self.b_1)) for xi in x]
+        return float(func(x, b=self.b_0, m=self.b_1))
+
+    def score(self, x: Union[List[float], np.ndarray], y: Union[List[float], np.ndarray]) -> float:
+        """
+        Calculate the Coefficient of Determination (R^2 score) of the prediction.
+
+        Parameters
+        ----------
+        x : array-like of shape (n_samples,)
+            Test input features.
+        y : array-like of shape (n_samples,)
+            True target values.
+
+        Returns
+        -------
+        float
+            R^2 score. A value of 1.0 indicates perfect fit.
+        """
+        x_arr = np.asarray(x, dtype=float)
+        y_arr = np.asarray(y, dtype=float)
+        y_pred = np.array(self.predict(x_arr), dtype=float)
+
+        ss_res = np.sum((y_arr - y_pred) ** 2)
+        ss_tot = np.sum((y_arr - np.mean(y_arr)) ** 2)
+
+        if ss_tot == 0.0:
+            return 0.0
+        return float(1.0 - (ss_res / ss_tot))
+
+
+class MultipleLinearRegression:
+    """
+    Multiple Linear Regression model using the closed-form Normal Equation.
+
+    Attributes
+    ----------
+    weights : np.ndarray or None
+        Coefficients for the input features (excluding the intercept).
+    intercept : float or None
+        The intercept of the regression hyperplane (bias).
+    """
+
+    def __init__(self) -> None:
+        self.weights: Optional[np.ndarray] = None
+        self.intercept: Optional[float] = None
+
+    def fit(self, X: Union[List[List[float]], np.ndarray], y: Union[List[float], np.ndarray]) -> None:
+        """
+        Fit the multiple linear model using the Normal Equation:
+        theta = (X^T * X)^(-1) * X^T * y
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training input features.
+        y : array-like of shape (n_samples,)
+            Target values.
+        """
+        X_arr = np.asarray(X, dtype=float)
+        y_arr = np.asarray(y, dtype=float)
+        
+        # Add bias term (column of 1s) to feature matrix
+        X_b = np.c_[np.ones(X_arr.shape[0]), X_arr]
+        
+        # Normal Equation solver
+        theta = np.linalg.inv(X_b.T @ X_b) @ X_b.T @ y_arr
+        self.intercept = float(theta[0])
+        self.weights = theta[1:]
+
+    def predict(self, X: Union[List[List[float]], np.ndarray]) -> np.ndarray:
+        """
+        Predict target values for multiple features.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Input features to predict.
+
+        Returns
+        -------
+        np.ndarray of shape (n_samples,)
+            Predicted target values.
+
+        Raises
+        ------
+        ValueError
+            If the model has not been fitted prior to prediction.
+        """
+        X_arr = np.asarray(X, dtype=float)
+        if self.weights is None or self.intercept is None:
+            raise ValueError("Model must be fitted before calling predict.")
+        return X_arr @ self.weights + self.intercept
+
+    def score(self, X: Union[List[List[float]], np.ndarray], y: Union[List[float], np.ndarray]) -> float:
+        """
+        Calculate the Coefficient of Determination (R^2 score) of the prediction.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Test input features.
+        y : array-like of shape (n_samples,)
+            True target values.
+
+        Returns
+        -------
+        float
+            R^2 score. A value of 1.0 indicates perfect fit.
+        """
+        X_arr = np.asarray(X, dtype=float)
+        y_arr = np.asarray(y, dtype=float)
+        preds = self.predict(X_arr)
+        ss_res = np.sum((y_arr - preds) ** 2)
+        ss_tot = np.sum((y_arr - np.mean(y_arr)) ** 2)
+        
+        if ss_tot == 0.0:
+            return 0.0
+        return float(1.0 - (ss_res / ss_tot))

data_blog_regression-0.1.0/data_blog/utils.py

@@ -0,0 +1,23 @@
+"""
+Utility functions for linear regression operations.
+"""
+
+def func(x: float, m: float = 0.0, b: float = 0.0) -> float:
+    """
+    Compute the linear function y = m * x + b.
+
+    Parameters
+    ----------
+    x : float
+        The input feature value.
+    m : float, default=0.0
+        The slope of the line (weight).
+    b : float, default=0.0
+        The y-intercept (bias).
+
+    Returns
+    -------
+    float
+        The calculated function value.
+    """
+    return m * x + b

data_blog_regression-0.1.0/data_blog_regression.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: data-blog-regression
+Version: 0.1.0
+Summary: From-scratch linear and multiple regression library for the Data Blog portfolio
+Author: Your Name
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.21
+
+# Regression Library
+
+A lightweight, from-scratch linear and multiple regression library implemented in Python with NumPy. Perfect for educational demonstration, portfolios, and quick testing of regression mechanics.
+
+## Features
+
+- **Simple Linear Regression**: Supports Batch Gradient Descent with complete loss and coefficient history, and closed-form OLS estimation.
+- **Multiple Linear Regression**: Analytical Normal Equation solver for multidimensional datasets.
+- **Visualization & Animation**: Real-time animation of gradient descent fitting and static regression line plotting with Matplotlib.
+- **Dataset Loaders**: Pre-packaged synthetic generators and subsets of classic real datasets (Iris and Housing).
+
+## Quick Start
+
+### Installation
+
+Clone the repository and install dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Running the Interactive Demo
+
+To explore interactive fits on various datasets and watch the live training animation:
+
+```bash
+python main.py
+```
+
+### Library Usage
+
+You can easily import and train models in your own scripts:
+
+```python
+from data_blog import LinearRegression, x, y
+
+# Instantiate and fit using Gradient Descent
+model = LinearRegression(learning_rate=0.01, epochs=1000)
+model.fit(x, y)
+
+print(f"Intercept: {model.b_0:.4f}")
+print(f"Slope: {model.b_1:.4f}")
+print(f"R-squared Score: {model.score(x, y):.4f}")
+```

data_blog_regression-0.1.0/data_blog_regression.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+README.md
+pyproject.toml
+data_blog/__init__.py
+data_blog/data.py
+data_blog/linear_regression.py
+data_blog/utils.py
+data_blog/animate/__init__.py
+data_blog/animate/track.py
+data_blog_regression.egg-info/PKG-INFO
+data_blog_regression.egg-info/SOURCES.txt
+data_blog_regression.egg-info/dependency_links.txt
+data_blog_regression.egg-info/requires.txt
+data_blog_regression.egg-info/top_level.txt
+tests/test_linear.py

data_blog_regression-0.1.0/data_blog_regression.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

data_blog_regression-0.1.0/data_blog_regression.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy>=1.21

data_blog_regression-0.1.0/data_blog_regression.egg-info/top_level.txt

@@ -0,0 +1 @@
+data_blog

data_blog_regression-0.1.0/pyproject.toml

@@ -0,0 +1,15 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "data-blog-regression"
+version = "0.1.0"
+description = "From-scratch linear and multiple regression library for the Data Blog portfolio"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [ { name = "Your Name" } ]
+dependencies = [
+  "numpy>=1.21"
+]

data_blog_regression-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

data_blog_regression-0.1.0/tests/test_linear.py

@@ -0,0 +1,195 @@
+import math
+
+import numpy as np
+import pytest
+from sklearn.linear_model import LinearRegression as SklearnLinearRegression
+from sklearn.metrics import r2_score
+
+from data_blog import (
+    LinearRegression,
+    MultipleLinearRegression,
+    x,
+    x_multi_test,
+    x_test,
+    y,
+    y_multi_test,
+    y_test,
+    make_simple_regression,
+    make_multiple_regression,
+    load_iris_regression,
+    load_housing_regression,
+)
+
+
+@pytest.fixture
+def model():
+    model = LinearRegression(learning_rate=0.01, epochs=1000)
+    model_ols = LinearRegression()
+    model_ols.fit_ols(x, y)
+    model.fit(x, y)
+    yield model, model_ols
+    del model
+
+def test_fit_changes_coefficients():
+    model = LinearRegression(learning_rate=0.01, epochs=10)
+    initial_b0, initial_b1 = model.b_0, model.b_1
+    model.fit(x, y)
+    assert not (
+        math.isclose(model.b_0, initial_b0) and math.isclose(model.b_1, initial_b1)
+    )
+
+def test_score_calculates_r_squared(model):
+    model, _ = model
+    r_squared = model.score(x, y)
+    assert isinstance(r_squared, float)
+    assert 0 <= r_squared <= 1
+
+def test_predict_returns_expected_values(model):
+    model, _ = model
+    predictions = model.predict(x)
+    assert len(predictions) == len(x)
+    assert all(isinstance(pred, (int, float)) for pred in predictions)
+
+def test_coefficients_close_to_expected(model):
+    model, _ = model
+    expected_b0 = 0.0
+    expected_b1 = 2.0
+    assert math.isclose(model.b_0, expected_b0, abs_tol=0.1)
+    assert math.isclose(model.b_1, expected_b1, abs_tol=0.1)
+    assert model.coeff == (model.b_0, model.b_1)
+
+def test_r_square_to_sklearn(model):
+    model, _ = model
+    sklearn_model = SklearnLinearRegression()
+    sklearn_model.fit(np.array(x).reshape(-1, 1), y)
+    sklearn_r2 = sklearn_model.score(np.array(x).reshape(-1, 1), y)
+    model_r2 = model.score(x, y)
+    assert math.isclose(model_r2, sklearn_r2, abs_tol=0.01)
+
+def test_predict_on_test_data(model):
+    model, _ = model
+    predictions = model.predict(x_test)
+    assert len(predictions) == len(x_test)
+    assert all(isinstance(pred, (int, float)) for pred in predictions)
+    r2 = r2_score(y_test, predictions)
+    assert r2 > 0.9
+
+def test_ols_coefficients_close_to_expected(model):
+    model, model_ols = model
+    expected_b0 = 0.0
+    expected_b1 = 2.0
+    assert math.isclose(model_ols.b_0, expected_b0, abs_tol=0.1)
+    assert math.isclose(model_ols.b_1, expected_b1, abs_tol=0.1)
+    assert model_ols.coeff == (model_ols.b_0, model_ols.b_1)
+
+def test_ols_r_square_to_sklearn(model):
+    model, model_ols = model
+    sklearn_model = SklearnLinearRegression()
+    sklearn_model.fit(np.array(x).reshape(-1, 1), y)
+    sklearn_r2 = sklearn_model.score(np.array(x).reshape(-1, 1), y)
+    model_ols_r2 = model_ols.score(x, y)
+    assert math.isclose(model_ols_r2, sklearn_r2, abs_tol=0.01)
+
+def test_ols_predict_on_test_data(model):
+    model, model_ols = model
+    predictions = model_ols.predict(x_test)
+    assert len(predictions) == len(x_test)
+    assert all(isinstance(pred, (int, float)) for pred in predictions)
+    r2 = r2_score(y_test, predictions)
+    assert r2 > 0.9
+
+
+def test_multiple_regression_vs_sklearn():
+    model = MultipleLinearRegression()
+    model.fit(x_multi_test, y_multi_test)
+
+    sklearn_model = SklearnLinearRegression()
+    sklearn_model.fit(x_multi_test, y_multi_test)
+
+    assert math.isclose(model.intercept, sklearn_model.intercept_, abs_tol=1e-5)
+    assert np.allclose(model.weights, sklearn_model.coef_, atol=1e-5)
+
+    preds = model.predict(x_multi_test)
+    sklearn_preds = sklearn_model.predict(x_multi_test)
+    assert np.allclose(preds, sklearn_preds, atol=1e-5)
+
+    score = model.score(x_multi_test, y_multi_test)
+    sklearn_score = sklearn_model.score(x_multi_test, y_multi_test)
+    assert math.isclose(score, sklearn_score, abs_tol=1e-5)
+
+
+def test_plot_regression_line():
+    from unittest.mock import patch
+    from data_blog.animate import plot_regression_line
+
+    model = LinearRegression(learning_rate=0.01, epochs=10)
+    model.fit(x, y)
+
+    with patch("matplotlib.pyplot.show") as mock_show:
+        plot_regression_line(x, y, model)
+        mock_show.assert_called_once()
+
+
+def test_animate_regression_fitting():
+    from unittest.mock import patch
+    from data_blog.animate import animate_regression_fitting
+
+    model = LinearRegression(learning_rate=0.01, epochs=10)
+    model.fit(x, y)
+
+    with patch("matplotlib.pyplot.show") as mock_show:
+        anim = animate_regression_fitting(x, y, model)
+        assert anim is not None
+        mock_show.assert_called_once()
+
+
+def test_make_simple_regression():
+    X, y = make_simple_regression(n_samples=50, slope=3.0, intercept=-2.0, noise=0.5, random_seed=123)
+    assert len(X) == 50
+    assert len(y) == 50
+    
+    # Fit OLS model on the generated data
+    model = LinearRegression()
+    model.fit_ols(X, y)
+    
+    # Should be close to slope 3.0 and intercept -2.0
+    assert math.isclose(model.b_1, 3.0, abs_tol=0.2)
+    assert math.isclose(model.b_0, -2.0, abs_tol=0.2)
+
+
+def test_make_multiple_regression():
+    X, y = make_multiple_regression(n_samples=100, n_features=4, weights=[1.5, -2.0, 0.5, 3.0], intercept=10.0, noise=0.1, random_seed=42)
+    assert X.shape == (100, 4)
+    assert len(y) == 100
+    
+    model = MultipleLinearRegression()
+    model.fit(X, y)
+    
+    assert math.isclose(model.intercept, 10.0, abs_tol=0.1)
+    assert np.allclose(model.weights, [1.5, -2.0, 0.5, 3.0], atol=0.1)
+
+
+def test_load_iris_regression():
+    X, y = load_iris_regression()
+    assert len(X) == 40
+    assert len(y) == 40
+    
+    model = LinearRegression()
+    model.fit_ols(X, y)
+    
+    score = model.score(X, y)
+    assert score > 0.90  # Iris petal width vs length has a strong correlation
+
+
+def test_load_housing_regression():
+    X, y = load_housing_regression()
+    assert X.shape == (20, 3)
+    assert len(y) == 20
+    
+    model = MultipleLinearRegression()
+    model.fit(X, y)
+    
+    score = model.score(X, y)
+    assert score > 0.95  # Our synthetic housing data fits very well
+
+