C++ API Reference for Intel® Data Analytics Acceleration Library 2020 Update 1

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

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