Python implementation of the multistate Bennett acceptance ratio (MBAR)

Overview

Build Status Anaconda Cloud Downloads Badge Anaconda Cloud Badge PyPI Version DOI

pymbar

Python implementation of the multistate Bennett acceptance ratio (MBAR) method for estimating expectations and free energy differences from equilibrium samples from multiple probability densities. See our docs.

Installation

The easiest way to install the pymbar release is via conda:

conda install -c conda-forge pymbar

You can also install pymbar from the Python package index using pip:

pip install pymbar

The development version can be installed directly from github via pip:

pip install git+https://github.com/choderalab/pymbar.git

Usage

Basic usage involves importing pymbar and constructing an MBAR object from the reduced potential of simulation or experimental data.

Suppose we sample a 1D harmonic oscillator from a few thermodynamic states:

>>> from pymbar import testsystems
>>> [x_n, u_kn, N_k, s_n] = testsystems.HarmonicOscillatorsTestCase().sample()

We have the nsamples sampled oscillator positions x_n (with samples from all states concatenated), reduced potentials in the (nstates,nsamples) matrix u_kn, number of samples per state in the nsamples array N_k, and indices s_n denoting which thermodynamic state each sample was drawn from.

To analyze this data, we first initialize the MBAR object:

>>> mbar = MBAR(u_kn, N_k)

Estimating dimensionless free energy differences between the sampled thermodynamic states and their associated uncertainties (standard errors) simply requires a call to getFreeEnergyDifferences():

>>>  results = mbar.getFreeEnergyDifferences(return_dict=True)

Here results is a dictionary with keys Deltaf_ij, dDeltaf, and Theta. Deltaf_ij[i,j] is the matrix of dimensionless free energy differences f_j - f_i, dDeltaf_ij[i,j] is the matrix of standard errors in this matrices estimate, and Theta is a covariance matrix that can be used to propagate error into quantities derived from the free energies. By default, return_dict is False and the return will be a tuple.

Expectations and associated uncertainties can easily be estimated for observables A(x) for all states:

>>> A_kn = x_kn # use position of harmonic oscillator as observable
>>> results = mbar.computeExpectations(A_kn, return_dict=True)

where results is a dictionary with keys mu, sigma, and Theta, where mu[i] is the array of the estimate for the average of the observable for in state i, sigma[i] is the estimated standard deviation of the mu estimates, and Theta[i,j] is the covarinace matrix of the log weights.

See the docstring help for these individual methods for more information on exact usage; in Python or IPython, you can view the docstrings with help().

Authors

References

  • Please cite the original MBAR paper:

    Shirts MR and Chodera JD. Statistically optimal analysis of samples from multiple equilibrium states. J. Chem. Phys. 129:124105 (2008). DOI

  • Some timeseries algorithms can be found in the following reference:

    Chodera JD, Swope WC, Pitera JW, Seok C, and Dill KA. Use of the weighted histogram analysis method for the analysis of simulated and parallel tempering simulations. J. Chem. Theor. Comput. 3(1):26-41 (2007). DOI

  • The automatic equilibration detection method provided in pymbar.timeseries.detectEquilibration() is described here:

    Chodera JD. A simple method for automated equilibration detection in molecular simulations. J. Chem. Theor. Comput. 12:1799, 2016. DOI

License

pymbar is free software and is licensed under the MIT license.

Thanks

We would especially like to thank a large number of people for helping us identify issues and ways to improve pymbar, including Tommy Knotts, David Mobley, Himanshu Paliwal, Zhiqiang Tan, Patrick Varilly, Todd Gingrich, Aaron Keys, Anna Schneider, Adrian Roitberg, Nick Schafer, Thomas Speck, Troy van Voorhis, Gupreet Singh, Jason Wagoner, Gabriel Rocklin, Yannick Spill, Ilya Chorny, Greg Bowman, Vincent Voelz, Peter Kasson, Dave Caplan, Sam Moors, Carl Rogers, Josua Adelman, Javier Palacios, David Chandler, Andrew Jewett, Stefano Martiniani, and Antonia Mey.

Notes

