Merge pull request #21 from weizhongchun/main

add parameter --disable-split-by-charge

Author: ypriverol

.github/workflows/python-app.yml

@@ -32,6 +32,11 @@ jobs:
         # Install the package in development mode
         pip install -e .
     
+    - name: Check PyOpenMS version and API
+      run: |
+        python -c "import pyopenms; print(f'PyOpenMS version: {pyopenms.__version__}')"
+        python -c "from pyopenms import IdXMLFile; help(IdXMLFile.load)"
+    
     - name: Install 7-Zip
       run: sudo apt-get update && sudo apt-get install -y p7zip-full
 

onsite/lucxor/cli.py

@@ -165,6 +165,12 @@
     default=None,
     help="Log file path (only used in debug mode, default: {output_base}_debug.log)"
 )
+@click.option(
+    "--disable-split-by-charge",
+    is_flag=True,
+    default=False,
+    help="Disable splitting PSMs by charge state for model training (train a single global model)"
+)
 def lucxor(
     input_spectrum,
     input_id,
@@ -187,6 +193,7 @@ def lucxor(
     rt_tolerance,
     debug,
     log_file,
+    disable_split_by_charge,
 ):
     """
     Modification site localization using pyLuciPHOr2 algorithm.
@@ -222,6 +229,7 @@ def lucxor(
             threads=threads,
             rt_tolerance=rt_tolerance,
             debug=debug,
+            disable_split_by_charge=disable_split_by_charge,
         )
 
         sys.exit(exit_code)
@@ -348,6 +356,7 @@ def run(
         threads: int,
         rt_tolerance: float,
         debug: bool,
+        disable_split_by_charge: bool = False,
     ) -> int:
         """
         LuciPHOr2 main workflow:
@@ -385,6 +394,7 @@ def run(
                 "min_num_psms_model": min_num_psms_model,
                 "num_threads": threads,
                 "rt_tolerance": rt_tolerance,
+                "disable_split_by_charge": disable_split_by_charge,
             }
         )
 

onsite/lucxor/models.py

@@ -815,59 +815,75 @@ def build(self, psms: List) -> None:
                 f"Insufficient high-scoring PSMs to train CID model (need at least {self.config.get('min_num_psms_model', 50)}, actual {len(psms)})"
             )
 
-        # Group PSMs by charge state
-        charge_psms = defaultdict(list)
-        for psm in psms:
-            charge_psms[psm.charge].append(psm)
-
-        # Check if each charge state has sufficient PSMs for modeling
-        min_psms_per_charge = self.config.get("min_num_psms_model", 50)
-        bad_charges = set()
-
-        logger.info("PSMs for modeling:")
-        logger.info("------------------")
-        for charge in sorted(charge_psms.keys()):
-            n_psms = len(charge_psms[charge])
-            logger.info(f"+{charge}: {n_psms} PSMs")
-            if n_psms < min_psms_per_charge:
-                bad_charges.add(charge)
-                logger.warning(
-                    f"Charge state +{charge} has insufficient PSMs for modeling (need {min_psms_per_charge}, got {n_psms})"
-                )
-
-        # Remove charge states with insufficient PSMs
-        for bad_charge in bad_charges:
-            del charge_psms[bad_charge]
-
-        if not charge_psms:
-            raise RuntimeError(
-                f"No charge states have sufficient PSMs for modeling (minimum {min_psms_per_charge} PSMs per charge state required)"
-            )
+        # Check if charge splitting is disabled
+        disable_split_by_charge = self.config.get("disable_split_by_charge", False)
 
-        logger.info(
-            f"Will build models for charge states: {sorted(charge_psms.keys())}"
-        )
+        if disable_split_by_charge:
+            # Train a single global model using all PSMs
+            logger.info("Training global CID model (charge splitting disabled)")
+            logger.info(f"Total PSMs for modeling: {len(psms)}")
 
-        # Get thread count configuration
-        num_threads = self.config.get("num_threads", os.cpu_count() or 4)
-        logger.info(f"Using {num_threads} threads for CID model training...")
+            # Use a dummy charge state (e.g., 0) to represent the global model
+            global_charge = 0
+            charge, model_data = self._build_charge_model(global_charge, psms)
+            self.charge_models[global_charge] = model_data
 
