tessl/pypi-pybaselines

A library of algorithms for the baseline correction of experimental data.

—

Pending

Overview

Eval results

Files

Polynomial Fitting Methods

Name: tessl/pypi-pybaselines
Author: tessl

Polynomial-based baseline correction using various fitting strategies and outlier handling approaches. These methods fit polynomial functions to data while minimizing the influence of peaks through iterative weighting, masking, or robust fitting techniques. They are suitable for simple baseline shapes and when interpretable parameters are desired.

Capabilities

Basic Polynomial Fitting

Standard least squares polynomial fitting without iterative reweighting.

def poly(data, x_data=None, poly_order=2, weights=None, return_coef=False):
    """
    Basic polynomial baseline fitting using least squares.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - x_data (array-like, optional): Input x-values
    - poly_order (int): Order of polynomial (0=constant, 1=linear, 2=quadratic, etc.)
    - weights (array-like, optional): Weight array for data points
    - return_coef (bool): Whether to return polynomial coefficients in params
    
    Returns:
    tuple: (baseline, params) where params may contain 'coef' if return_coef=True
    """

Modified Polynomial (modpoly)

Iteratively fits polynomials while masking data points that deviate significantly from the current fit.

def modpoly(data, poly_order=2, tol=1e-3, max_iter=250, weights=None, use_original=False, mask_initial_peaks=True, num_std=1.0, x_data=None, return_coef=False):
    """
    Modified polynomial baseline with iterative peak masking.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - poly_order (int): Order of polynomial
    - tol (float): Convergence tolerance for coefficient changes
    - max_iter (int): Maximum iterations
    - weights (array-like, optional): Initial weight array
    - use_original (bool): Whether to compare against original data for convergence
    - mask_initial_peaks (bool): Whether to mask obvious peaks in first iteration
    - num_std (float): Number of standard deviations for peak masking threshold
    - x_data (array-like, optional): Input x-values
    - return_coef (bool): Whether to return polynomial coefficients
    
    Returns:
    tuple: (baseline, params) containing 'weights' and optionally 'coef'
    """

Improved Modified Polynomial (imodpoly)

Enhanced version of modpoly with better peak detection and convergence criteria.

def imodpoly(data, x_data=None, poly_order=2, tol=1e-3, max_iter=250, weights=None, use_original=False, mask_initial_peaks=False, return_coef=False):
    """
    Improved modified polynomial baseline with enhanced peak masking.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - poly_order (int): Order of polynomial
    - tol (float): Convergence tolerance
    - max_iter (int): Maximum iterations
    - weights (array-like, optional): Initial weight array
    - use_original (bool): Whether to use original data for convergence check
    - mask_initial_peaks (bool): Whether to mask peaks initially
    - return_coef (bool): Whether to return coefficients
    
    Returns:
    tuple: (baseline, params)
    """

Penalized Polynomial

Combines polynomial fitting with penalty functions for outlier rejection and robust baseline estimation.

def penalized_poly(data, x_data=None, poly_order=2, tol=1e-3, max_iter=250, weights=None, cost_function='asymmetric_truncated_quadratic', threshold=None, alpha_factor=0.99, ensure_finite=True, return_coef=False):
    """
    Penalized polynomial baseline with robust cost functions.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - poly_order (int): Order of polynomial
    - tol (float): Convergence tolerance
    - max_iter (int): Maximum iterations
    - weights (array-like, optional): Initial weight array
    - cost_function (str): Penalty function type ('asymmetric_truncated_quadratic', 'symmetric_truncated_quadratic', etc.)
    - threshold (float, optional): Penalty threshold
    - alpha_factor (float): Factor for threshold adaptation (0 < alpha_factor < 1)
    - ensure_finite (bool): Whether to ensure all values are finite
    - return_coef (bool): Whether to return coefficients
    
    Returns:
    tuple: (baseline, params)
    """

Quantile Regression

