#include <LArSupportVectorMachine.h>

Inheritance diagram for lar_content::SupportVectorMachine:

Classes
class	FeatureInfo
	FeatureInfo class. More...

class	SupportVectorInfo
	SupportVectorInfo class. More...

Public Types
enum	KernelType { USER_DEFINED = 0, LINEAR = 1, QUADRATIC = 2, CUBIC = 3, GAUSSIAN_RBF = 4 }
	KernelType enum. More...

typedef std::function< double(const LArMvaHelper::MvaFeatureVector &, const LArMvaHelper::MvaFeatureVector &, const double)>	KernelFunction

Public Member Functions
	SupportVectorMachine ()
	Default constructor. More...

pandora::StatusCode	Initialize (const std::string &parameterLocation, const std::string &svmName)
	Initialize the svm using a serialized model. More...

bool	Classify (const LArMvaHelper::MvaFeatureVector &features) const
	Make a classification for a set of input features, based on the trained model. More...

double	CalculateClassificationScore (const LArMvaHelper::MvaFeatureVector &features) const
	Calculate the classification score for a set of input features, based on the trained model. More...

double	CalculateProbability (const LArMvaHelper::MvaFeatureVector &features) const
	Calculate the classification probability for a set of input features, based on the trained model. More...

bool	IsInitialized () const
	Query whether this svm is initialized. More...

unsigned int	GetNFeatures () const
	Get the number of features. More...

void	SetKernelFunction (KernelFunction kernelFunction)
	Set the kernel function to use. More...

Public Member Functions inherited from lar_content::MvaInterface
virtual	~MvaInterface ()=default
	Destructor. More...

Private Types
typedef std::vector< SupportVectorInfo >	SVInfoList

typedef std::vector< FeatureInfo >	FeatureInfoVector

typedef std::map< KernelType, KernelFunction >	KernelMap

Private Member Functions
void	ReadXmlFile (const std::string &svmFileName, const std::string &svmName)
	Read the svm parameters from an xml file. More...

pandora::StatusCode	ReadComponent (pandora::TiXmlElement *pCurrentXmlElement)
	Read the component at the current xml element. More...

pandora::StatusCode	ReadMachine (const pandora::TiXmlHandle &currentHandle)
	Read the machine component at the current xml handle. More...

pandora::StatusCode	ReadFeatures (const pandora::TiXmlHandle &currentHandle)
	Read the feature component at the current xml handle. More...

pandora::StatusCode	ReadSupportVector (const pandora::TiXmlHandle &currentHandle)
	Read the support vector component at the current xml handle. More...

double	CalculateClassificationScoreImpl (const LArMvaHelper::MvaFeatureVector &features) const
	Implementation method for calculating the classification score using the trained model. More...

Static Private Member Functions
static double	QuadraticKernel (const LArMvaHelper::MvaFeatureVector &supportVector, const LArMvaHelper::MvaFeatureVector &features, const double scaleFactor=1.)
	An inhomogeneous quadratic kernel. More...

static double	CubicKernel (const LArMvaHelper::MvaFeatureVector &supportVector, const LArMvaHelper::MvaFeatureVector &features, const double scaleFactor=1.)
	An inhomogeneous cubic kernel. More...

static double	LinearKernel (const LArMvaHelper::MvaFeatureVector &supportVector, const LArMvaHelper::MvaFeatureVector &features, const double scaleFactor=1.)
	A linear kernel. More...

static double	GaussianRbfKernel (const LArMvaHelper::MvaFeatureVector &supportVector, const LArMvaHelper::MvaFeatureVector &features, const double scaleFactor=1.)
	A gaussian RBF kernel. More...

Private Attributes
bool	m_isInitialized
	Whether this svm has been initialized. More...

bool	m_enableProbability
	Whether to enable probability calculations. More...

double	m_probAParameter
	The first-order score coefficient for mapping to a probability using the logistic function. More...

double	m_probBParameter
	The score offset parameter for mapping to a probability using the logistic function. More...

bool	m_standardizeFeatures
	Whether to standardize the features. More...

unsigned int	m_nFeatures
	The number of features. More...

double	m_bias
	The bias term. More...

double	m_scaleFactor
	The kernel scale factor. More...

