def _get_primal(self, dual_update):

        if self.lower is not None:
            dus = dual_update.shape

            if len(dus) == 2 and not 1 in set(dus):
                (U, s, V) = np.linalg.svd(dual_update)
                sparse_s = get_st(s, lower=self.lower)
                dual_update = get_multiplied_svd(U, s, V)
            else:
                dual_update = get_st(dual_update, lower=self.lower)

        return dual_update / (self.H + self.delta)
    def _get_primal(self, dual_update):

        if self.lower is not None:
            dus = dual_update.shape

            if len(dus) == 2 and not 1 in set(dus):
                (U, s, V) = np.linalg.svd(dual_update)
                sparse_s = get_st(s, lower=self.lower)
                dual_update = get_multiplied_svd(U, s, V)
            else:
                dual_update = get_st(dual_update, lower=self.lower)

        H_inv = get_svd_power(self.H, -1)

        return np.dot(H_inv, dual_update)
Exemple #3
0
    def _get_primal(self, dual_update):

        if self.lower is not None:
            dual_update = get_st(
                dual_update, lower=self.lower) 

        return dual_update / self.H
Exemple #4
0
    def _get_primal(self, dual_update):

        (self.U, dual_s, self.V) = np.linalg.svd(dual_update)

        if self.lower is not None:
            dual_s = get_st(dual_s, lower=self.lower)

        self.s = get_lpn_grad(dual_s, self.q)

        return get_multiplied_svd(self.U, self.s, self.V)
    def get_update(self, parameters, gradient, eta):

        unscaled = parameters - eta * gradient

        if self.lower is not None:
            unscaled = get_st(unscaled, lower=self.lower)

        if self.window.is_full():
            last_period = None

            if self.weight > 0:
                last = self.weight * self.window.dequeue()
                second_last = self.window.get_items()[-1]
                last_period = last + second_last
            else:
                last_period = self.window.dequeue()

            unscaled += self.c * last_period

        self.window.enqueue(np.copy(parameters))
        self.num_rounds += 1
        other_c = eta**(-1)

        return (other_c + other_c * self.c)**(-1) * unscaled