cntk 0.0.3

Wrapper around Microsoft CNTK library
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use variable::{Variable};
use learner::Learner;
use function::Function;
use data_map::DataMap;
use device::DeviceDescriptor;

cpp! {{
  #include <CNTKLibrary.h>
  #include <cstdio>
  #include <vector>

  using namespace CNTK;
  using namespace std;
}}

type TrainerInner = [u64; 2usize];

#[derive(Debug)]
pub struct Trainer {
    pub(super) payload: TrainerInner
}

impl Trainer {
    pub fn new(model: &Function, loss: &Function, learner: &Learner) -> Trainer {
        let modelpayload = model.payload;
        let losspayload = loss.payload;
        let learnerpayload = learner.payload;
        Trainer { payload: unsafe {
            cpp!([modelpayload as "FunctionPtr", losspayload as "FunctionPtr", learnerpayload as "LearnerPtr"] -> TrainerInner as "TrainerPtr"{
                return CreateTrainer(modelpayload, losspayload, { learnerpayload });
            })
        }}
    }

    pub fn new_with_evalatuion(model: &Function, loss: &Function, evaluation: &Function, learner: &Learner) -> Trainer {
        let modelpayload = model.payload;
        let losspayload = loss.payload;
        let learnerpayload = learner.payload;
        let evaluationpayload = evaluation.payload;
        Trainer { payload: unsafe {
            cpp!([modelpayload as "FunctionPtr", losspayload as "FunctionPtr", evaluationpayload as "FunctionPtr", learnerpayload as "LearnerPtr"] -> TrainerInner as "TrainerPtr"{
                return CreateTrainer(modelpayload, losspayload, evaluationpayload, { learnerpayload });
            })
        }}
    }

    pub fn train_minibatch(&self, arguments: &DataMap, outputs_to_fetch: &mut DataMap, device: DeviceDescriptor) {
        let payload = self.payload;
        let impayload = arguments.payload;
        let mut ompayload = outputs_to_fetch.payload;
        let dpayload = device.payload;
        unsafe {
            cpp!([payload as "TrainerPtr", impayload as "unordered_map<Variable, ValuePtr>*", mut ompayload as "unordered_map<Variable, ValuePtr>*", dpayload as "DeviceDescriptor"] {
                payload->TrainMinibatch(*impayload, *ompayload, dpayload);
            })
        };
    }
}

impl Drop for Trainer {
    fn drop(&mut self) {
        let payload = self.payload;
        unsafe {
            cpp!([payload as "TrainerPtr"] {
                payload.~TrainerPtr();
            })
        };
    }
}