Commit acaf76c7 authored by tpetaja1's avatar tpetaja1
Browse files

penalty functions, minor fixes 

-penalty functions into own file
-multiprotvgl bug fix
-minor fixes
parent 2f2fa6af

AsyncProTVGL.py

+2 −2
Original line number Diff line number Diff line 


from TVGL import TVGL

import numpy as np

import multiprocessing

import mp_workers2 as mp

from TVGL import TVGL

import mp_workers_async as mp





class AsyncProTVGL(TVGL):

MultiProTVGL.py

+24 −34
Original line number Diff line number Diff line 


import multiprocessing

import mp_workers as mp

from TVGL import TVGL

import multiprocessing

import mp_workers_multi as mp





class MultiProTVGL(TVGL):



    def __init__(self, filename, processes=1):

        super(MultiProTVGL, self).__init__(filename, processes)

    def __init__(self, filename, blocks=10, processes=2):

        super(MultiProTVGL, self).__init__(filename, blocks, processes)



    def theta_update(self):

        inputs = [(self.thetas[i], self.z0s[i], self.z1s[i], self.z2s[i],
@@ -15,56 +15,46 @@ class MultiProTVGL(TVGL): 
                   self.emp_cov_mat[i], self.nju)

                  for i in range(self.blocks)]

        pool = multiprocessing.Pool(self.processes)

        self.thetas = pool.map(mp.mp_theta_update, inputs)

        self.thetas = pool.map(mp.theta_update, inputs)

        pool.close()

        #pool.join()



    def z_update(self):

        self.z0_update()

        self.z1_z2_update()

    

    def z0_update(self):

        """ z0-update """

        inputs = [(self.thetas[i], self.u0s[i], self.lambd, self.rho)

                  for i in range(self.blocks)]

        pool = multiprocessing.Pool(self.processes)

        self.z0s = pool.map(mp.mp_z0_update, inputs)

        self.z0s = pool.map(mp.z0_update, inputs)

        pool.close()

        #pool.join()



    def z1_z2_update(self):

        """ z1-z2-update """

        inputs = [(self.thetas[i], self.thetas[i-1],

                   self.u1s[i], self.u1s[i-1], self.u2s[i],

                   self.beta, self.rho)

                  for i in range(1, self.blocks)]

        pool = multiprocessing.Pool(self.processes)

        zs = pool.map(mp.mp_z1_z2_update, inputs)

        zs = pool.map(mp.z1_z2_update, inputs)

        pool.close()

        #pool.join()

        for i in range(self.blocks - 1):

            self.z1s[i] = zs[i][0]

                self.z2s[i] = zs[i][1]

            self.z2s[i+1] = zs[i][1]



    def u_update(self):

        self.u0_update()

        self.u1_u2_update()



    def u0_update(self):

        """ u0-update """

        inputs = [(self.thetas[i], self.u0s[i], self.z0s[i])

                  for i in range(self.blocks)]

        pool = multiprocessing.Pool(self.processes)

        self.u0s = pool.map(mp.mp_u0_update, inputs)

        self.u0s = pool.map(mp.u0_update, inputs)

        pool.close()

        #pool.join()



    def u1_u2_update(self):

        inputs = [(self.thetas[i], self.thetas[i-1],

                   self.u1s[i-1], self.u2s[i],

                   self.z1s[i-1], self.z2s[i])

        """ u1-update """

        inputs = [(self.thetas[i], self.u1s[i], self.z1s[i])

                  for i in range(self.blocks - 1)]

        pool = multiprocessing.Pool(self.processes)

        u1s = pool.map(mp.u1_update, inputs)

        self.u1s[0:self.blocks - 1] = u1s

        pool.close()

        """ u2-update """

        inputs = [(self.thetas[i], self.u2s[i], self.z2s[i])

                  for i in range(1, self.blocks)]

        pool = multiprocessing.Pool(self.processes)

        us = pool.map(mp.mp_u1_u2_update, inputs)

        u2s = pool.map(mp.u2_update, inputs)

        self.u2s[1:self.blocks] = u2s

        pool.close()
 
        #pool.join()

        for i in range(self.blocks - 1):

                self.u1s[i] = us[i][0]

                self.u2s[i] = us[i][1]

SerialTVGL.py

+5 −3
Original line number Diff line number Diff line 


import numpy as np

from TVGL import TVGL

import penalty_functions as pf

import numpy as np





class SerialTVGL(TVGL):
@@ -27,12 +28,13 @@ class SerialTVGL(TVGL): 


    def z0_update(self):

        for i in range(self.blocks):

            self.z0s[i] = self.soft_threshold_odd(self.thetas[i] + self.u0s[i])

            self.z0s[i] = pf.soft_threshold_odd(self.thetas[i] + self.u0s[i],

                                                self.lambd, self.rho)



    def z1_z2_update(self):

        for i in range(1, self.blocks):

            a = self.thetas[i] - self.thetas[i-1] + self.u2s[i] - self.u1s[i-1]

            e = self.group_lasso_penalty(a, 2*self.beta/self.rho)

            e = pf.group_lasso_penalty(a, 2*self.beta/self.rho)

            self.z1s[i-1] = 0.5*(self.thetas[i-1] + self.thetas[i]

                                 + self.u1s[i] + self.u2s[i]) - 0.5*e

            self.z2s[i] = 0.5*(self.thetas[i-1] + self.thetas[i]

TVGL.py

+0 −22
Original line number Diff line number Diff line
@@ -96,28 +96,6 @@ class TVGL(object): 
        else:

            print "Max iterations (%s) reached" % max_iter



    def soft_threshold_odd(self, a):

        e = np.ones((self.dimension, self.dimension))

        for i in range(self.dimension):

            for j in range(self.dimension):

                if i != j:

                    if abs(a[i, j]) <= self.lambd/self.rho:

                        e[i, j] = 0

                    else:

                        e[i, j] = np.sign(a[i, j])*(

                            abs(a[i, j]) - self.lambd/self.rho)

        return e



    def group_lasso_penalty(self, a, nju):

        e = np.zeros((self.dimension, self.dimension))

        for j in range(self.dimension):

            l2_norm = np.linalg.norm(a[:, j])

            if l2_norm <= nju:

                e[:, j] = np.zeros(self.dimension)

            else:

                e[:, j] = (1 - nju/l2_norm)*a[:, j]

        return e



    def temporal_deviations(self):

        deviations = np.zeros(self.blocks - 1)

        for i in range(0, self.blocks - 1):

mp_workers2.py→mp_workers_async.py

+3 −29
Original line number Diff line number Diff line 


import numpy as np

import penalty_functions as pf

import traceback





def z0_update(thetas, z0s, u0s, lambd, rho, blocks):

    for i in range(blocks):

        z0s[i] = soft_threshold_odd(thetas[i] + u0s[i], lambd, rho)

        z0s[i] = pf.soft_threshold_odd(thetas[i] + u0s[i], lambd, rho)

    return z0s
@@ -13,7 +13,7 @@ def z1_z2_update(thetas, z1s, z2s, u1s, u2s, beta, rho, blocks): 
    try:

        for i in range(1, blocks):

            a = thetas[i] - thetas[i-1] + u2s[i] - u1s[i-1]

            e = group_lasso_penalty(a, 2*beta/rho)

            e = pf.group_lasso_penalty(a, 2*beta/rho)

            z1s[i-1] = 0.5*(thetas[i-1] + thetas[i]

                            + u1s[i] + u2s[i]) - 0.5*e

            z2s[i] = 0.5*(thetas[i-1] + thetas[i]
@@ -52,29 +52,3 @@ def u2_update(u2s, thetas, z2s, blocks): 
        traceback.print_exc()

        raise e

    return u2s
 




def soft_threshold_odd(a, lambd, rho):

    dimension = np.shape(a)[0]

    e = np.ones((dimension, dimension))

    for i in range(dimension):

        for j in range(dimension):

            if i != j:

                if abs(a[i, j]) <= lambd/rho:

                    e[i, j] = 0

                else:

                    e[i, j] = np.sign(a[i, j])*(

                        abs(a[i, j]) - lambd/rho)

    return e





def group_lasso_penalty(a, nju):

    dimension = np.shape(a)[0]

    e = np.zeros((dimension, dimension))

    for j in range(dimension):

        l2_norm = np.linalg.norm(a[:, j])

        if l2_norm <= nju:

            e[:, j] = np.zeros(dimension)

        else:

            e[:, j] = (1 - nju/l2_norm)*a[:, j]

    return e

CRA Git | Maintained and supported by SUSTech CRA and CCSE