plotResults Namespace Reference

Classes
class	Analysis

Functions
def	plotEffectiveSampleSize (ess)
def	plotPosteriorWeights (names, weight, params, bestId)
def	plotObservables (smcTest, obsNames)
def	plotCorrelations (smcTest, paramNames, obsNames)
def	plotParametersAndObservables (analysis, material)
def	plot_ellipses (ax, weights, means, covars)

Variables
dictionary	params

Function Documentation

plot_ellipses()

def plotResults.plot_ellipses	(		ax,
			weights,
			means,
			covars
	)

def plot_ellipses(ax, weights, means, covars):
    for n in range(means.shape[0]):
        eig_vals, eig_vecs = np.linalg.eigh(covars[n])
        unit_eig_vec = eig_vecs[0] / np.linalg.norm(eig_vecs[0])
        angle = np.arctan2(unit_eig_vec[1], unit_eig_vec[0])
        # Ellipse needs degrees
        angle = 180 * angle / np.pi
        # eigenvector normalization
        eig_vals = 2 * np.sqrt(2) * np.sqrt(eig_vals)
        ell = matplotlib.patches.Ellipse(
            means[n], eig_vals[0], eig_vals[1], 180 + angle, edgecolor="black"
        )
        ell.set_clip_box(ax.bbox)
        ell.set_alpha(weights[n])
        ell.set_facecolor("#56B4E9")
        ax.add_artist(ell)

plotCorrelations()

def plotResults.plotCorrelations	(		smcTest,
			paramNames,
			obsNames
	)

def plotCorrelations(smcTest, paramNames, obsNames):
    # the observables (response) obtained from dpm simulations
    dpmData = smcTest.DPMData[-1]
    # the observables (response) obtained from experiments
    obsData = smcTest.obsData[-1]
    # is the optimal calibration parameters found by smc
    bestId = smcTest.ips.T[0]
    # the calibration parameters set in dpm simulations
    smcSamples = smcTest.smcSamples[-1]
    ny = len(dpmData[0])
    nx = len(smcSamples[0])
    plt.figure('Correlations', figsize=(3 * nx, 3 * ny))
    # for each value
    for i in range(ny):
        for j in range(nx):
            y = dpmData[:, i]
            x = smcSamples[:, j]
            plt.subplot(ny, nx, i * nx + j + 1)
            plt.plot(x, y, 'o')
            plt.plot(bestId[i], obsData[i], 'r.')
            if i == ny - 1:
                plt.xlabel("$%s$" % paramNames[j])
            if j == 0:
                # plt.ylabel("obs%d" % i)
                plt.ylabel(obsNames[i])
                if i==0:
                    plt.legend(['sim', 'fit'])
    plt.tight_layout()
    plt.show(block=False)
 

plotEffectiveSampleSize()

def plotResults.plotEffectiveSampleSize

(

ess

)

def plotEffectiveSampleSize(ess):
    # print 'Effective sample size: %f' % ess[-1]
    # plot time evolution of effective sample size
    plt.figure()
    plt.plot(ess)
    plt.xlabel('data')
    plt.ylabel('Effective sample size')
    plt.show(block=False)
    return plt
 
 

plotObservables()

def plotResults.plotObservables	(		smcTest,
			obsNames
	)

def plotObservables(smcTest, obsNames):
    # get last iteration
    dpmData = smcTest.DPMData[-1]
    obsData = smcTest.obsData[-1]
    ny = round(len(obsData))
    nx = 1
    # ny = round(np.sqrt(len(obsData)))
    # nx = round(len(obsData)/ny+0.4999)
    plt.figure('Observables exp. vs sim.', figsize=(3 * nx, 2.8 * ny))
    # for each value
    for i in range(len(obsData)):
        val = dpmData[:, i]
        plt.subplot(ny, nx, i + 1)
        plt.plot(val, 'o')
        plt.plot(plt.xlim(), obsData[[i, i]], 'r')
        plt.ylabel(obsNames[i])
    plt.legend(['sim', 'exp'])
    plt.tight_layout()
    plt.show(block=False)
 
 

References Eigen::bfloat16_impl.round().

plotParametersAndObservables()

def plotResults.plotParametersAndObservables	(		analysis,
			material
	)

