C++ API Reference for Intel® Data Analytics Acceleration Library 2019 Update 5

data_management/data_source/modifiers/internal/engine.h
1 /* file: engine.h */
2 /*******************************************************************************
3 * Copyright 2014-2019 Intel Corporation.
4 *
5 * This software and the related documents are Intel copyrighted materials, and
6 * your use of them is governed by the express license under which they were
7 * provided to you (License). Unless the License provides otherwise, you may not
8 * use, modify, copy, publish, distribute, disclose or transmit this software or
9 * the related documents without Intel's prior written permission.
10 *
11 * This software and the related documents are provided as is, with no express
12 * or implied warranties, other than those that are expressly stated in the
13 * License.
14 *******************************************************************************/
15 
16 #ifndef __DATA_SOURCE_MODIFIERS_INTERNAL_ENGINE_H__
17 #define __DATA_SOURCE_MODIFIERS_INTERNAL_ENGINE_H__
18 
19 #include "services/collection.h"
20 #include "data_management/features/identifiers.h"
21 
22 namespace daal
23 {
24 namespace data_management
25 {
26 namespace modifiers
27 {
28 namespace internal
29 {
30 
35 class InputFeatureInfo : public Base { };
36 
41 class OutputFeatureInfo : public Base
42 {
43 public:
44  OutputFeatureInfo() :
45  _numberOfCategories(0),
46  _featureType(features::DAAL_CONTINUOUS) { }
47 
48  void setNumberOfCategories(size_t numberOfCategories)
49  {
50  _numberOfCategories = numberOfCategories;
51  }
52 
53  void setFeatureType(features::FeatureType featureType)
54  {
55  _featureType = featureType;
56  }
57 
58  void setCategoricalDictionary(const CategoricalFeatureDictionaryPtr &dictionary)
59  {
60  _dictionary = dictionary;
61  }
62 
63  void fillDataSourceFeature(DataSourceFeature &feature) const
64  {
65  setDataSourceFeatureType(feature);
66  feature.ntFeature.categoryNumber = _numberOfCategories;
67  feature.setCategoricalDictionary(_dictionary);
68  }
69 
70 private:
71  void setDataSourceFeatureType(DataSourceFeature &feature) const
72  {
73  switch (_featureType)
74  {
75  case features::DAAL_CONTINUOUS:
76  feature.setType<DAAL_DATA_TYPE>();
77  break;
78 
79  case features::DAAL_ORDINAL:
80  case features::DAAL_CATEGORICAL:
81  feature.setType<int>();
82  break;
83  }
84  feature.ntFeature.featureType = _featureType;
85  }
86 
87 private:
88  size_t _numberOfCategories;
89  features::FeatureType _featureType;
90  CategoricalFeatureDictionaryPtr _dictionary;
91 };
92 
99 template<typename InputFeatureInfo, typename OutputFeatureInfo>
100 class Config
101 {
102 public:
103  typedef InputFeatureInfo InputFeatureInfoType;
104  typedef OutputFeatureInfo OutputFeatureInfoType;
105 
106  Config() { }
107 
108  explicit Config(const services::internal::CollectionPtr<InputFeatureInfo *> &pickedInputFeatures,
109  services::Status *status = NULL) :
110  _pickedInputFeatures(pickedInputFeatures)
111  {
112  services::Status localStatus = reallocateOutputFeatures( pickedInputFeatures->size() );
113  services::internal::tryAssignStatusAndThrow(status, localStatus);
114  }
115 
116  size_t getNumberOfInputFeatures() const
117  {
118  return _pickedInputFeatures->size();
119  }
120 
121  services::Status setNumberOfOutputFeatures(size_t numberOfOutputFeatures)
122  {
123  return reallocateOutputFeatures(numberOfOutputFeatures);
124  }
125 
126  services::Status setOutputFeatureType(size_t outputFeatureIndex,
127  features::FeatureType featureType)
128  {
129  if (outputFeatureIndex >= _outputFeatures.size())
130  { return services::throwIfPossible(services::ErrorIncorrectIndex); }
131 
132  _outputFeatures[outputFeatureIndex].setFeatureType(featureType);
133  return services::Status();
134  }
135 
136  services::Status setNumberOfCategories(size_t outputFeatureIndex,
137  size_t numberOfCategories)
138  {
139  if (outputFeatureIndex >= _outputFeatures.size())
140  { return services::throwIfPossible(services::ErrorIncorrectIndex); }
141 
142  _outputFeatures[outputFeatureIndex].setNumberOfCategories(numberOfCategories);
143  return services::Status();
144  }
145 
146  services::Status setCategoricalDictionary(size_t outputFeatureIndex,
147  const CategoricalFeatureDictionaryPtr &dictionary)
148  {
149  if (outputFeatureIndex >= _outputFeatures.size())
150  { return services::throwIfPossible(services::ErrorIncorrectIndex); }
151 
152  _outputFeatures[outputFeatureIndex].setCategoricalDictionary(dictionary);
153  return services::Status();
154  }
155 
156  size_t getNumberOfOutputFeatures() const
157  {
158  return _outputFeatures.size();
159  }
160 
161  const services::Collection<OutputFeatureInfo> &getOutputFeaturesInfo() const
162  {
163  return _outputFeatures;
164  }
165 
166 protected:
167  const services::Collection<InputFeatureInfo *> &getPickedInputFeatures() const
168  {
169  return *_pickedInputFeatures;
170  }
171 
172  const InputFeatureInfo &getPickedInputFeature(size_t index) const
173  {
174  return *( _pickedInputFeatures->get(index) );
175  }
176 
177  services::Collection<OutputFeatureInfo> &getOutputFeatures()
178  {
179  return _outputFeatures;
180  }
181 
182  const OutputFeatureInfo &getOutputFeature(size_t index) const
183  {
184  return _outputFeatures[index];
185  }
186 
187  OutputFeatureInfo &getOutputFeature(size_t index)
188  {
189  return _outputFeatures[index];
190  }
191 
192 private:
193  services::Status reallocateOutputFeatures(size_t numberOfOutputFeatures)
194  {
195  _outputFeatures = services::Collection<OutputFeatureInfo>(numberOfOutputFeatures);
196  if (!_outputFeatures.data())
197  { return services::throwIfPossible(services::ErrorMemoryAllocationFailed); }
198 
199  return services::Status();
200  }
201 
202 private:
203  services::internal::CollectionPtr<InputFeatureInfo *> _pickedInputFeatures;
204  services::Collection<OutputFeatureInfo> _outputFeatures;
205 };
206 
213 template<typename InputFeatureInfo, typename OutputFeatureInfo>
214 class Context
215 {
216 public:
217  typedef InputFeatureInfo InputFeatureInfoType;
218  typedef OutputFeatureInfo OutputFeatureInfoType;
219 
220  Context() { }
221 
222  explicit Context(const services::internal::CollectionPtr<InputFeatureInfoType *> &pickedInputFeatures,
223  services::Status *status = NULL) :
224  _pickedInputFeatures(pickedInputFeatures) { }
225 
226  size_t getNumberOfInputFeatures() const
227  {
228  return _pickedInputFeatures->size();
229  }
230 
231  services::BufferView<DAAL_DATA_TYPE> getOutputBuffer() const
232  {
233  return _outputBuffer;
234  }
235 
236  void setOutputBuffer(const services::BufferView<DAAL_DATA_TYPE> &buffer)
237  {
238  _outputBuffer = buffer;
239  }
240 
241 protected:
242  const services::Collection<InputFeatureInfoType *> &getPickedInputFeatures() const
243  {
244  return *_pickedInputFeatures;
245  }
246 
247  const InputFeatureInfoType &getPickedInputFeature(size_t index) const
248  {
249  return *( _pickedInputFeatures->get(index) );
250  }
251 
252 private:
253  services::BufferView<DAAL_DATA_TYPE> _outputBuffer;
254  services::internal::CollectionPtr<InputFeatureInfoType *> _pickedInputFeatures;
255 };
256 
265 template<typename Modifier, typename Config, typename Context>
266 class ModifierBinding : public Base
267 {
268 public:
269  typedef Modifier ModifierType;
270  typedef typename Config::InputFeatureInfoType InputFeatureInfoType;
271  typedef typename Config::OutputFeatureInfoType OutputFeatureInfoType;
272 
273  ModifierBinding() :
274  _outputFeaturesOffset(0),
275  _numberOfOutputFeatures(0) { }
276 
277  explicit ModifierBinding(const features::FeatureIdCollectionIfacePtr &identifiers,
278  const services::SharedPtr<Modifier> &modifier,
279  services::Status *status = NULL) :
280  _modifier(modifier),
281  _identifiers(identifiers),
282  _outputFeaturesOffset(0),
283  _numberOfOutputFeatures(0) { }
284 
285  services::Status bind(size_t outputFeaturesOffset,
286  const features::FeatureIdMappingIfacePtr &mapping,
287  const services::internal::CollectionPtr<InputFeatureInfoType> &inputFeaturesInfo)
288  {
289  services::Status status;
290 
291  features::FeatureIndicesIfacePtr indices = _identifiers->mapToFeatureIndices(*mapping, &status);
292  DAAL_CHECK_STATUS_VAR(status);
293 
294  services::internal::CollectionPtr<InputFeatureInfoType *> pickedInputFeatureInfo =
295  features::internal::pickElements(indices, inputFeaturesInfo, &status);
296  DAAL_CHECK_STATUS_VAR(status);
297 
298  _config = Config(pickedInputFeatureInfo, &status);
299  _context = Context(pickedInputFeatureInfo, &status);
300  DAAL_CHECK_STATUS_VAR(status);
301 
302  _modifier->initialize(_config);
303 
304  _outputFeaturesOffset = outputFeaturesOffset;
305  _numberOfOutputFeatures = _config.getNumberOfOutputFeatures();
306 
307  return status;
308  }
309 
310  void apply(const services::BufferView<DAAL_DATA_TYPE> &outputBuffer)
311  {
312  _context.setOutputBuffer( outputBuffer.getBlock(_outputFeaturesOffset,
313  _numberOfOutputFeatures) );
314  _modifier->apply(_context);
315  }
316 
317  void finalize()
318  {
319  _modifier->finalize(_config);
320  }
321 
322  const OutputFeatureInfoType &getOutputFeatureInfo(size_t featureIndex) const
323  {
324  return _config.getOutputFeaturesInfo()[featureIndex];
325  }
326 
327  size_t getNumberOfOutputFeatures() const
328  {
329  return _numberOfOutputFeatures;
330  }
331 
332 private:
333  Config _config;
334  Context _context;
335 
336  size_t _outputFeaturesOffset;
337  size_t _numberOfOutputFeatures;
338 
339  services::SharedPtr<Modifier> _modifier;
340  features::FeatureIdCollectionIfacePtr _identifiers;
341 };
342 
348 template<typename ModifierBinding>
349 class ModifiersBinder : public Base
350 {
351 public:
352  typedef typename ModifierBinding::ModifierType ModifierType;
353  typedef typename ModifierBinding::InputFeatureInfoType InputFeatureInfoType;
354  typedef typename ModifierBinding::OutputFeatureInfoType OutputFeatureInfoType;
355 
356  ModifiersBinder() :
357  _numberOfOutputFeatures(0) { }
358 
359  services::Status add(const features::FeatureIdCollectionIfacePtr &identifiers,
360  const services::SharedPtr<ModifierType> &modifier)
361  {
362  if (!identifiers || !modifier)
363  { return services::throwIfPossible(services::ErrorNullPtr); }
364 
365  if ( !_bindings.safe_push_back(ModifierBinding(identifiers, modifier)) )
366  { return services::throwIfPossible(services::ErrorMemoryAllocationFailed); }
367 
368  return services::Status();
369  }
370 
371  void apply(const services::BufferView<DAAL_DATA_TYPE> &outputBuffer)
372  {
373  for (size_t i = 0; i < _bindings.size(); i++)
374  {
375  _bindings[i].apply(outputBuffer);
376  }
377  }
378 
379  void finalize()
380  {
381  for (size_t i = 0; i < _bindings.size(); i++)
382  {
383  _bindings[i].finalize();
384  }
385  }
386 
387  services::Status bind(const features::FeatureIdMappingIfacePtr &mapping,
388  const services::internal::CollectionPtr<InputFeatureInfoType> &inputFeaturesInfo)
389  {
390  DAAL_ASSERT( mapping );
391  DAAL_ASSERT( inputFeaturesInfo );
392 
393  services::Status status;
394 
395  size_t outputFeaturesOffset = 0;
396  for (size_t i = 0; i < _bindings.size(); i++)
397  {
398  status |= _bindings[i].bind(outputFeaturesOffset, mapping, inputFeaturesInfo);
399  DAAL_CHECK_STATUS_VAR(status);
400 
401  outputFeaturesOffset += _bindings[i].getNumberOfOutputFeatures();
402  }
403 
404  _inputFeaturesInfo = inputFeaturesInfo;
405  _numberOfOutputFeatures = outputFeaturesOffset;
406 
407  return status;
408  }
409 
410  size_t getNumberOfOutputFeatures() const
411  {
412  return _numberOfOutputFeatures;
413  }
414 
415  size_t getNumberOfModifiers() const
416  {
417  return _bindings.size();
418  }
419 
420  const ModifierBinding &getBinding(size_t index) const
421  {
422  return _bindings[index];
423  }
424 
425  services::Collection<InputFeatureInfoType> &getInputFeaturesInfo()
426  {
427  return *_inputFeaturesInfo;
428  }
429 
430  InputFeatureInfoType &getInputFeatureInfo(size_t featureIndex)
431  {
432  return _inputFeaturesInfo->get(featureIndex);
433  }
434 
435 private:
436  size_t _numberOfOutputFeatures;
437  services::Collection<ModifierBinding> _bindings;
438  services::internal::CollectionPtr<InputFeatureInfoType> _inputFeaturesInfo;
439 };
440 
448 template<typename Modifier, typename Config, typename Context>
449 class ModifiersManager : public Base
450 {
451 public:
452  typedef ModifierBinding<Modifier, Config, Context> ModifierBindingType;
453  typedef typename ModifierBindingType::InputFeatureInfoType InputFeatureInfoType;
454  typedef typename ModifierBindingType::OutputFeatureInfoType OutputFeatureInfoType;
455 
456  services::Status addModifier(const features::FeatureIdCollectionIfacePtr &identifiers,
457  const services::SharedPtr<Modifier> &modifier)
458  {
459  return _binder.add(identifiers, modifier);
460  }
461 
462  void applyModifiers(const services::BufferView<DAAL_DATA_TYPE> &outputBuffer)
463  {
464  _binder.apply(outputBuffer);
465  }
466 
467  void finalize()
468  {
469  _binder.finalize();
470  }
471 
472  services::Status fillDictionary(DataSourceDictionary &dictionary)
473  {
474  const size_t numberOfOutputFeatures = _binder.getNumberOfOutputFeatures();
475  dictionary.setNumberOfFeatures(numberOfOutputFeatures);
476 
477  size_t featureCounter = 0;
478  for (size_t i = 0; i < _binder.getNumberOfModifiers(); i++)
479  {
480  const ModifierBindingType &binding = _binder.getBinding(i);
481  for (size_t j = 0; j < binding.getNumberOfOutputFeatures(); j++)
482  {
483  const OutputFeatureInfoType &fi = binding.getOutputFeatureInfo(j);
484  fi.fillDataSourceFeature( dictionary[featureCounter++] );
485  }
486  }
487  DAAL_ASSERT( numberOfOutputFeatures == featureCounter );
488 
489  return services::Status();
490  }
491 
492  size_t getNumberOfOutputFeatures() const
493  {
494  return _binder.getNumberOfOutputFeatures();
495  }
496 
497 protected:
498  ModifiersManager() { }
499 
500  modifiers::internal::ModifiersBinder<ModifierBindingType> &getBinder()
501  {
502  return _binder;
503  }
504 
505 private:
506  modifiers::internal::ModifiersBinder<ModifierBindingType> _binder;
507 };
508 
509 } // namespace internal
510 } // namespace modifiers
511 } // namespace data_management
512 } // namespace daal
513 
514 #endif
daal
Definition: algorithm_base_common.h:31
daal::data_management::modifiers::internal::ModifiersBinder
Class that creates and manages bindings for a modifier.
Definition: data_management/data_source/modifiers/internal/engine.h:349
daal::data_management::modifiers::internal::Config
Base class for modifier configuration.
Definition: data_management/data_source/modifiers/internal/engine.h:100
daal::services::internal::CollectionPtr
Shared pointer to the Collection object.
Definition: internal/collection.h:136
daal::services::ErrorMemoryAllocationFailed
Definition: error_indexes.h:147
daal::services::ErrorIncorrectIndex
Definition: error_indexes.h:100
daal::services::ErrorNullPtr
Definition: error_indexes.h:139
daal::data_management::modifiers::internal::OutputFeatureInfo
Base class represents output feature for modifier, contains information about single output feature...
Definition: data_management/data_source/modifiers/internal/engine.h:41
daal::Base
Base class for Intel(R) Data Analytics Acceleration Library objects
Definition: base.h:39
daal::data_management::modifiers::internal::Context
Base class for modifier context.
Definition: data_management/data_source/modifiers/internal/engine.h:214
daal::data_management::modifiers::internal::ModifierBinding
Class that binds feature identifiers to concrete feature indices, performs initialization of a modifi...
Definition: data_management/data_source/modifiers/internal/engine.h:266
daal::data_management::modifiers::internal::InputFeatureInfo
Base class represents input feature for modifier, contains information about single input feature...
Definition: data_management/data_source/modifiers/internal/engine.h:35
daal::data_management::modifiers::internal::ModifiersManager
Class that holds modifiers and implements logic of modifiers applying flow.
Definition: data_management/data_source/modifiers/internal/engine.h:449

For more complete information about compiler optimizations, see our Optimization Notice.