SVInfoList	m_svInfoList
	The list of SupportVectorInfo objects. More...

FeatureInfoVector	m_featureInfoList
	The list of FeatureInfo objects. More...

KernelType	m_kernelType
	The kernel type. More...

KernelFunction	m_kernelFunction
	The kernel function. More...

KernelMap	m_kernelMap
	Map from the kernel types to the kernel functions. More...

Detailed Description

SupportVectorMachine class.

Definition at line 30 of file LArSupportVectorMachine.h.

Member Typedef Documentation

typedef std::vector<FeatureInfo> lar_content::SupportVectorMachine::FeatureInfoVector

private

Definition at line 162 of file LArSupportVectorMachine.h.

typedef std::function<double(const LArMvaHelper::MvaFeatureVector &, const LArMvaHelper::MvaFeatureVector &, const double)> lar_content::SupportVectorMachine::KernelFunction

Definition at line 33 of file LArSupportVectorMachine.h.

typedef std::map<KernelType, KernelFunction> lar_content::SupportVectorMachine::KernelMap

private

Definition at line 164 of file LArSupportVectorMachine.h.

typedef std::vector<SupportVectorInfo> lar_content::SupportVectorMachine::SVInfoList

private

Definition at line 161 of file LArSupportVectorMachine.h.

Member Enumeration Documentation

enum lar_content::SupportVectorMachine::KernelType

KernelType enum.

Enumerator
USER_DEFINED
LINEAR
QUADRATIC
CUBIC
GAUSSIAN_RBF

Definition at line 38 of file LArSupportVectorMachine.h.

     {
         USER_DEFINED = 0,
         LINEAR = 1,
         QUADRATIC = 2,
         CUBIC = 3,
         GAUSSIAN_RBF = 4
     };

Constructor & Destructor Documentation

lar_content::SupportVectorMachine::SupportVectorMachine ( )

Default constructor.

Definition at line 18 of file LArSupportVectorMachine.cc.

                                            :
     m_isInitialized(false),
     m_enableProbability(false),
     m_probAParameter(0.),
     m_probBParameter(0.),
     m_standardizeFeatures(true),
     m_nFeatures(0),
     m_bias(0.),
     m_scaleFactor(1.),
     m_kernelType(QUADRATIC),
     m_kernelFunction(QuadraticKernel),
     m_kernelMap{{LINEAR, LinearKernel}, {QUADRATIC, QuadraticKernel}, {CUBIC, CubicKernel}, {GAUSSIAN_RBF, GaussianRbfKernel}}
 {
 }

Member Function Documentation

double lar_content::SupportVectorMachine::CalculateClassificationScore ( const LArMvaHelper::MvaFeatureVector & features ) const

inlinevirtual

Calculate the classification score for a set of input features, based on the trained model.

Parameters

features the input features

Returns: the classification score

Implements lar_content::MvaInterface.

Definition at line 295 of file LArSupportVectorMachine.h.

 {
     return this->CalculateClassificationScoreImpl(features);
 }

double lar_content::SupportVectorMachine::CalculateClassificationScoreImpl ( const LArMvaHelper::MvaFeatureVector & features ) const

private

Implementation method for calculating the classification score using the trained model.

Parameters

features the vector of features

Returns: the classification score

Definition at line 250 of file LArSupportVectorMachine.cc.

 {
     if (!m_isInitialized)
     {
         std::cout << "SupportVectorMachine: could not perform classification because the svm was uninitialized" << std::endl;
         throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
     }
 
     if (m_svInfoList.empty())
     {
         std::cout << "SupportVectorMachine: could not perform classification because the initialized svm had no support vectors in the model"
                   << std::endl;
         throw StatusCodeException(STATUS_CODE_NOT_INITIALIZED);
     }
 
     LArMvaHelper::MvaFeatureVector standardizedFeatures;
     standardizedFeatures.reserve(m_nFeatures);
 
     if (m_standardizeFeatures)
     {
         for (std::size_t i = 0; i < m_nFeatures; ++i)
             standardizedFeatures.push_back(m_featureInfoList.at(i).StandardizeParameter(features.at(i).Get()));
     }
 
     double classScore(0.);
     for (const SupportVectorInfo &supportVectorInfo : m_svInfoList)
     {
         classScore += supportVectorInfo.m_yAlpha * m_kernelFunction(supportVectorInfo.m_supportVector,
                                                        (m_standardizeFeatures ? standardizedFeatures : features), m_scaleFactor);
     }
 
     return classScore + m_bias;
 }

