calculate
template <typename Optimizer>
void update_weights(Optimizer *o, size_t worker_size, size_t batch_size) {
for (auto pl : layers_)
pl->update_weight(o, worker_size, batch_size);
}
void divide_hessian(int denominator) {
for (auto pl : layers_)
pl->divide_hessian(denominator);
}
basicOperator
const layer_base* operator [] (size_t index) const {
return layers_[index + 1].get();
}
template <typename T>
const T& at(size_t index) const {
const T* v = dynamic_cast<const T*>(layers_[index + 1].get());
if (v) return *v;
throw nn_error("failed to cast");
}
layers& operator = (const layers& rhs) {
layers_.clear();
construct(rhs);
return *this;
}
layer_base* operator [] (size_t index) {
return layers_[index + 1].get();
}
basicOperator2
void init_weight() {
for (auto pl : layers_)
pl->init_weight();
}
bool empty() const { return layers_.size() == 0; }
bool is_exploded() const {
for (auto pl : layers_)
if (pl->is_exploded()) return true;
return false;
}
void add(std::shared_ptr<layer_base> new_tail) {
if (tail()) tail()->connect(new_tail);
layers_.push_back(new_tail);
}
void set_parallelize(bool parallelize) {
for (auto pl : layers_)
pl->set_parallelize(parallelize);
}
construct
layers() { add(std::make_shared<input_layer>()); }
layers(const layers& rhs) { construct(rhs); }
private:
void construct(const layers& rhs) {
add(std::make_shared<input_layer>());
for (size_t i = 1; i < rhs.layers_.size(); i++)
add(rhs.layers_[i]);
}
getter
layer_base* tail() const { return empty() ? 0 : layers_[layers_.size() - 1].get(); }
layer_base* head() const { return empty() ? 0 : layers_[0].get(); }
// get depth(number of layers) of networks
size_t depth() const {
return layers_.size() - 1; // except input-layer
}
