MedianEstimatorTrainerSQRT Class Reference

Inheritance diagram for MedianEstimatorTrainerSQRT:

Public Member Functions
	__init__ (self)
	create_result_dataframe (self)
	fit_result_parameters (self)
	train (self, data)
	plot_fit_result (self, data)
	plot_grouped_result (self, data)
	create_dedx_bins (self, data)
	create_p_bins (self, data)
	use_only_the_highest_values (self, data, number_of_values=None)
	create_fit_data (self, dedx_bin)
	fit_p_to_dedx_bin (self, dedx_bin)
	test (self, data)

Public Attributes
	train_function = train_function
	this class's training function
	result_function = result_function
	cached copy of the result function
dict	result_parameters_for_each_dedx_bin = {}
	cached copy of the dictionary of fitting parameters for each dE/dx bin
	use_sigma_for_result_fitting = use_sigma_for_result_fitting
	cached copy of the flag to add mean+/-sigma values to the output Dataframe
	dedx_estimator_parameters
	cached copies of the fit parameters and estimator function
	dedx_estimator_function = None
	by default, the dE/dx-particle-identification trainer has not run yet
str	dedx_column = "dedx"
	the default data column is 'dedx'

Static Public Attributes
int	number_of_bins_in_dedx = 20
	number of dE/dx bins
int	number_of_bins_in_p = 29
	number of track-momentum bins
int	number_of_head_values_used_to_fit = 20
	number of head values in fit

Detailed Description

Train a neural network for dE/dx-based particle identification using only the median values

Definition at line 354 of file train.py.

Constructor & Destructor Documentation

__init__()

__init__

(

self

)

Constructor

Definition at line 357 of file train.py.

    def __init__(self):
        """Constructor"""
        FittedGroupedDEDXEstimatorTrainer.__init__(self, fit_functions.inverse_sqrt, use_sigma_for_result_fitting=True)
 
        def train_function(fit_data):
            """Train on the curated-data median values whose truth value is known"""
            weighted_p_values = fit_data.apply(lambda data: [data.p_bin_centers] * int(data.number_of_p_values), axis=1).sum()
            median_value = np.median(weighted_p_values)
            iqr = np.percentile(weighted_p_values, 75) - np.percentile(weighted_p_values, 50)
 
            return [iqr, [None, median_value, None]]
 
        ## this class's training function
        self.train_function = train_function
 
 

Member Function Documentation

create_dedx_bins()

create_dedx_bins ( self, data )

inherited

Construct the dE/dx bins and then populate them with the data

Definition at line 52 of file train.py.

    def create_dedx_bins(self, data):
        """Construct the dE/dx bins and then populate them with the data"""
        dedx_bins = np.linspace(
            data[
                self.dedx_column].min(), data[
                self.dedx_column].max(), GroupedDEDXEstimationTrainer.number_of_bins_in_dedx)
        dedx_cuts = pd.cut(data[self.dedx_column], dedx_bins)
        return data.groupby(dedx_cuts), dedx_bins
 

create_fit_data()

create_fit_data ( self, dedx_bin )

inherited

Fit track-momentum values

Definition at line 74 of file train.py.

    def create_fit_data(self, dedx_bin):
        """Fit track-momentum values"""
        p_binned_data, p_bins = self.create_p_bins(dedx_bin)
 
        number_of_p_values = pd.Series(p_binned_data.count().p.values, name="number_of_p_values")
        p_bin_centers = pd.Series(0.5 * (p_bins[:-1] + p_bins[1:]), name="p_bin_centers")
 
        all_fit_data = pd.DataFrame([number_of_p_values, p_bin_centers]).T
        fit_data = self.use_only_the_highest_values(all_fit_data, GroupedDEDXEstimationTrainer.number_of_head_values_used_to_fit)
 
        return fit_data
 

create_p_bins()

create_p_bins ( self, data )

inherited

Construct the momentum bins and then populate them with the data