double lar_content::SupportVectorMachine::CalculateProbability ( const LArMvaHelper::MvaFeatureVector & features ) const

inlinevirtual

Calculate the classification probability for a set of input features, based on the trained model.

Parameters

features the input features

Returns: the classification probability

Implements lar_content::MvaInterface.

Definition at line 302 of file LArSupportVectorMachine.h.

 {
     if (!m_enableProbability)
     {
         std::cout << "LArSupportVectorMachine: cannot calculate probabilities for this SVM" << std::endl;
         throw pandora::STATUS_CODE_NOT_INITIALIZED;
     }
 
     // Use the logistic function to map the linearly-transformed score on the interval (-inf,inf) to a probability on [0,1] - the two free
     // parameters in the linear transformation are trained such that the logistic map produces an accurate probability
     const double scaledScore = m_probAParameter * this->CalculateClassificationScoreImpl(features) + m_probBParameter;
 
     return 1. / (1. + std::exp(scaledScore));
 }

bool lar_content::SupportVectorMachine::Classify ( const LArMvaHelper::MvaFeatureVector & features ) const

inlinevirtual

Make a classification for a set of input features, based on the trained model.

Parameters

features the input features

Returns: the predicted boolean class

Implements lar_content::MvaInterface.

Definition at line 288 of file LArSupportVectorMachine.h.

 {
     return (this->CalculateClassificationScoreImpl(features) > 0.);
 }

double lar_content::SupportVectorMachine::CubicKernel	(	const LArMvaHelper::MvaFeatureVector &	supportVector,
		const LArMvaHelper::MvaFeatureVector &	features,
		const double	scaleFactor = `1.`
	)

inlinestaticprivate

An inhomogeneous cubic kernel.

Parameters

supportVector	the support vector
features	the features
scale	factor the scale factor

Returns: result of the kernel operation

