PyLASP - The Python Version of the LASP

---

📋 Table of Contents

• Overview
• Installation
• Project Structure
• The Core Modules in LASP-CurveFit
• The Core Modules in LASP-Adam-GPU
• Workflow
• LASP-CurveFit Inference Process
• LASP-Adam-GPU Inference Process
• Parameter Inference Example
• LASP-CurveFit Inference Example
• LASP-Adam-GPU Inference Example
• Limitations and Future Work
• Citation
• License

---

🔭 Overview

PyLASP (The Python Version of the LAMOST Stellar Parameter Pipeline) is a modern, modular reimplementation of the original LASP (LASP-MPFit), which was developed in Interactive Data Language (IDL) and employed the ULySS software package to infer radial velocity, effective temperature, surface gravity, and metallicity from observed spectra.

PyLASP refactors the LASP-MPFit with two complementary modules:

• LASP-CurveFit — a new implementation of the LASP-MPFit fitting procedure that runs on CPU, preserving legacy logic while improving data I/O and multithreaded execution efficiency.
• LASP-Adam-GPU — a GPU accelerated method that introduces grouped optimization by constructing a joint residual function over multiple observed and model spectra, enabling high-throughput parameter inference across tens of millions of spectra.

PyLASP provides both No Clean and Clean strategies:

• No Clean strategy — a computationally efficient strategy that fits spectra without iterative pixel rejection. It is faster but may yield lower accuracy for spectra containing significant artifacts.
• Clean strategy — an iterative strategy that identifies and rejects anomalous flux points during the fitting process, specifically those whose model–data discrepancies cannot be reasonably explained by the spectral emulator. This approach improves robustness for spectra with defects or irregularities, but is computationally slower than the No Clean strategy.

---

🔧 Installation

Follow the steps below to set up PyLASP in a clean conda environment.

1. Create an independent conda environment:

conda create -n PyLASP-env python=3.10

2. Activate the environment:

conda activate PyLASP-env

3. Navigate to the PyLASP project folder:

cd /path/to/PyLASP

4. Install the package and its dependencies:

pip install -e .

⚠️ Note: The above steps install only the dependencies for LASP-CurveFit. To enable LASP-Adam-GPU, install the appropriate PyTorch version in the same environment. See the official PyTorch installation guide for details.

---

🖥️ Project Structure

The Core Modules in LASP-CurveFit

LASP-CurveFit/
│
├── tgm_model/                            # Spectral emulator
│   └── elodie32_flux_tgm.fits            # ELODIE polynomial coefficients
│
├── test_data/                            # Test data examples
│   ├── LAMOST_spec_fits/                 # LAMOST spectrum FITS files
│   │   └── *.fits
│   └── PyLASP_inferred_results/          # Parameter results inferred by PyLASP
│       └── *.csv
│
├── file_paths.py                         # Obtain the PyLASP file path
│
├── uly_read_lms/                         # Spectrum data reading
│   ├── uly_spect_alloc.py                # Initialize spectrum dictionary
│   ├── uly_spect_get.py                  # Extract fields from the spectrum dictionary
│   ├── uly_spect_extract.py              # Update dictionary entries based on wavelength range
│   └── uly_spect_read_lms.py             # Construct the LAMOST spectrum dictionary (example implementation)
│
├── uly_tgm/                              # Model spectrum structure
│   ├── uly_tgm.py                        # Define model spectrum dictionary
│   └── uly_tgm_init.py                   # Initialize model spectrum dictionary
│
├── uly_tgm_eval/                         # Model spectrum generation
│   └── uly_tgm_eval.py                   # Generate model spectra from parameters
│
├── WRS/                                  # Wavelength resampling
│   ├── xrebin.py                         # Interpolation methods
│   └── uly_spect_logrebin.py             # Spectrum resampling implementation
│
├── resolution_reduction/                 # Resolution matching
│   └── convol.py                         # Spectral resolution reduction
│
├── legendre_polynomial/                  # Shape correction
│   └── mregress.py                       # Legendre polynomial coefficient calculation
│
├── clean_outliers/                       # Outlier rejection
│   └── clean.py                          # Clean strategy
│ 
└── uly_fit/                              # Parameter fitting core
    ├── robust_sigma.py                   # Robust standard deviation calculation
    ├── uly_fit_init.py                   # Initialize a model spectrum dictionary
    ├── uly_makeparinfo.py                # Configure parameters to be optimized
    ├── uly_fit_conv_weight_poly.py       # Model preprocessing: convolution + weighting + shape correction
    ├── uly_fit_a_cmp.py                  # Compute best-fit parameters
    └── ulyss.py                          # Wrapper integrating uly_fit_a_cmp for parameter inference

---

The Core Modules in LASP-Adam-GPU

