SHOGUN  v1.1.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
MultitaskKernelPlifNormalizer.h
Go to the documentation of this file.
1 /*
2  * This program is free software; you can redistribute it and/or modify
3  * it under the terms of the GNU General Public License as published by
4  * the Free Software Foundation; either version 2 of the License, or
5  * (at your option) any later version.
6  *
7  * Written (W) 2010 Christian Widmer
8  * Copyright (C) 2010 Max-Planck-Society
9  */
10 
11 #ifndef _MULTITASKKERNELPLIFNORMALIZER_H___
12 #define _MULTITASKKERNELPLIFNORMALIZER_H___
13 
16 #include <shogun/kernel/Kernel.h>
17 #include <algorithm>
18 
19 
20 
21 namespace shogun
22 {
27 {
28 
29 public:
32  {
33  num_tasks = 0;
34  num_tasksqr = 0;
35  num_betas = 0;
36  }
37 
40  CMultitaskKernelPlifNormalizer(std::vector<float64_t> support_, std::vector<int32_t> task_vector)
42  {
43 
44  num_betas = static_cast<int>(support_.size());
45 
46  support = support_;
47 
48  // init support points values with constant function
49  betas = std::vector<float64_t>(num_betas);
50  for (int i=0; i!=num_betas; i++)
51  {
52  betas[i] = 1;
53  }
54 
55  num_tasks = get_num_unique_tasks(task_vector);
57 
58  // set both sides equally
59  set_task_vector(task_vector);
60 
61  // init distance matrix
62  distance_matrix = std::vector<float64_t>(num_tasksqr);
63 
64  // init similarity matrix
65  similarity_matrix = std::vector<float64_t>(num_tasksqr);
66 
67  }
68 
69 
75  inline virtual float64_t normalize(float64_t value, int32_t idx_lhs,
76  int32_t idx_rhs)
77  {
78 
79  //lookup tasks
80  int32_t task_idx_lhs = task_vector_lhs[idx_lhs];
81  int32_t task_idx_rhs = task_vector_rhs[idx_rhs];
82 
83  //lookup similarity
84  float64_t task_similarity = get_task_similarity(task_idx_lhs,
85  task_idx_rhs);
86 
87  //take task similarity into account
88  float64_t similarity = (value/scale) * task_similarity;
89 
90 
91  return similarity;
92 
93  }
94 
100  int32_t get_num_unique_tasks(std::vector<int32_t> vec) {
101 
102  //sort
103  std::sort(vec.begin(), vec.end());
104 
105  //reorder tasks with unique prefix
106  std::vector<int32_t>::iterator endLocation = std::unique(vec.begin(), vec.end());
107 
108  //count unique tasks
109  int32_t num_vec = std::distance(vec.begin(), endLocation);
110 
111  return num_vec;
112 
113  }
114 
115 
118  {
119  }
120 
121 
124  {
125 
126 
127  for (int32_t i=0; i!=num_tasks; i++)
128  {
129  for (int32_t j=0; j!=num_tasks; j++)
130  {
131 
132  float64_t similarity = compute_task_similarity(i, j);
133  set_task_similarity(i,j,similarity);
134 
135  }
136 
137  }
138  }
139 
140 
142  float64_t compute_task_similarity(int32_t task_a, int32_t task_b)
143  {
144 
145  float64_t distance = get_task_distance(task_a, task_b);
146  float64_t similarity = -1;
147 
148  int32_t upper_bound_idx = -1;
149 
150 
151  // determine interval
152  for (int i=1; i!=num_betas; i++)
153  {
154  if (distance <= support[i])
155  {
156  upper_bound_idx = i;
157  break;
158  }
159  }
160 
161  // perform interpolation (constant for beyond upper bound)
162  if (upper_bound_idx == -1)
163  {
164 
165  similarity = betas[num_betas-1];
166 
167  } else {
168 
169  int32_t lower_bound_idx = upper_bound_idx - 1;
170  float64_t interval_size = support[upper_bound_idx] - support[lower_bound_idx];
171 
172  float64_t factor_lower = 1 - (distance - support[lower_bound_idx]) / interval_size;
173  float64_t factor_upper = 1 - factor_lower;
174 
175  similarity = factor_lower*betas[lower_bound_idx] + factor_upper*betas[upper_bound_idx];
176 
177  }
178 
179  return similarity;
180 
181  }
182 
183 
184 public:
185 
187  virtual std::vector<int32_t> get_task_vector_lhs() const
188  {
189  return task_vector_lhs;
190  }
191 
193  virtual void set_task_vector_lhs(std::vector<int32_t> vec)
194  {
195  task_vector_lhs = vec;
196  }
197 
199  virtual std::vector<int32_t> get_task_vector_rhs() const
200  {
201  return task_vector_rhs;
202  }
203 
205  virtual void set_task_vector_rhs(std::vector<int32_t> vec)
206  {
207  task_vector_rhs = vec;
208  }
209 
211  virtual void set_task_vector(std::vector<int32_t> vec)
212  {
213  task_vector_lhs = vec;
214  task_vector_rhs = vec;
215  }
216 
222  float64_t get_task_distance(int32_t task_lhs, int32_t task_rhs)
223  {
224 
225  ASSERT(task_lhs < num_tasks && task_lhs >= 0);
226  ASSERT(task_rhs < num_tasks && task_rhs >= 0);
227 
228  return distance_matrix[task_lhs * num_tasks + task_rhs];
229 
230  }
231 
237  void set_task_distance(int32_t task_lhs, int32_t task_rhs,
238  float64_t distance)
239  {
240 
241  ASSERT(task_lhs < num_tasks && task_lhs >= 0);
242  ASSERT(task_rhs < num_tasks && task_rhs >= 0);
243 
244  distance_matrix[task_lhs * num_tasks + task_rhs] = distance;
245 
246  }
247 
253  float64_t get_task_similarity(int32_t task_lhs, int32_t task_rhs)
254  {
255 
256  ASSERT(task_lhs < num_tasks && task_lhs >= 0);
257  ASSERT(task_rhs < num_tasks && task_rhs >= 0);
258 
259  return similarity_matrix[task_lhs * num_tasks + task_rhs];
260 
261  }
262 
268  void set_task_similarity(int32_t task_lhs, int32_t task_rhs,
269  float64_t similarity)
270  {
271 
272  ASSERT(task_lhs < num_tasks && task_lhs >= 0);
273  ASSERT(task_rhs < num_tasks && task_rhs >= 0);
274 
275  similarity_matrix[task_lhs * num_tasks + task_rhs] = similarity;
276 
277  }
278 
282  float64_t get_beta(int32_t idx)
283  {
284 
285  return betas[idx];
286 
287  }
288 
293  void set_beta(int32_t idx, float64_t weight)
294  {
295 
296  betas[idx] = weight;
297 
298  update_cache();
299 
300  }
301 
305  int32_t get_num_betas()
306  {
307 
308  return num_betas;
309 
310  }
311 
312 
314  inline virtual const char* get_name() const
315  {
316  return "MultitaskKernelPlifNormalizer";
317  }
318 
323  {
324  return dynamic_cast<shogun::CMultitaskKernelPlifNormalizer*>(n);
325  }
326 
327 protected:
330  virtual void register_params()
331  {
332  m_parameters->add(&num_tasks, "num_tasks", "the number of tasks");
333  m_parameters->add(&num_betas, "num_betas", "the number of weights");
334  m_parameters->add_vector((SGString<float64_t>**)&distance_matrix, &num_tasksqr, "distance_matrix", "distance between tasks");
335  m_parameters->add_vector((SGString<float64_t>**)&similarity_matrix, &num_tasksqr, "similarity_matrix", "similarity between tasks");
336  m_parameters->add_vector((SGString<float64_t>**)&betas, &num_betas, "num_betas", "weights");
337  m_parameters->add_vector((SGString<float64_t>**)&support, &num_betas, "support", "support points");
338  }
339 
341  int32_t num_tasks;
343  int32_t num_tasksqr;
344 
346  std::vector<int32_t> task_vector_lhs;
347 
349  std::vector<int32_t> task_vector_rhs;
350 
352  std::vector<float64_t> distance_matrix;
353 
355  std::vector<float64_t> similarity_matrix;
356 
358  int32_t num_betas;
359 
361  std::vector<float64_t> betas;
362 
364  std::vector<float64_t> support;
365 
366 };
367 }
368 #endif

SHOGUN Machine Learning Toolbox - Documentation