Class QuatE

include/instance/model/knowledge_graph.h:585–814

 */
template<class _Vector>
class QuatE {
public:
    static_assert(_Vector::dim % 4 == 0,
                  "Model `QuatE` can only be instantiated with vector dimensions divisible by 4");
    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 / 4) {
            Float h_r = head[i * 4];
            Float h_i = head[i * 4 + 1];
            Float h_j = head[i * 4 + 2];
            Float h_k = head[i * 4 + 3];
            Float r_r = relation[i * 4];
            Float r_i = relation[i * 4 + 1];
            Float r_j = relation[i * 4 + 2];
            Float r_k = relation[i * 4 + 3];
            Float t_r = tail[i * 4];
            Float t_i = tail[i * 4 + 1];
            Float t_j = tail[i * 4 + 2];
            Float t_k = tail[i * 4 + 3];
            Float r_norm = sqrt(r_r * r_r + r_i * r_i + r_j * r_j + r_k * r_k);
            Float product_r = h_r * r_r - h_i * r_i - h_j * r_j - h_k * r_k;
            Float product_i = h_r * r_i + h_i * r_r + h_j * r_k - h_k * r_j;
            Float product_j = h_r * r_j - h_i * r_k + h_j * r_r + h_k * r_i;
            Float product_k = h_r * r_k + h_i * r_j - h_j * r_i + h_k * r_r;
            output += (product_r * t_r + product_i * t_i + product_j * t_j + product_k * t_k) / (r_norm + kEpsilon);
        }
        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 / 4) {
            Float h_r = head[i * 4];
            Float h_i = head[i * 4 + 1];
            Float h_j = head[i * 4 + 2];
            Float h_k = head[i * 4 + 3];
            Float r_r = relation[i * 4];
            Float r_i = relation[i * 4 + 1];
            Float r_j = relation[i * 4 + 2];
            Float r_k = relation[i * 4 + 3];
            Float t_r = tail[i * 4];
            Float t_i = tail[i * 4 + 1];
            Float t_j = tail[i * 4 + 2];
            Float t_k = tail[i * 4 + 3];
            Float r_norm = sqrt(r_r * r_r + r_i * r_i + r_j * r_j + r_k * r_k);
            Float grad = gradient / (r_norm + kEpsilon);
            // head