CluE  1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
kcenterevaluator.h
Go to the documentation of this file.
1 #ifndef KCENTEREVALUAR_H
2 #define KCENTEREVALUAR_H
3 
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"
9 
10 namespace CluE
11 {
12 
13 //TODO all=max(elem) or all=sum(elem) ?
14 
19 template<typename T> class KCenterEvaluator : public ProxyEvaluation<T>, public CombinedEvaluation<T>, public MeasureSetter<T>
20 {
21 public:
22 
29 
32  virtual ~KCenterEvaluator();
33 
37  virtual void setMeasure(DissimilarityMeasure<T> const *measure);
38 
39 //# ProxyEvaluation members
43  virtual double proxycost(std::vector<T*> const& points, std::vector<T> const& proxies) const;
44 
48  virtual double proxycost(std::vector<T*> const& points, std::vector<T*> const& proxies) const;
49 
53  virtual double proxycost(std::vector<T*> const& points, ProxyProvider<T> const &proxySource, unsigned int solutionIndex) const;
54 
58  virtual double proxycost(std::vector<T*> const& points, DiscreteProxyProvider<T> const &proxySource, unsigned int solutionIndex) const;
59 
60 
64  virtual double proxycost(std::vector<T*> const& points, std::vector<T> const& proxies, unsigned int index) const;
65 
69  virtual double proxycost(std::vector<T*> const& points, std::vector<T*> const& proxies, unsigned int index) const;
70 
74  virtual double proxycost(std::vector<T*> const& points, ProxyProvider<T> const &proxySource, unsigned int solutionIndex, unsigned int proxyIndex) const;
75 
79  virtual double proxycost(std::vector<T*> const& points, DiscreteProxyProvider<T> const &proxySource, unsigned int solutionIndex, unsigned int proxyIndex) const;
80 
81 //# CombinedEvaluation members
85  virtual double combinedcost(std::vector<std::vector<T*> > const& clusters, std::vector<T> const& proxies) const;
86 
90  virtual double combinedcost(std::vector<std::vector<T*> > const& clusters, std::vector<T*> const& proxies) const;
91 
92 
96  virtual double combinedcost(PartitionProvider<T> const &clusteringSource, ProxyProvider<T> const &proxySource, unsigned int solutionIndex) const;
97 
101  virtual double combinedcost(PartitionProvider<T> const &clusteringSource, DiscreteProxyProvider<T> const &proxySource, unsigned int solutionIndex) const;
102 
103 
107  virtual double combinedcost(std::vector<T*> const& cluster, T const& proxy) const;
108 
112  virtual double combinedcost(PartitionProvider<T> const &clusteringSource, ProxyProvider<T> const &proxySource, unsigned int solutionIndex, unsigned int proxyIndex) const;
113 
117  virtual double combinedcost(PartitionProvider<T> const &clusteringSource, DiscreteProxyProvider<T> const &proxySource, unsigned int solutionIndex, unsigned int proxyIndex) const;
118 
119 protected:
123  std::vector<double> proxycostGeneric(std::vector<T*> const& points, std::vector<T> const& proxies) const;
124 
128  std::vector<double> proxycostGeneric(std::vector<T*> const& points, std::vector<T*> const& proxies) const;
129 
130 private:
132 };
133 
135  measure(measure==0 ? 0 : measure->clone())
136 {
137  //empty
138 }
139 
141  measure(kce.measure == 0 ? 0 : kce.measure->clone())
142 {
143 }
144 
146 {
147  if(measure != 0)
148  delete measure;
149 
152 
153  measure = kce.measure == 0 ? 0 : kce.measure->clone();
154 
155  return *this;
156 }
157 
159 {
160  if(measure != 0)
161  delete measure;
162 }
163 
164 //### ProxyEvaluation members
165 
166 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, std::vector<T> const& proxies) const
167 {
168  std::vector<double> values = proxycostGeneric(points, proxies);
169  int numOfValues = values.size();
170 
171  double result = 0;
172  for(int i = 0; i < numOfValues; i++)
173  {
174  if(values[i] > result)
175  result = values[i];
176  }
177 
178  return result;
179 }
180 
181 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, std::vector<T*> const& proxies) const
182 {
183  std::vector<double> values = proxycostGeneric(points, proxies);
184  int numOfValues = values.size();
185 
186  double result = 0;
187  for(int i = 0; i < numOfValues; i++)
188  {
189  if(values[i] > result)
190  result = values[i];
191  }
192 
193  return result;
194 }
195 
196 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, ProxyProvider<T> const &provider, unsigned int solutionIndex) const
197 {
198  return proxycost(points, provider.proxies(solutionIndex));
199 }
200 
201 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, DiscreteProxyProvider<T> const &provider, unsigned int solutionIndex) const
202 {
203  return proxycost(points, provider.discrete_proxies(solutionIndex));
204 }
205 
206 
207 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, std::vector<T> const& proxies, unsigned int index) const
208 {
209  std::vector<double> values = proxycostGeneric(points, proxies);
210  return values.at(index);
211 }
212 
213 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, std::vector<T*> const& proxies, unsigned int index) const
214 {
215  std::vector<double> values = proxycostGeneric(points, proxies);
216  return values.at(index);
217 }
218 
219 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, ProxyProvider<T> const &provider, unsigned int solutionIndex, unsigned int proxyIndex) const
220 {
221  return proxycost(points, provider.proxies(solutionIndex), proxyIndex);
222 }
223 
224 template<typename T> double KCenterEvaluator<T>::proxycost(std::vector<T*> const& points, DiscreteProxyProvider<T> const &provider, unsigned int solutionIndex, unsigned int proxyIndex) const
225 {
226  return proxycost(points, provider.discrete_proxies(solutionIndex), proxyIndex);
227 }
228 
229 template<typename T> void KCenterEvaluator<T>::setMeasure(DissimilarityMeasure<T> const *measure)
230 {
231  if(measure)
232  this->measure = 0;
233  else
234  this->measure = measure->clone();
235 }
236 
237 
238 template<typename T> std::vector<double> KCenterEvaluator<T>::proxycostGeneric(std::vector<T*> const& points, std::vector<T> const& proxies) const
239 {
240  int numOfPoints = points.size();
241  int numOfProxies = proxies.size();
242 
243  std::vector<double> result(numOfProxies, 0);
244 
245  for(int i = 0; i < numOfPoints; i++)
246  {
247  T* point = points[i];
248 
249  double min = this->measure->dissimilarity(*point, proxies[0]);
250  int assignedProxy = 0;
251  for(int j = 1; j < numOfProxies; j++)
252  {
253  T proxy = proxies[j];
254  double candidate = this->measure->dissimilarity(*point, proxy);
255  if(candidate < min)
256  {
257  min = candidate;
258  assignedProxy = j;
259  }
260  }
261 
262  if(min > result[assignedProxy])
263  result[assignedProxy] = min;
264  }
265 
266  return result;
267 }
268 
269 template<typename T> std::vector<double> KCenterEvaluator<T>::proxycostGeneric(std::vector<T*> const& points, std::vector<T*> const& proxies) const
270 {
271  int numOfPoints = points.size();
272  int numOfProxies = proxies.size();
273 
274  std::vector<double> result(numOfProxies, 0);
275 
276  for(int i = 0; i < numOfPoints; i++)
277  {
278  T* point = points[i];
279 
280  double min = this->measure->dissimilarity(*point, *proxies[0]);
281  int assignedProxy = 0;
282  for(int j = 1; j < numOfProxies; j++)
283  {
284  T* proxy = proxies[j];
285  double candidate = this->measure->dissimilarity(*point, *proxy);
286  if(candidate < min)
287  {
288  min = candidate;
289  assignedProxy = j;
290  }
291  }
292 
293  if(min > result[assignedProxy])
294  result[assignedProxy] = min;
295  }
296 
297  return result;
298 }
299 
300 //### CombinedEvaluation members
301 
302 template<typename T> double KCenterEvaluator<T>::combinedcost(std::vector<std::vector<T*> > const& clusters, std::vector<T> const& proxies) const
303 {
304  double sum = 0;
305 
306  int numOfClusters = clusters.size();
307  int numOfProxies = proxies.size();
308  int minNumOfClustersProxies = numOfClusters < numOfProxies ? numOfClusters : numOfProxies;
309 
310  for(int i = 0; i < minNumOfClustersProxies; i++)
311  {
312  double cost = combinedcost(clusters[i], proxies[i]);
313  if(cost > sum)
314  sum = cost;
315  }
316 
317  if(numOfClusters < numOfProxies)
318  {
319  std::clog << "CluE::KCenterEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T>) - WARNING: More proxies than clusters: ignoring redundant proxies." << std::endl;
320  }
321  else if(numOfClusters > numOfProxies)
322  {
323  std::clog << "CluE::KCenterEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T>) - WARNING: Less proxies than clusters: assigning remaining points to proxies." << std::endl;
324  for(int i = numOfProxies; i < numOfClusters; i++)
325  {
326  double cost = proxycost(clusters[i], proxies);
327  if(cost > sum)
328  sum=cost;
329  }
330  }
331 
332  return sum;
333 }
334 
335 template<typename T> double KCenterEvaluator<T>::combinedcost(std::vector<std::vector<T*> > const& clusters, std::vector<T*> const& proxies) const
336 {
337  double sum = 0;
338 
339  int numOfClusters = clusters.size();
340  int numOfProxies = proxies.size();
341  int minNumOfClustersProxies = numOfClusters < numOfProxies ? numOfClusters : numOfProxies;
342 
343  for(int i = 0; i < minNumOfClustersProxies; i++)
344  {
345  double cost = CombinedEvaluation<T>::combinedcost(clusters[i], proxies[i]);
346  if(cost > sum)
347  sum = cost;
348  }
349 
350  if(numOfClusters < numOfProxies)
351  {
352  std::clog << "CluE::KCenterEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T*>) - WARNING: More proxies than clusters: ignoring redundant proxies." << std::endl;
353  }
354  else if(numOfClusters > numOfProxies)
355  {
356  std::clog << "CluE::KCenterEvaluator<T>::combinedcost(std::vector<std::vector<T*> >, std::vector<T*>) - WARNING: Less proxies than clusters: assigning remaining points to proxies." << std::endl;
357  for(int i = numOfProxies; i < numOfClusters; i++)
358  {
359  double cost = proxycost(clusters[i], proxies);
360  if(cost > sum)
361  sum=cost;
362  }
363  }
364 
365  return sum;
366 }
367 
368 template<typename T> double KCenterEvaluator<T>::combinedcost(PartitionProvider<T> const &clusterProvider, ProxyProvider<T> const &proxyProvider, unsigned int solutionIndex) const
369 {
370  return combinedcost(clusterProvider.clustering(solutionIndex), proxyProvider.proxies(solutionIndex));
371 }
372 
373 template<typename T> double KCenterEvaluator<T>::combinedcost(PartitionProvider<T> const &clusterProvider, DiscreteProxyProvider<T> const &proxyProvider, unsigned int solutionIndex) const
374 {
375  return combinedcost(clusterProvider.clustering(solutionIndex), proxyProvider.discrete_proxies(solutionIndex));
376 }
377 
378 template<typename T> double KCenterEvaluator<T>::combinedcost(std::vector<T*> const& cluster, T const& proxy) const
379 {
380  double sum = 0;
381 
382  int numOfPoints = cluster.size();
383  for(int i = 0; i < numOfPoints; i++)
384  {
385  double cost = this->measure->dissimilarity(*cluster[i], proxy);
386  if(cost > sum)
387  sum =cost;
388  }
389 
390  return sum;
391 }
392 
393 template<typename T> double KCenterEvaluator<T>::combinedcost(PartitionProvider<T> const &clusterProvider, ProxyProvider<T> const &proxyProvider, unsigned int solutionIndex, unsigned int proxyIndex) const
394 {
395  return combinedcost(clusterProvider.cluster(solutionIndex, proxyIndex), proxyProvider.proxy(solutionIndex, proxyIndex));
396 }
397 
398 template<typename T> double KCenterEvaluator<T>::combinedcost(PartitionProvider<T> const &clusterProvider, DiscreteProxyProvider<T> const &proxyProvider, unsigned int solutionIndex, unsigned int proxyIndex) const
399 {
400  return CombinedEvaluation<T>::combinedcost(clusterProvider.cluster(solutionIndex, proxyIndex), proxyProvider.discrete_proxy(solutionIndex, proxyIndex));
401 }
402 
403 }
404 
405 #endif
Calculates the k-center weight.
virtual T * discrete_proxy(unsigned int solutionIndex, unsigned int proxyIndex) const =0
Returns a pointer to the proxy for the specified clustering and cluster.
KCenterEvaluator< T > & operator=(const KCenterEvaluator< T > &)
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.
Definition: proxyprovider.h:14
KCenterEvaluator(DissimilarityMeasure< T > const *measure=0)
Instantiates KCenterEvaluator, optionally with a DissimilarityMeasure to use when calculation the max...
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-center weight of a given clustering.
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.
virtual T proxy(unsigned int solutionIndex, unsigned int proxyIndex) const =0
returns the proxy for the specified clustering and cluster
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.
virtual void setMeasure(DissimilarityMeasure< T > const *measure)
Sets the DissimilarityMeasure used when calculating the radius.
virtual double proxycost(std::vector< T * > const &points, std::vector< T > const &proxies) const
Assigns all points to a proxy and calculates the k-center weight of the resulting clustering...
Interface to propagate the ability to set a DissimilarityMeasure.
Definition: measuresetter.h:13
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
std::vector< double > proxycostGeneric(std::vector< T * > const &points, std::vector< T > const &proxies) const
Provides a k-center weight result per cluster (may be added, chosen from, ...).