C++ API Reference for Intel® Data Analytics Acceleration Library 2018 Update 3

implicit_als_training_distributed.h
1 /* file: implicit_als_training_distributed.h */
2 /*******************************************************************************
3 * Copyright 2014-2018 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 /*
17 //++
18 // Implementation of the interface for implicit ALS model-based training in the
19 // distributed processing mode
20 //--
21 */
22 
23 #ifndef __IMPLICIT_ALS_TRAINING_DISTRIBUTED_H__
24 #define __IMPLICIT_ALS_TRAINING_DISTRIBUTED_H__
25 
26 #include "algorithms/algorithm.h"
27 #include "algorithms/implicit_als/implicit_als_training_types.h"
28 
29 namespace daal
30 {
31 namespace algorithms
32 {
33 namespace implicit_als
34 {
35 namespace training
36 {
37 
38 namespace interface1
39 {
50 template<ComputeStep step, typename algorithmFPType, Method method, CpuType cpu>
51 class DAAL_EXPORT DistributedContainer
52 {};
53 
58 template<typename algorithmFPType, Method method, CpuType cpu>
59 class DAAL_EXPORT DistributedContainer<step1Local, algorithmFPType, method, cpu> : public
60  TrainingContainerIface<distributed>
61 {
62 public:
68  DistributedContainer(daal::services::Environment::env *daalEnv);
70  ~DistributedContainer();
71 
76  services::Status compute() DAAL_C11_OVERRIDE;
81  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
82 };
83 
88 template<typename algorithmFPType, Method method, CpuType cpu>
89 class DAAL_EXPORT DistributedContainer<step2Master, algorithmFPType, method, cpu> : public
90  TrainingContainerIface<distributed>
91 {
92 public:
98  DistributedContainer(daal::services::Environment::env *daalEnv);
100  ~DistributedContainer();
101 
106  services::Status compute() DAAL_C11_OVERRIDE;
111  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
112 };
113 
118 template<typename algorithmFPType, Method method, CpuType cpu>
119 class DAAL_EXPORT DistributedContainer<step3Local, algorithmFPType, method, cpu> : public
120  TrainingContainerIface<distributed>
121 {
122 public:
128  DistributedContainer(daal::services::Environment::env *daalEnv);
130  ~DistributedContainer();
131 
136  services::Status compute() DAAL_C11_OVERRIDE;
141  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
142 };
143 
148 template<typename algorithmFPType, Method method, CpuType cpu>
149 class DAAL_EXPORT DistributedContainer<step4Local, algorithmFPType, method, cpu> : public
150  TrainingContainerIface<distributed>
151 {
152 public:
158  DistributedContainer(daal::services::Environment::env *daalEnv);
160  ~DistributedContainer();
161 
166  services::Status compute() DAAL_C11_OVERRIDE;
171  services::Status finalizeCompute() DAAL_C11_OVERRIDE;
172 };
173 
186 template<ComputeStep step, typename algorithmFPType = DAAL_ALGORITHM_FP_TYPE, Method method = fastCSR>
187 class DAAL_EXPORT Distributed : public Training<distributed> {};
188 
204 template<typename algorithmFPType, Method method>
205 class DAAL_EXPORT Distributed<step1Local, algorithmFPType, method> : public Training<distributed>
206 {
207 public:
208  typedef algorithms::implicit_als::training::DistributedInput<step1Local> InputType;
209  typedef algorithms::implicit_als::Parameter ParameterType;
210  typedef algorithms::implicit_als::training::Result ResultType;
211  typedef algorithms::implicit_als::training::DistributedPartialResultStep1 PartialResultType;
212 
213  DistributedInput<step1Local> input;
214  ParameterType parameter;
217  Distributed()
218  {
219  initialize();
220  }
221 
228  Distributed(const Distributed<step1Local, algorithmFPType, method> &other) : input(other.input), parameter(other.parameter)
229  {
230  initialize();
231  }
232 
237  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int)method; }
238 
245  services::Status setPartialResult(const DistributedPartialResultStep1Ptr& partialResult)
246  {
247  DAAL_CHECK(partialResult, services::ErrorNullPartialResult);
248  _partialResult = partialResult;
249  _pres = _partialResult.get();
250  return services::Status();
251  }
252 
259  DistributedPartialResultStep1Ptr getPartialResult() { return _partialResult; }
260 
266  services::SharedPtr<Distributed<step1Local, algorithmFPType, method> > clone() const
267  {
268  return services::SharedPtr<Distributed<step1Local, algorithmFPType, method> >(cloneImpl());
269  }
270 
271 protected:
272  DistributedPartialResultStep1Ptr _partialResult;
273 
274  virtual Distributed<step1Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
275  {
276  return new Distributed<step1Local, algorithmFPType, method>(*this);
277  }
278 
279  services::Status allocateResult() DAAL_C11_OVERRIDE
280  {
281  return services::Status();
282  }
283 
284  services::Status allocatePartialResult() DAAL_C11_OVERRIDE
285  {
286  services::Status s = _partialResult->allocate<algorithmFPType>(&input, &parameter, method);
287  _pres = _partialResult.get();
288  return s;
289  }
290 
291  services::Status initializePartialResult() DAAL_C11_OVERRIDE
292  {
293  return services::Status();
294  }
295 
296  void initialize()
297  {
298  _ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step1Local, algorithmFPType, method)(&_env);
299  _in = &input;
300  _par = &parameter;
301  _partialResult.reset(new PartialResultType());
302  }
303 };
304 
320 template<typename algorithmFPType, Method method>
321 class DAAL_EXPORT Distributed<step2Master, algorithmFPType, method> : public Training<distributed>
322 {
323 public:
324  typedef algorithms::implicit_als::training::DistributedInput<step2Master> InputType;
325  typedef algorithms::implicit_als::Parameter ParameterType;
326  typedef algorithms::implicit_als::training::Result ResultType;
327  typedef algorithms::implicit_als::training::DistributedPartialResultStep2 PartialResultType;
328 
329  DistributedInput<step2Master> input;
330  ParameterType parameter;
333  Distributed()
334  {
335  initialize();
336  }
337 
344  Distributed(const Distributed<step2Master, algorithmFPType, method> &other) : input(other.input), parameter(other.parameter)
345  {
346  initialize();
347  }
348 
353  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int)method; }
354 
361  services::Status setPartialResult(const DistributedPartialResultStep2Ptr& partialResult)
362  {
363  DAAL_CHECK(partialResult, services::ErrorNullPartialResult);
364  _partialResult = partialResult;
365  _pres = _partialResult.get();
366  return services::Status();
367  }
368 
375  DistributedPartialResultStep2Ptr getPartialResult() { return _partialResult; }
376 
382  services::SharedPtr<Distributed<step2Master, algorithmFPType, method> > clone() const
383  {
384  return services::SharedPtr<Distributed<step2Master, algorithmFPType, method> >(cloneImpl());
385  }
386 
387 protected:
388  DistributedPartialResultStep2Ptr _partialResult;
389 
390  virtual Distributed<step2Master, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
391  {
392  return new Distributed<step2Master, algorithmFPType, method>(*this);
393  }
394 
395  services::Status allocateResult() DAAL_C11_OVERRIDE
396  {
397  return services::Status();
398  }
399 
400  services::Status allocatePartialResult() DAAL_C11_OVERRIDE
401  {
402  services::Status s = _partialResult->allocate<algorithmFPType>(&input, &parameter, method);
403  _pres = _partialResult.get();
404  return s;
405  }
406 
407  services::Status initializePartialResult() DAAL_C11_OVERRIDE
408  {
409  return services::Status();
410  }
411 
412  void initialize()
413  {
414  _ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step2Master, algorithmFPType, method)(&_env);
415  _in = &input;
416  _par = &parameter;
417  _partialResult.reset(new PartialResultType());
418  }
419 };
420 
421 
437 template<typename algorithmFPType, Method method>
438 class DAAL_EXPORT Distributed<step3Local, algorithmFPType, method> : public Training<distributed>
439 {
440 public:
441  typedef algorithms::implicit_als::training::DistributedInput<step3Local> InputType;
442  typedef algorithms::implicit_als::Parameter ParameterType;
443  typedef algorithms::implicit_als::training::Result ResultType;
444  typedef algorithms::implicit_als::training::DistributedPartialResultStep3 PartialResultType;
445 
446  DistributedInput<step3Local> input;
447  ParameterType parameter;
450  Distributed()
451  {
452  initialize();
453  }
454 
461  Distributed(const Distributed<step3Local, algorithmFPType, method> &other) : input(other.input), parameter(other.parameter)
462  {
463  initialize();
464  }
465 
470  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int)method; }
471 
478  services::Status setPartialResult(const DistributedPartialResultStep3Ptr& partialResult)
479  {
480  DAAL_CHECK(partialResult, services::ErrorNullPartialResult);
481  _partialResult = partialResult;
482  _pres = _partialResult.get();
483  return services::Status();
484  }
485 
492  DistributedPartialResultStep3Ptr getPartialResult() { return _partialResult; }
493 
499  services::SharedPtr<Distributed<step3Local, algorithmFPType, method> > clone() const
500  {
501  return services::SharedPtr<Distributed<step3Local, algorithmFPType, method> >(cloneImpl());
502  }
503 
504 protected:
505  DistributedPartialResultStep3Ptr _partialResult;
506 
507  virtual Distributed<step3Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
508  {
509  return new Distributed<step3Local, algorithmFPType, method>(*this);
510  }
511 
512  services::Status allocateResult() DAAL_C11_OVERRIDE
513  {
514  return services::Status();
515  }
516 
517  services::Status allocatePartialResult() DAAL_C11_OVERRIDE
518  {
519  services::Status s = _partialResult->allocate<algorithmFPType>(&input, &parameter, method);
520  _pres = _partialResult.get();
521  return s;
522  }
523 
524  services::Status initializePartialResult() DAAL_C11_OVERRIDE
525  {
526  return services::Status();
527  }
528 
529  void initialize()
530  {
531  _ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step3Local, algorithmFPType, method)(&_env);
532  _in = &input;
533  _par = &parameter;
534  _partialResult.reset(new PartialResultType());
535  }
536 };
537 
553 template<typename algorithmFPType, Method method>
554 class DAAL_EXPORT Distributed<step4Local, algorithmFPType, method> : public Training<distributed>
555 {
556 public:
557  typedef algorithms::implicit_als::training::DistributedInput<step4Local> InputType;
558  typedef algorithms::implicit_als::Parameter ParameterType;
559  typedef algorithms::implicit_als::training::Result ResultType;
560  typedef algorithms::implicit_als::training::DistributedPartialResultStep4 PartialResultType;
561 
562  DistributedInput<step4Local> input;
563  ParameterType parameter;
566  Distributed()
567  {
568  initialize();
569  }
570 
577  Distributed(const Distributed<step4Local, algorithmFPType, method> &other) : input(other.input), parameter(other.parameter)
578  {
579  initialize();
580  }
581 
586  virtual int getMethod() const DAAL_C11_OVERRIDE { return(int)method; }
587 
594  services::Status setPartialResult(const DistributedPartialResultStep4Ptr& partialResult)
595  {
596  DAAL_CHECK(partialResult, services::ErrorNullPartialResult);
597  _partialResult = partialResult;
598  _pres = _partialResult.get();
599  return services::Status();
600  }
601 
608  DistributedPartialResultStep4Ptr getPartialResult() { return _partialResult; }
609 
615  services::SharedPtr<Distributed<step4Local, algorithmFPType, method> > clone() const
616  {
617  return services::SharedPtr<Distributed<step4Local, algorithmFPType, method> >(cloneImpl());
618  }
619 
620 protected:
621  DistributedPartialResultStep4Ptr _partialResult;
622 
623  virtual Distributed<step4Local, algorithmFPType, method> * cloneImpl() const DAAL_C11_OVERRIDE
624  {
625  return new Distributed<step4Local, algorithmFPType, method>(*this);
626  }
627 
628  services::Status allocateResult() DAAL_C11_OVERRIDE
629  {
630  return services::Status();
631  }
632 
633  services::Status allocatePartialResult() DAAL_C11_OVERRIDE
634  {
635  services::Status s = _partialResult->allocate<algorithmFPType>(&input, &parameter, method);
636  _pres = _partialResult.get();
637  return s;
638  }
639 
640  services::Status initializePartialResult() DAAL_C11_OVERRIDE
641  {
642  return services::Status();
643  }
644 
645  void initialize()
646  {
647  _ac = new __DAAL_ALGORITHM_CONTAINER(distributed, DistributedContainer, step4Local, algorithmFPType, method)(&_env);
648  _in = &input;
649  _par = &parameter;
650  _partialResult.reset(new PartialResultType());
651  }
652 };
654 } // namespace interface1
655 using interface1::DistributedContainer;
656 using interface1::Distributed;
657 
658 }
659 }
660 }
661 }
662 
663 #endif
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep1Ptr &partialResult)
Definition: implicit_als_training_distributed.h:245
daal::algorithms::implicit_als::training::interface1::DistributedInput< step1Local >
Input objects for the implicit ALS training algorithm in the first step of the distributed processing...
Definition: implicit_als_training_types.h:296
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::input
DistributedInput< step1Local > input
Definition: implicit_als_training_distributed.h:213
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::input
DistributedInput< step4Local > input
Definition: implicit_als_training_distributed.h:562
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::Distributed
Distributed()
Definition: implicit_als_training_distributed.h:333
daal
Definition: algorithm_base_common.h:31
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep3Ptr &partialResult)
Definition: implicit_als_training_distributed.h:478
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: implicit_als_training_distributed.h:237
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::Distributed
Distributed(const Distributed< step4Local, algorithmFPType, method > &other)
Definition: implicit_als_training_distributed.h:577
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::Distributed
Distributed()
Definition: implicit_als_training_distributed.h:566
daal::algorithms::implicit_als::training::interface1::DistributedInput< step2Master >
Input objects for the implicit ALS training algorithm in the second step of the distributed processin...
Definition: implicit_als_training_types.h:392
daal::algorithms::implicit_als::training::interface1::DistributedInput< step3Local >
Input objects for the implicit ALS training algorithm in the third step of the distributed processing...
Definition: implicit_als_training_types.h:496
daal::services::ErrorNullPartialResult
Definition: error_indexes.h:105
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step3Local, algorithmFPType, method > > clone() const
Definition: implicit_als_training_distributed.h:499
daal::algorithms::implicit_als::training::interface1::DistributedInput< step4Local >
Input objects for the implicit ALS training algorithm in the fourth step of the distributed processin...
Definition: implicit_als_training_types.h:650
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::Distributed
Distributed()
Definition: implicit_als_training_distributed.h:450
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: implicit_als_training_distributed.h:353
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::input
DistributedInput< step3Local > input
Definition: implicit_als_training_distributed.h:446
daal::algorithms::implicit_als::training::interface1::DistributedContainer
Class containing methods to compute the result of implicit ALS model-based training in the distribute...
Definition: implicit_als_training_distributed.h:51
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep4Ptr &partialResult)
Definition: implicit_als_training_distributed.h:594
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::input
DistributedInput< step2Master > input
Definition: implicit_als_training_distributed.h:329
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::Distributed
Distributed(const Distributed< step3Local, algorithmFPType, method > &other)
Definition: implicit_als_training_distributed.h:461
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step2Master, algorithmFPType, method > > clone() const
Definition: implicit_als_training_distributed.h:382
daal::algorithms::kmeans::init::interface1::Distributed
class DAAL_EXPORT Distributed
Computes initial clusters for the K-Means algorithm in the distributed processing mode...
Definition: kmeans_init_distributed.h:255
daal::distributed
Definition: daal_defines.h:107
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >
Trains the implicit ALS model in the first step of the distributed processing mode.
Definition: implicit_als_training_distributed.h:205
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: implicit_als_training_distributed.h:470
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::Distributed
Distributed()
Definition: implicit_als_training_distributed.h:217
daal::algorithms::implicit_als::training::interface1::Distributed
Trains the implicit ALS model in the distributed processing mode.
Definition: implicit_als_training_distributed.h:187
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep1Ptr getPartialResult()
Definition: implicit_als_training_distributed.h:259
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >
Trains the implicit ALS model in the fourth step of the distributed processing mode.
Definition: implicit_als_training_distributed.h:554
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::Distributed
Distributed(const Distributed< step2Master, algorithmFPType, method > &other)
Definition: implicit_als_training_distributed.h:344
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step1Local, algorithmFPType, method > > clone() const
Definition: implicit_als_training_distributed.h:266
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >
Trains the implicit ALS model in the second step of the distributed processing mode.
Definition: implicit_als_training_distributed.h:321
daal::step4Local
Definition: daal_defines.h:120
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::parameter
ParameterType parameter
Definition: implicit_als_training_distributed.h:330
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::clone
services::SharedPtr< Distributed< step4Local, algorithmFPType, method > > clone() const
Definition: implicit_als_training_distributed.h:615
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >
Trains the implicit ALS model in the third step of the distributed processing mode.
Definition: implicit_als_training_distributed.h:438
daal::algorithms::kmeans::interface1::DistributedContainer
class DAAL_EXPORT DistributedContainer
Provides methods to run implementations of the K-Means algorithm. This class is associated with the d...
Definition: kmeans_distributed.h:55
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep3Ptr getPartialResult()
Definition: implicit_als_training_distributed.h:492
daal::step1Local
Definition: daal_defines.h:117
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep4Ptr getPartialResult()
Definition: implicit_als_training_distributed.h:608
daal::step2Master
Definition: daal_defines.h:118
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::parameter
ParameterType parameter
Definition: implicit_als_training_distributed.h:214
daal::algorithms::implicit_als::training::interface1::Distributed< step1Local, algorithmFPType, method >::Distributed
Distributed(const Distributed< step1Local, algorithmFPType, method > &other)
Definition: implicit_als_training_distributed.h:228
daal::algorithms::implicit_als::training::interface1::Distributed< step3Local, algorithmFPType, method >::parameter
ParameterType parameter
Definition: implicit_als_training_distributed.h:447
daal::step3Local
Definition: daal_defines.h:119
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::getPartialResult
DistributedPartialResultStep2Ptr getPartialResult()
Definition: implicit_als_training_distributed.h:375
daal::algorithms::implicit_als::training::interface1::Distributed< step2Master, algorithmFPType, method >::setPartialResult
services::Status setPartialResult(const DistributedPartialResultStep2Ptr &partialResult)
Definition: implicit_als_training_distributed.h:361
daal::algorithms::TrainingContainerIface
Abstract interface class that provides virtual methods to access and run implementations of the model...
Definition: training.h:50
daal::algorithms::Training
Provides methods to train models that depend on the data provided. For example, these methods enable ...
Definition: training.h:60
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::getMethod
virtual int getMethod() const DAAL_C11_OVERRIDE
Definition: implicit_als_training_distributed.h:586
daal::algorithms::implicit_als::training::interface1::Distributed< step4Local, algorithmFPType, method >::parameter
ParameterType parameter
Definition: implicit_als_training_distributed.h:563

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