Class SimplE

include/instance/model/knowledge_graph.h:351–434

 */
template<class _Vector>
class SimplE {
public:
    static_assert(_Vector::dim % 2 == 0, "Model `SimplE` can only be instantiated with even-dimensional vectors");
    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 l3_regularization) {
        output = 0;
        FOR(i, dim) {
            int j = i ^ 1;
            output += head[i] * relation[i] * tail[j];
        }
        output = SUM(output);
    }

    template<OptimizerType optimizer_type>
    __host__ __device__
    static void backward(Vector &head, Vector &tail, Vector &relation,
                         float l3_regularization, Float gradient, const Optimizer &optimizer,
                         float relation_lr_multiplier = 1, Float weight = 1) {
        auto update = get_update_function<Float, optimizer_type>();
        l3_regularization *= 3;
        FOR(i, dim) {
            int j = i ^ 1;
            Float h = head[i];
            Float t = tail[j];
            Float r = relation[i];
            head[i] -= (optimizer.*update)(h, gradient * r * t + l3_regularization * abs(h) * h, weight);
            tail[j] -= (optimizer.*update)(t, gradient * h * r + l3_regularization * abs(t) * t, weight);
            relation[i] -= relation_lr_multiplier *
                    (optimizer.*update)(r, gradient * h * t + l3_regularization * abs(r) * r, 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 l3_regularization, Float gradient, const Optimizer &optimizer,
                         float relation_lr_multiplier = 1, Float weight = 1) {
        auto update = get_update_function_1_moment<Float, optimizer_type>();
        l3_regularization *= 3;
        FOR(i, dim) {
            int j = i ^ 1;
            Float h = head[i];
            Float t = tail[j];
            Float r = relation[i];
            head[i] -= (optimizer.*update)(h, gradient * r * t + l3_regularization * abs(h) * h,
                                           head_moment1[i], weight);
            tail[j] -= (optimizer.*update)(t, gradient * h * r + l3_regularization * abs(t) * t,
                                           tail_moment1[j], weight);
            relation[i] -= relation_lr_multiplier *
                    (optimizer.*update)(r, gradient * h * t + l3_regularization * abs(r) * r,
                                        relation_moment1[i], weight);
        }