def baseline3(self, t, two_k):
assert self.seeds is None
self.load_baseline3_transition_matrix()
self.graph = self.graph.tocsc()
begin = time.time()
self.seeds = np.zeros(self.total_nodes)
c = np.array(self.partitions, dtype='float64')
for i in range(len(c)):
if c[i] < 0:
c[i] = 0
c *= self.targets
for i in range(t):
c = csc_matrix.dot(c, self.graph)
l = [None] * self.total_nodes
for i in range(self.total_nodes):
l[i] = (i, c[i])
cnt = 0
for elem in sorted(l, key=lambda x: x[1], reverse=True):
if elem[1] <= 0:
break
#seeds.append(elem[0])
self.seeds[elem[0]] = 1
cnt += 1
if cnt >= two_k / 2:
break
c = np.array(self.partitions, dtype='float64')
for i in range(len(c)):
if c[i] > 0:
c[i] = 0
else:
c[i] *= -1
c *= self.targets
for i in range(t):
c = csc_matrix.dot(c, self.graph)
l = [None] * self.total_nodes
for i in range(self.total_nodes):
l[i] = (i, c[i])
cnt = 0
for elem in sorted(l, key=lambda x: x[1], reverse=True):
if elem[1] <= 0:
break
#seeds.append(-1*elem[0])
self.seeds[elem[0]] = -1
cnt += 1
if cnt >= two_k / 2:
break
#for i in range(two_k):
# if self.partitions[seeds[i]] < 0:
# self.seeds[seeds[i]] = -1
# else:
# self.seeds[seeds[i]] = 1
end = time.time()
#print('\nB3 ---------------')
#print(self.seeds)
self.load_transition_matrix()
return end - begin
def explain(self, X):
"""
Return local explanation
Parameters
----------
X : tensor: `torch.Tensor`
Input data
Returns
-------
M_explain : matrix
Importance per sample, per columns.
masks : matrix
Sparse matrix showing attention masks used by network.
"""
try:
self.model.eval()
dataloader = DataLoader(
PredictDataset(X),
batch_size=self.batch_size,
shuffle=False,
)
res_explain = []
reducing_matrix = create_explain_matrix(self.model.input_dim, 0,
[], self.model.input_dim)
for batch_nb, data in enumerate(dataloader):
data = data.to(self.device).float()
M_explain, masks = self.model.forward_masks(data)
for key, value in masks.items():
masks[key] = csc_matrix.dot(value.cpu().detach().numpy(),
reducing_matrix)
res_explain.append(
csc_matrix.dot(M_explain.cpu().detach().numpy(),
reducing_matrix))
if batch_nb == 0:
res_masks = masks
else:
for key, value in masks.items():
res_masks[key] = np.vstack([res_masks[key], value])
res_explain = np.vstack(res_explain)
return res_explain, res_masks
finally:
self.model.train()
def compute_feature_importances(self, X):
"""Compute global feature importance.
Parameters
----------
loader : `torch.utils.data.Dataloader`
Pytorch dataloader.
"""
try:
X_tensor = torch.FloatTensor(X)
dataset = torch.utils.data.TensorDataset(X_tensor)
loader = torch.utils.data.DataLoader(dataset,
batch_size=self.batch_size)
self.model.eval()
reducing_matrix = create_explain_matrix(self.model.input_dim, 0,
[], self.model.input_dim)
feature_importances_ = np.zeros((self.model.input_dim))
for data, in loader:
data = data.to(self.device).float()
M_explain, masks = self.model.forward_masks(data)
feature_importances_ += M_explain.sum(
dim=0).cpu().detach().numpy()
feature_importances_ = csc_matrix.dot(feature_importances_,
reducing_matrix)
self.feature_importances_ = feature_importances_ / np.sum(
feature_importances_)
finally:
self.model.train()
def influ_max(self, t, two_k):
assert self.seeds is None
assert self.graph_type == 1
self.graph = self.graph.tocsc()
final_walk_distribution = np.array(self.partitions, dtype='float64')
final_walk_distribution *= self.targets
begin = time.time()
for tm in range(t):
final_walk_distribution = csc_matrix.dot(final_walk_distribution,
self.graph)
l = [None] * self.total_nodes
for i in range(len(final_walk_distribution)):
l[i] = (i, final_walk_distribution[i],
abs(final_walk_distribution[i]))
cnt = 0
total = 0
self.seeds = np.zeros(self.total_nodes)
for elem in sorted(l, key=lambda x: x[2], reverse=True):
if elem[1] < 0:
total += -1 * elem[1]
self.seeds[elem[0]] = -1
else:
total += elem[1]
self.seeds[elem[0]] = 1
cnt += 1
if cnt >= two_k:
break
end = time.time()
#print(self.seeds)
return end - begin
def explain(self, X):
"""
Return local explanation
Parameters
----------
data: a :tensor: `torch.Tensor`
Input data
target: a :tensor: `torch.Tensor`
Target data
Returns
-------
M_explain: matrix
Importance per sample, per columns.
masks: matrix
Sparse matrix showing attention masks used by network.
"""
self.network.eval()
dataloader = DataLoader(PredictDataset(X),
batch_size=self.batch_size,
shuffle=False)
for batch_nb, data in enumerate(dataloader):
data = data.to(self.device).float()
output, M_loss, M_explain, masks = self.network(data)
for key, value in masks.items():
masks[key] = csc_matrix.dot(value.cpu().detach().numpy(),
self.reducing_matrix)
if batch_nb == 0:
res_explain = csc_matrix.dot(M_explain.cpu().detach().numpy(),
self.reducing_matrix)
res_masks = masks
else:
res_explain = np.vstack([
res_explain,
csc_matrix.dot(M_explain.cpu().detach().numpy(),
self.reducing_matrix)
])
for key, value in masks.items():
res_masks[key] = np.vstack([res_masks[key], value])
return res_explain, res_masks
def tabnet_explain(model: TabNetModel, dl: TabDataLoader):
"Get explain values for a set of predictions"
dec_y = []
model.eval()
for batch_nb, data in enumerate(dl):
with torch.no_grad():
M_explain, masks = model.forward_masks(data[0], data[1])
for key, value in masks.items():
masks[key] = csc_matrix.dot(value.cpu().numpy(), model.emb_reducer)
explain = csc_matrix.dot(M_explain.cpu().numpy(), model.emb_reducer)
if batch_nb == 0:
res_explain = explain
res_masks = masks
else:
res_explain = np.vstack([res_explain, explain])
for key, value in masks.items():
res_masks[key] = np.vstack([res_masks[key], value])
return res_explain, res_masks
def tabnet_feature_importances(model: TabNetModel, dl: TabDataLoader):
model.eval()
feature_importances_ = np.zeros((model.post_emb))
for batch_nb, data in enumerate(dl):
M_explain, masks = model.forward_masks(data[0], data[1])
feature_importances_ += M_explain.sum(dim=0).cpu().detach().numpy()
feature_importances_ = csc_matrix.dot(feature_importances_,
model.emb_reducer)
return feature_importances_ / np.sum(feature_importances_)
def _compute_feature_importances(self, loader):
self.network.eval()
feature_importances_ = np.zeros((self.network.post_embed_dim))
for data, targets in loader:
data = data.to(self.device).float()
M_explain, masks = self.network.forward_masks(data)
feature_importances_ += M_explain.sum(dim=0).cpu().detach().numpy()
feature_importances_ = csc_matrix.dot(feature_importances_,
self.reducing_matrix)
self.feature_importances_ = feature_importances_ / np.sum(feature_importances_)
def train_epoch(self, train_loader):
"""
Trains one epoch of the network in self.network
Parameters
----------
train_loader: a :class: `torch.utils.data.Dataloader`
DataLoader with train set
"""
self.network.train()
y_preds = []
ys = []
total_loss = 0
feature_importances_ = np.zeros((self.network.post_embed_dim))
for data, targets in train_loader:
batch_outs = self.train_batch(data, targets)
if self.output_dim == 2:
y_preds.append(
torch.nn.Softmax(dim=1)(
batch_outs["y_preds"])[:, 1].cpu().detach().numpy())
else:
values, indices = torch.max(batch_outs["y_preds"], dim=1)
y_preds.append(indices.cpu().detach().numpy())
ys.append(batch_outs["y"].cpu().detach().numpy())
total_loss += batch_outs["loss"]
feature_importances_ += batch_outs['batch_importance']
# Reduce to initial input_dim
feature_importances_ = csc_matrix.dot(feature_importances_,
self.reducing_matrix)
# Normalize feature_importances_
feature_importances_ = feature_importances_ / np.sum(
feature_importances_)
y_preds = np.hstack(y_preds)
ys = np.hstack(ys)
if self.output_dim == 2:
stopping_loss = -roc_auc_score(y_true=ys, y_score=y_preds)
else:
stopping_loss = -accuracy_score(y_true=ys, y_pred=y_preds)
total_loss = total_loss / len(train_loader)
epoch_metrics = {
'loss_avg': total_loss,
'stopping_loss': stopping_loss,
'feature_importances_': feature_importances_
}
if self.scheduler is not None:
self.scheduler.step()
return epoch_metrics
def get_ek(self, psi):
assert isinstance(psi, Wavefunction)
v = self.v
dv = self.grid.dv
nelect = self.system.nelect
psi = psi.get_psi()
# T = psi'*Lap3*psi
T1 = csr_matrix.dot(v, psi)
T2 = csc_matrix.dot(csc_matrix(psi), T1)
T = T2 * nelect * dv
T = T[0]
return T
def stopcriterion(A, A_T, v, u, b, xi, r, s, r_norm, s_norm, p, n, ABSTOL,
RELTOL, rho, k):
pri_evalf = np.array([
np.linalg.norm(csr_matrix.dot(A, v[k + 1])),
np.linalg.norm(u[k + 1]),
np.linalg.norm(b)
])
eps_pri = np.sqrt(p) * ABSTOL + RELTOL * np.amax(pri_evalf)
dual_evalf = rho[k] * csc_matrix.dot(A_T, xi[k + 1])
eps_dual = np.sqrt(n) * ABSTOL + RELTOL * np.linalg.norm(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:
return 'break'
def train_epoch(self, train_loader):
"""
Trains one epoch of the network in self.network
Parameters
----------
train_loader: a :class: `torch.utils.data.Dataloader`
DataLoader with train set
"""
self.network.train()
y_preds = []
ys = []
total_loss = 0
feature_importances_ = np.zeros((self.network.post_embed_dim))
for data, targets in train_loader:
batch_outs = self.train_batch(data, targets)
y_preds.append(
batch_outs["y_preds"].cpu().detach().numpy().flatten())
ys.append(batch_outs["y"].cpu().detach().numpy())
total_loss += batch_outs["loss"]
feature_importances_ += batch_outs['batch_importance']
# Reduce to initial input_dim
feature_importances_ = csc_matrix.dot(feature_importances_,
self.reducing_matrix)
# Normalize feature_importances_
feature_importances_ = feature_importances_ / np.sum(
feature_importances_)
y_preds = np.hstack(y_preds)
ys = np.hstack(ys)
stopping_loss = mean_squared_error(y_true=ys, y_pred=y_preds)
total_loss = total_loss / len(train_loader)
epoch_metrics = {
'loss_avg': total_loss,
'stopping_loss': stopping_loss,
'feature_importances_': feature_importances_
}
if self.scheduler is not None:
self.scheduler.step()
print("Current learning rate: ",
self.optimizer.param_groups[-1]["lr"])
return epoch_metrics
def _compute_feature_importances(self, loader):
"""Compute global feature importance.
Parameters
----------
loader : `torch.utils.data.Dataloader`
Pytorch dataloader.
"""
self.network.eval()
feature_importances_ = np.zeros((self.network.post_embed_dim))
for data, targets in loader:
data = data.to(self.device).float()
M_explain, masks = self.network.forward_masks(data)
feature_importances_ += M_explain.sum(dim=0).cpu().detach().numpy()
feature_importances_ = csc_matrix.dot(
feature_importances_, self.reducing_matrix
)
self.feature_importances_ = feature_importances_ / np.sum(feature_importances_)
def rand_eig_function(A, k):
n = A.shape[1]
Omega = np.random.rand(n, k) # returns n x k matrix
Y = csr_matrix.dot(A, Omega)
q, r = np.linalg.qr(
Y) # Orthogonal-triangular decomposition (QR decomposition)
B = csc_matrix.dot((A.T), q).T # Compute Laplacian
B = B.dot(q)
S, U_ = np.linalg.eig(B)
sortidx = S.argsort()[::-1]
X = U_[:, sortidx][:, 0:k]
U = q.dot(X)
return U, S
def compute_feature_importances(self, X):
"""Compute global feature importance.
Parameters
----------
loader : `torch.utils.data.Dataloader`
Pytorch dataloader.
"""
dataloader = DataLoader(
PredictDataset(X),
batch_size=self.batch_size,
shuffle=False,
)
self.network.eval()
feature_importances_ = np.zeros((self.network.post_embed_dim))
for data in dataloader:
data = data.to(self.device).float()
M_explain, masks = self.network.forward_masks(data)
feature_importances_ += M_explain.sum(dim=0).cpu().detach().numpy()
feature_importances_ = csc_matrix.dot(feature_importances_,
self.reducing_matrix)
feature_importances_ = feature_importances_ / np.sum(
feature_importances_)
return feature_importances_
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
1), np.arange(0, A.shape[1], 1))))
L = D - A # Compute Laplacian
S, V = np.linalg.eig(np.array(L.todense()).squeeze()
) # Compute k smallest eigenvalues and eigenvec. of L
sortidx = S.argsort()
V = V[:, sortidx]
c_idx_un = kmeans.kmeans_python(V[:, 0:k], k) # Partition X by k-means
# [B] Normalized case
# c_idx: Clusters identified using normalized Laplacian version
# Degree Matrix (normalized)
D = np.diag(1 / np.sqrt(sumMat))
L = csc_matrix.dot(csr_matrix.tocsc(A.T), D.T).T # Compute Laplacian
L = L.dot(D)
S, V = np.linalg.eig(L) # Compute k largest eigenvalues and eigenvec. of L
sortidx = S.argsort()[::-1]
X = V[:, sortidx][:, 0:k]
norm2 = np.power(X, 2).sum(axis=1) # Normalize X row-wise
norm2.shape = (norm2.shape[0], 1)
X = X / (np.sqrt(norm2))
c_idx = kmeans.kmeans_python(X, k) # Partition X by k-means
# Clustering algorithm End
## Get node labels
idx2names = {}
for line in open('inverse_teams.txt'):
(index, name) = line.split("\t")
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 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 birgRank(G,
Rtrain,
dH,
alpha=.5,
theta=.5,
mu=.5,
eps=0,
max_iters=0,
nodes=None,
verbose=False):
"""
*Rtrain*: Matrix containing 0s and 1s for annotations.
Rows are nodes, columns are goids
*alpha*: teleportation parameter in Personalized PageRank.
*theta*: (1-theta) percent of Rtrain used in seeding vectors.
*mu*: (1-mu) percent of random walkers diffuse from G via Rtrain to H.
*eps*: use power iteration to approximate the scores, and iterate until x_i - x_i-1 < eps.
Default is 0 which means the solution will be solved directly.
Useful as scipy's solver struggles with these large matrices
*max_iters*: maximum # of iterations to run power iteration.
*nodes*: set of nodes for which to run RWR and get GO term scores.
Only used if eps or max_iters is not 0
*returns*: Xh - m*n matrix of scores for each GO term, protein pair, same size as Rtrain
"""
print("Starting birgRank")
m, n = Rtrain.shape
# make seeding vectors (matrix)
B = vstack([theta * eye(m), (1 - theta) * Rtrain.T]).tocsc()
# column normalize the matrix
B = alg_utils.normalizeGraphEdgeWeights(B, axis=0)
B = (1 - alpha) * B
# make transition matrix
#G = G/2 + G.T/2 # make sure G is symmetric
# final matrix is:
# [G 0]
# [RT H]
P = vstack([
hstack([mu * G, csc_matrix((m, n))]),
hstack([(1 - mu) * Rtrain.T, dH])
]).tocsc()
# try reversing the R connection and see if that makes a difference
#P = vstack([hstack([mu*G, (1-mu)*Rtrain]), hstack([csc_matrix((n,m)), dH])]).tocsc()
# normalize using the same normalization as AptRank
P = alg_utils.normalizeGraphEdgeWeights(P, axis=0) # column normalization
P = alpha * P
# make sure they're in csc format for the solvers
P = P.tocsc()
B = B.tocsc()
start_time = time.process_time()
if eps != 0 or max_iters != 0:
print("\tstarting power iteration over each node individually")
# Version of birgrank using a power iteration. Useful as scipy's solver struggles with these large matrices
# looks like the real problem is the amount of ram needed to store the results in the large matrix X
# rather than power iterate with the entire matrix B, run power iteration for column of B individually
# and then merge only the Xh results
Xh = lil_matrix((m, n))
# much faster to only compute scores for a subset of nodes
if nodes is None:
nodes = list(range(B.shape[1]))
for i in tqdm(nodes):
e = B[:, i].toarray().flatten()
x = e.copy()
prev_x = x.copy()
for iters in range(1, max_iters + 1):
x = csc_matrix.dot(P, prev_x) + e
max_d = (x - prev_x).max()
#if verbose:
# tqdm.write("\t\tmax score change: %0.6f" % (max_d))
if max_d < eps:
break
prev_x = x.copy()
Xh[i] = x[m:]
if verbose:
print(
"\tbirgRank converged after %d iterations. max_d: %0.2e, eps: %0.2e"
% (iters, max_d, eps))
Xh = Xh.T
total_time = time.process_time() - start_time
# this only shows the # of iterations for the last prot
print(
"\tbirgRank converged after %d iterations (%0.2f sec) for node %d"
% (iters, total_time, i))
else:
A = eye(m + n) - P
A = A.tocsc()
# solve PageRank linear system using 3-block solver
print("\tsolving for Xg")
# now solve the linear system X = A/B
# split it up into two equations to solve
# (I-alpha*G)Xg = (1-alpha)I
Xg = spsolve(A[:m, :][:, :m], B[:m, :])
print("\tsolving for Xh")
# alpha*RT*Xg = (I - alpha*H)Xh
Xh = spsolve(A[m:, :][:, m:], (B[m:, :] - A[m:, :][:, :m] * Xg))
total_time = time.process_time() - start_time
print("\tsolved birgRank using sparse linear system (%0.2f sec)" %
(total_time))
# transpose Xh so it has the same dimensions as Rtrain
# prot rows, goid columns
return Xh.T
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 = [
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
psi = ravel(psi)
psi = psi / h**(3. / 2)
n = 2 * psi**2
#exchange
vex = -(3. / pi)**(1. / 3) * n**(1. / 3)
#hartree
#Lap3 Vh = -4*pi*n
#pdb.set_trace()
vh = cgs(Lap3, -4 * pi * (n + ncomp))[0] - vcomp #Poisson solver
vtot = vex + vh + vext
#pdb.set_trace()
T1 = csr_matrix.dot(-0.5 * Lap3, psi)
T2 = csc_matrix.dot(csc_matrix(psi), T1)
T = T2 * 2 * h**3
T = T[0]
Eext = sum(n * vext) * h**3
Eh = 0.5 * sum(n * vh) * h**3
Ex = sum(-(3. / 4) * (3. / pi)**(1. / 3) * n**(4. / 3)) * h**3
Etot = T + Eext + Eh + Ex
ediff = abs(Eprev - Etot)
Eprev = Etot
E = E[0]
#pdb.set_trace()
print 'Helium', Etot, T, Eext, Eh, Ex, ediff
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
