network
2015-12-03 15:59:04 0 举报AI智能生成
network
作者其他创作
大纲/内容
test
* test and generate confusion-matrix for classification task
result test(const std::vector& in, const std::vector& t) {...}
std::vector test(const std::vector& in)
{
std::vector test_result(in.size());
for_i(in.size(), [&](int i)
{
test_result[i] = predict(in[i]);
});
return test_result;
}
vec_t predict(const vec_t& in) { return fprop(in); }
train
* training conv-net
* @param in array of input data
* @param t array of training signals(label or vector)
* @param epoch number of training epochs
* @param on_batch_enumerate callback for each mini-batch enumerate
* @param on_epoch_enumerate callback for each epoch
*/
template
bool train(...){...}
* training conv-net without callback
template
bool train(const std::vector& in, const std::vector& t, size_t batch_size = 1, int epoch = 1) {
return train(in, t, batch_size, epoch, nop, nop);
}
getter
layer_size_t in_dim() const { return layers_.head()->in_size(); }
layer_size_t out_dim() const { return layers_.tail()->out_size(); }
std::string name() const { return name_; }
Optimizer& optimizer() { return optimizer_; }
void add(std::shared_ptr layer) { layers_.add(layer); }
vec_t predict(const vec_t& in) { return fprop(in); }
size_t depth() const {
return layers_.depth();
}
fileOperation
void save(std::ostream& os) const {
os.precision(std::numeric_limits::digits10);
auto l = layers_.head();
while (l) { l->save(os); l = l->next(); }
}
void load(std::istream& is) {
is.precision(std::numeric_limits::digits10);
auto l = layers_.head();
while (l) { l->load(is); l = l->next(); }
}
check
* checking gradients calculated by bprop
bool gradient_check(const vec_t* in, const label_t* t, int data_size, float_t eps, grad_check_mode mode) {...}
bool has_same_weights(const network& others, float_t eps) const {...}
calculate
std::vector scoreRegressor(const std::vector& in)
{
std::vector test_result(in.size());
for_i(in.size(), [&](int i)
{
test_result[i] = predict(in[i])[0];
});
return test_result;
}
* calculate loss value (the smaller, the better) for regression task
float_t get_loss(const std::vector& in, const std::vector& t) {
float_t sum_loss = (float_t)0.0;
for (size_t i = 0; i < in.size(); i++) {
const vec_t predicted = predict(in[i]);
sum_loss += get_loss(predict(in[i]), t[i]);
}
return sum_loss;
}
explicit network(const std::string& name = "") : name_(name) {}
operator
template
const T& at(size_t index) const {
return layers_.at(index);
}
const layer_base* operator [] (size_t index) const {
return layers_[index];
}
layer_base* operator [] (size_t index) {
return layers_[index];
}
private
std::string name_;
Optimizer optimizer_;
layers layers_;
train
void train_once(const vec_t* in, const label_t* t, int size, const int nbThreads = CNN_TASK_SIZE) {
std::vector v;
label2vector(t, size, &v);
train_once(in, &v[0], size, nbThreads );
}
void train_once(const vec_t* in, const vec_t* t, int size, const int nbThreads = CNN_TASK_SIZE) {
if (size == 1) {
bprop(fprop(in[0]), t[0]);
layers_.update_weights(&optimizer_, 1, 1);
} else {
train_onebatch(in, t, size, nbThreads);
}
}
void train_onebatch(const vec_t* in, const vec_t* t, int batch_size, const int num_tasks = CNN_TASK_SIZE) {..}
transform
void label2vector(const label_t* t, int num, std::vector *vec) const {..}
calc
void calc_hessian(const std::vector& in, int size_initialize_hessian = 500) {
int size = std::min((int)in.size(), size_initialize_hessian);
for (int i = 0; i < size; i++)
bprop_2nd(fprop(in[i]));
layers_.divide_hessian(size);
}
template
bool is_canonical_link(const Activation& h) {
if (typeid(h) == typeid(activation::sigmoid) && typeid(E) == typeid(cross_entropy)) return true;
if (typeid(h) == typeid(activation::tan_h) && typeid(E) == typeid(cross_entropy)) return true;
if (typeid(h) == typeid(activation::identity) && typeid(E) == typeid(mse)) return true;
if (typeid(h) == typeid(activation::softmax) && typeid(E) == typeid(cross_entropy_multiclass)) return true;
return false;
}
const vec_t& fprop(const vec_t& in, int idx = 0) {
if (in.size() != (size_t)in_dim())
data_mismatch(*layers_[0], in);
return layers_.head()->forward_propagation(in, idx);
}
float_t get_loss(const vec_t& out, const vec_t& t) {
float_t e = 0.0;
assert(out.size() == t.size());
for_i(out.size(), [&](int i){ e += E::f(out[i], t[i]); });
return e;
}
void bprop_2nd(const vec_t& out) {...}
void bprop(const vec_t& out, const vec_t& t, int idx = 0) {..}
float_t calc_delta(const vec_t* in, const vec_t* v, int data_size, vec_t& w, vec_t& dw, int check_index) {...}
check
void check_t(size_t i, label_t t, layer_size_t dim_out) {..}
void check_t(size_t i, const vec_t& t, layer_size_t dim_out) {
if (t.size() != dim_out)
throw nn_error(format_str("output dimension mismatch!\n dim(target[%u])=%u, dim(network output size=%u", i, t.size(), dim_out));
}
template
void check_training_data(const std::vector& in, const std::vector& t) {...}
valueMinMax
float_t target_value_min() const { return layers_.tail()->activation_function().scale().first; }
float_t target_value_max() const { return layers_.tail()->activation_function().scale().second; }
init
template
network& bias_init(const BiasInit& f) {
auto ptr = std::make_shared(f);
for (size_t i = 0; i < depth(); i++)
layers_[i]->bias_init(ptr);
return *this;
}
template
network& weight_init(const WeightInit& f) {
auto ptr = std::make_shared(f);
for (size_t i = 0; i < depth(); i++)
layers_[i]->weight_init(ptr);
return *this;
}
void init_weight() { layers_.init_weight(); }
职业：IT
0 条评论
下一页
