bilby/bilby_mcmc/proposals.py

@@ -547,6 +547,7 @@ class GMMProposal(DensityEstimateProposal):
     def _sample(self, nsamples=None):
         return np.squeeze(self.density.sample(n_samples=nsamples)[0])
 
+    @staticmethod
     def check_dependencies(warn=True):
         if importlib.util.find_spec("sklearn") is None:
             if warn:
@@ -593,12 +594,15 @@ class NormalizingFlowProposal(DensityEstimateProposal):
             fallback=fallback,
             scale_fits=scale_fits,
         )
-        self.setup_flow()
-        self.setup_optimizer()
-
+        self.initialised = False
         self.max_training_epochs = max_training_epochs
         self.js_factor = js_factor
 
+    def initialise(self):
+        self.setup_flow()
+        self.setup_optimizer()
+        self.initialised = True
+
     def setup_flow(self):
         if self.ndim < 3:
             self.setup_basic_flow()
@@ -699,6 +703,9 @@ class NormalizingFlowProposal(DensityEstimateProposal):
         self.trained = True
 
     def propose(self, chain):
+        if self.initialised is False:
+            self.initialise()
+
         import torch
 
         self.steps_since_refit += 1
@@ -728,6 +735,7 @@ class NormalizingFlowProposal(DensityEstimateProposal):
 
         return theta, float(log_factor)
 
+    @staticmethod
     def check_dependencies(warn=True):
         if importlib.util.find_spec("nflows") is None:
             if warn:
@@ -1094,10 +1102,6 @@ def get_proposal_cycle(string, priors, L1steps=1, warn=True):
         ]
         if GMMProposal.check_dependencies(warn=warn):
             plist.append(GMMProposal(priors, weight=big_weight, scale_fits=L1steps))
-        if NormalizingFlowProposal.check_dependencies(warn=warn):
-            plist.append(
-                NormalizingFlowProposal(priors, weight=big_weight, scale_fits=L1steps)
-            )
 
     plist = remove_proposals_using_string(plist, string)
     return ProposalCycle(plist)

bilby/bilby_mcmc/sampler.py

@@ -2,6 +2,7 @@ import datetime
 import os
 import time
 from collections import Counter
+from pathlib import Path
 
 import numpy as np
 import pandas as pd
@@ -387,9 +388,10 @@ class Bilby_MCMC(MCMCSampler):
             logger.info("Written checkpoint file {}".format(self.resume_file))
         else:
             logger.warning(
-                "Cannot write pickle resume file! "
-                "Job will not resume if interrupted."
+                "Cannot write pickle resume file! Job may not resume if interrupted."
             )
+            # Touch the file to postpone next check-point attempt
+            Path(self.resume_file).touch(exist_ok=True)
         self.ptsampler.pool = _pool
 
     def print_long_progress(self):

bilby/core/result.py

@@ -1710,11 +1710,28 @@ class ResultList(list):
         else:
             raise TypeError("Could not append a non-Result type")
 
-    def combine(self, shuffle=False):
+    def combine(self, shuffle=False, consistency_level="error"):
         """
         Return the combined results in a :class:bilby.core.result.Result`
         object.
+
+        Parameters
+        ----------
+        shuffle: bool
+            If true, shuffle the samples when combining, otherwise they are concatenated.
+        consistency_level: str, [warning, error]
+            If warning, print a warning if inconsistencies are discovered between the results before combining.
+            If error, raise an error if inconsistencies are discovered between the results before combining.
+
+        Returns
+        -------
+        result: bilby.core.result.Result
+            The combined result file
+
         """
+
+        self.consistency_level = consistency_level
+
         if len(self) == 0:
             return Result()
         elif len(self) == 1:
@@ -1844,24 +1861,37 @@ class ResultList(list):
             except ValueError:
                 raise ResultListError("Not all results contain nested samples")
 
+    def _error_or_warning_consistency(self, msg):
+        if self.consistency_level == "error":
+            raise ResultListError(msg)
+        elif self.consistency_level == "warning":
+            logger.warning(msg)
+        else:
+            raise ValueError(f"Input consistency_level {self.consistency_level} not understood")
+
     def check_consistent_priors(self):
         for res in self:
             for p in self[0].priors.keys():
                 if not self[0].priors[p] == res.priors[p] or len(self[0].priors) != len(res.priors):
-                    raise ResultListError("Inconsistent priors between results")
+                    msg = "Inconsistent priors between results"
+                    self._error_or_warning_consistency(msg)
 
     def check_consistent_parameters(self):
         if not np.all([set(self[0].search_parameter_keys) == set(res.search_parameter_keys) for res in self]):
-            raise ResultListError("Inconsistent parameters between results")
+            msg = "Inconsistent parameters between results"
+            self._error_or_warning_consistency(msg)
 
     def check_consistent_data(self):
         if not np.allclose([res.log_noise_evidence for res in self], self[0].log_noise_evidence, atol=1e-8, rtol=0.0)\
                 and not np.all([np.isnan(res.log_noise_evidence) for res in self]):
