def _set_matplotlib_backend(): """Check if we have custom backend to set and it is different from current one """ backend = cfg.get('matplotlib', 'backend') if backend: import matplotlib as mpl mpl_backend = mpl.get_backend().lower() if mpl_backend != backend.lower(): if __debug__: debug('EXT_', "Trying to set matplotlib backend to %s" % backend) mpl.use(backend) import warnings # And disable useless warning from matplotlib in the future warnings.filterwarnings( 'ignore', 'This call to matplotlib.use() has no effect.*', UserWarning) elif __debug__: debug('EXT_', "Not trying to set matplotlib backend to %s since it was " "already set" % backend)
def _get_verbosity(verbosity): if verbosity is None: return int(cfg.get('tests', 'verbosity', default=1)) return verbosity
import numpy as np import pylab as pl from os.path import join as pjoin from mvpa2 import cfg """ In this example we use a dataset from :ref:`Haxby et al. (2001) <HGF+01>` were participants watched pictures of eight different visual objects, while fMRI was recorded. The following snippet load a portion of this dataset (single subject) from regions on the ventral and occipital surface of the brain. """ # load dataset -- ventral and occipital ROIs from mvpa2.datasets.sources.native import load_tutorial_data datapath = pjoin(cfg.get('location', 'tutorial data'), 'haxby2001') ds = load_tutorial_data(roi=(15, 16, 23, 24, 36, 38, 39, 40, 48)) """ We only do minimal pre-processing: linear trend removal and Z-scoring all voxel time-series with respect to the mean and standard deviation of the "rest" condition. """ # only minial detrending from mvpa2.mappers.detrend import poly_detrend poly_detrend(ds, polyord=1, chunks_attr='chunks') # z-scoring with respect to the 'rest' condition from mvpa2.mappers.zscore import zscore zscore(ds, chunks_attr='chunks', param_est=('targets', 'rest')) # now remove 'rest' samples
def do_sweep(*args_, **kwargs_): """Perform sweeping over provided keyword arguments """ def untrain_clf(argvalue): """Little helper""" if isinstance(argvalue, Classifier): # clear classifier after its use -- just to be sure ;-) argvalue.params.retrainable = False argvalue.untrain() failed_tests = {} skipped_tests = [] report_progress = cfg.get('tests', 'verbosity', default=1) > 1 for argname in kwargs.keys(): for argvalue in kwargs[argname]: if isinstance(argvalue, Classifier): # clear classifier before its use argvalue.untrain() if isinstance(argvalue, ClassWithCollections): argvalue.ca.reset() # update kwargs_ kwargs_[argname] = argvalue # do actual call try: if __debug__: debug( 'TEST', 'Running %s on args=%r and kwargs=%r' % (method.__name__, args_, kwargs_)) method(*args_, **kwargs_) status = '+' except SkipTest, e: skipped_tests += [e] status = 'S' except AssertionError, e: status = 'F' estr = str(e) etype, value, tb = sys.exc_info() # literal representation of exception tb, so # we could group them later on eidstr = ' '.join([ l for l in tbm.format_exception(etype, value, tb) if not ('do_sweep' in l or 'unittest.py' in l or 'AssertionError' in l or 'Traceback (most' in l) ]) # Store exception information for later on groupping if not eidstr in failed_tests: failed_tests[eidstr] = [] sargvalue = str(argvalue) if not (__debug__ and 'TEST' in debug.active): # by default lets make it of sane length if len(sargvalue) > 100: sargvalue = sargvalue[:95] + ' ...' failed_tests[eidstr].append( # skip top-most tb in sweep_args (argname, sargvalue, tb.tb_next, estr)) if __debug__: msg = "%s on %s=%s" % (estr, argname, argvalue) debug('TEST', 'Failed unittest: %s\n%s' % (eidstr, msg)) if report_progress: sys.stdout.write(status) sys.stdout.flush() untrain_clf(argvalue) # TODO: handle different levels of unittests properly if cfg.getboolean('tests', 'quick', False): # on TESTQUICK just run test for 1st entry in the list, # the rest are omitted # TODO: proper partitioning of unittests break
def do_sweep(*args_, **kwargs_): """Perform sweeping over provided keyword arguments """ def untrain_clf(argvalue): """Little helper""" if isinstance(argvalue, Classifier): # clear classifier after its use -- just to be sure ;-) argvalue.params.retrainable = False argvalue.untrain() failed_tests = {} skipped_tests = [] report_progress = cfg.get('tests', 'verbosity', default=1) > 1 for argname in list(kwargs.keys()): for argvalue in kwargs[argname]: if isinstance(argvalue, Classifier): # clear classifier before its use argvalue.untrain() if isinstance(argvalue, ClassWithCollections): argvalue.ca.reset() # update kwargs_ kwargs_[argname] = argvalue # do actual call try: if __debug__: debug( 'TEST', 'Running %s on args=%r and kwargs=%r' % (method.__name__, args_, kwargs_)) method(*args_, **kwargs_) status = '+' except SkipTest as e: skipped_tests += [e] status = 'S' except AssertionError as e: status = 'F' estr = str(e) etype, value, tb = sys.exc_info() # literal representation of exception tb, so # we could group them later on eidstr = ' '.join([ l for l in tbm.format_exception(etype, value, tb) if not ('do_sweep' in l or 'unittest.py' in l or 'AssertionError' in l or 'Traceback (most' in l) ]) # Store exception information for later on groupping if not eidstr in failed_tests: failed_tests[eidstr] = [] sargvalue = safe_str(argvalue) if not (__debug__ and 'TEST' in debug.active): # by default lets make it of sane length if len(sargvalue) > 100: sargvalue = sargvalue[:95] + ' ...' failed_tests[eidstr].append( # skip top-most tb in sweep_args (argname, sargvalue, tb.tb_next, estr)) if __debug__: msg = "%s on %s=%s" % (estr, argname, safe_str(argvalue)) debug('TEST', 'Failed unittest: %s\n%s' % (eidstr, msg)) if report_progress: sys.stdout.write(status) sys.stdout.flush() untrain_clf(argvalue) # TODO: handle different levels of unittests properly if cfg.getboolean('tests', 'quick', False): # on TESTQUICK just run test for 1st entry in the list, # the rest are omitted # TODO: proper partitioning of unittests break if report_progress: sys.stdout.write(' ') sys.stdout.flush() if len(failed_tests): # Lets now create a single AssertionError exception # which would nicely incorporate all failed exceptions multiple = len(failed_tests) != 1 # is it unique? # if so, we don't need to reinclude traceback since it # would be spitted out anyways below estr = "" cestr = "lead to failures of unittest %s" % method.__name__ if multiple: estr += "\n Different scenarios %s "\ "(specific tracebacks are below):" % cestr else: estr += "\n Single scenario %s:" % cestr for ek, els in failed_tests.items(): estr += '\n' if multiple: estr += ek estr += " on\n %s" % ( " ".join([ "%s=%s%s\n" % ( ea, eav, # Why didn't I just do regular for loop? ;) ":\n ".join( [xx for xx in [' ', es] if xx != ''])) for ea, eav, etb, es in els ])) # take first one... they all should be identical etb = els[0][2] raise AssertionError(estr).with_traceback(etb) if len(skipped_tests): # so if nothing has failed, lets at least report that some were # skipped -- for now just a simple SkipTest message raise SkipTest("%d tests were skipped in testing %s" % (len(skipped_tests), method.__name__))
import numpy as np import pylab as pl import os from os.path import join as pjoin from mvpa2 import cfg """ In this example we use a dataset from Haxby et al. (2001) were participants watched pictures of eight different visual objects, while fMRI was recorded. The following snippet load a portion of this dataset (single subject) from regions on the ventral and occipital surface of the brain. """ # load dataset -- ventral and occipital ROIs from mvpa2.datasets.sources.native import load_tutorial_data #'/home/lab/Desktop/PyMVPA-master/mvpa2/data/' #datapath = '/usr/lib/python2.7/dist-packages/mvpa2/data/haxby2001' datapath = pjoin(cfg.get('location', 'tutorial data'), 'haxby2001') ds = load_tutorial_data(path = '/usr/lib/python2.7/dist-packages/mvpa2/data',roi=(15, 16, 23, 24, 36, 38, 39, 40, 48)) """ We only do minimal pre-processing: linear trend removal and Z-scoring all voxel time-series with respect to the mean and standard deviation of the “rest” condition. """ # only minimal detrending from mvpa2.mappers.detrend import poly_detrend poly_detrend(ds, polyord=1, chunks_attr='chunks') # z-scoring with respect to the 'rest' condition from mvpa2.mappers.zscore import zscore zscore(ds, chunks_attr='chunks', param_est=('targets', 'rest')) # now remove 'rest' samples ds = ds[ds.sa.targets != 'rest']
def do_sweep(*args_, **kwargs_): """Perform sweeping over provided keyword arguments """ def untrain_clf(argvalue): """Little helper""" if isinstance(argvalue, Classifier): # clear classifier after its use -- just to be sure ;-) argvalue.params.retrainable = False argvalue.untrain() failed_tests = {} skipped_tests = [] report_progress = cfg.get('tests', 'verbosity', default=1) > 1 for argname in kwargs.keys(): for argvalue in kwargs[argname]: if isinstance(argvalue, Classifier): # clear classifier before its use argvalue.untrain() if isinstance(argvalue, ClassWithCollections): argvalue.ca.reset() # update kwargs_ kwargs_[argname] = argvalue # do actual call try: if __debug__: debug('TEST', 'Running %s on args=%r and kwargs=%r' % (method.__name__, args_, kwargs_)) method(*args_, **kwargs_) status = '+' except SkipTest, e: skipped_tests += [e] status = 'S' except AssertionError, e: status = 'F' estr = str(e) etype, value, tb = sys.exc_info() # literal representation of exception tb, so # we could group them later on eidstr = ' '.join( [l for l in tbm.format_exception(etype, value, tb) if not ('do_sweep' in l or 'unittest.py' in l or 'AssertionError' in l or 'Traceback (most' in l)]) # Store exception information for later on groupping if not eidstr in failed_tests: failed_tests[eidstr] = [] sargvalue = str(argvalue) if not (__debug__ and 'TEST' in debug.active): # by default lets make it of sane length if len(sargvalue) > 100: sargvalue = sargvalue[:95] + ' ...' failed_tests[eidstr].append( # skip top-most tb in sweep_args (argname, sargvalue, tb.tb_next, estr)) if __debug__: msg = "%s on %s=%s" % (estr, argname, argvalue) debug('TEST', 'Failed unittest: %s\n%s' % (eidstr, msg)) if report_progress: sys.stdout.write(status) sys.stdout.flush() untrain_clf(argvalue) # TODO: handle different levels of unittests properly if cfg.getboolean('tests', 'quick', False): # on TESTQUICK just run test for 1st entry in the list, # the rest are omitted # TODO: proper partitioning of unittests break
def run(limit=None, verbosity=None, exit_=False): """Runs the full or a subset of the PyMVPA unittest suite. Parameters ---------- limit : None or list If None, the full test suite is run. Alternatively, a list with test IDs can be provides. IDs are the base filenames of the test implementation, e.g. the ID for the suite in 'mvpa2/tests/test_niftidataset.py' is 'niftidataset'. verbosity : None or int Verbosity of unittests execution. If None, controlled by PyMVPA configuration tests/verbosity. Values >=3 enable all Python, and PyMVPA warnings, >=4 adds NumPy warnings, >=5 -- nose debug info. exit_ : bool, optional Either to exit with an error code upon the completion. """ if __debug__: from mvpa2.base import debug # Lets add some targets which provide additional testing debug.active += ['CHECK_.*'] if verbosity is None: verbosity = int(cfg.get('tests', 'verbosity', default=1)) # provide people with a hint about the warnings that might show up in a # second if verbosity: print("T: MVPA_SEED=%s" % _random_seed) if verbosity > 1: print('T: Testing for availability of external software packages.') # So we could see all warnings about missing dependencies maxcount = warning.maxcount warning.maxcount = 1000 # fully test of externals externals.test_all_dependencies(verbosity=max(0, verbosity-1)) if verbosity < 3: # no MVPA warnings during whole testsuite (but restore handlers later on) handler_backup = warning.handlers warning.handlers = [] # No python warnings (like ctypes version for slmr) import warnings warnings.simplefilter('ignore') if verbosity < 4: # No NumPy np_errsettings = np.geterr() np.seterr(**dict([(x, 'ignore') for x in np_errsettings])) try: if externals.exists('nose'): # Lets just use nose run_tests_using_nose(limit=limit, verbosity=verbosity, exit_=exit_) else: print("T: Warning -- major bulk of tests is skipped since nose " "is unavailable") # collect all tests suites = collect_test_suites(verbosity=verbosity) if limit is None: # make global test suite (use them all) ts = unittest.TestSuite(suites.values()) else: ts = unittest.TestSuite([suites[s] for s in limit]) class TextTestRunnerPyMVPA(unittest.TextTestRunner): """Extend TextTestRunner to print out random seed which was used in the case of failure""" def run(self, test): """Run the bloody test and puke the seed value if failed""" result = super(TextTestRunnerPyMVPA, self).run(test) if not result.wasSuccessful(): print "MVPA_SEED=%s" % _random_seed # finally run it TextTestRunnerPyMVPA(verbosity=verbosity).run(ts) finally: # restore warning handlers warning.maxcount = maxcount if verbosity < 3: # restore warning handlers warning.handlers = handler_backup if verbosity < 4: # restore numpy settings np.seterr(**np_errsettings)