39 #include "tiny_dnn/nodes.h"
40 #include "tiny_dnn/util/util.h"
41 #include "tiny_dnn/lossfunctions/loss_function.h"
42 #include "tiny_dnn/activations/activation_function.h"
46 enum class content_type {
52 enum class file_format {
58 result() : num_success(0), num_total(0) {}
60 float_t accuracy()
const {
61 return float_t(num_success * 100.0 / num_total);
64 template <
typename Char,
typename CharTraits>
65 void print_summary(std::basic_ostream<Char, CharTraits>& os)
const {
66 os <<
"accuracy:" << accuracy()
67 <<
"% (" << num_success <<
"/"
68 << num_total <<
")" << std::endl;
71 template <
typename Char,
typename CharTraits>
72 void print_detail(std::basic_ostream<Char, CharTraits>& os)
const {
74 auto all_labels = labels();
76 os << std::setw(5) <<
"*" <<
" ";
77 for (
auto c : all_labels)
78 os << std::setw(5) << c <<
" ";
81 for (
auto r : all_labels) {
82 os << std::setw(5) << r <<
" ";
83 const auto row_iter = confusion_matrix.find(r);
84 for (
auto c : all_labels) {
86 if (row_iter != confusion_matrix.end()) {
87 const auto& row = row_iter->second;
88 const auto col_iter = row.find(c);
89 if (col_iter != row.end()) {
90 count = col_iter->second;
93 os << std::setw(5) << count <<
" ";
99 std::set<label_t> labels()
const {
100 std::set<label_t> all_labels;
101 for (
auto r : confusion_matrix) {
102 all_labels.insert(r.first);
103 for (
auto c : r.second)
104 all_labels.insert(c.first);
111 std::map<label_t, std::map<label_t, int> > confusion_matrix;
114 enum grad_check_mode {
119 template <
typename NetType>
122 template <
typename Layer>
123 network<sequential>& operator << (network<sequential>& n, Layer&& l);
125 void construct_graph(network<graph>& graph,
126 const std::vector<std::shared_ptr<layer>>& inputs,
127 const std::vector<std::shared_ptr<layer>>& outputs);
128 void construct_graph(network<graph>& graph,
129 const std::vector<layer*>& inputs,
130 const std::vector<layer*>& outputs);
166 template<
typename NetType>
169 typedef typename std::vector<layerptr_t>::iterator iterator;
170 typedef typename std::vector<layerptr_t>::const_iterator const_iterator;
177 std::string
name()
const {
return name_; }
187 vec_t
predict(
const vec_t& in) {
return fprop(in); }
192 tensor_t
predict(
const tensor_t& in) {
return fprop(in); }
197 std::vector<tensor_t>
predict(
const std::vector<tensor_t>& in) {
return fprop(in); }
203 return fprop_max(in);
210 return fprop_max_index(in);
218 template <
typename Range>
222 return predict(vec_t(begin(in), end(in)));
245 template <
typename Error,
typename Optimizer,
246 typename OnBatchEnumerate,
typename OnEpochEnumerate>
248 const std::vector<vec_t>& inputs,
249 const std::vector<label_t>& class_labels,
252 OnBatchEnumerate on_batch_enumerate,
253 OnEpochEnumerate on_epoch_enumerate,
254 const bool reset_weights =
false,
255 const int n_threads = CNN_TASK_SIZE,
256 const std::vector<vec_t>& t_cost = std::vector<vec_t>()) {
257 std::vector<tensor_t> input_tensor, output_tensor, t_cost_tensor;
258 normalize_tensor(inputs, input_tensor);
259 normalize_tensor(class_labels, output_tensor);
260 if (!t_cost.empty()) normalize_tensor(t_cost, t_cost_tensor);
262 return fit<Error>(
optimizer, input_tensor, output_tensor, batch_size,
263 epoch, on_batch_enumerate, on_epoch_enumerate,
264 reset_weights, n_threads, t_cost_tensor);
309 template <
typename Error,
typename Optimizer,
310 typename OnBatchEnumerate,
typename OnEpochEnumerate,
311 typename T,
typename U>
313 const std::vector<T>& inputs,
314 const std::vector<U>& desired_outputs,
317 OnBatchEnumerate on_batch_enumerate,
318 OnEpochEnumerate on_epoch_enumerate,
319 const bool reset_weights =
false,
320 const int n_threads = CNN_TASK_SIZE,
321 const std::vector<U>& t_cost = std::vector<U>()) {
322 std::vector<tensor_t> input_tensor, output_tensor, t_cost_tensor;
323 normalize_tensor(inputs, input_tensor);
324 normalize_tensor(desired_outputs, output_tensor);
325 if (!t_cost.empty()) normalize_tensor(t_cost, t_cost_tensor);
327 return fit<Error>(
optimizer, input_tensor, output_tensor, batch_size,
328 epoch, on_batch_enumerate, on_epoch_enumerate,
329 reset_weights, n_threads, t_cost_tensor);
339 template<
typename Error,
typename Optimizer,
typename T,
typename U>
341 const std::vector<T>& inputs,
342 const std::vector<U>& desired_outputs,
343 size_t batch_size = 1,
345 return fit<Error>(
optimizer, inputs, desired_outputs,
346 batch_size, epoch, nop, nop);
356 template<
typename Error,
typename Optimizer>
358 const std::vector<vec_t>& inputs,
359 const std::vector<label_t>& class_labels,
360 size_t batch_size = 1,
362 return train<Error>(
optimizer, inputs, class_labels,
363 batch_size, epoch, nop, nop);
369 template<
typename Error,
typename Optimizer>
371 const std::vector<vec_t>& in,
372 const std::vector<vec_t>& t,
373 size_t batch_size = 1,
375 return fit<Error>(
optimizer, in, t, batch_size, epoch, nop, nop);
383 for (
auto n : net_) {
384 n->set_context(phase);
391 result test(
const std::vector<vec_t>& in,
const std::vector<label_t>& t) {
394 for (
size_t i = 0; i < in.size(); i++) {
395 const label_t predicted = fprop_max_index(in[i]);
396 const label_t actual = t[i];
398 if (predicted == actual) test_result.num_success++;
399 test_result.num_total++;
400 test_result.confusion_matrix[predicted][actual]++;
408 std::vector<vec_t>
test(
const std::vector<vec_t>& in) {
409 std::vector<vec_t> test_result(in.size());
411 for (
size_t i = 0; i < in.size(); i++) {
412 test_result[i] =
predict(in[i]);
420 template <
typename E>
422 const std::vector<vec_t>& t) {
423 float_t sum_loss = float_t(0);
425 for (
size_t i = 0; i < in.size(); i++) {
426 const vec_t predicted =
predict(in[i]);
427 sum_loss += E::f(predicted, t[i]);
435 template <
typename E,
typename T>
436 float_t
get_loss(
const std::vector<T>& in,
const std::vector<tensor_t>& t) {
437 float_t sum_loss = float_t(0);
438 std::vector<tensor_t> in_tensor;
439 normalize_tensor(in, in_tensor);
441 for (
size_t i = 0; i < in.size(); i++) {
442 const tensor_t predicted =
predict(in_tensor[i]);
443 for (
size_t j = 0; j < predicted.size(); j++) {
444 sum_loss += E::f(predicted[j], t[i][j]);
455 template <
typename E>
457 const std::vector<std::vector<label_t>>& t,
458 float_t eps, grad_check_mode mode) {
459 assert(in.size() == t.size());
461 std::vector<tensor_t> v(t.size());
462 const serial_size_t sample_count =
static_cast<serial_size_t
>(t.size());
463 for (serial_size_t sample = 0; sample < sample_count; ++sample) {
464 net_.label2vec(&t[sample][0],
static_cast<serial_size_t
>(t[sample].size()), &v[sample]);
467 for (
auto current : net_) {
468 if (current->weights().size() < 2) {
471 vec_t& w = *current->weights()[0];
472 vec_t& b = *current->weights()[1];
473 tensor_t& dw = (*current->weights_grads()[0]);
474 tensor_t& db = (*current->weights_grads()[1]);
476 if (w.empty())
continue;
480 for (
int i = 0; i < static_cast<int>(w.size()); i++)
481 if (!calc_delta<E>(in, v, w, dw, i, eps)) {
484 for (
int i = 0; i < static_cast<int>(b.size()); i++)
485 if (!calc_delta<E>(in, v, b, db, i, eps)) {
489 case GRAD_CHECK_RANDOM:
490 for (
int i = 0; i < 10; i++)
491 if (!calc_delta<E>(in, v, w, dw, uniform_idx(w), eps)) {
494 for (
int i = 0; i < 10; i++)
495 if (!calc_delta<E>(in, v, b, db, uniform_idx(b), eps)) {
500 throw nn_error(
"unknown grad-check type");
538 template <
typename T>
539 const T&
at(
size_t index)
const {
540 return net_.template at<T>(index);
543 template <
typename T>
544 T&
at(
size_t index) {
545 return net_.template at<T>(index);
552 return net_.out_data_size();
559 return net_.in_data_size();
565 template <
typename WeightInit>
567 auto ptr = std::make_shared<WeightInit>(f);
576 template <
typename BiasInit>
578 auto ptr = std::make_shared<BiasInit>(f);
587 template <
typename T>
589 auto first1 = net_.begin();
590 auto first2 = rhs.net_.begin();
591 auto last1 = net_.end();
592 auto last2 = rhs.net_.end();
594 for (; first1 != last1 && first2 != last2; ++first1, ++first2)
595 if (!(*first1)->has_same_weights(**first2, eps))
return false;
599 iterator begin() {
return net_.begin(); }
600 iterator end() {
return net_.end(); }
601 const_iterator begin()
const {
return net_.begin(); }
602 const_iterator end()
const {
return net_.end(); }
604 void load(
const std::string& filename,
605 content_type what = content_type::weights_and_model,
606 file_format format = file_format::binary) {
607 std::ifstream ifs(filename.c_str(), std::ios::binary | std::ios::in);
608 if (ifs.fail() || ifs.bad())
609 throw nn_error(
"failed to open:" + filename);
612 case file_format::binary:
614 cereal::BinaryInputArchive bi(ifs);
615 from_archive(bi, what);
618 case file_format::json:
620 cereal::JSONInputArchive ji(ifs);
621 from_archive(ji, what);
625 throw nn_error(
"invalid serialization format");
629 void save(
const std::string& filename,
630 content_type what = content_type::weights_and_model,
631 file_format format = file_format::binary)
const {
632 std::ofstream ofs(filename.c_str(), std::ios::binary | std::ios::out);
633 if (ofs.fail() || ofs.bad())
634 throw nn_error(
"failed to open:" + filename);
637 case file_format::binary:
639 cereal::BinaryOutputArchive bo(ofs);
640 to_archive(bo, what);
643 case file_format::json:
645 cereal::JSONOutputArchive jo(ofs);
646 to_archive(jo, what);
650 throw nn_error(
"invalid serialization format");
658 std::stringstream ss;
660 cereal::JSONOutputArchive oa(ss);
661 to_archive(oa, content_type::model);
670 std::stringstream ss;
672 cereal::JSONInputArchive ia(ss);
673 from_archive(ia, content_type::model);
677 void save(std::ostream& os)
const {
678 os.precision(std::numeric_limits<tiny_dnn::float_t>::digits10);
683 void load(std::istream& is) {
684 is.precision(std::numeric_limits<tiny_dnn::float_t>::digits10);
693 FILE* stream = fopen(filepath,
"r");
694 std::vector<float_t> data;
696 while (fscanf(stream,
"%lf", &temp) > 0)
697 data.push_back(float_t(temp));
703 template <
typename OutputArchive>
704 void to_archive(OutputArchive& ar,
705 content_type what = content_type::weights_and_model)
const {
706 if (what == content_type::model ||
707 what == content_type::weights_and_model) {
710 if (what == content_type::weights ||
711 what == content_type::weights_and_model) {
712 net_.save_weights(ar);
716 template <
typename InputArchive>
717 void from_archive(InputArchive& ar,
718 content_type what = content_type::weights_and_model) {
719 if (what == content_type::model ||
720 what == content_type::weights_and_model) {
723 if (what == content_type::weights ||
724 what == content_type::weights_and_model) {
725 net_.load_weights(ar);
730 float_t fprop_max(
const vec_t& in,
int idx = 0) {
731 const vec_t& prediction = fprop(in, idx);
732 return *std::max_element(std::begin(prediction), std::end(prediction));
735 label_t fprop_max_index(
const vec_t& in) {
736 return label_t(max_index(fprop(in)));
740 template <
typename Layer>
741 friend network<sequential>& operator << (network<sequential>& n, Layer&& l);
743 friend void construct_graph(network<graph>& graph,
744 const std::vector<std::shared_ptr<layer>>& inputs,
745 const std::vector<std::shared_ptr<layer>>& outputs);
747 friend void construct_graph(network<graph>& graph,
748 const std::vector<layer*>& inputs,
749 const std::vector<layer*>& outputs);
751 template <
typename Error,
typename Optimizer,
752 typename OnBatchEnumerate,
typename OnEpochEnumerate>
753 bool fit(Optimizer& optimizer,
754 const std::vector<tensor_t>& inputs,
755 const std::vector<tensor_t>& desired_outputs,
758 OnBatchEnumerate on_batch_enumerate,
759 OnEpochEnumerate on_epoch_enumerate,
760 const bool reset_weights =
false,
761 const int n_threads = CNN_TASK_SIZE,
762 const std::vector<tensor_t>& t_cost = std::vector<tensor_t>()) {
764 check_target_cost_matrix(desired_outputs, t_cost);
766 net_.setup(reset_weights);
769 n->set_parallelize(
true);
771 for (
int iter = 0; iter < epoch; iter++) {
772 for (
size_t i = 0; i < inputs.size(); i += batch_size) {
773 train_once<Error>(optimizer, &inputs[i], &desired_outputs[i],
774 static_cast<int>(std::min(batch_size, inputs.size() - i)),
776 get_target_cost_sample_pointer(t_cost, i));
777 on_batch_enumerate();
784 on_epoch_enumerate();
795 template <
typename E,
typename Optimizer>
796 void train_once(Optimizer& optimizer,
801 const tensor_t* t_cost) {
803 bprop<E>(fprop(in[0]), t[0], t_cost ? t_cost[0] : tensor_t());
804 net_.update_weights(&optimizer, 1);
806 train_onebatch<E>(optimizer, in, t, size, nbThreads, t_cost);
817 template <
typename E,
typename Optimizer>
818 void train_onebatch(Optimizer& optimizer,
823 const tensor_t* t_cost) {
824 std::vector<tensor_t> in_batch(&in[0], &in[0] + batch_size);
825 std::vector<tensor_t> t_batch(&t[0], &t[0] + batch_size);
826 std::vector<tensor_t> t_cost_batch = t_cost
827 ? std::vector<tensor_t>(&t_cost[0], &t_cost[0] + batch_size)
828 : std::vector<tensor_t>();
830 bprop<E>(fprop(in_batch), t_batch, t_cost_batch);
831 net_.update_weights(&optimizer, batch_size);
834 vec_t fprop(
const vec_t& in) {
836 data_mismatch(**net_.begin(), in);
838 return fprop(std::vector<vec_t>{ in })[0];
841 std::vector<tensor_t> a(1);
842 a[0].emplace_back(in);
843 return fprop(a)[0][0];
848 std::vector<vec_t> fprop(
const std::vector<vec_t>& in) {
849 return fprop(std::vector<tensor_t>{ in })[0];
852 std::vector<tensor_t> fprop(
const std::vector<tensor_t>& in) {
853 return net_.forward(in);
862 template <
typename E>
863 bool calc_delta(
const std::vector<tensor_t>& in,
864 const std::vector<tensor_t>& v,
865 vec_t& w, tensor_t& dw,
int check_index,
double eps) {
866 static const float_t delta = std::sqrt(
867 std::numeric_limits<float_t>::epsilon());
869 assert(in.size() == v.size());
871 const serial_size_t sample_count =
static_cast<serial_size_t
>(in.size());
873 assert(sample_count > 0);
876 assert(in[0].size() == 1);
877 assert(v[0].size() == 1);
880 for (vec_t& dw_sample : dw) {
881 std::fill(dw_sample.begin(), dw_sample.end(), float_t(0));
885 float_t prev_w = w[check_index];
887 float_t f_p = float_t(0);
888 w[check_index] = prev_w + delta;
889 for (serial_size_t i = 0; i < sample_count; i++) {
890 f_p += get_loss<E>(in[i], v[i]);
893 float_t f_m = float_t(0);
894 w[check_index] = prev_w - delta;
895 for (serial_size_t i = 0; i < sample_count; i++) {
896 f_m += get_loss<E>(in[i], v[i]);
899 float_t delta_by_numerical = (f_p - f_m) / (float_t(2) * delta);
900 w[check_index] = prev_w;
903 bprop<E>(fprop(in), v, std::vector<tensor_t>());
905 float_t delta_by_bprop = 0;
906 for (serial_size_t sample = 0; sample < sample_count; ++sample) {
907 delta_by_bprop += dw[sample][check_index];
911 return std::abs(delta_by_bprop - delta_by_numerical) <= eps;
915 template <
typename E>
916 void bprop(
const std::vector<vec_t>& out,
917 const std::vector<vec_t>& t,
const std::vector<vec_t>& t_cost) {
918 bprop<E>(std::vector<tensor_t>{out},
919 std::vector<tensor_t>{t}, std::vector<tensor_t>{t_cost});
922 template <
typename E>
923 void bprop(
const std::vector<tensor_t>& out,
924 const std::vector<tensor_t>& t,
925 const std::vector<tensor_t>& t_cost) {
926 std::vector<tensor_t> delta = gradient<E>(out, t, t_cost);
927 net_.backward(delta);
930 void check_t(
size_t i, label_t t, serial_size_t dim_out) {
932 std::ostringstream os;
933 os << format_str(
"t[%u]=%u, dim(net output)=%u\n", i, t, dim_out);
934 os <<
"in classification task, dim(net output) ";
935 os <<
"must be greater than max class id.\n";
937 os <<
"\n(for regression, use vector<vec_t> ";
938 os <<
"instead of vector<label_t> for training signal)\n";
941 throw nn_error(
"output dimension mismatch!\n " + os.str());
945 void check_t(
size_t i,
const vec_t& t, serial_size_t dim_out) {
946 if (t.size() != dim_out) {
947 throw nn_error(format_str(
948 "output dimension mismatch!\n dim(target[%u])=%u, "
949 "dim(network output size=%u", i, t.size(), dim_out));
953 template <
typename T>
954 void check_training_data(
const std::vector<vec_t>& in,
955 const std::vector<T>& t) {
959 if (in.size() != t.size()) {
960 throw nn_error(
"size of training data must be equal to label data");
963 size_t num = in.size();
965 for (
size_t i = 0; i < num; i++) {
966 if (in[i].size() != dim_in) {
967 throw nn_error(format_str(
968 "input dimension mismatch!\n dim(data[%u])=%d, "
969 "dim(network input)=%u", i, in[i].size(), dim_in));
971 check_t(i, t[i], dim_out);
975 void check_target_cost_matrix(
const std::vector<tensor_t>& t,
976 const std::vector<tensor_t>& t_cost) {
977 if (!t_cost.empty()) {
978 if (t.size() != t_cost.size()) {
979 throw nn_error(
"if target cost is supplied, "
980 "its length must equal that of target data");
983 for (
size_t i = 0, end = t.size(); i < end; i++) {
984 check_target_cost_element(t[i], t_cost[i]);
990 void check_target_cost_element(
const vec_t& t,
const vec_t& t_cost) {
991 if (t.size() != t_cost.size()) {
992 throw nn_error(
"if target cost is supplied for a regression task, "
993 "its shape must be identical to the target data");
996 void check_target_cost_element(
const tensor_t& t,
const tensor_t& t_cost) {
997 if (t.size() != t_cost.size()) {
998 throw nn_error(
"if target cost is supplied for a regression task, "
999 "its shape must be identical to the target data");
1001 for (
size_t i = 0; i < t.size(); i++)
1002 check_target_cost_element(t[i], t_cost[i]);
1005 const tensor_t* get_target_cost_sample_pointer(
1006 const std::vector<tensor_t>& t_cost,
size_t i) {
1007 if (!t_cost.empty()) {
1008 assert(i < t_cost.size());
1009 return &(t_cost[i]);
1015 void normalize_tensor(
const std::vector<tensor_t>& inputs,
1016 std::vector<tensor_t>& normalized) {
1017 normalized = inputs;
1020 void normalize_tensor(
const std::vector<vec_t>& inputs,
1021 std::vector<tensor_t>& normalized) {
1022 normalized.reserve(inputs.size());
1023 for (
size_t i = 0; i < inputs.size(); i++)
1024 normalized.emplace_back(tensor_t{ inputs[i] });
1027 void normalize_tensor(
const std::vector<label_t>& inputs,
1028 std::vector<tensor_t>& normalized) {
1029 std::vector<vec_t> vec;
1030 normalized.reserve(inputs.size());
1031 net_.label2vec(&inputs[0],
static_cast<serial_size_t
>(inputs.size()), &vec);
1032 normalize_tensor(vec, normalized);
1049 inline std::vector<vec_t> image2vec(
const float_t* data,
1050 const unsigned int rows,
1051 const unsigned int cols,
1052 const unsigned int sizepatch,
1053 const unsigned int step = 1) {
1055 std::vector<vec_t> res((cols-sizepatch) * (rows-sizepatch) / (step*step),
1056 vec_t(sizepatch*sizepatch));
1057 for_i((cols-sizepatch)*(rows-sizepatch)/(step*step), [&](
int count) {
1058 const int j = step*(count / ((cols-sizepatch)/step));
1059 const int i = step*(count % ((cols-sizepatch)/step));
1063 if (i+sizepatch < cols && j+sizepatch < rows) {
1064 for (
unsigned int k = 0; k < sizepatch*sizepatch; k++) {
1066 unsigned int y = k / sizepatch + j;
1067 unsigned int x = k % sizepatch + i;
1068 res[count][k] = data[x+y*cols];
1077 template <
typename Layer>
1078 network<sequential>& operator << (network<sequential>& n, Layer&& l) {
1079 n.net_.add(std::forward<Layer>(l));
1083 template <
typename NetType,
typename Char,
typename CharTraits>
1084 std::basic_ostream<Char, CharTraits>& operator << (std::basic_ostream<Char,
1086 const network<NetType>& n) {
1091 template <
typename NetType,
typename Char,
typename CharTraits>
1092 std::basic_istream<Char, CharTraits>& operator >> (std::basic_istream<Char,
1094 network<NetType>& n) {
1099 inline void construct_graph(network<graph>& graph,
1100 const std::vector<layer*>& inputs,
1101 const std::vector<layer*>& outputs) {
1102 graph.net_.construct(inputs, outputs);
1105 inline void construct_graph(network<graph>& graph,
1106 const std::vector<std::shared_ptr<layer>>& inputs,
1107 const std::vector<std::shared_ptr<layer>>& outputs) {
1108 std::vector<layer*> in_ptr, out_ptr;
1109 auto shared2ptr = [](std::shared_ptr<layer> l) {
return l.get(); };
1111 std::transform(inputs.begin(), inputs.end(),
1112 std::back_inserter(in_ptr), shared2ptr);
1113 std::transform(outputs.begin(), outputs.end(),
1114 std::back_inserter(out_ptr), shared2ptr);
1116 graph.net_.construct(in_ptr, out_ptr);
base class of all kind of NN layers
Definition: layer.h:62
A model of neural networks in tiny-dnn.
Definition: network.h:167
void set_netphase(net_phase phase)
set the netphase to train or test
Definition: network.h:382
vec_t predict(const vec_t &in)
executes forward-propagation and returns output
Definition: network.h:187
const layer * operator[](size_t index) const
return raw pointer of index-th layer
Definition: network.h:523
bool has_same_weights(const network< T > &rhs, float_t eps) const
returns if 2 networks have almost(<eps) the same weights
Definition: network.h:588
bool train(Optimizer &optimizer, const std::vector< vec_t > &inputs, const std::vector< label_t > &class_labels, size_t batch_size, int epoch, OnBatchEnumerate on_batch_enumerate, OnEpochEnumerate on_epoch_enumerate, const bool reset_weights=false, const int n_threads=CNN_TASK_SIZE, const std::vector< vec_t > &t_cost=std::vector< vec_t >())
trains the network for a fixed number of epochs (for classification task)
Definition: network.h:247
void init_weight()
explicitly initialize weights of all layers
Definition: network.h:182
std::string to_json() const
save the network architecture as json string
Definition: network.h:657
size_t depth() const
Definition: network.h:516
vec_t predict(const Range &in)
executes forward-propagation and returns output
Definition: network.h:219
network & weight_init(const WeightInit &f)
set weight initializer to all layers
Definition: network.h:566
std::vector< tensor_t > predict(const std::vector< tensor_t > &in)
executes forward-propagation and returns output
Definition: network.h:197
void save(std::ostream &os) const
Definition: network.h:677
result test(const std::vector< vec_t > &in, const std::vector< label_t > &t)
test and generate confusion-matrix for classification task
Definition: network.h:391
float_t get_loss(const std::vector< T > &in, const std::vector< tensor_t > &t)
calculate loss value (the smaller, the better) for regression task
Definition: network.h:436
void fast_load(const char *filepath)
load network weights from filepath, 30 times faster than stream reading
Definition: network.h:692
float_t get_loss(const std::vector< vec_t > &in, const std::vector< vec_t > &t)
calculate loss value (the smaller, the better) for regression task
Definition: network.h:421
network & bias_init(const BiasInit &f)
set bias initializer to all layers
Definition: network.h:577
bool train(Optimizer &optimizer, const std::vector< vec_t > &in, const std::vector< vec_t > &t, size_t batch_size=1, int epoch=1)
Definition: network.h:370
std::vector< vec_t > test(const std::vector< vec_t > &in)
generate output for each input
Definition: network.h:408
bool fit(Optimizer &optimizer, const std::vector< T > &inputs, const std::vector< U > &desired_outputs, size_t batch_size=1, int epoch=1)
Definition: network.h:340
label_t predict_label(const vec_t &in)
executes forward-propagation and returns maximum output index
Definition: network.h:209
bool gradient_check(const std::vector< tensor_t > &in, const std::vector< std::vector< label_t >> &t, float_t eps, grad_check_mode mode)
checking gradients calculated by bprop detail information: http://ufldl.stanford.edu/wiki/index....
Definition: network.h:456
tensor_t predict(const tensor_t &in)
executes forward-propagation and returns output
Definition: network.h:192
serial_size_t in_data_size() const
return total number of elements of input data
Definition: network.h:558
bool train(Optimizer &optimizer, const std::vector< vec_t > &inputs, const std::vector< label_t > &class_labels, size_t batch_size=1, int epoch=1)
Definition: network.h:357
size_t layer_size() const
return number of layers
Definition: network.h:509
void from_json(const std::string &json_string)
load the network architecture from json string
Definition: network.h:669
float_t predict_max_value(const vec_t &in)
executes forward-propagation and returns maximum output
Definition: network.h:202
bool fit(Optimizer &optimizer, const std::vector< T > &inputs, const std::vector< U > &desired_outputs, size_t batch_size, int epoch, OnBatchEnumerate on_batch_enumerate, OnEpochEnumerate on_epoch_enumerate, const bool reset_weights=false, const int n_threads=CNN_TASK_SIZE, const std::vector< U > &t_cost=std::vector< U >())
trains the network for a fixed number of epochs to generate desired output.
Definition: network.h:312
serial_size_t out_data_size() const
return total number of elements of output data
Definition: network.h:551
const T & at(size_t index) const
return index-th layer as <T> throw nn_error if index-th layer cannot be converted to T
Definition: network.h:539
std::string name() const
name of the network
Definition: network.h:177
error exception class for tiny-dnn
Definition: nn_error.h:37
base class of optimizer usesHessian : true if an optimizer uses hessian (2nd order derivative of loss...
Definition: optimizer.h:37