Definition at line 61 of file train.py.

    def create_p_bins(self, data):
        """Construct the momentum bins and then populate them with the data"""
        p_bins = np.linspace(data.p.min(), data.p.max(), GroupedDEDXEstimationTrainer.number_of_bins_in_p)
        p_cuts = pd.cut(data.p, p_bins)
        return data.groupby(p_cuts), p_bins
 

create_result_dataframe()

create_result_dataframe ( self )

inherited

Fit for the mean dE/dx and standard deviation, return the fit Dataframe

Definition at line 107 of file train.py.

    def create_result_dataframe(self):
        """Fit for the mean dE/dx and standard deviation, return the fit Dataframe"""
        result_df = pd.DataFrame([{"dedx_bin_center": dedx_bin_center,
                                   "mu": fit_parameters[1][1],
                                   "sigma": fit_parameters[0]} for dedx_bin_center,
                                  fit_parameters in self.result_parameters_for_each_dedx_bin.items()
                                  if fit_parameters is not None])
 
        if len(result_df) == 0:
            raise ValueError("Could not find any fitted parameters!")
 
        if self.use_sigma_for_result_fitting:
            result_df["mu_plus_sigma"] = result_df.mu + result_df.sigma
            result_df["mu_minus_sigma"] = result_df.mu - result_df.sigma
 
        result_df.sort("dedx_bin_center", inplace=True)
 
        return result_df
 

fit_p_to_dedx_bin()

fit_p_to_dedx_bin ( self, dedx_bin )

inherited

Fit the track-momentum values in the selected dE/dx bin, then train on the fitted values

Definition at line 86 of file train.py.

    def fit_p_to_dedx_bin(self, dedx_bin):
        """Fit the track-momentum values in the selected dE/dx bin, then train on the fitted values"""
        fit_data = self.create_fit_data(dedx_bin)
        return self.train_function(fit_data)
 
 

fit_result_parameters()

fit_result_parameters ( self )

inherited

Define the parameters for the fit, assign initial guesses

Definition at line 126 of file train.py.

    def fit_result_parameters(self):
        """Define the parameters for the fit, assign initial guesses"""
        result_df = self.create_result_dataframe()
 
        p0 = (7e+08, -4e+04, 0.1, 0)
 
        if self.use_sigma_for_result_fitting:
            popt, pcov = curve_fit(self.result_function, result_df.dedx_bin_center, result_df.mu, p0=p0,
                                   sigma=result_df.sigma, absolute_sigma=True)
        else:
            popt, pcov = curve_fit(self.result_function, result_df.dedx_bin_center, result_df.mu, p0=p0)
 
        return popt, lambda dedx: self.result_function(dedx, *popt)
 

plot_fit_result()

plot_fit_result ( self, data )

inherited

Plot the fitted results

Definition at line 154 of file train.py.

    def plot_fit_result(self, data):
        """Plot the fitted results"""
        plot_dedx_data = np.linspace(data[self.dedx_column].min(), data[self.dedx_column].max(), 100)
        result_df = self.create_result_dataframe()
 
        plt.plot(plot_dedx_data, self.dedx_estimator_function(plot_dedx_data), color="black", label="Fitted estimator")
        if self.use_sigma_for_result_fitting:
            # color = "black"
            plt.errorbar(result_df.dedx_bin_center, result_df.mu, marker="o", ls="", label="Data Points", yerr=result_df.sigma)
 
        plt.ylim(0, 0.14)
        plt.xlabel("dEdX in ADC count/cm")
        plt.ylabel("p in GeV/c")
        plt.legend(frameon=True)
 

plot_grouped_result()

plot_grouped_result ( self, data )

inherited

Plot the fitted grouped results

Reimplemented in FunctionFittedGroupedDEDXEstimatorTrainer.

