1 #ifndef KMEANSEVALUATOR_H
2 #define KMEANSEVALUATOR_H
4 #include "../base/measuresetter.h"
5 #include "../base/partitionprovider.h"
6 #include "../base/proxyevaluation.h"
7 #include "../base/combinedevaluation.h"
8 #include "../base/dissimilaritymeasure.h"
49 virtual double proxycost(std::vector<T*>
const& points, std::vector<T>
const& proxies)
const;
54 virtual double proxycost(std::vector<T*>
const& points, std::vector<T*>
const& proxies)
const;
61 virtual double proxycost(std::vector<T*>
const& points,
ProxyProvider<T> const &proxySource,
unsigned int solutionIndex)
const;
74 virtual double proxycost(std::vector<T*>
const& points, std::vector<T>
const& proxies,
unsigned int index)
const;
79 virtual double proxycost(std::vector<T*>
const& points, std::vector<T*>
const& proxies,
unsigned int index)
const;
86 virtual double proxycost(std::vector<T*>
const& points,
ProxyProvider<T> const &proxySource,
unsigned int solutionIndex,
unsigned int proxyIndex)
const;
98 virtual double combinedcost(std::vector<std::vector<T*> >
const& clusters, std::vector<T>
const& proxies)
const;
103 virtual double combinedcost(std::vector<std::vector<T*> >
const& clusters, std::vector<T*>
const& proxies)
const;
122 virtual double combinedcost(std::vector<T*>
const& cluster, T
const& proxy)
const;
139 std::vector<double>
proxycostGeneric(std::vector<T*>
const& points, std::vector<T>
const& proxies)
const;
144 std::vector<double>
proxycostGeneric(std::vector<T*>
const& points, std::vector<T*>
const& proxies)
const;
152 measure(measure==0 ? 0 : measure->clone()), weightModifier(0)
158 measure(kme.measure == 0 ? 0 : kme.measure->clone()), weightModifier(0)
166 if(weightModifier != 0)
167 delete weightModifier;
182 if(weightModifier != 0)
183 delete weightModifier;
190 std::vector<double> values = proxycostGeneric(points, proxies);
191 int numOfValues = values.size();
194 for(
int i = 0; i < numOfValues; i++)
204 std::vector<double> values = proxycostGeneric(points, proxies);
205 int numOfValues = values.size();
208 for(
int i = 0; i < numOfValues; i++)
218 return proxycost(points, provider.
proxies(solutionIndex));
229 std::vector<double> values = proxycostGeneric(points, proxies);
230 return values.at(index);
235 std::vector<double> values = proxycostGeneric(points, proxies);
236 return values.at(index);
241 return proxycost(points, provider.
proxies(solutionIndex), proxyIndex);
246 return proxycost(points, provider.
discrete_proxies(solutionIndex), proxyIndex);
254 this->measure = measure->
clone();
261 int numOfPoints = points.size();
262 int numOfProxies = proxies.size();
264 std::vector<double> result(numOfProxies, 0);
266 for(
int i = 0; i < numOfPoints; i++)
268 T* point = points[i];
270 double min = this->measure->dissimilarity(*point, proxies[0]);
271 int assignedProxy = 0;
272 for(
int j = 1; j < numOfProxies; j++)
274 T proxy = proxies[j];
275 double candidate = this->measure->dissimilarity(*point, proxy);
282 if(weightModifier != 0)
283 min *= weightModifier->getWeight(*point);
284 result[assignedProxy] += min;
293 int numOfPoints = points.size();
294 int numOfProxies = proxies.size();
296 std::vector<double> result(numOfProxies, 0);
298 for(
int i = 0; i < numOfPoints; i++)
300 T* point = points[i];
302 double min = this->measure->dissimilarity(*point, *proxies[0]);
303 int assignedProxy = 0;
304 for(
int j = 1; j < numOfProxies; j++)
306 T* proxy = proxies[j];
307 double candidate = this->measure->dissimilarity(*point, *proxy);
314 if(weightModifier != 0)
315 min *= weightModifier->getWeight(*point);
316 result[assignedProxy] += min;
328 int numOfClusters = clusters.size();
329 int numOfProxies = proxies.size();
330 int minNumOfClustersProxies = numOfClusters < numOfProxies ? numOfClusters : numOfProxies;
332 for(
int i = 0; i < minNumOfClustersProxies; i++)
334 sum += combinedcost(clusters[i], proxies[i]);
337 if(numOfClusters < numOfProxies)
339 std::clog <<
"CluE::KMeansEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T>) - WARNING: More proxies than clusters: ignoring redundant proxies." << std::endl;
341 else if(numOfClusters > numOfProxies)
343 std::clog <<
"CluE::KMeansEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T>) - WARNING: Less proxies than clusters: assigning remaining points to proxies." << std::endl;
344 for(
int i = numOfProxies; i < numOfClusters; i++)
346 sum += proxycost(clusters[i], proxies);
357 int numOfClusters = clusters.size();
358 int numOfProxies = proxies.size();
359 int minNumOfClustersProxies = numOfClusters < numOfProxies ? numOfClusters : numOfProxies;
361 for(
int i = 0; i < minNumOfClustersProxies; i++)
366 if(numOfClusters < numOfProxies)
368 std::clog <<
"CluE::KMeansEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T*>) - WARNING: More proxies than clusters: ignoring redundant proxies." << std::endl;
370 else if(numOfClusters > numOfProxies)
372 std::clog <<
"CluE::KMeansEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T*>) - WARNING: Less proxies than clusters: assigning remaining points to proxies." << std::endl;
373 for(
int i = numOfProxies; i < numOfClusters; i++)
375 sum += proxycost(clusters[i], proxies);
384 return combinedcost(clusterProvider.
clustering(solutionIndex), proxyProvider.
proxies(solutionIndex));
396 int numOfPoints = cluster.size();
397 for(
int i = 0; i < numOfPoints; i++)
399 double dist = this->measure->dissimilarity(*cluster[i], proxy);
400 if(weightModifier != 0)
401 dist *= weightModifier->getWeight(*cluster[i]);
410 return combinedcost(clusterProvider.
cluster(solutionIndex, proxyIndex), proxyProvider.
proxy(solutionIndex, proxyIndex));
421 weightModifier = wm->
clone();
virtual T * discrete_proxy(unsigned int solutionIndex, unsigned int proxyIndex) const =0
Returns a pointer to the proxy for the specified clustering and cluster.
Abstract base class to access the results of proxy / center based clustering algorithms.
Abstract base class to access results of proxy / center based clustering algorithms.
virtual WeightModifier< T > * clone() const =0
make an exact copy of this object The clone method creates a copy of this object and returns a pointe...
Calculates the k-means weight.
virtual double proxycost(std::vector< T * > const &points, std::vector< T > const &proxies) const
Assigns all points to a proxy and calculates the k-means weight of the resulting clustering.
void setWeightModifier(WeightModifier< T > *wm)
virtual std::vector< T * > cluster(unsigned int solutionIndex, unsigned int partitionIndex) const =0
Returns a vector of pointers to the elements of a particular cluster from the specified clustering...
Abstract class. Proxy based evaluation algorithms may be optimized by deriving from this class...
virtual double combinedcost(std::vector< std::vector< T * > > const &clusters, std::vector< T > const &proxies) const
Calculates the k-means weight of a given clustering.
Abstract base class to modify the weight of weighted objects.
virtual double combinedcost(std::vector< std::vector< T * > > const &partitioning, std::vector< T > const &proxies) const =0
Calculates the cost related to the proxies, based on the partitions.
std::vector< double > proxycostGeneric(std::vector< T * > const &points, std::vector< T > const &proxies) const
Provides a k-means weight result per cluster (may be added, chosen from, ...).
virtual T proxy(unsigned int solutionIndex, unsigned int proxyIndex) const =0
returns the proxy for the specified clustering and cluster
KMeansEvaluator(DissimilarityMeasure< T > const *measure=0)
Instantiates KMeansEvaluator, optionally with a DissimilarityMeasure to use when calculation the maxi...
virtual DissimilarityMeasure< T > * clone() const =0
virtual std::vector< std::vector< T * > > clustering(unsigned int solutionIndex) const =0
Returns the specified clustering as a vector of vector of pointers to the elements.
virtual std::vector< T * > discrete_proxies(unsigned int solutionIndex) const =0
Returns a vector of pointers to the proxies for the specified clustering.
WeightModifier< T > * weightModifier
virtual ~KMeansEvaluator()
KMeansEvaluator< T > & operator=(const KMeansEvaluator< T > &)
Interface to propagate the ability to set a DissimilarityMeasure.
virtual void setMeasure(DissimilarityMeasure< T > const *measure)
Sets the DissimilarityMeasure used when calculating the maximum diameter.
Abstract class for proxy-based evaluation algorithms.
Abstract base class to access results of partition based clustering algorithms.
virtual std::vector< T > proxies(unsigned int solutionIndex) const =0
returns the proxies for the specified clustering
Abstract base class for dissimilarity measurement.
DissimilarityMeasure< T > * measure