LASP-Adam-GPU/
│
├── config/                               # Configuration files for LASP-Adam-GPU
│   └── config.py                         # Data type and device configuration
│
├── tgm_model/                            # Spectral emulator
│   └── elodie32_flux_tgm.fits            # ELODIE polynomial coefficients
│
├── test_data/                            # Test data examples
│   ├── LAMOST_spec_fits/                 # LAMOST spectrum FITS files
│   │   └── *.fits
│   ├── LAMOST_spec_pt/                   # LAMOST spectrum files in .pt format
│   │   └── *.pt
│   └── PyLASP_inferred_results/          # Parameter results inferred by PyLASP
│       └── *.csv
│
├── file_paths.py                         # Obtain the PyLASP file path
│
├── data_to_pt/                           # Convert FITS spectra to .pt format
│   └── data_to_pt.py                     # Step 1: Convert observed spectra to .pt format
│
├── uly_tgm_eval/                         # Model spectrum generation
│   └── uly_tgm_eval_pytorch.py           # Step 2: Generate N model spectra
│
├── WRS/                                  # Wavelength resampling
│   └── xrebin_pytorch.py                 # Step 3: Resample N model spectra to observed wavelengths
│
├── resolution_reduction/                 # Resolution matching
│   └── convol_pytorch.py                 # Step 4: Reduce the resolution of N model spectra to observed spectra
│
├── legendre_polynomial/                  # Shape correction
│   ├── matrix_inverse_benchmark.py       # Efficiency comparison of matrix inversion methods
│   └── mregress_pytorch.py               # Step 5: Correct the shape of N model spectra to match observed spectra
│
│── clean_outliers/                       # Outlier rejection
│   └── clean_pytorch.py                  # Step 6: Clean strategy
│
│── model_err/                            # Parameter uncertainty estimation
│   ├── loss_reduced.py                   # Compute the flux residuals of N spectra
│   └── model_err.py                      # Step 7: Compute the parameter errors of N spectra
│ 
└── uly_fit/                              # Parameter fitting core
    ├── ulyss_pytorch.py                  # Initialize spectrum info for .pt storage (depends on LASP-CurveFit)
    └── uly_fit_conv_poly_pytorch.py      # Run steps 1–7 to compute best-fit parameters and save results to CSV

---

🚀 Workflow

LASP-CurveFit Inference Process

Step 1: Read a target spectrum and store it in a dictionary: uly_spect_read_lms.py

Step 2: Set the initial values for the parameters to be inferred, the Legendre polynomial degree, the model location, and whether to enable the Clean strategy, etc.: ulyss.py

Step 3: ulyss.py further updates the model dictionary and the observed-spectrum dictionary, and passes them to: uly_fit_a_cmp.py

Step 4: uly_fit_a_cmp.py constructs the objective function and iteratively calls: uly_fit_conv_weight_poly.py, which performs:

• Generate the model spectra: uly_tgm_eval.py
• Resample the model spectra to the observed wavelength grid: uly_spect_logrebin.py
• Match the resolution of the model spectra to the observed spectra: convol.py
• Correct the shape of the model spectra to match observed spectra: mregress.py
  

and finally saves the inferred results as CSV file.

LASP-Adam-GPU Inference Process

Step 1: Convert spectrum to .pt format: data_to_pt.py

Step 2: Configure parameters in uly_fit_conv_poly_pytorch.py — including whether to enable the Clean strategy — then construct the objective function and iteratively call:

• Generate N model spectra: uly_tgm_eval_pytorch.py
• Resample N model spectra to the observed wavelength grid: xrebin_pytorch.py
• Match the resolution of N model spectra to the observed spectra: convol_pytorch.py
• Correct the shape of N model spectra to match the observed spectra: mregress_pytorch.py
• Apply the Clean strategy (optional): clean_pytorch.py

Step 3: Once the objective function converges, uly_fit_conv_poly_pytorch.py calls model_err.py to compute the parameter errors of N spectra and saves the final results as a CSV file.

---

⚙️ Parameter Inference Example

LASP-CurveFit Inference Example

• LASP-CurveFit is used to infer stellar parameters: see case 2 in tutorial.ipynb
• Individual spectrum parameter inference using curve_fit
• Uses joblib to provide multiprocessing support for large spectroscopic datasets
• Preserves original IDL logic

LASP-Adam-GPU Inference Example

• LASP-Adam-GPU is used to infer stellar parameters for N spectra simultaneously: see case 3 in tutorial.ipynb
• Performs multi-spectrum parameter inference using the Adam optimizer
• Provides significantly higher throughput for large-scale datasets
• Easily extensible to multi-element or joint-parameter inference

---

🔄 Limitations and Future Work

Feature	Current Status	Planned Improvement	Implementation Plan
Initial Parameter Guess	Single initial guess per spectrum	Support for multiple initializations to improve robustness	Grid search over parameter space; select solution with lowest χ²
Wavelength Coverage	Single continuous range (e.g., 4200-5700 Å)	Add support for disjoint wavelength segments (e.g., 4200-4500 Å and 5200-5700 Å)	Apply wavelength mask array; set mask=0 for excluded regions (e.g., 4500-5200 Å)
Two-Stage Fitting	First-stage implemented	Full two-stage pipeline integration	Remove pseudo-continuum from observed spectra manually, then run PyLASP inference
Multi-Abundance Inference	Only RV, $T_{\rm eff}$, log $g$, [Fe/H]	Joint inference of multiple elemental abundances	Multi-objective optimization with extended spectral model
Legendre Polynomial	Multiplicative correction supported; additive mode not yet successful	Enable both multiplicative and additive polynomial corrections	Iterative testing and implementation refinement
Wavelength Sampling	Tested with log-uniform grids (ln λ)	Support for linear-uniform and non-uniform wavelength grids	Progressive testing across different sampling schemes

---

📄 Citation

When using this code, please cite the following works:

1. ULySS: a full spectrum fitting package
2. Coudé-feed stellar spectral library – atmospheric parameters
3. The first data release (DR1) of the LAMOST regular survey
4. Scalable Stellar Parameter Inference Using Python-Based LASP: From CPU Optimization to GPU Acceleration

---

⚖ License

This project is released under the GNU General Public License v3.0. See the LICENSE file for details.

---