tessl/pypi-pybaselines

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

—

Pending

Overview

Eval results

Files

Smoothing-Based Methods

Name: tessl/pypi-pybaselines
Author: tessl

Algorithms that use smoothing operations and iterative filtering to separate baseline from signal components. These methods are effective for noisy data and spectra with complex peak structures, using various windowing and filtering approaches to identify and preserve baseline regions while suppressing peak contributions.

Capabilities

Noise-Median Method

Uses median filtering combined with smoothing to estimate baseline from noisy data.

def noise_median(data, half_window=None, smooth_half_window=None, sigma=None, x_data=None, pad_kwargs=None, **kwargs):
    """
    Noise-median smoothing baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size for median filtering
    - smooth_half_window (int, optional): Half-window for smoothing operation
    - sigma (float, optional): Standard deviation for noise estimation
    - x_data (array-like, optional): Input x-values
    - pad_kwargs (dict, optional): Padding parameters for edge handling
    
    Returns:
    tuple: (baseline, params)
    """

SNIP Algorithm

Statistical Sensitive Non-linear Iterative Peak algorithm for baseline estimation.

def snip(data, max_half_window=None, decreasing=False, smooth_half_window=None, filter_order=2, x_data=None, pad_kwargs=None, **kwargs):
    """
    Statistical Sensitive Non-linear Iterative Peak algorithm.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - max_half_window (int, optional): Maximum half-window size for iterations
    - decreasing (bool): Whether to use decreasing window sizes
    - smooth_half_window (int, optional): Half-window for smoothing
    - filter_order (int): Order of smoothing filter
    - x_data (array-like, optional): Input x-values
    - pad_kwargs (dict, optional): Padding parameters
    
    Returns:
    tuple: (baseline, params)
    """

Small-Window Moving Average (SWIMA)

Uses moving averages with adaptive window sizing for baseline estimation.

def swima(data, min_half_window=3, max_half_window=None, smooth_half_window=None, x_data=None, pad_kwargs=None, **kwargs):
    """
    Small-window moving average baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - min_half_window (int): Minimum half-window size
    - max_half_window (int, optional): Maximum half-window size
    - smooth_half_window (int, optional): Half-window for final smoothing
    - x_data (array-like, optional): Input x-values
    - pad_kwargs (dict, optional): Padding parameters
    
    Returns:
    tuple: (baseline, params)
    """

Iterative Polynomial Smoothing Algorithm (IPSA)

Combines polynomial fitting with iterative smoothing for robust baseline estimation.

def ipsa(data, half_window=None, max_iter=500, tol=None, roi=None, original_criteria=False, x_data=None, pad_kwargs=None, **kwargs):
    """
    Iterative Polynomial Smoothing Algorithm.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - half_window (int, optional): Half-window size for smoothing
    - max_iter (int): Maximum iterations
    - tol (float, optional): Convergence tolerance
    - roi (array-like, optional): Region of interest for processing
    - original_criteria (bool): Whether to use original convergence criteria
    - x_data (array-like, optional): Input x-values
    - pad_kwargs (dict, optional): Padding parameters
    
    Returns:
    tuple: (baseline, params)
    """

Range Independent Algorithm (RIA)

Adapts to varying signal ranges and provides range-independent baseline correction.

def ria(data, x_data=None, half_window=None, max_iter=500, tol=1e-2, side='both', width_scale=0.1, height_scale=1., sigma_scale=1./12., pad_kwargs=None, **kwargs):
    """
    Range Independent Algorithm for baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - x_data (array-like, optional): Input x-values
    - half_window (int, optional): Half-window size
    - max_iter (int): Maximum iterations
    - tol (float): Convergence tolerance
    - side (str): Side for range extension ('left', 'right', 'both')
    - width_scale (float): Width scaling factor
    - height_scale (float): Height scaling factor
    - sigma_scale (float): Sigma scaling factor
    - pad_kwargs (dict, optional): Padding parameters
    
    Returns:
    tuple: (baseline, params)
    """

4S Peak Filling

Peak filling algorithm using iterative smoothing with controlled filling operations.

def peak_filling(data, x_data=None, half_window=None, sections=None, max_iter=5, lam_smooth=None):
    """
    4S Peak Filling algorithm for baseline correction.
    
    Parameters:
    - data (array-like): Input y-values to fit baseline
    - x_data (array-like, optional): Input x-values
    - half_window (int, optional): Half-window size for operations
    - sections (int, optional): Number of sections for processing
    - max_iter (int): Maximum iterations for filling
    - lam_smooth (float, optional): Smoothing parameter
    
    Returns:
    tuple: (baseline, params)
    """

Usage Examples

SNIP baseline correction:

import numpy as np
from pybaselines.smooth import snip

# Sample noisy data with multiple peaks
x = np.linspace(0, 1000, 2000)
baseline = 5 + 0.01 * x
peaks = (100 * np.exp(-((x - 200) / 30)**2) + 
         80 * np.exp(-((x - 500) / 50)**2) + 
         60 * np.exp(-((x - 800) / 40)**2))
noise = np.random.normal(0, 2, len(x))
data = baseline + peaks + noise

# Apply SNIP algorithm
baseline_est, params = snip(data, max_half_window=50, x_data=x)
corrected = data - baseline_est

Iterative smoothing with IPSA:

from pybaselines.smooth import ipsa

# Robust baseline estimation with iterative smoothing
baseline_est, params = ipsa(data, half_window=20, max_iter=100, x_data=x)
corrected = data - baseline_est

print(f"Converged in {len(params.get('tol_history', []))} iterations")

Install with Tessl CLI