-            raise ResultListError("Inconsistent data between results")
+
+            msg = "Inconsistent data between results"
+            self._error_or_warning_consistency(msg)
 
     def check_consistent_sampler(self):
         if not np.all([res.sampler == self[0].sampler for res in self]):
-            raise ResultListError("Inconsistent samplers between results")
+            msg = "Inconsistent samplers between results"
+            self._error_or_warning_consistency(msg)
 
 
 @latex_plot_format

cli_bilby/bilby_result.py

@@ -89,6 +89,11 @@ def setup_command_line_args():
         action="store_true",
         help="Merge the set of runs, output saved using the outdir and label",
     )
+    action_parser.add_argument(
+        "--ignore-inconsistent",
+        action="store_true",
+        help="If true, ignore inconsistency errors in the merge process, but print a warning",
+    )
     action_parser.add_argument(
         "-b", "--bayes", action="store_true", help="Print all Bayes factors."
     )
@@ -208,7 +213,11 @@ def main():
             save(result, args)
 
     if args.merge:
-        result = results_list.combine()
+        if args.ignore_inconsistent:
+            consistency_level = "warning"
+        else:
+            consistency_level = "error"
+        result = results_list.combine(consistency_level=consistency_level)
         if args.label is not None:
             result.label = args.label
         if args.outdir is not None:

test/bilby_mcmc/test_proposals.py

@@ -165,29 +165,33 @@ class TestProposals(TestBaseProposals):
     def test_NF_proposal(self):
         priors = self.create_priors()
         chain = self.create_chain(10000)
-        prop = proposals.NormalizingFlowProposal(priors, first_fit=10000)
-        prop.steps_since_refit = 9999
-        start = time.time()
-        p, w = prop(chain)
-        dt = time.time() - start
-        print(f"Training for {prop.__class__.__name__} took dt~{dt:0.2g} [s]")
-        self.assertTrue(prop.trained)
-
-        self.proposal_check(prop)
+        if proposals.NormalizingFlowProposal.check_dependencies():
+            prop = proposals.NormalizingFlowProposal(priors, first_fit=10000)
+            prop.steps_since_refit = 9999
+            start = time.time()
+            p, w = prop(chain)
+            dt = time.time() - start
+            print(f"Training for {prop.__class__.__name__} took dt~{dt:0.2g} [s]")
+            self.assertTrue(prop.trained)
+            self.proposal_check(prop)
+        else:
+            print("nflows not installed, unable to test NormalizingFlowProposal")
 
     def test_NF_proposal_15D(self):
         ndim = 15
         priors = self.create_priors(ndim)
         chain = self.create_chain(10000, ndim=ndim)
-        prop = proposals.NormalizingFlowProposal(priors, first_fit=10000)
-        prop.steps_since_refit = 9999
-        start = time.time()
-        p, w = prop(chain)
-        dt = time.time() - start
-        print(f"Training for {prop.__class__.__name__} took dt~{dt:0.2g} [s]")
-        self.assertTrue(prop.trained)
-
-        self.proposal_check(prop, ndim=ndim)
+        if proposals.NormalizingFlowProposal.check_dependencies():
+            prop = proposals.NormalizingFlowProposal(priors, first_fit=10000)
+            prop.steps_since_refit = 9999
+            start = time.time()
+            p, w = prop(chain)
+            dt = time.time() - start
+            print(f"Training for {prop.__class__.__name__} took dt~{dt:0.2g} [s]")
+            self.assertTrue(prop.trained)
+            self.proposal_check(prop, ndim=ndim)
+        else:
+            print("nflows not installed, unable to test NormalizingFlowProposal")
 
 
 if __name__ == "__main__":

test/core/sampler/nessai_test.py

@@ -21,6 +21,7 @@ class TestNessai(unittest.TestCase):
             plot=False,
             skip_import_verification=True,
             sampling_seed=150914,
+            npool=None,  # TODO: remove when support for nessai<0.7.0 is dropped
         )
         self.expected = self.sampler.default_kwargs
         self.expected['output'] = 'outdir/label_nessai/'
@@ -59,10 +60,13 @@ class TestNessai(unittest.TestCase):
         assert self.expected["seed"] == 150914
 
     def test_npool_max_threads(self):
+        # TODO: remove when support for nessai<0.7.0 is dropped
         expected = self.expected.copy()
         expected["n_pool"] = None
+        expected["max_threads"] = 1
         new_kwargs = self.sampler.kwargs.copy()
         new_kwargs["n_pool"] = 1
+        new_kwargs["max_threads"] = 1
         self.sampler.kwargs = new_kwargs
         self.assertDictEqual(expected, self.sampler.kwargs)
 

test/gw/utils_test.py

@@ -104,7 +104,7 @@ class TestGWUtils(unittest.TestCase):
         strain = gwutils.read_frame_file(
             filename, start_time=None, end_time=None, channel=channel
         )
-        self.assertEqual(strain.channel.name, channel)
+        self.assertEqual(strain.name, channel)
         self.assertTrue(np.all(strain.value == data[:-1]))
 
         # Check reading with time limits