def update(self, instance):
        """
        instance: [UserId, ItemId, LabelId] where LabelID should be index in range(self.L)
        """
        uid, iid, lid = instance
        ## calculate single gradient ##
        # intermediate #
        m = TDreconstruct(self.c, self.u[uid], self.v[iid], self.r)
        expm = np.exp(m)
        expmsum = np.sum(expm)
        mgrad = expm / expmsum
        mgrad[lid] = mgrad[lid] - 1.0
        mgrad = - mgrad
        ### test ###
        # print "m", m
        # print "mgrad", mgrad
        # print "lid", lid
        ###############
        # gradient for embeddings #
        delt_u = np.tensordot(a = mgrad, axes = (0,1),
                              b = np.tensordot(a = self.v[iid], axes = (0,1),
                                               b = np.tensordot(a = self.c, axes = (2,1),
                                                                b = self.r)
                                               )
                              )
        delt_v = np.tensordot(a = mgrad, axes = (0,1),
                              b = np.tensordot(a = self.u[uid], axes = (0,0),
                                               b = np.tensordot(a = self.c, axes = (2,1),
                                                                b = self.r)
                                               )
                              )
        delt_c = matrixTool.TensorOuter([self.u[uid], self.v[iid], np.tensordot(mgrad, self.r, axes = (0,0))])
        delt_r = np.outer(mgrad, np.tensordot(a = self.u[uid], axes = (0,0),
                                              b = np.tensordot(a = self.v[iid], axes = (0,1),
                                                               b = self.c)))
        ### test ###
        # rela_u = np.linalg.norm(delt_u)/np.linalg.norm(self.u[uid])
        # rela_v = np.linalg.norm(delt_v)/np.linalg.norm(self.v[iid])
        # rela_c = np.linalg.norm(delt_c)/np.linalg.norm(self.c)
        # rela_r = np.linalg.norm(delt_r)/np.linalg.norm(self.r)
        # print "relative step size", rela_u, rela_v, rela_c, rela_r
        # update #
        self.u[uid] += (self.SGDstep * (delt_u - self.lamda * self.u[uid]))
        self.v[iid] += (self.SGDstep * (delt_v - self.lamda * self.v[iid]))
        self.c += (self.SGDstep * (delt_c - self.lamda * self.c))
        self.r += (self.SGDstep * (delt_r - self.lamda * self.r))

        ### test ###
        # m = TDreconstruct(self.c, self.u[uid], self.v[iid], self.r)
        # print "m after update", m
        return self
Пример #2
0
 def update(self, instance):
     uid, iid, lid = instance
     ## calculate single gradient ##
     # intermediate #
     m = TDreconstruct(self.c, self.u[uid], self.v[iid], self.r)
     mgrad = -m
     mgrad[lid] = 1.0 + mgrad[lid]
     # gradient for embeddings #
     delt_u = np.tensordot(a=mgrad,
                           axes=(0, 1),
                           b=np.tensordot(a=self.v[iid],
                                          axes=(0, 1),
                                          b=np.tensordot(a=self.c,
                                                         axes=(2, 1),
                                                         b=self.r)))
     delt_v = np.tensordot(a=mgrad,
                           axes=(0, 1),
                           b=np.tensordot(a=self.u[uid],
                                          axes=(0, 0),
                                          b=np.tensordot(a=self.c,
                                                         axes=(2, 1),
                                                         b=self.r)))
     delt_c = matrixTool.TensorOuter([
         self.u[uid], self.v[iid],
         np.tensordot(mgrad, self.r, axes=(0, 0))
     ])
     delt_r = np.outer(
         mgrad,
         np.tensordot(a=self.u[uid],
                      axes=(0, 0),
                      b=np.tensordot(a=self.v[iid], axes=(0, 1), b=self.c)))
     # update #
     self.u[uid] += (self.SGDstep * (delt_u - self.lamda * self.u[uid]))
     self.v[iid] += (self.SGDstep * (delt_v - self.lamda * self.v[iid]))
     self.c += (self.SGDstep * (delt_c - self.lamda * self.c))
     self.r += (self.SGDstep * (delt_r - self.lamda * self.r))
     return self
Пример #3
0
 def update(self, instance):
     uid, iid, lid, value = instance
     m = TDreconstruct(self.c, self.u[uid], self.v[iid], self.r[lid])
     mgrad = 2.0 * (value - m)
     # gradient for embeddings #
     delt_u = mgrad * np.tensordot(
         a=self.v[iid],
         axes=(0, 1),
         b=np.tensordot(a=self.c, axes=(2, 0), b=self.r[lid]))
     delt_v = mgrad * np.tensordot(
         a=self.u[uid],
         axes=(0, 0),
         b=np.tensordot(a=self.c, axes=(2, 0), b=self.r[lid]))
     delt_c = mgrad * matrixTool.TensorOuter(
         [self.u[uid], self.v[iid], self.r[lid]])
     delt_r = mgrad * np.tensordot(
         a=self.u[uid],
         axes=(0, 0),
         b=np.tensordot(a=self.v[iid], axes=(0, 1), b=self.c))
     # update #
     self.u[uid] += (self.SGDstep * delt_u)
     self.v[iid] += (self.SGDstep * delt_v)
     self.c += (self.SGDstep * delt_c)
     self.r[lid] += (self.SGDstep * delt_r)
Пример #4
0
    def update(self, instance):
        """
        instance: [UserId, ItemId, LabelId] where LabelID should be index in range(self.L)
        """
        uid, iid, lid = instance
        ## calculate single gradient ##
        # intermediate #
        m = TDreconstruct(self.c, self.u[uid], self.v[iid], self.r)
        mgrad = softmaxGradient(m, lid)
        # gradient for embeddings #
        delt_u = np.tensordot(a=mgrad, axes=(0, 1),
                              b=np.tensordot(a=self.v[iid], axes=(0, 1),
                                             b=np.tensordot(a=self.c, axes=(2, 1),
                                                            b=self.r)
                                             )
                              )
        delt_v = np.tensordot(a=mgrad, axes=(0, 1),
                              b=np.tensordot(a=self.u[uid], axes=(0, 0),
                                             b=np.tensordot(a=self.c, axes=(2, 1),
                                                            b=self.r)
                                             )
                              )
        delt_c = matrixTool.TensorOuter([self.u[uid], self.v[iid], np.tensordot(mgrad, self.r, axes=(0, 0))])
        delt_r = np.outer(mgrad, np.tensordot(a=self.u[uid], axes=(0, 0),
                                              b=np.tensordot(a=self.v[iid], axes=(0, 1),
                                                             b=self.c)))
        # update #
        self.u[uid] += (self.SGDstep * (delt_u - self.lamda * self.u[uid]))
        self.v[iid] += (self.SGDstep * (delt_v - self.lamda * self.v[iid]))
        self.c += (self.SGDstep * (delt_c - self.lamda * self.c))
        self.r += (self.SGDstep * (delt_r - self.lamda * self.r))

        ### test ###
        # m = TDreconstruct(self.c, self.u[uid], self.v[iid], self.r)
        # print "m after update", m
        return self