Definition at line 373 of file LArSupportVectorMachine.h.

 {
     const double denominator(scaleFactor * scaleFactor);
     if (denominator < std::numeric_limits<double>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     double total(0.);
     for (unsigned int i = 0; i < features.size(); ++i)
         total += supportVector.at(i).Get() * features.at(i).Get();
 
     total = total / denominator + 1.;
     return total * total * total;
 }

double lar_content::SupportVectorMachine::GaussianRbfKernel	(	const LArMvaHelper::MvaFeatureVector &	supportVector,
		const LArMvaHelper::MvaFeatureVector &	features,
		const double	scaleFactor = `1.`
	)

inlinestaticprivate

A gaussian RBF kernel.

Parameters

supportVector	the support vector
features	the features
scale	factor the scale factor

Returns: result of the kernel operation

Definition at line 390 of file LArSupportVectorMachine.h.

 {
     double total(0.);
     for (unsigned int i = 0; i < features.size(); ++i)
         total += (supportVector.at(i).Get() - features.at(i).Get()) * (supportVector.at(i).Get() - features.at(i).Get());
 
     return std::exp(-scaleFactor * total);
 }

unsigned int lar_content::SupportVectorMachine::GetNFeatures ( ) const

inline

Get the number of features.

Returns: the number of features

Definition at line 326 of file LArSupportVectorMachine.h.

 {
     return m_nFeatures;
 }

StatusCode lar_content::SupportVectorMachine::Initialize	(	const std::string &	parameterLocation,
		const std::string &	svmName
	)

Initialize the svm using a serialized model.

Parameters

parameterLocation	the location of the model
svmName	the name of the model

Returns: success

Definition at line 35 of file LArSupportVectorMachine.cc.

 {
     if (m_isInitialized)
     {
         std::cout << "SupportVectorMachine: svm was already initialized" << std::endl;
         return STATUS_CODE_ALREADY_INITIALIZED;
     }
 
     this->ReadXmlFile(parameterLocation, svmName);
 
     // Check the sizes of sigma and scale factor if they are to be used as divisors
     if (m_standardizeFeatures)
     {
         for (const FeatureInfo &featureInfo : m_featureInfoList)
         {
             if (featureInfo.m_sigmaValue < std::numeric_limits<double>::epsilon())
             {
                 std::cout << "SupportVectorMachine: could not standardize parameters because sigma value was too small" << std::endl;
                 throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
             }
         }
     }
 
     // Check the number of features is consistent.
     m_nFeatures = m_featureInfoList.size();
 
     for (const SupportVectorInfo &svInfo : m_svInfoList)
     {
         if (svInfo.m_supportVector.size() != m_nFeatures)
         {
             std::cout << "SupportVectorMachine: the number of features in the xml file was inconsistent" << std::endl;
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
         }
     }
 
     // There's the possibility of a user-defined kernel that doesn't use this as a divisor but let's be safe
     if (m_scaleFactor < std::numeric_limits<double>::epsilon())
     {
         std::cout << "SupportVectorMachine: could not evaluate kernel because scale factor was too small" << std::endl;
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
     }
 
     m_isInitialized = true;
     return STATUS_CODE_SUCCESS;
 }

bool lar_content::SupportVectorMachine::IsInitialized ( ) const

inline

Query whether this svm is initialized.

Returns: whether the model is initialized

Definition at line 319 of file LArSupportVectorMachine.h.

 {
     return m_isInitialized;
 }

double lar_content::SupportVectorMachine::LinearKernel	(	const LArMvaHelper::MvaFeatureVector &	supportVector,
		const LArMvaHelper::MvaFeatureVector &	features,
		const double	scaleFactor = `1.`
	)

inlinestaticprivate

A linear kernel.

Parameters

supportVector	the support vector
features	the features
scale	factor the scale factor

Returns: result of the kernel operation

Definition at line 340 of file LArSupportVectorMachine.h.

 {
     const double denominator(scaleFactor * scaleFactor);
     if (denominator < std::numeric_limits<double>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     double total(0.);
     for (unsigned int i = 0; i < features.size(); ++i)
         total += supportVector.at(i).Get() * features.at(i).Get();
 
     return total / denominator;
 }

double lar_content::SupportVectorMachine::QuadraticKernel	(	const LArMvaHelper::MvaFeatureVector &	supportVector,
		const LArMvaHelper::MvaFeatureVector &	features,
		const double	scaleFactor = `1.`
	)

inlinestaticprivate

An inhomogeneous quadratic kernel.

Parameters

supportVector	the support vector
features	the features
scale	factor the scale factor

Returns: result of the kernel operation

Definition at line 356 of file LArSupportVectorMachine.h.

 {
     const double denominator(scaleFactor * scaleFactor);
     if (denominator < std::numeric_limits<double>::epsilon())
         throw pandora::StatusCodeException(pandora::STATUS_CODE_INVALID_PARAMETER);
 
     double total(0.);
     for (unsigned int i = 0; i < features.size(); ++i)
         total += supportVector.at(i).Get() * features.at(i).Get();
 
     total = total / denominator + 1.;
     return total * total;
 }

StatusCode lar_content::SupportVectorMachine::ReadComponent ( pandora::TiXmlElement * pCurrentXmlElement )

private

Read the component at the current xml element.

Parameters

pCurrentXmlElement address of the current xml element

Returns: success

Definition at line 143 of file LArSupportVectorMachine.cc.

 {
     const std::string componentName(pCurrentXmlElement->ValueStr());
     const TiXmlHandle currentHandle(pCurrentXmlElement);
 
     if ((std::string("Name") == componentName) || (std::string("Timestamp") == componentName))
         return STATUS_CODE_SUCCESS;
 
     if (std::string("Machine") == componentName)
         return this->ReadMachine(currentHandle);
 
     if (std::string("Features") == componentName)
         return this->ReadFeatures(currentHandle);
 
     if (std::string("SupportVector") == componentName)
         return this->ReadSupportVector(currentHandle);
 
     return STATUS_CODE_INVALID_PARAMETER;
 }

StatusCode lar_content::SupportVectorMachine::ReadFeatures ( const pandora::TiXmlHandle & currentHandle )

private

Read the feature component at the current xml handle.

Parameters

currentHandle the current xml handle

Returns: success

Definition at line 204 of file LArSupportVectorMachine.cc.

 {
     std::vector<double> muValues;
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadVectorOfValues(currentHandle, "MuValues", muValues));
 
     std::vector<double> sigmaValues;
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadVectorOfValues(currentHandle, "SigmaValues", sigmaValues));
 
     if (muValues.size() != sigmaValues.size())
     {
         std::cout << "SupportVectorMachine: could not add feature info because the size of mu (" << muValues.size()
                   << ") did not match "
                      "the size of sigma ("
                   << sigmaValues.size() << ")" << std::endl;
         return STATUS_CODE_INVALID_PARAMETER;
     }
 
     m_featureInfoList.reserve(muValues.size());
 
     for (std::size_t i = 0; i < muValues.size(); ++i)
         m_featureInfoList.emplace_back(muValues.at(i), sigmaValues.at(i));
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::SupportVectorMachine::ReadMachine ( const pandora::TiXmlHandle & currentHandle )

private

Read the machine component at the current xml handle.

Parameters

currentHandle the current xml handle

Returns: success

Definition at line 165 of file LArSupportVectorMachine.cc.

 {
     int kernelType(0);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "KernelType", kernelType));
 
     double bias(0.);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "Bias", bias));
 
     double scaleFactor(0.);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "ScaleFactor", scaleFactor));
 
     bool standardize(true);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "Standardize", standardize));
 
     bool enableProbability(false);
     PANDORA_RETURN_RESULT_IF_AND_IF(
         STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "EnableProbability", enableProbability));
 
     double probAParameter(0.);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "ProbAParameter", probAParameter));
 
     double probBParameter(0.);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "ProbBParameter", probBParameter));
 
     m_kernelType = static_cast<KernelType>(kernelType);
     m_bias = bias;
     m_scaleFactor = scaleFactor;
     m_enableProbability = enableProbability;
     m_probAParameter = probAParameter;
     m_probBParameter = probBParameter;
 
     if (kernelType != USER_DEFINED) // if user-defined, leave it so it alone can be set before/after initialization
         m_kernelFunction = m_kernelMap.at(m_kernelType);
 
     return STATUS_CODE_SUCCESS;
 }

