SHOGUN  v3.0.0
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
MultitaskKernelMaskPairNormalizer.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 _MULTITASKKERNELMASKPAIRNORMALIZER_H___
12 #define _MULTITASKKERNELMASKPAIRNORMALIZER_H___
13 
15 #include <shogun/kernel/Kernel.h>
16 
17 #include <string>
18 #include <vector>
19 #include <utility>
20 
21 namespace shogun
22 {
23 
24 
30 {
31 
32 public:
33 
38  {
39  }
40 
45  CMultitaskKernelMaskPairNormalizer(std::vector<int32_t> task_vector_,
46  std::vector<std::pair<int32_t, int32_t> > active_pairs_) :
47  scale(1.0), normalization_constant(1.0)
48  {
49 
50  set_task_vector(task_vector_);
51  active_pairs = active_pairs_;
52 
53  }
54 
55 
58  {
59  }
60 
63  virtual bool init(CKernel* k)
64  {
65  ASSERT(k)
66  int32_t num_lhs = k->get_num_vec_lhs();
67  int32_t num_rhs = k->get_num_vec_rhs();
68  ASSERT(num_lhs>0)
69  ASSERT(num_rhs>0)
70 
71 
72  //same as first-element normalizer
73  CFeatures* old_lhs=k->lhs;
74  CFeatures* old_rhs=k->rhs;
75  k->lhs=old_lhs;
76  k->rhs=old_lhs;
77 
78 
79  if (std::string(k->get_name()) == "WeightedDegree") {
80  SG_INFO("using first-element normalization\n")
81  scale=k->compute(0, 0);
82  } else {
83  SG_INFO("no inner normalization for non-WDK kernel\n")
84  scale=1.0;
85  }
86 
87  k->lhs=old_lhs;
88  k->rhs=old_rhs;
89 
90 
91  return true;
92  }
93 
94 
95 
101  virtual float64_t normalize(float64_t value, int32_t idx_lhs, int32_t idx_rhs)
102  {
103 
104  //lookup tasks
105  int32_t task_idx_lhs = task_vector_lhs[idx_lhs];
106  int32_t task_idx_rhs = task_vector_rhs[idx_rhs];
107 
108  //lookup similarity
109  float64_t task_similarity = get_similarity(task_idx_lhs, task_idx_rhs);
110 
111  //take task similarity into account
112  float64_t similarity = (value/scale) * task_similarity;
113 
114 
115  return similarity;
116 
117  }
118 
123  virtual float64_t normalize_lhs(float64_t value, int32_t idx_lhs)
124  {
125  SG_ERROR("normalize_lhs not implemented")
126  return 0;
127  }
128 
133  virtual float64_t normalize_rhs(float64_t value, int32_t idx_rhs)
134  {
135  SG_ERROR("normalize_rhs not implemented")
136  return 0;
137  }
138 
140  std::vector<int32_t> get_task_vector_lhs() const
141  {
142  return task_vector_lhs;
143  }
144 
145 
147  void set_task_vector_lhs(std::vector<int32_t> vec)
148  {
149 
150  task_vector_lhs.clear();
151 
152  for (int32_t i = 0; i != (int32_t)(vec.size()); ++i)
153  {
154  task_vector_lhs.push_back(vec[i]);
155  }
156 
157  }
158 
161  std::vector<int32_t> get_task_vector_rhs() const
162  {
163  return task_vector_rhs;
164  }
165 
166 
168  void set_task_vector_rhs(std::vector<int32_t> vec)
169  {
170 
171  task_vector_rhs.clear();
172 
173  for (int32_t i = 0; i != (int32_t)(vec.size()); ++i)
174  {
175  task_vector_rhs.push_back(vec[i]);
176  }
177 
178  }
179 
181  void set_task_vector(std::vector<int32_t> vec)
182  {
183  set_task_vector_lhs(vec);
184  set_task_vector_rhs(vec);
185  }
186 
187 
193  float64_t get_similarity(int32_t task_lhs, int32_t task_rhs)
194  {
195 
196  float64_t similarity = 0.0;
197 
198  for (int32_t i=0; i!=static_cast<int>(active_pairs.size()); i++)
199  {
200  std::pair<int32_t, int32_t> block = active_pairs[i];
201 
202  // ignore order of pair
203  if ((block.first==task_lhs && block.second==task_rhs) ||
204  (block.first==task_rhs && block.second==task_lhs))
205  {
206  similarity = 1.0 / normalization_constant;
207  break;
208  }
209  }
210 
211 
212  return similarity;
213 
214  }
215 
217  std::vector<std::pair<int32_t, int32_t> > get_active_pairs()
218  {
219  return active_pairs;
220  }
221 
224  {
225  return normalization_constant;
226  }
227 
230  {
231  normalization_constant = constant;
232 
234  return 0.0;
235  }
236 
237 
239  virtual const char* get_name() const
240  {
241  return "MultitaskKernelMaskPairNormalizer";
242  }
243 
248  {
249  return dynamic_cast<shogun::CMultitaskKernelMaskPairNormalizer*>(n);
250  }
251 
252 protected:
253 
255  std::vector<std::pair<int32_t, int32_t> > active_pairs;
256 
258  std::vector<int32_t> task_vector_lhs;
259 
261  std::vector<int32_t> task_vector_rhs;
262 
265 
268 
269 };
270 }
271 #endif

SHOGUN Machine Learning Toolbox - Documentation