CaloClusterMLCalib Namespace Reference

Typedefs
using	TransformFunc = std::function<float(float, const std::vector<float> &)>

Functions
float	standard (float x, const std::vector< float > &params)
float	log (float x, const std::vector< float > &)
float	logTen (float x, const std::vector< float > &)
float	logStandard (float x, const std::vector< float > &params)
float	logTenStandard (float x, const std::vector< float > &params)
float	maxAbsolute (float x, const std::vector< float > &params)
float	minMax (float x, const std::vector< float > &params)
float	log_sum_exp (const std::vector< float > &vec)
float	log_likelihood (float x, const std::vector< float > &mus, const std::vector< float > &log_sigma2s, const std::vector< float > &alphas)
float	modes (const std::vector< float > &mus, const std::vector< float > &log_sigma2s, const std::vector< float > &alphas)
float	sigma_stoch (const std::vector< float > &mus, const std::vector< float > &log_sigma2s, const std::vector< float > &alphas)

Variables
const std::map< std::string, TransformFunc >	TRANSFORMATIONS
constexpr float	epsilon = 1e-9

Typedef Documentation

TransformFunc

using CaloClusterMLCalib::TransformFunc = std::function<float(float, const std::vector<float> &)>

Definition at line 79 of file CaloClusterMLCalibFeatureTransform.h.

Function Documentation

log()

float CaloClusterMLCalib::log	(	float	x,
		const std::vector< float > &	)

Definition at line 27 of file CaloClusterMLCalibFeatureTransform.h.

    {
        if (x <= 0)
            return -INFINITY; // mimic numpy's log(0) behavior
        return std::log(x);
    }

log_likelihood()

float CaloClusterMLCalib::log_likelihood	(	float	x,
		const std::vector< float > &	mus,
		const std::vector< float > &	log_sigma2s,
		const std::vector< float > &	alphas )

Definition at line 34 of file CaloClusterMLGaussianMixture.h.

    {
        // Ensure vectors have the correct size
        assert(mus.size() == 3 && log_sigma2s.size() == 3 && alphas.size() == 3);
 
        std::vector<float> log_likelihood_components(3);
 
        for (int i = 0; i < 3; ++i)
        {
            // Calculate one-dimensional negative log-Gaussian
            float neg_log_gauss = std::pow(mus[i] - x, 2.0) / (2.0 * std::exp(log_sigma2s[i])) + 0.5 * log_sigma2s[i];
            neg_log_gauss += 0.5 * std::log(2.0 * M_PI); // M_PI is a common constant for pi
 
            // log_prob_components = -neg_log_gauss_i + log(alpha_i)
            log_likelihood_components[i] = -neg_log_gauss + std::log(alphas[i] + epsilon); // Added epsilon to avoid FPE DIVBYZERO warning
        }
 
        // log_prob = log(sum_i exp(log_prob_components_i))
        return log_sum_exp(log_likelihood_components);
    }

log_sum_exp()

float CaloClusterMLCalib::log_sum_exp

(

const std::vector< float > &

vec

)

Definition at line 19 of file CaloClusterMLGaussianMixture.h.

    {
        if (vec.empty())
        {
            return -std::numeric_limits<float>::infinity();
        }
        float max_val = *std::max_element(vec.begin(), vec.end());
        float sum = 0.0;
        for (float val : vec)
        {
            sum += std::exp(val - max_val);
        }
        return max_val + std::log(sum);
    }

logStandard()

float CaloClusterMLCalib::logStandard	(	float	x,
		const std::vector< float > &	params )

Definition at line 41 of file CaloClusterMLCalibFeatureTransform.h.

    {
        if (params.size() != 2)
            throw std::invalid_argument("LogStandard expects 2 parameters [mean, std_dev]");
        float log_x = log(x, {});
        return standard(log_x, params);
    }

logTen()

float CaloClusterMLCalib::logTen	(	float	x,
		const std::vector< float > &	)

Definition at line 34 of file CaloClusterMLCalibFeatureTransform.h.

    {
        if (x <= 0)
            return -INFINITY;
        return std::log10(x);
    }

logTenStandard()

float CaloClusterMLCalib::logTenStandard	(	float	x,
		const std::vector< float > &	params )

Definition at line 49 of file CaloClusterMLCalibFeatureTransform.h.

    {
        if (params.size() != 4)
            throw std::invalid_argument("LogTenStandard expects 4 parameters [xmin, epsilon, mean, std_dev]");
        float xmin = params[0], epsilon = params[1], mean = params[2], std_dev = params[3];
        float x_shifted = x - xmin + epsilon;
        float log_x = logTen(x_shifted, {});
        return standard(log_x, {mean, std_dev});
    }

maxAbsolute()

float CaloClusterMLCalib::maxAbsolute	(	float	x,
		const std::vector< float > &	params )