StatusCode lar_content::SupportVectorMachine::ReadSupportVector ( const pandora::TiXmlHandle & currentHandle )

private

Read the support vector component at the current xml handle.

Parameters

currentHandle the current xml handle

Returns: success

Definition at line 232 of file LArSupportVectorMachine.cc.

 {
     double yAlpha(0.0);
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadValue(currentHandle, "AlphaY", yAlpha));
 
     std::vector<double> values;
     PANDORA_RETURN_RESULT_IF_AND_IF(STATUS_CODE_SUCCESS, STATUS_CODE_NOT_FOUND, !=, XmlHelper::ReadVectorOfValues(currentHandle, "Values", values));
 
     LArMvaHelper::MvaFeatureVector valuesFeatureVector;
     for (const double &value : values)
         valuesFeatureVector.emplace_back(value);
 
     m_svInfoList.emplace_back(yAlpha, valuesFeatureVector);
     return STATUS_CODE_SUCCESS;
 }

void lar_content::SupportVectorMachine::ReadXmlFile	(	const std::string &	svmFileName,
		const std::string &	svmName
	)

private

Read the svm parameters from an xml file.

Parameters

svmFileName	the sml file name
svmName	the name of the svm

Definition at line 83 of file LArSupportVectorMachine.cc.

 {
     TiXmlDocument xmlDocument(svmFileName);
 
     if (!xmlDocument.LoadFile())
     {
         std::cout << "SupportVectorMachine::Initialize - Invalid xml file." << std::endl;
         throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
     }
 
     const TiXmlHandle xmlDocumentHandle(&xmlDocument);
     TiXmlNode *pContainerXmlNode(TiXmlHandle(xmlDocumentHandle).FirstChildElement().Element());
 
     // Try to find the svm container with the required name
     while (pContainerXmlNode)
     {
         if (pContainerXmlNode->ValueStr() != "SupportVectorMachine")
             throw StatusCodeException(STATUS_CODE_FAILURE);
 
         const TiXmlHandle currentHandle(pContainerXmlNode);
 
         std::string currentName;
         PANDORA_THROW_RESULT_IF(STATUS_CODE_SUCCESS, !=, XmlHelper::ReadValue(currentHandle, "Name", currentName));
 
         if (currentName.empty() || (currentName.size() > 1000))
         {
             std::cout << "SupportVectorMachine::Initialize - Implausible svm name extracted from xml." << std::endl;
             throw StatusCodeException(STATUS_CODE_INVALID_PARAMETER);
         }
 
         if (currentName == svmName)
             break;
 
         pContainerXmlNode = pContainerXmlNode->NextSibling();
     }
 
     if (!pContainerXmlNode)
     {
         std::cout << "SupportVectorMachine: Could not find an svm by the name " << svmName << std::endl;
         throw StatusCodeException(STATUS_CODE_NOT_FOUND);
     }
 
     // Read the components of this svm container
     TiXmlHandle localHandle(pContainerXmlNode);
     TiXmlElement *pCurrentXmlElement = localHandle.FirstChild().Element();
 
     while (pCurrentXmlElement)
     {
         if (STATUS_CODE_SUCCESS != this->ReadComponent(pCurrentXmlElement))
         {
             std::cout << "SupportVectorMachine: Unknown component in xml file" << std::endl;
             throw StatusCodeException(STATUS_CODE_FAILURE);
         }
 
         pCurrentXmlElement = pCurrentXmlElement->NextSiblingElement();
     }
 }

