[WIP] An implementation of discontiguous sampling of the SRerf variant; we call it MTORF(?)

Python/rerf/rerfClassifier.py

@@ -230,7 +230,7 @@ def fit(self, X, y):
             else:
                 forestType = "binnedBaseTern"
             self.method_to_use_ = 1
-        elif self.projection_matrix == "S-RerF":
+        elif self.projection_matrix in ["S-RerF", "MT-MORF"]:
             if self.oob_score:
                 warn(
                     "OOB is not currently implemented for the S-RerF"
@@ -241,7 +241,12 @@ def fit(self, X, y):
                 self.oob_score = False
 
             forestType = "binnedBaseTern"  # this should change
-            self.method_to_use_ = 2
+
+            if self.projection_matrix == 'S-RerF':
+                self.method_to_use_ = 2
+            elif self.projection_matrix == 'MT-MORF':
+                self.method_to_use_ = 3
+
             # Check that image_height and image_width are divisors of
             # the num_features.  This is the most we can do to
             # prevent an invalid value being passed in.

packedForest/Makefile

@@ -1,7 +1,8 @@
 #Compiler and Linker
 #CC          := g++-mp-4.7
 CC          := g++ -std=c++11
-#CC          := g++-6 -std=c++11
+# CC          := gcc-9 -std=c++11 -c
+# CC          := g++-6 -std=c++11
 
 #The Target Binary Program
 TARGET      := fp
@@ -21,7 +22,7 @@ OBJEXT      := o
 CFLAGS      := -fopenmp -Wall -O3 -DNDEBUG -ffast-math
 CFLAGS      := -fopenmp -Wall -O3 -ffast-math
 #LIB         := -fopenmp -lm -lnuma
-LIB         :=  -fopenmp -lm -O3 
+LIB         := -fopenmp -lm -O3 
 INC         := -I$(INCDIR) -I/usr/local/include -I/usr/local/include/eigen3
 INCDEP      := -I$(INCDIR)
 

packedForest/src/forestTypes/binnedTree/processingNodeBin.h

@@ -81,7 +81,7 @@ namespace fp{
 				inline void calcMtryForNode(std::vector<weightedFeature>& featuresToTry){
 					featuresToTry.resize(fpSingleton::getSingleton().returnMtry());
 					int methodToUse = fpSingleton::getSingleton().returnMethodToUse();
-					assert(methodToUse == 1 || methodToUse == 2);
+					assert(methodToUse == 1 || methodToUse == 2 || methodToUse == 3 || methodToUse == 4);
 
 					switch(methodToUse){
 						case 1:{
@@ -92,6 +92,13 @@ namespace fp{
 							randMatImagePatch(featuresToTry, paramsRandMatImagePatch());
 							break;
 							}
+						case 3:{
+							randMatMultivariateTimePatch(featuresToTry, paramsRandMatImagePatch());
+							break;
+						case 4:{
+							randMatMultivariateTimePatchv2(featuresToTry, paramsRandMatImagePatch());
+						}
+						}
 					}
 				}
 
@@ -176,6 +183,80 @@ namespace fp{
 				} // END randMatStructured
 
 
+				inline void randMatMultivariateTimePatch(std::vector<weightedFeature>& featuresToTry, std::vector<std::vector<int> > patchPositions){
+					assert((int)(patchPositions[0].size()) == fpSingleton::getSingleton().returnMtry());
+
+					// Preset parameters
+					const int& imageHeight = fpSingleton::getSingleton().returnImageHeight();
+					const int& imageWidth = fpSingleton::getSingleton().returnImageWidth();
+
+					std::default_random_engine generator(randNum->gen());
+
+					int pixelIndex = -1;
+					for (int k = 0; k < fpSingleton::getSingleton().returnMtry(); k++) {
+						const int& numRowsInPatch = patchPositions[0][k];
+
+						// fill with values 0, 1, ..., imageHeight - 1
+						std::vector<int> rowInds(imageHeight);
+						std::iota(std::begin(rowInds), std::end(rowInds), 0);
+
+						// shuffle and select row indices
+						std::shuffle(rowInds.begin(), rowInds.end(), generator);
+						std::vector<int> selectedRows(rowInds.begin(), rowInds.begin() + numRowsInPatch);
+
+						assert((int) selectedRows.size() == numRowsInPatch);
+
+						for (int row = 0; row < numRowsInPatch; row++) {
+							for (int col = 0; col < patchPositions[1][k]; col++) {
+								pixelIndex = (patchPositions[2][k] % imageWidth) + col + (selectedRows[row] * imageWidth);
+								featuresToTry[k].returnFeatures().push_back(pixelIndex);
+								featuresToTry[k].returnWeights().push_back(1); // weight hard-coded to 1.
+								}
+						} // Could possibly turn this into one for-loop somehow later. [JLP]
+					}
+				} // END randMatStructured
+
+
+				inline void randMatMultivariateTimePatchv2(std::vector<weightedFeature>& featuresToTry, std::vector<std::vector<int> > patchPositions){
+					assert((int)(patchPositions[0].size()) == fpSingleton::getSingleton().returnMtry());
+
+					// Preset parameters
+					const int& imageHeight = fpSingleton::getSingleton().returnImageHeight();
+					const int& imageWidth = fpSingleton::getSingleton().returnImageWidth();
+
+					std::default_random_engine generator(randNum->gen());
+
+					int pixelIndex = -1;
+					for (int k = 0; k < fpSingleton::getSingleton().returnMtry(); k++) {
+						const int& numRowsInPatch = patchPositions[0][k];
+						const int& numColsInPatch = patchPositions[1][k];
+
+						// fill with values 0, 1, ..., imageHeight - 1
+						std::vector<int> rowInds(imageHeight);
+						std::iota(std::begin(rowInds), std::end(rowInds), 0);
+
+						// fill with values 0, 1, ..., imageWidth - 1
+						std::vector<int> colInds(imageWidth);
+						std::iota(std::begin(colInds), std::end(colInds), 0);
+
+						// shuffle and select indices
+						std::shuffle(rowInds.begin(), rowInds.end(), generator);
+						std::shuffle(colInds.begin(), colInds.end(), generator);
+						std::vector<int> selectedRows(rowInds.begin(), rowInds.begin() + numRowsInPatch);
+						std::vector<int> selectedCols(colInds.begin(), colInds.begin() + numColsInPatch);
+
+						assert((int) selectedRows.size() == numRowsInPatch);
+
+						for (int row = 0; row < numRowsInPatch; row++) {
+							for (int col = 0; col < numColsInPatch; col++) {
+								pixelIndex = (patchPositions[2][k] % imageWidth) + (selectedCols[col] * imageHeight) + (selectedRows[row] * imageWidth);
+								featuresToTry[k].returnFeatures().push_back(pixelIndex);
+								featuresToTry[k].returnWeights().push_back(1); // weight hard-coded to 1.
+								}
+						} // Could possibly turn this into one for-loop somehow later. [JLP]
+					}
+				} // END randMatStructured
+
 				inline void resetLeftNode(){
 					propertiesOfLeftNode.resetClassTotals();
 				}

packedForest/src/fp.cpp

@@ -92,6 +92,33 @@ int main(int argc, char* argv[]) {
                         	case 14:
                                 	forest.setParameter("forestType", "urerf");
                                 	break;
+				case 15:
+					forest.setParameter("forestType", "binnedBaseTern");
+					forest.setParameter("numTreeBins", numCores);
+					forest.setParameter("methodToUse", 3);
+					forest.setParameter("imageHeight", 28);
+					forest.setParameter("imageWidth", 28);
+					forest.setParameter("patchHeightMax", 5);
+					forest.setParameter("patchHeightMin", 5);
+					forest.setParameter("patchWidthMax", 5);
+					forest.setParameter("patchWidthMin", 5);
+					std::cout << "\nForcing dataset to be MNIST:\n";
+					dataSet = 3;
+					break;
+
+				case 16:
+					forest.setParameter("forestType", "binnedBaseTern");
+					forest.setParameter("numTreeBins", numCores);
+					forest.setParameter("methodToUse", 4);
+					forest.setParameter("imageHeight", 28);
+					forest.setParameter("imageWidth", 28);
+					forest.setParameter("patchHeightMax", 5);
+					forest.setParameter("patchHeightMin", 5);
+					forest.setParameter("patchWidthMax", 5);
+					forest.setParameter("patchWidthMin", 5);
+					std::cout << "\nForcing dataset to be MNIST:\n";
+					dataSet = 3;
+					break;
 
 				default:
 					std::cout << "unknown alg selected" << std::endl;

packedForest/src/fpSingleton/fpInfo.h

@@ -324,8 +324,8 @@ namespace fp {
 					useRowMajor = (bool)parameterValue;
 				}else if(parameterName == "methodToUse"){
 					methodToUse = parameterValue;
-					if(!(methodToUse == 1 || methodToUse == 2)){
-						throw std::runtime_error("methodToUse outside allowable parameters {1,2}.");
+					if(!(methodToUse == 1 || methodToUse == 2 || methodToUse == 3)){
+						throw std::runtime_error("methodToUse outside allowable parameters {1,2,3}.");
 					}
 				}else if(parameterName == "imageHeight"){
 					imageHeight = parameterValue;
@@ -363,7 +363,7 @@ namespace fp {
 				std::cout << "seed -> " << seed << "\n";
 				std::cout << "numTreeBins -> " << numTreeBins << "\n";
 
-				if(methodToUse == 2){
+				if(methodToUse == 2 || methodToUse == 3){
 					std::cout << "imageHeight -> " << imageHeight << "\n";
 					std::cout << "imageWidth -> " << imageWidth << "\n";
 					std::cout << "patchHeightMax -> " << patchHeightMax << "\n";

packedForest/src/fpSingleton/fpSingleton.h

@@ -190,7 +190,7 @@ namespace fp {
 
 			inline void checkDataDependentParameters(){
 				// For Structured RerF
-				if(fpForestInfo.returnMethodToUse() == 2){
+				if(fpForestInfo.returnMethodToUse() == 2 || fpForestInfo.returnMethodToUse() == 3){
 					if((fpSingleton::getSingleton().returnNumFeatures() % fpSingleton::getSingleton().returnImageHeight()) != 0){
 						throw std::runtime_error("Specified image height is not a multiple of the number of features." );
 					}