RF: Add warning snippet when CompCor fails

Author: effigies

fmriprep/interfaces/patches.py

@@ -12,49 +12,110 @@
 
 from numpy.linalg.linalg import LinAlgError
 from nipype.algorithms import confounds as nac
+from nipype.interfaces.base import (File, traits)
+from nipype.interfaces.mixins import reporting
 
 
-class RobustACompCor(nac.ACompCor):
-    """
-    Runs aCompCor several times if it suddenly fails with
-    https://github.com/poldracklab/fmriprep/issues/776
+class RetryCompCorInputSpecMixin(reporting.ReportCapableInputSpec):
+    out_report = File('report.html', usedefault=True, hash_files=False,
+                      desc='filename for warning HTML snippet')
+    # 'NaN` by default
+    failure_mode = traits.Enum(
+        'NaN', 'error',
+        usedefault=True,
+        desc='When no components are found or convergence fails, raise an error '
+             'or silently return columns of NaNs.')
 
-    """
 
+class RetryCompCorMixin(reporting.ReportCapableInterface):
     def _run_interface(self, runtime):
+        warn = self.inputs.failure_mode == 'NaN'
+
         failures = 0
+        save_exc = None
         while True:
+            success = True
+            # Identifiy success/failure in both error and NaN mode
             try:
-                runtime = super(RobustACompCor, self)._run_interface(runtime)
+                runtime = super()._run_interface(runtime)
+                if warn and self._check_nans():
+                    success = False
+            except LinAlgError as exc:
+                success = False
+                save_exc = exc
+
+            if success:
                 break
-            except LinAlgError:
-                failures += 1
-                if failures > 10:
-                    raise
-                start = (failures - 1) * 10
-                sleep(randint(start + 4, start + 10))
+
+            failures += 1
+            if failures > 10:
+                if warn:
+                    break
+                raise save_exc
+            start = (failures - 1) * 10
+            sleep(randint(start + 4, start + 10))
 
         return runtime
 
+    def _check_nans(self):
+        import numpy as np
+        outputs = self._list_outputs()
+        components = np.loadtxt(outputs['components_file'], skiprows=1)
+        return np.isnan(components).all()
+
+    def _generate_report(self):
+        snippet = ''
+        if self._check_nans():
+            snippet = '''\
+<p class="elem-desc">
+    Warning: {} components could not be estimated, due to a linear algebra error.
+    While not definitive, this may be an indication of a poor mask.
+    Please inspect the {} contours above to ensure that they are located
+    in the white matter/CSF.
+</p>
+'''.format(self._header, 'magenta' if self._header[0] == 'a' else 'blue')
+
+        with open(self._out_report, 'w') as fobj:
+            fobj.write(snippet)
 
-class RobustTCompCor(nac.TCompCor):
+
+class RobustACompCorInputSpec(RetryCompCorInputSpecMixin, nac.ACompCorInputSpec):
+    pass
+
+
+class RobustACompCorOutputSpec(reporting.ReportCapableOutputSpec, nac.ACompCorOutputSpec):
+    pass
+
+
+class RobustACompCor(RetryCompCorMixin, nac.ACompCor):
     """
-    Runs tCompCor several times if it suddenly fails with
-    https://github.com/poldracklab/fmriprep/issues/940
+    Runs aCompCor several times if it suddenly fails with
+    https://github.com/poldracklab/fmriprep/issues/776
+
+    Warns by default, rather than failing, on linear algebra errors.
+    https://github.com/poldracklab/fmriprep/issues/1433
 
     """
+    input_spec = RobustACompCorInputSpec
+    output_spec = RobustACompCorOutputSpec
 
-    def _run_interface(self, runtime):
-        failures = 0
-        while True:
-            try:
-                runtime = super(RobustTCompCor, self)._run_interface(runtime)
-                break
-            except LinAlgError:
-                failures += 1
-                if failures > 10:
-                    raise
-                start = (failures - 1) * 10
-                sleep(randint(start + 4, start + 10))
 
-        return runtime
+class RobustTCompCorInputSpec(RetryCompCorInputSpecMixin, nac.ACompCorInputSpec):
+    pass
+
+
+class RobustTCompCorOutputSpec(reporting.ReportCapableOutputSpec, nac.TCompCorOutputSpec):
+    pass
+
+
+class RobustTCompCor(RetryCompCorMixin, nac.ACompCor):
+    """
+    Runs tCompCor several times if it suddenly fails with
+    https://github.com/poldracklab/fmriprep/issues/776
+
+    Warns by default, rather than failing, on linear algebra errors.
+    https://github.com/poldracklab/fmriprep/issues/1433
+
+    """
+    input_spec = RobustTCompCorInputSpec
+    output_spec = RobustTCompCorOutputSpec