Definition at line 169 of file train.py.

    def plot_grouped_result(self, data):
        """Plot the fitted grouped results"""
        dedx_binned_data, dedx_bins = self.create_dedx_bins(data)
 
        # List to prevent bug in pd.DataFrame.apply
        already_plotted_list = []
 
        def plot_fitted_results(dedx_bin):
            dedx_bin_center = dedx_bin.mean().values[0]
 
            if dedx_bin_center not in already_plotted_list:
                already_plotted_list.append(dedx_bin_center)
 
                fit_data = self.create_fit_data(dedx_bin)
                plt.plot(fit_data.p_bin_centers, fit_data.number_of_p_values, ls="", marker=".", color="black")
 
            return True
 
        plt.xlabel("p in GeV/c")
        plt.ylabel("Entries")
 
        dedx_binned_data.apply(plot_fitted_results)
 
 

test()

test ( self, data )

inherited

Get the trained neural-network output value for test data

Reimplemented in MVADEDXEstimationTrainer.

Definition at line 34 of file train.py.

    def test(self, data):
        """Get the trained neural-network output value for test data"""
        if self.dedx_estimator_function is None:
            raise ValueError("Train the estimator first!")
 
        return self.dedx_estimator_function(data[self.dedx_column])
 
 

train()

train ( self, data )

inherited

Train the neural network using curated data

Reimplemented from DEDXEstimationTrainer.

Definition at line 140 of file train.py.

    def train(self, data):
        """Train the neural network using curated data"""
        dedx_binned_data, dedx_bins = self.create_dedx_bins(data)
 
        def fit_and_save_results(dedx_bin):
            fit_result = self.fit_p_to_dedx_bin(dedx_bin)
            return {dedx_bin.mean()[self.dedx_column]: fit_result}
 
        for result in dedx_binned_data.apply(fit_and_save_results):
            self.result_parameters_for_each_dedx_bin.update(result)
 
        
        self.dedx_estimator_parameters, self.dedx_estimator_function = self.fit_result_parameters()
 

use_only_the_highest_values()

use_only_the_highest_values ( self, data, number_of_values = None )

inherited

Sort the data then select only the highest N values

Definition at line 67 of file train.py.

    def use_only_the_highest_values(self, data, number_of_values=None):
        """Sort the data then select only the highest N values"""
        if number_of_values is None:
            return data
        else:
            return data.sort("number_of_p_values", ascending=False).head(number_of_values).sort()
 

Member Data Documentation

dedx_column

str dedx_column = "dedx"

inherited

the default data column is 'dedx'

Definition at line 27 of file train.py.

dedx_estimator_function

dedx_estimator_function = None

inherited

by default, the dE/dx-particle-identification trainer has not run yet

Definition at line 25 of file train.py.

dedx_estimator_parameters

dedx_estimator_parameters

inherited

cached copies of the fit parameters and estimator function

Definition at line 152 of file train.py.

number_of_bins_in_dedx

int number_of_bins_in_dedx = 20

staticinherited

number of dE/dx bins

Definition at line 46 of file train.py.

number_of_bins_in_p

int number_of_bins_in_p = 29

staticinherited

number of track-momentum bins

Definition at line 48 of file train.py.

number_of_head_values_used_to_fit

int number_of_head_values_used_to_fit = 20

staticinherited

number of head values in fit

Definition at line 50 of file train.py.

result_function

result_function = result_function

inherited

cached copy of the result function

Definition at line 99 of file train.py.

result_parameters_for_each_dedx_bin

dict result_parameters_for_each_dedx_bin = {}

inherited

cached copy of the dictionary of fitting parameters for each dE/dx bin

Definition at line 101 of file train.py.

train_function

train_function = train_function

this class's training function

Definition at line 370 of file train.py.

use_sigma_for_result_fitting

use_sigma_for_result_fitting = use_sigma_for_result_fitting

inherited

cached copy of the flag to add mean+/-sigma values to the output Dataframe

Definition at line 103 of file train.py.

---

The documentation for this class was generated from the following file:

• tracking/studies/low_momentum_vxd_estimation/train.py