def plotParametersAndObservables(analysis, material):
    # number of iterations
    nIter = len(analysis)
    # number of observables (number of plots in y)
    nObs = len(analysis[0].obsNames)
    # number of parameters (number of plots in x)
    nPar = len(analysis[0].paramNames)
    # the observables (response) obtained from experiments
    obsData = analysis[0].smcTest.obsData[-1]
    # start plot
    fig = plt.figure('Correlations', figsize=(3 * nPar, min(3 * nObs, 14)))
    axs = fig.subplots(nObs, nPar)
    for iter in range(nIter):
        # the calibration parameters set in dpm simulations
        numPar = analysis[iter].smcTest.smcSamples[-1]
        # the observables (response) obtained from dpm simulations
        numObs = analysis[iter].smcTest.DPMData[-1]
        for par in range(nPar):
            for obs in range(nObs):
                if nObs==1 and nPar==1:
                    ax = axs
                else:
                    ax = axs[obs,par];
                ax.plot(numPar[:, par], numObs[:, obs], 'o',label=str(iter))
                # if plt.ylim()[0]<0:
                #     ax.set_ylim(0,max(ax.get_ylim()))
                if iter==nIter-1:
                    ax.plot(ax.get_xlim(), obsData[[obs, obs]], 'r',label='exp')
                    ax.set_ylim(0, 2*obsData[[obs]])
                    if obs==nObs-1:
                        ax.set_xlabel(analysis[0].paramNames[par])
                    if par==0:
                        ax.set_ylabel(analysis[0].obsNames[obs])
                        if obs==0:
                            ax.legend()
    #bestId = analysis[iter].bestId
    #ax.plot(numPar[bestId, par], numObs[bestId, obs], 'x',label=str(iter))
    plt.tight_layout()
    plt.show(block=False)
    plt.savefig('%s.png' % material, dpi=200)
    # # number of parameters
    # nPar = len(smcSamples[0])
    # # the observables (response) obtained from dpm simulations
    # dpmData = analysis[0].smcTest.DPMData[-1]
    # # the observables (response) obtained from experiments
    # obsData = smcTest.obsData[-1]
    # # is the optimal calibration parameters found by smc
    # bestId = smcTest.ips.T[0]
    # # the calibration parameters set in dpm simulations
    # smcSamples = smcTest.smcSamples[-1]
    # ny = len(dpmData[0])
    # nx = len(smcSamples[0])
    # plt.figure('Correlations', figsize=(3 * nx, 3 * ny))
    # # for each value
    # for i in range(ny):
    #     for j in range(nx):
    #         y = dpmData[:, i]
    #         x = smcSamples[:, j]
    #         plt.subplot(ny, nx, i * nx + j + 1)
    #         plt.plot(x, y, 'o')
    #         plt.plot(bestId[i], obsData[i], 'r.')
    #         if i == ny - 1:
    #             plt.xlabel("$%s$" % paramNames[j])
    #         if j == 0:
    #             # plt.ylabel("obs%d" % i)
    #             plt.ylabel(obsNames[i])
    #             if i==0:
    #                 plt.legend(['sim', 'fit'])
    # plt.tight_layout()
    # plt.show()
 

References min, and compute_granudrum_aor.str.

plotPosteriorWeights()

def plotResults.plotPosteriorWeights	(		names,
			weight,
			params,
			bestId
	)

def plotPosteriorWeights(names, weight, params, bestId):
    # plot posterior weights
    plt.figure('Posterior weights (likelihoods)', figsize=(3 * len(names), 3))
    for i, name in enumerate(names):
        plt.subplot(1, len(names), i + 1)
        plt.plot(params[:, i], weight[:], 'o')
        plt.xlabel(r'$' + name + '$')
        plt.plot(bestId[[i, i]], plt.ylim(), 'r')
        if i == 0:
            # plt.ylabel('weights')
            plt.legend(['weight', 'optimum'])
        plt.grid(True)
        index_max = np.argmax(weight)
        value_max = params[index_max, i]
    plt.tight_layout()
    plt.show(block=False)
 
 

Variable Documentation

params

dictionary plotResults.params

Initial value:

=  {'lines.linewidth': 1, 'backend': 'ps', 'axes.labelsize': 12, 'font.size': 12, 'legend.fontsize': 9,
          'xtick.labelsize': 9, 'ytick.labelsize': 9, 'text.usetex': False, 'font.family': 'serif',
          'legend.edgecolor': 'k', 'legend.fancybox': False}