linesight 0.1.0__tar.gz

linesight-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 LineSight Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

linesight-0.1.0/PKG-INFO

@@ -0,0 +1,160 @@
+Metadata-Version: 2.4
+Name: linesight
+Version: 0.1.0
+Summary: Educational regression library with tutor-style explanations and visualizations
+Home-page: https://github.com/AnshumanTiwari2006/linesight
+Author: Anshuman Tiwari
+License: MIT
+Project-URL: Homepage, https://github.com/AnshumanTiwari2006/linesight
+Project-URL: Bug Tracker, https://github.com/AnshumanTiwari2006/linesight/issues
+Keywords: machine-learning,regression,education,visualization,gradient-descent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: matplotlib>=3.6
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pandas>=1.5; extra == "dev"
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# LineSight 🔍
+
+**LineSight** is an educational, "glass-box" machine learning library built for understanding—not just executing—regression models. 
+
+Where traditional libraries like `scikit-learn` act as black boxes (you put data in, you get predictions out), LineSight is explicitly designed to teach you **how** the algorithm works under the hood. Every model can visually show you its loss surface, animate its gradient descent path, and explain its mathematical equations in plain English.
+
+---
+
+## 🏗️ Library Architecture
+
+LineSight is built on a strict, pedagogical tri-layer design. Every single model in the library is broken down into three distinct modules:
+
+1. **`engine` (The Math)**
+   The core implementation using pure NumPy. Instead of opaque, heavily-optimized C-extensions, the engines are written in highly readable Python. We use explicit `weights` and `bias` variables instead of unified `theta` vectors so the code reads exactly like a textbook formula.
+   
+2. **`explain` (The Interpretation)**
+   A suite of functions that translate the mathematical state of the model into plain-English sentences. It explains the effect of the L2 penalty, parses out the slope coefficient, and dynamically tells you what the model learned.
+
+3. **`visualization` (The Proof)**
+   A massive collection of Matplotlib-based functions. You can visualize the dataset, the residuals, the 3D loss surface, and even generate live animations of the algorithm learning step-by-step.
+
+---
+
+## 🧠 The Models
+
+LineSight currently implements 6 foundational regression models, each designed to teach a specific mathematical concept:
+
+| Model | Algorithm | What it teaches |
+|---|---|---|
+| `LinearRegression` | Gradient Descent | The baseline concept of minimizing Mean Squared Error (MSE). |
+| `MultipleLinearRegression` | Gradient Descent | Dealing with planes, hyperplanes, and multicollinearity. |
+| `PolynomialRegression` | Gradient Descent | Basis expansion and the bias-variance tradeoff (underfitting vs overfitting). |
+| `RidgeRegression` | Gradient Descent | L2 Regularization (weight decay) to handle correlated features. |
+| `LassoRegression` | Coordinate Descent | L1 Regularization and automatic feature selection (sparsity). |
+| `ElasticNetRegression` | Coordinate Descent | Blending L1 and L2 penalties via the `l1_ratio`. |
+| `LogisticRegression` | Gradient Descent | Binary classification, the Sigmoid function, and Log Loss. |
+
+---
+
+## ⚡ The Unified API
+
+All models strictly follow a unified, `scikit-learn`-style API, meaning you already know how to use them. 
+
+### 1. Core Execution
+```python
+model = RidgeRegression(alpha=0.1, learning_rate=0.01)
+model.fit(X, y)                    # Trains the model
+predictions = model.predict(X)     # Generates predictions
+metrics = model.score(X, y)        # Returns {'r2', 'rmse', 'mae', 'mse'}
+```
+
+### 2. Context Panels & Explanations
+Every visualization and summary natively includes **Context Panels**—live, dynamically generated text boxes attached directly to the plots that explain the theory, the formula, and how to read the chart.
+```python
+model.summary()                    # Prints training summary and final metrics
+model.show_equation()              # Prints the literal mathematical formula (e.g., y = 3.5x + 1.2)
+model.explain_regularization()     # Explains the specific L1/L2 penalty active in the model
+```
+
+### 3. Visualizations & Animations
+Instead of just returning predictions, LineSight lets you look inside the optimization process:
+```python
+# Visualize the exact distance (error) of every point from the line
+model.plot_residuals(X, y)
+
+# Watch the line physically shift and tilt as it minimizes loss over epochs
+model.animate_training(X, y)
+
+# See the 3D bowl of the loss surface and the path the gradient took
+model.plot_loss_surface(X, y)
+
+# (Lasso/Ridge) Watch features get eliminated as the penalty increases
+model.plot_coefficient_shrinkage(X, y)
+```
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+For local usage and development:
+```bash
+git clone https://github.com/AnshumanTiwari2006/linesight
+cd linesight
+pip install -e ".[dev]"
+```
+
+### Example Usage
+
+```python
+import numpy as np
+from linesight import LinearRegression
+
+# 1. Generate some dummy data
+X = np.array([[1], [2], [3], [4], [5]])
+y = np.array([2.1, 4.0, 5.8, 8.1, 9.9])
+
+# 2. Instantiate and train the model (store_history is required for animations)
+model = LinearRegression(learning_rate=0.01, epochs=1000, store_history=True)
+model.fit(X, y)
+
+# 3. Understand what the model learned
+model.show_equation()          # Prints: y = 1.9800x + 0.1200
+model.explain_coefficients()   # Explains what 1.98 means in plain English
+
+# 4. Prove it visually
+model.plot_fit(X, y)           # View the regression line
+model.plot_loss_curve()        # Ensure the learning rate was stable
+```
+
+---
+
+## 🧪 Running Tests
+
+LineSight is heavily tested to ensure mathematical correctness matches `scikit-learn` implementations. To run the test suite:
+
+```bash
+pytest tests/ -v
+```
+*(109 tests covering validators, all model engines, training history, metrics, and explanation layers).*
+
+---
+
+## 📄 License
+
+MIT License. Built for education, transparency, and the love of math.

linesight-0.1.0/README.md

@@ -0,0 +1,127 @@
+# LineSight 🔍
+
+**LineSight** is an educational, "glass-box" machine learning library built for understanding—not just executing—regression models. 
+
+Where traditional libraries like `scikit-learn` act as black boxes (you put data in, you get predictions out), LineSight is explicitly designed to teach you **how** the algorithm works under the hood. Every model can visually show you its loss surface, animate its gradient descent path, and explain its mathematical equations in plain English.
+
+---
+
+## 🏗️ Library Architecture
+
+LineSight is built on a strict, pedagogical tri-layer design. Every single model in the library is broken down into three distinct modules:
+
+1. **`engine` (The Math)**
+   The core implementation using pure NumPy. Instead of opaque, heavily-optimized C-extensions, the engines are written in highly readable Python. We use explicit `weights` and `bias` variables instead of unified `theta` vectors so the code reads exactly like a textbook formula.
+   
+2. **`explain` (The Interpretation)**
+   A suite of functions that translate the mathematical state of the model into plain-English sentences. It explains the effect of the L2 penalty, parses out the slope coefficient, and dynamically tells you what the model learned.
+
+3. **`visualization` (The Proof)**
+   A massive collection of Matplotlib-based functions. You can visualize the dataset, the residuals, the 3D loss surface, and even generate live animations of the algorithm learning step-by-step.
+
+---
+
+## 🧠 The Models
+
+LineSight currently implements 6 foundational regression models, each designed to teach a specific mathematical concept:
+
+| Model | Algorithm | What it teaches |
+|---|---|---|
+| `LinearRegression` | Gradient Descent | The baseline concept of minimizing Mean Squared Error (MSE). |
+| `MultipleLinearRegression` | Gradient Descent | Dealing with planes, hyperplanes, and multicollinearity. |
+| `PolynomialRegression` | Gradient Descent | Basis expansion and the bias-variance tradeoff (underfitting vs overfitting). |
+| `RidgeRegression` | Gradient Descent | L2 Regularization (weight decay) to handle correlated features. |
+| `LassoRegression` | Coordinate Descent | L1 Regularization and automatic feature selection (sparsity). |
+| `ElasticNetRegression` | Coordinate Descent | Blending L1 and L2 penalties via the `l1_ratio`. |
+| `LogisticRegression` | Gradient Descent | Binary classification, the Sigmoid function, and Log Loss. |
+
+---
+
+## ⚡ The Unified API
+
+All models strictly follow a unified, `scikit-learn`-style API, meaning you already know how to use them. 
+
+### 1. Core Execution
+```python
+model = RidgeRegression(alpha=0.1, learning_rate=0.01)
+model.fit(X, y)                    # Trains the model
+predictions = model.predict(X)     # Generates predictions
+metrics = model.score(X, y)        # Returns {'r2', 'rmse', 'mae', 'mse'}
+```
+
+### 2. Context Panels & Explanations
+Every visualization and summary natively includes **Context Panels**—live, dynamically generated text boxes attached directly to the plots that explain the theory, the formula, and how to read the chart.
+```python
+model.summary()                    # Prints training summary and final metrics
+model.show_equation()              # Prints the literal mathematical formula (e.g., y = 3.5x + 1.2)
+model.explain_regularization()     # Explains the specific L1/L2 penalty active in the model
+```
+
+### 3. Visualizations & Animations
+Instead of just returning predictions, LineSight lets you look inside the optimization process:
+```python
+# Visualize the exact distance (error) of every point from the line
+model.plot_residuals(X, y)
+
+# Watch the line physically shift and tilt as it minimizes loss over epochs
+model.animate_training(X, y)
+
+# See the 3D bowl of the loss surface and the path the gradient took
+model.plot_loss_surface(X, y)
+
+# (Lasso/Ridge) Watch features get eliminated as the penalty increases
+model.plot_coefficient_shrinkage(X, y)
+```
+
+---
+
+## 🚀 Quick Start
+
+### Installation
+
+For local usage and development:
+```bash
+git clone https://github.com/AnshumanTiwari2006/linesight
+cd linesight
+pip install -e ".[dev]"
+```
+
+### Example Usage
+
+```python
+import numpy as np
+from linesight import LinearRegression
+
+# 1. Generate some dummy data
+X = np.array([[1], [2], [3], [4], [5]])
+y = np.array([2.1, 4.0, 5.8, 8.1, 9.9])
+
+# 2. Instantiate and train the model (store_history is required for animations)
+model = LinearRegression(learning_rate=0.01, epochs=1000, store_history=True)
+model.fit(X, y)
+
+# 3. Understand what the model learned
+model.show_equation()          # Prints: y = 1.9800x + 0.1200
+model.explain_coefficients()   # Explains what 1.98 means in plain English
+
+# 4. Prove it visually
+model.plot_fit(X, y)           # View the regression line
+model.plot_loss_curve()        # Ensure the learning rate was stable
+```
+
+---
+
+## 🧪 Running Tests
+
+LineSight is heavily tested to ensure mathematical correctness matches `scikit-learn` implementations. To run the test suite:
+
+```bash
+pytest tests/ -v
+```
+*(109 tests covering validators, all model engines, training history, metrics, and explanation layers).*
+
+---
+
+## 📄 License
+
+MIT License. Built for education, transparency, and the love of math.

linesight-0.1.0/linesight/__init__.py

@@ -0,0 +1,19 @@
+from linesight.regression.linear.core import LinearRegression
+from linesight.regression.polynomial.core import PolynomialRegression
+from linesight.regression.multiple.core import MultipleLinearRegression
+from linesight.regression.ridge.core import RidgeRegression
+from linesight.regression.lasso.core import LassoRegression
+from linesight.regression.elasticnet.core import ElasticNetRegression
+from linesight.regression.logistic.core import LogisticRegression
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "LinearRegression",
+    "PolynomialRegression",
+    "MultipleLinearRegression",
+    "RidgeRegression",
+    "LassoRegression",
+    "ElasticNetRegression",
+    "LogisticRegression",
+]

linesight-0.1.0/linesight/base.py

@@ -0,0 +1,195 @@
+import matplotlib.pyplot as plt
+from linesight.exceptions import LineSightNotFittedError
+
+
+class LineSightBase:
+
+    _is_fitted: bool = False
+
+    def _check_fitted(self, method_name: str) -> None:
+        if not self._is_fitted:
+            raise LineSightNotFittedError(
+                f"Call fit(X, y) before calling {method_name}()."
+            )
+
+    def _validate_hyperparams(self) -> None:
+        """Hook for subclasses to validate hyperparams before fitting."""
+        if hasattr(self, 'learning_rate') and getattr(self, 'learning_rate') <= 0:
+            raise ValueError("learning_rate must be > 0")
+        if hasattr(self, 'epochs') and getattr(self, 'epochs') <= 0:
+            raise ValueError("epochs must be > 0")
+        if hasattr(self, 'alpha') and getattr(self, 'alpha') < 0:
+            raise ValueError("alpha must be >= 0")
+        if hasattr(self, 'l1_ratio') and not (0 <= getattr(self, 'l1_ratio') <= 1):
+            raise ValueError("l1_ratio must be between 0 and 1")
+        if hasattr(self, 'degree') and getattr(self, 'degree') < 1:
+            raise ValueError("degree must be >= 1")
+        if hasattr(self, 'batch_size'):
+            bs = getattr(self, 'batch_size')
+            if bs is not None and bs <= 0:
+                raise ValueError("batch_size must be >= 1 or None")
+
+    def show(self, animation_obj=None, fig=None):
+        """
+        Display a figure or animation correctly for the current environment.
+
+        THE CORRECT BEHAVIOR — read carefully:
+
+        For STATIC figures (fig parameter):
+          - In Jupyter/Colab: plt.show() closes the figure and triggers
+            the inline backend to render it. Do NOT return fig after plt.show()
+            because the figure object is now closed. Return None.
+          - In script: plt.show() opens the window. Return None.
+          - NEVER call IPython.display.display(fig) — causes triple rendering.
+
+        For ANIMATIONS (animation_obj parameter):
+          - In Jupyter/Colab: return HTML(anim.to_jshtml()).
+            Do NOT call plt.show() first — it closes the figure.
+          - In script: plt.show() runs the animation in a window.
+
+        This corrects the bug in the original specification where static
+        figures returned fig after plt.show() had already closed them.
+        """
+        from linesight.utils.environment import _detect_environment
+        env = _detect_environment()
+
+        if animation_obj is not None:
+            if env in ('jupyter', 'colab'):
+                try:
+                    from IPython.display import HTML
+                    plt.close()   # close the underlying figure to free memory
+                    return HTML(animation_obj.to_jshtml())
+                except ImportError:
+                    plt.show()
+                    return None
+            else:
+                plt.show()
+                return None
+
+        elif fig is not None:
+            # For static figures: plt.show() handles both environments.
+            # In Jupyter with %matplotlib inline, plt.show() triggers the
+            # inline renderer. In scripts it opens the window.
+            # After plt.show(), the figure is closed. Return None always.
+            plt.tight_layout()
+            plt.show()
+            return None
+
+        return None
+
+    def save(self, filepath: str, fig=None, animation_obj=None,
+             dpi: int = 150, fps: int = 20) -> str:
+        """
+        Save a figure or animation to disk.
+
+        Parameters
+        ----------
+        filepath : str
+            Full path including extension.
+            For figures: use .png, .pdf, .svg
+            For animations: use .gif or .mp4
+            Example: "my_plot.png" or "training.gif"
+        fig : matplotlib.figure.Figure, optional
+        animation_obj : FuncAnimation, optional
+        dpi : int, default 150
+            Resolution for raster formats (png, gif).
+        fps : int, default 20
+            Frames per second for animation exports.
+
+        Returns
+        -------
+        str — the filepath that was saved to, for confirmation.
+
+        Usage in visualization methods
+        --------------------------------
+        To let users save without displaying:
+            fig = model.plot_fit(X, y, display=False)
+            model.save("fit.png", fig=fig)
+
+        Or as a one-liner (display=False returns the object):
+            model.save("training.gif",
+                       animation_obj=model.animate_training(X, y, display=False))
+
+        Raises
+        ------
+        ValueError if neither fig nor animation_obj is provided.
+        ImportError with helpful message if saving .mp4 requires ffmpeg.
+        """
+        if fig is None and animation_obj is None:
+            raise ValueError(
+                "Pass either fig= or animation_obj= to save().\n"
+                "Get the object by calling the visualization method "
+                "with display=False."
+            )
+
+        if fig is not None:
+            fig.savefig(filepath, dpi=dpi, bbox_inches='tight')
+            print(f"Saved to: {filepath}")
+            return filepath
+
+        if animation_obj is not None:
+            if filepath.endswith('.gif'):
+                animation_obj.save(filepath, writer='pillow', fps=fps)
+            elif filepath.endswith('.mp4'):
+                try:
+                    animation_obj.save(filepath, writer='ffmpeg', fps=fps)
+                except Exception:
+                    raise ImportError(
+                        "Saving .mp4 requires ffmpeg installed on your system.\n"
+                        "Install it with: conda install ffmpeg\n"
+                        "Or save as .gif instead: model.save('training.gif', ...)"
+                    )
+            else:
+                animation_obj.save(filepath, fps=fps)
+            print(f"Saved to: {filepath}")
+            return filepath
+
+    def summary(self) -> str:
+        """
+        Print a complete model summary: parameters, fit quality, coefficients.
+
+        Every regression class overrides this to include model-specific info.
+        The base implementation raises NotFittedError if called before fit().
+
+        Returns
+        -------
+        str — the summary text. Also printed (in script mode) or returned
+        (in Jupyter, displayed automatically as the cell's last value).
+        """
+        self._check_fitted("summary")
+        raise NotImplementedError(
+            "summary() must be implemented by each regression subclass."
+        )
+
+    def refit(self, X, y):
+        """
+        Re-train the model from scratch on new data.
+
+        Resets ALL state: coefficients, intercept, history, fitted flag.
+        Equivalent to creating a new instance with the same hyperparameters
+        and calling fit(X, y).
+
+        Why this exists
+        ---------------
+        If a student calls fit() twice on the same model object, the second
+        call continues from where the first left off (coef_ is NOT reset to 0).
+        This produces confusing results. refit() makes the intention explicit
+        and resets properly.
+
+        Usage
+        -----
+        model.fit(X_train, y_train)        # initial training
+        model.refit(X_new, y_new)          # clean reset + retrain on new data
+        """
+        # Reset state — subclasses that use theta_ instead of coef_/intercept_
+        # must override this to reset theta_ as well
+        if hasattr(self, 'coef_'):
+            self.coef_ = 0.0
+        if hasattr(self, 'intercept_'):
+            self.intercept_ = 0.0
+        if hasattr(self, 'theta_'):
+            self.theta_ = None
+        self._is_fitted = False
+        from linesight.utils.history import TrainingHistory
+        self._history = TrainingHistory(learning_rate=getattr(self, 'learning_rate', 0))
+        return self.fit(X, y)

linesight-0.1.0/linesight/exceptions/__init__.py

@@ -0,0 +1,13 @@
+from linesight.exceptions.shape_error import LineSightShapeError
+from linesight.exceptions.not_fitted_error import LineSightNotFittedError
+from linesight.exceptions.convergence_warning import LineSightConvergenceWarning
+from linesight.exceptions.data_warning import LineSightDataWarning
+from linesight.exceptions.gradient_error import LineSightGradientError
+
+__all__ = [
+    "LineSightShapeError",
+    "LineSightNotFittedError",
+    "LineSightConvergenceWarning",
+    "LineSightDataWarning",
+    "LineSightGradientError",
+]

linesight-0.1.0/linesight/exceptions/convergence_warning.py

@@ -0,0 +1,9 @@
+import warnings
+
+class LineSightConvergenceWarning(UserWarning):
+    """
+    Issued (not raised) when the model may not have converged.
+    Use warnings.warn(..., LineSightConvergenceWarning) to issue it.
+    Does not stop execution.
+    """
+    pass

linesight-0.1.0/linesight/exceptions/data_warning.py

@@ -0,0 +1,6 @@
+class LineSightDataWarning(UserWarning):
+    """
+    Issued (not raised) when data has potential issues that will not crash
+    the model but may produce poor results.
+    """
+    pass

linesight-0.1.0/linesight/exceptions/gradient_error.py

@@ -0,0 +1,5 @@
+class LineSightGradientError(Exception):
+    """
+    Raised when gradient descent diverges and losses go to infinity/NaN.
+    """
+    pass

linesight-0.1.0/linesight/exceptions/not_fitted_error.py

@@ -0,0 +1,13 @@
+class LineSightNotFittedError(RuntimeError):
+    """
+    Raised when any method that requires a trained model is called before fit().
+
+    Always constructed with the method name that was called.
+
+    Example
+    -------
+    raise LineSightNotFittedError(
+        "Call fit(X, y) before calling predict()."
+    )
+    """
+    pass

linesight-0.1.0/linesight/exceptions/shape_error.py

@@ -0,0 +1,18 @@
+class LineSightShapeError(ValueError):
+    """
+    Raised when array shapes are incompatible.
+
+    Always constructed with a message that includes:
+    - What was expected
+    - What was actually received
+    - A suggested fix
+
+    Example
+    -------
+    raise LineSightShapeError(
+        "X and y must have the same number of samples.\n"
+        f"X has {X.shape[0]} samples, y has {y.shape[0]} samples.\n"
+        "Did you forget to align your datasets?"
+    )
+    """
+    pass

linesight-0.1.0/linesight/metrics/__init__.py

@@ -0,0 +1,5 @@
+from linesight.metrics.mse import mse
+from linesight.metrics.rmse import rmse
+from linesight.metrics.mae import mae
+from linesight.metrics.r2 import r2
+from linesight.metrics.accuracy import accuracy

linesight-0.1.0/linesight/metrics/accuracy.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+def accuracy(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    """
+    Classification accuracy. Used only by LogisticRegression.
+    Formula: number of correct predictions / total predictions.
+    y_pred should be class labels (0 or 1), not probabilities.
+    """
+    return float(np.mean(y_true == y_pred))

linesight-0.1.0/linesight/metrics/mae.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+def mae(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    """Mean Absolute Error. Formula: (1/n) * sum(|y_true - y_pred|)"""
+    return float(np.mean(np.abs(y_true - y_pred)))

linesight-0.1.0/linesight/metrics/mse.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+def mse(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    """Mean Squared Error. Formula: (1/n) * sum((y_true - y_pred)^2)"""
+    return float(np.mean((y_true - y_pred) ** 2))

linesight-0.1.0/linesight/metrics/r2.py

@@ -0,0 +1,20 @@
+import numpy as np
+
+def r2(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    """
+    R-squared (coefficient of determination).
+
+    Formula: 1 - SS_res / SS_tot
+    where SS_res = sum((y_true - y_pred)^2)
+    and   SS_tot = sum((y_true - mean(y_true))^2)
+
+    Returns 1.0 for perfect fit.
+    Returns 0.0 if model just predicts the mean.
+    Can be negative if model is worse than predicting the mean.
+    """
+    ss_res = np.sum((y_true - y_pred) ** 2)
+    ss_tot = np.sum((y_true - np.mean(y_true)) ** 2)
+    if ss_tot == 0:
+        # All y values are identical — R^2 is undefined, return 0
+        return 0.0
+    return float(1 - ss_res / ss_tot)

linesight-0.1.0/linesight/metrics/rmse.py

@@ -0,0 +1,6 @@
+import numpy as np
+from linesight.metrics.mse import mse
+
+def rmse(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    """Root Mean Squared Error. Square root of MSE."""
+    return float(np.sqrt(mse(y_true, y_pred)))

linesight-0.1.0/linesight/regression/__init__.py

@@ -0,0 +1,6 @@
+from linesight.regression.linear.core import LinearRegression
+from linesight.regression.multiple.core import MultipleLinearRegression
+from linesight.regression.ridge.core import RidgeRegression
+from linesight.regression.lasso.core import LassoRegression
+from linesight.regression.elasticnet.core import ElasticNetRegression
+from linesight.regression.logistic.core import LogisticRegression

linesight-0.1.0/linesight/regression/elasticnet/__init__.py

@@ -0,0 +1 @@
+from linesight.regression.elasticnet.core import ElasticNetRegression