Class TransE

include/instance/model/knowledge_graph.h:35–103

 */
template<class _Vector>
class TransE {
public:
    static const size_t dim = _Vector::dim;
    typedef _Vector Vector;
    typedef typename _Vector::Float Float;

    __host__ __device__
    static void forward(const Vector &head, const Vector &tail, const Vector &relation, Float &output, float margin) {
        output = 0;
        FOR(i, dim)
            output += abs(head[i] + relation[i] - tail[i]);
        output = margin - SUM(output);
    }

    template<OptimizerType optimizer_type>
    __host__ __device__
    static void backward(Vector &head, Vector &tail, Vector &relation,
                         float margin, Float gradient, const Optimizer &optimizer, float relation_lr_multiplier = 1,
                         Float weight = 1) {
        auto update = get_update_function<Float, optimizer_type>();
        FOR(i, dim) {
            Float h = head[i];
            Float t = tail[i];
            Float r = relation[i];
            Float s = h + r - t > 0 ? 1 : -1;
            head[i] -= (optimizer.*update)(h, -gradient * s, weight);
            tail[i] -= (optimizer.*update)(t, gradient * s, weight);
            relation[i] -= relation_lr_multiplier * (optimizer.*update)(r, -gradient * s, weight);
        }
    }

    template<OptimizerType optimizer_type>
    __host__ __device__
    static void backward(Vector &head, Vector &tail, Vector &relation,
                         Vector &head_moment1, Vector &tail_moment1, Vector &relation_moment1,
                         float margin, Float gradient, const Optimizer &optimizer, float relation_lr_multiplier = 1,
                         Float weight = 1) {
        auto update = get_update_function_1_moment<Float, optimizer_type>();
        FOR(i, dim) {
            Float h = head[i];
            Float t = tail[i];
            Float r = relation[i];
            Float s = h + r - t > 0 ? 1 : -1;
            head[i] -= (optimizer.*update)(h, -gradient * s, head_moment1[i], weight);
            tail[i] -= (optimizer.*update)(t, gradient * s, tail_moment1[i], weight);
            relation[i] -= relation_lr_multiplier * (optimizer.*update)(r, -gradient * s, relation_moment1[i], weight);
        }
    }

    template<OptimizerType optimizer_type>
    __host__ __device__
    static void backward(Vector &head, Vector &tail, Vector &relation,
                         Vector &head_moment1, Vector &tail_moment1, Vector &relation_moment1,
                         Vector &head_moment2, Vector &tail_moment2, Vector &relation_moment2,
                         float margin, Float gradient, const Optimizer &optimizer, float relation_lr_multiplier = 1,
                         Float weight = 1) {
        auto update = get_update_function_2_moment<Float, optimizer_type>();
        FOR(i, dim) {