TEST: new tests for DR models

Modules/Learning/DimensionalityReductionLearning/test/CMakeLists.txt

@@ -23,6 +23,8 @@ otb_module_test()
 set(OTBDimensionalityReductionLearningTests
 otbDimensionalityReductionLearningTestDriver.cxx
 otbAutoencoderModelTest.cxx
+otbPCAModelTest.cxx
+otbSOMModelTest.cxx
 )
 
 add_executable(otbDimensionalityReductionLearningTestDriver ${OTBDimensionalityReductionLearningTests})
@@ -40,13 +42,61 @@ otb_add_test(NAME leTvAutoencoderModelTrain COMMAND
   otbDimensionalityReductionLearningTestDriver
   otbAutoencoderModeTrain
   ${INPUTDATA}/letter_light.scale
-  ${TEMP}/ae_model.txt
+  ${TEMP}/model.ae
   )
 
 otb_add_test(NAME leTvAutoencoderModelCanRead COMMAND
   otbDimensionalityReductionLearningTestDriver
   otbAutoencoderModelCanRead
-  ${TEMP}/ae_model.txt
+  ${TEMP}/model.ae
   )
 
 set_property(TEST leTvAutoencoderModelCanRead APPEND PROPERTY DEPENDS leTvAutoencoderModelTrain)
+
+# --------------- PCA --------------------------------
+otb_add_test(NAME leTuPCAModelNew COMMAND
+  otbDimensionalityReductionLearningTestDriver
+  otbPCAModelNew
+  )
+
+otb_add_test(NAME leTvPCAModelTrain COMMAND
+  otbDimensionalityReductionLearningTestDriver
+  otbPCAModeTrain
+  ${INPUTDATA}/letter_light.scale
+  ${TEMP}/model.pca
+  )
+
+otb_add_test(NAME leTvPCAModelCanRead COMMAND
+  otbDimensionalityReductionLearningTestDriver
+  otbPCAModelCanRead
+  ${TEMP}/model.pca
+  )
+
+set_property(TEST leTvPCAModelCanRead APPEND PROPERTY DEPENDS leTvPCAModelTrain)
+
+# --------------- SOM --------------------------------
+otb_add_test(NAME leTuSOMModelNew COMMAND
+  otbDimensionalityReductionLearningTestDriver
+  otbSOMModelNew
+  )
+
+otb_add_test(NAME leTvSOMModelTrain COMMAND
+  otbDimensionalityReductionLearningTestDriver
+  otbSOMModeTrain
+  ${INPUTDATA}/letter_light.scale
+  ${TEMP}/model2D.som
+  ${TEMP}/model3D.som
+  ${TEMP}/model4D.som
+  ${TEMP}/model5D.som
+  )
+
+otb_add_test(NAME leTvSOMModelCanRead COMMAND
+  otbDimensionalityReductionLearningTestDriver
+  otbSOMModelCanRead
+  ${TEMP}/model2D.som
+  ${TEMP}/model3D.som
+  ${TEMP}/model4D.som
+  ${TEMP}/model5D.som
+  )
+
+set_property(TEST leTvSOMModelCanRead APPEND PROPERTY DEPENDS leTvSOMModelTrain)

Modules/Learning/DimensionalityReductionLearning/test/otbAutoencoderModelTest.cxx

@@ -88,7 +88,7 @@ int otbAutoencoderModeTrain(int argc, char * argv [])
 
   LogAutoencoderModel::Pointer model = LogAutoencoderModel::New();
   model->SetNumberOfHiddenNeurons(nb_neuron);
-  model->SetNumberOfIterations(100);
+  model->SetNumberOfIterations(50);
   model->SetNumberOfIterationsFineTuning(0);
   model->SetEpsilon(0.0);
   model->SetInitFactor(1.0);

Modules/Learning/DimensionalityReductionLearning/test/otbDimensionalityReductionLearningTestDriver.cxx

@@ -25,4 +25,10 @@ void RegisterTests()
   REGISTER_TEST(otbAutoencoderModelNew);
   REGISTER_TEST(otbAutoencoderModelCanRead);
   REGISTER_TEST(otbAutoencoderModeTrain);