void lar_content::SupportVectorMachine::SetKernelFunction ( KernelFunction kernelFunction )

inline

Set the kernel function to use.

Parameters

kernelFunction the kernel function

Definition at line 333 of file LArSupportVectorMachine.h.

 {
     m_kernelFunction = std::move(kernelFunction);
 }

Member Data Documentation

double lar_content::SupportVectorMachine::m_bias

private

The bias term.

Definition at line 174 of file LArSupportVectorMachine.h.

bool lar_content::SupportVectorMachine::m_enableProbability

private

Whether to enable probability calculations.

Definition at line 168 of file LArSupportVectorMachine.h.

FeatureInfoVector lar_content::SupportVectorMachine::m_featureInfoList

private

The list of FeatureInfo objects.

Definition at line 178 of file LArSupportVectorMachine.h.

bool lar_content::SupportVectorMachine::m_isInitialized

private

Whether this svm has been initialized.

Definition at line 166 of file LArSupportVectorMachine.h.

KernelFunction lar_content::SupportVectorMachine::m_kernelFunction

private

The kernel function.

Definition at line 181 of file LArSupportVectorMachine.h.

KernelMap lar_content::SupportVectorMachine::m_kernelMap

private

Map from the kernel types to the kernel functions.

Definition at line 182 of file LArSupportVectorMachine.h.

KernelType lar_content::SupportVectorMachine::m_kernelType

private

The kernel type.

Definition at line 180 of file LArSupportVectorMachine.h.

unsigned int lar_content::SupportVectorMachine::m_nFeatures

private

The number of features.

Definition at line 173 of file LArSupportVectorMachine.h.

double lar_content::SupportVectorMachine::m_probAParameter

private

The first-order score coefficient for mapping to a probability using the logistic function.

Definition at line 169 of file LArSupportVectorMachine.h.

double lar_content::SupportVectorMachine::m_probBParameter

private

The score offset parameter for mapping to a probability using the logistic function.

Definition at line 170 of file LArSupportVectorMachine.h.

double lar_content::SupportVectorMachine::m_scaleFactor

private

The kernel scale factor.

Definition at line 175 of file LArSupportVectorMachine.h.

bool lar_content::SupportVectorMachine::m_standardizeFeatures

private

Whether to standardize the features.

Definition at line 172 of file LArSupportVectorMachine.h.

SVInfoList lar_content::SupportVectorMachine::m_svInfoList

private

The list of SupportVectorInfo objects.

Definition at line 177 of file LArSupportVectorMachine.h.

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

larpandoracontent/larpandoracontent/LArObjects/LArSupportVectorMachine.h
larpandoracontent/larpandoracontent/LArObjects/LArSupportVectorMachine.cc

Classes

Public Types

Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation