def PrimalDual(A, b, c, ite):
(m, n) = np.shape(A)
(x, llambda, s) = InitialPoints(A, b, c)
sigma = 0.1
for i in range(0, ite):
alpha = np.random.uniform(0.1, 0.5, 1)
S = diags(s)
X = diags(x)
rs = csc_matrix.transpose(A).dot(llambda) + s - c
rb = A.dot(x) - b
#print np.linalg.norm(rs)
if np.linalg.norm(rs) < 1e-2 and np.linalg.norm(rb) < 1e-2:
break
Mu = (np.dot(s, x) / n)
XSe = np.multiply(s, x) #- (sigma*Mu)*np.ones(n)
K1 = sparse.hstack([
csc_matrix((n, n)),
csc_matrix.transpose(A),
identity(n, dtype=float)
])
K2 = sparse.hstack([A, csc_matrix((m, m)), csc_matrix((m, n))])
K3 = sparse.hstack([S, csc_matrix((n, m)), X])
K = csc_matrix(sparse.vstack([K1, K2, K3]))
bb = np.concatenate((rs, rb, XSe))
#xx = np.linalg.solve(K.toarray(), -bb)
xx = spsolve(K, -bb)
while (x + alpha * xx[0:n] <=
0.0).any() or (s + alpha * xx[n + m:2 * n + m] <= 0.0).any():
alpha = alpha / 2.0
x = x + alpha * xx[0:n]
llambda = llambda + alpha * xx[n:(n + m)]
s = s + alpha * xx[(n + m):2 * n + m]
return x, llambda, s
def PrimalDual(A, b, c, ite, errorgrad, errorfit, alphamean, sigma):
(m, n) = np.shape(A)
(x, llambda, s) = InitialPoints(A, b, c)
I = identity(n, dtype=float)
fitness = 1e100
antnorm = 1e100
for i in range(0, ite):
alpha = np.random.uniform(alphamean, 0.1, 1)
#alpha = alphamean
alpha = max(0.0001, alpha)
alpha = min(1.0, alpha)
S = diags(s)
X = diags(x)
rs = csc_matrix.transpose(A).dot(llambda) + s - c
rb = A.dot(x) - b
Mu = (np.dot(s, x) / n)
# print Mu
XSe = np.multiply(s, x) - (sigma * Mu) * np.ones(n)
K1 = sparse.hstack([csc_matrix((n, n)), csc_matrix.transpose(A), I])
K2 = sparse.hstack([A, csc_matrix((m, m)), csc_matrix((m, n))])
K3 = sparse.hstack([S, csc_matrix((n, m)), X])
K = csc_matrix(sparse.vstack([K1, K2, K3]))
bb = np.concatenate((rs, rb, XSe))
# xx = np.linalg.solve(K.toarray(), -bb)
xx = spsolve(K, -bb)
#print ' ',xx.dot(xx)
while (x + alpha * xx[0:n] <=
0.0).any() or (s + alpha * xx[n + m:2 * n + m] <= 0.0).any():
alpha = alpha / 2.0
if (A.dot(x + alpha * xx[0:n]) - b).dot(
(A.dot(x + alpha * xx[0:n]) -
b)) < rb.dot(rb) and (x + alpha * xx[0:n]).dot(c) <= x.dot(c):
x = x + alpha * xx[0:n]
if (csc_matrix.transpose(A).dot(llambda + alpha * xx[n:(n + m)]) +
alpha * xx[(n + m):2 * n + m] - c).dot(
csc_matrix.transpose(A).dot(llambda +
alpha * xx[n:(n + m)]) +
alpha * xx[(n + m):2 * n + m] - c) < rs.dot(rs):
llambda = llambda + alpha * xx[n:(n + m)]
s = s + alpha * xx[(n + m):2 * n + m]
#if abs(antnorm - xx.dot(xx)) < errorgrad:
#print xx[0:n].dot(xx[0:n])
if xx[0:n].dot(xx[0:n]) < errorgrad:
break
# antnorm = xx.dot(xx)
# if abs(fitness - c.dot(x)) < errorfit:
# break
fitness = c.dot(x)
return x, np.transpose(c).dot(x), i
def InitialPoints(A, b, c):
AT = csc_matrix.transpose(A)
AATI = inv(sparse.csc_matrix(A).dot(csc_matrix.transpose(A)))
x = sparse.csc_matrix(AT).dot(AATI).dot(b)
llambda = sparse.csc_matrix(AATI).dot(A).dot(c)
#llambda = sparse.csc_matrix(AATI).dot(b)
s = (c - sparse.csc_matrix(AT).dot(llambda))
deltas = max(0, -(3.0 / 2.0) * min(s))
s = s + deltas
deltax = max(0, -(3.0 / 2.0) * min(x))
x = x + deltax
x = x + (1.0 / 2.0) * (np.dot(x, s) / (np.sum(s)))
s = s + (1.0 / 2.0) * (np.dot(x, s) / (np.sum(x)))
(m, n) = np.shape(A)
return (x, llambda, s)
def buildAttributeGraph(X_select,PG):
n,T = X_select.shape
P_Ai = np.zeros([n, n, T])
for i_attribute in range(T):
P_Ai[:,:,i_attribute] = PG.toarray()
tmp = X_select[:,i_attribute].dot( csr_matrix.multiply( csc_matrix.transpose(X_select[:,i_attribute]), 1/(1e-64 + X_select[:,i_attribute].sum())) )
flyout_ind, cols = X_select[:, i_attribute].nonzero()
P_Ai[flyout_ind,:,i_attribute] = tmp[flyout_ind, :].toarray()
return P_Ai
def InitialPoints(G, A, b, c):
(m, n) = np.shape(A)
x = np.ones(n)+1
y = np.ones(m)+1
llambda = np.zeros(m)+1
I = identity(m, dtype=float)
Y = diags(y)
La = diags(llambda)
rd = G.dot(x) - csc_matrix.transpose(A).dot(llambda) + c
rp = A.dot(x) - y - b
LaYe = np.multiply(llambda, y)
K1 = sparse.hstack([G, csc_matrix( (n,m)) , -csc_matrix.transpose(A)])
K2 = sparse.hstack([A, -I , csc_matrix( (m,m)) ])
K3 = sparse.hstack([csc_matrix( (m,n)), La, Y])
K = csc_matrix(sparse.vstack([K1, K2, K3]))
bb = np.concatenate((-rd,-rp, -LaYe))
deltaAffin = spsolve(K, bb)
deltaxAffin = deltaAffin[0:n]
deltayAffin = deltaAffin[n:n+m]
deltalambdaAffin = deltaAffin[n+m:2*m+n]
y = np.maximum(np.ones(m),np.abs(y+deltayAffin))
llambda = np.maximum(np.ones(m),np.abs(llambda+deltalambdaAffin))
return (x, llambda, y)
def vp_N_He(problem_data, rho_method):
######################
## IMPORT LIBRARIES ##
######################
#Math libraries
import numpy as np
from scipy.sparse import csc_matrix
from scipy.sparse import csr_matrix
from scipy.sparse import linalg
#Timing
import time
#Import data
from Data.read_fclib import *
#Plot residuals
from Solver.ADMM_iteration.Numerics.plot import *
#Initial penalty parameter
import Solver.Rho.Optimal
#Max iterations and kind of tolerance
from Solver.Tolerance.iter_totaltolerance import *
#Varying penalty parameter
from Solver.Rho.Varying.He import *
#b = Es matrix
from Data.Es_matrix import *
#Projection onto second order cone
from Solver.ADMM_iteration.Numerics.projection import *
##################################
############# REQUIRE ############
##################################
start = time.clock()
problem = hdf5_file(problem_data)
M = problem.M.tocsc()
f = problem.f
A = csc_matrix.transpose(problem.H.tocsc())
A_T = csr_matrix.transpose(A)
w = problem.w
mu = problem.mu
#Dimensions (normal,tangential,tangential)
dim1 = 3
dim2 = np.shape(w)[0]
#Problem size
n = np.shape(M)[0]
p = np.shape(w)[0]
b = 0.1 * Es_matrix(w, mu, np.ones([
p,
])) / np.linalg.norm(Es_matrix(w, mu, np.ones([
p,
])))
#################################
############# SET-UP ############
#################################
#Set-up of vectors
v = [np.zeros([
n,
])]
u = [
np.zeros([
p,
])
] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
xi = [np.zeros([
p,
])]
r = [np.zeros([
p,
])] #primal residual
s = [np.zeros([
p,
])] #dual residual
r_norm = [0]
s_norm = [0]
e = [] #restart
rho = []
#Optimal penalty parameter
rho_string = 'Solver.Rho.Optimal.' + rho_method + '(A,M,A_T)'
rh = eval(rho_string)
rho.append(rh) #rho[0]
################
## ITERATIONS ##
################
for k in range(MAXITER):
#Super LU factorization of M + rho * dot(M_T,M)
if rho[k] != rho[k - 1] or k == 0:
P = M + rho[k] * csc_matrix.dot(A_T, A)
LU = linalg.splu(P)
LU_old = LU
else:
LU = LU_old
################
## v - update ##
################
RHS = -f + rho[k] * csc_matrix.dot(A_T, -w - b - xi[k] + u[k])
v.append(LU.solve(RHS)) #v[k+1]
################
## u - update ##
################
Av = csr_matrix.dot(A, v[k + 1])
vector = Av + xi[k] + w + b
u.append(projection(vector, mu, dim1, dim2)) #u[k+1]
########################
## residuals - update ##
########################
s.append(rho[k] * csc_matrix.dot(A_T, (u[k + 1] - u[k]))) #s[k+1]
r.append(Av - u[k + 1] + w + b) #r[k+1]
#################
## xi - update ##
#################
ratio = rho[k -
1] / rho[k] #update of dual scaled variable with new rho
xi.append(ratio * (xi[k] + r[k + 1])) #xi[k+1]
####################
## stop criterion ##
####################
pri_evalf = np.amax(
np.array([
np.linalg.norm(csr_matrix.dot(A, v[k + 1])),
np.linalg.norm(u[k + 1]),
np.linalg.norm(w + b)
]))
eps_pri = np.sqrt(p) * ABSTOL + RELTOL * pri_evalf
dual_evalf = np.linalg.norm(rho[k] * csc_matrix.dot(A_T, xi[k + 1]))
eps_dual = np.sqrt(n) * ABSTOL + RELTOL * dual_evalf
r_norm.append(np.linalg.norm(r[k + 1]))
s_norm.append(np.linalg.norm(s[k + 1]))
if r_norm[k + 1] <= eps_pri and s_norm[k + 1] <= eps_dual:
break
################################
## penalty parameter - update ##
################################
rho.append(penalty(rho[k], r_norm[k + 1], s_norm[k + 1]))
#end rutine
end = time.clock()
####################
## REPORTING DATA ##
####################
#plotit(r,s,start,end,'Without acceleration / Without restarting for '+problem_data+' for rho: '+rho_method)
time = end - start
return time
def cp_RR(problem_data, rho_method): ###################### ## IMPORT LIBRARIES ## ###################### #Math libraries import numpy as np from scipy.sparse import csc_matrix from scipy.sparse import csr_matrix from scipy.sparse import linalg #Timing import time #Import data from Data.read_fclib import * #Plot residuals from Solver.ADMM_iteration.Numerics.plot import * #Initial penalty parameter import Solver.Rho.Optimal #Max iterations and kind of tolerance from Solver.Tolerance.iter_totaltolerance import * #Acceleration from Solver.Acceleration.plusr import * #b = Es matrix from Data.Es_matrix import * #Projection onto second order cone from Solver.ADMM_iteration.Numerics.projection import * ##################################################### ############# TERMS / NOT A FUNCTION YET ############ ##################################################### start = time.clock() problem = hdf5_file(problem_data) M = problem.M.tocsc() f = problem.f A = csc_matrix.transpose(problem.H.tocsc()) A_T = csr_matrix.transpose(A) w = problem.w mu = problem.mu #Dimensions (normal,tangential,tangential) dim1 = 3 dim2 = np.shape(w)[0] #Problem size n = np.shape(M)[0] p = np.shape(w)[0] b = 0.1 * Es_matrix(w,mu,np.ones([p,])) / np.linalg.norm(Es_matrix(w,mu,np.ones([p,]))) ################################# ############# SET-UP ############ ################################# #Set-up of vectors v = [np.zeros([n,])] u = [np.zeros([p,])] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])] u_hat = [np.zeros([p,])] #u_hat[0] #in the notation of the paper this used with a underline xi = [np.zeros([p,])] xi_hat = [np.zeros([p,])] r = [np.zeros([p,])] #primal residual s = [np.zeros([p,])] #dual residual r_norm = [0] s_norm = [0] tau = [1] #over-relaxation e = [] #restart #Optimal penalty parameter rho_string = 'Solver.Rho.Optimal.' + rho_method + '(A,M,A_T)' rho = eval(rho_string) ######################################## ## TERMS COMMON TO ALL THE ITERATIONS ## ######################################## #Super LU factorization of M + rho * dot(M_T,M) P = M + rho * csc_matrix.dot(A_T,A) LU = linalg.splu(P) ################ ## ITERATIONS ## ################ for k in range(MAXITER): ################ ## v - update ## ################ RHS = -f + rho * csc_matrix.dot(A_T, -w - b - xi_hat[k] + u_hat[k]) v.append(LU.solve(RHS)) #v[k+1] ################ ## u - update ## ################ Av = csr_matrix.dot(A,v[k+1]) vector = Av + xi_hat[k] + w + b u.append(projection(vector,mu,dim1,dim2)) #u[k+1] ######################## ## residuals - update ## ######################## s.append(rho * csc_matrix.dot(A_T,(u[k+1]-u_hat[k]))) #s[k+1] r.append(Av - u[k+1] + w + b) #r[k+1] ################# ## xi - update ## ################# xi.append(xi_hat[k] + r[k+1]) #xi[k+1] #################### ## stop criterion ## #################### pri_evalf = np.amax(np.array([np.linalg.norm(csr_matrix.dot(A,v[k+1])),np.linalg.norm(u[k+1]),np.linalg.norm(w + b)])) eps_pri = np.sqrt(p)*ABSTOL + RELTOL*pri_evalf dual_evalf = np.linalg.norm(rho * csc_matrix.dot(A_T,xi[k+1])) eps_dual = np.sqrt(n)*ABSTOL + RELTOL*dual_evalf r_norm.append(np.linalg.norm(r[k+1])) s_norm.append(np.linalg.norm(s[k+1])) if r_norm[k+1]<=eps_pri and s_norm[k+1]<=eps_dual: break ################################### ## accelerated ADMM with restart ## ################################### plusr(tau,u,u_hat,xi,xi_hat,k,e,rho) #end rutine end = time.clock() #################### ## REPORTING DATA ## #################### #plotit(r,s,start,end,'With acceleration / With restarting for '+problem_data+' for rho: '+rho_method) time = end - start return time
def Mehrotra(A, b, c, ite, errorgrad, errorfit, eta):
(m, n) = np.shape(A)
(x, llambda, s) = InitialPoints(A, b, c)
I = identity(n, dtype=float)
fitness = 1e100
antnorm = 1e100
for i in range(0, ite):
S = diags(s)
X = diags(x)
rs = csc_matrix.transpose(A).dot(llambda) + s - c
rb = A.dot(x) - b
XSe = np.multiply(s, x)
K1 = sparse.hstack([csc_matrix((n, n)), csc_matrix.transpose(A), I])
K2 = sparse.hstack([A, csc_matrix((m, m)), csc_matrix((m, n))])
K3 = sparse.hstack([S, csc_matrix((n, m)), X])
K = csc_matrix(sparse.vstack([K1, K2, K3]))
bb = np.concatenate((rs, rb, XSe))
deltaxaffin = spsolve(K, -bb)
deltax = deltaxaffin[0:n]
deltalambda = deltaxaffin[n:n + m]
deltas = deltaxaffin[n + m:2 * n + m]
if any(deltax < 0):
alpha_primal_max = min(-x[deltax < 0] / deltax[deltax < 0])
if any(deltas < 0):
alpha_dual_max = min(-s[deltas < 0] / deltas[deltas < 0])
Muaff = (np.dot(x + alpha_primal_max * deltax,
s + alpha_dual_max * deltas) / n)
Mu = (np.dot(s, x) / n)
Sigma = (Muaff / Mu) * (Muaff / Mu) * (Muaff / Mu)
#print Mu
bb = np.concatenate(
(rs, rb, XSe + np.multiply(deltax, deltas) - Sigma * Mu))
deltaxcorr = spsolve(K, -bb)
delta = deltaxaffin + deltaxcorr
#calculo de alphas...
deltax = delta[0:n]
deltalambda = delta[n:n + m]
deltas = delta[n + m:2 * n + m]
if any(deltax < 0):
alpha_primal_max = min(-x[deltax < 0] / deltax[deltax < 0])
if any(deltas < 0):
alpha_dual_max = min(-s[deltas < 0] / deltas[deltas < 0])
alphaprimal = min(1.0, eta * alpha_primal_max)
alphadual = min(1.0, eta * alpha_dual_max)
# if abs(antnorm - x.dot(x)) < errorgrad:
# break
# antnorm = x.dot(x)
#print deltax.dot(deltax)
if deltax.dot(deltax) < errorgrad:
break
#if abs(c.dot(x + alphaprimal*deltax) - c.dot(x)) < errorfit:
# break
if fitness > c.dot(x):
x = x + alphaprimal * deltax
fitness = c.dot(x)
llambda = llambda + alphadual * deltalambda
s = s + alphadual * deltas
return x, np.transpose(c).dot(x), i
def vp_RR_He(problem_data, rho_method): ###################### ## IMPORT LIBRARIES ## ###################### #Math libraries import numpy as np from scipy.sparse import csc_matrix from scipy.sparse import csr_matrix from scipy.sparse import linalg #Timing import time #Import data from Data.read_fclib import * #Plot residuals from Solver.ADMM_iteration.Numerics.plot import * #Initial penalty parameter import Solver.Rho.Optimal #Max iterations and kind of tolerance from Solver.Tolerance.iter_totaltolerance import * #Acceleration from Solver.Acceleration.plusr_vp import * #Varying penalty parameter from Solver.Rho.Varying.He import * #b = Es matrix from Data.Es_matrix import * #Db = DEs matrix (derivative) from Data.DEs_matrix import * #Projection onto second order cone from Solver.ADMM_iteration.Numerics.projection import * ################################## ############# REQUIRE ############ ################################## start = time.clock() problem = hdf5_file(problem_data) M = problem.M.tocsc() f = problem.f A = csc_matrix.transpose(problem.H.tocsc()) A_T = csr_matrix.transpose(A) w = problem.w mu = problem.mu #Dimensions (normal,tangential,tangential) dim1 = 3 dim2 = np.shape(w)[0] #Problem size n = np.shape(M)[0] p = np.shape(w)[0] b = [1/linalg.norm(A,'fro') * Es_matrix(w,mu,np.zeros([p,])) / np.linalg.norm(Es_matrix(w,mu,np.ones([p,])))] ################################# ############# SET-UP ############ ################################# #Set-up of vectors v = [np.zeros([n,])] u = [np.zeros([p,])] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])] u_hat = [np.zeros([p,])] #u_hat[0] #in the notation of the paper this used with a underline xi = [np.zeros([p,])] xi_hat = [np.zeros([p,])] r = [np.zeros([p,])] #primal residual s = [np.zeros([p,])] #dual residual r_norm = [0] s_norm = [0] tau = [1] #over-relaxation e = [] #restart rho = [] #Optimal penalty parameter rho_string = 'Solver.Rho.Optimal.' + rho_method + '(A,M,A_T)' rh = eval(rho_string) rho.append(rh) #rho[0] ################ ## ITERATIONS ## ################ for k in range(MAXITER): print k #Super LU factorization of M + rho * dot(M_T,M) if k == 0: P = M + rho[k] * csc_matrix.dot(A_T,A) LU = linalg.splu(P) else: DE = DEs_matrix(w, mu, Av + w, A.toarray()) P = M + rho[k] * csc_matrix.dot(A_T + DE,A) LU = linalg.splu(P) ################ ## v - update ## ################ if k==0: RHS = -f + rho[k] * csc_matrix.dot(A_T, -w - b[k] - xi_hat[k] + u_hat[k]) v.append(LU.solve(RHS)) #v[k+1] else: RHS = -f + rho[k] * csc_matrix.dot(A_T + DE, -w - b[k] - xi_hat[k] + u_hat[k]) v.append(LU.solve(RHS)) #v[k+1] ################ ## u - update ## ################ Av = csr_matrix.dot(A,v[k+1]) vector = Av + xi_hat[k] + w + b[k] u.append(projection(vector,mu,dim1,dim2)) #u[k+1] ######################## ## residuals - update ## ######################## s.append(rho[k] * csc_matrix.dot(A_T,(u[k+1]-u_hat[k]))) #s[k+1] r.append(Av - u[k+1] + w + b[k]) #r[k+1] ################# ## xi - update ## ################# ratio = rho[k-1]/rho[k] #update of dual scaled variable with new rho xi.append(ratio*(xi_hat[k] + r[k+1])) #xi[k+1] #b update b.append(Es_matrix(w,mu,Av + w)) #################### ## stop criterion ## #################### pri_evalf = np.amax(np.array([np.linalg.norm(csr_matrix.dot(A,v[k+1])),np.linalg.norm(u[k+1]),np.linalg.norm(w + b[k+1])])) eps_pri = np.sqrt(p)*ABSTOL + RELTOL*pri_evalf dual_evalf = np.linalg.norm(rho[k] * csc_matrix.dot(A_T,xi[k+1])) eps_dual = np.sqrt(n)*ABSTOL + RELTOL*dual_evalf r_norm.append(np.linalg.norm(r[k+1])) s_norm.append(np.linalg.norm(s[k+1])) if r_norm[k+1]<=eps_pri and s_norm[k+1]<=eps_dual: orthogonal = np.dot(u[-1],rho[-2]*xi[-1]) print orthogonal break #b_per_contact_j1 = np.split(b[k+1],dim2/dim1) #b_per_contact_j0 = np.split(b[k],dim2/dim1) #count = 0 #for j in range(dim2/dim1): # if np.linalg.norm(b_per_contact_j1[j] - b_per_contact_j0[j]) / np.linalg.norm(b_per_contact_j0[j]) > 1e-03: # count += 1 #if count < 1: # break ################################### ## accelerated ADMM with restart ## ################################### plusr(tau,u,u_hat,xi,xi_hat,k,e,rho,ratio) ################################ ## penalty parameter - update ## ################################ rho.append(penalty(rho[k],r_norm[k+1],s_norm[k+1])) #end rutine end = time.clock() #################### ## REPORTING DATA ## #################### #print b[-1] #print np.linalg.norm(b[-1]) #plotit(r,s,start,end,'With acceleration / Without restarting for '+problem_data+' for rho: '+rho_method) plotit(r,s,start,end,'Internal update with vp_RR_He (Di Cairano)') time = end - start print 'Total time: ', time return time
def vp_RR_He(problem_data, rho_method):
######################
## IMPORT LIBRARIES ##
######################
#Math libraries
import numpy as np
from scipy.sparse import csc_matrix
from scipy.sparse import csr_matrix
from scipy.sparse import linalg
#Timing
import time
#Import data
from Data.read_fclib import *
#Plot residuals
from Solver.ADMM_iteration.Numerics.plot import *
#Initial penalty parameter
import Solver.Rho.Optimal
#Max iterations and kind of tolerance
from Solver.Tolerance.iter_totaltolerance import *
#Acceleration
from Solver.Acceleration.plusr_vp import *
#Varying penalty parameter
from Solver.Rho.Varying.He import *
#b = Es matrix
from Data.Es_matrix import *
#Projection onto second order cone
from Solver.ADMM_iteration.Numerics.projection import *
##################################
############# REQUIRE ############
##################################
start = time.clock()
problem = hdf5_file(problem_data)
M = problem.M.tocsc()
f = problem.f
A = csc_matrix.transpose(problem.H.tocsc())
A_T = csr_matrix.transpose(A)
w = problem.w
mu = problem.mu
#Dimensions (normal,tangential,tangential)
dim1 = 3
dim2 = np.shape(w)[0]
#Problem size
n = np.shape(M)[0]
p = np.shape(w)[0]
b = [Es_matrix(w, mu, np.zeros([
p,
]))]
#################################
############# SET-UP ############
#################################
#Set-up of vectors
v = [np.zeros([
n,
])]
u = [
np.zeros([
p,
])
] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
u_hat = [np.zeros([
p,
])] #u_hat[0] #in the notation of the paper this used with a underline
xi = [np.zeros([
p,
])]
xi_hat = [np.zeros([
p,
])]
r = [np.zeros([
p,
])] #primal residual
s = [np.zeros([
p,
])] #dual residual
r_norm = [0]
s_norm = [0]
tau = [1] #over-relaxation
e = [] #restart
rho = []
#Optimal penalty parameter
rho_string = 'Solver.Rho.Optimal.' + rho_method + '(A,M,A_T)'
rh = eval(rho_string)
rho.append(rh) #rho[0]
#Plot
rho_plot = []
r_plot = []
s_plot = []
b_plot = []
u_bin_plot = []
xi_bin_plot = []
siconos_plot = []
################
## ITERATIONS ##
################
for j in range(200):
print j
len_u = len(u) - 1
for k in range(len_u, MAXITER):
#Super LU factorization of M + rho * dot(M_T,M)
if rho[k] != rho[k - 1] or k == len_u: #rho[k] != rho[k-1] or
P = M + rho[k] * csc_matrix.dot(A_T, A)
LU = linalg.splu(P)
LU_old = LU
else:
LU = LU_old
################
## v - update ##
################
RHS = -f + rho[k] * csc_matrix.dot(
A_T, -w - b[j] - xi_hat[k] + u_hat[k])
v.append(LU.solve(RHS)) #v[k+1]
################
## u - update ##
################
Av = csr_matrix.dot(A, v[k + 1])
vector = Av + xi_hat[k] + w + b[j]
u.append(projection(vector, mu, dim1, dim2)) #u[k+1]
########################
## residuals - update ##
########################
s.append(rho[k] * csc_matrix.dot(A_T,
(u[k + 1] - u_hat[k]))) #s[k+1]
r.append(Av - u[k + 1] + w + b[j]) #r[k+1]
#################
## xi - update ##
#################
ratio = rho[k - 1] / rho[
k] #update of dual scaled variable with new rho
xi.append(ratio * (xi_hat[k] + r[k + 1])) #xi[k+1]
###################################
## accelerated ADMM with restart ##
###################################
plusr(tau, u, u_hat, xi, xi_hat, k, e, rho, ratio)
################################
## penalty parameter - update ##
################################
r_norm.append(np.linalg.norm(r[k + 1]))
s_norm.append(np.linalg.norm(s[k + 1]))
rho.append(penalty(rho[k], r_norm[k + 1], s_norm[k + 1]))
####################
## stop criterion ##
####################
pri_evalf = np.amax(
np.array([
np.linalg.norm(csr_matrix.dot(A, v[k + 1])),
np.linalg.norm(u[k + 1]),
np.linalg.norm(w + b[j])
]))
eps_pri = np.sqrt(p) * ABSTOL + RELTOL * pri_evalf
dual_evalf = np.linalg.norm(rho[k] *
csc_matrix.dot(A_T, xi[k + 1]))
eps_dual = np.sqrt(n) * ABSTOL + RELTOL * dual_evalf
R = -rho[k] * xi[k + 1]
N1 = csc_matrix.dot(M, v[k + 1]) - csc_matrix.dot(A_T, R) + f
N2 = u[k + 1] - projection(u[k + 1] - R, mu, dim1, dim2)
N1_norm = np.linalg.norm(N1)
N2_norm = np.linalg.norm(N2)
siconos_plot.append(np.sqrt(N1_norm**2 + N2_norm**2))
if r_norm[k + 1] <= eps_pri and s_norm[k + 1] <= eps_dual:
#if k == len_u:
for element in range(len(u)):
#Relative velocity
u_proj = projection(u[element], mu, dim1, dim2)
u_proj_contact = np.split(u_proj, dim2 / dim1)
u_contact = np.split(u[element], dim2 / dim1)
u_count = 0.0
for contact in range(dim2 / dim1):
#if np.linalg.norm(u_contact[contact] - u_proj_contact[contact]) / np.linalg.norm(u_contact[contact]) < 1e-01:
if np.allclose(u_contact[contact],
u_proj_contact[contact],
rtol=0.1,
atol=0.0):
u_count += 1.0
u_bin = 100 * u_count / (dim2 / dim1)
u_bin_plot.append(u_bin)
#Reaction
xi_proj = projection(-1 * xi[element], 1 / mu, dim1, dim2)
xi_proj_contact = np.split(xi_proj, dim2 / dim1)
xi_contact = np.split(-1 * xi[element], dim2 / dim1)
xi_count = 0.0
for contact in range(dim2 / dim1):
#if np.linalg.norm(xi_contact[contact] - xi_proj_contact[contact]) / np.linalg.norm(xi_contact[contact]) < 1e-01:
if np.allclose(xi_contact[contact],
xi_proj_contact[contact],
rtol=0.1,
atol=0.0):
xi_count += 1.0
xi_bin = 100 * xi_count / (dim2 / dim1)
xi_bin_plot.append(xi_bin)
for element in range(len(r_norm)):
rho_plot.append(rho[element])
r_plot.append(r_norm[element])
s_plot.append(s_norm[element])
b_plot.append(np.linalg.norm(b[j]))
#print 'First contact'
#print -rho[k]*xi[k+1][:3]
#uy = projection(-rho[k]*xi[k+1],1/mu,dim1,dim2)
#print uy[:3]
#print 'Last contact'
#print -rho[k]*xi[k+1][-3:]
#print uy[-3:]
#R = -rho[k]*xi[k+1]
#N1 = csc_matrix.dot(M, v[k+1]) - csc_matrix.dot(A_T, R) + f
#N2 = u[k+1] - projection(u[k+1] - R, mu, dim1, dim2)
#N1_norm = np.linalg.norm(N1)
#N2_norm = np.linalg.norm(N2)
#print np.sqrt( N1_norm**2 + N2_norm**2 )
print b_plot[-1]
print b[-1][:3]
print b[-1][-3:]
break
#end rutine
#b(s) stop criterion
b.append(Es_matrix(w, mu, Av + w))
if j == 0:
pass
else:
b_per_contact_j1 = np.split(b[j + 1], dim2 / dim1)
b_per_contact_j0 = np.split(b[j], dim2 / dim1)
count = 0
for i in range(dim2 / dim1):
if np.linalg.norm(b_per_contact_j1[i] -
b_per_contact_j0[i]) / np.linalg.norm(
b_per_contact_j0[i]) > 1e-03:
count += 1
if count < 1:
break
v = [np.zeros([
n,
])]
u = [
np.zeros([
p,
])
] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
u_hat = [np.zeros([
p,
])] #u_hat[0] #in the notation of the paper this used with a underline
xi = [np.zeros([
p,
])]
xi_hat = [np.zeros([
p,
])]
r = [np.zeros([
p,
])] #primal residual
s = [np.zeros([
p,
])] #dual residual
r_norm = [0]
s_norm = [0]
tau = [1] #over-relaxation
e = [] #restart
rho = [rho[-1]]
end = time.clock()
time = end - start
####################
## REPORTING DATA ##
####################
f, axarr = plt.subplots(5, sharex=True)
f.suptitle('External update with vp_RR_He (Di Cairano)')
axarr[0].semilogy(b_plot)
axarr[0].set(ylabel='||Phi(s)||')
axarr[1].plot(rho_plot)
axarr[1].set(ylabel='Rho')
axarr[2].semilogy(r_plot, label='||r||')
axarr[2].semilogy(s_plot, label='||s||')
axarr[2].legend()
axarr[2].set(ylabel='Residuals')
axarr[3].semilogy(siconos_plot)
axarr[3].set(ylabel='SICONOS error')
axarr[4].plot(u_bin_plot, label='u in K*')
axarr[4].plot(xi_bin_plot, label='-xi in K')
axarr[4].legend()
axarr[4].set(xlabel='Iteration', ylabel='Projection (%)')
plt.show()
print 'Total time: ', time
return time
def LongStepPath(A, b, c, ite, errorgrad, errorfit, sigmamin, sigmamax, gamma):
(m, n) = np.shape(A)
##Se utiliza el algoritmo Primal Dual para encontrar un punto inicial en la vecindad...
(x, llambda, s) = PrimalDual(A, b, c, 100)
I = identity(n, dtype=float)
fitness = 1e100
antnorm = 1e100
for i in range(0, ite):
sigma = np.random.uniform(sigmamin, sigmamax, 1)
S = diags(s)
X = diags(x)
rs = csc_matrix.transpose(A).dot(llambda) + s - c
rb = A.dot(x) - b
Mu = (np.dot(s, x) / n)
XSe = np.multiply(s, x) - np.ones(n) * (sigma * Mu)
K1 = sparse.hstack([csc_matrix((n, n)), csc_matrix.transpose(A), I])
K2 = sparse.hstack([A, csc_matrix((m, m)), csc_matrix((m, n))])
K3 = sparse.hstack([S, csc_matrix((n, m)), X])
K = csc_matrix(sparse.vstack([K1, K2, K3]))
bb = np.concatenate((rs, rb, XSe))
#xx = np.linalg.solve(K.toarray(), -bb)
#print Mu
xx = spsolve(K, -bb)
alpha = 1e-100
while (
(x + alpha * xx[0:n] >= 0).all() and
(s + alpha * xx[(n + m):2 * n + m] >= 0).all()
and np.linalg.norm(A.dot(x + alpha * xx[0:n]) - b) < 1e-2
) and np.linalg.norm(
csc_matrix.transpose(A).dot(llambda + alpha * xx[n:(n + m)]) +
s + alpha * xx[(n + m):2 * n + m] - c) < 1e-2 and np.multiply(
x + alpha * xx[0:n],
s + alpha * xx[(n + m):2 * n + m] >= Mu * gamma).any():
alpha = alpha * 2.0
alpha = alpha / 2.0
alpha = min(1.0, alpha)
if (A.dot(x + alpha * xx[0:n]) - b).dot(
(A.dot(x + alpha * xx[0:n]) -
b)) < rb.dot(rb) and (x + alpha * xx[0:n]).dot(c) <= x.dot(c):
x = x + alpha * xx[0:n]
if (csc_matrix.transpose(A).dot(llambda + alpha * xx[n:(n + m)]) +
alpha * xx[(n + m):2 * n + m] - c).dot(
csc_matrix.transpose(A).dot(llambda +
alpha * xx[n:(n + m)]) +
alpha * xx[(n + m):2 * n + m] - c) < rs.dot(rs):
llambda = llambda + alpha * xx[n:(n + m)]
s = s + alpha * xx[(n + m):2 * n + m]
#print xx[0:n].dot(xx[0:n])
if xx[0:n].dot(xx[0:n]) < errorgrad:
break
# if abs(antnorm - xx.dot(xx)) < errorgrad:
# break
# antnorm = xx.dot(xx)
# if abs(fitness - c.dot(x)) < errorfit:
# break
fitness = c.dot(x)
return x, np.transpose(c).dot(x), i
def cp_RR(problem_data, rho_method):
######################
## IMPORT LIBRARIES ##
######################
#Math libraries
import numpy as np
from scipy.sparse import csc_matrix
from scipy.sparse import csr_matrix
from scipy.sparse import linalg
#Timing
import time
#Import data
from Data.read_fclib import *
#Plot residuals
from Solver.ADMM_iteration.Numerics.plot import *
#Initial penalty parameter
import Solver.Rho.Optimal
#Max iterations and kind of tolerance
from Solver.Tolerance.iter_totaltolerance import *
#Acceleration
from Solver.Acceleration.plusr import *
#b = Es matrix
from Data.Es_matrix import *
#Projection onto second order cone
from Solver.ADMM_iteration.Numerics.projection import *
#####################################################
############# TERMS / NOT A FUNCTION YET ############
#####################################################
start = time.clock()
problem = hdf5_file(problem_data)
M = problem.M.tocsc()
f = problem.f
A = csc_matrix.transpose(problem.H.tocsc())
A_T = csr_matrix.transpose(A)
w = problem.w
mu = problem.mu
#Dimensions (normal,tangential,tangential)
dim1 = 3
dim2 = np.shape(w)[0]
#Problem size
n = np.shape(M)[0]
p = np.shape(w)[0]
b = [
1 / linalg.norm(A, 'fro') * Es_matrix(w, mu, np.zeros([
p,
])) / np.linalg.norm(Es_matrix(w, mu, np.ones([
p,
])))
]
#################################
############# SET-UP ############
#################################
#Set-up of vectors
v = [np.zeros([
n,
])]
u = [
np.zeros([
p,
])
] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
u_hat = [np.zeros([
p,
])] #u_hat[0] #in the notation of the paper this used with a underline
xi = [np.zeros([
p,
])]
xi_hat = [np.zeros([
p,
])]
r = [np.zeros([
p,
])] #primal residual
s = [np.zeros([
p,
])] #dual residual
r_norm = [0]
s_norm = [0]
tau = [1] #over-relaxation
e = [] #restart
#Optimal penalty parameter
rho_string = 'Solver.Rho.Optimal.' + rho_method + '(A,M,A_T)'
rho = eval(rho_string)
#Plot
r_plot = []
s_plot = []
b_plot = []
u_bin_plot = []
xi_bin_plot = []
########################################
## TERMS COMMON TO ALL THE ITERATIONS ##
########################################
#Super LU factorization of M + rho * dot(M_T,M)
P = M + rho * csc_matrix.dot(A_T, A)
LU = linalg.splu(P)
################
## ITERATIONS ##
################
for j in range(20):
print j
len_u = len(u) - 1
for k in range(len_u, MAXITER):
################
## v - update ##
################
RHS = -f + rho * csc_matrix.dot(A_T,
-w - b[j] - xi_hat[k] + u_hat[k])
v.append(LU.solve(RHS)) #v[k+1]
################
## u - update ##
################
Av = csr_matrix.dot(A, v[k + 1])
vector = Av + xi_hat[k] + w + b[j]
u.append(projection(vector, mu, dim1, dim2)) #u[k+1]
########################
## residuals - update ##
########################
s.append(rho * csc_matrix.dot(A_T, (u[k + 1] - u_hat[k]))) #s[k+1]
r.append(Av - u[k + 1] + w + b[j]) #r[k+1]
#################
## xi - update ##
#################
xi.append(xi_hat[k] + r[k + 1]) #xi[k+1]
###################################
## accelerated ADMM with restart ##
###################################
plusr(tau, u, u_hat, xi, xi_hat, k, e, rho)
####################
## stop criterion ##
####################
pri_evalf = np.amax(
np.array([
np.linalg.norm(csr_matrix.dot(A, v[k + 1])),
np.linalg.norm(u[k + 1]),
np.linalg.norm(w + b[j])
]))
eps_pri = np.sqrt(p) * ABSTOL + RELTOL * pri_evalf
dual_evalf = np.linalg.norm(rho * csc_matrix.dot(A_T, xi[k + 1]))
eps_dual = np.sqrt(n) * ABSTOL + RELTOL * dual_evalf
r_norm.append(np.linalg.norm(r[k + 1]))
s_norm.append(np.linalg.norm(s[k + 1]))
if r_norm[k + 1] <= eps_pri and s_norm[k + 1] <= eps_dual:
for element in range(len(u)):
#Relative velocity
u_proj = projection(u[element], mu, dim1, dim2)
u_proj_contact = np.split(u_proj, dim2 / dim1)
u_contact = np.split(u[element], dim2 / dim1)
u_count = 0.0
for contact in range(dim2 / dim1):
if np.array_equiv(u_contact[contact],
u_proj_contact[contact]):
u_count += 1.0
u_bin = 100 * u_count / (dim2 / dim1)
u_bin_plot.append(u_bin)
#Reaction
xi_proj = projection(xi[element], 1 / mu, dim1, dim2)
xi_proj_contact = np.split(xi_proj, dim2 / dim1)
xi_contact = np.split(xi[element], dim2 / dim1)
xi_count = 0.0
for contact in range(dim2 / dim1):
if np.array_equiv(xi_contact[contact],
xi_proj_contact[contact]):
xi_count += 1.0
xi_bin = 100 * xi_count / (dim2 / dim1)
xi_bin_plot.append(xi_bin)
for element in range(len(r_norm)):
r_plot.append(r_norm[element])
s_plot.append(s_norm[element])
b_plot.append(np.linalg.norm(b[j]))
#print 'First contact'
#print rho*xi[k+1][:3]
#uy = projection(rho*xi[k+1],1/mu,dim1,dim2)
#print uy[:3]
#print 'Last contact'
#print rho*xi[k+1][-3:]
#print uy[-3:]
#print u[k+1]
#R = rho*xi[k+1]
#N1 = csc_matrix.dot(M, v[k+1]) - csc_matrix.dot(A_T, R) + f
#N2 = R - projection(R - u[k+1], 1/mu, dim1, dim2)
#N1_norm = np.linalg.norm(N1)
#N2_norm = np.linalg.norm(N2)
#print np.sqrt( N1_norm**2 + N2_norm**2 )
break
#b(s) stop criterion
b.append(Es_matrix(w, mu, Av + w))
if j == 0:
pass
else:
b_per_contact_j1 = np.split(b[j + 1], dim2 / dim1)
b_per_contact_j0 = np.split(b[j], dim2 / dim1)
count = 0
for i in range(dim2 / dim1):
if np.linalg.norm(b_per_contact_j1[i] -
b_per_contact_j0[i]) / np.linalg.norm(
b_per_contact_j0[i]) > 1e-03:
count += 1
if count < 1:
break
v = [np.zeros([
n,
])]
u = [
np.zeros([
p,
])
] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
u_hat = [np.zeros([
p,
])] #u_hat[0] #in the notation of the paper this used with a underline
xi = [np.zeros([
p,
])]
xi_hat = [np.zeros([
p,
])]
r = [np.zeros([
p,
])] #primal residual
s = [np.zeros([
p,
])] #dual residual
r_norm = [0]
s_norm = [0]
tau = [1] #over-relaxation
e = [] #restart
end = time.clock()
####################
## REPORTING DATA ##
####################
f, axarr = plt.subplots(4, sharex=True)
f.suptitle('External update with cp_RR (Acary)')
axarr[0].semilogy(b_plot)
axarr[0].set(ylabel='||Phi(s)||')
axarr[1].axhline(y=rho)
axarr[1].set(ylabel='Rho')
axarr[2].semilogy(r_plot, label='||r||')
axarr[2].semilogy(s_plot, label='||s||')
axarr[2].set(ylabel='Residuals')
axarr[3].plot(u_bin_plot, label='u in K*')
axarr[3].plot(xi_bin_plot, label='xi in K')
axarr[3].legend()
axarr[3].set(xlabel='Iteration', ylabel='Projection (%)')
plt.show()
#plotit(r,b,start,end,'With acceleration / With restarting for '+problem_data+' for rho: '+rho_method)
time = end - start
print 'Total time: ', time
return time
def PredictorCorrectorQPSolver(G, A, b, c, x, ite=10, errorgrad=1e-5, errorfit=1e-5, eta=0.3):
(m, n) = np.shape(A)
(xt, llambda, y) = InitialPoints(G,A,b,c)
I = identity(m, dtype=float)
fitness = 1e100
antnorm = 1e100
# llambda = llambda*0
for i in range(0,ite):
###1
Y = diags(y)
La = diags(llambda)
rd = G.dot(x) - csc_matrix.transpose(A).dot(llambda) + c
rp = A.dot(x) - y - b
LaYe = np.multiply(llambda, y)
K1 = sparse.hstack([G, csc_matrix( (n,m)) , -csc_matrix.transpose(A)])
K2 = sparse.hstack([A, -I , csc_matrix( (m,m)) ])
K3 = sparse.hstack([csc_matrix( (m,n)), La, Y])
K = csc_matrix(sparse.vstack([K1, K2, K3]))
bb = np.concatenate((-rd,-rp, -LaYe))
deltaAffin = spsolve(K, bb)
deltaxAffin = deltaAffin[0:n]
deltayAffin = deltaAffin[n:n+m]
deltalambdaAffin = deltaAffin[n+m:2*m+n]
###2
Mu = (np.dot(y, llambda)/m)
###3
alphay_affin = 1.0
alphalambda_affin = 1.0
if any(deltayAffin<0):
alphay_affin = min(-y[deltayAffin<0]/deltayAffin[ deltayAffin < 0 ])
if any(deltalambdaAffin<0):
alphalambda_affin = min(-llambda[deltalambdaAffin<0]/deltalambdaAffin[ deltalambdaAffin < 0 ])
alphay_affin = min(1.0, alphay_affin)
alphalambda_affin = min(1.0, alphalambda_affin)
alpha = min(alphay_affin, alphalambda_affin)
###4
Muaff = (np.dot(y+alpha*deltayAffin, llambda+alpha*deltalambdaAffin)/m)
###5
Sigma = (Muaff/Mu)*(Muaff/Mu)*(Muaff/Mu)
###6
bb = np.concatenate((-rd,-rp, -LaYe - np.multiply(deltalambdaAffin, deltayAffin) + Sigma*Mu))
deltacorr = spsolve(K, bb )
###7
deltaxcorr = deltacorr[0:n]
deltaycorr = deltacorr[n:n+m]
deltalambdacorr = deltacorr[n+m:2*m+n]
tao = 0.5
alpha_tao_pri = 1
alpha_tao_dual = 1
if any(deltaycorr<0):
ytmp = y-(1.0-tao)*y
alpha_tao_pri = min(-ytmp[deltaycorr<0]/deltaycorr[deltaycorr<0])
if any(deltalambdacorr<0):
llambdatmp = llambda-(1.0-tao)*llambda
alpha_tao_dual = min(-llambdatmp[deltalambdacorr<0]/(deltalambdacorr[deltalambdacorr<0]) )
alpha_tao_pri = min(1, alpha_tao_pri)
alpha_tao_dual = min(1, alpha_tao_dual)
alpha = min(alpha_tao_pri, alpha_tao_dual)
x2 = x + alpha*deltaxcorr
if deltaxcorr.dot(deltaxcorr) < errorgrad:
break
# if (x.T).dot(G.dot(x))*0.5 + c.dot(x) > (x2.T).dot(G.dot(x2))*0.5 + c.dot(x2):
x = x2#x + alpha*deltaxcorr
fitness = (x2.T).dot(G.dot(x2))*0.5 + c.dot(x2)
# print fitness
y = y + alpha*deltaycorr
llambda = llambda + alpha*deltalambdacorr
return x, (x.T).dot(G.dot(x))*0.5 + c.dot(x), i, y, llambda
def cp_N(problem_data, rho_method):
######################
## IMPORT LIBRARIES ##
######################
#Math libraries
import numpy as np
from scipy.sparse import csc_matrix
from scipy.sparse import csr_matrix
from scipy.sparse import linalg
#Timing
import time
#Import data
from Data.read_fclib import *
#Plot residuals
from Solver.ADMM_iteration.Numerics.plot import *
#Initial penalty parameter
import Solver.Rho.Optimal
#Max iterations and kind of tolerance
from Solver.Tolerance.iter_totaltolerance import *
#b = Es matrix
from Data.Es_matrix import *
#Projection onto second order cone
from Solver.ADMM_iteration.Numerics.projection import *
##################################
############# REQUIRE ############
##################################
start = time.clock()
problem = hdf5_file(problem_data)
M = problem.M.tocsc()
f = problem.f
A = csc_matrix.transpose(problem.H.tocsc())
A_T = csr_matrix.transpose(A)
w = problem.w
mu = problem.mu
#Dimensions (normal,tangential,tangential)
dim1 = 3
dim2 = np.shape(w)[0]
#Problem size
n = np.shape(M)[0]
p = np.shape(w)[0]
b = [
1 / linalg.norm(A, 'fro') * Es_matrix(w, mu, np.ones([
p,
])) / np.linalg.norm(Es_matrix(w, mu, np.ones([
p,
])))
]
#################################
############# SET-UP ############
#################################
#Set-up of vectors
v = [np.zeros([
n,
])]
u = [
np.zeros([
p,
])
] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
xi = [np.zeros([
p,
])]
r = [np.zeros([
p,
])] #primal residual
s = [np.zeros([
p,
])] #dual residual
r_norm = [0]
s_norm = [0]
e = [] #restart
#Optimal penalty parameter
start = time.clock()
rho_string = 'Solver.Rho.Optimal.' + rho_method + '(A,M,A_T)'
rho = eval(rho_string)
########################################
## TERMS COMMON TO ALL THE ITERATIONS ##
########################################
#Super LU factorization of M + rho * dot(M_T,M)
P = M + rho * csc_matrix.dot(A_T, A)
LU = linalg.splu(P)
################
## ITERATIONS ##
################
for j in range(MAXITER):
for k in range(len(u) - 1, MAXITER):
################
## v - update ##
################
RHS = -f + rho * csc_matrix.dot(A_T, -w - b[j] - xi[k] + u[k])
v.append(LU.solve(RHS)) #v[k+1]
################
## u - update ##
################
Av = csr_matrix.dot(A, v[k + 1])
vector = Av + xi[k] + w + b[j]
u.append(projection(vector, mu, dim1, dim2)) #u[k+1]
########################
## residuals - update ##
########################
s.append(rho * csc_matrix.dot(A_T, (u[k + 1] - u[k]))) #s[k+1]
r.append(Av - u[k + 1] + w + b[j]) #r[k+1]
#################
## xi - update ##
#################
xi.append(xi[k] + r[k + 1]) #xi[k+1]
####################
## stop criterion ##
####################
pri_evalf = np.amax(
np.array([
np.linalg.norm(csr_matrix.dot(A, v[k + 1])),
np.linalg.norm(u[k + 1]),
np.linalg.norm(w + b[j])
]))
eps_pri = np.sqrt(p) * ABSTOL + RELTOL * pri_evalf
dual_evalf = np.linalg.norm(rho * csc_matrix.dot(A_T, xi[k + 1]))
eps_dual = np.sqrt(n) * ABSTOL + RELTOL * dual_evalf
r_norm.append(np.linalg.norm(r[k + 1]))
s_norm.append(np.linalg.norm(s[k + 1]))
if r_norm[k + 1] <= eps_pri and s_norm[k + 1] <= eps_dual:
break
#end rutine
#b(s) stop criterion
b.append(Es_matrix(w, mu, csr_matrix.dot(A, v[k + 1])))
if j == 0:
pass
else:
b_per_contact_j1 = np.split(b[j + 1], dim2 / dim1)
b_per_contact_j0 = np.split(b[j], dim2 / dim1)
count = 0
for i in range(dim2 / dim1):
if np.linalg.norm(b_per_contact_j1[i] -
b_per_contact_j0[i]) / np.linalg.norm(
b_per_contact_j0[i]) > 1e-02:
count += 1
if count < 1:
break
v.append(np.zeros([
n,
]))
u.append(
np.zeros([
p,
])
) #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
xi.append(np.zeros([
p,
]))
r.append(np.zeros([
p,
])) #primal residual
s.append(np.zeros([
p,
])) #dual residual
r_norm.append(0)
s_norm.append(0)
#print(1 / linalg.norm(A,'fro'))
#print(1 / linalg.norm(A,1))
print(b[-1])
end = time.clock()
####################
## REPORTING DATA ##
####################
plotit(
b, s, start, end, 'Without acceleration / Without restarting for ' +
problem_data + ' for rho: ' + rho_method)
time = end - start
return time
def vp_RR_He(problem_data, rho_method):
######################
## IMPORT LIBRARIES ##
######################
#Math libraries
import numpy as np
from scipy.sparse import csc_matrix
from scipy.sparse import csr_matrix
from scipy.sparse import linalg
#Timing
import time
#Import data
from Data.read_fclib import *
#Plot residuals
from Solver.ADMM_iteration.Numerics.plot import *
#Initial penalty parameter
import Solver.Rho.Optimal
#Max iterations and kind of tolerance
from Solver.Tolerance.iter_totaltolerance import *
#Acceleration
from Solver.Acceleration.plusr_vp import *
#Varying penalty parameter
from Solver.Rho.Varying.He import *
#b = Es matrix
from Data.Es_matrix import *
#Projection onto second order cone
from Solver.ADMM_iteration.Numerics.projection import *
##################################
############# REQUIRE ############
##################################
start = time.clock()
problem = hdf5_file(problem_data)
M = problem.M.tocsc()
f = problem.f
A = csc_matrix.transpose(problem.H.tocsc())
A_T = csr_matrix.transpose(A)
w = problem.w
mu = problem.mu
#Dimensions (normal,tangential,tangential)
dim1 = 3
dim2 = np.shape(w)[0]
#Problem size
n = np.shape(M)[0]
p = np.shape(w)[0]
b = [
1 / linalg.norm(A, 'fro') * Es_matrix(w, mu, np.zeros([
p,
])) / np.linalg.norm(Es_matrix(w, mu, np.ones([
p,
])))
]
#################################
############# SET-UP ############
#################################
#Set-up of vectors
v = [np.zeros([
n,
])]
u = [
np.zeros([
p,
])
] #this is u tilde, but in the notation of the paper is used as hat [np.zeros([10,0])]
u_hat = [np.zeros([
p,
])] #u_hat[0] #in the notation of the paper this used with a underline
xi = [np.zeros([
p,
])]
xi_hat = [np.zeros([
p,
])]
r = [np.zeros([
p,
])] #primal residual
s = [np.zeros([
p,
])] #dual residual
r_norm = [0]
s_norm = [0]
tau = [1] #over-relaxation
e = [] #restart
rho = []
#Optimal penalty parameter
rho_string = 'Solver.Rho.Optimal.' + rho_method + '(A,M,A_T)'
rh = eval(rho_string)
rho.append(rh) #rho[0]
################
## ITERATIONS ##
################
for j in range(15):
print j
len_u = len(u) - 1
for k in range(len_u, MAXITER):
#Super LU factorization of M + rho * dot(M_T,M)
if k == 0: #rho[k] != rho[k-1] or
P = M + rho[k] * csc_matrix.dot(A_T, A)
LU = linalg.splu(P)
LU_old = LU
else:
LU = LU_old
#rho[k] != rho[k-1] or
################
## v - update ##
################
RHS = -f + rho[k] * csc_matrix.dot(
A_T, -w - b[j] - xi_hat[k] + u_hat[k])
v.append(LU.solve(RHS)) #v[k+1]
#P = M + rho[k] * csc_matrix.dot(A_T,A)
#RHS = -f + rho[k] * csc_matrix.dot(A_T, -w - b[j] - xi_hat[k] + u_hat[k])
#v.append(linalg.spsolve(P,RHS)) #v[k+1]
#P = M + rho[k] * csc_matrix.dot(A_T,A)
#LU = linalg.factorized(P)
#RHS = -f + rho[k] * csc_matrix.dot(A_T, -w - b[j] - xi_hat[k] + u_hat[k])
#v.append(LU(RHS)) #v[k+1]
################
## u - update ##
################
Av = csr_matrix.dot(A, v[k + 1])
vector = Av + xi_hat[k] + w + b[j]
u.append(projection(vector, mu, dim1, dim2)) #u[k+1]
########################
## residuals - update ##
########################
s.append(rho[k] * csc_matrix.dot(A_T,
(u[k + 1] - u_hat[k]))) #s[k+1]
r.append(Av - u[k + 1] + w + b[j]) #r[k+1]
#################
## xi - update ##
#################
ratio = rho[k - 1] / rho[
k] #update of dual scaled variable with new rho
xi.append(ratio * (xi_hat[k] + r[k + 1])) #xi[k+1]
if j != 0 and k != 0 and j < 2:
#from mpl_toolkits.mplot3d import Axes3D
#soa = np.array([np.concatenate((xi[k+1][:3],np.array([0,0,0]))).tolist()])
#np.concatenate((xi[k][:3],np.array([0,0,0]))).tolist()
#print rho[k]*xi[k+1][:3] * 1e19
print u[k + 1][:3]
#X, Y, Z, U, V, W = zip(*soa)
#fig = plt.figure()
#ax = fig.add_subplot(111, projection='3d')
#ax.quiver(X, Y, Z, U, V, W)
#ax.set_xlim([-1, 1])
#ax.set_ylim([-1, 1])
#ax.set_zlim([-1, 1])
#plt.show()
#plotit(xi[-2:], xi[-2:], start, 5.0,'External update with vp_RR_He (Di Cairano)')
#print Av[-3:] - u[k+1][-3:] + w[-3:]
###################################
## accelerated ADMM with restart ##
###################################
plusr(tau, u, u_hat, xi, xi_hat, k, e, rho, ratio)
################################
## penalty parameter - update ##
################################
r_norm.append(np.linalg.norm(r[k + 1]))
s_norm.append(np.linalg.norm(s[k + 1]))
rho.append(penalty(rho[k], r_norm[k + 1], s_norm[k + 1]))
#rho.append(0.125)
####################
## stop criterion ##
####################
pri_evalf = np.amax(
np.array([
np.linalg.norm(csr_matrix.dot(A, v[k + 1])),
np.linalg.norm(u[k + 1]),
np.linalg.norm(w + b[j])
]))
eps_pri = np.sqrt(p) * ABSTOL + RELTOL * pri_evalf
dual_evalf = np.linalg.norm(rho[k] *
csc_matrix.dot(A_T, xi[k + 1]))
eps_dual = np.sqrt(n) * ABSTOL + RELTOL * dual_evalf
if r_norm[k + 1] <= eps_pri and s_norm[k + 1] <= eps_dual:
R = rho[k] * xi[k + 1]
N1 = csc_matrix.dot(M, v[k + 1]) - csc_matrix.dot(A_T, R) + f
N2 = R - projection(R - u[k + 1], 1 / mu, dim1, dim2)
N1_norm = np.linalg.norm(N1)
N2_norm = np.linalg.norm(N2)
print np.sqrt(N1_norm**2 + N2_norm**2)
#print rho[k]*xi[k+1]
#plotit(r[len_u:], xi[len_u:], start, 5.0,'External update with vp_RR_He (Di Cairano)')
break
#end rutine
#b(s) stop criterion
b.append(Es_matrix(w, mu, Av + w))
if j == 0:
pass
else:
b_per_contact_j1 = np.split(b[j + 1], dim2 / dim1)
b_per_contact_j0 = np.split(b[j], dim2 / dim1)
count = 0
for i in range(dim2 / dim1):
if np.linalg.norm(b_per_contact_j1[i] -
b_per_contact_j0[i]) / np.linalg.norm(
b_per_contact_j0[i]) > 1e-03:
count += 1
if count < 1:
#orthogonal = np.dot(u[-1],rho[-2]*xi[-1])
#print orthogonal
break
v.append(np.zeros([
n,
]))
u.append(np.zeros([
p,
]))
u_hat.append(np.zeros([
p,
]))
xi.append(np.zeros([
p,
]))
xi_hat.append(np.zeros([
p,
]))
r.append(np.zeros([
p,
])) #primal residual
s.append(np.zeros([
p,
])) #dual residual
r_norm.append(0)
s_norm.append(0)
tau.append(1) #over-relaxation
e.append(np.nan) #restart
rho.append(rho[-1])
end = time.clock()
time = end - start
####################
## REPORTING DATA ##
####################
print P.nnz
print np.shape(P)
f, axarr = plt.subplots(2, sharex=True)
f.suptitle('Sharing X axis')
axarr[0].plot(rho, label='rho')
axarr[1].semilogy(r_norm, label='||r||')
axarr[1].semilogy(s_norm, label='||s||')
plt.show()
#plt.semilogy(r_norm, label='||r||')
#plt.hold(True)
#plt.semilogy(rho, label='||s||')
#plt.hold(True)
#plt.ylabel('Residuals')
#plt.xlabel('Iteration')
#plt.text(len(r)/2,np.log(np.amax(S)+np.amax(R))/10,'N_iter = '+str(len(r)-1))
#plt.text(len(r)/2,np.log(np.amax(S)+np.amax(R))/100,'Total time = '+str((end-start)*10**3)+' ms')
#plt.text(len(r)/2,np.log(np.amax(S)+np.amax(R))/1000,'Time_per_iter = '+str(((end-start)/(len(r)-1))*10**3)+' ms')
#plt.title('External update with vp_RR_He (Di Cairano)')
#plt.legend()
plt.show()
#print 'Total time: ',time
return time
