Machine Learning Library
CMultiClassSVM.h
Go to the documentation of this file.
1 /*
2  COPYRIGHT (C) 2003 APPLIED NEUROINFORMATIC GROUP - UNIVERSITY OF BIELEFELD.
3 
4  ALL RIGHTS RESERVED.
5 
6  REDISTRIBUTION AND USE IN SOURCE AND BINARY FORM, WITH OR WITHOUT
7  MODIFICATION, REQUIRE THE PERMISSION OF THE COPYRIGHT HOLDERS.
8 
9  COMMERCIAL USE WITHOUT THE EXPLICIT PERMISSION OF THE COPYRIGHT HOLDERS
10  IS FORBIDDEN
11 
12  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
13  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
14  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
15  ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
16  ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
17  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
18  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
19  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
20  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
21  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
22 */
23 
24 
25 
26 #ifndef CMULTICLASSSVM_H
27 #define CMULTICLASSSVM_H
28 
29 #include "CSVMModel.h"
30 #include "CKernel.h"
31 #include "CConjugateGradientOptimizer.h"
32 
33 template<class Type>
34 class COneVsAllCalibration : protected CConjugateGradientOptimizer<Type> {
35 private:
36  CDenseVector<Type> m_tTrueClass;
37  CMatrix<Type> m_tMargins;
38  int m_iClasses;
39 public:
41 
42 
43  Type calibrate(CDenseVector<Type>& tTrueClass, CMatrix<Type>& tMargins) {
44  /*-----------------------------------------------------*/
45 #ifdef SAVE
46  ML_EQ_CHK(tTrueClass.dimension(), tMargins.rows());
47  ML_GEQ_CHK(tMargins.columns(), m_iClasses);
48 #endif
49 /*-----------------------------------------------------*/
50  m_tTrueClass = tTrueClass;
51  m_tMargins = tMargins;
52  m_iClasses = tMargins.columns();
53  this->setPosition(CDenseVector<Type>((m_iClasses-1)*2,0.0));
54  return optimize();
55  };
56 
58  /*-----------------------------------------------------*/
59 #ifdef SAVE
60  ML_EQ_CHK(m_iClasses, tVec.dimension());
61 #endif
62 /*-----------------------------------------------------*/
63 
64  CDenseVector<Type> tSoftMax(tVec);
65 
66  for(int i=0; i<m_iClasses-1; i++)
67  tSoftMax[i] = getPosition()[i*2] * tVec[i] + getPosition()[i*2+1];
68  tSoftMax[m_iClasses-1] = 1.0 * tVec[m_iClasses-1] + 1.0;
69  tSoftMax -= tSoftMax.maxElement();
70  for(int i=0; i<m_iClasses; i++)
71  tSoftMax[i] = exp(tSoftMax[i]);
72  tSoftMax /= tSoftMax.sumElements();
73  return tSoftMax;
74  };
75 
76 
77  bool serialize2(CArchiv& tA) {
78  string str;
79  int iTmp;
80  if(!CConjugateGradientOptimizer<Type>::serialize2(tA))
81  return false;
82 
83  if(tA.isReading()) {
84  tA >> m_iClasses;
85  return true;
86  } else {
87  tA << m_iClasses; tA.flush();
88  return true;
89  }
90  return false;
91  };
92 
93 
94 protected:
96  Type tValue=0;
97 
98  for(int i=0;i<m_tMargins.rows();i++)
99  tValue -= log(softMax(m_tMargins.getRow(i), tPos)[(int)m_tTrueClass[i]] + 0.0000001);
100  return tValue;
101  };
102 
105  CDenseVector<Type> tDP(tPos.dimension(),0.0);
106  Type tNet;
107 
108  for(int i=0;i<m_tMargins.rows();i++) {
109  tP = softMax(m_tMargins.getRow(i), tPos);
110  for(int j=0; j<m_iClasses-1; j++) {
111  if(m_tTrueClass[i]==j)
112  tNet = tP[j] - 1.0;
113  else
114  tNet = tP[j] - 0.0;
115  tDP[j*2] += tNet * tP[j] * (1.0-tP[j]) * m_tMargins(i,j);
116  tDP[j*2+1] += tNet * tP[j] * (1.0-tP[j]) * 1;
117  }
118  }
119  return tDP;
120  };
121 
123  CDenseVector<Type> tSoftMax(tVec);
124 
125  for(int i=0; i<m_iClasses-1; i++)
126  tSoftMax[i] = tPos[i*2] * tVec[i] + tPos[i*2+1];
127  tSoftMax[m_iClasses-1] = 1.0 * tVec[m_iClasses-1] + 1.0;
128  tSoftMax -= tSoftMax.maxElement();
129  for(int i=0; i<m_iClasses; i++)
130  tSoftMax[i] = exp(tSoftMax[i]);
131  tSoftMax /= tSoftMax.sumElements();
132  return tSoftMax;
133  };
134 };
135 
136 
137 template<class Type>
138 class CMultiClassSVM : public CClassifier<Type>
139 {
140 public:
142 protected:
143  vector< CSVMModel<Type> > m_tClassifiers;
147  Type m_tC;
153 public:
155  CMultiClassSVM(int iNumClasses, TMultiClassSVMType tType = ONE_VS_ALL);
156 
157 
159  ~CMultiClassSVM();
160 
161 
162  int classify(const CVector<Type>& tPattern) const;
163 
164 
165  void classify(const CVector<Type>&, Type&, Type&) const {};
166 
167  int classify(const CVector<Type>&, CDenseVector<Type>& rtVotes) const;
169  void setKernel(CKernel<Type>* ptKernel);
170 
172  void setRegularization(Type tC) {this->m_tC = tC;};
173 
174 
177 
178  void setCalibratedOutput(bool bSwitch) { m_bCalibrated = bSwitch; };
179 
180 
181  void trainCalibratedOneVsAll(vector< CDataset<Type> >& rtClassDs);
182 
184  void setCacheSize(int iSize) {m_iCacheSize = iSize;};
185 
186  const CKernel<Type>* kernel() const { return m_ptKernel; };
187 
188  void train(const CDataset<Type>& rtDataset);
189  string className() const;
190  bool isA(const char* acClass) const;
191  bool serialize2(CArchiv& tA);
192 protected:
193  void trainOneVsAll(vector<CDataset<Type> >& rtClassData);
194  void trainOneVsOne(vector<CDataset<Type> >& rtClassData);
195 };
196 
197 #endif
TMultiClassSVMType
Definition: CMultiClassSVM.h:141
virtual bool isReading() const
Definition: CArchiv.h:25
void trainOneVsAll(vector< CDataset< Type > > &rtClassData)
void trainCalibratedOneVsAll(vector< CDataset< Type > > &rtClassDs)
int rows() const
Definition: CMatrix.h:195
void classify(const CVector< Type > &, Type &, Type &) const
Definition: CMultiClassSVM.h:165
string className() const
COneVsAllCalibration()
Definition: CMultiClassSVM.h:40
CKernel< Type > * m_ptKernel
Definition: CMultiClassSVM.h:146
bool isA(const char *acClass) const
void setCacheSize(int iSize)
Set size of kernel cache.
Definition: CMultiClassSVM.h:184
const CKernel< Type > * kernel() const
Definition: CMultiClassSVM.h:186
Definition: CMultiClassSVM.h:138
Template object implementing a matrix of single and double precision elements.
Definition: CDenseVector.h:38
int dimension() const
Definition: CDenseVector.h:150
#define ML_EQ_CHK(var, val)
Definition: Macros.h:123
COneVsAllCalibration< Type > m_tOneVsAllCalibration
Definition: CMultiClassSVM.h:152
Definition: CMultiClassSVM.h:141
int m_iCalibrationFolds
Definition: CMultiClassSVM.h:151
CDenseVector< int > m_tNumClassItems
Definition: CMultiClassSVM.h:144
TMultiClassSVMType m_tType
Definition: CMultiClassSVM.h:145
Type sumElements() const
int m_iCacheSize
Definition: CMultiClassSVM.h:150
int classify(const CVector< Type > &tPattern) const
Definition: CMultiClassSVM.h:141
CDenseVector< Type > softMax(const CDenseVector< Type > &tVec, const CDenseVector< Type > &tPos)
Definition: CMultiClassSVM.h:122
Type m_tMaxTerminationError
Definition: CMultiClassSVM.h:148
CMultiClassSVM(int iNumClasses, TMultiClassSVMType tType=ONE_VS_ALL)
Constructor.
Base class of object serialization.
Definition: CArchiv.h:19
Type functionValueAt(CDenseVector< Type > &tPos)
Definition: CMultiClassSVM.h:95
int columns() const
Definition: CMatrix.h:203
~CMultiClassSVM()
Destructor.
Base class for kernel functions Base class for kernel function used for example by the support vector...
Definition: CKernel.h:46
Template object for vectors of single and double precision and integer.
Definition: CDenseVector.h:37
templatized vector for numerical applications
Definition: CMatrix.h:39
void setMaxTerminationError(Type tTE)
Set termination error.
Definition: CMultiClassSVM.h:176
vector< CSVMModel< Type > > m_tClassifiers
Definition: CMultiClassSVM.h:143
void trainOneVsOne(vector< CDataset< Type > > &rtClassData)
#define ML_GEQ_CHK(var, val)
Definition: Macros.h:119
void setKernel(CKernel< Type > *ptKernel)
Set kernel functiob.
Manages pairs of input and output vectors.
Definition: CDataset.h:110
void setCalibratedOutput(bool bSwitch)
Definition: CMultiClassSVM.h:178
bool m_bCalibrated
Definition: CMultiClassSVM.h:149
void setRegularization(Type tC)
Set regularization value.
Definition: CMultiClassSVM.h:172
CDenseVector< Type > partialDerivativeAt(CDenseVector< Type > &tPos)
Definition: CMultiClassSVM.h:103
Type maxElement() const
Definition: CMultiClassSVM.h:34
bool serialize2(CArchiv &tA)
Definition: CMultiClassSVM.h:77
Type m_tC
Definition: CMultiClassSVM.h:147
void train(const CDataset< Type > &rtDataset)
CDenseVector< Type > softMax(const CDenseVector< Type > &tVec) const
Definition: CMultiClassSVM.h:57
virtual void flush()
Definition: CArchiv.h:26
bool serialize2(CArchiv &tA)
Type calibrate(CDenseVector< Type > &tTrueClass, CMatrix< Type > &tMargins)
Definition: CMultiClassSVM.h:43