tiny-dnn源码Edge类

class edge { public:    edge(node* prev, const shape3d& shape, vector_type vtype)        : shape_(shape),          vtype_(vtype),          data_({vec_t(shape.size())}),          grad_({ vec_t(shape.size()) }),          prev_(prev)    {    }    void merge_grads(vec_t *dst) {        dst->resize(grad_[0].size());        std::fill(dst->begin(), dst->end(), static_cast<float_t>(0));        // @todo consider adding parallelism        for (cnn_size_t sample = 0, sample_count = grad_.size(); sample < sample_count; ++sample) {            vectorize::reduce<float_t>(&grad_[sample][0], dst->size(), &(*dst)[0]);        }    }    void clear_grads() {        for (cnn_size_t sample = 0, sample_count = grad_.size(); sample < sample_count; ++sample) {            std::fill(grad_[sample].begin(), grad_[sample].end(), (float_t)0);        }    }    tensor_t* get_data() {        return &data_;    }    const tensor_t* get_data() const {        return &data_;    }    tensor_t* get_gradient() {        return &grad_;    }    const tensor_t* get_gradient() const {        return &grad_;    }    const std::vector<node*>& next() const { return next_; }    node* prev() { return prev_; }    const node* prev() const { return prev_; }    const shape3d& shape() const { return shape_; }    vector_type vtype() const { return vtype_; }    void add_next_node(node* next) { next_.push_back(next); } private:    shape3d shape_;    vector_type vtype_;    tensor_t data_;    tensor_t grad_;    node* prev_;               // previous node, "producer" of this tensor    std::vector<node*> next_;  // next nodes, "consumers" of this tensor};

class node : public std::enable_shared_from_this<node> {public:    node(cnn_size_t in_size, cnn_size_t out_size)        : prev_(in_size), next_(out_size) {}    virtual ~node() {}    const std::vector<edgeptr_t>& prev() const { return prev_; }    const std::vector<edgeptr_t>& next() const { return next_; }    cnn_size_t prev_port(const edge& e) const {        auto it = std::find_if(prev_.begin(), prev_.end(),                               [&](edgeptr_t ep) { return ep.get() == &e; });        return (cnn_size_t)std::distance(prev_.begin(), it);    }    cnn_size_t next_port(const edge& e) const {        auto it = std::find_if(next_.begin(), next_.end(),                               [&](edgeptr_t ep) { return ep.get() == &e; });        return (cnn_size_t)std::distance(next_.begin(), it);    }    std::vector<node*> prev_nodes() const; // @todo refactor and remove this method    std::vector<node*> next_nodes() const; // @todo refactor and remove this method protected:    node() = delete;    friend void connect(layerptr_t head, layerptr_t tail,                        cnn_size_t head_index, cnn_size_t tail_index);    mutable std::vector<edgeptr_t> prev_;    mutable std::vector<edgeptr_t> next_;};