Comments
  • Pymbar4 bootstrapping

    Pymbar4 bootstrapping

    Adding support for bootstrapped errors to all expectations.

    Computes bootstrap uncertainties and covariances for:

    • compute_free_energy_differences
    • compute_expectations
    • compute_multiple_expectations
    • compute_perturbed_free_energies
    • compute_entropy_and_enthalpy

    These are accessed by using the uncertainty_method = "bootstrap". Note that MBAR needs to be initialized with "n_bootstrap=(some integer)" samples in order to do use this method - an error is omitted otherwise. Possibly could be done differently, but the logic is simpler this way for now.

    I could use a little help in rewriting the pytests. Currently, to get bootstrap uncertainties from various functions, as one will now want to check both the default uncertainties and the bootstrap uncertainties, and MBAR needs to be initialized differently each way, which the pytests don't seem to handle.

    Note this is built off of #444, so many of the differences are from that branch.

    opened by mrshirts 71
  • Bootstrap uncertainties first pass

    Bootstrap uncertainties first pass

    Just putting it up here to show what is going on. Works for free energies so far, still need to get it working for other sections. No merging yet until that is working!

    opened by mrshirts 51
  • Nk

    Nk

    Here's the proposed generalization of the expectations. Not quite as clean as I would have hoped, and took a while to get it to this state, but does eliminate a lot of the non-vectorized loops.

    It appears to be slightly slower for larger N (500K to 2M states), and I have not yet tested the performance on large numbers of states (sampled or unsampled) between the codes. It may require a bit of tweaking.

    I didn't try to run the PMF code through it as well; that would have meant a number of other conditionals that seemed to complicated the code too much.

    It may make sense to split out the computePerturbedFreeEnergies functions; that will simplify the inner loop a bit more.

    opened by mrshirts 41
  • proposed conversion from u_kln->u_kn formalism

    proposed conversion from u_kln->u_kn formalism

    includes a slightly modified harmonic_oscillator_update.py, which gives identical behavior with the new code to pymbar-examples/harmonic_oscillator.py run with the previous code up to numerical precision.

    This new code automatically converts from old-style u_kln matrices internally.

    It supports all existing functionality, including updating the weave code and the _pymbar.c code.

    The one major difference is in handling computeExpectations. This change hopefully provides a much more general solution which can possibly reduce the total amount of repetitive code as well.

    Previously, computeExpectations recognized whether observables were state_dependent or state_independent by whether the observable array was KxN_max, or KxLxN_max. Now, this is done by giving an explicit state_dependent flag. If state_dependent is False, computeExpectations handles the code like the 2D version before (although now the array is 1D, the observable at each state). The big difference is if state_dependent is True. In this case, computeExpectations expects K different observables (the K different observables at each state - for example, the potential energies in each of the K states), as well as K different energies (which defaults to just the u_kn matrix MBAR was generated with). It then calculates the expectations of the first observable and the first state, 2nd observable and the 2nd state, and so forth, which is what the previous code did.

    In order to make this happen, I've created a computeGeneralExpectations routine, that takes in I observable arrays and K state observables (see see #89 ).

    I'm up for lots of other improvements; but I though it would be easier to start by solving the biggest problem first independently of other issues.

    opened by mrshirts 33
  • Convert to N x K storage for U_kln matrix

    Convert to N x K storage for U_kln matrix

    For data sets where we have different numbers of samples at different states, rather than having the energies stored in a KxKxN_each matrix, it would be more efficient to store data as a KxN_tot matrix, where N is the total number of sampled collected, and K is the number of states we are evaluating the energies at. This will take a bit of extra work, however,

    enhancement 
    opened by mrshirts 32
  • Pymbar4 with jax (real try now)

    Pymbar4 with jax (real try now)

    A branch that supports JAX, including minimize using BFGS and adaptive. It does not pass all the tests yet (because some pathways are mixed JAX/numpy, and those don't get handled well). But it will pass a lot of of the tests locally. I have not tested in GPU's yet. But it at least can be configured to run with JAX now on the conda environment. solver_protocol="jax" will exercise all of the JAX accelerated options.

    opened by mrshirts 29
  • Coming up with a good pathway to use BAR to initialize free energies with arbitrary state connectivities

    Coming up with a good pathway to use BAR to initialize free energies with arbitrary state connectivities

    in 1D, its clear that BAR is between neighboring states. In 2D is is not so clear which path to choose. Is there a way to guess a good path? Or do we just give up and let the user specify one, or just do i->i+1 as given.

    enhancement 
    opened by mrshirts 27
  • Add deprecation warnings for camelCase names and add snake_case variants

    Add deprecation warnings for camelCase names and add snake_case variants

    Addresses #365

    I added a temporary _deprecate function in _deprecate.py to ease the transition and avoid duplication. I have tested it with functions and should also work with methods...

    I took master as a base, but most of the changes here won't reach Pymbar 4 (only the name replacements), and we have this excellent table here now:

    BAR_zero                                             BARzero
    BAR_zero                                             computeBARzero
    BAR                                                  computeBAR
    order_replicates                                     OrderReplicates
    anderson_darling                                     AndersonDarling
    QQ_plot                                              QQPlot
    generate_confidence_intervals                        generateConfidenceIntervals
    EXP_gauss                                            EXPGauss
    EXP                                                  computeEXP
    EXPGauss                                             computeEXPGauss
    weights                                              getWeights
    compute_effective_sample_number                      computeEffectiveSampleNumber
    compute_overlap                                      computeOverlap
    compute_free_energy_differences                      getFreeEnergyDifferences
    compute_expectations_inner                           computeExpectationsInner
    compute_covariance_of_sums                           computeCovarianceOfSums
    compute_expectations                                 computeExpectations
    compute_multiple_expectations                        computeMultipleExpectations
    compute_perturbed_free_energies                      computePerturbedFreeEnergies
    compute_entropy_and_enthalpy                         computeEntropyAndEnthalpy
    compute_pmf                                          computePMF
    statistical_inefficiency                             statisticalInefficiency
    statistical_inefficiency_multiple                    statisticalInefficiencyMultiple
    integrated_autocorrelation_time                      integratedAutocorrelationTime
    integrated_autocorrelation_time_multiple             integratedAutocorrelationTimeMultiple
    normalized_fluctuation_correlation_function          normalizedFluctuationCorrelationFunction
    normalized_fluctuation_correlation_function_multiple normalizedFluctuationCorrelationFunctionMultiple
    subsample_correlated_data                            subsampleCorrelatedData
    detect_equilibration                                 detectEquilibration
    statistical_inefficiency_fft                         statisticalInefficiency_fft
    detect_equilibration_binary_search                   detectEquilibration_binary_search
    

    I have only modified callables for now. Attributes (if relevant), parameters and free variables are untouched for now.

    opened by jaimergp 24
  • Fast numexpr / scipy MBAR solver.

    Fast numexpr / scipy MBAR solver.

    Lots of stuff going on here, but it's all logically related so a "big" PR is mostly unavoidable.

    1. Moved current version of MBAR to old_mbar.py as a reference implementation for testing against.
    2. Cleared all MBAR solver code into mbar_solvers.py
    3. Added fast NumExpr based logsumexp() function to use as foundation of fast-but-precise MBAR calculations. If NumExpr is unavailable, a pure-numpy implementation is used.
    4. Implemented matrix multiplication-based faster-but-imprecise MBAR calculations.
    5. Replaced hand-written solvers with a single interface to scipy.optimize.minimize and scipy.optimize.root, which are scipy's unified interfaces to minimization and root-finding algorithms, respectively.
    6. Because balancing precision and performance is pretty challenging, we need to make multiple passes through the solver--first get a rough guess with BFGS, then refine it with the MINPACK implementation of NR / HYBR. mbar_solvers.solve_mbar() uses a "protocol" to call BFGS and NR code several times in a way that achieves similar precision while matching the performance of the old MBAR code.
    7. Added pymbar/testsystems/pymbar_datasets.py to automatically load the large datasets from compressed HDF5 files, which I will add to the pymbar-datasets repository soon.
    8. Added tests/test_mbar_solvers.py to test the accuracy of the new MBAR code on several challenging systems, and also compare to the old MBAR code.
    9. Added scripts/benchmark_pymbar.py to do performance and accuracy benchmarks against the old mbar code on several challenging datasets, including the gas and 8proteins datasets.

    Overall, the speed is somewhat improved for the challenging gas and 8proteins datasets. More importantly, this restructuring helps us eliminate the weave dependence (needed for Py3 compliance) and the hand-written C code. I also think that mbar_solvers.py is an improvement in readability. If we need more speed in the future, we can plug in faster versions of the gradient / hessian calculation.

    opened by kyleabeauchamp 24
  • camelCase -> snake_case

    camelCase -> snake_case

    Following PEP8 recommendations and using table of replacements as provided in #368.

    Note that examples/ is not affected in this PR. They will be "modernized" in a separate PR.

    Questions

    • [x] Shall I apply snake_case to public attributes and module-level variables?
    • [x] Shall I apply snake_case to unexposed variables?

    Notes

    • This PR introduces breaking changes! Check replacements in #368.
      • Special attention: getFreeEnergyDifferences is now compute_free_energy_differences, for consistency with other methods and functions.
    • pymbar.bar and pymbar.exp modules have been merged into pymbar.other_estimators.

    Summary of changed names:

    AndersonDarling                                    anderson_darling
    BARzero                                            bar_zero
    computeBAR                                         bar
    computeBARzero                                     bar_zero
    computeCovarianceOfSums                            compute_covariance_of_sums
    computeEffectiveSampleNumber                       compute_effective_sample_number
    computeEntropyAndEnthalpy                          compute_entropy_and_enthalpy
    computeEXP                                         exp
    computeExpectations                                compute_expectations
    computeExpectationsInner                           compute_expectations_inner
    computeEXPGauss                                    exp_gauss
    computeMultipleExpectations                        compute_multiple_expectations
    computeOverlap                                     compute_overlap
    computePerturbedFreeEnergies                       compute_perturbed_free_energies
    computePMF                                         compute_pmf
    detectEquilibration                                detect_equilibration
    detectEquilibration_binary_search                  detect_equilibration_binary_search
    EXPGauss                                           exp_gauss
    generateConfidenceIntervals                        generate_confidence_intervals
    generatePMF                                        generate_pmf
    GetAnalytical                                      get_analytical
    getFreeEnergyDifferences                           compute_free_energy_differences
    getInformationCriteria                             get_information_criteria
    getKDE                                             get_kde
    getMBAR                                            get_mbar
    getPMF                                             get_pmf
    getWeights                                         weights
    integratedAutocorrelationTime                      integrated_autocorrelation_time
    integratedAutocorrelationTimeMultiple              integrated_autocorrelation_time_multiple
    normalizedFluctuationCorrelationFunction           normalized_fluctuation_correlation_function
    normalizedFluctuationCorrelationFunctionMultiple   normalized_fluctuation_correlation_function_multiple
    OrderReplicates                                    order_replicates
    PrintResults                                       print_results
    QQPlot                                             qq_plot
    statisticalInefficiency                            statistical_inefficiency
    statisticalInefficiency_fft                        statistical_inefficiency_fft
    statisticalInefficiencyMultiple                    statistical_inefficiency_multiple
    subsampleCorrelatedData                            subsample_correlated_data
    
    opened by jaimergp 20
  • [WIP] FFT based equilibration detection.

    [WIP] FFT based equilibration detection.

    One issue is that some of the previous "tricks" are ineffective (e.g. fast=True), as the FFT-based approach calculates all lagtimes simultaneously.

    For the search the discard region t, I've elected to just do binary search of the logarithmically-spaced lagtime grid.

    opened by kyleabeauchamp 20
  • Do not use removed `numpy.bool`

    Do not use removed `numpy.bool`

    >>> import numpy
    >>> numpy.__version__
    '1.24.0'
    >>> numpy.bool
    <stdin>:1: FutureWarning: In the future `np.bool` will be defined as the corresponding NumPy scalar.  (This may have returned Python scalars in past versions.
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
      File "/Users/mattthompson/mambaforge/envs/openff-interchange-env/lib/python3.9/site-packages/numpy/__init__.py", line 284, in __getattr__
        raise AttributeError("module {!r} has no attribute "
    AttributeError: module 'numpy' has no attribute 'bool'
    opened by mattwthompson 2
  • Examples do not work with NumPy 1.24

    Examples do not work with NumPy 1.24

    Aliases for built-ins were deprecated in February 2021: https://numpy.org/doc/stable/release/1.20.0-notes.html#using-the-aliases-of-builtin-types-like-np-int-is-deprecated

    https://github.com/choderalab/pymbar/actions/runs/3736207271/jobs/6340264997

    opened by mattwthompson 5
  • The discrepancy in calculating u_kln  between  parallel-tempering-2dpmf.py and umbrella-sampling.py

    The discrepancy in calculating u_kln between parallel-tempering-2dpmf.py and umbrella-sampling.py

    After reading the examples for calculating the PMF based on data by parallel-templering and umbrella-sampling simulations, i found that there is a discrepancy in calculating u_kln(reduced potential energy).

    Following the line 222 to 226 in (https://github.com/mrshirts/pymbar/blob/master/examples/parallel-tempering-2dpmf/parallel-tempering-2dpmf.py), reduced potential energy( u_kln[k,l,n] ) of trajectory segment n of temperature k evaluated at temperature l was calculated by following:.

        print("Computing reduced potential energies...")
        u_kln = numpy.zeros([K,K,N_max]) # u_kln[k,l,n] is reduced potential energy of trajectory segment n of temperature k evaluated at temperature l
        for k in range(K):
           for l in range(K):
              u_kln[k,l,0:N_k[k]] = beta_k[l] * U_kn[k,0:N_k[k]]
    

    which means that u_kln[k,l,n] = beta_k[l] * U_kn[k,n] = beta_k[l] * U_kn[k,l,n] ( without bias, U_kn[k,n] = U_kn[k,1,n] = U_kn[k,2,n] = ... = U_kn[k,l,n] = .... ). [equation 1]

    While in the examples of analyzing the data by umbrella sampling, as shown in the line 141 to 143 of https://github.com/mrshirts/pymbar/blob/master/examples/umbrella-sampling-pmf/umbrella-sampling.py, it is calculated by:

        # Compute energy of snapshot n from simulation k in umbrella potential l
        u_kln[k,:,n] = u_kn[k,n] + beta_k[k] * (K_k/2.0) * dchi**2
    

    where

        u_kn[k,n] = beta_k[k] * (float(tokens[2]) - float(tokens[1])) # reduced potential energy without umbrella restraint(line 89)
    

    which indicates: u_kln[k,l,n] = beta_k[k] * U0_kn[k,n] + beta_k[k] * (K_k[l] / 2.0) * dchi[l]**2 = beta_k[k] * ( U0_kn[k,n] + (K_k[l] / 2.0) * dchi[l]**2 ) = beta_k[k] * U_kn[k,l,n] [ equation 2]

    It seems that the [equation 1] is the correct expression, while the [ equation 2 ] is not.

    Generally, based on [ euqation 2 ], for umbrella sampling of constanst temperature(beta_k[k] = beta_k[l]), it is ok, while for different temperature, it will lead to incorrect result.

    Here are my suggestions: 1)In line 89 of https://github.com/mrshirts/pymbar/blob/master/examples/umbrella-sampling-pmf/umbrella-sampling.py,

      u_kn[k,n] = beta_k[k] * (float(tokens[2]) - float(tokens[1])) # reduced potential energy without umbrella restraint
    

    should be changed to :

      U_kn[k,n] = float(tokens[2]) - float(tokens[1])  # potential energy without umbrella restraint
    

    2)In line 143,

      u_kln[k,:,n] = u_kn[k,n] + beta_k[k] * (K_k/2.0) * dchi**2 
    

    should be changed to:

      u_kln[k,:,n] = beta_k * ( U_kn[k,n] + (K_k/2.0) * dchi**2 )
    
    opened by Vinvin-Zhang 1
  • bin value are not unique

    bin value are not unique

    I found that in line 544-548 of pymbar/fes.py you wrote

                    # how do we label the bins? if N-dimensional:
                    # bins[0] + bins[1]*bin_length[1]**1 + bins[2]*bin_length[2]**2
                    sample_label[n] = int(
                        np.sum([bin_n[n][d] * bin_length[d] ** d for d in range(dims)])
                    )
    

    However, this setting can not give unique bin values. For example, given bin_length=[100,2], bins=(30,1) and bins=(32,0) would have the same bin value of 32 (i.e. 30*100**0+1*2**1=32*100**0+0*2**1=32).

    Non-unique bin values would cause under-counting of histogram_data["bin_order"] in line 566-576 of pymbar/fes.py

            if b == 0:
                bin_order = {}
                i = 0
                for bv in bin_label.values():
                    if bv not in bin_order:
                        bin_order[bv] = i
                        i += 1
                histogram_data["bin_order"] = bin_order
                histogram_data["bin_label"] = bin_label
            else:
                bin_order = self.histogram_data["bin_order"]
    

    I would suggest to correct line 546-548 of pymbar/fes.py to be

                    sample_label[n] = int(
                        np.sum([bin_n[n][d] * np.sum(bin_length[:d+1]) ** d for d in range(dims)])
                    )
    
    enhancement 
    opened by shawnhsueh 3
  • bin_edges in multi-dimension PMF can only have equal number of element in each dimension

    bin_edges in multi-dimension PMF can only have equal number of element in each dimension

    I want to construct a 2D-PMF using fes.get_fes function. However, I found that the number of bins in each dimension must be the same to avoid an error.

    The problem might rooted In line 467 and 468 of pymbar/fes.py

            if len(np.shape(histogram_parameters["bin_edges"])) == 1:
                histogram_parameters["bin_edges"] = [histogram_parameters["bin_edges"]]
    

    The if-statement would pass if the number of bins in each dimension (each element in histogram_parameters["bin_edges"]) are not the same. Say, if histogram_parameters["bin_edges"]=[np.array(1,2,3,4),np.array(1,2)], the if-statement could also pass.

    question 
    opened by shawnhsueh 3
Releases(3.1.1)
  • 3.1.1(Nov 30, 2022)

  • 3.1(Jul 29, 2022)

    What's New

    We now support computation of bootstrapped uncertainties for MBAR free energies -- just specify n_bootstraps=n_desired_bootstraps when initializing MBAR(), where n_desired_bootstraps is the number of bootstrap iterations you'd like to run, and uncertainty_method='bootstrap' when calling getFreeEnergyDifferences().

    What's Changed

    • Fix for expectations of very small numbers by @mrshirts in https://github.com/choderalab/pymbar/pull/441
    • Noticed one bug in setlogzero commit by @mrshirts in https://github.com/choderalab/pymbar/pull/443
    • Getting CI working on the current default branch by @mikemhenry in https://github.com/choderalab/pymbar/pull/449
    • Bootstrap uncertainties first pass by @mrshirts in https://github.com/choderalab/pymbar/pull/302
    • Fix divide by zero warning in pymbar3 by @zhang-ivy in https://github.com/choderalab/pymbar/pull/470
    • sphinx.ext.pngmath is now sphinx.ext.imgmath by @mikemhenry in https://github.com/choderalab/pymbar/pull/471

    New Contributors

    • @zhang-ivy made their first contribution in https://github.com/choderalab/pymbar/pull/470

    Full Changelog: https://github.com/choderalab/pymbar/compare/3.0.7...3.1

    Source code(tar.gz)
    Source code(zip)
  • 4.0.1(Jul 20, 2022)

    Breaking Changes Ahead!

    This pymbar release has several API changes and some exciting new features (such as JAX acceleration and support)

    See this guide on how to migrate from pymbar 3.x to pymbar 4.x.

    pymbar 3.x support

    We will still support the pymbar 3.x version line as a long term support release. We encourage new pymbar users to use the 4.x version, but due to the considerable infrastructure build around pymbar 3.x, we will continue to provide maintenance support. Don't expect new features to be backported, but we will fix bugs.

    What's Changed

    • Fixed return type of multiple values to dict-like object by @mrshirts in https://github.com/choderalab/pymbar/pull/325
    • Move CI to GHA and start upgrade to Cookiecutter style by @Lnaden in https://github.com/choderalab/pymbar/pull/328
    • Convert to PyTest by @Lnaden in https://github.com/choderalab/pymbar/pull/333
    • Reused the gradient calculation in the adaptive algorithm. by @mrshirts in https://github.com/choderalab/pymbar/pull/336
    • Add CodeCov by @Lnaden in https://github.com/choderalab/pymbar/pull/344
    • Replace np.matrix calls and other warnings by @Lnaden in https://github.com/choderalab/pymbar/pull/334
    • Fix formatting by @mrshirts in https://github.com/choderalab/pymbar/pull/342
    • Reduce the cost of check for duplicate states by @mrshirts in https://github.com/choderalab/pymbar/pull/337
    • Revamping of PMF by @mrshirts in https://github.com/choderalab/pymbar/pull/327
    • Start Coverage Improvements (Mbar.py) by @Lnaden in https://github.com/choderalab/pymbar/pull/347
    • Bar.py and exp.py tests by @mrshirts in https://github.com/choderalab/pymbar/pull/350
    • cleaning up examples by @mrshirts in https://github.com/choderalab/pymbar/pull/352
    • Remove 2.01 compatible calls for exp and bar. by @mrshirts in https://github.com/choderalab/pymbar/pull/354
    • Even more coverage! by @Lnaden in https://github.com/choderalab/pymbar/pull/357
    • From print to logging by @jaimergp in https://github.com/choderalab/pymbar/pull/360
    • Add linting to CI by @jaimergp in https://github.com/choderalab/pymbar/pull/367
    • Apply black to the whole package by @jaimergp in https://github.com/choderalab/pymbar/pull/371
    • camelCase -> snake_case by @jaimergp in https://github.com/choderalab/pymbar/pull/372
    • Make Pylint less noisy by @Lnaden in https://github.com/choderalab/pymbar/pull/375
    • Modernize examples by @jaimergp in https://github.com/choderalab/pymbar/pull/374
    • Refactoring pmf code by @mrshirts in https://github.com/choderalab/pymbar/pull/385
    • Better dimension checking by @mrshirts in https://github.com/choderalab/pymbar/pull/386
    • Bin edges support by @mrshirts in https://github.com/choderalab/pymbar/pull/387
    • Apply Black to examples/ too by @jaimergp in https://github.com/choderalab/pymbar/pull/392
    • Updated heat capacity example by @mrshirts in https://github.com/choderalab/pymbar/pull/394
    • Replace "potential of mean force" with "free energy surface" by @mrshirts in https://github.com/choderalab/pymbar/pull/397
    • Update GHA to use Conda-Incubator by @Lnaden in https://github.com/choderalab/pymbar/pull/410
    • Bump conda-incubator in GHA to v2 by @Lnaden in https://github.com/choderalab/pymbar/pull/411
    • Clean out old Omnia references for Pymbar 4.0 branch by @Lnaden in https://github.com/choderalab/pymbar/pull/412
    • Modernize setup.py and versioning by @jaimergp in https://github.com/choderalab/pymbar/pull/413
    • Fix for expectations of very small numbers by @mrshirts in https://github.com/choderalab/pymbar/pull/441
    • Noticed one bug in setlogzero commit by @mrshirts in https://github.com/choderalab/pymbar/pull/443
    • Syncing Pymbar4 with master by @mrshirts in https://github.com/choderalab/pymbar/pull/444
    • Getting CI working on the current default branch by @mikemhenry in https://github.com/choderalab/pymbar/pull/449
    • Pymbar 4.0 adaptive logic by @mrshirts in https://github.com/choderalab/pymbar/pull/446
    • Pymbar4 add adaptivity by @mrshirts in https://github.com/choderalab/pymbar/pull/453
    • Convert JAX JIT to Decorators by @Lnaden in https://github.com/choderalab/pymbar/pull/451
    • Align namespaces to work if JAX is not installed by @Lnaden in https://github.com/choderalab/pymbar/pull/454
    • Pymbar4 bootstrapping by @mrshirts in https://github.com/choderalab/pymbar/pull/448
    • Remove old_mbar.py by @mrshirts in https://github.com/choderalab/pymbar/pull/457
    • Pymbar4 with jax (real try now) by @mrshirts in https://github.com/choderalab/pymbar/pull/447
    • Pymbar 4.0 by @mrshirts in https://github.com/choderalab/pymbar/pull/458
    • [WIP] Pymbar4 documentation by @mrshirts in https://github.com/choderalab/pymbar/pull/455
    • remove special character for now. by @mrshirts in https://github.com/choderalab/pymbar/pull/460
    • switch to napoleon for better output formatting. by @mrshirts in https://github.com/choderalab/pymbar/pull/461
    • More working on doc appearance. by @mrshirts in https://github.com/choderalab/pymbar/pull/462
    • Update classifier to match PyPi expectations. by @Lnaden in https://github.com/choderalab/pymbar/pull/465
    • Further improve RTD and previous versions. by @mrshirts in https://github.com/choderalab/pymbar/pull/466
      • Further improve RTD and previous versions. by @mrshirts in https://github.com/choderalab/pymbar/pull/467

    Full Changelog: https://github.com/choderalab/pymbar/compare/3.0.7...4.0.1

    Source code(tar.gz)
    Source code(zip)
  • 4.0.0(Jul 20, 2022)

    Breaking Changes Ahead!

    This pymbar release has several API changes and some exciting new features (such as JAX acceleration and support)

    See this guide on how to migrate from pymbar 3.x to pymbar 4.x.

    pymbar 3.x support

    We will still support the pymbar 3.x version line as a long term support release. We encourage new pymbar users to use the 4.x version, but due to the considerable infrastructure build around pymbar 3.x, we will continue to provide maintenance support. Don't expect new features to be backported, but we will fix bugs.

    What's Changed

    • Fixed return type of multiple values to dict-like object by @mrshirts in https://github.com/choderalab/pymbar/pull/325
    • Move CI to GHA and start upgrade to Cookiecutter style by @Lnaden in https://github.com/choderalab/pymbar/pull/328
    • Convert to PyTest by @Lnaden in https://github.com/choderalab/pymbar/pull/333
    • Reused the gradient calculation in the adaptive algorithm. by @mrshirts in https://github.com/choderalab/pymbar/pull/336
    • Add CodeCov by @Lnaden in https://github.com/choderalab/pymbar/pull/344
    • Replace np.matrix calls and other warnings by @Lnaden in https://github.com/choderalab/pymbar/pull/334
    • Fix formatting by @mrshirts in https://github.com/choderalab/pymbar/pull/342
    • Reduce the cost of check for duplicate states by @mrshirts in https://github.com/choderalab/pymbar/pull/337
    • Revamping of PMF by @mrshirts in https://github.com/choderalab/pymbar/pull/327
    • Start Coverage Improvements (Mbar.py) by @Lnaden in https://github.com/choderalab/pymbar/pull/347
    • Bar.py and exp.py tests by @mrshirts in https://github.com/choderalab/pymbar/pull/350
    • cleaning up examples by @mrshirts in https://github.com/choderalab/pymbar/pull/352
    • Remove 2.01 compatible calls for exp and bar. by @mrshirts in https://github.com/choderalab/pymbar/pull/354
    • Even more coverage! by @Lnaden in https://github.com/choderalab/pymbar/pull/357
    • From print to logging by @jaimergp in https://github.com/choderalab/pymbar/pull/360
    • Add linting to CI by @jaimergp in https://github.com/choderalab/pymbar/pull/367
    • Apply black to the whole package by @jaimergp in https://github.com/choderalab/pymbar/pull/371
    • camelCase -> snake_case by @jaimergp in https://github.com/choderalab/pymbar/pull/372
    • Make Pylint less noisy by @Lnaden in https://github.com/choderalab/pymbar/pull/375
    • Modernize examples by @jaimergp in https://github.com/choderalab/pymbar/pull/374
    • Refactoring pmf code by @mrshirts in https://github.com/choderalab/pymbar/pull/385
    • Better dimension checking by @mrshirts in https://github.com/choderalab/pymbar/pull/386
    • Bin edges support by @mrshirts in https://github.com/choderalab/pymbar/pull/387
    • Apply Black to examples/ too by @jaimergp in https://github.com/choderalab/pymbar/pull/392
    • Updated heat capacity example by @mrshirts in https://github.com/choderalab/pymbar/pull/394
    • Replace "potential of mean force" with "free energy surface" by @mrshirts in https://github.com/choderalab/pymbar/pull/397
    • Update GHA to use Conda-Incubator by @Lnaden in https://github.com/choderalab/pymbar/pull/410
    • Bump conda-incubator in GHA to v2 by @Lnaden in https://github.com/choderalab/pymbar/pull/411
    • Clean out old Omnia references for Pymbar 4.0 branch by @Lnaden in https://github.com/choderalab/pymbar/pull/412
    • Modernize setup.py and versioning by @jaimergp in https://github.com/choderalab/pymbar/pull/413
    • Fix for expectations of very small numbers by @mrshirts in https://github.com/choderalab/pymbar/pull/441
    • Noticed one bug in setlogzero commit by @mrshirts in https://github.com/choderalab/pymbar/pull/443
    • Syncing Pymbar4 with master by @mrshirts in https://github.com/choderalab/pymbar/pull/444
    • Getting CI working on the current default branch by @mikemhenry in https://github.com/choderalab/pymbar/pull/449
    • Pymbar 4.0 adaptive logic by @mrshirts in https://github.com/choderalab/pymbar/pull/446
    • Pymbar4 add adaptivity by @mrshirts in https://github.com/choderalab/pymbar/pull/453
    • Convert JAX JIT to Decorators by @Lnaden in https://github.com/choderalab/pymbar/pull/451
    • Align namespaces to work if JAX is not installed by @Lnaden in https://github.com/choderalab/pymbar/pull/454
    • Pymbar4 bootstrapping by @mrshirts in https://github.com/choderalab/pymbar/pull/448
    • Remove old_mbar.py by @mrshirts in https://github.com/choderalab/pymbar/pull/457
    • Pymbar4 with jax (real try now) by @mrshirts in https://github.com/choderalab/pymbar/pull/447
    • Pymbar 4.0 by @mrshirts in https://github.com/choderalab/pymbar/pull/458
    • [WIP] Pymbar4 documentation by @mrshirts in https://github.com/choderalab/pymbar/pull/455
    • remove special character for now. by @mrshirts in https://github.com/choderalab/pymbar/pull/460
    • switch to napoleon for better output formatting. by @mrshirts in https://github.com/choderalab/pymbar/pull/461
    • More working on doc appearance. by @mrshirts in https://github.com/choderalab/pymbar/pull/462

    Full Changelog: https://github.com/choderalab/pymbar/compare/3.0.7...4.0.0

    Source code(tar.gz)
    Source code(zip)
  • 3.0.7(May 13, 2022)

    What's Changed

    • Fix #427 : Add BAR compute overlap method by @jchodera in https://github.com/choderalab/pymbar/pull/430
    • Add warning about unstable API by @mikemhenry in https://github.com/choderalab/pymbar/pull/432

    Full Changelog: https://github.com/choderalab/pymbar/compare/3.0.6...3.0.7

    Source code(tar.gz)
    Source code(zip)
  • 3.0.6(Jan 24, 2022)

    What's Changed

    • Fixes sanity check for empty bins in computePMF by @tuckerburgin in https://github.com/choderalab/pymbar/pull/324
    • Change anaconda channel from omnia to conda-forge by @chrisjonesBSU in https://github.com/choderalab/pymbar/pull/404
    • Update README installation instructions from -c omnia to -c conda-forge. by @bdice in https://github.com/choderalab/pymbar/pull/418
    • Forward maximum_iterations from MBAR constructor by @maxentile in https://github.com/choderalab/pymbar/pull/425
    • Removed travis CI config file by @mikemhenry in https://github.com/choderalab/pymbar/pull/426

    New Contributors

    • @tuckerburgin made their first contribution in https://github.com/choderalab/pymbar/pull/324
    • @chrisjonesBSU made their first contribution in https://github.com/choderalab/pymbar/pull/404
    • @bdice made their first contribution in https://github.com/choderalab/pymbar/pull/418
    • @maxentile made their first contribution in https://github.com/choderalab/pymbar/pull/425
    • @mikemhenry made their first contribution in https://github.com/choderalab/pymbar/pull/426

    Full Changelog: https://github.com/choderalab/pymbar/compare/3.0.5...3.0.6

    Source code(tar.gz)
    Source code(zip)
  • 3.0.5(Dec 2, 2019)

    In adding support for python 3.8 and scipy 1.0, pymbar 3.0.4 accidentally changed the API for key components to a new experimental API in which dict objects were returned for convenience.

    This release restores the previous API behavior in pymbar 3.0.0-3.0.3, but allows the new API to be accessed via the optional keyword argument return_dict=True (via PR https://github.com/choderalab/pymbar/pull/319). Without this keyword, the old API is used.

    We will consider making the dict API the default in pymbar 4, but we will plan to add warnings of the API change well in advance of this change.

    Apologies to all our users who were affected by this issue!

    Source code(tar.gz)
    Source code(zip)
  • 3.0.4(Nov 14, 2019)

  • 3.0.3(Sep 6, 2017)

    This release fixes a subtle but important issue caused by missing file when PyPi Tarball was compiled from Python 3, but then downloaded in Python 2

    Because this changes the setup.py file, this formal release was cut.

    Source code(tar.gz)
    Source code(zip)
  • 3.0.1.beta0(Mar 3, 2017)

  • 3.0.0.beta2(Jun 16, 2015)

  • 3.0.0.beta1(Jun 10, 2015)

  • v2.1.0-beta(Jun 10, 2014)

    A number of minor improvements (including some API changes) have been made in this version:

    • Docstrings now conform to the NumPy/SciPy convention
    • Documentation has been cleaned up
    • Installation of prerequisites has been automated
    • Pyflakes was used to remove unused dependencies
    • Tests have been improved and automated using nose
    • Automated integration testing implemented with travis-ci
    • License has been changed to LGPL
    • Import and init styles have been made more consistent
    • Source code now more generally follows pep8
    • Test systems have been refactored
    Source code(tar.gz)
    Source code(zip)
Owner
Chodera lab // Memorial Sloan Kettering Cancer Center
Chodera lab // Memorial Sloan Kettering Cancer Center
A forwarding MPI implementation that can use any other MPI implementation via an MPI ABI

MPItrampoline MPI wrapper library: MPI trampoline library: MPI integration tests: MPI is the de-facto standard for inter-node communication on HPC sys

Erik Schnetter 31 Dec 22, 2022
ALBERT-pytorch-implementation - ALBERT pytorch implementation

ALBERT-pytorch-implementation developing... 모델의 개념이해를 돕기 위한 구현물로 현재 변수명을 상세히 적었고

BG Kim 3 Oct 6, 2022
A fast python implementation of Ray Tracing in One Weekend using python and Taichi

ray-tracing-one-weekend-taichi A fast python implementation of Ray Tracing in One Weekend using python and Taichi. Taichi is a simple "Domain specific

null 157 Dec 26, 2022
Experimental Python implementation of OpenVINO Inference Engine (very slow, limited functionality). All codes are written in Python. Easy to read and modify.

PyOpenVINO - An Experimental Python Implementation of OpenVINO Inference Engine (minimum-set) Description The PyOpenVINO is a spin-off product from my

Yasunori Shimura 7 Oct 31, 2022
Python implementation of cover trees, near-drop-in replacement for scipy.spatial.kdtree

This is a Python implementation of cover trees, a data structure for finding nearest neighbors in a general metric space (e.g., a 3D box with periodic

Patrick Varilly 28 Nov 25, 2022
A fast Evolution Strategy implementation in Python

Evostra: Evolution Strategy for Python Evolution Strategy (ES) is an optimization technique based on ideas of adaptation and evolution. You can learn

Mika 251 Dec 8, 2022
🌳 A Python-inspired implementation of the Optimum-Path Forest classifier.

OPFython: A Python-Inspired Optimum-Path Forest Classifier Welcome to OPFython. Note that this implementation relies purely on the standard LibOPF. Th

Gustavo Rosa 30 Jan 4, 2023
Python implementation of Wu et al (2018)'s registration fusion

reg-fusion Projection of a central sulcus probability map using the RF-ANTs approach (right hemisphere shown). This is a Python implementation of Wu e

Dan Gale 26 Nov 12, 2021
A Python implementation of global optimization with gaussian processes.

Bayesian Optimization Pure Python implementation of bayesian global optimization with gaussian processes. PyPI (pip): $ pip install bayesian-optimizat

fernando 6.5k Jan 2, 2023
Implementation of Kalman Filter in Python

Kalman Filter in Python This is a basic example of how Kalman filter works in Python. I do plan on refactoring and expanding this repo in the future.

Enoch Kan 35 Sep 11, 2022
Python Implementation of the CoronaWarnApp (CWA) Event Registration

Python implementation of the Corona-Warn-App (CWA) Event Registration This is an implementation of the Protocol used to generate event and location QR

MaZderMind 17 Oct 5, 2022
Python and C++ implementation of "MarkerPose: Robust real-time planar target tracking for accurate stereo pose estimation". Accepted at LXCV @ CVPR 2021.

MarkerPose: Robust real-time planar target tracking for accurate stereo pose estimation This is a PyTorch and LibTorch implementation of MarkerPose: a

Jhacson Meza 47 Nov 18, 2022
Tensorflow python implementation of "Learning High Fidelity Depths of Dressed Humans by Watching Social Media Dance Videos"

Learning High Fidelity Depths of Dressed Humans by Watching Social Media Dance Videos This repository is the official tensorflow python implementation

Yasamin Jafarian 287 Jan 6, 2023
Python Implementation of Chess Playing AI with variable difficulty

Chess AI with variable difficulty level implemented using the MiniMax AB-Pruning Algorithm

Ali Imran 7 Feb 20, 2022
A python implementation of Deep-Image-Analogy based on pytorch.

Deep-Image-Analogy This project is a python implementation of Deep Image Analogy.https://arxiv.org/abs/1705.01088. Some results Requirements python 3

Peng Lu 171 Dec 14, 2022
A Python implementation of the Locality Preserving Matching (LPM) method for pruning outliers in image matching.

LPM_Python A Python implementation of the Locality Preserving Matching (LPM) method for pruning outliers in image matching. The code is established ac

AoxiangFan 11 Nov 7, 2022
Python implementation of a live deep learning based age/gender/expression recognizer

TUT live age estimator Python implementation of a live deep learning based age/gender/smile/celebrity twin recognizer. All components use convolutiona

Heikki Huttunen 80 Nov 21, 2022
A python implementation of Physics-informed Spline Learning for nonlinear dynamics discovery

PiSL A python implementation of Physics-informed Spline Learning for nonlinear dynamics discovery. Sun, F., Liu, Y. and Sun, H., 2021. Physics-informe

Fangzheng (Andy) Sun 8 Jul 13, 2022