-        # Parallel processing for each charge state
-        with ThreadPoolExecutor(max_workers=num_threads) as executor:
-            futures = []
-            for charge, charge_psm_list in charge_psms.items():
-                future = executor.submit(
-                    self._build_charge_model, charge, charge_psm_list
+            logger.info(f"Global CID model trained with {len(psms)} PSMs")
+        else:
+            # Original behavior: split by charge state
+            # Group PSMs by charge state
+            charge_psms = defaultdict(list)
+            for psm in psms:
+                charge_psms[psm.charge].append(psm)
+
+            # Check if each charge state has sufficient PSMs for modeling
+            min_psms_per_charge = self.config.get("min_num_psms_model", 50)
+            bad_charges = set()
+
+            logger.info("PSMs for modeling:")
+            logger.info("------------------")
+            for charge in sorted(charge_psms.keys()):
+                n_psms = len(charge_psms[charge])
+                logger.info(f"+{charge}: {n_psms} PSMs")
+                if n_psms < min_psms_per_charge:
+                    bad_charges.add(charge)
+                    logger.warning(
+                        f"Charge state +{charge} has insufficient PSMs for modeling (need {min_psms_per_charge}, got {n_psms})"
+                    )
+
+            # Remove charge states with insufficient PSMs
+            for bad_charge in bad_charges:
+                del charge_psms[bad_charge]
+
+            if not charge_psms:
+                raise RuntimeError(
+                    f"No charge states have sufficient PSMs for modeling (minimum {min_psms_per_charge} PSMs per charge state required)"
                 )
-                futures.append(future)
 
-            # Wait for all tasks to complete
-            for future in as_completed(futures):
-                try:
-                    charge, model_data = future.result()
-                    self.charge_models[charge] = model_data
-                except Exception as e:
-                    logger.error(f"CID model training error: {str(e)}")
+            logger.info(
+                f"Will build models for charge states: {sorted(charge_psms.keys())}"
+            )
+
+            # Get thread count configuration
+            num_threads = self.config.get("num_threads", os.cpu_count() or 4)
+            logger.info(f"Using {num_threads} threads for CID model training...")
+
+            # Parallel processing for each charge state
+            with ThreadPoolExecutor(max_workers=num_threads) as executor:
+                futures = []
+                for charge, charge_psm_list in charge_psms.items():
+                    future = executor.submit(
+                        self._build_charge_model, charge, charge_psm_list
+                    )
+                    futures.append(future)
+
+                # Wait for all tasks to complete
+                for future in as_completed(futures):
+                    try:
+                        charge, model_data = future.result()
+                        self.charge_models[charge] = model_data
+                    except Exception as e:
+                        logger.error(f"CID model training error: {str(e)}")
 
     def _build_charge_model(
         self, charge: int, charge_psm_list: List
@@ -937,6 +953,11 @@ def get_charge_model(self, charge: int) -> Optional[ModelData_CID]:
         Returns:
             ModelData_CID instance, returns None if not found
         """
+        # Check if using global model (charge splitting disabled)
+        if 0 in self.charge_models:
+            # Global model exists, use it for all charges
+            return self.charge_models[0]
+
         # First try to get the exact charge model
         if charge in self.charge_models:
             return self.charge_models[charge]
@@ -1057,47 +1078,63 @@ def build(self, psms: List) -> None:
                 f"Insufficient high-scoring PSMs to train HCD model (need at least {self.config.get('min_num_psms_model', 50)}, actual {len(psms)})"
             )
 
-        charge_psms = defaultdict(list)
-        for psm in psms:
-            charge_psms[psm.charge].append(psm)
-
-        # Check if each charge state has sufficient PSMs for modeling
-        min_psms_per_charge = self.config.get("min_num_psms_model", 50)
-        bad_charges = set()
-
-        logger.info("PSMs for modeling:")
-        logger.info("------------------")
-        for charge in sorted(charge_psms.keys()):
-            n_psms = len(charge_psms[charge])
-            logger.info(f"+{charge}: {n_psms} PSMs")
-            if n_psms < min_psms_per_charge:
-                bad_charges.add(charge)
-                logger.warning(
-                    f"Charge state +{charge} has insufficient PSMs for modeling (need {min_psms_per_charge}, got {n_psms})"
-                )
+        # Check if charge splitting is disabled
+        disable_split_by_charge = self.config.get("disable_split_by_charge", False)
 
-        # Remove charge states with insufficient PSMs
-        for bad_charge in bad_charges:
-            del charge_psms[bad_charge]
+        if disable_split_by_charge:
+            # Train a single global model using all PSMs
+            logger.info("Training global HCD model (charge splitting disabled)")
+            logger.info(f"Total PSMs for modeling: {len(psms)}")
 
-        if not charge_psms:
-            raise RuntimeError(
-                f"No charge states have sufficient PSMs for modeling (minimum {min_psms_per_charge} PSMs per charge state required)"
-            )
+            # Use a dummy charge state (e.g., 0) to represent the global model
+            global_charge = 0
+            charge, model_data = self._build_charge_model(global_charge, psms)
+            self.charge_models[global_charge] = model_data
 
-        logger.info(
-            f"Will build models for charge states: {sorted(charge_psms.keys())}"
-        )
+            logger.info(f"Global HCD model trained with {len(psms)} PSMs")
+        else:
+            # Original behavior: split by charge state
+            charge_psms = defaultdict(list)
+            for psm in psms:
+                charge_psms[psm.charge].append(psm)
+
+            # Check if each charge state has sufficient PSMs for modeling
+            min_psms_per_charge = self.config.get("min_num_psms_model", 50)
+            bad_charges = set()
+
+            logger.info("PSMs for modeling:")
+            logger.info("------------------")
+            for charge in sorted(charge_psms.keys()):
+                n_psms = len(charge_psms[charge])
+                logger.info(f"+{charge}: {n_psms} PSMs")
+                if n_psms < min_psms_per_charge:
+                    bad_charges.add(charge)
+                    logger.warning(
+                        f"Charge state +{charge} has insufficient PSMs for modeling (need {min_psms_per_charge}, got {n_psms})"
+                    )
+
+            # Remove charge states with insufficient PSMs
+            for bad_charge in bad_charges:
+                del charge_psms[bad_charge]
+
+            if not charge_psms:
+                raise RuntimeError(
+                    f"No charge states have sufficient PSMs for modeling (minimum {min_psms_per_charge} PSMs per charge state required)"
+                )
 
-        num_threads = self.config.get("num_threads", os.cpu_count() or 4)
-        logger.info(f"Using {num_threads} threads for HCD model training...")
+            logger.info(
+                f"Will build models for charge states: {sorted(charge_psms.keys())}"
+            )
 
-        with ThreadPoolExecutor(max_workers=num_threads) as executor:
-            futures = []
-            for charge, charge_psm_list in charge_psms.items():
-                future = executor.submit(
-                    self._build_charge_model, charge, charge_psm_list
-                )
+            num_threads = self.config.get("num_threads", os.cpu_count() or 4)
+            logger.info(f"Using {num_threads} threads for HCD model training...")
+
+            with ThreadPoolExecutor(max_workers=num_threads) as executor:
+                futures = []
+                for charge, charge_psm_list in charge_psms.items():
+                    future = executor.submit(
+                        self._build_charge_model, charge, charge_psm_list
+                    )
                 futures.append(future)
 
             for future in as_completed(futures):
@@ -1177,6 +1214,11 @@ def get_charge_model(self, charge: int) -> Optional[ModelData_HCD]:
         Returns:
             ModelData_HCD instance, returns None if not found
         """
+        # Check if using global model (charge splitting disabled)
+        if 0 in self.charge_models:
+            # Global model exists, use it for all charges
+            return self.charge_models[0]
+
         # First try to get the exact charge model
         if charge in self.charge_models:
             return self.charge_models[charge]

pyproject.toml

@@ -21,7 +21,7 @@ classifiers = [
 ]
 requires-python = ">=3.11"
 dependencies = [
-    "pyopenms>=3.4.0",
+    "pyopenms==3.4.0",
     "numpy>=2.3.2",
     "scipy>=1.16.1",
     "click>=8.0.0",
@@ -58,3 +58,4 @@ addopts = "-v --tb=short"
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
+

requirements.txt

@@ -1,4 +1,4 @@
 # Core dependencies
-pyopenms>=3.4.0
+pyopenms==3.4.0
 numpy>=2.3.2
 scipy>=1.16.1