├── CMakeLists.txt
├── README.md
├── src
    ├── Algorithms
    │   ├── ConstantAlgorithm.cpp
    │   ├── ConstantAlgorithm.h
    │   ├── ConstantAlgorithmLSHTC.cpp
    │   ├── ConstantAlgorithmLSHTC.h
    │   ├── OneClassStumpAlgorithm.h
    │   ├── RegressionStumpAlgorithm.h
    │   ├── SparseStumpAlgorithm.h
    │   ├── StumpAlgorithm.h
    │   └── StumpAlgorithmLSHTC.h
    ├── Bandits
    │   ├── Exp3.cpp
    │   ├── Exp3.h
    │   ├── Exp3G.cpp
    │   ├── Exp3G.h
    │   ├── Exp3G2.cpp
    │   ├── Exp3G2.h
    │   ├── Exp3P.cpp
    │   ├── Exp3P.h
    │   ├── GenericBanditAlgorithm.cpp
    │   ├── GenericBanditAlgorithm.h
    │   ├── Random.cpp
    │   ├── Random.h
    │   ├── UCBK.cpp
    │   ├── UCBK.h
    │   ├── UCBKRandomized.cpp
    │   ├── UCBKRandomized.h
    │   ├── UCBKV.cpp
    │   └── UCBKV.h
    ├── BanditsLS
    │   ├── Exp3GLS.cpp
    │   ├── Exp3GLS.h
    │   ├── Exp3LS.cpp
    │   ├── Exp3LS.h
    │   ├── GenericBanditAlgorithmLS.cpp
    │   ├── GenericBanditAlgorithmLS.h
    │   ├── UCTLS.cpp
    │   └── UCTLS.h
    ├── Bzip2
    │   ├── Bzip2Wrapper.cpp
    │   ├── Bzip2Wrapper.h
    │   ├── blocksort.c
    │   ├── bzip2.c
    │   ├── bzip2recover.c
    │   ├── bzlib.c
    │   ├── bzlib.h
    │   ├── bzlib_private.h
    │   ├── compress.c
    │   ├── crctable.c
    │   ├── decompress.c
    │   ├── dlltest.c
    │   ├── huffman.c
    │   ├── mk251.c
    │   ├── randtable.c
    │   ├── spewG.c
    │   └── unzcrash.c
    ├── Classifiers
    │   ├── AdaBoostMHClassifier.cpp
    │   ├── AdaBoostMHClassifier.h
    │   ├── ExampleResults.cpp
    │   ├── ExampleResults.h
    │   ├── SoftCascadeClassifier.cpp
    │   ├── SoftCascadeClassifier.h
    │   ├── VJCascadeClassifier.cpp
    │   └── VJCascadeClassifier.h
    ├── Defaults.h
    ├── IO
    │   ├── ArffParser.cpp
    │   ├── ArffParser.h
    │   ├── ArffParserBzip2.cpp
    │   ├── ArffParserBzip2.h
    │   ├── EncodeData.cpp
    │   ├── EncodeData.h
    │   ├── GenericParser.h
    │   ├── HaarData.cpp
    │   ├── HaarData.h
    │   ├── InputData.cpp
    │   ├── InputData.h
    │   ├── NameMap.cpp
    │   ├── NameMap.h
    │   ├── OutputInfo.cpp
    │   ├── OutputInfo.h
    │   ├── ParasiteData.h
    │   ├── RawData.cpp
    │   ├── RawData.h
    │   ├── SVMLightParser.cpp
    │   ├── SVMLightParser.h
    │   ├── Serialization.cpp
    │   ├── Serialization.h
    │   ├── SortedData.cpp
    │   ├── SortedData.h
    │   ├── TxtParser.cpp
    │   └── TxtParser.h
    ├── Others
    │   ├── Example.h
    │   └── Rates.h
    ├── Registrations.h
    ├── StrongLearners
    │   ├── AdaBoostMHLearner.cpp
    │   ├── AdaBoostMHLearner.h
    │   ├── ArcGVLearner.cpp
    │   ├── ArcGVLearner.h
    │   ├── FilterBoostLearner.cpp
    │   ├── FilterBoostLearner.h
    │   ├── GenericStrongLearner.h
    │   ├── SoftCascadeLearner.cpp
    │   ├── SoftCascadeLearner.h
    │   ├── VJCascadeLearner.cpp
    │   └── VJCascadeLearner.h
    ├── Utils
    │   ├── Args.cpp
    │   ├── Args.h
    │   ├── ClassHierarchy.cpp
    │   ├── ClassHierarchy.h
    │   ├── MathematicalTools.h
    │   ├── StreamTokenizer.h
    │   ├── UCTutils.cpp
    │   ├── UCTutils.h
    │   ├── Utils.cpp
    │   └── Utils.h
    ├── WeakLearners
    │   ├── AbstainableLearner.cpp
    │   ├── AbstainableLearner.h
    │   ├── AdaLineLearner.cpp
    │   ├── AdaLineLearner.h
    │   ├── BanditLearner.cpp
    │   ├── BanditLearner.h
    │   ├── BanditSingleSparseStump.cpp
    │   ├── BanditSingleSparseStump.h
    │   ├── BanditSingleStumpLearner.cpp
    │   ├── BanditSingleStumpLearner.h
    │   ├── BaseLearner.cpp
    │   ├── BaseLearner.h
    │   ├── ConstantLearner.cpp
    │   ├── ConstantLearner.h
    │   ├── FeaturewiseLearner.cpp
    │   ├── FeaturewiseLearner.h
    │   ├── Haar
    │   │   ├── HaarFeatures.cpp
    │   │   ├── HaarFeatures.h
    │   │   ├── HaarLearner.cpp
    │   │   └── HaarLearner.h
    │   ├── HaarMultiStumpLearner.cpp
    │   ├── HaarMultiStumpLearner.h
    │   ├── HaarSingleStumpLearner.cpp
    │   ├── HaarSingleStumpLearner.h
    │   ├── IndicatorLearner.cpp
    │   ├── IndicatorLearner.h
    │   ├── MultiStumpLearner.cpp
    │   ├── MultiStumpLearner.h
    │   ├── MultiThresholdStumpLearner.cpp
    │   ├── MultiThresholdStumpLearner.h
    │   ├── NeuronLearner.cpp
    │   ├── NeuronLearner.h
    │   ├── OneClassStumpLearner.cpp
    │   ├── OneClassStumpLearner.h
    │   ├── ParasiteLearner.cpp
    │   ├── ParasiteLearner.h
    │   ├── ProductLearner.cpp
    │   ├── ProductLearner.h
    │   ├── ProductLearnerUCT.cpp
    │   ├── ProductLearnerUCT.h
    │   ├── ScalarLearner.h
    │   ├── SelectorLearner.cpp
    │   ├── SelectorLearner.h
    │   ├── SigmoidSingleStumpLearner.cpp
    │   ├── SigmoidSingleStumpLearner.h
    │   ├── SingleRegressionStumpLearner.cpp
    │   ├── SingleRegressionStumpLearner.h
    │   ├── SingleSparseStump.cpp
    │   ├── SingleSparseStump.h
    │   ├── SingleSparseStumpLearner.cpp
    │   ├── SingleSparseStumpLearner.h
    │   ├── SingleStumpLearner.cpp
    │   ├── SingleStumpLearner.h
    │   ├── StochasticLearner.cpp
    │   ├── StochasticLearner.h
    │   ├── TreeLearner.cpp
    │   ├── TreeLearner.h
    │   ├── TreeLearnerUCT.cpp
    │   ├── TreeLearnerUCT.h
    │   ├── UCBVHaarSingleStumpLearner.cpp
    │   └── UCBVHaarSingleStumpLearner.h
    └── main.cpp
├── trash
    ├── MathUtils.cpp
    ├── TreeLearner2.cpp
    ├── TreeLearner2.h
    ├── TreeLearner3.cpp
    └── TreeLearner3.h
└── version


/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | #The following command allows the use of the "file" command
 2 | cmake_minimum_required(VERSION 2.8)
 3 | 
 4 | #The declaration of the project
 5 | project(multiboost)
 6 | 
 7 | # Multiboost Version
 8 | file(READ "version" mbversion)
 9 | add_definitions(-DMB_CURRENT_VERSION="${mbversion}")
10 | 
11 | set(BASEPATH "${CMAKE_SOURCE_DIR}/src")
12 | 
13 | #This allows recursive parsing of the source files
14 | # Including sub-directories recursively
15 | file(GLOB project_SRCS "${BASEPATH}/*.h")
16 | file(GLOB_RECURSE project_SRCS 
17 |   "${BASEPATH}/Algorithms/*.cpp" "${BASEPATH}/Algorithms/*.h"
18 |   "${BASEPATH}/Bandits/*.cpp" "${BASEPATH}/Bandits/*.h"
19 |   "${BASEPATH}/BanditsLS/*.cpp" "${BASEPATH}/BanditsLS/*.h"
20 |   "${BASEPATH}/Classifiers/*.cpp" "${BASEPATH}/Classifiers/*.h"
21 |   "${BASEPATH}/IO/*.cpp" "${BASEPATH}/IO/*.h"
22 |   "${BASEPATH}/Others/*.cpp" "${BASEPATH}/Others/*.h"
23 |   "${BASEPATH}/StrongLearners/*.cpp" "${BASEPATH}/StrongLearners/*.h"
24 |   "${BASEPATH}/Utils/*.cpp" "${BASEPATH}/Utils/*.h"
25 |   "${BASEPATH}/WeakLearners/*.cpp" "${BASEPATH}/WeakLearners/*.h")
26 | 
27 | # Bzip2
28 | file(GLOB bzip2_SRCS "${BASEPATH}/Bzip2/*.cpp" "${BASEPATH}/Bzip2/*.c" "${BASEPATH}/Bzip2/*.h")
29 | add_library(Bzip2Lib STATIC ${bzip2_SRCS})
30 | 
31 | # By Default AlphaReal is double and FeatureReal is float
32 | # uncomment those lines to change that
33 | #ADD_DEFINITIONS( "-DFEATUREREALDOUBLE" )
34 | #ADD_DEFINITIONS( "-DALPHAREALFLOAT" )
35 | 
36 | #set(CMAKE_INCLUDE_PATH ./)
37 | include_directories("${BASEPATH}")
38 | 
39 | # make the library (used for unit testing)
40 | add_library(MultiBoostLib STATIC ${project_SRCS})
41 | 
42 | #This indicates the target (the executable)
43 | add_executable(multiboost "${BASEPATH}/main.cpp")
44 | 
45 | # adding library to the exec
46 | target_link_libraries(multiboost MultiBoostLib Bzip2Lib)
47 | 
48 | 
49 | 
50 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | MultiBoost
 2 | ==========
 3 | Welcome to the MultiBoost project!
 4 | ----------
 5 | The MultiBoost package is a *multi-class / multi-label / multi-task classification* boosting software implemented in C++. It implements essentially a multi-class version of **AdaBoost** (namely **AdaBoost.MH**) along with several multi-class weak-learning algorithms and cascades. It is free and easy to build into other applications due to its high modularity.
 6 | 
 7 | If you use this software in any publication, please refer to the following article:
 8 | 
 9 |     D. Benbouzid, R. Busa-Fekete, N. Casagrande, F.-D. Collin, and B. Kégl
