/usr/include/shogun/multiclass/MCLDA.h is in libshogun-dev 3.1.1-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 | /*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 3 of the License, or
* (at your option) any later version.
*
* Written (W) 2013 Kevin Hughes
* Copyright (C) 2013 Kevin Hughes
*
* Thanks to Fernando José Iglesias García (shogun)
* and Matthieu Perrot (scikit-learn)
*/
#ifndef _MCLDA_H__
#define _MCLDA_H__
#include <shogun/lib/config.h>
#ifdef HAVE_EIGEN3
#include <shogun/features/DotFeatures.h>
#include <shogun/features/DenseFeatures.h>
#include <shogun/machine/NativeMulticlassMachine.h>
#include <shogun/lib/SGNDArray.h>
namespace shogun
{
//#define DEBUG_MCLDA
/** @brief Class MCLDA implements multiclass Linear Discriminant Analysis.
*
* MCLDA learns a linear classifier and requires examples to be CDenseFeatures.
* The learned linear classification rule is optimal under the assumption that
* the classes are gaussian distributed with equal co-variance
*
*/
class CMCLDA : public CNativeMulticlassMachine
{
public:
MACHINE_PROBLEM_TYPE(PT_MULTICLASS)
/** constructor
*
* @param tolerance tolerance used in training
* @param store_cov whether to store the within class covariances
*/
CMCLDA(float64_t tolerance = 1e-4, bool store_cov = false);
/** constructor
*
* @param traindat training features
* @param trainlab labels for training features
* @param tolerance tolerance used in training
* @param store_cov whether to store the within class covariances
*/
CMCLDA(CDenseFeatures<float64_t>* traindat, CLabels* trainlab, float64_t tolerance = 1e-4, bool store_cov = false);
virtual ~CMCLDA();
/** apply CMCLDA to data
*
* @param data (test) data to be classified
* @return labels result of classification
*/
virtual CMulticlassLabels* apply_multiclass(CFeatures* data=NULL);
/** set tolerance
*
* @param tolerance tolerance used during training
*/
inline void set_tolerance(float64_t tolerance) { m_tolerance = tolerance; }
/** get tolerance
*
* @return tolerance used during training
*/
inline bool get_tolerance() { return m_tolerance; }
/** get classifier type
*
* @return classifier type MCLDA
*/
virtual EMachineType get_classifier_type() { return CT_LDA; } // for now add to machine typers properly later
/** set features
*
* @param feat features to set
*/
virtual void set_features(CDotFeatures* feat)
{
if (feat->get_feature_class() != C_DENSE ||
feat->get_feature_type() != F_DREAL)
SG_ERROR("MCLDA requires SIMPLE REAL valued features\n")
SG_REF(feat);
SG_UNREF(m_features);
m_features = feat;
}
/** get features
*
* @return features
*/
virtual CDotFeatures* get_features() { SG_REF(m_features); return m_features; }
/** get object name
*
* @return object name
*/
virtual const char* get_name() const { return "MCLDA"; }
/** get a class' mean vector
*
* @param c class index
*
* @return mean vector of class c
*/
inline SGVector< float64_t > get_mean(int32_t c) const
{
return SGVector< float64_t >(m_means.get_column_vector(c), m_dim, false);
}
/** get covariance matrix
*
* @return covariance matrix
*/
inline SGMatrix< float64_t > get_cov() const
{
return m_cov;
}
protected:
/** train MCLDA classifier
*
* @param data training data
*
* @return whether training was successful
*/
virtual bool train_machine(CFeatures* data = NULL);
private:
void init();
void cleanup();
private:
/** feature vectors */
CDotFeatures* m_features;
/** tolerance used during training */
float64_t m_tolerance;
/** whether to store the within class covariances */
bool m_store_cov;
/** number of classes */
int32_t m_num_classes;
/** dimension of the features space */
int32_t m_dim;
/** feature covariances for each of the classes in the training data
* stored if store_cov
*/
SGMatrix< float64_t > m_cov;
/** feature means for each of the classes in the training data */
SGMatrix< float64_t > m_means;
/** total mean */
SGVector< float64_t > m_xbar;
/** rank */
int32_t m_rank;
/** scalings */
SGMatrix< float64_t > m_scalings;
/** weight vectors / coefs */
SGMatrix< float64_t > m_coef;
/** intercept */
SGVector< float64_t > m_intercept;
}; /* class MCLDA */
} /* namespace shogun */
#endif /* HAVE_EIGEN3 */
#endif /* _MCLDA_H__ */
|