linesight 0.1.0__py3-none-any.whl

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/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/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/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/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/exceptions/gradient_error.py

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

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/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/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/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/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/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/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/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/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/regression/elasticnet/__init__.py

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

linesight/regression/elasticnet/core.py

@@ -0,0 +1,103 @@
+import numpy as np
+from linesight.base import LineSightBase
+from linesight.utils.history import TrainingHistory
+
+from linesight.regression.elasticnet.engine.fit import _fit
+from linesight.regression.elasticnet.engine.predict import predict
+from linesight.regression.elasticnet.engine.score import score
+from linesight.regression.elasticnet.engine.get_history import get_training_history
+from linesight.regression.elasticnet.explain.explain_regularization import explain_regularization
+from linesight.regression.elasticnet.explain.explain_coefficients import explain_coefficients
+from linesight.regression.elasticnet.visualization.plot_fit import plot_fit
+from linesight.regression.elasticnet.visualization.plot_loss_curve import plot_loss_curve
+from linesight.regression.elasticnet.visualization.plot_coefficient_shrinkage import plot_coefficient_shrinkage
+from linesight.regression.elasticnet.visualization.compare_regularization_methods import compare_regularization_methods
+
+
+from linesight.regression.elasticnet.visualization.plot_actual_vs_predicted import plot_actual_vs_predicted
+from linesight.regression.elasticnet.visualization.plot_learning_curve import plot_learning_curve
+from linesight.regression.elasticnet.visualization.plot_l1_l2_balance import plot_l1_l2_balance
+
+from linesight.regression.elasticnet.visualization.animate_l1_ratio_sweep import animate_l1_ratio_sweep
+from linesight.regression.linear.visualization.plot_residuals import plot_residuals
+
+class ElasticNetRegression(LineSightBase):
+    """
+    ElasticNet regression: L1 (sparsity) + L2 (shrinkage) combined.
+    l1_ratio=1 -> pure Lasso.  l1_ratio=0 -> pure Ridge.
+
+    Parameters
+    ----------
+    alpha         : float, default 1.0
+    l1_ratio      : float, default 0.5  (must be in [0, 1])
+    epochs        : int,   default 1000
+    store_history : bool,  default False
+    """
+
+    def __init__(
+        self,
+        alpha: float = 1.0,
+        l1_ratio: float = 0.5,
+        epochs: int = 1000,
+        store_history: bool = False,
+        normalize: bool = False,
+    ):
+        self.alpha = alpha
+        self.l1_ratio = l1_ratio
+        self.epochs = epochs
+        self.store_history = store_history
+        self.normalize = normalize
+        self.store_history = store_history
+        self.weights = np.zeros(1)
+        self.bias = 0.0
+        self._history = TrainingHistory()
+        self._n_features_in_ = 1
+        self._is_fitted = False
+
+    @property
+    def coef_(self):
+        return self.weights
+
+    @property
+    def intercept_(self):
+        return float(self.bias)
+
+    fit = _fit
+    predict = predict
+    score = score
+    get_training_history = get_training_history
+    explain_regularization = explain_regularization
+    explain_coefficients = explain_coefficients
+    plot_fit = plot_fit
+    plot_loss_curve = plot_loss_curve
+    plot_coefficient_shrinkage = plot_coefficient_shrinkage
+    compare_regularization_methods = compare_regularization_methods
+
+    plot_actual_vs_predicted = plot_actual_vs_predicted
+    plot_learning_curve = plot_learning_curve
+    plot_l1_l2_balance = plot_l1_l2_balance
+
+    animate_l1_ratio_sweep = animate_l1_ratio_sweep
+    plot_residuals = plot_residuals
+    def summary(self) -> str:
+        self._check_fitted("summary")
+        converged_str = "Yes" if self._history.converged else "No"
+        final_loss = round(self._history.losses[-1], 6) if not self._history.is_empty() else "N/A"
+        
+        lines = [
+            "=" * 50,
+            f"LineSight — ElasticNetRegression",
+            "=" * 50,
+            "Training config:",
+            f"  Alpha:          {getattr(self, 'alpha', 'N/A')}",
+            f"  L1 ratio:       {getattr(self, 'l1_ratio', 'N/A')}",
+            f"  Epochs:         {getattr(self, 'epochs', 'N/A')}",
+            f"  Converged:      {converged_str}",
+            f"  Final loss:     {final_loss}",
+            "=" * 50,
+        ]
+        output = "\n".join(lines)
+        from linesight.utils.environment import _detect_environment
+        if _detect_environment() == 'script':
+            print(output)
+        return output

