/
1_mnist_mlp.cpp
120 lines (95 loc) · 3.13 KB
/
1_mnist_mlp.cpp
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
/*
* EDDL Library - European Distributed Deep Learning Library.
* Version: 1.1
* copyright (c) 2022, Universitat Politècnica de València (UPV), PRHLT Research Centre
* Date: March 2022
* Author: PRHLT Research Centre, UPV, (rparedes@prhlt.upv.es), (jon@prhlt.upv.es)
* All rights reserved
*/
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include "eddl/apis/eddl.h"
using namespace eddl;
//////////////////////////////////
// mnist_mlp.cpp:
// A very basic MLP for mnist
// Using fit for training
//////////////////////////////////
int main(int argc, char **argv) {
bool testing = false;
bool use_cpu = false;
for (int i = 1; i < argc; ++i) {
if (strcmp(argv[i], "--testing") == 0) testing = true;
else if (strcmp(argv[i], "--cpu") == 0) use_cpu = true;
}
// Download mnist
download_mnist();
// Settings
int epochs = (testing) ? 2 : 10;
int batch_size = 100;
int num_classes = 10;
// Define network
layer in = Input({784});
layer l = in; // Aux var
l = LeakyReLu(Dense(l, 1024));
l = LeakyReLu(Dense(l, 1024));
l = LeakyReLu(Dense(l, 1024));
layer out = Softmax(Dense(l, num_classes), -1); // Softmax axis optional (default=-1)
model net = Model({in}, {out});
net->verbosity_level = 0;
// dot from graphviz should be installed:
plot(net, "model.pdf");
compserv cs = nullptr;
if (use_cpu) {
cs = CS_CPU();
} else {
cs = CS_GPU({1},"low_mem"); // one GPU
// cs = CS_GPU({1,1},100); // two GPU with weight sync every 100 batches
// cs = CS_CPU();
// cs = CS_FPGA({1});
}
// Build model
build(net,
adam(0.001), // Optimizer
{"softmax_cross_entropy"}, // Losses
{"categorical_accuracy"}, // Metrics
cs );
// toGPU(net, {1}, 100,"low_mem"); // In two gpus, syncronize every 100 batches, low_mem setup
// View model
summary(net);
// Load dataset
Tensor* x_train = Tensor::load("mnist_trX.bin");
Tensor* y_train = Tensor::load("mnist_trY.bin");
Tensor* x_test = Tensor::load("mnist_tsX.bin");
Tensor* y_test = Tensor::load("mnist_tsY.bin");
if (testing) {
std::string _range_ = "0:" + std::to_string(2 * batch_size);
Tensor* x_mini_train = x_train->select({_range_, ":"});
Tensor* y_mini_train = y_train->select({_range_, ":"});
Tensor* x_mini_test = x_test->select({_range_, ":"});
Tensor* y_mini_test = y_test->select({_range_, ":"});
delete x_train;
delete y_train;
delete x_test;
delete y_test;
x_train = x_mini_train;
y_train = y_mini_train;
x_test = x_mini_test;
y_test = y_mini_test;
}
// Preprocessing
x_train->div_(255.0f);
x_test->div_(255.0f);
// Train model
fit(net, {x_train}, {y_train}, batch_size, epochs);
// Evaluate
evaluate(net, {x_test}, {y_test});
// Release objects, layers, optimizer and computing service are released by the net object
delete x_train;
delete y_train;
delete x_test;
delete y_test;
delete net;
return EXIT_SUCCESS;
}