Source code for openpathsampling.numerics.resampling_statistics

Tools for resampling functions that output pandas.DataFrame objects.

Typically, you use these tools in 3 steps:

1. Create resampling groups of data, using, e.g., BlockResampling
2. Create a function that maps a list of input data into the desired output
3. Create a ResamplingStatistics object using the `input` from step 1 and
   the `function` from step 2.

import numpy as np
import itertools
import pandas as pd

import logging
logger = logging.getLogger(__name__)

# NOTE: there may be a better way to do this, by converting the results to
# numpy arrays and using the numpy functions. However, you'd have to be very
# careful that the rows and columns still correspond to the same things,
# i.e., that there's no permutation of index order. Using pandas protects us
# from such problems. Alternatively, it may be possible to bunch these into
# a pandas.Panel, and use pandas functions. All requires some performance
# testing; the advantange of the approach below is that when we want both
# mean and std, the mean can be calculated first and passed to the std to
# speed it up. (However, performance probably won't matter much for the
# things we'll be doing).

def mean_df(objects):
    """Basic calculation of mean (average) of a list of DataFrames.

    objects : list of pandas.DataFrame
        the DataFrames to calculate the mean (NB: technically, these don't
        have to be DataFrames. They must be closed on the `sum` operation
        and over division by a float.

    pandas.DataFrame :
        the mean of each element in the DataFrame
    return sum(objects) / float(len(objects))

def std_df(objects, mean_x=None):
    """Standard deviation of a list of DataFrames.

    objects : list of pandas.DataFrame
        the DataFrames to calculate the standard deviation
    mean_x : pandas.DataFrame
        (optional) pre-calculated mean of the `objects` list. If None
        (default), then the mean will be calculated.

        the standard deviation of each element in the dataframe
    if mean_x is None:
        mean_x = mean_df(objects)
    n_obj = float(len(objects))
    sq = [o**2 for o in objects]
    variance = mean_df(sq) - mean_x**2
    return variance.applymap(np.sqrt)

[docs]class ResamplingStatistics(object): """ Contains and organizes resampled statistics. Attributes ---------- results : list of pandas.DataFrame the result DataFrames after applying the function mean : pandas.DataFrame DataFrame containing mean of the result DataFrames std : pandas.DataFrame DataFrame containing standard deviation of the result DataFrames Parameters ---------- function : callable the function to apply the statistics to; must take one item from the list `inputs` and return a pandas.DataFrame inputs : list each element of inputs is can be used as input to `function` """
[docs] def __init__(self, function, inputs): self.function = function self.inputs = inputs self.results = [self.function(inp) for inp in self.inputs] self._mean = None self._std = None self._sorted_series = None
@property def mean(self): if self._mean is None: self._mean = mean_df(self.results) return self._mean @property def std(self): if self._std is None: self._std = std_df(self.results, mean_x=self.mean) return self._std @property def index(self): return self.mean.index @property def columns(self): return self.mean.columns @property def sorted_series(self): if self._sorted_series is None: self._sorted_series = { loc: pd.Series(df.loc[loc] for df in self.results).sort_values() for loc in itertools.product(self.index, self.columns) } return self._sorted_series def percentile(self, percent): """Percentile, using Nearest Rank method. Parameters ---------- percent : float the percentile desired Returns ------- pd.DataFrame the DataFrame nearest to that percentile """ n_entries = len(self.results) rank = min(int(percent / 100.0 * n_entries), n_entries - 1) df = pd.DataFrame(index=self.index, columns=self.columns) for idx in self.index: for col in self.columns: df.loc[idx, col] = self.sorted_series[(idx, col)].iloc[rank] return df
[docs]class BlockResampling(object): """Select samples according to block resampling. If neither n_blocks nor n_per_block are set (as is the default behavior) then n_blocks=20 is used. The blocks are always of the same size, if the number of samples doesn't divide evenly, then the extra samples are placed in the `unassigned` attribute. Parameters ---------- all_samples : list list of all samples n_blocks : int number of blocks (resampling sets) n_per_block : int number of samples per block """
[docs] def __init__(self, all_samples, n_blocks=None, n_per_block=None): self.n_total_samples = len(all_samples) if n_blocks is None and n_per_block is None: n_blocks = 20 if n_blocks is None and n_per_block is not None: n_blocks = self.n_total_samples // n_per_block elif n_blocks is not None and n_per_block is None: n_per_block = self.n_total_samples // n_blocks self.n_blocks = n_blocks self.n_per_block = n_per_block self.blocks = [all_samples[i*n_per_block:(i+1)*n_per_block] for i in range(n_blocks)] self.unassigned = all_samples[n_blocks*n_per_block:] self.n_resampled = self.n_total_samples - len(self.unassigned)