linesight/regression/elasticnet/engine/compute_loss.py

@@ -0,0 +1,8 @@
+import numpy as np
+
+def _compute_loss(self, X: np.ndarray, y: np.ndarray) -> float:
+    y_pred = np.dot(X, self.weights) + self.bias
+    mse_term = float(np.mean((y - y_pred) ** 2))
+    l1_term = self.alpha * self.l1_ratio * float(np.sum(np.abs(self.weights)))
+    l2_term = self.alpha * (1 - self.l1_ratio) * float(np.sum(self.weights ** 2))
+    return mse_term + l1_term + l2_term

linesight/regression/elasticnet/engine/fit.py

@@ -0,0 +1,72 @@
+import numpy as np
+import warnings
+from linesight.utils.validators import _validate_Xy
+from linesight.utils.history import TrainingHistory
+from linesight.exceptions import LineSightConvergenceWarning, LineSightGradientError
+from linesight.regression.elasticnet.engine.soft_threshold import _soft_threshold
+from linesight.regression.elasticnet.engine.compute_loss import _compute_loss
+
+
+def _fit(self, X, y):
+    """Train ElasticNet with coordinate descent: L1 (sparsity) + L2 (shrinkage)."""
+    self._validate_hyperparams()
+
+    feature_names = list(X.columns) if hasattr(X, "columns") else None
+    X, y = _validate_Xy(X, y)
+    n_samples, n_features = X.shape
+    self._n_features_in_ = n_features
+    self.feature_names_in_ = feature_names or [f"x{i}" for i in range(n_features)]
+
+    # Feature scaling
+    if getattr(self, "normalize", False):
+        self._X_mean = X.mean(axis=0)
+        self._X_std  = X.std(axis=0)
+        self._X_std[self._X_std == 0] = 1.0
+        X = (X - self._X_mean) / self._X_std
+    else:
+        self._X_mean = None
+        self._X_std  = None
+
+    self.weights = np.zeros(n_features)
+    self.bias = 0.0
+
+    losses, weights, biases = [], [], []
+
+    with np.errstate(over='ignore', invalid='ignore'):
+        for epoch in range(self.epochs):
+            self.bias = np.mean(y - np.dot(X, self.weights))
+
+            for j in range(n_features):
+                w_j = self.weights[j]
+                y_excl_j = np.dot(X, self.weights) - X[:, j] * w_j + self.bias
+                rho_j = (1 / n_samples) * np.dot(X[:, j], y - y_excl_j)
+                x_j_sq = np.mean(X[:, j] ** 2)
+                denom = x_j_sq + self.alpha * (1 - self.l1_ratio)
+                self.weights[j] = 0.0 if denom == 0 else _soft_threshold(rho_j, self.alpha * self.l1_ratio) / denom
+
+            loss = _compute_loss(self, X, y)
+
+            if not np.isfinite(loss):
+                raise LineSightGradientError(
+                    f"Training failed: loss exploded to infinity at epoch {epoch}. "
+                    f"Coordinate descent is usually stable, but extremely large feature values can cause overflow. "
+                    f"Try scaling your features first."
+                )
+
+            if self.store_history:
+                losses.append(loss)
+                weights.append(self.weights.copy())
+                biases.append(self.bias)
+
+    converged = True
+    if self.store_history and len(losses) >= 2:
+        if losses[-1] < losses[-2]:
+            converged = False
+            warnings.warn("Model hasn't fully converged. Loss still decreasing.", LineSightConvergenceWarning, stacklevel=2)
+
+    self._history = TrainingHistory(
+        losses=losses, weights=weights, biases=biases,
+        learning_rate=0.0, epochs_run=self.epochs, converged=converged
+    )
+    self._is_fitted = True
+    return self

linesight/regression/elasticnet/engine/get_history.py

@@ -0,0 +1,9 @@
+import warnings
+from linesight.exceptions import LineSightDataWarning
+
+
+def get_training_history(self):
+    self._check_fitted("get_training_history")
+    if self._history.is_empty():
+        warnings.warn("Re-fit with store_history=True.", LineSightDataWarning, stacklevel=2)
+    return self._history

linesight/regression/elasticnet/engine/predict.py

@@ -0,0 +1,9 @@
+import numpy as np
+from linesight.utils.validators import _validate_X
+
+def predict(self, X) -> np.ndarray:
+    self._check_fitted("predict")
+    X = _validate_X(X, expected_features=self._n_features_in_)
+    if getattr(self, "normalize", False) and getattr(self, "_X_mean", None) is not None:
+        X = (X - self._X_mean) / self._X_std
+    return np.dot(X, self.weights) + self.bias

linesight/regression/elasticnet/engine/score.py

@@ -0,0 +1,13 @@
+from linesight.utils.validators import _validate_Xy
+from linesight.metrics import mse, rmse, mae, r2
+
+
+def score(self, X, y) -> dict:
+    self._check_fitted("score")
+    X, y = _validate_Xy(X, y)
+    y_pred = self.predict(X)
+    return {
+        "mse": round(mse(y, y_pred), 6), "rmse": round(rmse(y, y_pred), 6),
+        "mae": round(mae(y, y_pred), 6), "r2": round(r2(y, y_pred), 6),
+        "n_samples": int(X.shape[0]), "n_features": int(X.shape[1]),
+    }

linesight/regression/elasticnet/engine/soft_threshold.py

@@ -0,0 +1,8 @@
+def _soft_threshold(rho: float, alpha: float) -> float:
+    """Soft-threshold operator for coordinate descent (same as Lasso)."""
+    if rho > alpha:
+        return rho - alpha
+    elif rho < -alpha:
+        return rho + alpha
+    else:
+        return 0.0

linesight/regression/elasticnet/explain/__init__.py

@@ -0,0 +1 @@
+ 

linesight/regression/elasticnet/explain/explain_coefficients.py

@@ -0,0 +1,29 @@
+import numpy as np
+
+def explain_coefficients(self) -> str:
+    self._check_fitted("explain_coefficients")
+    intercept = round(float(self.bias), 4)
+    names = self.feature_names_in_
+
+    lines = [
+        f"Intercept: {intercept}",
+        f"",
+        f"Feature coefficients (ElasticNet-regularized, alpha={self.alpha}, l1_ratio={self.l1_ratio}):",
+        f"  Note: Coefficients at exactly 0 were eliminated by the L1 part of the penalty.",
+        f"",
+    ]
+    for name, coef in zip(names, self.weights):
+        coef_r = round(float(coef), 4)
+        if coef_r == 0:
+            lines.append(f"  {name}: 0 [eliminated]")
+        else:
+            direction = "increases" if coef_r > 0 else "decreases"
+            lines.append(f"  {name}: {coef_r}")
+            lines.append(f"    A 1-unit increase {direction} prediction by {abs(coef_r)}.")
+        lines.append("")
+
+    output = "\n".join(lines)
+    from linesight.utils.environment import _detect_environment
+    if _detect_environment() == 'script':
+        print(output)
+    return output

linesight/regression/elasticnet/explain/explain_regularization.py

@@ -0,0 +1,33 @@
+import numpy as np
+
+def explain_regularization(self) -> str:
+    """Explain ElasticNet L1/L2 balance."""
+    self._check_fitted("explain_regularization")
+    alpha = self.alpha
+    l1_ratio = self.l1_ratio
+    
+    l1_penalty = float(np.sum(np.abs(self.weights)))
+    l2_penalty = float(np.sum(self.weights ** 2))
+    
+    n_zero = int(np.sum(self.weights == 0))
+    n_total = len(self.weights)
+    
+    lines = [
+        "ElasticNet Regularization (L1 + L2)",
+        "-" * 35,
+        f"alpha = {alpha} (Overall regularization strength)",
+        f"l1_ratio = {l1_ratio} (Balance between Lasso and Ridge)",
+        "",
+        "ElasticNet combines both L1 (Lasso) and L2 (Ridge) penalties:",
+        "  - L1 creates sparsity (sets coefficients to exactly zero)",
+        "  - L2 shrinks coefficients and handles correlated features better than L1 alone",
+        "",
+        f"L1 penalty sum(|theta|): {round(l1_penalty, 6)}",
+        f"L2 penalty sum(theta^2): {round(l2_penalty, 6)}",
+        f"Features set to exactly zero: {n_zero} / {n_total}",
+    ]
+    output = "\n".join(lines)
+    from linesight.utils.environment import _detect_environment
+    if _detect_environment() == 'script':
+        print(output)
+    return output

linesight/regression/elasticnet/visualization/__init__.py

@@ -0,0 +1 @@
+