1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
|
/*
* Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
*
* This file is part of Orfeo Toolbox
*
* https://www.orfeo-toolbox.org/
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef otbSharkKMeansMachineLearningModel_h
#define otbSharkKMeansMachineLearningModel_h
#include <memory>
#include "itkLightObject.h"
#include "otbMachineLearningModel.h"
// Quiet a deprecation warning
#define BOOST_BIND_GLOBAL_PLACEHOLDERS
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic push
#if (defined (__GNUC__) && (__GNUC__ >= 9)) || (defined (__clang__) && (__clang_major__ >= 10))
#pragma GCC diagnostic ignored "-Wdeprecated-copy"
#endif
#pragma GCC diagnostic ignored "-Wshadow"
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Woverloaded-virtual"
#pragma GCC diagnostic ignored "-Wignored-qualifiers"
#pragma GCC diagnostic ignored "-Wsign-compare"
#pragma GCC diagnostic ignored "-Wcast-align"
#pragma GCC diagnostic ignored "-Wunknown-pragmas"
#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wheader-guard"
#pragma clang diagnostic ignored "-Wexpansion-to-defined"
#else
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
#endif
#include "otb_shark.h"
#include "shark/Models/Clustering/HardClusteringModel.h"
#include "shark/Models/Clustering/SoftClusteringModel.h"
#include "shark/Models/Clustering/Centroids.h"
#include "shark/Models/Clustering/ClusteringModel.h"
#include "shark/Algorithms/KMeans.h"
#include "shark/Models/Normalizer.h"
#if defined(__GNUC__) || defined(__clang__)
#pragma GCC diagnostic pop
#endif
/** \class SharkKMeansMachineLearningModel
* \brief Shark version of Random Forests algorithm
*
* This is a specialization of MachineLearningModel class allowing to
* use Shark implementation of the Random Forests algorithm.
*
* It is noteworthy that training step is parallel.
*
* For more information, see
* http://image.diku.dk/shark/sphinx_pages/build/html/rest_sources/tutorials/algorithms/kmeans.html
*
* \ingroup OTBUnsupervised
*/
namespace otb
{
template <class TInputValue, class TTargetValue>
class ITK_EXPORT SharkKMeansMachineLearningModel : public MachineLearningModel<TInputValue, TTargetValue>
{
public:
/** Standard class typedefs. */
typedef SharkKMeansMachineLearningModel Self;
typedef MachineLearningModel<TInputValue, TTargetValue> Superclass;
typedef itk::SmartPointer<Self> Pointer;
typedef itk::SmartPointer<const Self> ConstPointer;
typedef typename Superclass::InputValueType InputValueType;
typedef typename Superclass::InputSampleType InputSampleType;
typedef typename Superclass::InputListSampleType InputListSampleType;
typedef typename Superclass::TargetValueType TargetValueType;
typedef typename Superclass::TargetSampleType TargetSampleType;
typedef typename Superclass::TargetListSampleType TargetListSampleType;
typedef typename Superclass::ConfidenceValueType ConfidenceValueType;
typedef typename Superclass::ConfidenceSampleType ConfidenceSampleType;
typedef typename Superclass::ConfidenceListSampleType ConfidenceListSampleType;
typedef typename Superclass::ProbaSampleType ProbaSampleType;
typedef typename Superclass::ProbaListSampleType ProbaListSampleType;
typedef shark::HardClusteringModel<shark::RealVector> ClusteringModelType;
typedef ClusteringModelType::OutputType ClusteringOutputType;
/** Run-time type information (and related methods). */
itkNewMacro(Self);
itkTypeMacro(SharkKMeansMachineLearningModel, MachineLearningModel);
/** Train the machine learning model */
virtual void Train() override;
/** Save the model to file */
virtual void Save(const std::string& filename, const std::string& name = "") override;
/** Load the model from file */
virtual void Load(const std::string& filename, const std::string& name = "") override;
/**\name Classification model file compatibility tests */
//@{
/** Is the input model file readable and compatible with the corresponding classifier ? */
virtual bool CanReadFile(const std::string&) override;
/** Is the input model file writable and compatible with the corresponding classifier ? */
virtual bool CanWriteFile(const std::string&) override;
//@}
/** Get the maximum number of iteration for the kMeans algorithm.*/
itkGetMacro(MaximumNumberOfIterations, unsigned);
/** Set the maximum number of iteration for the kMeans algorithm.*/
itkSetMacro(MaximumNumberOfIterations, unsigned);
/** Get the number of class for the kMeans algorithm.*/
itkGetMacro(K, unsigned);
/** Set the number of class for the kMeans algorithm.*/
itkSetMacro(K, unsigned);
/** Initialize the centroids for the kmeans algorithm */
void SetCentroidsFromData(const shark::Data<shark::RealVector>& data)
{
m_Centroids.setCentroids(data);
this->Modified();
}
void ExportCentroids(const std::string& filename);
protected:
/** Constructor */
SharkKMeansMachineLearningModel();
/** Destructor */
virtual ~SharkKMeansMachineLearningModel();
/** Predict values using the model */
virtual TargetSampleType DoPredict(const InputSampleType& input, ConfidenceValueType* quality = nullptr, ProbaSampleType* proba = nullptr) const override;
virtual void DoPredictBatch(const InputListSampleType*, const unsigned int& startIndex, const unsigned int& size, TargetListSampleType*,
ConfidenceListSampleType* = nullptr, ProbaListSampleType* = nullptr) const override;
/** PrintSelf method */
void PrintSelf(std::ostream& os, itk::Indent indent) const override;
private:
SharkKMeansMachineLearningModel(const Self&) = delete;
void operator=(const Self&) = delete;
// Parameters set by the user
unsigned int m_K;
unsigned int m_MaximumNumberOfIterations;
bool m_CanRead;
/** Centroids results form kMeans */
shark::Centroids m_Centroids;
/** shark Model could be SoftClusteringModel or HardClusteringModel */
std::shared_ptr<ClusteringModelType> m_ClusteringModel;
};
} // end namespace otb
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbSharkKMeansMachineLearningModel.hxx"
#endif
#endif
|