Definition at line 59 of file CaloClusterMLCalibFeatureTransform.h.

    {
        if (params.size() != 1)
            throw std::invalid_argument("MaxAbsolute expects 1 parameter [max_value]");
        float max_val = params[0];
        if (max_val == 0)
            return x;
        return x / std::abs(max_val);
    }

minMax()

float CaloClusterMLCalib::minMax	(	float	x,
		const std::vector< float > &	params )

Definition at line 69 of file CaloClusterMLCalibFeatureTransform.h.

    {
        if (params.size() != 2)
            throw std::invalid_argument("MinMaxNorm expects 2 parameters [min_val, max_val]");
        float min_val = params[0], max_val = params[1];
        if (min_val == max_val)
            return 0.0; // Avoid division by zero
        return (x - min_val) / (max_val - min_val);
    }

modes()

float CaloClusterMLCalib::modes	(	const std::vector< float > &	mus,
		const std::vector< float > &	log_sigma2s,
		const std::vector< float > &	alphas )

Definition at line 55 of file CaloClusterMLGaussianMixture.h.

    {
        // Select range to check for maxima
        float x_min = 0.9 * (*std::min_element(mus.begin(), mus.end()));
        float x_max = 1.1 * (*std::max_element(mus.begin(), mus.end()));
 
        // Create array of ranges to check for maxima
        const int num_points = 1000;
        std::vector<float> x_test(num_points);
        float step = (x_max - x_min) / (num_points - 1);
        for (int i = 0; i < num_points; ++i)
        {
            x_test[i] = x_min + i * step;
        }
 
        float max_log_likelihood = -std::numeric_limits<float>::infinity();
        float mode = x_test[0]; // Initialize to first test point instead of 0
 
        // Find the x-point with the largest likelihood value
        for (float x : x_test)
        {
            float ll = log_likelihood(x, mus, log_sigma2s, alphas);
            if (ll > max_log_likelihood)
            {
                max_log_likelihood = ll;
                mode = x;
            }
        }
 
        return mode;
    }

sigma_stoch()

float CaloClusterMLCalib::sigma_stoch	(	const std::vector< float > &	mus,
		const std::vector< float > &	log_sigma2s,
		const std::vector< float > &	alphas )

Definition at line 87 of file CaloClusterMLGaussianMixture.h.

    {
        float sigma_stoch2 = 0.0;
        float sum_alphas_mus = 0.0;
 
        // This loop combines the first three lines of the Python function.
        for (size_t i = 0; i < mus.size(); ++i)
        {
            // Corresponds to: np.sum(alphas * sigma2s, axis=-1)
            sigma_stoch2 += alphas[i] * std::exp(log_sigma2s[i]);
            // Corresponds to: np.sum(alphas * np.power(mus, 2), axis=-1)
            sigma_stoch2 += alphas[i] * std::pow(mus[i], 2);
            // Accumulates sum for the final term: np.sum(alphas * mus, axis=-1)
            sum_alphas_mus += alphas[i] * mus[i];
        }
 
        // Corresponds to: sigma_stoch2 -= np.power(np.sum(alphas * mus, axis=-1), 2)
        sigma_stoch2 -= std::pow(sum_alphas_mus, 2);
 
        // Corresponds to: return np.sqrt(sigma_stoch2)
        return std::sqrt(sigma_stoch2);
    }

standard()

float CaloClusterMLCalib::standard	(	float	x,
		const std::vector< float > &	params )

Definition at line 17 of file CaloClusterMLCalibFeatureTransform.h.

    {
        if (params.size() != 2)
            throw std::invalid_argument("Standard expects 2 parameters [mean, std_dev]");
        float mean = params[0], std_dev = params[1];
        if (std_dev == 0)
            return x - mean;
        return (x - mean) / std_dev;
    }

Variable Documentation

epsilon

float CaloClusterMLCalib::epsilon = 1e-9

constexpr

Definition at line 16 of file CaloClusterMLGaussianMixture.h.

TRANSFORMATIONS

const std::map<std::string, TransformFunc> CaloClusterMLCalib::TRANSFORMATIONS

Initial value:

= {
        {"Standard", standard},
        {"Log", log},
        {"LogTen", logTen},
        {"LogStandard", logStandard},
        {"LogTenStandard", logTenStandard},
        {"MaxAbsolute", maxAbsolute},
        {"MinMaxNorm", minMax}}

Definition at line 81 of file CaloClusterMLCalibFeatureTransform.h.

                                                             {
        {"Standard", standard},
        {"Log", log},
        {"LogTen", logTen},
        {"LogStandard", logStandard},
        {"LogTenStandard", logTenStandard},
        {"MaxAbsolute", maxAbsolute},
        {"MinMaxNorm", minMax}};