10 |     MultiBoost: a multi-purpose boosting package
11 |     Journal of Machine Learning Research, 13:549–553, 2012. 
12 | 
13 | * [Original website](http://multiboost.org)
14 | 


--------------------------------------------------------------------------------
/src/Algorithms/ConstantAlgorithm.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | #include "ConstantAlgorithm.h"
 35 | 
 36 | #include <vector>
 37 | #include <cassert>
 38 | 
 39 | #include "IO/InputData.h"
 40 | #include "Others/Rates.h"
 41 | #include "IO/NameMap.h"
 42 | 
 43 | //To be checked with sparse with BreastCancer
 44 | 
 45 | namespace MultiBoost {
 46 | 
 47 | // ------------------------------------------------------------------------------
 48 | 
 49 |     void ConstantAlgorithm::findConstantWeightsEdges( InputData* pData,
 50 |                                                       vector<AlphaReal>& halfWeightsPerClass,
 51 |                                                       vector<AlphaReal>& halfEdges)
 52 |     { 
 53 |         const int numClasses = pData->getNumClasses();
 54 |         const int numExamples = pData->getNumExamples();
 55 | 
 56 |         memset(&(halfWeightsPerClass[0]), 0, sizeof(AlphaReal) * halfWeightsPerClass.size() );
 57 |         memset(&(halfEdges[0]), 0, sizeof(AlphaReal) * halfEdges.size() );
 58 |         //fill(halfWeightsPerClass.begin(), halfWeightsPerClass.end(), 0);
 59 |         //fill(halfEdges.begin(), halfEdges.end(), 0);
 60 | 
 61 |         for (int i = 0; i < numExamples; ++i)
 62 |         {
 63 |             vector<Label>& labels = pData->getLabels(i);
 64 |             vector<Label>::iterator lIt;
 65 | 
 66 |             int l = 0;
 67 |             for (lIt = labels.begin(); lIt != labels.end(); ++lIt)
 68 |             {
 69 |                 halfWeightsPerClass[ lIt->idx ] += lIt->weight;
 70 |                 halfEdges[ lIt->idx ] += lIt->weight * lIt->y;
 71 |             }
 72 |         }
 73 | 
 74 |         for (int l = 0; l < numClasses; ++l)
 75 |         {
 76 |             halfWeightsPerClass[l] /= 2.0;
 77 |             halfEdges[l] /= 2.0;
 78 |         }
 79 |     } // end of findConstantWeightsEdges
 80 | 
 81 | // ------------------------------------------------------------------------------
 82 | 
 83 |     AlphaReal ConstantAlgorithm::findConstant(InputData* pData,
 84 |                                               vector<sRates>* pMu, vector<AlphaReal>* pV)
 85 |     { 
 86 |         const int numClasses = pData->getNumClasses();
 87 | 
 88 |         vector<AlphaReal> halfWeightsPerClass(numClasses);
 89 |         vector<AlphaReal> halfEdges(numClasses);
 90 |    
 91 |         findConstantWeightsEdges(pData, halfWeightsPerClass, halfEdges);
 92 |    
 93 |         AlphaReal halfEdge = 0;
 94 | 
 95 |         for (int l = 0; l < numClasses; ++l)
 96 |         {
 97 |             if (halfEdges[l] > 0)
 98 |                 (*pV)[l] = +1;
 99 |             else
100 |                 (*pV)[l] = -1;
101 | 
102 |             halfEdge += (*pV)[l] * halfEdges[l];
103 | 
104 |             (*pMu)[l].classIdx = l;
105 |       
106 |             (*pMu)[l].rPls  = halfWeightsPerClass[l] + (*pV)[l] * halfEdges[l];
107 |             (*pMu)[l].rMin  = halfWeightsPerClass[l] - (*pV)[l] * halfEdges[l];
108 |             (*pMu)[l].rZero = (*pMu)[l].rPls + (*pMu)[l].rMin; // == weightsPerClass[l]
109 |         }
110 | 
111 |         return 2 * halfEdge;
112 | 
113 |     } // end of findConstant
114 | 
115 | // ------------------------------------------------------------------------------
116 | 
117 | } // end of namespace MultiBoost
118 | 


--------------------------------------------------------------------------------
/src/Algorithms/ConstantAlgorithm.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #ifndef __CONSTANT_ALGORITHM_H
35 | #define __CONSTANT_ALGORITHM_H
36 | 
37 | #include <vector>
38 | #include <cassert>
39 | 
40 | #include "IO/InputData.h"
41 | #include "Others/Rates.h"
42 | 
43 | using namespace std;
44 | 
45 | namespace MultiBoost {
46 | 
47 | //////////////////////////////////////////////////////////////////////////////////////////////
48 | //////////////////////////////////////////////////////////////////////////////////////////////
49 | 
50 |     class ConstantAlgorithm
51 |     {
52 |     public:
53 | 
54 |         /**
55 |          * Computes the half of the classwise weights and half of the
56 |          * classwise edges.
57 |          * @param pData The pointer to the data.
58 |          * @param pHalfWeightsPerClass The pointer to the half of the classwise weights.
59 |          * @param pHalfEdges The pointer to the half of the classwise edges.
60 |          * @date 30/06/2006
61 |          */
62 |         void findConstantWeightsEdges( InputData* pData, 
63 |                                        vector<AlphaReal>& pHalfWeightsPerClass,
64 |                                        vector<AlphaReal>& pHalfEdges);
65 |         /**
66 |          * Computes the classwise mus and votes (alignment) of the constant classifier
67 |          * @param pData The pointer to the data.
68 |          * @param pMu The The class-wise rates to update.
69 |          * @param pV The alignment vector to update.
70 |          * @return The edge.
71 |          * @date 20/07/2006
72 |          */
73 |         AlphaReal findConstant( InputData* pData, 
74 |                                 vector<sRates>* pMu, vector<AlphaReal>* pV);
75 |     };
76 | 
77 | } // end of namespace MultiBoost
78 | 
79 | #endif // __CONSTANT_ALGORITHM_H
80 | 


--------------------------------------------------------------------------------
/src/Algorithms/ConstantAlgorithmLSHTC.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | #include "ConstantAlgorithmLSHTC.h"
 35 | 
 36 | #include <vector>
 37 | #include <cassert>
 38 | 
 39 | #include "IO/InputData.h"
 40 | #include "Others/Rates.h"
 41 | #include "IO/NameMap.h"
 42 | 
 43 | //To be checked with sparse with BreastCancer data
 44 | 
 45 | namespace MultiBoost {
 46 | 
 47 |         
 48 | // ------------------------------------------------------------------------------
 49 | 
 50 |     void ConstantAlgorithmLSHTC::findConstantWeightsEdges( InputData* pData,
 51 |                                                            vector<AlphaReal>& halfWeightsPerClass,
 52 |                                                            vector<AlphaReal>& halfEdges)
 53 |     { 
 54 |         const int numClasses = pData->getNumClasses();
 55 |         const int numExamples = pData->getNumExamples();
 56 | 
 57 |         memset(&(halfWeightsPerClass[0]), 0, sizeof(AlphaReal) * halfWeightsPerClass.size() );
 58 |         memset(&(halfEdges[0]), 0, sizeof(AlphaReal) * halfEdges.size() );
 59 |         //fill(halfWeightsPerClass.begin(), halfWeightsPerClass.end(), 0);
 60 |         //fill(halfEdges.begin(), halfEdges.end(), 0);
 61 | 
 62 |         for (int i = 0; i < numExamples; ++i)
 63 |         {
 64 |             vector<Label>& labels = pData->getLabels(i);
 65 |             vector<Label>::iterator lIt;
 66 | 
 67 |             int l = 0;
 68 |             for (lIt = labels.begin(); lIt != labels.end(); ++lIt)
 69 |             {
 70 |                 halfWeightsPerClass[ lIt->idx ] += lIt->weight;
 71 |                 halfEdges[ lIt->idx ] += lIt->weight * lIt->y;
 72 |             }
 73 |         }
 74 | 
 75 |         for (int l = 0; l < numClasses; ++l)
 76 |         {
 77 |             halfWeightsPerClass[l] /= 2.0;
 78 |             halfEdges[l] /= 2.0;
 79 |         }
 80 |     } // end of findConstantWeightsEdges
 81 | 
 82 | // ------------------------------------------------------------------------------
 83 | 
 84 |     AlphaReal ConstantAlgorithmLSHTC::findConstant(InputData* pData,
 85 |                                                    vector<sRates>* pMu, vector<AlphaReal>* pV)
 86 |     { 
 87 |         const int numClasses = pData->getNumClasses();
 88 | 
 89 |         vector<AlphaReal> halfWeightsPerClass(numClasses);
 90 |         vector<AlphaReal> halfEdges(numClasses);
 91 |    
 92 |         findConstantWeightsEdges(pData, halfWeightsPerClass, halfEdges);
 93 |    
 94 |         AlphaReal halfEdge = 0;
 95 | 
 96 |         for (int l = 0; l < numClasses; ++l)
 97 |         {
 98 |             if (halfEdges[l] > 0)
 99 |                 (*pV)[l] = +1;
100 |             else
101 |                 (*pV)[l] = -1;
102 | 
103 |             halfEdge += (*pV)[l] * halfEdges[l];
104 | 
105 |             (*pMu)[l].classIdx = l;
106 |       
107 |             (*pMu)[l].rPls  = halfWeightsPerClass[l] + (*pV)[l] * halfEdges[l];
108 |             (*pMu)[l].rMin  = halfWeightsPerClass[l] - (*pV)[l] * halfEdges[l];
109 |             (*pMu)[l].rZero = (*pMu)[l].rPls + (*pMu)[l].rMin; // == weightsPerClass[l]
110 |         }
111 | 
112 |         return 2 * halfEdge;
113 | 
114 |     } // end of findConstant
115 | 
116 | // ------------------------------------------------------------------------------
117 | 
118 | } // end of namespace MultiBoost
119 | 


--------------------------------------------------------------------------------
/src/Algorithms/ConstantAlgorithmLSHTC.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #ifndef __CONSTANT_ALGORITHM_LSHTC_H
35 | #define __CONSTANT_ALGORITHM_LSHTC_H
36 | 
37 | #include <vector>
38 | #include <cassert>
39 | 
40 | #include "IO/InputData.h"
41 | #include "Others/Rates.h"
42 | 
43 | using namespace std;
44 | 
45 | namespace MultiBoost {
46 | 
47 | //////////////////////////////////////////////////////////////////////////////////////////////
48 | //////////////////////////////////////////////////////////////////////////////////////////////
49 | 
50 |     class ConstantAlgorithmLSHTC
51 |     {
52 |     public:
53 | 
54 |         /**
55 |          * Computes the half of the classwise weights and half of the
56 |          * classwise edges.
57 |          * @param pData The pointer to the data.
58 |          * @param pHalfWeightsPerClass The pointer to the half of the classwise weights.
59 |          * @param pHalfEdges The pointer to the half of the classwise edges.
60 |          * @date 30/06/2006
61 |          */
62 |         void findConstantWeightsEdges( InputData* pData, 
63 |                                        vector<AlphaReal>& pHalfWeightsPerClass,
64 |                                        vector<AlphaReal>& pHalfEdges);
65 |         /**
66 |          * Computes the classwise mus and votes (alignment) of the constant classifier
67 |          * @param pData The pointer to the data.
68 |          * @param pMu The The class-wise rates to update.
69 |          * @param pV The alignment vector to update.
70 |          * @return The edge.
71 |          * @date 20/07/2006
72 |          */
73 |         AlphaReal findConstant( InputData* pData, 
74 |                                 vector<sRates>* pMu, vector<AlphaReal>* pV);
75 |     };
76 | 
77 | } // end of namespace MultiBoost
78 | 
79 | #endif // __CONSTANT_ALGORITHM_H
80 | 


--------------------------------------------------------------------------------
/src/Bandits/Exp3.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #include "Exp3.h"
 36 | #include <limits>
 37 | #include <set>
 38 | #include <math.h>
 39 | 
 40 | namespace MultiBoost {
 41 | //----------------------------------------------------------------
 42 | //----------------------------------------------------------------
 43 | 
 44 | 
 45 |     Exp3::Exp3( void ) : GenericBanditAlgorithm()
 46 |     {
 47 |         _gamma = 0.01;
 48 |         //_eta = 0.05;
 49 |         //_alpha = 0.05;
 50 |     }
 51 | 
 52 | 
 53 | //----------------------------------------------------------------
 54 | //----------------------------------------------------------------
 55 |     void Exp3::initLearningOptions(const nor_utils::Args& args) 
 56 |     {
 57 |         if ( args.hasArgument( "gamma" ) ){
 58 |             _gamma = args.getValue<double>("gamma", 0 );
 59 |         } 
 60 | 
 61 |     }
 62 | 
 63 | 
 64 | //----------------------------------------------------------------
 65 | //----------------------------------------------------------------
 66 |     int Exp3::getNextAction()
 67 |     {
 68 |         vector< AlphaReal > cumsum( getArmNumber()+1 );
 69 |         int i;
 70 | 
 71 |         cumsum[0] = 0.0;
 72 |         for( int i=0; i < getArmNumber(); i++ )
 73 |         {
 74 |             cumsum[i+1] = cumsum[i] + _pHat[i];
 75 |         }
 76 | 
 77 |         for( i=0; i < getArmNumber(); i++ )
 78 |         {
 79 |             cumsum[i+1] /= cumsum[  getArmNumber() ];
 80 |         }
 81 | 
 82 |         AlphaReal r = rand() / (AlphaReal) RAND_MAX;
 83 | 
 84 |         for( i=0; i < getArmNumber(); i++ )
 85 |         {
 86 |             if ( (cumsum[i] <= r) && ( r<=cumsum[i+1] )  ) break;
 87 |         }
 88 | 
 89 |         return i;
 90 |     }
 91 | 
 92 | //----------------------------------------------------------------
 93 | //----------------------------------------------------------------
 94 | 
 95 |     void Exp3::initialize( vector< AlphaReal >& vals )
 96 |     {
 97 |         _p.resize( _numOfArms );
 98 |         _pHat.resize( _numOfArms );
 99 | 
100 |         fill( _p.begin(), _p.end(), 1.0 / _numOfArms );
101 |         fill( _pHat.begin(), _pHat.end(), 1.0 / _numOfArms );
102 | 
103 |         //_alpha = pow( 4*_numOfArms*log((double)_numOfArms) * ( 1.0 / 100000 ), 1.0/3.0);
104 |         //_gamma = pow( (_numOfArms*log((double)_numOfArms))/( 2.0 * 100000 ) , 0.5);
105 |         //if ( _gamma > 1.0 ) _gamma = 1.0;
106 | 
107 | 
108 |         //copy the initial values to X
109 |         copy( vals.begin(), vals.end(), _X.begin() );
110 | 
111 |         for( int i=0; i < _X.size(); i++ ) _X[i] *= ( _gamma /(double) _numOfArms* _numOfArms);
112 | 
113 |         //one pull for all arm
114 |         fill( _T.begin(), _T.end(), 1 );
115 | 
116 | 
117 |         setInitializedFlagToTrue();
118 |     }
119 | 
120 | //----------------------------------------------------------------
121 | //----------------------------------------------------------------
122 | 
123 |     void Exp3::updateithValue( int i )
124 |     {
125 |         AlphaReal sumexp = 0.0;
126 | 
127 |         AlphaReal max = -numeric_limits<AlphaReal>::max();
128 |         for( int i=0; i<_numOfArms; i++ ) 
129 |         {
130 |             if ( max < _X[i] ) max = _X[i];
131 |         }
132 | 
133 |         for( int i=0; i<_numOfArms; i++ ) 
134 |         {
135 |             _p[i] = exp( _X[i]-max);// * log( 1.0 + _alpha ); 
136 |             sumexp += _p[i];
137 |         }
138 |         
139 |         for( int i=0; i<_numOfArms; i++ ) 
140 |         {
141 |             _p[i] /= sumexp;
142 |             //_p[i] = exp( _p[i] );
143 |         
144 |             //sum += _p[i];
145 |         }
146 | 
147 | 
148 |         for( int i=0; i<_numOfArms; i++ ) 
149 |         {
150 |             _pHat[i] = (1-_gamma)*_p[i] + _gamma / _numOfArms;
151 |         }
152 | 
153 |     }
154 | 
155 | //----------------------------------------------------------------
156 | //----------------------------------------------------------------
157 |     void Exp3::receiveReward( int armNum, AlphaReal reward )
158 |     {
159 |         _T[ armNum ]++;
160 |         AlphaReal xHat = reward / _pHat[armNum];
161 |         _X[ armNum ] += ( ( _gamma  * xHat )/ _numOfArms );
162 |         incIter();
163 |         updateithValue( armNum );               
164 |     }
165 | 
166 | 
167 | } // end namespace MultiBoost
168 | 


--------------------------------------------------------------------------------
/src/Bandits/Exp3.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | /**
 34 |    \file Exp3.h 
 35 | */
 36 | 
 37 | #ifndef _EXP3_H
 38 | #define _EXP3_H
 39 | 
 40 | #include <list> 
 41 | #include <functional>
 42 | #include <math.h> //for pow
 43 | #include "GenericBanditAlgorithm.h"
 44 | #include "Utils/Utils.h"
 45 | 
 46 | using namespace std;
 47 | //////////////////////////////////////////////////////////////////////////////////////////////
 48 | //////////////////////////////////////////////////////////////////////////////////////////////
 49 | 
 50 | namespace MultiBoost {
 51 | 
 52 |     class Hedge : public GenericBanditAlgorithm {
 53 |     protected:
 54 |         AlphaReal _alpha;
 55 |         vector< AlphaReal > _p;
 56 | 
 57 |     public:
 58 |         
 59 |     Hedge( void ) : GenericBanditAlgorithm(), _p(0)
 60 |         {
 61 |             _alpha = 0.05;
 62 |         }
 63 | 
 64 |         //----------------------------------------------------------------
 65 |         //----------------------------------------------------------------
 66 |         // getters and setters 
 67 |         //----------------------------------------------------------------
 68 |         //----------------------------------------------------------------
 69 |         double getAlpha() { return _alpha; }
 70 |         void setAlpha( AlphaReal alpha ) { _alpha = alpha; }
 71 | 
 72 |         void getProbabilityVector( vector< double >& p )
 73 |         {
 74 |             p.resize( _p.size() );
 75 |             copy( _p.begin(), _p.end(), p.begin() );
 76 |         }       
 77 | 
 78 |         //----------------------------------------------------------------
 79 |         // receive rewards for all arms!!!
 80 |         void receiveRewardVector( vector< AlphaReal >& r )
 81 |         {
 82 |             for( int i=0; i < _numOfArms; i++ )
 83 |             {
 84 |                 _T[i]++;
 85 |                 _X[i] += r[i];
 86 |                 incIter();
 87 |             }
 88 |             setPVector();
 89 |         }
 90 |         //----------------------------------------------------------------
 91 | 
 92 | 
 93 |         virtual void initialize( vector< AlphaReal >& vals )
 94 |         {
 95 |             _p.resize( _numOfArms );
 96 |             setPVector();
 97 |         }
 98 | 
 99 |         virtual void getKBestAction( const int k, vector<int>& bestArms ) {}
100 |         virtual int getNextAction() { return 0; }
101 | 
102 |         virtual void initLearningOptions(const nor_utils::Args& args) {}
103 |     protected:
104 |         virtual void updateithValue( int armNum ) 
105 |         { 
106 |             setPVector();
107 |         }               
108 | 
109 |         void setPVector( void ) 
110 |         {
111 |             AlphaReal sum = 0.0;
112 | 
113 |             for( int i=0; i < _numOfArms; i++ )
114 |             {
115 |                 _p[i] = pow( ( 1 + _alpha ), _X[i] );
116 |                 sum += _p[i];
117 |             }
118 |             for( int i=0; i < _numOfArms; i++ )
119 |             {
120 |                 _p[i] /= sum;
121 |             }
122 |         }
123 |     };
124 | 
125 | //////////////////////////////////////////////////////////////////////////////////
126 | //////////////////////////////////////////////////////////////////////////////////
127 | 
128 | 
129 |     class Exp3 : public GenericBanditAlgorithm
130 |     {
131 |     protected:
132 |         //double _alpha;
133 |         AlphaReal _gamma;
134 |         vector< AlphaReal > _p;
135 |         vector< AlphaReal > _pHat;
136 | 
137 |         //Hedge _hedge;
138 |     public:
139 |         Exp3(void);
140 |         virtual ~Exp3(void) 
141 |         {
142 |         }
143 | 
144 |         //----------------------------------------------------------------
145 |         //----------------------------------------------------------------
146 |         // getters and setters 
147 |         //----------------------------------------------------------------
148 |         //----------------------------------------------------------------
149 |         //double getAlpha() { return _alpha; }
150 |         //void setAlpha( double alpha ) { _alpha = alpha; }
151 |         AlphaReal getGamma() { return _gamma; }
152 |         void setGamma( AlphaReal gamma ) { _gamma = gamma; }
153 | 
154 |         virtual void receiveReward( int armNum, AlphaReal reward );
155 | 
156 |         virtual void initialize( vector< AlphaReal >& vals );
157 | 
158 |         virtual int getNextAction();
159 | 
160 |         virtual void initLearningOptions(const nor_utils::Args& args);
161 |     protected:
162 |         virtual void updateithValue( int i );   
163 |     };
164 | 
165 | 
166 | //////////////////////////////////////////////////////////////////////////////////
167 | //////////////////////////////////////////////////////////////////////////////////
168 | 
169 | 
170 | } // end of namespace MultiBoost
171 | 
172 | #endif
173 | 
174 | 


--------------------------------------------------------------------------------
/src/Bandits/Exp3G.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #ifndef _Exp3G_H
 36 | #define _Exp3G_H
 37 | 
 38 | #include <list> 
 39 | #include <functional>
 40 | #include <math.h> //for pow
 41 | #include "GenericBanditAlgorithm.h"
 42 | #include "Utils/Utils.h"
 43 | 
 44 | /*
 45 |   The Exp3G Algorithm was published in: 
 46 |   Kocsis and Szepesvari:
 47 |   Reduced-Variance Payoff Estimation in Adversarial Bandit Problems
 48 |   (it isn't available the journal where it was appeared, but it was written that it is published in the proceedings of ECML05)
 49 | */
 50 | 
 51 | 
 52 | using namespace std;
 53 | //////////////////////////////////////////////////////////////////////////////////////////////
 54 | //////////////////////////////////////////////////////////////////////////////////////////////
 55 | 
 56 | namespace MultiBoost {
 57 | 
 58 | 
 59 |     class Exp3G : public GenericBanditAlgorithm
 60 |     {
 61 |     protected:
 62 |         AlphaReal _eta;
 63 |         AlphaReal _gamma;
 64 |         vector< AlphaReal > _p;
 65 |         vector< AlphaReal > _w;
 66 |         vector< AlphaReal > _tmpW;
 67 |         vector< vector< int > > _sideInformation;
 68 |         vector< int > _actions;
 69 |         //Hedge _hedge;
 70 |     public:
 71 |         Exp3G(void);
 72 |         virtual ~Exp3G(void) 
 73 |         {
 74 |         }
 75 | 
 76 |         //----------------------------------------------------------------
 77 |         //----------------------------------------------------------------
 78 |         // getters and setters 
 79 |         //----------------------------------------------------------------
 80 |         //----------------------------------------------------------------
 81 |         double getEta() { return _eta; }
 82 |         void setEta( AlphaReal eta ) { _eta = eta; }
 83 |         double getGamma() { return _gamma; }
 84 |         void setGamma( double gamma ) { _gamma = gamma; }
 85 | 
 86 |         virtual void receiveReward( int armNum, AlphaReal reward );
 87 | 
 88 |         virtual void initialize( vector< AlphaReal >& vals );
 89 |         virtual int getNextAction();
 90 | 
 91 |         virtual void initLearningOptions(const nor_utils::Args& args );
 92 |     protected:
 93 |         virtual void updateithValue( int arm ); 
 94 |     };
 95 | 
 96 | 
 97 | //////////////////////////////////////////////////////////////////////////////////
 98 | //////////////////////////////////////////////////////////////////////////////////
 99 | 
100 | 
101 | } // end of namespace MultiBoost
102 | 
103 | #endif
104 | 
105 | 


--------------------------------------------------------------------------------
/src/Bandits/Exp3G2.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #include "Exp3G2.h"
 36 | #include <limits>
 37 | #include <set>
 38 | #include <math.h>
 39 | 
 40 | namespace MultiBoost {
 41 | //----------------------------------------------------------------
 42 | //----------------------------------------------------------------
 43 | 
 44 | 
 45 |     Exp3G2::Exp3G2( void ) : Exp3G()
 46 |     {
 47 |         _gamma = 0.05;
 48 |         _eta = 0.4;
 49 |     }
 50 | 
 51 | //----------------------------------------------------------------
 52 | //----------------------------------------------------------------
 53 | 
 54 |     void Exp3G2::initialize( vector< AlphaReal >& vals )
 55 |     {
 56 |         _p.resize( _numOfArms );
 57 |         _w.resize( _numOfArms );
 58 |         _tmpW.resize( _numOfArms );
 59 | 
 60 |         fill( _p.begin(), _p.end(), 1.0 / _numOfArms );
 61 |         fill( _w.begin(), _w.end(), 1.0 );
 62 | 
 63 | 
 64 |         //pull all arm  
 65 |         copy( vals.begin(), vals.end(), _X.begin() );
 66 |         fill( _T.begin(), _T.end(), 1 );
 67 |         
 68 |         
 69 |         for( int i=0; i < _numOfArms; i++ ) 
 70 |         {
 71 |             _w[i] = _eta * _X[i];
 72 |         }
 73 | 
 74 |         setInitializedFlagToTrue();
 75 |     }
 76 | 
 77 | 
 78 | 
 79 | //----------------------------------------------------------------
 80 | //----------------------------------------------------------------
 81 |     void Exp3G2::receiveReward( int armNum, AlphaReal reward )
 82 |     {
 83 | 
 84 |         _T[ armNum ]++;
 85 |         // calculate the feedback value
 86 | 
 87 |         incIter();
 88 |          
 89 |         //update 
 90 |         for( int i=0; i < _numOfArms; i++ ) 
 91 |         {
 92 |             _w[i] += ( _eta * reward );
 93 |         }
 94 | 
 95 |         //_w[armNum] += ( _eta * reward );
 96 | 
 97 |         updateithValue( armNum );               
 98 |     }
 99 | 
100 | //----------------------------------------------------------------
101 | //----------------------------------------------------------------
102 |     void Exp3G2::receiveReward( vector<AlphaReal> reward )
103 |     {
104 |         incIter();
105 |          
106 |         //update 
107 |         for( int i=0; i < _numOfArms; i++ ) 
108 |         {
109 |             _w[i] += ( _eta * reward[i] );
110 |         }
111 | 
112 |         //_w[armNum] += ( _eta * reward );
113 | 
114 |         updateithValue( 0 );            
115 |     }
116 | 
117 | 
118 | } // end namespace MultiBoost
119 | 


--------------------------------------------------------------------------------
/src/Bandits/Exp3G2.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | 
35 | #ifndef _Exp3G2_H
36 | #define _Exp3G2_H
37 | 
38 | #include <list> 
39 | #include <functional>
40 | #include <math.h> //for pow
41 | #include "GenericBanditAlgorithm.h"
42 | #include "Exp3G.h"
43 | #include "Utils/Utils.h"
44 | 
45 | /*
46 |   The Exp3G2 Algorithm was published in: 
47 |   Kocsis and Szepesvari:
48 |   Reduced-Variance Payoff Estimation in Adversarial Bandit Problems
49 |   (it isn't available the journal where it was appeared, but it was written that it is published in the proceedings of ECML05)
50 | */
51 | 
52 | 
53 | using namespace std;
54 | //////////////////////////////////////////////////////////////////////////////////////////////
55 | //////////////////////////////////////////////////////////////////////////////////////////////
56 | 
57 | namespace MultiBoost {
58 | 
59 | 
60 |     class Exp3G2 : public Exp3G
61 |     {
62 |     public:
63 |         Exp3G2(void);
64 |         virtual ~Exp3G2(void) 
65 |         {
66 |         }
67 | 
68 |         virtual void receiveReward( int armNum, AlphaReal reward );
69 |         virtual void receiveReward( vector< AlphaReal > reward );
70 | 
71 |         virtual void initialize( vector< AlphaReal >& vals );
72 | 
73 |     };
74 | 
75 | 
76 | //////////////////////////////////////////////////////////////////////////////////
77 | //////////////////////////////////////////////////////////////////////////////////
78 | 
79 | 
80 | } // end of namespace MultiBoost
81 | 
82 | #endif
83 | 
84 | 
85 | 


--------------------------------------------------------------------------------
/src/Bandits/Exp3P.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #include "Exp3P.h"
 36 | #include <limits>
 37 | #include <set>
 38 | #include <math.h>
 39 | 
 40 | namespace MultiBoost {
 41 | //----------------------------------------------------------------
 42 | //----------------------------------------------------------------
 43 | 
 44 | 
 45 |     Exp3P::Exp3P( void ) : Exp3G()
 46 |     {
 47 |         _gamma = 0.1;
 48 |         _eta = 0.4;
 49 |         _horizon = 100.0;
 50 |     }
 51 | 
 52 | 
 53 | 
 54 | //----------------------------------------------------------------
 55 | //----------------------------------------------------------------
 56 | 
 57 |     void Exp3P::initialize( vector< AlphaReal >& vals )
 58 |     {
 59 |         _p.resize( _numOfArms );
 60 |         _w.resize( _numOfArms );
 61 |         _tmpW.resize( _numOfArms );
 62 | 
 63 |         fill( _p.begin(), _p.end(), 1.0 / _numOfArms );
 64 |         fill( _w.begin(), _w.end(), 1.0 );
 65 | 
 66 |         copy( vals.begin(), vals.end(), _X.begin() );
 67 |         
 68 |         //one pull for all arm
 69 |         fill( _T.begin(), _T.end(), 1 );
 70 |         
 71 |         for( int i=0; i < _numOfArms; i++ ) 
 72 |         {
 73 |             _w[i] = ((_gamma * _eta ) / 3.0 ) * pow( ( _horizon / ((AlphaReal)_numOfArms) ) , 0.5 ) ;
 74 |             if ( vals.size() == _numOfArms ) {
 75 |                 _w[i]+= ( (_gamma / (3 * (AlphaReal)_numOfArms )) * // _gamma / 3K
 76 |                           (vals[i]*((AlphaReal)_numOfArms ))  // x hat
 77 |                           + ( ( ( _eta * (AlphaReal)_numOfArms ) / (  pow( (AlphaReal)_numOfArms * _horizon,0.5 )))));
 78 |             }
 79 |         }
 80 | 
 81 |         setInitializedFlagToTrue();
 82 |     }
 83 | //----------------------------------------------------------------
 84 | //----------------------------------------------------------------
 85 | 
 86 | 
 87 |     void Exp3P::receiveReward( int armNum, AlphaReal reward )
 88 |     {
 89 |         _T[ armNum ]++;
 90 |         // calculate the feedback value
 91 | 
 92 |         incIter();
 93 |          
 94 |         //update 
 95 |         AlphaReal xHat = reward / _p[armNum]; 
 96 |         _w[armNum] +=  (_gamma / (3 * (AlphaReal)_numOfArms )) * ( xHat + ( _eta / ( _p[armNum] * pow( (AlphaReal)_numOfArms * _horizon,0.5 )) ) );
 97 | 
 98 |         /*
 99 |           double wsum = 0.0;
100 |           for( int i=0; i<_numOfArms; i++ ) 
101 |           {
102 |           wsum += _w[i];
103 |           }
104 |           for( int i=0; i<_numOfArms; i++ ) 
105 |           {
106 |           _w[i] /= wsum;
107 |           }
108 |         */
109 | 
110 |         updateithValue( armNum );               
111 |     }
112 | 
113 | 
114 | } // end namespace MultiBoost
115 | 


--------------------------------------------------------------------------------
/src/Bandits/Exp3P.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | 
35 | #ifndef _Exp3P_H
36 | #define _Exp3P_H
37 | 
38 | #include <list> 
39 | #include <functional>
40 | #include <math.h> //for pow
41 | #include "GenericBanditAlgorithm.h"
42 | #include "Utils/Utils.h"
43 | #include "Exp3G.h"
44 | using namespace std;
45 | //////////////////////////////////////////////////////////////////////////////////////////////
46 | //////////////////////////////////////////////////////////////////////////////////////////////
47 | 
48 | namespace MultiBoost {
49 | 
50 | 
51 | //////////////////////////////////////////////////////////////////////////////////
52 | //////////////////////////////////////////////////////////////////////////////////
53 | 
54 | 
55 |     class Exp3P : public Exp3G
56 |     {
57 |     protected:
58 |         double _horizon; //horizon
59 |         // _eta is the alpha in the paper
60 |         //Hedge _hedge;
61 |     public:
62 |         Exp3P(void);
63 |         virtual ~Exp3P(void) 
64 |         {
65 |         }
66 | 
67 |         virtual void receiveReward( int armNum, AlphaReal reward );
68 |         virtual void initialize( vector< AlphaReal >& vals );
69 |     };
70 | 
71 | 
72 | //////////////////////////////////////////////////////////////////////////////////
73 | //////////////////////////////////////////////////////////////////////////////////
74 | 
75 | 
76 | } // end of namespace MultiBoost
77 | 
78 | #endif
79 | 
80 | 


--------------------------------------------------------------------------------
/src/Bandits/GenericBanditAlgorithm.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "GenericBanditAlgorithm.h"
35 | 


--------------------------------------------------------------------------------
/src/Bandits/Random.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "Random.h"
35 | #include <limits>
36 | #include <set>
37 | 
38 | namespace MultiBoost {
39 | //----------------------------------------------------------------
40 | //----------------------------------------------------------------
41 | 
42 | 
43 |     Random::Random( void ) : GenericBanditAlgorithm()
44 |     {
45 |     }
46 | 
47 | 
48 | //----------------------------------------------------------------
49 | //----------------------------------------------------------------
50 | 
51 | 
52 |     void Random::getKBestAction( const int k, vector<int>& bestArms )
53 |     {
54 |         set<int> s;
55 |         for( int i=0; i<k; i++ )
56 |         {
57 |             s.insert( getNextAction() );
58 |         }
59 |         bestArms.clear();
60 |         for( set<int>::iterator it = s.begin(); it != s.end(); it++ )
61 |         {
62 |             bestArms.push_back( *it );
63 |         }
64 | 
65 |     }
66 | //----------------------------------------------------------------
67 | //----------------------------------------------------------------
68 | 
69 |     int Random::getNextAction()
70 |     {
71 |         int arm = (int) (rand() % getArmNumber() );
72 | 
73 |         return arm;
74 |     }
75 | 
76 | //----------------------------------------------------------------
77 | //----------------------------------------------------------------
78 | 
79 |     void Random::updateithValue( int i )
80 |     {
81 |     }
82 | 
83 | //----------------------------------------------------------------
84 | //----------------------------------------------------------------
85 | 
86 | 
87 | } // end namespace MultiBoost
88 | 
89 | 


--------------------------------------------------------------------------------
/src/Bandits/Random.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | 
35 | #ifndef _RANDOM_H
36 | #define _RANDOM_H
37 | 
38 | #include <list> 
39 | #include <functional>
40 | #include <math.h> //for log
41 | #include "GenericBanditAlgorithm.h"
42 | #include "Utils/Utils.h"
43 | //////////////////////////////////////////////////////////////////////////////////////////////
44 | //////////////////////////////////////////////////////////////////////////////////////////////
45 | 
46 | namespace MultiBoost {
47 | /*
48 |   class StorageElement{
49 |   protected:
50 |   int             _index;
51 |   double  _value;
52 |   public:
53 |   int getIndex() { return _index; }
54 |   double getValue() { return _value; }
55 |   void setIndex( int index ) { _index = index; }
56 |   void setValue( double value ) { _value = value; }
57 |   };
58 | */
59 | 
60 |     class Random : public GenericBanditAlgorithm
61 |     {
62 |     protected:
63 |     public:
64 |         Random(void);
65 |         virtual ~Random(void) {}
66 | 
67 |         virtual void getKBestAction( const int k, vector<int>& bestArms );
68 |         virtual int getNextAction();
69 | 
70 |         virtual void initLearningOptions(const nor_utils::Args& args) {}
71 |     protected:
72 |         virtual void updateithValue( int i );   
73 |     };
74 | 
75 | } // end of namespace MultiBoost
76 | 
77 | #endif
78 | 
79 | 


--------------------------------------------------------------------------------
/src/Bandits/UCBK.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #include "UCBK.h"
 36 | #include <limits>
 37 | 
 38 | namespace MultiBoost {
 39 | //----------------------------------------------------------------
 40 | //----------------------------------------------------------------
 41 | 
 42 | 
 43 |     UCBK::UCBK( void ) : GenericBanditAlgorithm(), _valuesList(0)
 44 |     {
 45 |     }
 46 | 
 47 | 
 48 | //----------------------------------------------------------------
 49 | //----------------------------------------------------------------
 50 | 
 51 | 
 52 |     void UCBK::getKBestAction( const int k, vector<int>& bestArms )
 53 |     {
 54 |         bestArms.resize(k);
 55 |         int i=0; 
 56 |         for( list< pair<AlphaReal,int>* >::iterator it = _valuesList.begin(); i<k; it++, i++ )
 57 |         {
 58 |             bestArms[i] = (**it).second;
 59 |         }
 60 |     }
 61 | //----------------------------------------------------------------
 62 | //----------------------------------------------------------------
 63 | 
 64 |     int UCBK::getNextAction()
 65 |     {
 66 |         return _valuesList.front()->second;
 67 |     }
 68 | 
 69 | //----------------------------------------------------------------
 70 | //----------------------------------------------------------------
 71 | 
 72 |     void UCBK::initialize( vector< AlphaReal >& vals )
 73 |     {
 74 |         _valueRecord.resize( _numOfArms );
 75 |                 
 76 |         for( int i=0; i < _numOfArms; i++ ) {
 77 |             pair< AlphaReal, int >* tmpPair = new pair< AlphaReal, int >(0.0,i);
 78 | 
 79 |             _valuesList.push_back( tmpPair );
 80 |             _valueRecord[i] = tmpPair;
 81 |         }
 82 | 
 83 | 
 84 |         //copy the initial values to X
 85 |         copy( vals.begin(), vals.end(), _X.begin() );
 86 |         //one pull for all arm
 87 |         fill( _T.begin(), _T.end(), 1 );
 88 |         
 89 |         //update the values
 90 |         for( int i = 0; i < _numOfArms; i++ )
 91 |         {
 92 |             _valueRecord[i]->first = _X[i] / (AlphaReal) _T[i] + sqrt( ( 2 * log( (AlphaReal)getIterNum() ) ) / _T[i] );
 93 |         }
 94 |         //sort them according to the values the arms
 95 |         _valuesList.sort( nor_utils::comparePairP< 1, AlphaReal, int, greater<AlphaReal> >() );
 96 | 
 97 |         setInitializedFlagToTrue();
 98 |     }
 99 | 
100 | //----------------------------------------------------------------
101 | //----------------------------------------------------------------
102 | 
103 |     void UCBK::updateithValue( int i )
104 |     {
105 |         //update the value
106 |         _valueRecord[i]->first = _X[i] / (AlphaReal) _T[i] + sqrt( ( 2 * log( (AlphaReal)getIterNum() ) ) / _T[i] );
107 |         //sort them according to the values the arms
108 |         _valuesList.sort( nor_utils::comparePairP< 1, AlphaReal, int, greater<AlphaReal> >() );
109 |     }
110 | 
111 | //----------------------------------------------------------------
112 | //----------------------------------------------------------------
113 | 
114 | 
115 | } // end namespace MultiBoost
116 | 
117 | 


--------------------------------------------------------------------------------
/src/Bandits/UCBK.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | 
35 | #ifndef _UCBK_H
36 | #define _UCBK_H
37 | 
38 | #include <list> 
39 | #include <functional>
40 | #include <math.h> //for log
41 | #include "GenericBanditAlgorithm.h"
42 | #include "Utils/Utils.h"
43 | //////////////////////////////////////////////////////////////////////////////////////////////
44 | //////////////////////////////////////////////////////////////////////////////////////////////
45 | 
46 | namespace MultiBoost {
47 | /*
48 |   class StorageElement{
49 |   protected:
50 |   int             _index;
51 |   double  _value;
52 |   public:
53 |   int getIndex() { return _index; }
54 |   double getValue() { return _value; }
55 |   void setIndex( int index ) { _index = index; }
56 |   void setValue( double value ) { _value = value; }
57 |   };
58 | */
59 | 
60 |     class UCBK : public GenericBanditAlgorithm
61 |     {
62 |     protected:
63 |         list< pair<AlphaReal, int >* > _valuesList;
64 |         vector< pair<AlphaReal, int >* > _valueRecord;
65 |     public:
66 |         UCBK(void);
67 |         virtual ~UCBK(void) 
68 |         {
69 |             list< pair< AlphaReal, int >* >::iterator it;
70 |                 
71 |             for( it = _valuesList.begin(); it != _valuesList.end(); it ++ )
72 |             {
73 |                 delete *it;
74 |             }
75 | 
76 |             _valuesList.clear();
77 |             _valueRecord.clear();
78 |         }
79 | 
80 |         virtual void initialize( vector< AlphaReal >& vals );
81 | 
82 |         virtual void getKBestAction( const int k, vector<int>& bestArms );
83 |         virtual int getNextAction();
84 | 
85 |         virtual void initLearningOptions(const nor_utils::Args& args) {}
86 |     protected:
87 |         virtual void updateithValue( int i );   
88 |     };
89 | 
90 | } // end of namespace MultiBoost
91 | 
92 | #endif
93 | 
94 | 


--------------------------------------------------------------------------------
/src/Bandits/UCBKRandomized.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #include "UCBKRandomized.h"
 36 | #include <limits>
 37 | #include <set>
 38 | 
 39 | namespace MultiBoost {
 40 | //----------------------------------------------------------------
 41 | //----------------------------------------------------------------
 42 | 
 43 | 
 44 |     UCBKRandomized::UCBKRandomized( void ) : UCBK()
 45 |     {
 46 |     }
 47 | 
 48 | 
 49 | //----------------------------------------------------------------
 50 | //----------------------------------------------------------------
 51 | 
 52 | 
 53 |     void UCBKRandomized::getKBestAction( const int k, vector<int>& bestArms )
 54 |     {
 55 |         set<int> s;
 56 |         for( int i=0; i<k; i++ )
 57 |         {
 58 |             s.insert( getNextAction() );
 59 |         }
 60 |         bestArms.clear();
 61 |         for( set<int>::iterator it = s.begin(); it != s.end(); it++ )
 62 |         {
 63 |             bestArms.push_back( *it );
 64 |         }
 65 |     }
 66 | //----------------------------------------------------------------
 67 | //----------------------------------------------------------------
 68 | 
 69 |     int UCBKRandomized::getNextAction()
 70 |     {
 71 |         vector< AlphaReal > cumsum( getArmNumber()+1 );
 72 |         int i;
 73 | 
 74 |         cumsum[0] = 0.0;
 75 |         for( int i=0; i < getArmNumber(); i++ )
 76 |         {
 77 |             cumsum[i+1] = cumsum[i] + _valueRecord[i]->first;
 78 |         }
 79 | 
 80 |         for( i=0; i < getArmNumber(); i++ )
 81 |         {
 82 |             cumsum[i+1] /= cumsum[  getArmNumber() ];
 83 |         }
 84 | 
 85 |         AlphaReal r = rand() / (AlphaReal) RAND_MAX;
 86 | 
 87 |         for( i=0; i < getArmNumber(); i++ )
 88 |         {
 89 |             if ( (cumsum[i] <= r) && ( r<=cumsum[i+1] )  ) break;
 90 |         }
 91 | 
 92 |         return i;
 93 |     }
 94 | 
 95 | //----------------------------------------------------------------
 96 | //----------------------------------------------------------------
 97 | 
 98 |     void UCBKRandomized::updateithValue( int i )
 99 |     {
100 |         //update the value
101 |         //_valueRecord[i]->first = _X[i] / (double) _T[i] + sqrt( ( 2 * log( (double)getIterNum() ) ) / _T[i] );
102 |         _valueRecord[i]->first = _X[i] / (AlphaReal) _T[i];// + sqrt( ( 2 * log( (double)getIterNum() ) ) / _T[i] );
103 |         //_valueRecord[i]->first = exp( _valueRecord[i]->first );
104 |         //sort them according to the values the arms
105 |         _valuesList.sort( nor_utils::comparePairP< 1, AlphaReal, int, greater<AlphaReal> >() );
106 |     }
107 | //----------------------------------------------------------------
108 | //----------------------------------------------------------------
109 | 
110 | 
111 | } // end namespace MultiBoost
112 | 
113 | 
114 | 


--------------------------------------------------------------------------------
/src/Bandits/UCBKRandomized.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | 
35 | #ifndef _UCBK_RANDOMIZED_H
36 | #define _UCBK_RANDOMIZED_H
37 | 
38 | #include <list> 
39 | #include <functional>
40 | #include <math.h> //for log
41 | #include "GenericBanditAlgorithm.h"
42 | #include "Utils/Utils.h"
43 | #include "UCBK.h"
44 | //////////////////////////////////////////////////////////////////////////////////////////////
45 | //////////////////////////////////////////////////////////////////////////////////////////////
46 | 
47 | namespace MultiBoost {
48 | /*
49 |   class StorageElement{
50 |   protected:
51 |   int             _index;
52 |   double  _value;
53 |   public:
54 |   int getIndex() { return _index; }
55 |   double getValue() { return _value; }
56 |   void setIndex( int index ) { _index = index; }
57 |   void setValue( double value ) { _value = value; }
58 |   };
59 | */
60 | 
61 |     class UCBKRandomized : public UCBK
62 |     {
63 |     public:
64 |         UCBKRandomized(void);
65 | 
66 |         virtual void getKBestAction( const int k, vector<int>& bestArms );
67 |         virtual int getNextAction();
68 |     protected:
69 |         virtual void updateithValue( int i );
70 |     };
71 | 
72 | } // end of namespace MultiBoost
73 | 
74 | #endif
75 | 
76 | 


--------------------------------------------------------------------------------
/src/Bandits/UCBKV.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | #include "UCBKV.h"
 35 | #include <limits>
 36 | 
 37 | namespace MultiBoost {
 38 | //----------------------------------------------------------------
 39 | //----------------------------------------------------------------
 40 | 
 41 | 
 42 |     UCBKV::UCBKV( void ) : GenericBanditAlgorithm(), _valuesList(0), _table( 0 ), _kszi( 1.0 ), _c(1.0/3.0), _b(1)
 43 |     {
 44 |     }
 45 | 
 46 | 
 47 | //----------------------------------------------------------------
 48 | //----------------------------------------------------------------
 49 | 
 50 | 
 51 |     void UCBKV::getKBestAction( const int k, vector<int>& bestArms )
 52 |     {
 53 |         bestArms.resize(k);
 54 |         int i=0; 
 55 |         for( list< pair< AlphaReal,int>* >::iterator it = _valuesList.begin(); i<k; it++, i++ )
 56 |         {
 57 |             bestArms[i] = (**it).second;
 58 |         }
 59 |     }
 60 | //----------------------------------------------------------------
 61 | //----------------------------------------------------------------
 62 | 
 63 |     int UCBKV::getNextAction()
 64 |     {
 65 |         return _valuesList.front()->second;
 66 |     }
 67 | 
 68 | //----------------------------------------------------------------
 69 | //----------------------------------------------------------------
 70 | 
 71 |     void UCBKV::initialize( vector< AlphaReal >& vals )
 72 |     {
 73 |         int i;
 74 | 
 75 |         _valueRecord.resize( _numOfArms );
 76 |                 
 77 |         for( i=0; i < _numOfArms; i++ ) {
 78 |             pair< AlphaReal, int >* tmpPair = new pair< AlphaReal, int >(0.0,i);
 79 | 
 80 |             _valuesList.push_back( tmpPair );
 81 |             _valueRecord[i] = tmpPair;
 82 |         }
 83 | 
 84 | 
 85 |         //copy the initial values to X
 86 |         copy( vals.begin(), vals.end(), _X.begin() );
 87 |         
 88 |         //copy the initial values into the table
 89 |         _table.resize( _numOfArms );
 90 |         for( i = 0; i < _numOfArms; i++ ) 
 91 |         {
 92 |             _table[i].resize( 1 );
 93 |             _table[i][0] = vals[i];
 94 |         }
 95 | 
 96 |         //one pull for all arm
 97 |         fill( _T.begin(), _T.end(), 1 );
 98 |         
 99 |         //update the values
100 |         for( i = 0; i < _numOfArms; i++ )
101 |         {
102 |             //_valueRecord[i]->first = _X[i] / (double) _T[i] + sqrt( ( 2 * log( (double)getIterNum() ) ) / _T[i] );
103 |             _valueRecord[i]->first = _X[i] / (AlphaReal) _T[i] + _c * ( ( 3 * _b * _kszi *  log( (AlphaReal)getIterNum() ) )/ _T[i]); //second term is zero because of the variance is eqaul to zero
104 |         }
105 |         //sort them according to the values the arms
106 |         _valuesList.sort( nor_utils::comparePairP< 1, AlphaReal, int, greater<AlphaReal> >() );
107 | 
108 |         setInitializedFlagToTrue();
109 |     }
110 | 
111 | //----------------------------------------------------------------
112 | //----------------------------------------------------------------
113 | 
114 |     void UCBKV::updateithValue( int i )
115 |     {
116 |         //update the value
117 |         AlphaReal mean = _X[i] / (AlphaReal) _T[i];
118 |         AlphaReal variance = 0.0;
119 | 
120 |         for( int j = 0; j < _T[i]; j++ )
121 |         {
122 |             variance += (( _table[i][j] - mean )*( _table[i][j] - mean ));
123 |         }
124 |         variance /= _T[i];
125 | 
126 |         _valueRecord[i]->first = mean + sqrt( ( 2.0 * _kszi * variance * log( (AlphaReal)getIterNum() ) ) / _T[i] ) + 
127 |             _c * ( ( 3 * _b * _kszi *  log( (AlphaReal)getIterNum() ) )/ _T[i]) ;
128 |         
129 |         //sort them according to the values the arms
130 |         _valuesList.sort( nor_utils::comparePairP< 1, AlphaReal, int, greater<AlphaReal> >() );
131 |     }
132 | 
133 | //----------------------------------------------------------------
134 | //----------------------------------------------------------------
135 | 
136 |     void UCBKV::receiveReward( int armNum, AlphaReal reward )
137 |     {
138 |         _T[ armNum ]++;
139 |         _X[ armNum ] += reward;
140 |         _table[armNum].push_back( reward );
141 |         incIter();
142 |         updateithValue( armNum );               
143 |     }
144 | 
145 | //----------------------------------------------------------------
146 | //----------------------------------------------------------------
147 | 
148 | 
149 | } // end namespace MultiBoost
150 | 


--------------------------------------------------------------------------------
/src/Bandits/UCBKV.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #ifndef _UCBKVV_H
 36 | #define _UCBKVV_H
 37 | 
 38 | #include <list> 
 39 | #include <functional>
 40 | #include <math.h> //for log
 41 | #include "GenericBanditAlgorithm.h"
 42 | #include "Utils/Utils.h"
 43 | //////////////////////////////////////////////////////////////////////////////////////////////
 44 | //////////////////////////////////////////////////////////////////////////////////////////////
 45 | 
 46 | namespace MultiBoost {
 47 | /*
 48 |   class StorageElement{
 49 |   protected:
 50 |   int             _index;
 51 |   double  _value;
 52 |   public:
 53 |   int getIndex() { return _index; }
 54 |   double getValue() { return _value; }
 55 |   void setIndex( int index ) { _index = index; }
 56 |   void setValue( double value ) { _value = value; }
 57 |   };
 58 | */
 59 | 
 60 |     class UCBKV : public GenericBanditAlgorithm
 61 |     {
 62 |     protected:
 63 |         list< pair< AlphaReal, int >* > _valuesList;
 64 |         vector< pair< AlphaReal, int >* > _valueRecord;
 65 |         vector< vector< AlphaReal > > _table;
 66 |         AlphaReal _kszi; //exploaration paramerter
 67 |         AlphaReal _c; //trade-off parameter
 68 |         AlphaReal _b; // the support of rewards [0;b]
 69 | 
 70 |     public:
 71 |         UCBKV(void);
 72 |         virtual ~UCBKV(void) 
 73 |         {
 74 |             list< pair< AlphaReal, int >* >::iterator it;
 75 |                 
 76 |             for( it = _valuesList.begin(); it != _valuesList.end(); it ++ )
 77 |             {
 78 |                 delete *it;
 79 |             }
 80 | 
 81 |             _valuesList.clear();
 82 |             _valueRecord.clear();
 83 |         }
 84 |         
 85 |         virtual void receiveReward( int armNum, AlphaReal reward );
 86 | 
 87 |         virtual void initialize( vector< AlphaReal >& vals );
 88 | 
 89 |         virtual void getKBestAction( const int k, vector<int>& bestArms );
 90 |         virtual int getNextAction();
 91 | 
 92 |         virtual void initLearningOptions(const nor_utils::Args& args) {}
 93 |     protected:
 94 |         virtual void updateithValue( int i );   
 95 |     };
 96 | 
 97 | } // end of namespace MultiBoost
 98 | 
 99 | #endif
100 | 
101 | 


--------------------------------------------------------------------------------
/src/BanditsLS/Exp3GLS.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "Exp3GLS.h"
35 | #include "GenericBanditAlgorithmLS.h"
36 | 
37 | #include <limits>
38 | #include <set>
39 | #include <math.h>
40 | 
41 | namespace MultiBoost {
42 | //----------------------------------------------------------------
43 | //----------------------------------------------------------------
44 | /*
45 |   template class Exp3GLS<float,string>;
46 |   template class Exp3GLS<double,string>;
47 |   template class Exp3GLS<float,int>;
48 |   template class Exp3GLS<double,int>;
49 | */
50 | 
51 | 
52 | 
53 | 
54 | } // end namespace MultiBoost
55 | 
56 | 


--------------------------------------------------------------------------------
/src/BanditsLS/Exp3LS.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "Exp3LS.h"
35 | #include "GenericBanditAlgorithmLS.h"
36 | 
37 | #include <limits>
38 | #include <set>
39 | #include <math.h>
40 | 
41 | namespace MultiBoost {
42 | //----------------------------------------------------------------
43 | //----------------------------------------------------------------
44 | /*
45 |   template class Exp3LS<float,string>;
46 |   template class Exp3LS<double,string>;
47 |   template class Exp3LS<float,int>;
48 |   template class Exp3LS<double,int>;
49 | 
50 | 
51 | 
52 |   template< typename BaseType,typename KeyType>
53 |   Exp3LS<BaseType,KeyType>::Exp3LS(void) :  _Xsum(0.0), _expsum(1.0)
54 |   {
55 |   GenericBanditAlgorithmLS();
56 |   _gamma  = static_cast<BaseType>(0.05);
57 |   }
58 | */
59 | 
60 | 
61 | 
62 | } // end namespace MultiBoost
63 | 
64 | 


--------------------------------------------------------------------------------
/src/BanditsLS/GenericBanditAlgorithmLS.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "GenericBanditAlgorithmLS.h"
35 | 


--------------------------------------------------------------------------------
/src/BanditsLS/UCTLS.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "UCTLS.h"
35 | #include <cctype> // for isspace
36 | #include <algorithm>
37 | #include <sstream>
38 | #include <fstream>
39 | 
40 | namespace MultiBoost {
41 | 
42 | // ----------------------------------------------------------------
43 | 
44 | // ----------------------------------------------------------------
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/src/BanditsLS/UCTLS.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file UCTLS.h The UCT algorithm.
 36 |  */
 37 | 
 38 | #ifndef __UCT_H
 39 | #define __UCT_H
 40 | 
 41 | #include "GenericBanditAlgorithmLS.h"
 42 | #include "Utils/UCTutils.h"
 43 | 
 44 | using namespace std;
 45 | 
 46 | 
 47 | //////////////////////////////////////////////////////////////////////////////////////////////
 48 | //////////////////////////////////////////////////////////////////////////////////////////////
 49 | 
 50 | namespace MultiBoost {
 51 |         
 52 | //////////////////////////////////////////////////////////////////////////
 53 | 
 54 |     template< typename BaseType=double,typename KeyType=string>
 55 |         class UCT : public GenericBanditAlgorithmLS< BaseType, KeyType>
 56 |         {
 57 |         protected:
 58 |         InnerNodeUCTSparse      _root;
 59 |         locale                                                                          _loc; 
 60 | 
 61 |         public:
 62 | 
 63 |         virtual void receiveReward( KeyType key, BaseType reward );
 64 |         virtual void initialize( map<KeyType,BaseType>& vals );
 65 |         virtual KeyType getNextAction( KeyType defaultValue );
 66 | 
 67 |         virtual void setDepth( int d ) { InnerNodeUCTSparse::setDepth( d ); }
 68 |         virtual void setOrder( int o ) { InnerNodeUCTSparse::setBranchOrder( o ); }
 69 | 
 70 |         protected:
 71 |         virtual void updateithValue( KeyType key ){}            
 72 | 
 73 |         };
 74 | 
 75 | //----------------------------------------------------------------
 76 | //----------------------------------------------------------------
 77 |     template< typename BaseType,typename KeyType>
 78 |         void UCT<BaseType,KeyType>::initialize( map<KeyType,BaseType>& vals )
 79 |     {       
 80 |         //initialize the root
 81 |         _loc = locale(locale(), new nor_utils::white_spaces(":"));
 82 |         _root.setChildrenNum();
 83 |         this->setInitializedFlagToTrue();
 84 |     }
 85 | 
 86 | //----------------------------------------------------------------
 87 | //----------------------------------------------------------------
 88 |     template< typename BaseType,typename KeyType>
 89 |         void UCT<BaseType,KeyType>::receiveReward( KeyType key, BaseType reward )
 90 |     {
 91 |         int d = InnerNodeUCTSparse::getDepth();
 92 |         stringstream ss( static_cast<string>(key) );
 93 |         ss.imbue( _loc );
 94 |         vector<int> tmpArms( d );
 95 |         for( int i=0; i < d; i++ ) 
 96 |         {
 97 |             int tmpInt; 
 98 |             ss >> tmpInt;
 99 |             tmpArms[i] = tmpInt;
100 |         }
101 |         _root.updateInnerNodes( static_cast<double>(reward), tmpArms );
102 |     }
103 | 
104 | //----------------------------------------------------------------
105 | //----------------------------------------------------------------
106 |     template< typename BaseType,typename KeyType>
107 |         KeyType UCT<BaseType,KeyType>::getNextAction( KeyType defaultValue )
108 |     {
109 |         vector<int> tmpVec(0);
110 |         _root.getBestTrajectory( tmpVec );
111 |         string key = nor_utils::int2string( tmpVec[0] );
112 |         for( int i=1; i < tmpVec.size(); i++ )
113 |         {
114 |             key.append( ":" );
115 |             key.append( nor_utils::int2string( tmpVec[i] ) );
116 |         }
117 |         return (key);
118 |     }
119 | 
120 | //----------------------------------------------------------------
121 | //----------------------------------------------------------------
122 | } // end of namespace MultiBoost
123 | 
124 | #endif
125 | 


--------------------------------------------------------------------------------
/src/Bzip2/Bzip2Wrapper.cpp:
--------------------------------------------------------------------------------
 1 | #include "Bzip2Wrapper.h"
 2 | 
 3 | Bzip2WrapperWriter::Bzip2WrapperWriter(void)
 4 | {
 5 | }
 6 | 
 7 | Bzip2WrapperWriter::~Bzip2WrapperWriter(void)
 8 | {
 9 | }
10 | 
11 | 
12 | 
13 | Bzip2WrapperReader::~Bzip2WrapperReader(void)
14 | {
15 | }
16 | 


--------------------------------------------------------------------------------
/src/Bzip2/crctable.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /*-------------------------------------------------------------*/
  3 | /*--- Table for doing CRCs                                  ---*/
  4 | /*---                                            crctable.c ---*/
  5 | /*-------------------------------------------------------------*/
  6 | 
  7 | /* ------------------------------------------------------------------
  8 |    This file is part of bzip2/libbzip2, a program and library for
  9 |    lossless, block-sorting data compression.
 10 | 
 11 |    bzip2/libbzip2 version 1.0.5 of 10 December 2007
 12 |    Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
 13 | 
 14 |    Please read the WARNING, DISCLAIMER and PATENTS sections in the 
 15 |    README file.
 16 | 
 17 |    This program is released under the terms of the license contained
 18 |    in the file LICENSE.
 19 |    ------------------------------------------------------------------ */
 20 | 
 21 | 
 22 | #include "bzlib_private.h"
 23 | 
 24 | /*--
 25 |   I think this is an implementation of the AUTODIN-II,
 26 |   Ethernet & FDDI 32-bit CRC standard.  Vaguely derived
 27 |   from code by Rob Warnock, in Section 51 of the
 28 |   comp.compression FAQ.
 29 |   --*/
 30 | 
 31 | UInt32 BZ2_crc32Table[256] = {
 32 | 
 33 |     /*-- Ugly, innit? --*/
 34 | 
 35 |     0x00000000L, 0x04c11db7L, 0x09823b6eL, 0x0d4326d9L,
 36 |     0x130476dcL, 0x17c56b6bL, 0x1a864db2L, 0x1e475005L,
 37 |     0x2608edb8L, 0x22c9f00fL, 0x2f8ad6d6L, 0x2b4bcb61L,
 38 |     0x350c9b64L, 0x31cd86d3L, 0x3c8ea00aL, 0x384fbdbdL,
 39 |     0x4c11db70L, 0x48d0c6c7L, 0x4593e01eL, 0x4152fda9L,
 40 |     0x5f15adacL, 0x5bd4b01bL, 0x569796c2L, 0x52568b75L,
 41 |     0x6a1936c8L, 0x6ed82b7fL, 0x639b0da6L, 0x675a1011L,
 42 |     0x791d4014L, 0x7ddc5da3L, 0x709f7b7aL, 0x745e66cdL,
 43 |     0x9823b6e0L, 0x9ce2ab57L, 0x91a18d8eL, 0x95609039L,
 44 |     0x8b27c03cL, 0x8fe6dd8bL, 0x82a5fb52L, 0x8664e6e5L,
 45 |     0xbe2b5b58L, 0xbaea46efL, 0xb7a96036L, 0xb3687d81L,
 46 |     0xad2f2d84L, 0xa9ee3033L, 0xa4ad16eaL, 0xa06c0b5dL,
 47 |     0xd4326d90L, 0xd0f37027L, 0xddb056feL, 0xd9714b49L,
 48 |     0xc7361b4cL, 0xc3f706fbL, 0xceb42022L, 0xca753d95L,
 49 |     0xf23a8028L, 0xf6fb9d9fL, 0xfbb8bb46L, 0xff79a6f1L,
 50 |     0xe13ef6f4L, 0xe5ffeb43L, 0xe8bccd9aL, 0xec7dd02dL,
 51 |     0x34867077L, 0x30476dc0L, 0x3d044b19L, 0x39c556aeL,
 52 |     0x278206abL, 0x23431b1cL, 0x2e003dc5L, 0x2ac12072L,
 53 |     0x128e9dcfL, 0x164f8078L, 0x1b0ca6a1L, 0x1fcdbb16L,
 54 |     0x018aeb13L, 0x054bf6a4L, 0x0808d07dL, 0x0cc9cdcaL,
 55 |     0x7897ab07L, 0x7c56b6b0L, 0x71159069L, 0x75d48ddeL,
 56 |     0x6b93dddbL, 0x6f52c06cL, 0x6211e6b5L, 0x66d0fb02L,
 57 |     0x5e9f46bfL, 0x5a5e5b08L, 0x571d7dd1L, 0x53dc6066L,
 58 |     0x4d9b3063L, 0x495a2dd4L, 0x44190b0dL, 0x40d816baL,
 59 |     0xaca5c697L, 0xa864db20L, 0xa527fdf9L, 0xa1e6e04eL,
 60 |     0xbfa1b04bL, 0xbb60adfcL, 0xb6238b25L, 0xb2e29692L,
 61 |     0x8aad2b2fL, 0x8e6c3698L, 0x832f1041L, 0x87ee0df6L,
 62 |     0x99a95df3L, 0x9d684044L, 0x902b669dL, 0x94ea7b2aL,
 63 |     0xe0b41de7L, 0xe4750050L, 0xe9362689L, 0xedf73b3eL,
 64 |     0xf3b06b3bL, 0xf771768cL, 0xfa325055L, 0xfef34de2L,
 65 |     0xc6bcf05fL, 0xc27dede8L, 0xcf3ecb31L, 0xcbffd686L,
 66 |     0xd5b88683L, 0xd1799b34L, 0xdc3abdedL, 0xd8fba05aL,
 67 |     0x690ce0eeL, 0x6dcdfd59L, 0x608edb80L, 0x644fc637L,
 68 |     0x7a089632L, 0x7ec98b85L, 0x738aad5cL, 0x774bb0ebL,
 69 |     0x4f040d56L, 0x4bc510e1L, 0x46863638L, 0x42472b8fL,
 70 |     0x5c007b8aL, 0x58c1663dL, 0x558240e4L, 0x51435d53L,
 71 |     0x251d3b9eL, 0x21dc2629L, 0x2c9f00f0L, 0x285e1d47L,
 72 |     0x36194d42L, 0x32d850f5L, 0x3f9b762cL, 0x3b5a6b9bL,
 73 |     0x0315d626L, 0x07d4cb91L, 0x0a97ed48L, 0x0e56f0ffL,
 74 |     0x1011a0faL, 0x14d0bd4dL, 0x19939b94L, 0x1d528623L,
 75 |     0xf12f560eL, 0xf5ee4bb9L, 0xf8ad6d60L, 0xfc6c70d7L,
 76 |     0xe22b20d2L, 0xe6ea3d65L, 0xeba91bbcL, 0xef68060bL,
 77 |     0xd727bbb6L, 0xd3e6a601L, 0xdea580d8L, 0xda649d6fL,
 78 |     0xc423cd6aL, 0xc0e2d0ddL, 0xcda1f604L, 0xc960ebb3L,
 79 |     0xbd3e8d7eL, 0xb9ff90c9L, 0xb4bcb610L, 0xb07daba7L,
 80 |     0xae3afba2L, 0xaafbe615L, 0xa7b8c0ccL, 0xa379dd7bL,
 81 |     0x9b3660c6L, 0x9ff77d71L, 0x92b45ba8L, 0x9675461fL,
 82 |     0x8832161aL, 0x8cf30badL, 0x81b02d74L, 0x857130c3L,
 83 |     0x5d8a9099L, 0x594b8d2eL, 0x5408abf7L, 0x50c9b640L,
 84 |     0x4e8ee645L, 0x4a4ffbf2L, 0x470cdd2bL, 0x43cdc09cL,
 85 |     0x7b827d21L, 0x7f436096L, 0x7200464fL, 0x76c15bf8L,
 86 |     0x68860bfdL, 0x6c47164aL, 0x61043093L, 0x65c52d24L,
 87 |     0x119b4be9L, 0x155a565eL, 0x18197087L, 0x1cd86d30L,
 88 |     0x029f3d35L, 0x065e2082L, 0x0b1d065bL, 0x0fdc1becL,
 89 |     0x3793a651L, 0x3352bbe6L, 0x3e119d3fL, 0x3ad08088L,
 90 |     0x2497d08dL, 0x2056cd3aL, 0x2d15ebe3L, 0x29d4f654L,
 91 |     0xc5a92679L, 0xc1683bceL, 0xcc2b1d17L, 0xc8ea00a0L,
 92 |     0xd6ad50a5L, 0xd26c4d12L, 0xdf2f6bcbL, 0xdbee767cL,
 93 |     0xe3a1cbc1L, 0xe760d676L, 0xea23f0afL, 0xeee2ed18L,
 94 |     0xf0a5bd1dL, 0xf464a0aaL, 0xf9278673L, 0xfde69bc4L,
 95 |     0x89b8fd09L, 0x8d79e0beL, 0x803ac667L, 0x84fbdbd0L,
 96 |     0x9abc8bd5L, 0x9e7d9662L, 0x933eb0bbL, 0x97ffad0cL,
 97 |     0xafb010b1L, 0xab710d06L, 0xa6322bdfL, 0xa2f33668L,
 98 |     0xbcb4666dL, 0xb8757bdaL, 0xb5365d03L, 0xb1f740b4L
 99 | };
100 | 
101 | 
102 | /*-------------------------------------------------------------*/
103 | /*--- end                                        crctable.c ---*/
104 | /*-------------------------------------------------------------*/
105 | 


--------------------------------------------------------------------------------
/src/Bzip2/dlltest.c:
--------------------------------------------------------------------------------
  1 | /*
  2 |   minibz2
  3 |   libbz2.dll test program.
  4 |   by Yoshioka Tsuneo (tsuneo@rr.iij4u.or.jp)
  5 |   This file is Public Domain.  Welcome any email to me.
  6 | 
  7 |   usage: minibz2 [-d] [-{1,2,..9}] [[srcfilename] destfilename]
  8 | */
  9 | 
 10 | #define BZ_IMPORT
 11 | #include <stdio.h>
 12 | #include <stdlib.h>
 13 | #include "bzlib.h"
 14 | #ifdef _WIN32
 15 | #include <io.h>
 16 | #endif
 17 | 
 18 | 
 19 | #ifdef _WIN32
 20 | 
 21 | #define BZ2_LIBNAME "libbz2-1.0.2.DLL" 
 22 | 
 23 | #include <windows.h>
 24 | static int BZ2DLLLoaded = 0;
 25 | static HINSTANCE BZ2DLLhLib;
 26 | int BZ2DLLLoadLibrary(void)
 27 | {
 28 |     HINSTANCE hLib;
 29 | 
 30 |     if(BZ2DLLLoaded==1){return 0;}
 31 |     hLib=LoadLibrary(BZ2_LIBNAME);
 32 |     if(hLib == NULL){
 33 |         fprintf(stderr,"Can't load %s\n",BZ2_LIBNAME);
 34 |         return -1;
 35 |     }
 36 |     BZ2_bzlibVersion=GetProcAddress(hLib,"BZ2_bzlibVersion");
 37 |     BZ2_bzopen=GetProcAddress(hLib,"BZ2_bzopen");
 38 |     BZ2_bzdopen=GetProcAddress(hLib,"BZ2_bzdopen");
 39 |     BZ2_bzread=GetProcAddress(hLib,"BZ2_bzread");
 40 |     BZ2_bzwrite=GetProcAddress(hLib,"BZ2_bzwrite");
 41 |     BZ2_bzflush=GetProcAddress(hLib,"BZ2_bzflush");
 42 |     BZ2_bzclose=GetProcAddress(hLib,"BZ2_bzclose");
 43 |     BZ2_bzerror=GetProcAddress(hLib,"BZ2_bzerror");
 44 | 
 45 |     if (!BZ2_bzlibVersion || !BZ2_bzopen || !BZ2_bzdopen
 46 |         || !BZ2_bzread || !BZ2_bzwrite || !BZ2_bzflush
 47 |         || !BZ2_bzclose || !BZ2_bzerror) {
 48 |         fprintf(stderr,"GetProcAddress failed.\n");
 49 |         return -1;
 50 |     }
 51 |     BZ2DLLLoaded=1;
 52 |     BZ2DLLhLib=hLib;
 53 |     return 0;
 54 | 
 55 | }
 56 | int BZ2DLLFreeLibrary(void)
 57 | {
 58 |     if(BZ2DLLLoaded==0){return 0;}
 59 |     FreeLibrary(BZ2DLLhLib);
 60 |     BZ2DLLLoaded=0;
 61 | }
 62 | #endif /* WIN32 */
 63 | 
 64 | void usage(void)
 65 | {
 66 |     puts("usage: minibz2 [-d] [-{1,2,..9}] [[srcfilename] destfilename]");
 67 | }
 68 | /*
 69 |   int main(int argc,char *argv[])
 70 |   {
 71 |   int decompress = 0;
 72 |   int level = 9;
 73 |   char *fn_r = NULL;
 74 |   char *fn_w = NULL;
 75 | 
 76 |   #ifdef _WIN32
 77 |   if(BZ2DLLLoadLibrary()<0){
 78 |   fprintf(stderr,"Loading of %s failed.  Giving up.\n", BZ2_LIBNAME);
 79 |   exit(1);
 80 |   }
 81 |   printf("Loading of %s succeeded.  Library version is %s.\n",
 82 |   BZ2_LIBNAME, BZ2_bzlibVersion() );
 83 |   #endif
 84 |   while(++argv,--argc){
 85 |   if(**argv =='-' || **argv=='/'){
 86 |   char *p;
 87 | 
 88 |   for(p=*argv+1;*p;p++){
 89 |   if(*p=='d'){
 90 |   decompress = 1;
 91 |   }else if('1'<=*p && *p<='9'){
 92 |   level = *p - '0';
 93 |   }else{
 94 |   usage();
 95 |   exit(1);
 96 |   }
 97 |   }
 98 |   }else{
 99 |   break;
100 |   }
101 |   }
102 |   if(argc>=1){
103 |   fn_r = *argv;
104 |   argc--;argv++;
105 |   }else{
106 |   fn_r = NULL;
107 |   }
108 |   if(argc>=1){
109 |   fn_w = *argv;
110 |   argc--;argv++;
111 |   }else{
112 |   fn_w = NULL;
113 |   }
114 |   {
115 |   int len;
116 |   char buff[0x1000];
117 |   char mode[10];
118 | 
119 |   if(decompress){
120 |   BZFILE *BZ2fp_r = NULL;
121 |   FILE *fp_w = NULL;
122 | 
123 |   if(fn_w){
124 |   if((fp_w = fopen(fn_w,"wb"))==NULL){
125 |   printf("can't open [%s]\n",fn_w);
126 |   perror("reason:");
127 |   exit(1);
128 |   }
129 |   }else{
130 |   fp_w = stdout;
131 |   }
132 |   if((fn_r == NULL && (BZ2fp_r = BZ2_bzdopen(fileno(stdin),"rb"))==NULL)
133 |   || (fn_r != NULL && (BZ2fp_r = BZ2_bzopen(fn_r,"rb"))==NULL)){
134 |   printf("can't bz2openstream\n");
135 |   exit(1);
136 |   }
137 |   while((len=BZ2_bzread(BZ2fp_r,buff,0x1000))>0){
138 |   fwrite(buff,1,len,fp_w);
139 |   }
140 |   BZ2_bzclose(BZ2fp_r);
141 |   if(fp_w != stdout) fclose(fp_w);
142 |   }else{
143 |   BZFILE *BZ2fp_w = NULL;
144 |   FILE *fp_r = NULL;
145 | 
146 |   if(fn_r){
147 |   if((fp_r = fopen(fn_r,"rb"))==NULL){
148 |   printf("can't open [%s]\n",fn_r);
149 |   perror("reason:");
150 |   exit(1);
151 |   }
152 |   }else{
153 |   fp_r = stdin;
154 |   }
155 |   mode[0]='w';
156 |   mode[1] = '0' + level;
157 |   mode[2] = '\0';
158 | 
159 |   if((fn_w == NULL && (BZ2fp_w = BZ2_bzdopen(fileno(stdout),mode))==NULL)
160 |   || (fn_w !=NULL && (BZ2fp_w = BZ2_bzopen(fn_w,mode))==NULL)){
161 |   printf("can't bz2openstream\n");
162 |   exit(1);
163 |   }
164 |   while((len=fread(buff,1,0x1000,fp_r))>0){
165 |   BZ2_bzwrite(BZ2fp_w,buff,len);
166 |   }
167 |   BZ2_bzclose(BZ2fp_w);
168 |   if(fp_r!=stdin)fclose(fp_r);
169 |   }
170 |   }
171 |   #ifdef _WIN32
172 |   BZ2DLLFreeLibrary();
173 |   #endif
174 |   return 0;
175 |   }
176 | */
177 | 
178 | 
179 | 


--------------------------------------------------------------------------------
/src/Bzip2/mk251.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /* Spew out a long sequence of the byte 251.  When fed to bzip2
 3 |    versions 1.0.0 or 1.0.1, causes it to die with internal error
 4 |    1007 in blocksort.c.  This assertion misses an extremely rare
 5 |    case, which is fixed in this version (1.0.2) and above.
 6 | */
 7 | 
 8 | /* ------------------------------------------------------------------
 9 |    This file is part of bzip2/libbzip2, a program and library for
10 |    lossless, block-sorting data compression.
11 | 
12 |    bzip2/libbzip2 version 1.0.5 of 10 December 2007
13 |    Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
14 | 
15 |    Please read the WARNING, DISCLAIMER and PATENTS sections in the 
16 |    README file.
17 | 
18 |    This program is released under the terms of the license contained
19 |    in the file LICENSE.
20 |    ------------------------------------------------------------------ */
21 | 
22 | 
23 | #include <stdio.h>
24 | /*
25 |   int main ()
26 |   {
27 |   int i;
28 |   for (i = 0; i < 48500000 ; i++)
29 |   putchar(251);
30 |   return 0;
31 |   }
32 | */
33 | 
34 | 
35 | 


--------------------------------------------------------------------------------
/src/Bzip2/randtable.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /*-------------------------------------------------------------*/
 3 | /*--- Table for randomising repetitive blocks               ---*/
 4 | /*---                                           randtable.c ---*/
 5 | /*-------------------------------------------------------------*/
 6 | 
 7 | /* ------------------------------------------------------------------
 8 |    This file is part of bzip2/libbzip2, a program and library for
 9 |    lossless, block-sorting data compression.
10 | 
11 |    bzip2/libbzip2 version 1.0.5 of 10 December 2007
12 |    Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
13 | 
14 |    Please read the WARNING, DISCLAIMER and PATENTS sections in the 
15 |    README file.
16 | 
17 |    This program is released under the terms of the license contained
18 |    in the file LICENSE.
19 |    ------------------------------------------------------------------ */
20 | 
21 | 
22 | #include "bzlib_private.h"
23 | 
24 | 
25 | /*---------------------------------------------*/
26 | Int32 BZ2_rNums[512] = { 
27 |     619, 720, 127, 481, 931, 816, 813, 233, 566, 247, 
28 |     985, 724, 205, 454, 863, 491, 741, 242, 949, 214, 
29 |     733, 859, 335, 708, 621, 574, 73, 654, 730, 472, 
30 |     419, 436, 278, 496, 867, 210, 399, 680, 480, 51, 
31 |     878, 465, 811, 169, 869, 675, 611, 697, 867, 561, 
32 |     862, 687, 507, 283, 482, 129, 807, 591, 733, 623, 
33 |     150, 238, 59, 379, 684, 877, 625, 169, 643, 105, 
34 |     170, 607, 520, 932, 727, 476, 693, 425, 174, 647, 
35 |     73, 122, 335, 530, 442, 853, 695, 249, 445, 515, 
36 |     909, 545, 703, 919, 874, 474, 882, 500, 594, 612, 
37 |     641, 801, 220, 162, 819, 984, 589, 513, 495, 799, 
38 |     161, 604, 958, 533, 221, 400, 386, 867, 600, 782, 
39 |     382, 596, 414, 171, 516, 375, 682, 485, 911, 276, 
40 |     98, 553, 163, 354, 666, 933, 424, 341, 533, 870, 
41 |     227, 730, 475, 186, 263, 647, 537, 686, 600, 224, 
42 |     469, 68, 770, 919, 190, 373, 294, 822, 808, 206, 
43 |     184, 943, 795, 384, 383, 461, 404, 758, 839, 887, 
44 |     715, 67, 618, 276, 204, 918, 873, 777, 604, 560, 
45 |     951, 160, 578, 722, 79, 804, 96, 409, 713, 940, 
46 |     652, 934, 970, 447, 318, 353, 859, 672, 112, 785, 
47 |     645, 863, 803, 350, 139, 93, 354, 99, 820, 908, 
48 |     609, 772, 154, 274, 580, 184, 79, 626, 630, 742, 
49 |     653, 282, 762, 623, 680, 81, 927, 626, 789, 125, 
50 |     411, 521, 938, 300, 821, 78, 343, 175, 128, 250, 
51 |     170, 774, 972, 275, 999, 639, 495, 78, 352, 126, 
52 |     857, 956, 358, 619, 580, 124, 737, 594, 701, 612, 
53 |     669, 112, 134, 694, 363, 992, 809, 743, 168, 974, 
54 |     944, 375, 748, 52, 600, 747, 642, 182, 862, 81, 
55 |     344, 805, 988, 739, 511, 655, 814, 334, 249, 515, 
56 |     897, 955, 664, 981, 649, 113, 974, 459, 893, 228, 
57 |     433, 837, 553, 268, 926, 240, 102, 654, 459, 51, 
58 |     686, 754, 806, 760, 493, 403, 415, 394, 687, 700, 
59 |     946, 670, 656, 610, 738, 392, 760, 799, 887, 653, 
60 |     978, 321, 576, 617, 626, 502, 894, 679, 243, 440, 
61 |     680, 879, 194, 572, 640, 724, 926, 56, 204, 700, 
62 |     707, 151, 457, 449, 797, 195, 791, 558, 945, 679, 
63 |     297, 59, 87, 824, 713, 663, 412, 693, 342, 606, 
64 |     134, 108, 571, 364, 631, 212, 174, 643, 304, 329, 
65 |     343, 97, 430, 751, 497, 314, 983, 374, 822, 928, 
66 |     140, 206, 73, 263, 980, 736, 876, 478, 430, 305, 
67 |     170, 514, 364, 692, 829, 82, 855, 953, 676, 246, 
68 |     369, 970, 294, 750, 807, 827, 150, 790, 288, 923, 
69 |     804, 378, 215, 828, 592, 281, 565, 555, 710, 82, 
70 |     896, 831, 547, 261, 524, 462, 293, 465, 502, 56, 
71 |     661, 821, 976, 991, 658, 869, 905, 758, 745, 193, 
72 |     768, 550, 608, 933, 378, 286, 215, 979, 792, 961, 
73 |     61, 688, 793, 644, 986, 403, 106, 366, 905, 644, 
74 |     372, 567, 466, 434, 645, 210, 389, 550, 919, 135, 
75 |     780, 773, 635, 389, 707, 100, 626, 958, 165, 504, 
76 |     920, 176, 193, 713, 857, 265, 203, 50, 668, 108, 
77 |     645, 990, 626, 197, 510, 357, 358, 850, 858, 364, 
78 |     936, 638
79 | };
80 | 
81 | 
82 | /*-------------------------------------------------------------*/
83 | /*--- end                                       randtable.c ---*/
84 | /*-------------------------------------------------------------*/
85 | 
86 | 


--------------------------------------------------------------------------------
/src/Bzip2/spewG.c:
--------------------------------------------------------------------------------
 1 | 
 2 | /* spew out a thoroughly gigantic file designed so that bzip2
 3 |    can compress it reasonably rapidly.  This is to help test
 4 |    support for large files (> 2GB) in a reasonable amount of time.
 5 |    I suggest you use the undocumented --exponential option to
 6 |    bzip2 when compressing the resulting file; this saves a bit of
 7 |    time.  Note: *don't* bother with --exponential when compressing 
 8 |    Real Files; it'll just waste a lot of CPU time :-)
 9 |    (but is otherwise harmless).
10 | */
11 | 
12 | /* ------------------------------------------------------------------
13 |    This file is part of bzip2/libbzip2, a program and library for
14 |    lossless, block-sorting data compression.
15 | 
16 |    bzip2/libbzip2 version 1.0.5 of 10 December 2007
17 |    Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
18 | 
19 |    Please read the WARNING, DISCLAIMER and PATENTS sections in the 
20 |    README file.
21 | 
22 |    This program is released under the terms of the license contained
23 |    in the file LICENSE.
24 |    ------------------------------------------------------------------ */
25 | 
26 | 
27 | #define _FILE_OFFSET_BITS 64
28 | 
29 | #include <stdio.h>
30 | #include <stdlib.h>
31 | 
32 | /* The number of megabytes of junk to spew out (roughly) */
33 | #define MEGABYTES 5000
34 | 
35 | #define N_BUF 1000000
36 | char buf[N_BUF];
37 | 
38 | /*
39 |   int main ( int argc, char** argv )
40 |   {
41 |   int ii, kk, p;
42 |   srandom(1);
43 |   setbuffer ( stdout, buf, N_BUF );
44 |   for (kk = 0; kk < MEGABYTES * 515; kk+=3) {
45 |   p = 25+random()%50;
46 |   for (ii = 0; ii < p; ii++)
47 |   printf ( "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" );
48 |   for (ii = 0; ii < p-1; ii++)
49 |   printf ( "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb" );
50 |   for (ii = 0; ii < p+1; ii++)
51 |   printf ( "ccccccccccccccccccccccccccccccccccccc" );
52 |   }
53 |   fflush(stdout);
54 |   return 0;
55 |   }
56 | */
57 | 
58 | 


--------------------------------------------------------------------------------
/src/Bzip2/unzcrash.c:
--------------------------------------------------------------------------------
  1 | 
  2 | /* A test program written to test robustness to decompression of
  3 |    corrupted data.  Usage is 
  4 |    unzcrash filename
  5 |    and the program will read the specified file, compress it (in memory),
  6 |    and then repeatedly decompress it, each time with a different bit of
  7 |    the compressed data inverted, so as to test all possible one-bit errors.
  8 |    This should not cause any invalid memory accesses.  If it does, 
  9 |    I want to know about it!
 10 | 
 11 |    PS.  As you can see from the above description, the process is
 12 |    incredibly slow.  A file of size eg 5KB will cause it to run for
 13 |    many hours.
 14 | */
 15 | 
 16 | /* ------------------------------------------------------------------
 17 |    This file is part of bzip2/libbzip2, a program and library for
 18 |    lossless, block-sorting data compression.
 19 | 
 20 |    bzip2/libbzip2 version 1.0.5 of 10 December 2007
 21 |    Copyright (C) 1996-2007 Julian Seward <jseward@bzip.org>
 22 | 
 23 |    Please read the WARNING, DISCLAIMER and PATENTS sections in the 
 24 |    README file.
 25 | 
 26 |    This program is released under the terms of the license contained
 27 |    in the file LICENSE.
 28 |    ------------------------------------------------------------------ */
 29 | 
 30 | 
 31 | #include <stdio.h>
 32 | #include <assert.h>
 33 | #include "bzlib.h"
 34 | 
 35 | #define M_BLOCK 1000000
 36 | 
 37 | typedef unsigned char uchar;
 38 | 
 39 | #define M_BLOCK_OUT (M_BLOCK + 1000000)
 40 | uchar inbuf[M_BLOCK];
 41 | uchar outbuf[M_BLOCK_OUT];
 42 | uchar zbuf[M_BLOCK + 600 + (M_BLOCK / 100)];
 43 | 
 44 | int nIn, nOut, nZ;
 45 | 
 46 | static char *bzerrorstrings[] = {
 47 |     "OK"
 48 |     ,"SEQUENCE_ERROR"
 49 |     ,"PARAM_ERROR"
 50 |     ,"MEM_ERROR"
 51 |     ,"DATA_ERROR"
 52 |     ,"DATA_ERROR_MAGIC"
 53 |     ,"IO_ERROR"
 54 |     ,"UNEXPECTED_EOF"
 55 |     ,"OUTBUFF_FULL"
 56 |     ,"???"   /* for future */
 57 |     ,"???"   /* for future */
 58 |     ,"???"   /* for future */
 59 |     ,"???"   /* for future */
 60 |     ,"???"   /* for future */
 61 |     ,"???"   /* for future */
 62 | };
 63 | 
 64 | void flip_bit ( int bit )
 65 | {
 66 |     int byteno = bit / 8;
 67 |     int bitno  = bit % 8;
 68 |     uchar mask = 1 << bitno;
 69 |     //fprintf ( stderr, "(byte %d  bit %d  mask %d)",
 70 |     //          byteno, bitno, (int)mask );
 71 |     zbuf[byteno] ^= mask;
 72 | }
 73 | /*
 74 |   int main ( int argc, char** argv )
 75 |   {
 76 |   FILE* f;
 77 |   int   r;
 78 |   int   bit;
 79 |   int   i;
 80 | 
 81 |   if (argc != 2) {
 82 |   fprintf ( stderr, "usage: unzcrash filename\n" );
 83 |   return 1;
 84 |   }
 85 | 
 86 |   f = fopen ( argv[1], "r" );
 87 |   if (!f) {
 88 |   fprintf ( stderr, "unzcrash: can't open %s\n", argv[1] );
 89 |   return 1;
 90 |   }
 91 | 
 92 |   nIn = fread ( inbuf, 1, M_BLOCK, f );
 93 |   fprintf ( stderr, "%d bytes read\n", nIn );
 94 | 
 95 |   nZ = M_BLOCK;
 96 |   r = BZ2_bzBuffToBuffCompress (
 97 |   zbuf, &nZ, inbuf, nIn, 9, 0, 30 );
 98 | 
 99 |   assert (r == BZ_OK);
100 |   fprintf ( stderr, "%d after compression\n", nZ );
101 | 
102 |   for (bit = 0; bit < nZ*8; bit++) {
103 |   fprintf ( stderr, "bit %d  ", bit );
104 |   flip_bit ( bit );
105 |   nOut = M_BLOCK_OUT;
106 |   r = BZ2_bzBuffToBuffDecompress (
107 |   outbuf, &nOut, zbuf, nZ, 0, 0 );
108 |   fprintf ( stderr, " %d  %s ", r, bzerrorstrings[-r] );
109 | 
110 |   if (r != BZ_OK) {
111 |   fprintf ( stderr, "\n" );
112 |   } else {
113 |   if (nOut != nIn) {
114 |   fprintf(stderr, "nIn/nOut mismatch %d %d\n", nIn, nOut );
115 |   return 1;
116 |   } else {
117 |   for (i = 0; i < nOut; i++)
118 |   if (inbuf[i] != outbuf[i]) { 
119 |   fprintf(stderr, "mismatch at %d\n", i ); 
120 |   return 1; 
121 |   }
122 |   if (i == nOut) fprintf(stderr, "really ok!\n" );
123 |   }
124 |   }
125 | 
126 |   flip_bit ( bit );
127 |   }
128 | 
129 |   #if 0
130 |   assert (nOut == nIn);
131 |   for (i = 0; i < nOut; i++) {
132 |   if (inbuf[i] != outbuf[i]) {
133 |   fprintf ( stderr, "difference at %d !\n", i );
134 |   return 1;
135 |   }
136 |   }
137 |   #endif
138 | 
139 |   fprintf ( stderr, "all ok\n" );
140 |   return 0;
141 |   }
142 | */
143 | 
144 | 
145 | 


--------------------------------------------------------------------------------
/src/Classifiers/ExampleResults.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "Classifiers/ExampleResults.h"
35 | #include "Utils/Utils.h" // for nor_utils::comparePairOnSecond
36 | #include <cassert>
37 | #include <functional> // for greater
38 | #include <algorithm> // for sort
39 | 
40 | namespace MultiBoost {
41 | 
42 | // -------------------------------------------------------------------------
43 | // -------------------------------------------------------------------------
44 | 
45 |     pair<int, AlphaReal> ExampleResults::getWinner(int rank)
46 |     {
47 |         assert(rank >= 0);
48 | 
49 |         vector< pair<int, AlphaReal> > rankedList;
50 |         getRankedList(rankedList); // get the sorted rankings
51 |         return rankedList[rank];
52 |     }
53 | 
54 | // -------------------------------------------------------------------------
55 | 
56 |     bool ExampleResults::isWinner(const Example& example, int atLeastRank) const
57 |     {
58 |         assert(atLeastRank >= 0);
59 | 
60 |         vector< pair<int, AlphaReal> > rankedList;
61 |         getRankedList(rankedList); // get the sorted rankings
62 | 
63 |         for (int i = 0; i <= atLeastRank; ++i)
64 |         {
65 |             if ( example.hasPositiveLabel(rankedList[i].first) )
66 |                 return true;
67 |         }
68 | 
69 |         return false;
70 |     }
71 | 
72 | // -------------------------------------------------------------------------
73 | 
74 |     void ExampleResults::getRankedList( vector< pair<int, AlphaReal> >& rankedList ) const
75 |     {
76 |         rankedList.resize( _votesVector.size() );
77 | 
78 |         vector<AlphaReal>::const_iterator vIt;
79 |         const vector<AlphaReal>::const_iterator votesVectorEnd = _votesVector.end();
80 |         int i;
81 |         for (vIt = _votesVector.begin(), i = 0; vIt != votesVectorEnd; ++vIt, ++i )
82 |             rankedList[i] = make_pair(i, *vIt);
83 | 
84 |         sort( rankedList.begin(), rankedList.end(), 
85 |               nor_utils::comparePair<2, int, AlphaReal, greater<AlphaReal> >() );
86 |     }
87 | 
88 | // -------------------------------------------------------------------------
89 | 
90 | } // end of namespace MultiBoost
91 | 


--------------------------------------------------------------------------------
/src/Classifiers/ExampleResults.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | #ifndef __EXAMPLE_RESULTS_H
 35 | #define __EXAMPLE_RESULTS_H
 36 | 
 37 | #include <vector>
 38 | #include "Others/Example.h" // for Example
 39 | 
 40 | using namespace std;
 41 | 
 42 | //////////////////////////////////////////////////////////////////////////////////////////////
 43 | //////////////////////////////////////////////////////////////////////////////////////////////
 44 | 
 45 | namespace MultiBoost {
 46 | 
 47 | /**
 48 |  * Holds the results per example.
 49 |  * This class holds all the results obtained with computeResults(), 
 50 |  * which is equivalent to \f${\bf g}(x)\f$. It also offers two methods
 51 |  * that allow the quick evaluation of the results.
 52 |  * \date 16/11/2005
 53 |  */
 54 |     class ExampleResults 
 55 |     {
 56 |     public:
 57 | 
 58 |         /**
 59 |          * The constructor. Initialize the index and the votes vector.
 60 |          * \param idx The index of the example.
 61 |          * \param numClasses The number of classes.
 62 |          * \date 16/11/2005
 63 |          */
 64 |     ExampleResults(const int idx, const int numClasses) 
 65 |         : _idx(idx), _votesVector(numClasses, 0) {}
 66 | 
 67 |         const int getIdx() { return _idx; }
 68 | 
 69 |         vector<AlphaReal>& getVotesVector() { return _votesVector; }
 70 | 
 71 |         /**
 72 |          * Get the winner. 
 73 |          * \param rank The rank. 0 = winner. 1 = second, etc..
 74 |          * \return A pair <\f$\ell\f$, \f$g_\ell(x)\f$>, where \f$\ell\f$ is the class index.
 75 |          * \date 16/11/2005
 76 |          */
 77 |         pair<int, AlphaReal> getWinner(int rank = 0);
 78 | 
 79 |         /**
 80 |          * Checks if the given class is the winner class.
 81 |          * Example: if the ranking is 5 2 6 3 1 4 (in class indexes):
 82 |          * \code
 83 |          * isWinner(5,0); // -> true
 84 |          * isWinner(2,0); // -> false
 85 |          * isWinner(2,1); // -> true
 86 |          * isWinner(3,3); // -> true
 87 |          * \endcode
 88 |          * \param idxRealClass The index of the actual class.
 89 |          * \param atLeastRank The maximum rank in which the class must be
 90 |          * to be considered a "winner".
 91 |          * \date 16/11/2005
 92 |          */
 93 |         bool isWinner(const Example& example, int atLeastRank = 0) const;
 94 | 
 95 |     private:
 96 | 
 97 |         /**
 98 |          * Create a sorted ranking list. It uses votesVector to build a vector
 99 |          * of pairs that contains the index of the class and the value of the votes
100 |          * (that is a vector of <\f$\ell\f$, \f$g_\ell(x)\f$>), which is sorted
101 |          * by the second element, resulting in a ranking of the votes per class.
102 |          * \param rankedList the vector that will be filled with the rankings.
103 |          * \date 16/11/2005
104 |          */
105 |         void getRankedList( vector< pair<int, AlphaReal> >& rankedList ) const;
106 | 
107 |         const int _idx; //!< The index of the example 
108 | 
109 |         /**
110 |          * The vector with the results. Equivalent to what returned by \f${\bf g}(x)\f$.
111 |          * \remark It is public because the methods of Classifier will access it
112 |          * directly.
113 |          */
114 |         vector<AlphaReal> _votesVector; 
115 |   
116 |         /**
117 |          * Fake assignment operator to avoid warning.
118 |          * \date 6/03/2006
119 |          */
120 |         ExampleResults& operator=( const ExampleResults& ) {return *this;}
121 | 
122 |     }; // ExampleResults
123 | 
124 | } // end of namespace MultiBoost
125 | 
126 | #endif // __EXAMPLE_RESULTS_H
127 | 


--------------------------------------------------------------------------------
/src/Classifiers/SoftCascadeClassifier.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | //
 34 | //  SoftCascadeClassifier.h
 35 | //  MultiBoost
 36 | //
 37 | 
 38 | #ifndef __SOFT_CASCADE_CLASSIFIER_H
 39 | #define __SOFT_CASCADE_CLASSIFIER_H
 40 | 
 41 | //includes
 42 | #include <string>
 43 | #include "Utils/Args.h"
 44 | #include "Defaults.h"
 45 | 
 46 | using namespace std;
 47 | 
 48 | namespace MultiBoost {
 49 |     
 50 |     //forward declarations
 51 |     class InputData;
 52 |     class BaseLearner;
 53 |     class OutputInfo;
 54 |     
 55 |     class SoftCascadeClassifier {
 56 |         
 57 |     public:
 58 |         
 59 |         /**
 60 |          * The constructor. It initializes the variable and set them using the
 61 |          * information provided by the arguments passed. They are parsed
 62 |          * using the helpers provided by class Args.
 63 |          * \param args The arguments defined by the user in the command line.
 64 |          * \param verbose The level of verbosity
 65 |          * \see _verbose
 66 |          * \date 01/07/2011
 67 |          */
 68 |         SoftCascadeClassifier(const nor_utils::Args& args, int verbose = 1);
 69 |         
 70 |         
 71 |         /**
 72 |          * Starts the classification process. 
 73 |          * \param dataFileName The file name of the data to be classified.
 74 |          * \param shypFileName The strong hypothesis filename. It is the xml file containing the
 75 |          * list of weak hypotheses that form the strong hypothesis.
 76 |          * \param outResFileName The name of the file in which the results of the classification
 77 |          * will be saved.
 78 |          * \param numRanksEnclosed This parameter defines the number of ranks to be printed.
 79 |          * \date 01/07/2011
 80 |          */
 81 |         void run(const string& dataFileName, const string& shypFileName, 
 82 |                  int numIterations, const string& outResFileName = "", 
 83 |                  int numRanksEnclosed = 2);
 84 | 
 85 |         /**
 86 |          * \param dataFileName The file name of the data to be classified.
 87 |          * \param shypFileName The strong hypothesis filename. It is the xml file containing the
 88 |          * list of weak hypotheses that form the strong hypothesis.
 89 |          * \param outResFileName The name of the file in which the results of the classification
 90 |          * will be saved.
 91 |          * \date 01/07/2011
 92 |          */
 93 |         void savePosteriors(const string& dataFileName, 
 94 |                             const string& shypFileName, 
 95 |                             const string& outFileName, 
 96 |                             int numIterations );
 97 |         
 98 |         
 99 |     protected:
100 |         /**
101 |          * Loads the data. It needs the Strong Hypothesis file because it needs
102 |          * the information about the weak learner used to generate it. The weak
103 |          * learner might have associated a special InputData derived class,
104 |          * which is returned by BaseLearner::createInputData() once the weak
105 |          * learner has been identified.
106 |          * \param dataFileName The file name of the data to be classified.
107 |          * \param shypFileName The strong hypothesis filename. It is the xml file containing the
108 |          * \warning The returned object must be destroyed by the caller.
109 |          * \date 01/07/2011
110 |          */
111 |         InputData* loadInputData(const string& dataFileName, const string& shypFileName);
112 |         
113 |         /**
114 |          * Print interation-wise information.
115 |          * \date 21/07/2011
116 |          */
117 |         void printOutputInfo(OutputInfo* pOutInfo, int t, 
118 |                              InputData* pData, 
119 |                              BaseLearner* pWeakHypothesis,
120 |                              AlphaReal r);
121 |         
122 |         
123 |         // internal structures
124 |         /**
125 |          * Defines the level of verbosity:
126 |          * - 0 = no messages
127 |          * - 1 = basic messages
128 |          * - 2 = show all messages
129 |          */
130 |         int      _verbose;
131 |         
132 |         const nor_utils::Args&  _args;  //!< The arguments defined by the user.
133 |         string   _outputInfoFile; //!< The filename of the step-by-step information file that will be updated 
134 |         
135 |         string  _positiveLabelName;
136 | 
137 |     private:
138 |         
139 |         /**
140 |          * Fake assignment operator to avoid warning.
141 |          * \date 6/12/2005
142 |          */
143 |         SoftCascadeClassifier& operator=( const SoftCascadeClassifier& ) {return *this;}
144 |         
145 | 
146 |     };
147 | 
148 | } // end of namespace MultiBoost
149 | 
150 | #endif // __SOFT_CASCADE_CLASSIFIER_H
151 | 


--------------------------------------------------------------------------------
/src/Defaults.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file Defaults.h
 36 |  * Defines macros and default values.
 37 |  * This file just holds some macros and static strings that define
 38 |  * some default values.
 39 |  * \date 11/11/2005
 40 |  */
 41 | 
 42 | #include <iomanip>
 43 | 
 44 | #ifndef __DEFAULTS_H
 45 | #define __DEFAULTS_H
 46 | 
 47 | static const char SHYP_NAME[] = "shyp"; //!< The default strong hypothesis file name
 48 | static const char SHYP_EXTENSION[] = "xml"; //!< The default strong hypothesis file name extension
 49 | static const char OUTPUT_NAME[] = "outputinfo.dta"; //!< The default outputinfo file name
 50 | 
 51 | static const char COMMENT[] = "Research code"; //!< Comment to put in the executable 
 52 | 
 53 | static const char defaultLearner[] = "SingleStumpLearner"; //!< The default weak learner
 54 | 
 55 | static const char defaultOutput[] = "e01"; //<! The default output type for OutputInfo
 56 | 
 57 | 
 58 | /**
 59 |  * The type definition of the values of features
 60 |  * \date 15/06/2011
 61 |  */
 62 | // TODO: the type of AlphaType should be set in the camake config file
 63 | #ifndef FEATUREREALDOUBLE
 64 | typedef float FeatureReal; // DEFAULT
 65 | #else //FEATUREREALDOUBLE
 66 | typedef double FeatureReal;
 67 | #endif //FEATUREREALDOUBLE
 68 | 
 69 | /**
 70 |  * The type definition of the following variables:
 71 |  * - \alpha : the coefficient of the base learners
 72 |  * - {\bf W}: the weight matrix elements
 73 |  * - \vec{v}: the vector \vec{v} 
 74 |  * \date 15/06/2011
 75 |  */
 76 | // TODO: the type of AlphaType should be set in the camake config file
 77 | #ifndef ALPHAREALFLOAT
 78 | typedef double AlphaReal; // DEFAULT
 79 | #else //ALPHAREALFLOAT
 80 | typedef float AlphaReal;
 81 | #endif //ALPHAREALFLOAT
 82 | 
 83 | /**
 84 |  * Defines the sorting method.
 85 |  * Columns needs to be sorted when using the decision stumps algorithm;
 86 |  * Generally conservativeness is not an issue with this type of algorithm
 87 |  * but because I want to get \b exactly the same results on win32 an unix, 
 88 |  * if I set non conservative sort, the outcome is different on the two.
 89 |  * \remarks The valid values are:
 90 |  * - 1 = slow but stable
 91 |  * - 0 = fast but non stable
 92 |  * \date 16/11/2005
 93 |  */
 94 | #define STABLE_SORT 0
 95 | 
 96 | /**
 97 |  * Debug level. If there is a problem try activating this.
 98 |  * \date 16/11/2005
 99 |  */ 
100 | #define MB_DEBUG 0
101 | 
102 | #define OUTPUT_SEPARATOR "\t" 
103 | #define HEADER_FIELD_LENGTH  "\t"
104 | //#define HEADER_FIELD_LENGTH  setiosflags(ios::left) << setw(7) 
105 | 
106 | #define S_(X) #X //!< Used with STRINGIZE can stringize a macro name
107 | #define STRINGIZE(X) S_(X) //!< Stringize a macro name! :)
108 | 
109 | #endif // __DEFAULTS_H
110 | 


--------------------------------------------------------------------------------
/src/IO/EncodeData.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #include "EncodeData.h"
35 | 
36 | 
37 | //
38 | namespace MultiBoost {
39 | 
40 | // ------------------------------------------------------------------------
41 | 
42 |     void EncodeData::resetData()
43 |     { 
44 |         _pData->clearRawData();
45 |     }
46 | 
47 | 
48 | // ------------------------------------------------------------------------
49 | 
50 |     void EncodeData::addExample(Example example)
51 |     { 
52 |         _pData->addExample( example );
53 |     }
54 | 
55 | } // end of namespace MultiBoost
56 | 


--------------------------------------------------------------------------------
/src/IO/EncodeData.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | /**
35 |  * \file AddlayerData.h Input data with additional manipulation possibilities for
36 |  * the --encode option.
37 |  */
38 | 
39 | #ifndef __ENCODE_DATA_H
40 | #define __ENCODE_DATA_H
41 | 
42 | #include "IO/InputData.h"
43 | 
44 | #include <vector>
45 | #include <utility> // for pair
46 | 
47 | using namespace std;
48 | 
49 | namespace MultiBoost {
50 | 
51 | //////////////////////////////////////////////////////////////////////////////////////////////
52 | //////////////////////////////////////////////////////////////////////////////////////////////
53 | 
54 | /**
55 |  * Overloading of the InputData class to support the --encode option.
56 |  * \date 25/04/2007
57 |  */
58 |     class EncodeData : public InputData
59 |     {
60 |     public:
61 | 
62 |         /**
63 |          * The destructor. Must be declared (virtual) for the proper destruction of 
64 |          * the object.
65 |          * \date 25/04/2007
66 |          */
67 |         virtual ~EncodeData() {}
68 | 
69 |         /**
70 |          * Clear the _data field and set _numExamples to 0.
71 |          * \date 25/04/2007
72 |          */
73 |         void resetData();
74 | 
75 |         /**
76 |          * Push back an example to the _data field and increment _numExamples.
77 |          * Be careful: weight initialization is not done in this function.
78 |          * \date 25/04/2007
79 |          */
80 |         void addExample( Example example );
81 | 
82 |     };
83 | 
84 | } // end of namespace MultiBoost
85 | 
86 | #endif // __ENCODE_DATA_H
87 | 


--------------------------------------------------------------------------------
/src/IO/GenericParser.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file GenericParser.h Defines an abstract class for parsing files
 36 |  */
 37 | 
 38 | #ifndef __GENERIC_PARSER_H
 39 | #define __GENERIC_PARSER_H
 40 | 
 41 | #include <string>
 42 | #include <vector>
 43 | #include <algorithm>
 44 | 
 45 | #include "Others/Example.h"
 46 | #include "NameMap.h"
 47 | #include "InputData.h"
 48 | 
 49 | using namespace std;
 50 | 
 51 | namespace MultiBoost
 52 | {
 53 |         
 54 |     ////////////////////////////////////////////////////////////////
 55 |         
 56 |     class GenericParser 
 57 |     { 
 58 |     public:
 59 |         /**
 60 |          * The constructor. It initializes the data file and the header file.
 61 |          * \remark The data and label representation are set to dense by default.
 62 |          * \data 30/07/2011 
 63 |          */
 64 |     GenericParser(const string& fileName, const string& headerFileName)
 65 |         : _fileName(fileName), _headerFileName(headerFileName), 
 66 |             _dataRep(DR_DENSE), _labelRep(LR_DENSE), _hasWeigthInit(false) {}
 67 |                 
 68 |         /**
 69 |          * Abstract function for reading data.
 70 |          * \param examples The vector of examples to be filled up.
 71 |          * \param classMap The map which stores the class names.
 72 |          * \param enumMaps It stores the mapping of nominal values into natural numbers.
 73 |          * \param attributeNameMap The name of attributes given by the user.
 74 |          * \param attributeTypes The type of attributes, for example numerical or nominal. \see RawData::eAttributeType
 75 |          * \data 30/07/2011 
 76 |          */
 77 |         virtual void            readData(vector<Example>& examples, NameMap& classMap, 
 78 |                                          vector<NameMap>& enumMaps, NameMap& attributeNameMap,
 79 |                                          vector<RawData::eAttributeType>& attributeTypes) = 0;
 80 |                 
 81 |         /**
 82 |          * It retrurns the number of features. 
 83 |          * \remark It might be implemented here, and not as an abstract function.
 84 |          * \return The number of features.
 85 |          * \data 30/07/2011 
 86 |          */
 87 |         virtual int       getNumAttributes() const = 0;
 88 |                 
 89 |         /**
 90 |          * It gets the data representation, i.e. sparse or dense.
 91 |          * \return The type of data representation 
 92 |          * \data 30/07/2011              
 93 |          */
 94 |         const eDataRep    getDataRep()  const { return _dataRep; }
 95 |                 
 96 |         /**
 97 |          * It gets the label representation, i.e. sparse or dense.
 98 |          * \return The type of label representation 
 99 |          * \data 30/07/2011              
100 |          */             
101 |         const eLabelRep   getLabelRep() const { return _labelRep; }
102 |                                 
103 |         /**
104 |          * It gets whether there is an intial weighting or not.
105 |          * \remark Initial weights can be set only with sparse labels.
106 |          * \return If the user gave initial weights for the labels, it returns with true, othervise with false.
107 |          * \data 30/07/2011 
108 |          */
109 |         bool  hasWeightInitialized()    const { return _hasWeigthInit; }
110 | 
111 |         /** 
112 |          * Verbose Level for parsing stages
113 |          *
114 |          */
115 |         int _verboseLevel;
116 | 
117 |     protected:
118 |         /**
119 |          * The data file name.
120 |          * \data 30/07/2011 
121 |          */                             
122 |         const string& _fileName;
123 |                 
124 |         /**
125 |          * If there is given a separate header file then this variable stores its name.
126 |          * \data 30/07/2011 
127 |          */
128 |         const string& _headerFileName;
129 |                 
130 |         /**
131 |          * The data representation, i.e. sparse or dense.
132 |          * \data 30/07/2011 
133 |          */             
134 |         eDataRep      _dataRep;
135 |                 
136 |         /**
137 |          * The label representation.
138 |          * \data 30/07/2011 
139 |          */
140 |         eLabelRep     _labelRep;
141 |                 
142 |         /**
143 |          * In the case of sparse label representation the user is allowed to provide initial weigths for each label. 
144 |          * If the user do this this flag is set to true.
145 |          * \data 30/07/2011 
146 |          */
147 |         bool          _hasWeigthInit;
148 |         
149 | 
150 |     };
151 |         
152 |     ////////////////////////////////////////////////////////////////
153 |         
154 | };
155 | 
156 | #endif // __GENERIC_PARSER_H
157 | 


--------------------------------------------------------------------------------
/src/IO/InputData.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | // Indexes: i = loop on examples
 35 | //          j = loop on columns
 36 | //          l = loop on classes
 37 | 
 38 | #include <iostream> // for cerr
 39 | #include <algorithm> // for sort
 40 | #include <functional> // for less
 41 | #include <fstream>
 42 | 
 43 | #include "IO/TxtParser.h"
 44 | #include "IO/ArffParser.h"
 45 | 
 46 | #include "Utils/Utils.h" // for white_tabs
 47 | #include "IO/InputData.h"
 48 | 
 49 | //#include <cassert>
 50 | //#include <cmath>  //for fabs
 51 | 
 52 | //
 53 | namespace MultiBoost {
 54 |         
 55 |     // ------------------------------------------------------------------------
 56 |     
 57 |     
 58 |     void InputData::addExample( Example example ) { 
 59 |         
 60 |         int exampleIndex = _pData->getNumExample();
 61 |         
 62 |         _pData->addExample(example);
 63 |         const vector<Label> & labels = example.getLabels();
 64 |         vector<Label>::const_iterator lIt;
 65 |         
 66 |         for (lIt = labels.begin(); lIt != labels.end(); ++lIt) {
 67 |             if ( lIt->y > 0) {
 68 |                 _nExamplesPerClass[lIt->idx]++;
 69 |             }
 70 |         }
 71 |         
 72 |         this->_indirectIndices.push_back(exampleIndex);
 73 |         this->_rawIndices[exampleIndex] = this->_numExamples;
 74 |         
 75 |         this->_numExamples++;
 76 |         
 77 |         //why shouldn't we do the same direct update of _subset in loadIndexSet() ?
 78 |         _subset.push_back(example);
 79 |         
 80 |         //otherwise : _subsetAlreadyComputed = false;
 81 |     }
 82 |         
 83 |     // ------------------------------------------------------------------------
 84 |         
 85 |     int     InputData::loadIndexSet( set< int > ind ) {
 86 |         int i = 0;
 87 |         //upload the indirection
 88 |         for (int j = 0; j < this->_rawIndices.size(); j++) this->_rawIndices[j] = -1;
 89 | 
 90 |         map<int, int> tmpPointsPerClass;
 91 |                 
 92 |         for( set< int >::iterator it = ind.begin(); it != ind.end(); it++ ) {
 93 |             this->_indirectIndices[i] = *it;
 94 |             this->_rawIndices[*it] = i;
 95 |                         
 96 |             i++;
 97 |                         
 98 |             const vector<Label>& labels = _pData->getLabels( *it );
 99 |             vector<Label>::const_iterator lIt;
100 |                         
101 |             for (lIt = labels.begin(); lIt != labels.end(); ++lIt )
102 |             {
103 |                 switch ( this->_pData->getLabelRep() ) {
104 |                 case LR_DENSE:
105 |                     if ( lIt->y > 0 )
106 |                         tmpPointsPerClass[lIt->idx]++;
107 |                     break;
108 |                 case LR_SPARSE:
109 |                     if ( lIt->y > 0 )
110 |                         tmpPointsPerClass[lIt->idx]++;
111 |                     break;
112 |                 }
113 |             }
114 |         }
115 |                 
116 |         _nExamplesPerClass.clear();
117 |         for (int l = 0; l < this->_pData->getNumClasses(); ++l)
118 |             _nExamplesPerClass.push_back( tmpPointsPerClass[l] );
119 |                 
120 |                 
121 |         this->_numExamples = (int)ind.size();
122 |         
123 |         _subsetAlreadyComputed = false;
124 |         
125 |         return 0;
126 |     }
127 |         
128 |         
129 |     // ------------------------------------------------------------------------
130 |         
131 |     void InputData::clearIndexSet( void ) {
132 |                 
133 |         for( int i = 0; i < this->_pData->getNumExample(); i++ ) {
134 |             this->_indirectIndices[ i ] = i;
135 |             this->_rawIndices[ i ] = i;
136 |         }
137 |         this->_numExamples = this->_pData->getNumExample();
138 |                 
139 |         _nExamplesPerClass.clear();
140 |         _nExamplesPerClass = this->_pData->getExamplesPerClass();
141 |         
142 |         _subsetAlreadyComputed = false;
143 |     }
144 |         
145 | } // end of namespace MultiBoost
146 | 


--------------------------------------------------------------------------------
/src/IO/NameMap.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | #include "NameMap.h"
 35 | 
 36 | #include "Defaults.h" // for MB_DEBUG
 37 | #include <fstream> // for ifstream
 38 | #include <iostream> // for cerr
 39 | 
 40 | //////////////////////////////////////////////////////////////////////////////////////////////
 41 | //////////////////////////////////////////////////////////////////////////////////////////////
 42 | 
 43 | namespace MultiBoost {
 44 | 
 45 | // ------------------------------------------------------------------------
 46 | 
 47 |     int NameMap::addName(const string& name)
 48 |     {
 49 |         // if we haven't seen yet this name, add it to the mapping structures
 50 |         if ( _mapNameToIdx.find(name) == _mapNameToIdx.end() )
 51 |         {
 52 |             _mapNameToIdx[name] = _numRegNames;
 53 |             _mapIdxToName.push_back(name);
 54 |             ++_numRegNames;
 55 |         }
 56 |    
 57 |         return _mapNameToIdx[name];
 58 |     }
 59 | 
 60 | // ------------------------------------------------------------------------
 61 | 
 62 |     string NameMap::getNameFromIdx(int idx) const
 63 |     {
 64 | #if MB_DEBUG
 65 |         if ( idx >= _mapIdxToName.size() )
 66 |         {
 67 |             cerr << "ERROR: trying to map a name index that does not exists. The input file" << endl;
 68 |             cerr << "might not have all the names used for training. Make sure that all names" << endl;
 69 |             cerr << "(enum attributes, classes) are correctly enumerated in the *training* file." << endl;
 70 |             exit(1);
 71 |         }
 72 | #endif
 73 |         return _mapIdxToName[idx]; 
 74 |     }
 75 | 
 76 | // ------------------------------------------------------------------------
 77 | 
 78 |     int NameMap::getIdxFromName(const string& name) const
 79 |     { 
 80 | #if MB_DEBUG
 81 |         if ( _mapNameToIdx.find(name) == _mapNameToIdx.end() )
 82 |         {
 83 |             cerr << "ERROR: trying to map a name (" << name << ") that does not exists. The input file" << endl;
 84 |             cerr << "might not have all the names used for training. Make sure that all names" << endl;
 85 |             cerr << "(enum attributes, classes) are correctly enumerated in the *training* file." << endl;
 86 |             exit(1);
 87 |         }
 88 | #endif
 89 |         return _mapNameToIdx[name]; 
 90 |     }
 91 | 
 92 | // ------------------------------------------------------------------------
 93 | 
 94 |     void NameMap::clear( void ) {
 95 |         _mapIdxToName.clear();
 96 |         _mapNameToIdx.clear();
 97 |         _numRegNames = 0;
 98 |     }
 99 | 
100 | 
101 | // ------------------------------------------------------------------------
102 | 
103 | 
104 | } // end of namespace MultiBoost
105 | 
106 | 


--------------------------------------------------------------------------------
/src/IO/NameMap.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file NameMap.h The map of the names of classes and enum type attributes.
 36 |  */
 37 | 
 38 | #ifndef __NAME_MAP_H
 39 | #define __NAME_MAP_H
 40 | 
 41 | #include <string>
 42 | #include <vector>
 43 | #include <map>
 44 | #include <iostream>
 45 | 
 46 | using namespace std;
 47 | 
 48 | //////////////////////////////////////////////////////////////////////////////////////////////
 49 | //////////////////////////////////////////////////////////////////////////////////////////////
 50 | 
 51 | namespace MultiBoost {
 52 | 
 53 | /**
 54 |  * A class to represent name (classes, enum attributes) map.
 55 |  * Each name is mapped into an index for efficiency reasons.
 56 |  * \date 14/11/2005
 57 |  */
 58 |     class NameMap
 59 |     {
 60 |     public:
 61 | 
 62 |         /**
 63 |          * The constructor. It does noting but initializing some variables.
 64 |          * \date 19/04/2007
 65 |          */
 66 |     NameMap() : _numRegNames(0) {  }
 67 | 
 68 |         /**
 69 |          * Add a name to the registered list.
 70 |          * \param name The name to add.
 71 |          * \date 19/04/2007
 72 |          */
 73 |         int addName(const string& name);
 74 | 
 75 |         /**
 76 |          * Get the name using the index.
 77 |          * Example:
 78 |          * \code
 79 |          * getNameFromIdx(0); // -> "rock"
 80 |          * \endcode
 81 |          * \param idx The index of the name.
 82 |          * \date 19/04/2007
 83 |          */
 84 |         string getNameFromIdx(int idx) const; 
 85 | 
 86 |         /**
 87 |          * Get the index using the name
 88 |          * Example:
 89 |          * \code
 90 |          * getIdxFromName("rock"); // -> 0
 91 |          * \endcode
 92 |          * \param name The name.
 93 |          * \date 19/04/2007
 94 |          */
 95 |         int getIdxFromName(const string& name) const;
 96 | 
 97 |         int getNumNames() const { return _numRegNames; }   //!< Returns the number of names 
 98 | 
 99 |         void clear( void );
100 |     private:
101 |         /**
102 |          * Maps the internal index to the name: internal_index->name. 
103 |          * \see getNameFromIdx
104 |          * \date 19/04/2007
105 |          */
106 |         vector<string>   _mapIdxToName; 
107 | 
108 |         /**
109 |          * Maps the name to the internal index: name->internal_index.
110 |          * \see getIdxFromName
111 |          * \date 19/04/2007
112 |          */
113 |         mutable map<string, int> _mapNameToIdx;
114 | 
115 |         int _numRegNames; //!< The number of the names registered. 
116 |     };
117 | 
118 | } // end of namespace MultiBoost
119 | 
120 | #endif // NAME_MAP_H
121 | 
122 | 


--------------------------------------------------------------------------------
/src/IO/ParasiteData.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | /**
35 |  * \file ParasiteData.h Input data which has the column sorted.
36 |  */
37 | 
38 | #ifndef __PARASITE_DATA_H
39 | #define __PARASITE_DATA_H
40 | 
41 | #include "InputData.h"
42 | #include "WeakLearners/BaseLearner.h"
43 | 
44 | #include <vector>
45 | 
46 | using namespace std;
47 | 
48 | namespace MultiBoost {
49 | 
50 | //////////////////////////////////////////////////////////////////////////////////////////////
51 | //////////////////////////////////////////////////////////////////////////////////////////////
52 | 
53 | /**
54 |  * Overloading of the InputData class to support ParasiteLearner.
55 |  * it stores a pool of baselearners already learned
56 |  * \date 24/04/2007
57 |  */
58 |     class ParasiteData : public InputData
59 |     {
60 |     public:
61 | 
62 |         /**
63 |          * The destructor. Must be declared (virtual) for the proper destruction of 
64 |          * the object.
65 |          */
66 |         virtual ~ParasiteData() {}
67 | 
68 |         int getNumBaseLearners() const 
69 |         { return _baseLearners.size(); }   //!< Returns the number of base learners
70 | 
71 |         BaseLearner getBaseLearner(int i) const 
72 |         { return _baseLearners[i]; }   //!< Returns the number of base learners
73 | 
74 |         void addBaseLearner(const BaseLearner& baseLearner) 
75 |         { _baseLearners.push_back(baseLearner); }   //!< Returns the number of base learners
76 | 
77 |     protected:
78 | 
79 |         vector<BaseLearner>    _baseLearners; //!< the pool of base learners
80 | 
81 |     };
82 | 
83 | } // end of namespace MultiBoost
84 | 
85 | #endif // __PARASITE_DATA_H
86 | 


--------------------------------------------------------------------------------
/src/IO/SVMLightParser.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file SVMLightParser.h A parser for ARFF file format
 36 |  */
 37 | #pragma warning( disable : 4786 )
 38 | 
 39 | 
 40 | #ifndef __SVMLIGHT_PARSER_H
 41 | #define __SVMLIGHT_PARSER_H
 42 | 
 43 | #include <fstream>
 44 | #include <sstream>
 45 | #include "GenericParser.h"
 46 | #include "NameMap.h"
 47 | #include "InputData.h"
 48 | #include "Utils/ClassHierarchy.h"
 49 | 
 50 | using namespace std;
 51 | 
 52 | namespace MultiBoost {
 53 |         
 54 |     class SVMLightParser : public GenericParser
 55 |     {
 56 |     public:
 57 |         SVMLightParser(const string& fileName, const string& headerFileName);
 58 |                 
 59 |         virtual void readData(vector<Example>& examples, NameMap& classMap, 
 60 |                               vector<NameMap>& enumMaps, NameMap& attributeNameMap,
 61 |                               vector<RawData::eAttributeType>& attributeTypes);
 62 |                 
 63 |         virtual int  getNumAttributes() const
 64 |         { return _numAttributes; }
 65 |                                 
 66 |     protected:
 67 |         /**
 68 |            Read the header in the following form:
 69 |            First line: 1 2 4 6 # class labels
 70 |            Second line: id1 id2 id3 # feature names
 71 |            Third line: 0.2 0.2 0.1 0.5 # label weights (optional )
 72 |         */
 73 |         void readHeader( NameMap& classMap, 
 74 |                          vector<NameMap>& enumMaps, NameMap& attributeNameMap,
 75 |                          vector<RawData::eAttributeType>& attributeTypes );
 76 |                 
 77 |         void readData(ifstream& in, vector<Example>& examples, NameMap& classMap, 
 78 |                       vector<NameMap>& enumMaps, NameMap& attributeNameMap,
 79 |                       vector<RawData::eAttributeType>& attributeTypes);
 80 | 
 81 |         /**
 82 |          * If no header file is given, it is assumed that the labesl are 0..(K-1) and the features
 83 |          * are denoted by 1..F. This function finds the label and feauter having highest index.          
 84 |          * \data 27/07/2011
 85 |          */
 86 |         void getHeaderInfoFromData(ifstream& in, NameMap& classMap, 
 87 |                                    vector<NameMap>& enumMaps, NameMap& attributeNameMap,
 88 |                                    vector<RawData::eAttributeType>& attributeTypes);
 89 |                 
 90 |         string readName(ifstream& in);
 91 |                 
 92 |                 
 93 |         void readDenseValues(ifstream& in, vector<FeatureReal>& values,
 94 |                              vector<NameMap>& enumMaps, 
 95 |                              const vector<RawData::eAttributeType>& attributeTypes);
 96 |                 
 97 |         void readSparseValues(istringstream& ss, vector<FeatureReal>& values, vector<int>& idxs, map<int, int>& idxmap, 
 98 |                               vector<NameMap>& enumMaps, 
 99 |                               const vector<RawData::eAttributeType>& attributeTypes, NameMap& attributeNameMap);
100 |                 
101 |         void allocateSimpleLabels( vector<int>& labelIdx, vector<Label>& labels,
102 |                                    NameMap& classMap );                          
103 |                 
104 |         int                                      _numAttributes;
105 |                 
106 |         locale                           _denseLocale;
107 |         locale                           _sparseLocale;
108 |         locale                           _labelLocale;
109 |         bool                             _hasName;
110 |         map< int, AlphaReal> _weightOfClasses; //! In the header file it is possible to define initial weights for classes
111 |                 
112 |         size_t                           _numRows;
113 |     public:
114 |                 
115 |     };
116 |         
117 |     // -----------------------------------------------------------------------------
118 |         
119 |     inline string SVMLightParser::readName(ifstream& in)
120 |     {
121 |         const locale& originalLocale = in.imbue(_denseLocale); 
122 |         string name;
123 |         in >> name;
124 |         in.imbue(originalLocale);
125 |         return name;
126 |     }
127 |         
128 |     // -----------------------------------------------------------------------------
129 |         
130 |         
131 | } // end of namespace MultiBoost
132 | 
133 | #endif // __ARFF_PARSER_H
134 | 


--------------------------------------------------------------------------------
/src/IO/TxtParser.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file TxtParser.h A parser for TXT file format: dense data and single class only here!
 36 |  */
 37 | 
 38 | #ifndef __TXT_PARSER_H
 39 | #define __TXT_PARSER_H
 40 | 
 41 | #include "IO/GenericParser.h"
 42 | 
 43 | using namespace std;
 44 | 
 45 | namespace MultiBoost {
 46 |         
 47 |     /**
 48 |      * Parse simple text data.
 49 |      * Here is an example of valid data (note: in this case the argument \b --examplelabel has been provided!):
 50 |      * \verbatim
 51 |      /home/music/classical/classical.00078.au       classical       5.72939e+01     2.95128e+02     6.43395e+00
 52 |      /home/music/disco/disco.00078.au       disco   1.98315e+02     1.31341e+03     -6.15398e+00
 53 |      /home/music/reggae/reggae.00022.au     reggae  2.51418e+02     7.68241e+02     -5.66704e+00
 54 |      /home/music/hiphop/hiphop.00080.au     hiphop  2.62773e+02     4.83971e+02     8.80924e-01
 55 |      /home/music/rock/rock.00015.au rock    2.03546e+02     9.31192e+02     -7.56387e+00    1.15847e+02
 56 |      /home/music/hiphop/hiphop.00027.au     hiphop  2.37860e+02     1.03110e+03     2.50052e-01
 57 |      /home/music/rock/rock.00094.au rock    2.48359e+02     1.69432e+02     -1.66508e+01
 58 |      \endverbatim 
 59 |      * \remark The column can be separated by any white-space character. If a particular 
 60 |      * separator needs to be specified (for instance when the class name contains spaces), 
 61 |      * use the --d option.
 62 |      * \remark The TxtParser is STRICTLY single class (can have many classes but just one per example).
 63 |      */
 64 |     class TxtParser : public GenericParser
 65 |     {
 66 |     public:
 67 |     TxtParser(const string& fileName,const string& headerFileName)
 68 |         : GenericParser(fileName,headerFileName) {}
 69 |                 
 70 |         void setHasExampleName(bool hasExampleName)
 71 |         { _hasExampleName = hasExampleName; }
 72 |                 
 73 |         void setClassEnd(bool hasClassEnd)
 74 |         { _hasClassEnd = hasClassEnd; }
 75 |                 
 76 |         void setSepChars(const string& sepChars)
 77 |         { _sepChars = sepChars; }
 78 |                 
 79 |         virtual void readData( vector<Example>& examples, NameMap& classMap, 
 80 |                                vector<NameMap>& enumMaps, NameMap& attributeNameMap, 
 81 |                                vector<RawData::eAttributeType>& attributeTypes );
 82 |                 
 83 |         virtual int   getNumAttributes() const
 84 |         { return _numAttributes; }
 85 |                 
 86 |     private:
 87 |                 
 88 |         bool checkInput(const string& line, int numColumns) const;
 89 |                 
 90 |         bool     _hasExampleName;
 91 |         bool     _hasClassEnd;
 92 |         string   _sepChars;
 93 |                 
 94 |         int      _numAttributes;
 95 |     };
 96 |         
 97 | } // end of namespace MultiBoost
 98 | 
 99 | #endif // __TXT_PARSER_H
100 | 


--------------------------------------------------------------------------------
/src/Others/Rates.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #ifndef __PER_CLASS_RATES_H
35 | #define __PER_CLASS_RATES_H
36 | 
37 | #include <stdio.h>
38 | #include <string.h> 
39 | 
40 | namespace MultiBoost {
41 | 
42 | //////////////////////////////////////////////////////////////////////////////////////////////
43 | //////////////////////////////////////////////////////////////////////////////////////////////
44 | 
45 | /**
46 |  * The per class rates. 
47 |  * It is defined (using \f$\mu\f$ as variable) as
48 |  * \f{eqnarray*}
49 |  *   \mu_{\ell+} & = & \sum_{correct} w_{i,\ell}^{(t)},\\
50 |  *   \mu_{\ell-} &=& \sum_{incorrect} w_{i,\ell}^{(t)}, \\ 
51 |  *   \mu_{\ell0} & = & \mu_{\ell-} + \mu_{\ell+}
52 |  * \f}
53 |  * \remark The implemented decision stump algorithms do not abstain themselves.
54 |  * The abstention value, that is for \f$v=0\f$ is computed in getEnergy()
55 |  * \date 11/11/2005
56 |  */
57 |     struct sRates
58 |     {
59 |     sRates() : classIdx(-1), rPls(0), rMin(0), rZero(0) {} //!< The constructor. 
60 |         void clear() { memset( this, 0, sizeof(sRates) ); /* classIdx = 0; rPls = 0; rMin = 0; rZero = 0;*/  }
61 | 
62 |         int     classIdx; //!< the index of the class. Needed because we will sort the vector that contains this object
63 | 
64 |         AlphaReal  rPls; //!< positive rate, or \f$\mu_{\ell+}\f$
65 |         AlphaReal  rMin; //!<  negative rate, or \f$\mu_{\ell-}\f$
66 |         AlphaReal  rZero; //!< abstention rate, or \f$\mu_{\ell0}\f$
67 | 
68 |         /**
69 |          * Overloading of the operator to allow sorting.
70 |          * \param el The other element to be compared with
71 |          * \date 11/11/2005
72 |          */ 
73 |         bool operator<(const sRates& el) const
74 |             {
75 |                 return el.rPls * el.rMin < this->rPls * this->rMin;
76 |             }
77 |     };
78 | 
79 | 
80 | } // end of namespace MultiBoost
81 | 
82 | #endif // __PER_CLASS_RATES_H
83 | 


--------------------------------------------------------------------------------
/src/Registrations.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it 
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: multiboost@googlegroups.com 
26 |  * 
27 |  *    For more information and up-to-date version, please visit
28 |  *        
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | #pragma once
34 | 
35 | #include "WeakLearners/AdaLineLearner.h"
36 | #include "WeakLearners/BanditSingleSparseStump.h"
37 | #include "WeakLearners/BanditSingleStumpLearner.h"
38 | #include "WeakLearners/ConstantLearner.h"
39 | #include "WeakLearners/HaarMultiStumpLearner.h"
40 | #include "WeakLearners/HaarSingleStumpLearner.h"
41 | #include "WeakLearners/IndicatorLearner.h"
42 | #include "WeakLearners/MultiStumpLearner.h"
43 | #include "WeakLearners/MultiThresholdStumpLearner.h"
44 | #include "WeakLearners/OneClassStumpLearner.h"
45 | #include "WeakLearners/ParasiteLearner.h"
46 | #include "WeakLearners/ProductLearner.h"
47 | #include "WeakLearners/ProductLearnerUCT.h"
48 | #include "WeakLearners/SelectorLearner.h"
49 | #include "WeakLearners/SigmoidSingleStumpLearner.h"
50 | #include "WeakLearners/SingleRegressionStumpLearner.h"
51 | #include "WeakLearners/SingleSparseStump.h"
52 | #include "WeakLearners/SingleSparseStumpLearner.h"
53 | #include "WeakLearners/SingleStumpLearner.h"
54 | #include "WeakLearners/TreeLearner.h"
55 | #include "WeakLearners/TreeLearnerUCT.h"
56 | #include "WeakLearners/UCBVHaarSingleStumpLearner.h"
57 | 
58 | #include "WeakLearners/Haar/HaarFeatures.h"
59 | 
60 | namespace MultiBoost {
61 |     REGISTER_LEARNER(AdaLineLearner)                
62 |         REGISTER_LEARNER(BanditSingleSparseStump)
63 |         REGISTER_LEARNER(BanditSingleStumpLearner)
64 |         REGISTER_LEARNER(ConstantLearner)
65 |         REGISTER_LEARNER_NAME(HaarMultiStump, HaarMultiStumpLearner)
66 |         REGISTER_LEARNER(HaarSingleStumpLearner)
67 |         REGISTER_LEARNER(IndicatorLearner)
68 |         REGISTER_LEARNER(MultiStumpLearner)
69 |         REGISTER_LEARNER(MultiThresholdStumpLearner)
70 |         REGISTER_LEARNER(OneClassStumpLearner)
71 |         REGISTER_LEARNER(ParasiteLearner)
72 |         REGISTER_LEARNER(ProductLearner)
73 |         REGISTER_LEARNER(ProductLearnerUCT)
74 |         REGISTER_LEARNER(SelectorLearner)
75 |         REGISTER_LEARNER(SigmoidSingleStumpLearner)
76 |         REGISTER_LEARNER(SingleRegressionStumpLearner)
77 |         REGISTER_LEARNER(SingleSparseStump)
78 |         REGISTER_LEARNER(SingleSparseStumpLearner)
79 |         REGISTER_LEARNER(SingleStumpLearner)
80 |         REGISTER_LEARNER(TreeLearner)
81 |         REGISTER_LEARNER(TreeLearnerUCT)
82 |         REGISTER_LEARNER_NAME(UCBVHaarSingleStump, UCBVHaarSingleStumpLearner)
83 | 
84 |         // Register the haar features
85 |         REGISTER_HAAR_FEATURE(2h, HaarFeature_2H);
86 |     REGISTER_HAAR_FEATURE(2v, HaarFeature_2V);
87 |     REGISTER_HAAR_FEATURE(3h, HaarFeature_3H);
88 |     REGISTER_HAAR_FEATURE(3v, HaarFeature_3V);
89 |     REGISTER_HAAR_FEATURE(4q, HaarFeature_4SQ);
90 | 
91 | }
92 | 


--------------------------------------------------------------------------------
/src/StrongLearners/ArcGVLearner.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file ArcGVLearner.h The meta-learner arc-gv.
 36 |  * See 
 37 |  */
 38 | #pragma warning( disable : 4786 )
 39 | 
 40 | #ifndef __ARCGV_LEARNER_H
 41 | #define __ARCGV_LEARNER_H
 42 | 
 43 | #include "StrongLearners/AdaBoostMHLearner.h"
 44 | #include "Utils/Args.h"
 45 | #include "Defaults.h"
 46 | 
 47 | using namespace std;
 48 | 
 49 | //////////////////////////////////////////////////////////////////////////////////////////////
 50 | //////////////////////////////////////////////////////////////////////////////////////////////
 51 | 
 52 | namespace MultiBoost {
 53 |     /**
 54 |      * The arc-gv learner. This class performs the meta-learning
 55 |      * by calling the weak learners and updating the weights. The
 56 |      * main difference between AdaBoost.MH and arc-gv is that the 
 57 |      * weight of weak classifier is regularized with the minimal margin.
 58 |      * See Breiman, L. (1998). Arcing classifiers. The Annals of Statistics, 26, 801–-849.
 59 |      * \date 04/04/2012
 60 |      */
 61 |     class ArcGVLearner : public AdaBoostMHLearner
 62 |     {
 63 |     public:
 64 |         
 65 |         /**
 66 |          * The constructor. It initializes the variables and sets them using the
 67 |          * information provided by the arguments passed. They are parsed
 68 |          * using the helpers provided by class Args.
 69 |          * \date 13/11/2005
 70 |          */
 71 |     ArcGVLearner() : AdaBoostMHLearner(), _alphaSum(0.0), _minMarginThreshold( 0.0 ) {}
 72 |         
 73 |         /**
 74 |          * Start the learning process.
 75 |          * \param args The arguments provided by the command line with all
 76 |          * the options for training.
 77 |          * \see OutputInfo
 78 |          * \date 10/11/2005
 79 |          */
 80 |         virtual void run(const nor_utils::Args& args);                          
 81 |     protected:
 82 |         /**
 83 |          * Get the needed parameters (for the strong learner) from the argumens.
 84 |          * \param The arguments provided by the command line.
 85 |          */
 86 |         void getArgs(const nor_utils::Args& args);
 87 |                 
 88 |                 
 89 |     private:
 90 |         /**
 91 |          * Fake assignment operator to avoid warning.
 92 |          * \date 04/04/2012
 93 |          */
 94 |         AdaBoostMHLearner& operator=( const AdaBoostMHLearner& ) {return *this;}
 95 |         
 96 |         AlphaReal _alphaSum;
 97 |         AlphaReal _minMarginThreshold;
 98 |     };
 99 |     
100 | } // end of namespace ArcGV
101 | 
102 | #endif // __ARCGV_LEARNER_H
103 | 


--------------------------------------------------------------------------------
/src/StrongLearners/FilterBoostLearner.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file FilterBoostLearner.h The meta-learner FilterBoost.
 36 |  */
 37 | 
 38 | #ifndef __FILTERBOOST_LEARNER_H
 39 | #define __FILTERBOOST_LEARNER_H
 40 | 
 41 | #include "StrongLearners/GenericStrongLearner.h"
 42 | #include "StrongLearners/AdaBoostMHLearner.h"
 43 | #include "Utils/Args.h"
 44 | 
 45 | using namespace std;
 46 | 
 47 | //////////////////////////////////////////////////////////////////////////////////////////////
 48 | //////////////////////////////////////////////////////////////////////////////////////////////
 49 | 
 50 | namespace MultiBoost {
 51 | 
 52 |     /**
 53 |      * The FilterBoost learner. This class performs the meta-learning
 54 |      * by calling the weak learners and updating the weights.
 55 |      \verbatim
 56 |      @InProceedings{BrSc07,
 57 |      author =       {Bradley, J.K.  and Schapire, R.E.},
 58 |      title  =       {{FilterBoost}: Regression and Classification on Large
 59 |      Datasets},
 60 |      booktitle =    {Advances in Neural Information Processing Systems},
 61 |      volume =       {20},
 62 |      year =         {2008},
 63 |      publisher =    {The MIT Press}
 64 |      } \endverbatim
 65 |      *       
 66 |      * \date 04/07/2011
 67 |      */
 68 |     class FilterBoostLearner : public AdaBoostMHLearner
 69 |     {
 70 |     public:
 71 | 
 72 |         /**
 73 |          * The constructor. It initializes the variables and sets them using the
 74 |          * information provided by the arguments passed. They are parsed
 75 |          * using the helpers provided by class Args. The constant learner is switched on by default.
 76 |          * \date 13/11/2005
 77 |          */
 78 |     FilterBoostLearner() : AdaBoostMHLearner(), _Cn(300), _onlineWeakLearning(false), _sumAlpha(0.0) {}
 79 | 
 80 |         /**
 81 |          * Start the learning process.
 82 |          * \param args The arguments provided by the command line with all
 83 |          * the options for training.
 84 |          * \see OutputInfo
 85 |          * \date 10/11/2005
 86 |          */
 87 |         virtual void run(const nor_utils::Args& args);
 88 | 
 89 |     protected:
 90 | 
 91 |         /**
 92 |          * Get the needed parameters (for the strong learner) from the argumens.
 93 |          * \param The arguments provided by the command line.
 94 |          */
 95 |         void getArgs(const nor_utils::Args& args);
 96 | 
 97 |                 
 98 |         /**
 99 |          * Resume the training using the features in _resumeShypFileName if the
100 |          * option -resume has been specified. The margins should be updated as well.
101 |          * \date 21/12/2005
102 |          */
103 |         void resumeProcess(Serialization& ss, InputData* pTrainingData, InputData* pTestData, 
104 |                            OutputInfo* pOutInfo);
105 |                 
106 |                 
107 |     private:
108 |         /**
109 |          * Fake assignment operator to avoid warning.
110 |          * \date 6/12/2005
111 |          */
112 |         FilterBoostLearner& operator=( const FilterBoostLearner& ) {return *this;}
113 | 
114 |         /**
115 |          * For margins
116 |          */
117 |         vector< vector<AlphaReal> > _margins;
118 |                 
119 |         /**
120 |          * The filter function. It draws random instances from the training data WITHOUT replacement.
121 |          */
122 |         void filter( InputData* pData, int size, bool rejection = true );
123 |                                 
124 |         void setWeightToMargins( InputData* pData );
125 |         void updateMargins( InputData* pData, BaseLearner* pWeakHypothesis );
126 |         /**
127 |          * The size of subset will be used for training the base learner
128 |          */
129 |         int _Cn;
130 |                 
131 |         /**
132 |          * The weak learner will be trained in an online fashion. In this case, GradientLearner has to be used.
133 |          */
134 |         bool _onlineWeakLearning;
135 |         AlphaReal _sumAlpha;
136 |         // temporary function
137 |         void saveMargins();             
138 |     };
139 | 
140 | } // end of namespace MultiBoost
141 | 
142 | #endif // __ADABOOST_MH_LEARNER_H
143 | 
144 | 


--------------------------------------------------------------------------------
/src/StrongLearners/GenericStrongLearner.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |   $Author: nova77 $
 3 |   $Date: 2007/02/12 16:13:17 $
 4 |   $Revision: 1.7 $
 5 | */
 6 | 
 7 | /*
 8 |  *
 9 |  *    MultiBoost - Multi-purpose boosting package
10 |  *
11 |  *    Copyright (C)        AppStat group
12 |  *                         Laboratoire de l'Accelerateur Lineaire
13 |  *                         Universite Paris-Sud, 11, CNRS
14 |  *
15 |  *    This file is part of the MultiBoost library
16 |  *
17 |  *    This library is free software; you can redistribute it 
18 |  *    and/or modify it under the terms of the GNU General Public
19 |  *    License as published by the Free Software Foundation
20 |  *    version 2.1 of the License.
21 |  *
22 |  *    This library is distributed in the hope that it will be useful,
23 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
24 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25 |  *    General Public License for more details.
26 |  *
27 |  *    You should have received a copy of the GNU General Public
28 |  *    License along with this library; if not, write to the Free Software
29 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
30 |  *
31 |  *    Contact: : multiboost@googlegroups.com
32 |  *
33 |  *    For more information and up-to-date version, please visit
34 |  *        
35 |  *                       http://www.multiboost.org/
36 |  *
37 |  */
38 | 
39 | 
40 | /**
41 |  * \file GenericStrongLearner.h An abstract class for a generic meta-learner.
42 |  */
43 | 
44 | #ifndef __GENERIC_STRONG_LEARNER_H
45 | #define __GENERIC_STRONG_LEARNER_H
46 | 
47 | #include "Utils/Args.h"
48 | 
49 | using namespace std;
50 | 
51 | //////////////////////////////////////////////////////////////////////////////////////////////
52 | //////////////////////////////////////////////////////////////////////////////////////////////
53 | 
54 | namespace MultiBoost {
55 | 
56 | /**
57 |  * An abstract class for a generic meta-learner.
58 |  * \see AdaBoostMHLearner
59 |  * \date 20/3/2006
60 |  */
61 |     class GenericStrongLearner
62 |     {
63 |     public:
64 | 
65 |         /**
66 |          * Performs the learning process.
67 |          * \param args The arguments provided by the command line.
68 |          */
69 |         virtual void run(const nor_utils::Args& args) = 0;
70 | 
71 |         /**
72 |          * Performs the classification.
73 |          * \param args The arguments provided by the command line.
74 |          */
75 |         virtual void classify(const nor_utils::Args& args) = 0;
76 | 
77 |         /**
78 |          * Print to stdout (or to file) a confusion matrix.
79 |          * \param args The arguments provided by the command line.
80 |          * \date 20/3/2006
81 |          */
82 |         virtual void doConfusionMatrix(const nor_utils::Args& args) = 0;
83 | 
84 |         /**
85 |          * Print to stdout (or to file) the posteriors of each class.
86 |          * \param args The arguments provided by the command line.
87 |          */
88 |         virtual void doPosteriors(const nor_utils::Args& args) = 0;
89 | 
90 | 
91 |         virtual ~GenericStrongLearner(){}
92 |     };
93 | 
94 | } // end of namespace MultiBoost
95 | 
96 | #endif // __GENERIC_MODEL_H
97 | 


--------------------------------------------------------------------------------
/src/Utils/MathematicalTools.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | 
35 | 
36 | #ifndef __MATHTOOLS_H
37 | #define __MATHTOOLS_H
38 | 
39 | 
40 | #include "blaswrap.h"
41 | #include "f2c.h"
42 | 
43 | //////////////////////////////////////////////////////////////////////////////////////////////
44 | // extern for lapack routines
45 | extern "C" /* Subroutine */ int dgetri_(integer *n, doublereal *a, integer *lda, integer 
46 |                                         *ipiv, doublereal *work, integer *lwork, integer *info);
47 | extern "C" /* Subroutine */ int sgemm_(char *transa, char *transb, integer *m, integer *
48 |                                        n, integer *k, real *alpha, real *a, integer *lda, real *b, integer *
49 |                                        ldb, real *beta, real *c__, integer *ldc);
50 | extern "C" /* Subroutine */ int dgetrf_(integer *m, integer *n, doublereal *a, integer *
51 |                                         lda, integer *ipiv, integer *info);
52 | 
53 | 
54 | int matrixInverse( integer *n, doublereal *a );
55 | void solveEquationSystem( double* X, double* b, int* N );
56 | 
57 | 
58 | 
59 | 
60 | void solveEquationSystem( double* X, double* b, int* N ) {
61 |     matrixInverse( (integer*) N, (doublereal*) X );
62 | }
63 | 
64 | 
65 | int matrixInverse( integer *n, doublereal *a ) {
66 |     integer info;
67 |     static integer lwork = WSIZE;
68 |     
69 |     dgetrf_( n, n, a, n, ipiv, &info);
70 |     dgetri_( n, a, n, ipiv, work, &lwork, &info);    
71 |     return info;
72 | }
73 | 
74 | #endif
75 | 


--------------------------------------------------------------------------------
/src/Utils/StreamTokenizer.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | /**
 36 |  * \file StreamTokenizer.h Tokenize a stream.
 37 |  */
 38 | 
 39 | #ifndef __STREAM_TOKENIZER_H
 40 | #define __STREAM_TOKENIZER_H
 41 | 
 42 | #include <string>
 43 | #include <iterator>
 44 | 
 45 | using namespace std;
 46 | 
 47 | //////////////////////////////////////////////////////////////////////////////////////////////
 48 | //////////////////////////////////////////////////////////////////////////////////////////////
 49 | 
 50 | namespace nor_utils {
 51 | 
 52 | /**
 53 |  * Can tokenize a stream.
 54 |  * It takes a stream, and defined the delimiters, it returns the tokens between these
 55 |  * delimiters.
 56 |  * \date 16/11/2005
 57 |  */
 58 |     class StreamTokenizer
 59 |     {
 60 |         typedef istream_iterator<char> sIt; //!< A stream iterator typedef
 61 | 
 62 |     public:
 63 | 
 64 |         /**
 65 |          * The constructor. It defines the delimiters, and use the normal
 66 |          * white-spaces on the stream.
 67 |          * \param is The input stream.
 68 |          * \param delim The delimiters.
 69 |          * \date 16/11/2005
 70 |          */
 71 |     StreamTokenizer(istream& is, const string delim = " \t")
 72 |         : p(is), end_of_stream(), delimiters(delim) 
 73 |         { is.unsetf(std::ios::skipws); }
 74 | 
 75 |         /**
 76 |          * Get the next token.
 77 |          * \return The string of the next token in the list.
 78 |          * \date 16/11/2005
 79 |          */
 80 |         string next_token()
 81 |         {
 82 |             string result;
 83 |             char ch;
 84 |             insert_iterator<string> iIt(result, result.begin());
 85 | 
 86 |             if ( p != end_of_stream)
 87 |             {
 88 |                 // move until the delimiter
 89 |                 while ( p != end_of_stream && is_delimiter(*p) )
 90 |                 {
 91 |                     ch = *p;
 92 |                     p++;
 93 |                 }
 94 | 
 95 |                 // move until the next delimiter, and build
 96 |                 // the string.
 97 |                 while ( p != end_of_stream && !is_delimiter(*p) )
 98 |                 {
 99 |                     ch = *p;
100 |                     *iIt++ = *p++;
101 |                 }
102 |             }
103 | 
104 |             return result;
105 |         }
106 | 
107 |         /**
108 |          * Ask if the stream has other tokens.
109 |          * \return True if it is at the end of the stream, false
110 |          * otherwise.
111 |          * \date 16/11/2005
112 |          * \bug In fact this method does not know if there are other tokens
113 |          * awaiting. If there are characters after the last delimiter
114 |          * at the end of the stream, they will be considered a token
115 |          * and therefore, this method will return true. This happens
116 |          * also if there is just a newline (in the case it is not a delimiter).
117 |          * It is possible to avoid this problem, but will affect efficency.
118 |          * Because a "spurious" token will just be ignored by the parser
119 |          * I decided to just leave it as it is.
120 |          */
121 |         bool has_token()
122 |         { return (! (p == end_of_stream) ); }
123 | 
124 |     private:
125 | 
126 |         /**
127 |          * Fake assignment operator to avoid warning.
128 |          * \date 6/12/2005
129 |          */
130 |         StreamTokenizer& operator=( const StreamTokenizer& ) {return *this;}
131 | 
132 |         sIt p; //!< The current position in the stream.
133 |         sIt end_of_stream; //!< The end of the stream.
134 | 
135 |         const string delimiters; //!< The delimiters. 
136 | 
137 |         /**
138 |          * Checks if the given char is a delimiter.
139 |          * \param c The char to be checked
140 |          * \return True if \a c is a delimiter, false otherwise.
141 |          * \date 16/11/2005
142 |          */
143 |         bool is_delimiter(char c)
144 |         { 
145 |             return delimiters.find(c) != string::npos; 
146 |         }
147 |     };
148 | 
149 | } // end of namespace nor_utils
150 | 
151 | #endif //__STREAM_TOKENIZER_H
152 | 
153 | 


--------------------------------------------------------------------------------
/src/Utils/UCTutils.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | #include "Utils/UCTutils.h"
34 | #include <cctype> // for isspace
35 | #include <algorithm>
36 | #include <sstream>
37 | #include <fstream>
38 | 
39 | namespace MultiBoost {
40 | 
41 | // ----------------------------------------------------------------
42 | 
43 |     int     NodeUCTSparse::_depth = 0;
44 |     int     NodeUCTSparse::_branchOrder = 0;
45 | 
46 | // ----------------------------------------------------------------
47 | 
48 | }
49 | 
50 | 
51 | 


--------------------------------------------------------------------------------
/src/WeakLearners/BanditSingleSparseStump.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file BanditSingleSparseStump.h A single threshold decision stump learner. 
 36 |  */
 37 | 
 38 | #ifndef __BANDIT_SINGLE_SPARSE_STUMP_H
 39 | #define __BANDIT_SINGLE_SPARSE_STUMP_H
 40 | 
 41 | //#include "WeakLearners/ClasswiseLearner.h"
 42 | #include "WeakLearners/FeaturewiseLearner.h"
 43 | #include "WeakLearners/BanditSingleStumpLearner.h"
 44 | #include "Utils/Args.h"
 45 | #include "IO/InputData.h"
 46 | #include "IO/SortedData.h"
 47 | #include "Bandits/Exp3G2.h"
 48 | 
 49 | #include <vector>
 50 | #include <fstream>
 51 | #include <cassert>
 52 | 
 53 | using namespace std;
 54 | 
 55 | //////////////////////////////////////////////////////////////////////////////////////////////
 56 | //////////////////////////////////////////////////////////////////////////////////////////////
 57 | 
 58 | namespace MultiBoost {
 59 | 
 60 | /**
 61 |  * A \b single threshold decision stump learner. 
 62 |  * There is ONE and ONE ONLY threshold here.
 63 |  */
 64 |     class BanditSingleSparseStump : public BanditSingleStumpLearner
 65 |     {
 66 |     public:
 67 |     BanditSingleSparseStump() : BanditSingleStumpLearner() {}
 68 | 
 69 |         /**
 70 |          * The destructor. Must be declared (virtual) for the proper destruction of 
 71 |          * the object.
 72 |          */
 73 |         virtual ~BanditSingleSparseStump() {}
 74 | 
 75 |         /**
 76 |          */
 77 |         virtual void init();
 78 | 
 79 | 
 80 |         /**
 81 |          * Returns itself as object.
 82 |          * \remark It uses the trick described in http://www.parashift.com/c++-faq-lite/serialization.html#faq-36.8
 83 |          * for the auto-registering classes.
 84 |          * \date 14/11/2005
 85 |          */
 86 |         virtual BaseLearner* subCreate() { 
 87 |             BaseLearner* retLearner = new BanditSingleSparseStump();
 88 |             dynamic_cast< BanditSingleStumpLearner* >(retLearner)->setBanditAlgoObject( _banditAlgo );
 89 |             return retLearner;
 90 |         }
 91 | 
 92 |         /**
 93 |          * Run the learner to build the classifier on the given data.
 94 |          * \param pData The pointer to the data.
 95 |          * \see BaseLearner::run
 96 |          * \date 11/11/2005
 97 |          */
 98 |         virtual AlphaReal run();
 99 | 
100 |         virtual AlphaReal run( int colIdx );
101 | 
102 |     protected:
103 | 
104 |     };
105 | 
106 | //////////////////////////////////////////////////////////////////////////
107 | 
108 | } // end of namespace MultiBoost
109 | 
110 | #endif // __SINGLE_STUMP_LEARNER_H
111 | 


--------------------------------------------------------------------------------
/src/WeakLearners/ConstantLearner.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | #include "ConstantLearner.h"
 35 | 
 36 | #include "IO/Serialization.h"
 37 | #include "Algorithms/ConstantAlgorithm.h"
 38 | 
 39 | #include <limits> // for numeric_limits<>
 40 | 
 41 | namespace MultiBoost {
 42 | 
 43 | 
 44 | //REGISTER_LEARNER_NAME(Constant, ConstantLearner)
 45 | 
 46 | 
 47 |     // ------------------------------------------------------------------------------
 48 | 
 49 |     AlphaReal ConstantLearner::run()
 50 |     {
 51 | 
 52 |         const int numClasses = _pTrainingData->getNumClasses();
 53 |         //const int numColumns = _pTrainingData->getNumColumns();
 54 | 
 55 |         // set the smoothing value to avoid numerical problem
 56 |         // when theta=0.
 57 |         setSmoothingVal( 1.0 / (AlphaReal)_pTrainingData->getNumExamples() * 0.01 );
 58 | 
 59 |         vector<sRates> mu(numClasses); // The class-wise rates. See BaseLearner::sRates for more info.
 60 |         vector<AlphaReal> tmpV(numClasses); // The class-wise votes/abstentions
 61 | 
 62 |         ConstantAlgorithm cAlgo;
 63 |         cAlgo.findConstant(_pTrainingData,&mu,&tmpV);
 64 |    
 65 |         _v = tmpV;
 66 | 
 67 |         return getEnergy(mu, _alpha, _v);
 68 |     }
 69 | 
 70 | // ------------------------------------------------------------------------------
 71 | 
 72 |     AlphaReal ConstantLearner::run( int colNum )
 73 |     {
 74 |         return this->run();
 75 |     }
 76 | 
 77 |         
 78 | // -----------------------------------------------------------------------
 79 |     void ConstantLearner::initLearning()
 80 |     {
 81 |         const int numClasses = _pTrainingData->getNumClasses();
 82 |         _v.resize(numClasses);
 83 |         fill(_v.begin(), _v.end(), 0.0 );
 84 | 
 85 |     }
 86 | // -----------------------------------------------------------------------      
 87 |     void ConstantLearner::subCopyState(BaseLearner *pBaseLearner)
 88 |     {
 89 |         StochasticLearner::subCopyState( pBaseLearner );
 90 |         AbstainableLearner::subCopyState( pBaseLearner );
 91 |     }
 92 |         
 93 |         
 94 | // -----------------------------------------------------------------------      
 95 |     AlphaReal ConstantLearner::finishLearning()
 96 |     {
 97 |         const int numClasses = _pTrainingData->getNumClasses();
 98 |         AlphaReal bestEdge = 0.0;
 99 |         
100 |         for(int i=0; i<numClasses;++i) 
101 |         {
102 |             bestEdge += (_v[i]<0)? -_v[i] : _v[i];  
103 |             _v[i] = (_v[i]<0)? 1.0 : -1.0;  
104 |         }
105 |         
106 |         return bestEdge;
107 |     }       
108 | // -----------------------------------------------------------------------
109 |     AlphaReal ConstantLearner::update( int idx )
110 |     {
111 |         vector<Label> labels = _pTrainingData->getLabels(idx);
112 |         vector<Label>::iterator lIt;
113 |         
114 |         for ( lIt = labels.begin(); lIt != labels.end(); ++lIt )
115 |         {
116 |             _v[lIt->idx] += (lIt->weight * lIt->y);
117 |         }
118 |         
119 |         return 0.0;
120 |     }       
121 |         
122 | // -----------------------------------------------------------------------      
123 |     void ConstantLearner::getStateData( vector<FeatureReal>& data, const string& /*reason*/, InputData* pData )
124 |     {
125 | //    const int numClasses = ClassMappings::getNumClasses();
126 | //    const int numExamples = pData->getNumExamples();
127 | 
128 | //    // reason ignored for the moment as it is used for a single task
129 | //    data.resize( numClasses + numExamples );
130 | 
131 | //    int pos = 0;
132 | 
133 | //    for (int l = 0; l < numClasses; ++l)
134 | //       data[pos++] = _v[l];
135 | 
136 | //    for (int i = 0; i < numExamples; ++i)
137 | //       data[pos++] = ConstantLearner::phi( pData->getValue( i, _selectedColumn), 0 );
138 |     }
139 | 
140 | // -----------------------------------------------------------------------
141 | 
142 | } // end of namespace MultiBoost
143 | 


--------------------------------------------------------------------------------
/src/WeakLearners/NeuronLearner.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | 
 35 | #include "NeuronLearner.h"
 36 | #include "IO/Serialization.h"
 37 | 
 38 | namespace MultiBoost {
 39 |         
 40 |     // ------------------------------------------------------------------------------
 41 |         
 42 |     void NeuronLearner::declareArguments(nor_utils::Args& args)
 43 |     {
 44 |         AbstainableLearner::declareArguments(args);
 45 |     }
 46 |         
 47 |     // ------------------------------------------------------------------------------
 48 |         
 49 |     void NeuronLearner::initLearningOptions(const nor_utils::Args& args)
 50 |     {
 51 |         AbstainableLearner::initLearningOptions(args);
 52 |     }
 53 |         
 54 |     // -----------------------------------------------------------------------
 55 |         
 56 |     void NeuronLearner::save(ofstream& outputStream, int numTabs)
 57 |     {
 58 |         // Calling the super-class method
 59 |         AbstainableLearner::save(outputStream, numTabs);
 60 |                 
 61 |         // save feature weights         
 62 |         stringstream featureWeightsSS("");              
 63 |         vector<FeatureReal>::iterator it = _featuresWeight.begin();
 64 |         featureWeightsSS << *it;
 65 |         ++it;
 66 |         for (;it != _featuresWeight.end(); ++it )
 67 |         {
 68 |             featureWeightsSS << " " << *it;
 69 |         }
 70 |                 
 71 |         outputStream << Serialization::standardTag("fweights", featureWeightsSS.str(), numTabs) << endl;
 72 |     }
 73 |         
 74 |     // -----------------------------------------------------------------------
 75 |         
 76 |     void NeuronLearner::load(nor_utils::StreamTokenizer& st)
 77 |     {
 78 |         // Calling the super-class method
 79 |         AbstainableLearner::load(st);
 80 |                 
 81 |         _featuresWeight.resize(0);
 82 |                 
 83 |         // load feature weights
 84 |         locale tmpLocale  = locale(locale(), new nor_utils::white_spaces(", "));
 85 |         string featureWeightsString = UnSerialization::seekAndParseEnclosedValue<string>(st, "fweights");
 86 |                 
 87 |         stringstream featureWeightsSS(featureWeightsString);
 88 |         featureWeightsSS.imbue(tmpLocale);
 89 |                 
 90 |         // store the weights
 91 |         while (!featureWeightsSS.eof())
 92 |         {
 93 |             FeatureReal tmpWeight;
 94 |             featureWeightsSS >> tmpWeight;
 95 |                         
 96 |             _featuresWeight.push_back( tmpWeight );
 97 |         }
 98 |                 
 99 |                 
100 |     }
101 |         
102 |     // -----------------------------------------------------------------------      
103 |     void NeuronLearner::subCopyState(BaseLearner *pBaseLearner)
104 |     {
105 |         AbstainableLearner::subCopyState(pBaseLearner);
106 |                 
107 |         NeuronLearner* pNeuronLearner =
108 |             dynamic_cast<NeuronLearner*>(pBaseLearner);
109 |                 
110 |         pNeuronLearner->_featuresWeight = _featuresWeight;
111 |     }
112 |         
113 |     // -----------------------------------------------------------------------
114 |         
115 | } // end of namespace MultiBoost
116 | 


--------------------------------------------------------------------------------
/src/WeakLearners/OneClassStumpLearner.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file OneClassStumpLearner.h A single threshold decision stump learner. 
 36 |  */
 37 | 
 38 | #ifndef __ONECLASS_STUMP_LEARNER_H
 39 | #define __ONECLASS_STUMP_LEARNER_H
 40 | 
 41 | #include "WeakLearners/ScalarLearner.h"
 42 | #include "WeakLearners/FeaturewiseLearner.h"
 43 | #include "WeakLearners/SingleStumpLearner.h"
 44 | #include "Utils/Args.h"
 45 | #include "IO/InputData.h"
 46 | #include "IO/SortedData.h"
 47 | 
 48 | #include <vector>
 49 | #include <fstream>
 50 | #include <cassert>
 51 | 
 52 | using namespace std;
 53 | 
 54 | //////////////////////////////////////////////////////////////////////////////////////////////
 55 | //////////////////////////////////////////////////////////////////////////////////////////////
 56 | 
 57 | namespace MultiBoost {
 58 |         
 59 |     /**
 60 |      * A \b single threshold decision stump learner. 
 61 |      * There is ONE and ONE ONLY threshold here.
 62 |      */
 63 |     class OneClassStumpLearner : public virtual FeaturewiseLearner, 
 64 |         public virtual ScalarLearner,
 65 |         public virtual SingleStumpLearner
 66 |         {
 67 |         public:
 68 |                 
 69 |             /**
 70 |              * The destructor. Must be declared (virtual) for the proper destruction of 
 71 |              * the object.
 72 |              */
 73 |             virtual ~OneClassStumpLearner() {}
 74 |                 
 75 |             /**
 76 |              * Returns itself as object.
 77 |              * \remark It uses the trick described in http://www.parashift.com/c++-faq-lite/serialization.html#faq-36.8
 78 |              * for the auto-registering classes.
 79 |              * \date 14/11/2005
 80 |              */
 81 |             virtual BaseLearner* subCreate() { return new OneClassStumpLearner(); }
 82 |                 
 83 |                 
 84 |             /**
 85 |              * Run the learner to build the classifier on the given data.
 86 |              * \param pData The pointer to the data.
 87 |              * \see BaseLearner::run
 88 |              * \date 11/11/2005
 89 |              */
 90 |             virtual AlphaReal run();
 91 |                 
 92 |             virtual AlphaReal run( int colIdx );
 93 |                 
 94 |             // TODO: comment
 95 |             virtual AlphaReal run( vector<int>& colIndexes );
 96 |                 
 97 |         };
 98 |         
 99 |     //////////////////////////////////////////////////////////////////////////
100 |         
101 | } // end of namespace MultiBoost
102 | 
103 | #endif // __SINGLE_STUMP_LEARNER_H
104 | 


--------------------------------------------------------------------------------
/src/WeakLearners/ScalarLearner.h:
--------------------------------------------------------------------------------
 1 | /*
 2 |  *
 3 |  *    MultiBoost - Multi-purpose boosting package
 4 |  *
 5 |  *    Copyright (C)        AppStat group
 6 |  *                         Laboratoire de l'Accelerateur Lineaire
 7 |  *                         Universite Paris-Sud, 11, CNRS
 8 |  *
 9 |  *    This file is part of the MultiBoost library
10 |  *
11 |  *    This library is free software; you can redistribute it
12 |  *    and/or modify it under the terms of the GNU General Public
13 |  *    License as published by the Free Software Foundation
14 |  *    version 2.1 of the License.
15 |  *
16 |  *    This library is distributed in the hope that it will be useful,
17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 |  *    General Public License for more details.
20 |  *
21 |  *    You should have received a copy of the GNU General Public
22 |  *    License along with this library; if not, write to the Free Software
23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 |  *
25 |  *    Contact: : multiboost@googlegroups.com
26 |  *
27 |  *    For more information and up-to-date version, please visit
28 |  *
29 |  *                       http://www.multiboost.org/
30 |  *
31 |  */
32 | 
33 | 
34 | #ifndef __SCALARLEARNER_H_
35 | #define __SCALARLEARNER_H_
36 | 
37 | #include "BaseLearner.h"
38 | 
39 | using namespace std;
40 | 
41 | //////////////////////////////////////////////////////////////////////////////////////////////
42 | //////////////////////////////////////////////////////////////////////////////////////////////
43 | 
44 | namespace MultiBoost {
45 | 
46 | /**
47 |  * \file ScalarLearner.h It represents all weak learners that divide into two parts
48 |  * of data using the implementation of phi(x,l) independently on the feature idx.
49 |  *
50 |  * \date 19/07/10
51 |  */
52 | 
53 |     class ScalarLearner: public virtual BaseLearner
54 |     {
55 |     public:
56 |         /**
57 |          * The destructor. Must be declared (virtual) for the proper destruction of
58 |          * the object.
59 |          */
60 |         virtual ~ScalarLearner() {}
61 | 
62 |         /**
63 |          * The single cut function for a particular feature. This function can return
64 |          * with zero as well, indicating that the classifier abstained to classify
65 |          * the instance having index idx.
66 |          * \return +1,-1,0
67 |          * \date 21/10/2010       
68 |          */
69 |         virtual AlphaReal cut( InputData* pData, int idx ) const = 0;
70 |     };
71 | 
72 | }
73 | #endif /* SCALARLEARNER_H_ */
74 | 


--------------------------------------------------------------------------------
/src/WeakLearners/SingleSparseStumpLearner.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it 
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: multiboost@googlegroups.com 
 26 |  * 
 27 |  *    For more information and up-to-date version, please visit
 28 |  *        
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | /**
 35 |  * \file SingleSparseStumpLearner.h A single threshold decision stump learner.
 36 |  */
 37 | 
 38 | #ifndef __SINGLE_SPARSE_STUMP_LEARNER_H
 39 | #define __SINGLE_SPARSE_STUMP_LEARNER_H
 40 | 
 41 | //#include "WeakLearners/ClasswiseLearner.h"
 42 | #include "WeakLearners/FeaturewiseLearner.h"
 43 | #include "Utils/Args.h"
 44 | #include "IO/InputData.h"
 45 | #include "IO/SortedData.h"
 46 | #include "SingleStumpLearner.h"
 47 | 
 48 | #include <vector>
 49 | #include <fstream>
 50 | #include <cassert>
 51 | 
 52 | using namespace std;
 53 | 
 54 | //////////////////////////////////////////////////////////////////////////////////////////////
 55 | //////////////////////////////////////////////////////////////////////////////////////////////
 56 | 
 57 | namespace MultiBoost {
 58 |         
 59 |     /**
 60 |      * A \b single threshold decision stump learner. 
 61 |      * There is ONE and ONE ONLY threshold here. It works on sparse features.
 62 |      */
 63 |     class SingleSparseStumpLearner : public virtual SingleStumpLearner
 64 |     {
 65 |     public:
 66 |         /**
 67 |          * Returns itself as object.
 68 |          * \remark It uses the trick described in http://www.parashift.com/c++-faq-lite/serialization.html#faq-36.8
 69 |          * for the auto-registering classes.
 70 |          * \date 14/11/2005
 71 |          */
 72 |         virtual BaseLearner* subCreate() { return new SingleSparseStumpLearner(); }
 73 |                 
 74 |         /**
 75 |          * The destructor. Must be declared (virtual) for the proper destruction of 
 76 |          * the object.
 77 |          */
 78 |         virtual ~SingleSparseStumpLearner() {}
 79 |                 
 80 |         /**
 81 |          * Run the learner to build the classifier on the given data.
 82 |          * \see FeaturewiseLearner::run
 83 |          * \date 1/11/2009
 84 |          */
 85 |         virtual AlphaReal run();
 86 |                 
 87 |         /**
 88 |          * Run the learner to build the classifier using a single feature from the given data.
 89 |          * \see FeaturewiseLearner::run
 90 |          * \date 11/11/2005
 91 |          */     
 92 |         virtual AlphaReal run( int colIdx );
 93 |                 
 94 |     protected:
 95 |     };
 96 |         
 97 |     //////////////////////////////////////////////////////////////////////////
 98 |         
 99 | } // end of namespace MultiBoost
100 | 
101 | #endif // __SINGLE_SPARSE_STUMP_LEARNER_H
102 | 


--------------------------------------------------------------------------------
/src/WeakLearners/StochasticLearner.h:
--------------------------------------------------------------------------------
  1 | /*
  2 |  *
  3 |  *    MultiBoost - Multi-purpose boosting package
  4 |  *
  5 |  *    Copyright (C)        AppStat group
  6 |  *                         Laboratoire de l'Accelerateur Lineaire
  7 |  *                         Universite Paris-Sud, 11, CNRS
  8 |  *
  9 |  *    This file is part of the MultiBoost library
 10 |  *
 11 |  *    This library is free software; you can redistribute it
 12 |  *    and/or modify it under the terms of the GNU General Public
 13 |  *    License as published by the Free Software Foundation
 14 |  *    version 2.1 of the License.
 15 |  *
 16 |  *    This library is distributed in the hope that it will be useful,
 17 |  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 18 |  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 19 |  *    General Public License for more details.
 20 |  *
 21 |  *    You should have received a copy of the GNU General Public
 22 |  *    License along with this library; if not, write to the Free Software
 23 |  *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
 24 |  *
 25 |  *    Contact: : multiboost@googlegroups.com
 26 |  *
 27 |  *    For more information and up-to-date version, please visit
 28 |  *
 29 |  *                       http://www.multiboost.org/
 30 |  *
 31 |  */
 32 | 
 33 | 
 34 | #ifndef __STOCHASTICLEARNER_H_
 35 | #define __STOCHASTICLEARNER_H_
 36 | 
 37 | #include "BaseLearner.h"
 38 | 
 39 | using namespace std;
 40 | 
 41 | //////////////////////////////////////////////////////////////////////////////////////////////
 42 | //////////////////////////////////////////////////////////////////////////////////////////////
 43 | 
 44 | namespace MultiBoost {
 45 |     enum GradientMethods {
 46 |         OPT_SGD, // stochastic descend
 47 |         OPT_BGD  // batch gradient descend
 48 |     };
 49 |         
 50 |     enum TargetFunctions {
 51 |         TF_EDGE,
 52 |         TF_EXPLOSS
 53 |     };
 54 |         
 55 |         
 56 |     /**
 57 |      * \file StochasticLearner.h It represents all weak learners that can be trained in an online fashion.
 58 |      * \date 03/11/2011
 59 |      */
 60 |         
 61 |     class StochasticLearner : public virtual BaseLearner
 62 |     {
 63 |     public:         
 64 |     StochasticLearner() : BaseLearner(),
 65 |             _gMethod( OPT_BGD ),
 66 |             _tFunction( TF_EXPLOSS ),
 67 |             _maxIter(20),
 68 |             _gammaDivider(1.0),
 69 |             _initialGammat(10.0),
 70 |             _lambda(0.001),
 71 |             _gammdivperiod(1)
 72 |                 
 73 |             {}
 74 |         /**
 75 |          * The destructor. Must be declared (virtual) for the proper destruction of
 76 |          * the object.
 77 |          */
 78 |         virtual ~StochasticLearner() {}
 79 | 
 80 |         /**
 81 |          * Declare weak-learner-specific arguments.
 82 |          * These arguments will be added to the list of arguments under 
 83 |          * the group specific of the weak learner. It is called
 84 |          * automatically in main, when the list of arguments is built up.
 85 |          * Use this method to declare the arguments that belongs to
 86 |          * the weak learner only.
 87 |          * 
 88 |          * This class declares the argument "rtrainingsize".
 89 |          * \param args The Args class reference which can be used to declare
 90 |          * additional arguments.
 91 |          * \date 19/07/2006
 92 |          */
 93 |         virtual void declareArguments(nor_utils::Args& args);
 94 |                 
 95 |         /**
 96 |          * Set the arguments of the algorithm using the standard interface
 97 |          * of the arguments. Call this to set the arguments asked by the user.
 98 |          * \param args The arguments defined by the user in the command line.
 99 |          * \date 24/04/2007
100 |          */
101 |         virtual void initLearningOptions(const nor_utils::Args& args);
102 |                 
103 |         /**
104 |          * Copy all the info we need in classify().
105 |          * pBaseLearner was created by subCreate so it has the correct (sub) type.
106 |          * Usually one must copy the same fields that are loaded and saved. Don't 
107 |          * forget to call the parent's subCopyState().
108 |          * \param pBaseLearner The sub type pointer into which we copy.
109 |          * \see save
110 |          * \see load
111 |          * \see classify
112 |          * \see ProductLearner::run()
113 |          * \date 25/05/2007
114 |          */
115 |         virtual void subCopyState(BaseLearner *pBaseLearner);
116 |                 
117 |         /**
118 |          * Allocate memory for training.
119 |          * \date 03/11/2011
120 |          */             
121 |         virtual void initLearning() = 0;
122 | 
123 |         /**
124 |          * Release memory usied during training.
125 |          * \date 03/11/2011
126 |          */                             
127 |         virtual AlphaReal finishLearning() = 0;
128 |                 
129 |         /**
130 |          * It updates the parameter of weak learner.
131 |          * \return edge for the given istance
132 |          * \date 03/11/2011
133 |          */
134 |         virtual AlphaReal update( int idx ) = 0;
135 |     protected:
136 |         GradientMethods            _gMethod;
137 |         int                        _maxIter;
138 |         TargetFunctions            _tFunction;
139 |                 
140 |                 
141 |         AlphaReal                                       _gammat;                
142 |         AlphaReal                                       _gammaDivider;
143 |         int                                                     _age;
144 |         AlphaReal                                       _initialGammat;
145 |         AlphaReal                                       _nu;
146 |         AlphaReal                                       _lambda;                
147 |         int                                                     _gammdivperiod;         
148 |     };
149 |         
150 | }
151 | #endif /* SCALARLEARNER_H_ */
152 | 


--------------------------------------------------------------------------------
/trash/MathUtils.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | *
 3 | *    MultiBoost - Multi-purpose boosting package
 4 | *
 5 | *    Copyright (C) 2010   AppStat group
 6 | *                         Laboratoire de l'Accelerateur Lineaire
 7 | *                         Universite Paris-Sud, 11, CNRS
 8 | *
 9 | *    This file is part of the MultiBoost library
10 | *
11 | *    This library is free software; you can redistribute it
12 | *    and/or modify it under the terms of the GNU General Public
13 | *    License as published by the Free Software Foundation; either
14 | *    version 2.1 of the License, or (at your option) any later version.
15 | *
16 | *    This library is distributed in the hope that it will be useful,
17 | *    but WITHOUT ANY WARRANTY; without even the implied warranty of
18 | *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
19 | *    General Public License for more details.
20 | *
21 | *    You should have received a copy of the GNU General Public
22 | *    License along with this library; if not, write to the Free Software
23 | *    Foundation, Inc., 51 Franklin St, 5th Floor, Boston, MA 02110-1301 USA
24 | *
25 | *    Contact: Balazs Kegl (balazs.kegl@gmail.com)
26 | *             Norman Casagrande (nova77@gmail.com)
27 | *             Robert Busa-Fekete (busarobi@gmail.com)
28 | *
29 | *    For more information and up-to-date version, please visit
30 | *
31 | *                       http://www.multiboost.org/
32 | *
33 | */
34 | 
35 | 
36 | #include "blaswrap.h"
37 | #include "f2c.h"
38 | 
39 | #define DIM 1024
40 | #define WSIZE DIM * DIM
41 | 
42 | //for MDL
43 | static doublereal       work[WSIZE];
44 | static integer          ipiv[WSIZE];
45 | 
46 | 
47 | //////////////////////////////////////////////////////////////////////////////////////////////
48 | // extern for lapack routines
49 | extern "C" /* Subroutine */ int dgetri_(integer *n, doublereal *a, integer *lda, integer 
50 | 	*ipiv, doublereal *work, integer *lwork, integer *info);
51 | extern "C" /* Subroutine */ int sgemm_(char *transa, char *transb, integer *m, integer *
52 | 	n, integer *k, real *alpha, real *a, integer *lda, real *b, integer *
53 | 	ldb, real *beta, real *c__, integer *ldc);
54 | extern "C" /* Subroutine */ int dgetrf_(integer *m, integer *n, doublereal *a, integer *
55 | 	lda, integer *ipiv, integer *info);
56 | extern "C" void solveEquationSystem( double* X, double* b, int* N );
57 | 
58 | int matrixInverse( integer *n, doublereal *a );
59 | void solveEquationSystem( double* X, double* b, int* N );
60 | 
61 | 
62 | 
63 | 
64 | void solveEquationSystem( double* X, double* b, int* N ) {
65 | 	matrixInverse( (integer*) N, (doublereal*) X );
66 | 	double* sum = new double[ *N ];
67 | 	for( int i = 0; i < *N; i++ ) {
68 | 		sum[i] = 0.0;
69 | 		for( int j = 0; j < *N; j++ ) {
70 | 			sum[i] += (X[(i*(*N))+j] * b[j]);
71 | 		}
72 | 	}
73 | 	for( int i = 0; i < *N; i++ ) {
74 | 		b[i] = sum[i];
75 | 	}
76 | 	
77 | 	delete [] sum;
78 | }
79 | 
80 | 
81 | int matrixInverse( integer *n, doublereal *a ) {
82 |     integer info;
83 |     static integer lwork = WSIZE;
84 |     
85 | 	dgetrf_( n, n, a, n, ipiv, &info);
86 |     dgetri_( n, a, n, ipiv, work, &lwork, &info);    
87 |     return info;
88 | }
89 | 


--------------------------------------------------------------------------------
/version:
--------------------------------------------------------------------------------
1 | 1.2.01


--------------------------------------------------------------------------------