Fits polynomials using quantile regression to estimate baseline at specified quantile levels.

def quant_reg(data, poly_order=2, quantile=0.05, tol=1e-6, max_iter=1000, weights=None, eps=None, x_data=None, return_coef=False):
    """
    Quantile regression polynomial baseline fitting.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - poly_order (int): Order of polynomial
    - quantile (float): Quantile level for regression (0 < quantile < 1)
    - tol (float): Convergence tolerance for optimization
    - max_iter (int): Maximum iterations for optimization
    - weights (array-like, optional): Weight array
    - eps (float, optional): Smoothing parameter for quantile loss
    - x_data (array-like, optional): Input x-values
    - return_coef (bool): Whether to return coefficients
    
    Returns:
    tuple: (baseline, params)
    """

LOESS/LOWESS Regression

Locally weighted regression using polynomials for flexible baseline fitting that adapts to local data characteristics.

def loess(data, x_data=None, fraction=0.2, total_points=None, poly_order=1, scale=3.0, tol=1e-6, max_iter=250, weights=None, use_threshold=False, return_coef=False):
    """
    LOESS (locally weighted regression) baseline fitting.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - x_data (array-like, optional): Input x-values
    - fraction (float): Fraction of data points used for local regression (0 < fraction <= 1)
    - total_points (int, optional): Alternative to fraction - exact number of points
    - poly_order (int): Order of local polynomial (0=constant, 1=linear, 2=quadratic)
    - scale (float): Scale factor for robust weighting
    - tol (float): Convergence tolerance
    - max_iter (int): Maximum iterations for robust fitting
    - weights (array-like, optional): Global weight array
    - use_threshold (bool): Whether to use threshold-based robust weighting
    - return_coef (bool): Whether to return local coefficients
    
    Returns:
    tuple: (baseline, params)
    """

Goldindec Algorithm

Combines polynomial fitting with peak detection and iterative coefficient adjustment.

def goldindec(data, x_data=None, poly_order=2, tol=1e-3, max_iter=250, weights=None, cost_function='asymmetric_truncated_quadratic', threshold=None, alpha_factor=0.99, return_coef=False):
    """
    Goldindec polynomial baseline algorithm with peak detection.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - poly_order (int): Order of polynomial
    - tol (float): Convergence tolerance
    - max_iter (int): Maximum iterations
    - weights (array-like, optional): Initial weight array
    - cost_function (str): Cost function for penalty
    - threshold (float, optional): Penalty threshold
    - alpha_factor (float): Threshold adaptation factor
    - return_coef (bool): Whether to return coefficients
    
    Returns:
    tuple: (baseline, params)
    """

Usage Examples

Basic polynomial baseline:

import numpy as np
from pybaselines.polynomial import poly

# Sample data with quadratic baseline
x = np.linspace(0, 100, 1000)
true_baseline = 10 + 0.1 * x + 0.001 * x**2
peaks = 50 * np.exp(-((x - 30) / 5)**2) + 30 * np.exp(-((x - 70) / 8)**2)
data = true_baseline + peaks + np.random.normal(0, 1, len(x))

# Fit quadratic polynomial baseline
baseline, params = poly(data, poly_order=2, x_data=x, return_coef=True)
corrected = data - baseline

print(f"Polynomial coefficients: {params['coef']}")

Iterative polynomial with peak masking:

from pybaselines.polynomial import modpoly

# Automatically mask peaks and fit polynomial
baseline, params = modpoly(data, poly_order=2, num_std=1.5, x_data=x)
corrected = data - baseline

# Check which points were masked
masked_points = params['weights'] < 0.5
print(f"Masked {np.sum(masked_points)} peak points")

Quantile regression for robust fitting:

from pybaselines.polynomial import quant_reg

# Fit polynomial at 5th percentile (robust to outliers)
baseline, params = quant_reg(data, poly_order=2, quantile=0.05, x_data=x)
corrected = data - baseline

Install with Tessl CLI