+  REGISTER_TEST(otbPCAModelNew);
+  REGISTER_TEST(otbPCAModelCanRead);
+  REGISTER_TEST(otbPCAModeTrain);
+  REGISTER_TEST(otbSOMModelNew);
+  REGISTER_TEST(otbSOMModelCanRead);
+  REGISTER_TEST(otbSOMModeTrain);
 }

Modules/Learning/DimensionalityReductionLearning/test/otbPCAModelTest.cxx

@@ -18,3 +18,61 @@
  * limitations under the License.
  */
 
+#include "otbPCAModel.h"
+#include "otbReadDataFile.h"
+
+typedef otb::PCAModel<double> PCAModelType;
+typedef PCAModelType::InputListSampleType InputListSampleType;
+typedef PCAModelType::TargetListSampleType TargetListSampleType;
+
+int otbPCAModelNew(int itkNotUsed(argc), char * itkNotUsed(argv) [])
+{
+  PCAModelType::Pointer model = PCAModelType::New();
+
+  return EXIT_SUCCESS;
+}
+
+int otbPCAModelCanRead(int argc, char * argv [])
+{
+  if (argc < 2)
+    {
+    std::cerr << "Usage: " << argv[0] << " <model>" << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  PCAModelType::Pointer model = PCAModelType::New();
+  std::string filename(argv[1]);
+  if (! model->CanReadFile(filename) )
+    {
+    std::cerr << "Failed to read model file : "<< filename << std::endl;
+    return EXIT_FAILURE;
+    }
+  return EXIT_SUCCESS;
+}
+
+int otbPCAModeTrain(int argc, char * argv [])
+{
+  if (argc < 3)
+    {
+    std::cerr << "Usage: " << argv[0] << " letter.scale  model.out" << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Extract data from letter.scale
+  InputListSampleType::Pointer samples = InputListSampleType::New();
+  TargetListSampleType::Pointer target = TargetListSampleType::New();
+  if (!otb::ReadDataFile(argv[1], samples, target))
+    {
+    std::cout << "Failed to read samples file " << argv[1] << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  PCAModelType::Pointer model = PCAModelType::New();
+  model->SetDimension(14);
+  model->SetWriteEigenvectors(true);
+  model->SetInputListSample(samples);
+  model->Train();
+  model->Save(std::string(argv[2]));
+
+  return EXIT_SUCCESS;
+}

Modules/Learning/DimensionalityReductionLearning/test/otbSOMModelTest.cxx

@@ -18,3 +18,151 @@
  * limitations under the License.
  */
 
+#include "otbSOMModel.h"
+#include "otbReadDataFile.h"
+
+typedef otb::SOMModel<double,2> SOMModel2D;
+typedef otb::SOMModel<double,3> SOMModel3D;
+typedef otb::SOMModel<double,4> SOMModel4D;
+typedef otb::SOMModel<double,5> SOMModel5D;
+
+typedef SOMModel2D::InputListSampleType InputListSampleType;
+typedef SOMModel2D::TargetListSampleType TargetListSampleType;
+
+int otbSOMModelNew(int itkNotUsed(argc), char * itkNotUsed(argv) [])
+{
+  SOMModel2D::Pointer model2D = SOMModel2D::New();
+  SOMModel3D::Pointer model3D = SOMModel3D::New();
+  SOMModel4D::Pointer model4D = SOMModel4D::New();
+  SOMModel5D::Pointer model5D = SOMModel5D::New();
+
+  return EXIT_SUCCESS;
+}
+
+int otbSOMModelCanRead(int argc, char * argv [])
+{
+  if (argc < 2)
+    {
+    std::cerr << "Usage: " << argv[0] << " <model2D> <model3D> <model4D> <model5D>" << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  std::string filename2D(argv[1]);
+  std::string filename3D(argv[2]);
+  std::string filename4D(argv[3]);
+  std::string filename5D(argv[4]);
+
+  SOMModel2D::Pointer model2D = SOMModel2D::New();
+  SOMModel3D::Pointer model3D = SOMModel3D::New();
+  SOMModel4D::Pointer model4D = SOMModel4D::New();
+  SOMModel5D::Pointer model5D = SOMModel5D::New();
+
+  if (! model2D->CanReadFile(filename2D) )
+    {
+    std::cerr << "Failed to read model file : "<< filename2D << std::endl;
+    return EXIT_FAILURE;
+    }
+  if (! model3D->CanReadFile(filename3D) )
+    {
+    std::cerr << "Failed to read model file : "<< filename3D << std::endl;
+    return EXIT_FAILURE;
+    }
+  if (! model4D->CanReadFile(filename4D) )
+    {
+    std::cerr << "Failed to read model file : "<< filename4D << std::endl;
+    return EXIT_FAILURE;
+    }
+  if (! model5D->CanReadFile(filename5D) )
+    {
+    std::cerr << "Failed to read model file : "<< filename5D << std::endl;
+    return EXIT_FAILURE;
+    }
+  return EXIT_SUCCESS;
+}
+
+int otbSOMModeTrain(int argc, char * argv [])
+{
+  if (argc < 3)
+    {
+    std::cerr << "Usage: " << argv[0] << " letter.scale  model2D.out model3D.out model4D.out model5D.out" << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  // Extract data from letter.scale
+  InputListSampleType::Pointer samples = InputListSampleType::New();
+  TargetListSampleType::Pointer target = TargetListSampleType::New();
+  if (!otb::ReadDataFile(argv[1], samples, target))
+    {
+    std::cout << "Failed to read samples file " << argv[1] << std::endl;
+    return EXIT_FAILURE;
+    }
+
+  SOMModel2D::Pointer model2D = SOMModel2D::New();
+  SOMModel3D::Pointer model3D = SOMModel3D::New();
+  SOMModel4D::Pointer model4D = SOMModel4D::New();
+  SOMModel5D::Pointer model5D = SOMModel5D::New();
+
+  SOMModel2D::SizeType size2D, radius2D;
+  size2D.Fill(10);
+  radius2D.Fill(3);
+  SOMModel3D::SizeType size3D, radius3D;
+  size3D.Fill(6);
+  radius3D.Fill(3);
+  SOMModel4D::SizeType size4D, radius4D;
+  size4D.Fill(4);
+  radius4D.Fill(2);
+  SOMModel5D::SizeType size5D, radius5D;
+  size5D.Fill(3);
+  radius5D.Fill(2);
+
+  std::cout << "Train 2D model..."<< std::endl;
+  model2D->SetNumberOfIterations(10);
+  model2D->SetBetaInit(1.0);
+  model2D->SetWriteMap(true);
+  model2D->SetBetaEnd(0.1);
+  model2D->SetMaxWeight(10.0);
+  model2D->SetMapSize(size2D);
+  model2D->SetNeighborhoodSizeInit(radius2D);
+  model2D->SetInputListSample(samples);
+  model2D->Train();
+  model2D->Save(std::string(argv[2]));
+
+  std::cout << "Train 3D model..."<< std::endl;
+  model3D->SetNumberOfIterations(10);
+  model3D->SetBetaInit(1.0);
+  model3D->SetWriteMap(true);
+  model3D->SetBetaEnd(0.1);
+  model3D->SetMaxWeight(10.0);
+  model3D->SetMapSize(size3D);
+  model3D->SetNeighborhoodSizeInit(radius3D);
+  model3D->SetInputListSample(samples);
+  model3D->Train();
+  model3D->Save(std::string(argv[3]));
+
+  std::cout << "Train 4D model..."<< std::endl;
+  model4D->SetNumberOfIterations(10);
+  model4D->SetBetaInit(1.0);
+  model4D->SetWriteMap(true);
+  model4D->SetBetaEnd(0.1);
+  model4D->SetMaxWeight(10.0);
+  model4D->SetMapSize(size4D);
+  model4D->SetNeighborhoodSizeInit(radius4D);
+  model4D->SetInputListSample(samples);
+  model4D->Train();
+  model4D->Save(std::string(argv[4]));
+
+  std::cout << "Train 5D model..."<< std::endl;
+  model5D->SetNumberOfIterations(10);
+  model5D->SetBetaInit(1.0);
+  model5D->SetWriteMap(true);
+  model5D->SetBetaEnd(0.1);
+  model5D->SetMaxWeight(10.0);
+  model5D->SetMapSize(size5D);
+  model5D->SetNeighborhoodSizeInit(radius5D);
+  model5D->SetInputListSample(samples);
+  model5D->Train();
+  model5D->Save(std::string(argv[5]));
+
+  return EXIT_SUCCESS;
+}
+